DB2 pureXML Cookbook Master the Power of the IBM Hybrid Data Server Hands-On Solutions and Best Practices for Developing and Managing XML Database Applications with DB2 More and more database developers and DBAs are being asked to develop applications and manage databases that involve XML data. Many are utilizing the highly praised DB2 pureXML technology from IBM. In the DB2 pureXML Cookbook, two leading experts from IBM offer the practical solutions and proven code samples that database professionals need to build better XML solutions faster. Organized by task, this book is packed with more than 700 easy-to-adapt “recipe-style” examples covering the entire application lifecycle–from planning and design through coding, optimization, and troubleshooting. This extraordinary library of recipes includes more than 250 XQuery and SQL/XML queries. With the authors’ hands-on guidance, you’ll learn how to combine pureXML “ingredients” to efficiently perform virtually any XML data management task, from the simplest to the most advanced. Coverage includes pureXML in DB2 9 for z/OS and DB2 9.1, 9.5, and 9.7 for Linux, UNIX, and Windows Best practices for designing XML data, applications, and storage objects Importing, exporting, loading, replicating, and federating XML data Querying XML data, from start to finish: XPath and XQuery data model and languages, SQL/XML, stored procedures, UDFs, and much more Avoiding common errors and inefficient XML queries Converting relational data to XML and vice versa Updating and transforming XML documents Defining and working with XML indexes Monitoring and optimizing the performance of XML queries and other operations Using XML Schemas to constrain and validate XML documents XML application development–including code samples for Java, .NET, C, COBOL,PL/1, PHP, and Perl

Mule in Action covers Mule fundamentals and best practices. It is a comprehensive tutorial that starts with a quick ESB overview and then gets Mule to work. It dives into core concepts like sending, receiving, routing, and transforming data. Next, it gives you a close look at Mule's standard components and how to roll out custom ones. You'll pick up techniques for testing, performance tuning, BPM orchestration, and even a touch of Groovy scripting. About the Technology Mule is a widely used open source enterprise service bus. It is standards based, provides easy integration with Spring and JBoss, and fully supports the enterprise messaging patterns collected by Hohpe and Woolf. You can readily customize Mule without writing a lot of new code. About the Book Mule in Action covers Mule fundamentals and best practices. It is a comprehensive tutorial that starts with a quick ESB overview and then gets Mule to work. It dives into core concepts like sending, receiving, routing, and transforming data. Next, it gives you a close look at Mule's standard components and how to roll out custom ones. You'll pick up techniques for testing, performance tuning, BPM orchestration, and even a touch of Groovy scripting. What's Inside Mule deployment, logging, and monitoring Common transports, routers, and transformers Security, routing, orchestration, and transactions About the Reader Written for developers, architects, and IT managers, the book requires familiarity with Java but no previous exposure to Mule or other ESBs. About the Authors Both authors are Java EE architects. David Dossot is the project "despot" of the JCR Transport and has worked with Mule since 2005. John D'Emic is Chief Integration Architect at OpSource Inc., where he has used Mule since 2006. Quotes A deep, anatomical view of Mule ESB. - Ara Abrahamian, Arachitect, Coauthor of Java Open Source Programming A top-to-bottom example-driven guide I haven't found anywhere else. - Ben Hall, Technical Lead, IBBS Outstanding examples show how to use Mule. - Doug Warren, Software Architect, Java Web Services These guys know what they are talking about! - Fabrice Dewasmes, Java & Open Source Department Director, Pragma Consult Works better than a carrot to get the Mule going. Useful even for experts. - Jeroen Benckhuijsen, Software Architect, Atos Origin

In the classic style of Manning's "In Action" series, NHibernate in Action introduces .NET developers to the NHibernate Object/Relational Mapping tool. As NHibernate is a port of Hibernate from Java to .NET, the book is based on Manning's bestselling Hibernate in Action. NHibernate in Action begins by describing how to implement persistence in a layered .NET application. The book then quickly springs into action by introducing NHibernate through a classic "Hello World" example. It explains how to configure NHibernate to specify the mapping information between business objects and database tables, and then explores the internal architecture of NHibernate. A complete example application is progressively built with Agile methodologies in mind, which shows readers all kinds of entity and relationship mappings and how to perform CRUD operations. The book also covers advanced techniques like caching, concurrency access, and isolation levels. The Hibernate Query Language (HQL) and criteria query APIs are thoroughly detailed with optimization tips. The last chapters of this book discuss various development scenarios, how to implement the layers of an NHibernate application (covering Windows and Web development), and which tools are available for these tasks. They also provide some solutions for data-binding objects to .NET GUI controls, integrating services, and interacting with components using DataSets. Finally, they explain how to build a complex application involving advanced session management and distributed transactions. About the Technology About the Book NHibernate in Action begins by describing how to implement persistence in a layered .NET application. The book then quickly springs into action by introducing NHibernate through a classic "Hello World" example. It explains how to configure NHibernate to specify the mapping information between business objects and database tables, and then explores the internal architecture of NHibernate. A complete example application is progressively built with Agile methodologies in mind, which shows readers all kinds of entity and relationship mappings and how to perform CRUD operations. The book also covers advanced techniques like caching, concurrency access, and isolation levels. The Hibernate Query Language (HQL) and criteria query APIs are thoroughly detailed with optimization tips. The last chapters of this book discuss various development scenarios, how to implement the layers of an NHibernate application (covering Windows and Web development), and which tools are available for these tasks. They also provide some solutions for data-binding objects to .NET GUI controls, integrating services, and interacting with components using DataSets. Finally, they explain how to build a complex application involving advanced session management and distributed transactions. What's Inside Object/Relational Mapping for .NET NHibernate configuration, mapping, and query APIs Development processes for the domain model and data-binding Advanced session management and distributed transactions Using NHibernate in real-world projects About the Reader About the Author Pierre Henri Kuaté is one of the main developers on the NHibernate project team, author of the NHibernate.Mapping.Attributes library, and a major contributor to the NHibernate forum. He's responsible for managing the NHibernate documentation, website, and forum on the Hibernate.org site. He started using NHibernate more than two years ago in commercial development. Tobin Harris has worked with NHibernate since it was in early Beta. His passion is tools and practices that help build quality software at high speeds. As an independent consultant and entrepreneur, Tobin works with companies across the globe in various sectors including banking, personal finance, healthcare, software components and new media. In 2001, Tobin was the founder of the Open Source SqlBuddy project. Subsequently he has worked in partnership with Frost Innovation on Gaia Ajax Widgets, an Open Source Ajax suite for .NET. Tobin obtained his degree in Software Engineering at Leeds Metropolitan University, and continues to work and live in Leeds, UK. Christian Bauer is a member of the Hibernate developer team and a trainer, consultant, and product manager for Hibernate, EJB 3.0, and JBoss Seam at JBoss. He is the lead author of Hibernate in Action and Java Persistence with Hibernate. Gavin King is a lead developer at JBoss, the creator of Hibernate, and a member of the EJB 3.0 (JSR 220) expert group. He also leads the Web Beans JSR 299, a standardization effort involving Hibernate concepts, JSF, and EJB 3.0. Quotes A much needed book for novices and experts. - Mark Monster, Rubicon Finally, a great book covering NHibernate. - Paul Wilson, McKesson A must-have for NHibernate developers. - Ayende Rahien, NHibernate Committer Accelerates your learning curve for ORM in .NET. - Doug Warren, Java Web Services

