XQuery Books

XQuery has its logical side, but it's pretty easy to forget all the syntax rules and nuances associated with it. Without this book, I'd easily be cursing XQuery and everything associated with it.

It was a great read to get started, but it's become an indispensable reference for day-to-day work and play. With the 30 or so sticky-notes poking out the top, I find myself constantly in this book looking for not just answers, but ways to better use XQuery efficiently in a maintenance-friendly manner.

This is a nice, comprehensive book written by someone highly qualified to talk about XQuery. The author, Priscilla Walmsley, was a member of the W3C XML Schema Working Group.

Now that XML is being added to database management systems, DBAs and database developers will need to know how to query that data. And they'll more than likely be using XQuery to do it. As such, this book would be a good way for database professionals to gain expertise on XQuery.

Walmsley's book offers a concise, yet in-depth tutorial on the XQuery language specification. After digesting these 25 chapters you'll have the knowledge required to program using XQuery to read your XML data. Whether you're coming from a relational and SQL background or you're an XML and XSLT coder, this well-written text will help you understand and write queries using XQuery.

The problem of this book is it doesn't give detailed information on how to implement X-Query on your computer. When you have Windows Vista, eXist doesn't work. Neither does WAMP. And unless you have heavy duty experience with SQL Server, this book is useless. The author of this book needs to include many more simple examples so that people like me can use the language. I might figure out how to use this someday, but it will be a long time before I do. That is so disappointing.

I needed to come up to speed with an XML database server (Mark Logic) and I found this book very useful for learning how to use XQuery. It was concise and provided many good examples. The presentation of chapters was somewhat episodic--you had to read the later chapters to find out how some of the topics turned out. This was probably due to the newness and complexity of the topic. I wouldn't be surprised if there was a chapter reorg for the 2nd edition.

In my case, the book covers only XQuery and does not cover the XQuery extensions and specifics of the XML database system I was using. Walmsley's book makes a great companion to the vendor documentation.

XML programmers and database users will find Priscilla Walmsley's XQUERY a specific, valuable reference which is based on the Xquery 1.0 standards and which offers a basic tutorial on specifications and programming with the query language base. Query writers should have some knowledge of XML basics to use this, and can quickly progress into the 'advanced' category using an overview and tour of Xquery which includes guidelines for working with different types of data and an A-Z reference to the program's functions.

Doug Tidwell knows his stuff, loves his stuff, and is eager to share his stuff with you. His stuff is xml, but his authoritative and well-written new book, XSLT, Second Edition, focuses on the eXtensible Stylesheet Language for Transformations.

If you're reading this, you probably already know that transformations are the means by which xml files can be converted from one format to another and sliced, diced, sorted, ordered, linked, and/or combined with other xml files along the way. Or maybe you don't already know that but you've heard that XSLT is a mysterious force with the power to convert xml data into html or pdf or scalable vector graphic format or other formats. Either way, Tidwell's book will help you grasp and exploit the power of xml transformations.

Previous exposure to xml concepts will save you time and help you to get the most out of the book, but don't worry if you're a newbie, because Tidwell provides a concise description of xml basics near the front of the book. And don't worry if you lack specialized tools for processing XSLT files: Tidwell thoughtfully provides download links and installation instructions for four popular XSLT processors (Xalan, Saxon, Microsoft XSLT Processor, and the Altova XSLT engine).

Nearly 600 pages of the book are devoted to appendixes filled with reference materials (about which, more later), but don't be misled by that fact. Tidwell knows that reference materials are useless without orientation and understanding, and the first 300 pages of the book provide exactly that.

Tidwell also knows that your time is valuable, and so he starts you off easy but FAST. In less than 45 pages, he covers the basics and walks you through a "Hello World" example. If you're new to XML or XSLT, the scales will fall from your eyes as you breeze through these pages.

