Traditional relational databases and embedded databases both have shortcomings that can leave a developer perplexed. So for many people, the solution resides in SQLite, an open source embeddable database with an amazingly small footprint (less than 250 kilobytes). SQLite packs a powerful array of features and can handle databases as large as 2 terabytes. It offers a flexible set of datatypes and the ability to perform transactions, and it is supported by languages like C, PHP, Perl, and Python. And because SQLite's databases are completely file based, privileges are granted at the operating system level, allowing for easy and fast user management.

The Definitive Guide to SQLite is the first book to devote complete coverage to the latest version of this powerful database. It offers you a thorough overview of SQLite capabilities and APIs, while remaining cognizant of newcomers who may be making their first foray into a database environment with SQLite. This book serves as both a first-time tutorial and future reference guide.

Amazon.com® Reader Reviews (Ranked by Helpfulness)

Average Amazon.com® Rating:  Based on 26 Ratings

Exhaustive, for better or worse. - 2009-07-19
Reviewer Rating:
It's reasonable to look over the description of this book and ask yourself what is so idiosyncratic and bizarre about SQLite that it merits a 464-page reference for developers to wrap their heads around it. Especially when as a stated goal, SQLite overtly aims to be simple, stripped-down and uncomplicated in use.

The answer thankfully, is not very much. As the author goes to great pains to reinforce many times, SQL as a logical Data Manipulation Language is specified as being completely divorced from the underlying implementation. While all SQL DBs have their own annoying extensions, incompatibilities and divergences from the standard, the underlying syntax and form of SQL is mostly constant. You may, in the course of reading this book, come under the impression you're actually reading two separate publications, with their chapters collated together and coarsely interleaved in the same binding. One is broadly about SQL and RDBMS's, the other is actually about SQLite. As it turns out, there isn't much specific to the topic of SQLite that really demands so much coverage, so with the declared intention of being "definitive", the author has written something of a ground up tutorial/reference that aims to introduce both SQL and SQLite to audiences thoroughly unfamiliar with either. Passing over the table of contents in the front of the book I found myself raising an eyebrow as I realized how narrow of a demographic this book aims to cater to; that is, programmers who know nothing of SQL or relational DB theory and yet feel compelled and ready to embed an RDBMS library into their applications. I happened to be one of these people, but I question the usefulness of much of this book to someone already familiar with SQL.

Chapters 1 and 2 are boilerplate for introducing and setting up SQLite. Chapter 3 is an interesting but non-particular explanation of the Relational model. Chapter 4 is the centerpiece of the book and is a thorough introduction to SQL; while SQLite obviously is chosen as the reference implementation here, apart from the usual nuances this should not be at all unfamiliar to users of other relational DB's.

It isn't until chapter 5 that the book veers into territory solidly in the realm of SQLite. Chapters 5,6,7 and 8 all concern programming language interfaces to SQLite, however there's questionable utility to some of this. Chapter 5 "Design Concepts" redundantly presents the general structure of the API in pseudocode in advance of chapter 6 doing it all over again with the actual C function calls. 7 is the extension API, then chapter 8 continues over to the interfaces to higher level scripting and RAD languages. The repetition in this chapter is somewhat disquieting as unsurprisingly the general process of using SQLite is unchanged regardless of modules or the API in use, and in most languages there are reasonable standard generic DB interfaces to be used and there turns out not to be anything necessarily special about working with SQLite. Nonetheless, it's all there for reference and I found the examples in the Perl section useful while working on a project. The book ends with an overview of the internals of SQLite's compiler and VM backend. It's suggested in the chapter that an understanding of the engine may be of use to an application developer in reasoning about the workings of his or her queries, but I generally suspect that the point at which someone would need to concern themselves with the workings of the internal VM is the point at which they've either reached the performance limitations of their machine or the library, or else they've missed the forest for the trees and need to review the logical organization of their query. The remaining 60 or so pages are all reference appendices.

For programmers already familiar with SQL, most of what you should find of worth here is the API reference. Listings of function calls don't necessarily validate these chapters but the in-depth explanations of locking issues and race conditions do make these parts of the book worth the read versus just looking up the on-line documentation. Despite the criticisms earlier, if you actually fall within the boundaries of whom this book would provide instruction of unfamiliar topics to and need the long explanation of SQL given here, this is a good book for the topics it covers. The general SQL chapters are interesting and highly educational and well written, the SQLite chapters are good reference tutorials, but note that this book aims to be exhaustive and potentially retreads material that will likely already be known to advanced users.

great service, product exactly as described - 2009-10-13
Reviewer Rating:
It's supposed to be the definitive book, and it it's not I'm not sure where you'll find a better one! Clearly written (sometimes a little flowery) and well organized.

Great Book for enablement, right through to expert - 2009-09-14
Reviewer Rating:
When I bought "The Definitive Guide to SQLite" I was skeptical about the word "definitive". And I also thought it might be one of those books that I read once, move to shelf, and really never use. Defying my suspicions, I bought it, and I have been delighted every since.
It is an outstanding work, and is now one of my most used books.

The detailed walk though of SQL (with examples at every step and every command) made the first part of the book a re-education in SQL and a reawakening of the power of set theory in software design and implementation. By example, I found more in Chapter 4 of this book than the 3 other books I have on SQL/Database Design! The details on the often elusive topics of Database administration and Design Concepts (Locking, Triggers, Fetching Records, Indexing, etc..) with the inner explanation of what's happening in the database was just fantastic. And I won't even use the chapters that go into the Core C API, and the extension API.

The only gripe I have about the book is that the Index is a little sparse and is based more around knowledge groups rather than index. Something so minor, but it would help in referencing back to all the little gems that you discover in the pages and want to go back to.

All up I think developers should read this as the foundation work for software design, as knowing SQL in a SQLite context immediately provides great flexibility in solution design in all manner of places from scripts right through to high end desktop and web solutions.

In a few words: Fantastic, Accessible, Clear and Concise.

Great - 2009-04-20
Reviewer Rating:
This is one of the best technical books I have ever bought. First, it was the only place I was able to find sufficiently detailed information on installing SQLite. And then the detailed technical discussions and examples are great. If you are going to use SQLite (and I recommend that you do), this is a "must have" reference.
One negative: index sucks to the point of useless.

A good guide but not "definitive" - 2009-04-03
Reviewer Rating:
I've referred to this book several times and read chapter openings/introductions to familiarize myself with it. (This is how I use most such books.) It definitely is a help.

But I have a couple qualifications: 1) the publisher should take a quality control check - pg numbers do not always match index or toc - not off my much but enough to drive you nuts if you don't realize it 2) "definitive" ? - then I should have Appendices at least that reference how to install in VS or in other environments. No these are not "standardized," but none the less a hint in this direction is better than silence.

And finally, can't Apress or O'R or someone have websites that carry updates to info in the book? Ebooks are wonderfully searchable but fall out of date (so five minutes ago) really quickly too. Access to ongoing updates purchase with the book price or with an "add-on" would be a great thing.

Browse Similar Topics

Top Level Categories:
Databases

Sub-Categories:
Databases > Relational Database
Databases > SQL