Hibernate Search in Action is a practical, example-oriented guide for Java developers with some background in Hibernate Core. As the first book to cover Hibernate Search, it guides you through every step to set up full text search functionality in your Java applications. The book also introduces core search techniques and reviews the relevant parts of Lucene, in particular the query capabilities. Hibernate Search in Action also provides a pragmatic, how-to exploration of more advanced topics such as Search clustering. For anyone using Hibernate or JBoss Seam, this book is the definitive guide on how to add or enhance search features in their applications. About the Technology Good search capability is one of the primary demands of a business application. Engines like Lucene provide a great starting point, but with complex applications it can be tricky to implement. It's tough to keep the index up to date, deal with the mismatch between the index structure and the domain model, handle querying conflicts, and so on. Hibernate Search is an enterprise search tool based on Hibernate Core and Apache Lucene. It provides full text search capabilities for Hibernate-based applications without the infrastructural code required by other search engines. With this free, open-source technology, you can quickly add high-powered search features in an intelligent, maintainable way. About the Book What's Inside About the Reader About the Author Emmanuel Bernard: After graduating from Supelec (French "Grande Ecole"), Emmanuel has spent a few years in the retail industry where he started to be involved in the ORM space and in full text technology. He joined the Hibernate team in 2003 and is now a lead developer at JBoss, a division of Red Hat. Emmanuel is the lead developer of Hibernate Annotations and Hibernate EntityManager, two key projects on top of Hibernate core implementing the Java Persistence(tm) specification. He has also lead the Hibernate Search project from its inception, reconsiling the two fields Emmanuel has been involved in: ORM and Full Text search. He is a regular speaker at various conferences and JUGs, including JavaOne, JBoss World and Javapolis (Javoxx). He is also involved in the Java Community Process as a specification lead for JSR 303 (Bean Validation) and as a expert group member for JSR 317 (Java Persistence 2.0). John Griffin has been in the software and computer industry in one form or another since 1969. He remembers writing his first FORTRAN IV program on his way back from Woodstock. Currently, he is the software engineer/architect for SOS Staffing Services, Inc. He was formerly the lead e-commerce architect for Iomega Corporation, lead SOA architect for Realm Systems and an independent consultant for the Dept of the Interior among many other callings. John has even spent time as an adjunct university professor. He enjoys being a committer to projects because he believes it's time to get involved and give back to the community. John is the author of XML and SQL Server 2000 published by New Riders Press. He is a member of the ACM. Currently, he resides in Layton, Utah with wife, Judy and Australian Shepherds, Clancy and Molly. Quotes A great resource for true database independent full text search. - Aaron Walker, base2Services It has completely changed the way I do complex search. Awesome! - Ayenda Rahien, Author of Building Domain Specific Languages in Boo Love its vast coverage--the definitive source. - Patrick Dennis, Management Dynamics Incs. Covers it all...the only source I need. - Robert Hanson, Author of GWT in Action A superb discussion of a complex topic. - Spencer Stejskal, SOS Staffing Services

The Definitive Guide to Oracle Database 11 g Get full details on the powerful features of Oracle Database 11 g from this thoroughly updated Oracle Press guide. Oracle Database 11g: The Complete Reference explains how to use all the new features and tools, execute powerful SQL queries, construct PL/SQL and SQLPlus statements, and work with large objects and object-relational databases. Learn how to implement the latest security measures, tune database performance, and deploy grid computing techniques. An invaluable cross-referenced appendix containing Oracle commands, keywords, features, and functions is also included. Install Oracle Database 11 g or upgrade from an earlier version Create database tables, sequences, indexes, views, and user accounts Construct SQL statements, procedures, queries, and subqueries Optimize security using virtual private databases and transparent data encryption Import and export data using SQLLoader and Oracle Data Pump Use SQL replay, change management, and result caching Avoid human errors using flashback and automatic undo management Build and tune PL/SQL triggers, functions, and packages Develop database applications using Java, JDBC, and XML Optimize availability and scalability with Oracle Real Application Clusters

CRYSTAL REPORTS® 2008 OFFICIAL GUIDE Whether you’re a DBA, data warehousing or business intelligence professional, Every significant enhancement introduced in Crystal Reports 2008 is covered, including its new visualization options and more robust Web services capabilities. The book concludes by showing how to use Crystal Reports’ powerful .NET and Java SDKs to customize and extend enterprise reporting in virtually unlimited ways. • Learn hands-on, through step-by-step examples and exercises–and discover tips and tricks proven in real-world enterprise environments • Master new Crystal Reports 2008 features, including interactive report viewing, Xcelsius dashboarding, Flex, and Flash integration, Report Designer improvements, report bursting, and more • Publish professional-quality reports against virtually any data source, including relational and OLAP databases, Universes, SAP, PeopleSoft, JavaBeans, .NET/COM objects, XML, and more • Discover advanced visualization techniques using Xcelsius, charts, and maps • Learn methods for distributing reports and integrating content into other applications • Learn about the latest reporting addition to the Business Objects family–Xcelsius and begin creating dynamic and interactive dashboards NEIL FITZGERALD has spent several years working at Business Objects and with one of Business Objects’ largest providers of custom BI and enterprise reporting solutions. BOB COATES currently works as a Sales Consultant for Business Objects, an SAP company, where he has been employed for more than eleven years. RYAN GOODMAN is the founder of Centigon Solutions, Inc., and remains one of the top Xcelsius experts and evangelists in the world. MICHAEL VOLOSHKO is a senior presales consultant for the financial services team at Business Objects. ON THE WEB Find all this and more at informit.com/sams: • Java and .NET sample reports and code samples for all examples in the book • Bonus chapters, tips, tricks, and links to great reporting resources CATEGORY: Database COVERS: Crystal Reports 2008, Crystal Reports Server 2008, Crystal Reports Viewer, crystalreports.com, Xcelsius 2008 USER LEVEL: Beginning–Intermediate informit.com/sams