From there, Tidwell devotes the next 100 pages to the two main activities of transformation: 1) teasing precise bodies of data from source files and 2)generating output in the desired format. By the time you get that far, you realize that you're in very good hands. Tidwell builds your comfort level and your confidence as he goes along. He holds back the really gnarly stuff until last: branching and control elements, links and cross-references and, finally, sorting, grouping, and combining data.

It's a very well organized approach, and the 300+ pages of orientation are exactly what you need in order to benefit from the reference materials in the appendixes.

And what about those reference materials? More fantastic stuff: The XSLT reference covers all the elements defined in the XSLT specification; the XPath reference covers key aspects of the XPath specification; other appendixes cover XSLT, XPath, and XQuery functions, XML Schemas, regular expressions, XSLT formatting codes, and migration from XSLT 1.0 to 2.0. (But NOTE: Changes brought about by XSLT 2.0 are discussed throughout the book, not limited to a single appendix entry.)

Even if you're a Jedi Master of XSLT, you'll be glad to have this book on your shelf for ready reference to the appendixes. If you rate yourself at an intermediate level of mastery, the chapters on advanced XSLT concepts will carry you to the next level. And if you're just beginning, you'll recognize Tidwell as a true friend in the transformation business. He will get you going in no time. The book is well organized, well written, and extremely well focused on its stated subject.

This book is a compact and thorough guide to XQuery. The Jonathan Robie tutorial in the beginning of the book is itself worth the overall price of the book.

This is a good book if you know what you are getting. If you are looking for a focused guide to XQuery practical applications you aren't going to like this book. It's worth repeating, this is not a general reference or introduction to XQuery. This is a set of articles on XQuery related topics. The first 'chapter' is an introduction to XQuery which is actually quite good. After that is a chapter on the history of XQuery. Then there is a chapter on XSLT and XPath, which is a nice, but brief, introduction to those topics. There is a section on the semantics of XQuery which is so thick you could cut it with a knife. The book finishes with two chapters on relational to XML mapping.

If you are a serious XQuery user, are interested in a case study in standards development, or are into relational theory this book is probably worth a look.

Full disclosure: I know all of the authors and count them among my friends.

In spite of that, I can honestly say that I think this book is a very valuable guide to the emerging standard query language for XML. The insights provided by people who are actually doing the day-to-day design, and implementation in some cases, of this language are not available in any other XQuery book.

The various chapters of the book provide overviews, design precepts, detailed examples, and thorough explanations (even of subjects as arcane as the static typing rules of the language).

I enthusiastically encourage everybody interested in XQuery to add this book to their libraries.

A very useful explanation of XQuery and how to use it to analyse XML data. The book shows how this can be done with or without a supporting XML Schema or DTD that describes the XML. The authors explain why this goes beyond a Google-type search. The latter does not (at least currently) know or use any structural information about data, primarily because it scans all types of mostly unstructured data.

But the rise of XML has driven demand for XQuery, to take advantage of this structure. The book also shows how XPath is used, as part of the XQuery implementation.

Another merit of the book is its good description of the difference between XQuery and XSLT. The latter also has been getting a lot of attention from programmers. But, as explained by the authors, XSLT is mainly used on document centric data, mostly to generate HTML. By contrast, XQuery has no such restriction.

Simply good. A collection of essays written by so many well-known names in the industry covering various aspects of the XQuery language from a "A Guided Tour" to "Introduction to Formal Semantics". A book that would be very useful for people with XSLT background, and need more power to do their job. A book that closes the between Relational Databases and XML.

A good number of authors and innovators contributed materials to this book:
- Don Chamberlin (an editor of the XML Query Use Cases, XQuery 1.0, XML Path Language 2.0 working drafts),
- Denise Draper (one of the editors of XQuery 1.0 Formal Semantics),
- Mary Fernandez (one of the editors of the working drafts of XQuery 1.0, XPath 2.0 Data Model, XML Path Language and XQuery 1.0 Formal Semantics),
- Howard Katz (editor of this book)
- Michael Kay (an editor of the XSLT, XSLT 2.0 and XQuery Serialization and XML Path Language 2.0 working drafts)
- Jonathan Robie (an editor of XQuery 1.0, XML Query Requirements, XML Syntax for XQuery 1.0 and XPath 2.0 working drafts)
- Michael Rys (an editor of the XQuery Formal Semantics, XML Syntax for XQuery, XML Query Requirements, XML Query and the XPath Full-Text Requirements working drafts)
- Jerome Simeon (an editor of XQuery 1.0, XPath 2.0 and the XQuery Formal Semantics working drafts)
- Jim Tivy (System architect of the ODMC 1.0 SQL Engine for Microsoft)
- Philip Walder (an editor of the XQuery, XPath Formal Semantics and the XML Schema working drafts)

Even though that some of the chapter in this book will benefit an expert programmer, with a solid background in XML, there are more than enough chapter that will benefit the beginner and one's who are no really familiar with XPath, XQuery and XSLT. The book starts by going over the basics of the XQuery language. The Guided Tour is simply a refresher, and introduces the reader to XQuery and its syntax/semantics. It talks about the differences between XPath and XQuery for example, and the benefits of XQuery over XPath. Small code sections are used to convey to the read the difference of one technology versus the other. XPath and XQuery get a lot of attention in this book as there are lots of similarities between the two as far as syntax is concerned and plenty of difference as far as its capabilities with XPath.
The author[s] dedicate the second chapter to the principles behind the design decisions of the XQuery language. Don Chamberlin, the author of this chapter, write the following mission statement for XQuery:
"The purpose of the new query language was to provide a flexability to extract information from real and virtual XML documents."
It is very refreshing to see the committee for creating XML actually went to the process of defining requirements, design definitions and the rest of the formal specification realization before they actually "wrote" the language. The message of formalism is very clear throughout the book. At each stage of design for this new language, proper documents have been generated (Use Case doc, Requirements doc, etc) that portray a good process. The section on formal semantics adds the following:
"After the Java programming language was released, several formal semantics of the language were written. Some of these semantics revealed errors in the type system, which in turn could lead to security holes in browsers that run Java programs. ..."

XQuery looks very similar to XPath, and this book spends a couple of chapters (a little of chapter 2, and most of chapter 3) to talk about the similarities, differences and influences of one language over the other. The new releases of XSTL, XPath and XQuery 1.0 look very similar since these groups collaborated with each other throughout the process of development. If you don't know anything about XPath or XSLT, and want to know how they differ and hoe they have evolved in the recent years, chapter 3, by Michael Kay, is what you need to read - or may even start with before you read the other chapters in this book. Chapter 3 starts off very easy, but it goes into more advanced topics such as optimization techniques used with XQuery - specially the one's that have been used before with XSLT and XPath for the same purpose.
One of the most interesting chapters in this book is chapter 5 on Formal Semantics. It is rare and rather refreshing to see a language being broken up like that and it's predicate logic and semantics be given in such detail. You can skip this chapter all together, but I suggest otherwise. Even if it is to realize how language processing and semantics of a language work. I would love to see such topic for C++ or JAVA... This chapter is good for anyone interested in optimization techniques and wishes to learn more about the details and correctness of the XQuery language.
Applications of XQuery at they apply to Databases and how it can be integrated into databases are covered in part 4.
XQuery had the capability to navigate, select, combine, transform, sort and aggregate XML data - thus making the integration of XQuery with the backend database very powerful and rather simple. XML data, and how it can be integrated into the database with the help of XQuery is covered in detail and two techniques are laid out: the LOB (large object) representation where the entire XML data is saved as a large object in the database, and the composed representation where each XML element is stored individually.
Even though XQuery is fairly a new language, the authors in this book go to great length depicting the formalism, the correctness, the stability and flexibility of the XQuery language. The chapters that cover Database integration with XML data clearly convey the power of this language, and thought process that went behind designing such stable and powerful language.