Choice is usually a good thing for consumers but it can be difficult to navigate the landscape of Open Source ESBs. I believe this book is extremely valuable for readers looking to choose an ESB and looking to get a stronger grasp on how to implement an ESB using open source projects. I found the case studies in section III particularly useful since they pull together many of the concepts learned throughout the book. This book guides the reader through a logical journey of discovery and demonstration to deliver a solid understanding of the core ESB concepts and how they can be used in the real world. Armed with this book and the wealth of open source projects available I think the reader will be ready to take on any ESB project. Open Source made ESBs a lot more fun, go and enjoy yourself! —From the Foreword by Ross Mason, Creator of the Mule Project Open-Source ESBs in Action describes how to use ESBs in real-world situations. You will learn how the various features of an ESB such as transformation, routing, security, connectivity, and more can be implemented on the example of two open-source ESB implementations: Mule and ServiceMix. The authors first introduce ServiceMix and Mule, and then present general principles and patterns of ESB use, as well as a structured approach to solving common integration problems, through examples using them. About the Technology The need for enterprise integration is widespread for the simple reason that businesses require independent applications to exchange information with each other. A CRM application must know about the order history of a customer, but that history is stored in the sales application. A technology that companies increasingly use to integrate enterprise applications is the Enterprise Service Bus (ESB). About the Book Working in integration projects is exciting, with new technologies and paradigms arriving every day. In this area, open source is playing a more and more dominant role with projects such as Mule and ServiceMix. Open-Source ESBs in Action will help you to learn open-source integration technologies quickly and will provide you with knowledge that you can use to effectively work with Mule and ServiceMix. What's Inside Numerous code examples Detailed explanation on how to use Mule and ServiceMix Practical, real-world examples and case studies Integration with a full open source tool stack About the Reader About the Authors Tijs Rademakers is a software architect with more than six years of experience in designing and developing Java and EE applications. He works for Atos Origin, a large European system integrator, where he is responsible for SOA and BPM services and knowledge development. Tijs has designed and implemented large process- and application-integration solutions, primarily focused on open standards. He has extensive product knowledge of open source as well as closed source SOA and enterprise integration tools, including Mule, ServiceMix, jBPM, and WebSphere Process Server. Tijs is a regular speaker at Java conferences, where he talks about open source integration topics like Mule and ServiceMix. Tijs lives in the Netherlands near Eindhoven with his girlfriend and his new daughter, Liv. Jos Dirksen has been working with Java and J2EE applications for more than six years as a software architect. The last couple of years, his focus topics have been open source, security, and quality. He has worked with various open source and commercial integration solutions, mostly in the government and the healthcare areas. Jos has a lot of project experience working with Mule, Apache Synapse, and Apache Axis2 and has also completed projects based on the integration tooling from IBM. Jos regularly gives presentation on open source, Mule, and other related topics. He lives in Eindhoven, the Netherlands, with his wife. Quotes A great book for any ESB practitioner. - Rick Wagner, Acxiom Corporation A must-have ESB resource! - Craig Borysowich, Imagination Edge, Inc. The most comprehensive content that I've seen on open source ESBs. - Rodney Biresch, Chariot Solutions The Bible for integration architects. - Davide Piazza, Omnys s.r.l. ...ample code samples and excellent descriptions. - Jeff Davis, HireRight, Inc. This book will take you to a new level. - Christian Siegers, Stater International Mortgage Services

Get the definitive guide on all the fundamentals of Terracotta as well as user secrets, recipes, and prepackaged frameworks. Written by Terracotta's chief technology officer Ari Zilka and his team, The Definitive Guide to Terracotta: Cluster the JVM for Spring, Hibernate and POJO Scalability covers the following: High Availability (HA) nth degree scaling and clustering for traditional J2EE and Java EE 5 applications (using Seam or other application) as well as Spring-based enterprise applications Everyday Terracotta using its prepackaged frameworks and integration recipes, including configuration and customization for your application tuning, no matter the scale Power user secrets available, including config modules, customized advanced performance tuning, SDLC, Maven, and more