These guys put together a wonderful book; I've find it an ideal guide to solving pitfalls using XQuery. Having this book on my desktop help me in preventing potential problems with my code and saving countless hours of time tracking down issues that aren't initially apparent.

I don't think I've read a computer book as poorly organized as this one. The basic premise seems to be present some random aspects of XQuery or related topics in a chapter and have no flow through the book.

There is a lot of good material in the book but try to find it - it's more or less impossible because the index is abysmal. There's no real introduction to how to use XQuery - instead we start off with XSLT. That may be OK (they are related) but it seemed a bit strange to me.

Another problem with the book is that some of it is out of date. The XQuery specification is a work in progress but the book was written after (and refers to) the final draft - but a lot of the examples are not compliant with that final draft.

The best thing that I can say about this book is that it forced me to research issues more deeply and therefore find out what I needed to know. I wouldn't buy this book - try to borrow it and see if it meets your needs.

Many of the books on XQuery tell you how XQuery was created but not how to use it. This one is different and will help you hit the ground running. I recommend buying this book.

This book is about best practices, patterns and anti-patterns, and about how to use XML and XQuery correctly and efficiently. It will be useful to a professional with any level of experience. It may be used as a tutorial and read from the cover to cover, or one can enjoy reading selected items, depending on the experience and taste. The book's very detailed index makes it an excellent reference on the subject as well.

The authors are XQuery standardization committee members with long tenures at Oracle, thus possessing an unique grounding in that 'other' query language, SQL. As a result, the book is balanced with respect to what SQL/XML and XQuery can respectively do. A number of examples are provided, to illustrate where XQuery is useful and where other query mechanisms might work.

I've been an XQuery developer for an academic press for a number of years, and I read this book cover to cover. It sets out to describe methods for querying and does so,
in an almost scholarly fashion, for many common but different contexts. I found it provided cohesion to the diverse world of XML, from broad subjects to the details of spec grammars--a very welcome contribution to a technical library.

My only complaint with this book is that it emphasizes DTD over Schema a bit too much. For this and other reasons, I felt the treatment of XML seemed a little dated, and also a bit shallow.

If you need to learn XQuery or XPath fast, this is not the book, or you need to skip the first 8 chapters. XQuery and XPath are hardly even mentioned until Chapter 9. The first 8 chapters discuss everything except what is in the title. XML is a pretty boring topic, and excess verbage doesn't help.

I have had this book for almost a month now. This book is painful to get through. I can usually get through a technical book within a week and try some examples. I started reading this book front to back and did not skip any sections.

I am not a NOOB when it comes to XML so I found this surprising. I am a certified XML developer (from before XQuery), an experienced programming engineer of 8 years, an MCAD.Net, and I have even written a paper on XQuery for a Master's Program and I simply have become unmotivated and am struggling to get through this book. As others have stated in reviews, this book takes a long time to get to the point. I like to get my money's worth when I buy a book though.

I kept asking myself chapter after chapter "when do we start programming some examples?" The first 10 chapters are filled with everything but XQuery. The author covers the background of XML and why we would use XQuery in detail. I see the argument for why this book may be beneficial to some but if you wish to get up and running on XQuery this is not the book for you.

I may update this as I finish off the book. I am getting more into actual XQuery syntax and grammar as of chapter 11. A flip through the TOC shows that the author covers some implementation info. My goal was to have a better understanding of how to actually implement XQuery and learn some of the more detailed points of it versus just FLWOR that the numerous online tutorials offer. I have purchased another book by O'Reilly instead.

Update: I received the O'Reilly book right after writing this review. I flipped through the TOC and first few pages of XQuery by O'Reilly for a comparison. Wow! These two books could not be any different. I am on chapter 5 of the O'Reilly XQuery book just in a few hours of off and on reading at work. It appears thus far to be the better choice. Luckily, work is paying for these books so I was only cheated out of time buying "Querying XML".

This very good book gets only 1 star because of the poor quality of binding. A few months of (admittedly heavy) use is all it took for individual pages and whole sections to start falling out.
Otherwise, I generally agree with the previous review. It's a thorough introduction to the XQuery language with extensive reference and numerous examples. If it wasn't for the horrible production values I'd give it 5 stars.

This is a well written introductory and reference work on XQuery. It's primarily an introductory work, the first 260 pages are introduction and the final 240 are a reference that is organized as an appendix.

The writing is solid, and it by no means panders to the reader, so you should be prepared to read over sections multiple times to completely understand the topic. I can't penalize the book for this because the topic is fairly complex.

On the downside there could be more in the way of real world examples in the text as they explain so of the more complex topics. It easier for the reader to retain the information if they knew why they would be using the language feature in the real world. In addition the book needs a section on existing tools and support for XQuery.

Strong chapters are chapters five and six which cut to the heart for the FLWOR expression syntax.

Overall this is a fine introductory work that could use some expansion and some more focused explanations.

This is simply a great introduction to XQuery. In general this is a book rich on examples. I used this to test every other query, and gain a more thorough understand of the particular topic. The best way to learn a new language is to practice - right ?

Besides the examples bit, I think this is a well written book that explains the more academic content in straight forward manner. About half of the book is references, which has a lot of examples. My personal favorite section is the "Idioms" part of Chapter 10 that gives some clever solutions that I wouldn't have come up with myself.

This is a well written introductory and reference work on XQuery. It's primarily an introductory work, the first 260 pages are introduction and the final 240 are a reference that is organized as an appendix.

The writing is solid, and it by no means panders to the reader, so you should be prepared to read over sections multiple times to completely understand the topic. I can't penalize the book for this because the topic is fairly complex.

On the downside there could be more in the way of real world examples in the text as they explain so of the more complex topics. It easier for the reader to retain the information if they knew why they would be using the language feature in the real world. In addition the book needs a section on existing tools and support for XQuery.

Strong chapters are chapters five and six which cut to the heart for the FLWOR expression syntax.

Overall this is a fine introductory work that could use some expansion and some more focused explanations.

Too many development books are slanted towards either concepts or practical, in-the-trenches development. This book manages to balance both by giving not only the what's and why's, but the how to's, and does so in a readable and highly credible manner.

The discussion about why Xquery instead of Xpath, XSLT or even direct access through another programming language shows both the strengths and some weaknesses of Xquery. This discussion extended into documents, databases, the state of the Xquery specification, and culminated in a essential types, and types you will not need. This is both conceptual and practical.

For the developer who wants to get up-to-speed with (or refine skills in) Xquery, this book goes deep into every facet, using concepts, concrete examples, and code. More importantly, the author's extensive experience is shown in Chapter 11, which covers problem areas and common points of confusion. This short chapter will prove invaluable to new developers. I also liked the chapter on query optimization, and the rich reference material in the appendices, which is almost half of this book.

If you want to learn Xquery, hone existing skills, or step back and see the big picture this book is the best one in my opinion. Expect in-depth technical information, and expect it to be provided by someone who understands developers and provides the code to make it real.

This is exactly what I want from a technical book on a tricky, subtle topic: it is *serious* and does not kid around. If you're new to programming, XML, declarative languages, or regular expressions: this is not the book for you. If you're familar with all those things and want to put a new tool in your toolbelt, this is the book. It explains the semantics and the processing model thoroughly, instead of just describing the syntax. It also serves as a reference for XSLT 1.0, because the author carefully indicates what features are available in which version.
I recommend getting the companion XPath book XPath 2.0 Programmer's Reference (Programmer to Programmer) at the same time; the XSLT book doesn't cover XPath, but you really need solid XPath skills to accomplish anything with XSLT.
Just one problem: the diagrams are really ugly. They weren't designed for print; they're jaggy and blurry. I've seen the same diagrams in other materials though; I think it's part of the XSLT spec.