This book is primarily a practical reference book for professional XSLT developers. It assumes no previous knowledge of the language, and many developers have used it as their first introduction to XSLT; however, it is not structured as a tutorial, and there are other books on XSLT that provide a gentler approach for beginners. The book does assume a basic knowledge of XML, HTML, and the architecture of the Web, and it is written for experienced programmers. There's no assumption that you know any particular language such as Java or Visual Basic, just that you recognize the concepts that all programming languages have in common. The book is suitable both for XSLT 1.0 users upgrading to XSLT 2.0, and for newcomers to XSLT. The book is also equally suitable whether you work in the Java or .NET world. As befits a reference book, a key aim is that the coverage should be comprehensive and authoritative. It is designed to give you all the details, not just an overview of the 20 percent of the language that most people use 80 percent of the time. It's designed so that you will keep coming back to the book whenever you encounter new and challenging programming tasks, not as a book that you skim quickly and then leave on the shelf. If you like detail, you will enjoy this book; if not, you probably won't. But as well as giving the detail, this book aims to explain the concepts, in some depth. It's therefore a book for people who not only want to use the language but who also want to understand it at a deep level. The book aims to tell you everything you need to know about the XSLT 2.0 language. It gives equal weight to the things that are new in XSLT 2.0 and the things that were already present in version 1.0. The book is about the language, not about specific products. However, there are appendices about Saxon (the author's own implementation of XSLT 2.0), about the Altova XSLT 2.0 implementation, and about the Java and Microsoft APIs for controlling XSLT transformations, which will no doubt be upgraded to handle XSLT 2.0 as well as 1.0. A third XSLT 2.0 processor, Gestalt, was released shortly before the book went to press, too late to describe it in any detail. But the experience of XSLT 1.0 is that there has been a very high level of interoperability between different XSLT processors, and if you can use one of them, then you can use them all. In the previous edition we split XSLT 2.0 and XPath 2.0 into separate volumes. The idea was that some readers might be interested in XPath alone. However, many bought the XSLT 2.0 book without its XPath companion and were left confused as a result; so this time, the material is back together. The XPath reference information is in self-contained chapters, so it should still be accessible when you use XPath in contexts other than XSLT. The book does not cover XSL Formatting Objects, a big subject in its own right. Nor does it cover XML Schemas in any detail. If you want to use these important technologies in conjunction with XSLT, there are other books that do them justice. This book contains twenty chapters and eight appendixes (the last of which is a glossary) organized into four parts. The following section outlines what you can find in each part, chapter, and appendix. Part I: Foundations: The first part of the book covers essential concepts. You should read these before you start coding. If you ignore this advice, as most people do, then you read them when you get to that trough of despair when you find it impossible to make the language do anything but the most trivial tasks. XSLT is different from other languages, and to make it work for you, you need to understand how it was designed to be used. Chapter 1: XSLT in Context: This chapter explains how XSLT fits into the big picture: how the language came into being and how it sits alongside other technologies. It also has a few simple coding examples to keep you alert. Chapter 2: The XSLT Processing Model: This is about the architecture of an XSLT processor: the inputs, the outputs, and the data model. Understanding the data model is perhaps the most important thing that distinguishes an XSLT expert from an amateur; it may seem like information that you can't use immediately, but it's knowledge that will stop you making a lot of stupid mistakes. Chapter 3: Stylesheet Structure: XSLT development is about writing stylesheets, and this chapter takes a bird's eye view of what stylesheets look like. It explains the key concepts of rule-based programming using templates, and explains how to undertake programming-in-the-large by structuring your application using modules and pipelines. Chapter 4: Stylesheets and Schemas: A key innovation in XSLT 2.0 is that stylesheets can take advantage of knowledge about the structure of your input and output documents, provided in the form of an XML Schema. This chapter provides a quick overview of XML Schema to describe its impact on XSLT development. Not everyone uses schemas, and you can skip this chapter if you fall into that category. Chapter 5: The Type System: XPath 2.0 and XSLT 2.0 offer strong typing as an alternative to the weak typing approach of the 1.0 languages. This means that you can declare the types of your variables, functions, and parameters, and use this information to get early warning of programming errors. This chapter explains the data types available and the mechanisms for creating user-defined types. Part II: XSLT and XPath Reference: This section of the book contains reference material, organized in the hope that you can easily find what you need when you need it. It's not designed for sequential reading, though you might well want to leaf through the pages to discover what's there. Chapter 6: XSLT Elements: This monster chapter lists all the XSLT elements you can use in a stylesheet, in alphabetical order, giving detailed rules for the syntax and semantics of each element, advice on usage, and examples. This is probably the part of the book you will use most frequently as you become an expert XSLT user. It's a "no stone unturned" approach, based on the belief that as a professional developer you need to know what happens when the going gets tough, not just when the wind is in your direction. Chapter 7: XPath Fundamentals: This chapter explains the basics of XPath: the low-level constructs such as literals, variables, and function calls. It also explains the context rules, which describe how the evaluation of XPath expressions depends on the XSLT processing context in which they appear. Chapter 8: XPath: Operators on Items: XPath offers the usual range of operators for performing arithmetic, boolean comparison, and the like. However, these don't always behave exactly as you would expect, so it's worth reading this chapter to see what's available and how it differs from the last language that you used. Chapter 9: XPath: Path Expressions: Path expressions are what make XPath special; they enable you to navigate around the structure of an XML document. This chapter explains the syntax of path expressions, the 13 axes that you can use to locate the nodes that you need, and associated operators such as union, intersection, and difference. Chapter 10: XPath: Sequence Expressions: Unlike XPath 1.0, in version 2.0 all values are sequences (singletons are just a special case). Some of the most important operators in XPath 2.0 are those that manipulate sequences, notably the "for" expression, which translates one sequence into another by applying a mapping. Chapter 11: XPath: Type Expressions: The type system was explained in Chapter 5; this chapter explains the operations that you can use to take advantage of types. This includes the "cast" operation which is used to convert values from one type to another.A big part of this chapter is devoted to the detailed rules for how these conversions are done. Chapter 12: XSLT Patterns: This chapter returns from XPath to a subject that's specific to XSLT. Patterns are used to define template rules, the essence of XSLT's rule-based programming approach. The reason for explaining them now is that the syntax and semantics of patterns depends strongly on the corresponding rules for XPath expressions. Chapter 13: The Function Library: XPath 2.0 includes a library of functions that can be called from any XPath expression; XSLT 2.0 extends this with some additional functions that are available only when XPath is used within XSLT. The library has grown immensely since XPath 1.0. This chapter provides a single alphabetical reference for all these functions. Chapter 14: Regular Expressions: Processing of text is an area where XSLT 2.0 and XPath 2.0 are much more powerful than version 1.0, and this is largely through the use of constructs that exploit regular expressions. If you're familiar with regexes from languages such as Perl, this chapter tells you how XPath regular expressions differ. If you're new to the subject, it explains it from first principles. Chapter 15: Serialization: Serialization in XSLT means the ability to generate a textual XML document from the tree structure that's manipulated by a stylesheet. This isn't part of XSLT processing proper, so (following W3C's lead) it's separated it into its own chapter. You can control serialization from the stylesheet using an declaration, but many products also allow you to control it directly via an API. Part III: Exploitation: The final section of the book is advice and guidance on how to take advantage of XSLT to write real applications. It's intended to make you not just a competent XSLT coder, but a competent designer too. The best way of learning is by studying the work of others, so the emphasis here is on practical case studies. Chapter 16: Extensibility: This chapter describes the "hooks" provided in the XSLT specification to allow vendors and users to plug in extra functionality. The way this works will vary from one implementation to another, so we can't cover all possibilities, but one important aspect that the chapter does cover is how to use such extensions and still keep your code portable. Chapter 17: Stylesheet Design Patterns: This chapter explores a number of design and coding patterns for XSLT programming, starting with the simplest "fill-in-the-blanks" stylesheet, and extending to the full use of recursive programming in the functional programming style, which is needed to tackle problems of any computational complexity. This provides an opportunity to explain the thinking behind functional programming and the change in mindset needed to take full advantage of this style of development. Chapter 18: Case Study: XMLSpec: XSLT is often used for rendering documents, so where better to look for a case study than the stylesheets used by the W3C to render the XML and XSLT specifications, and others in the same family, for display on the web? The resulting stylesheets are typical of those you will find in any publishing organization that uses XML to develop a series of documents with a compatible look-and-feel. Chapter 19: Case Study: A Family Tree: Displaying a family tree is another typical XSLT application. This example with semi-structured data—a mixture of fairly complex data and narrative text—that can be presented in many different ways for different audiences. It also shows how to tackle another typical XSLT problem, conversion of the data into XML from a legacy text-based format. As it happens, this uses nearly all the important new XSLT 2.0 features in one short stylesheet. But another aim of this chapter is to show a collection of stylesheets doing different jobs as part of a complete application. Chapter 20: Case Study: Knight's Tour: Finding a route around a chessboard where a knight visits every square without ever retracing its steps might sound a fairly esoteric application for XSLT, but it's a good way of showing how even the most complex of algorithms are within the capabilities of the language. You may not need to tackle this particular problem, but if you want to construct an SVG diagram showing progress against your project plan, then the problems won't be that dissimilar. Part IV: Appendices: Appendix A: XPath 2.0 Syntax Summary: Collects the XPath grammar rules and operator precedences into one place for ease of reference. Appendix B: Error Codes: A list of all the error codes defined in the XSLT and XPath language specifications, with brief explanations to help you understand what's gone wrong. Appendix C: Backward Compatibility: The list of things you need to look out for when converting applications from XSLT 1.0. Appendix D: Microsoft XSLT Processors: Although the two Microsoft XSLT processors don't yet support XSLT 2.0, we thought many readers would find it useful to have a quick summary here of the main objects and methods used in their APIs. Appendix E: JAXP: the Java API for XML Processing: JAXP is an interface rather than a product. Again, it doesn't have explicit support yet for XSLT 2.0, but Java programmers will often be using it in XSLT 2.0 projects, so the book includes an overview of the classes and methods available. Appendix F: Saxon: At the time of writing Saxon (developed by the author of this book) provides the most comprehensive implementation of XSLT 2.0 and XPath 2.0, so its interfaces and extensions are covered in some detail. Appendix G: Altova: Altova, the developers of XML Spy, have an XSLT 2.0 processor that can be used either as part of the development environment or as a freestanding component. This appendix gives details of its interfaces. Appendix H: Glossary Note: CD-ROM/DVD and other supplementary materials are not included as part of eBook file.

Harnessing Hibernate is an ideal introduction to the popular framework that lets Java developers work with information from a relational database easily and efficiently. Databases are a very different world than Java objects, and they often involve people with different skills and specializations. With Hibernate, bridging these two worlds is significantly easier, and with this book, you can get up to speed with Hibernate quickly. Rather than present you with another reference, Harnessing Hibernate lets you explore the system, from download and configuration through a series of projects that demonstrate how to accomplish a variety of practical goals. The new edition of this concise guide walks you through Hibernate's primary features, which include mapping from Java classes to database tables, and from Java data types to SQL data types. You will also learn about Hibernate's data query and retrieval facilities, and much more. By reading and following along with the examples, you can get your own Hibernate environment set up quickly and start using it for real-world tasks right away. Harnessing Hibernate teaches you how to: Perform Object/Relational mapping Work with persistent data from Java code Work with groups and relationships between objects Extend Hibernate's rich type support for your own needs Simplify query creation using criteria and examples Use the Hibernate Query Language (HQL) and understand how it differs from SQL Use Hibernate in conjunction with Spring Use Hibernate in conjunction with other packages, such as the Stripes web framework and the Eclipse IDE Once you're past the first few chapters, you can jump to topics that you find particularly interesting or relevant. All background material and explanations of how Hibernate works and why is in the service of a focused task. Source code can be downloaded from the book's website. If using SQL is an uncomfortable chore, Harnessing Hibernate offers you an effective and trouble-free method for working with the information you store in your applications.

Design Feature-Rich PL/SQL Applications Deliver dynamic, client/server PL/SQL applications with expert guidance from an Oracle programming professional. With full coverage of the latest features and tools, Oracle Database 11g PL/SQL Programming lays out each topic alongside detailed explanations, cut-and-paste syntax examples, and real-world case studies. Access and modify database information, construct powerful PL/SQL statements, execute effective queries, and deploy bulletproof security. You'll also learn how to implement C, C++, and Java procedures, Web-enable your database, cut development time, and optimize performance. Create, debug, and manage Oracle-driven PL/SQL programs Use PL/SQL structures, delimiters, operators, variables, and statements Identify and eliminate errors using PLSQL_WARNINGS and exception handlers Work with functions, procedures, packages, collections, and triggers Define and deploy varray, nested table, and associative array data types Handle external routines, object types, large objects, and secure files Communicate between parallel sessions using DBMS_ALERT and DBMS_PIPE Call external procedures through Oracle Net Services and PL/SQL wrappers Integrate internal and server-side Java class libraries using Oracle JVM Develop robust Web applications using PL/SQL Gateway and Web Toolkit

Write powerful SQL statements and PL/SQL programs Learn to access Oracle databases through SQL statements and construct PL/SQL programs with guidance from Oracle expert, Jason Price. Published by Oracle Press, Oracle Database 11g SQL explains how to retrieve and modify database information, use SQL Plus and SQL Developer, work with database objects, write PL/SQL programs, and much more. Inside, you'll find in-depth coverage of the very latest SQL features and tools, performance optimization techniques, advanced queries, Java support, and XML. This book contains everything you need to master SQL. Explore SQL Plus and SQL Developer Use SQL SELECT, INSERT, UPDATE, and DELETE statements Write PL/SQL programs Create tables, sequences, indexes, views, and triggers Write advanced queries containing complex analytical functions Create database objects and collections to handle abstract data Use large objects to handle multimedia files containing music and movies Write Java programs to access an Oracle Database using JDBC Tune your SQL statements to make them execute faster Explore the XML capabilities of the Oracle Database Master the very latest Oracle Database 11 g features, such as PIVOT and UNPIVOT, flashback archives, and much more

The fourth edition of this popular pocket guide provides quick-reference information that will help you use Oracle's PL/SQL language, including the newest Oracle Database 11g features. It's a companion to Steven Feuerstein and Bill Pribyl's bestselling Oracle PL/SQL Programming. This concise guide boils down the most vital PL/SQL information into an accessible summary of: The new edition describes such Oracle Database 11g elements as PL/SQL's function result cache, compound triggers, the CONTINUE statement, the SIMPLE_INTEGER datatype, and improvements to native compilation, regular expressions, and compiler optimization (including intra-unit inlining). In addition, this book now includes substantial new sections on Oracle's built-in functions and packages. Fundamental language elements (e.g., block structure, datatypes, declarations) Statements for program control, cursor management, and exception handling Records, procedures, functions, triggers, and packages Calling PL/SQL functions in SQL Compilation options, object-oriented features, collections, and Java integration When you need answers quickly, the Oracle PL/SQL Language Pocket Reference will save you hours of frustration.

Service-oriented architecture (SOA) is one of the most important topics on the agenda of any IT person. SOA involves a new vision of how to design, develop, and manage applications. It also has new requirements when building an architecture for the underlying infrastructure. This IBM Redbooks publication is the result of a project managed in the IBM European Design Center, based in Montpellier, France. The scope of the project involved helping a major worldwide customer in the automotive industry to validate and justify an SOA implementation. In particular, the customer wanted to add new business values to work with its partners, by adding new data models. It also wanted to modernize an infrastructure, by adding new Internet interfaces. The customer faced the need to eradicate an obsolete programming language. Furthermore, it wanted to build a smooth migration path, with as few risks and costs as possible. The thought, planning, and architecture of the new system, which included integration of the SOA concepts, was built by the customer with the participation of Atos Origin, a leading international IT services provider. The existing customer IT infrastructure was already built around UNIX systems, IBM System z, non-IBM clusters, SAP solutions, 3270 screens, IMS-DL/I databases, and specific code. SOA was the right solution to connect this existing environment to new components using Java, Web services, and DB2 in particular. This book explores the business needs and the architectural choices that were faced by the customer. It describes the mock-ups and prototypes, provides performance numbers that were used to validate the decisions, and explains how they were implemented. It also suggests a generic and riskless solution to eradicate the obsolete programming language.

There is a strong shift in the industry toward reuse of the existing software and hardware resources within the companies to minimize the IT cost. Instead of creating or buying a new solutions, companies are trying to build a set of reusable software components based on the existing applications. These components can be quickly assembled in many different ways to satisfy the business needs of the companies. This environment is based on service-oriented architecture (SOA) and solutions that support business process automation. This book provides the detailed information about multiple ways for building SOA-based solutions around the System i platform. The discussion in the book covers the server and client side implementations that include: - ProgramCall in IBM Toolbox for Java Parts of the book are appropriate for CIOs, system architects, and application developers.

When the first edition of this book was written, XML was a relatively new language but already gaining ground fast and becoming more and more widely used in a vast range of applications. By the time of the second edition, XML had already proven itself to be more than a passing fad, and was in fact being used throughout the industry for an incredibly wide range of uses. With the third edition, it was clear that XML was a mature technology, but more important, it became evident that the XML landscape was dividing into several areas of expertise. Now in this edition, we needed to categorize the increasing number of specifications surrounding XML, which either use XML or provide functionality in addition to the XML core specification. So what is XML? It's a markup language, used to describe the structure of data in meaningful ways. Anywhere that data is input/output, stored, or transmitted from one place to another, is a potential fit for XML's capabilities. Perhaps the most well-known applications are web-related (especially with the latest developments in handheld web access—for which some of the technology is XML-based). However, there are many other non-web-based applications for which XML is useful—for example, as a replacement for (or to complement) traditional databases, or for the transfer of financial information between businesses. News organizations, along with individuals, have also been using XML to distribute syndicated news stories and blog entries. This book aims to teach you all you need to know about XML—what it is, how it works, what technologies surround it, and how it can best be used in a variety of situations, from simple data transfer to using XML in your web pages. It answers the fundamental questions: What is XML? How do you use XML? How does it work? * What can you use it for, anyway? This book is for people who know that it would be a pretty good idea to learn XML but aren't 100 percent sure why. You've heard the hype but haven't seen enough substance to figure out what XML is and what it can do. You may be using development tools that try to hide the XML behind user interfaces and scripts, but you want to know what is really happening behind the scenes. You may already be somehow involved in web development and probably even know the basics of HTML, although neither of these qualifications is absolutely necessary for this book. What you don't need is knowledge of markup languages in general. This book assumes that you're new to the concept of markup languages, and we have structured it in a way that should make sense to the beginner and yet quickly bring you to XML expert status. The word "Beginning" in the title refers to the style of the book, rather than the reader's experience level. There are two types of beginner for whom this book is ideal: Programmers who are already familiar with some web programming or data exchange techniques. Programmers in this category will already understand some of the concepts discussed here, but you will learn how you can incorporate XML technologies to enhance those solutions you currently develop. Those working in a programming environment but with no substantial knowledge or experience of web development or data exchange applications. In addition to learning how XML technologies can be applied to such applications, you will be introduced to some new concepts to help you understand how such systems work. The subjects covered in this book are arranged to take you from novice to expert in as logical a manner as we could. This Fourth Edition is structured in sections based on various areas of XML expertise. Unless you are already using XML, you should start by reading the introduction to XML in Part I. From there, you can quickly jump into specific areas of expertise, or, if you prefer, you can read through the book in order. Keep in mind that there is quite a lot of overlap in XML, and that some of the sections make use of techniques described elsewhere in the book. The book begins by explaining what exactly XML is and why the industry felt that a language like this was needed. After covering the why, the next logical step is the how, so it shows you how to create well-formed XML. Once you understand the whys and hows of XML, you'll go on to some more advanced things you can do when creating your XML documents, to make them not only well formed, but valid. (And you'll learn what "valid" really means.) After you're comfortable with XML and have seen it in action, the book unleashes the programmer within and looks at an XML-based programming language that you can use to transform XML documents from one format to another. Eventually, you will need to store and retrieve XML information from databases. At this point, you will learn not only the state of the art for XML and databases, but also how to query XML information using an SQL-like syntax called XQuery. XML wouldn't really be useful unless you could write programs to read the data in XML documents and create new XML documents, so we'll get back to programming and look at a couple of ways that you can do that. Understanding how to program and use XML within your own business is one thing, but sending that information to a business partner or publishing it to the Internet is another. You'll learn about technologies that use XML that enable you to send messages across the Internet, publish information, and discover services that provide information. Since you have all of this data in XML format, it would be great if you could easily display it to people, and it turns out you can. You'll see an XML version of HTML called XHTML. You'll also look at a technology you may already be using in conjunction with HTML documents called CSS. CSS enables you to add visual styles to your XML documents. In addition, you'll learn how to design stunning graphics and make interactive forms using XML. Finally, the book ends with a case study, which should help to give you ideas about how XML can be used in real-life situations, and which could be used in your own applications. This book builds on the strengths of the earlier editions, and provides new material to reflect the changes in the XML landscape—notably XQuery, RSS and Atom, and AJAX. Updates have been made to reflect the most recent versions of specifications and best practices throughout the book. In addition to the many changes, each chapter has a set of exercise questions to test your understanding of the material. Possible solutions to these questions appear in Appendix A. Part I: Introduction: The introduction is where most readers should begin. The first three chapters introduce some of the goals of XML as well as the specific rules for constructing XML. Once you have read this part you should be able to read and create your own XML documents. Chapter 1: What Is XML?: This chapter cover some basic concepts, introducing the fact that XML is a markup language (a bit like HTML) whereby you can define your own elements, tags, and attributes (known as a vocabulary). You'll see that tags have no presentation meaning—they're just a way to describe the structure of the data. Chapter 2: Well-Formed XML: In addition to explaining what well-formed XML is, we offer a look at the rules that exist (the XML 1.0 and 1.1 Recommendations) for naming and structuring elements—you need to comply with these rules in order to produce well-formed XML. Chapter 3: XML Namespaces: Because tags can be made up, you need to avoid name conflicts when sharing documents. Namespaces provide a way to uniquely identify a group of tags, using a URI. This chapter explains how to use namespaces. Part II: Validation: In addition to the well-formedness rules you learn in Part I, you will most likely want to learn how to create and use different XML vocabularies. This Part introduces you to DTDs, XML Schemas, and RELAX NG: three languages that define custom XML vocabularies. It also shows you how to utilize these definitions to validate your XML documents. Chapter 4: Document Type Definitions: You can specify how an XML document should be structured, and even provide default values, using Document Type Definitions (DTDs). If XML conforms to the associated DTD, it is known as valid XML. This chapter covers the basics of using DTDs. Chapter 5: XML Schemas: XML Schemas, like DTDs, enable you to define how a document should be structured. In addition to defining document structure, they enable you to specify the individual datatypes of attribute values and element content. They are a more powerful alternative to DTDs. Chapter 6: RELAX NG: RELAX NG is a third technology used to define the structure of documents. In addition to a new syntax and new features, it takes the best from XML Schemas and DTDs, and is therefore very simple and very powerful. RELAX NG has two syntaxes; both the full syntax and compact syntax are discussed. Part III: Processing: In addition to defining and creating XML documents, you need to know how to work with documents to extract information and convert it to other formats. In fact, easily extracting information and converting it to other formats is what makes XML so powerful. Chapter 7: XPath: The XPath language is used to locate sections and data in the XML document, and it's important in many other XML technologies. Chapter 8: XSLT: XML can be transformed into other XML documents, HTML, and other formats using XSLT stylesheets, which are introduced in this chapter. Part IV: Databases: Creating and processing XML documents is good, but eventually you will want to store those documents. This section describes strategies for storing and retrieving XML documents and document fragments from different databases. Chapter 9: XQuery, the XML Query Language: Very often, you will need to retrieve information from within a database. XQuery, which is built on XPath and XPath2, enables you to do this in an elegant way. Chapter 10: XML and Databases: XML is perfect for structuring data, and some traditional databases are beginning to offer support for XML. This chapter discusses these, and provides a general overview of how XML can be used in an n-tier architecture. In addition, new databases based on XML are introduced. Part V: Programming: At some point in your XML career, you will need to work with an XML document from within a custom application. The two most popular methodologies, the Document Object Model (DOM) and the Simple API for XML (SAX), are explained in this part. Chapter 11: The Document Object Model (DOM): Programmers can use a variety of programming languages to manipulate XML using the Document Object Model's objects, interfaces, methods, and properties, which are described in this chapter. Chapter 12: Simple API for XML (SAX): An alternative to the DOM for programmatically manipulating XML data is to use the Simple API for XML (SAX) as an interface. This chapter shows how to use SAX and utilizes examples from the Java SAX API. Part VI: Communication: Sending and receiving data from one computer to another is often difficult, but several technologies have been created to make communication with XML much easier. This part discusses RSS and content syndication, as well as web services and SOAP. This edition includes a new chapter on Ajax techniques. Chapter 13: RSS, Atom, and Content Syndication: RSS is an actively evolving technology that is used to publish syndicated news stories and website summaries on the Internet. This chapter not only discusses how to use the different versions of RSS and Atom, it also covers the future direction of the technology. In addition, it demonstrates how to create a simple newsreader application that works with any of the currently published versions. Chapter 14: Web Services: Web services enable you to perform cross-computer communications. This chapter describes web services and introduces you to using remote procedure calls in XML (using XML-RPC and REST), as well as giving you a brief look at major topics such as SOAP. Finally, it breaks down the assortment of specifications designed to work in conjunction with web services. Chapter 15: SOAP and WSDL: Fundamental to XML web services, the Simple Object Access Protocol (SOAP) is one of the most popular specifications for allowing cross-computer communications. Using SOAP, you can package up XML documents and send them across the Internet to be processed. This chapter explains SOAP and the Web Services Description Language (WSDL) that is used to publish your service. Chapter 16: Ajax: Ajax enables you to utilize JavaScript with web services and SOAP, or REST communications. Additionally, Ajax patterns can be used within web pages to communicate with the web server without refreshing. This chapter is new to the Fourth Edition. Part VII: Display: Several XML technologies are devoted to displaying the data stored inside of an XML document. Some of these technologies are web-based, and some are designed for applications and mobile devices. This part discusses the primary display strategies and formats used today. Chapter 17: Cascading Style Sheets (CSS): Website designers have long been using Cascading Style Sheets (CSS) with their HTML to easily make changes to a website's presentation without having to touch the underlying HTML documents. This power is also available for XML, enabling you to display XML documents right in the browser. Or, if you need a bit more flexibility with your presentation, you can use XSLT to transform your XML to HTML or XHTML and then use CSS to style these documents. Chapter 18: XHTML: XHTML is a new version of HTML that follows the rules of XML. This chapter discusses the differences between HTML and XHTML, and shows you how XHTML can help make your sites available to a wider variety of browsers, from legacy browsers to the latest browsers on mobile phones. Chapter 19: Scalable Vector Graphics (SVG): Do you want to produce a custom graphic using XML? SVG enables you to describe a graphic using XML-based vector commands. This chapter teaches you the basics of SVG and then dives into a more complex SVG-based application that can be published to the Internet. Chapter 20: XForms: XForms are XML-based forms that can be used to design desktop applications, paper-based forms, and of course XHTML-based forms. This chapter demonstrates both the basics and some of the more interesting uses of XForms. Part VIII: Case Study: Throughout the book you'll gain an understanding of how XML is used in web, business-to-business (B2B), data storage, and many other applications. The case study covers an example application and shows how the theory can be put into practice in real-life situations. The case study is new to this edition. Chapter 21: Case Study: Payment Calculator: This case study explores some of the possibilities and strategies for using XML in your website. It includes an example that demonstrates a loan payment calculator by creating a web page using XHTML and CSS, communicating with a local web service using AJAX, utilizing an XML Schema to build data structures in .NET, and ultimately using the Document Object Model to display the results in SVG. An online version of this case study on the book's website covers the same material using Ruby on Rails instead of .NET. Appendixes: Appendix A provides answers to the exercise questions that appear throughout the book. The remaining appendixes provide reference material that you may find useful as you begin to apply the knowledge gained throughout the book in your own applications. These are: Appendix B: XPath Reference; Appendix C: XSLT Reference; Appendix D: The XML Document Object Model; Appendix E: XML Schema Element and Attribute Reference; Appendix F: XML Schema Datatypes Reference; Appendix G: SAX 2.0.2 Reference. Appendixes A, B, and C are included within the book; Appendixes D-G are available on the book's website.

This is your guide to building Internet applications and user interfaces with the Mozilla component framework, which is best known for the Firefox web browser and Thunderbird email client. Programming Firefox demonstrates how to use the XML User Interface Language (XUL) with open source tools in the framework's Cross-Platform Component (XPCOM) library to develop a variety of projects, such as commercial web applications and Firefox extensions. This book serves as both a programmer's reference and an in-depth tutorial, so not only do you get a comprehensive look at XUL's capabilities--from simple interface design to complex, multitier applications with real-time operations--but you also learn how to build a complete working application with XUL. If you're coming from a Java or .NET environment, you'll be amazed at how quickly large-scale applications can be constructed with XPCOM and XUL. Topics in Programming Firefox include: An overview of Firefox technology An introduction to the graphical elements that compose a XUL application Firefox development tools and the process used to design and build applications Managing an application with multiple content areas Introduction to Resource Description Files, and how the Firefox interface renders RDF Manipulating XHTML with JavaScript Displaying documents using the Scalable Vector Graphics standard and HTML Canvas The XML Binding Language and interface overlays to extend Firefox Implementing the next-generation forms interface through XForms Programming Firefox is ideal for the designer or developer charged with delivering innovative standards-based Internet applications, whether they're web server applications or Internet-enabled desktop applications. It's not just a how-to book, but a what-if exploration that encourages you to push the envelope of the Internet experience.

As XML gains popularity, developers are looking to implement XML technologies in their line-of-business applications This book offers readers real-world insight into XML so that they can build the best possible applications Offers an in-depth look at XML and discusses XML tools, services (RSS, SOAP, REST, WSDL), programming (DOM, SAX, Ajax), and languages (.NET, Java, PHP)

This IBM Redbooks publication provides an overview of the Informix Dynamic Server (IDS), Version 10. IDS provides the reliability, flexibility, and ease of maintenance that can enable you to adapt to new customer requirements. It is well known for its blazing online transaction processing (OLTP) performance, legendary reliability, and nearly hands-free administration for businesses of all sizes--all while simplifying and automating enterprise database deployment. Version 10 offers significant improvements in performance, availability, security, and manageability, including patent-pending technology that virtually eliminates downtime and automates many of the tasks that are associated with deploying mission-critical enterprise systems. New features speed application development, enable more robust enterprise data replication, and enable improved programmer productivity through support of IBM Rational development tools, JDBC 3.0, and Microsoft .NET as examples. Version 10 provides a robust foundation for e-business infrastructures with optimized Java support, IBM WebSphere certification, and XML and Web services support. Ready for service-oriented architecture (SOA)? This book also includes descriptions and demonstrations of support that are specific to IDS for an SOA.

Java and XML, 3rd Edition, shows you how to cut through all the hype about XML and put it to work. It teaches you how to use the APIs, tools, and tricks of XML to build real-world applications. The result is a new approach to managing information that touches everything from configuration files to web sites. After two chapters on XML basics, including XPath, XSL, DTDs, and XML Schema, the rest of the book focuses on using XML from your Java applications. This third edition of Java and XML covers all major Java XML processing libraries, including full coverage of the SAX, DOM, StAX, JDOM, and dom4j APIs as well as the latest version of the Java API for XML Processing (JAXP) and Java Architecture for XML Binding (JAXB). The chapters on web technology have been entirely rewritten to focus on the today's most relevant topics: syndicating content with RSS and creating Web 2.0 applications. You'll learn how to create, read, and modify RSS feeds for syndicated content and use XML to power the next generation of websites with Ajax and Adobe Flash. Topics include: The basics of XML, including DTDs, namespaces, XML Schema, XPath, and Transformations The SAX API, including all handlers, filters, and writers The DOM API, including DOM Level 2, Level 3, and the DOM HTML module The JDOM API, including the core and a look at XPath support The StAX API, including StAX factories, producing documents and XMLPull Data Binding with JAXB, using the new JAXB 2.0 annotations Web syndication and podcasting with RSS XML on the Presentation Layer, paying attention to Ajax and Flash applications If you are developing with Java and need to use XML, or think that you will be in the future; if you're involved in the new peer-to-peer movement, messaging, or web services; or if you're developing software for electronic commerce, Java and XML will be an indispensable companion.