In addition to his obvious authority on the subject of XSLT Michael Kay is one of the best writers out there. This book gives a thorough explication of the history and concepts behind XSLT that is valuable for newcomers and informative for more experienced hands. It is written for those with experience with programming languages but new to XSLT or new to XSLT 2.0. It presents thorough documentation for elements and functions, with examples of their use.

I purchased this book primarily as a reference when I need a little more detail on a tag or function. The author has done what seems to be an entirely thorough job documenting each tag and function in a consistent and useful manner. Once I find it, the content is all I need. I have yet to read through the other chapters; I have a feeling they will provide useful insights.

Unfortunately, it is all but impossible to thumb through the book to find a specific tag. Because the tags and function names are all lowercase, they appear almost identical to the next-level headings which are mixed case. A rule under the paragraph or something would have helped a lot (I have been marking each with a highlighter). I'm not sure why they didn't maintain the boldface from the TOC (see below); that would have helped.

The headers and footers display nothing more than the chapter name/number and page number-- contrast this with a typical O'Reilly design (JavaScript 5th Edition) where the page headers in the Core JS Reference chapter show the first and last entries on the spread just like a (good) dictionary.

So, you can expect to have to refer to the Table of Contents often. Unfortunately, there is typically 4"+ (10-12cm) of blank space between an entry and its page number in the table of contents. This would be another usability disaster except that they at least boldface the tag and function names along with their page numbers. (Hint to designer: dot leaders have been around for a while now...)

I will avoid purchasing reference works from Wrox/Wiley in the future.

I would not think this book is a "start learning xslt book". It is not meant to be start of with. It is a definately a great reference book for xslt 1.0 and updates for xslt 2.0. This is a kind of book in which you work your way from the index at the back of the book to the desired topic.

From the book's introduction: "In previous editions, XSLT and XPath were covered in a single volume. This time, they have been divided into two separate books: this one covers XSLT 2.0, while the companion book 'XPath 2.0 Programmer's Reference" describes XPath." ... "This book is intended to be used alongside the companion volume ... Since XSLT 2.0 has such a strong dependence on XPath 2.0, you really need both books."

It turns out, most of the questions I needed answered aren't even covered in this book. That was frustrating for me.

I later purchased the companion XPath 2.0 book. In their favor, I will say that I have never had a question about XSLT or XPath that wasn't answered by these books.

However, both books are perhaps the worst-formatted reference books I have ever seen. Much of the book consists of an alphabetical reference of XML elements or XPath functions. Unfortunately, the page headers and footers only contain page numbers and chapter titles. They do not contain the name of the element or function that is described on that page. So you can't just riff through the pages watching for your function to appear in the footer.

There is a heading for each element or function name, but the font used for the sub-headings are as large as (if not larger than) the major headings. There are no page breaks between functions or elements. So you can't even visually scan the pages looking for your functions.

Finally, the table of contents consists largely of function or element names on the left, with page numbers on the right, separated by about five inches. But there are no dot leaders between them. So, even when you resort to using the table of contents to find the section you need, you have to use a ruler to find the page number.

Not much info you can get from this book. Maybe it was published too early?

When i read the author listing and their occupations, after i had purchased this book ... i was a bit furious at myself, as if i had wasted money in quenching my thirst for this new language based on XML. Unlikely, the book is very well authored and gives references to vendors and tools that provide hands on experience of this new language and makes it rather less formidable for a person trying to grasp the specs (which are already numerous enough to confuse you when you look into XML technology). In short, provides considerable in depth to serve the purpose of deciding to go this way or not ... at the same time it demonstrates and teaches the language (as minimum and limited as it is currently) in a exemplary way, so in my opinion it strikes a good balance between the theory and examples it provides. Infact focuses more on examples and practicality, if you are really interetsed in using this language somewhere down the road i would advise to get this book than rather scratch your head over its specs a W3C for long periods of time.