Muutke küpsiste eelistusi

Definitive Guide to SQLite 1st ed. [Kõva köide]

3.90/5 (80 hinnangut Goodreads-ist)
  • Formaat: Hardback, 440 pages, kõrgus x laius: 235x178 mm, kaal: 1018 g, XXI, 440 p., 1 Hardback
  • Ilmumisaeg: 24-May-2006
  • Kirjastus: APress
  • ISBN-10: 1590596730
  • ISBN-13: 9781590596739
Teised raamatud teemal:
  • Kõva köide
  • Hind: 49,87 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Tavahind: 58,67 €
  • Säästad 15%
  • Raamatu kohalejõudmiseks kirjastusest kulub orienteeruvalt 2-4 nädalat
  • Kogus:
  • Lisa ostukorvi
  • Tasuta tarne
  • Tellimisaeg 2-4 nädalat
  • Lisa soovinimekirja
Definitive Guide to SQLite 1st ed.Suurem pilt
  • Formaat: Hardback, 440 pages, kõrgus x laius: 235x178 mm, kaal: 1018 g, XXI, 440 p., 1 Hardback
  • Ilmumisaeg: 24-May-2006
  • Kirjastus: APress
  • ISBN-10: 1590596730
  • ISBN-13: 9781590596739
Teised raamatud teemal:
Püsilink: https://www.kriso.ee/db/9781590596739.html
Märksõnad:
Traditional relational databases and embedded databases both have shortcomings that can leave a developer perplexed. So for many people, the solution resides in 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 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.
Foreword xv
About the Author xvii
About the Technical Reviewer xix
Acknowledgments xxi
Introducing SQLite
1(16)
An Embedded Database
1(1)
A Developer's Database
2(1)
An Administrator's Database
3(1)
SQLite History
3(1)
Who Uses SQLite
4(1)
Architecture
5(3)
The Interface
6(1)
The Compiler
6(1)
The Virtual Machine
6(1)
The Back-end
7(1)
Utilities and Test Code
8(1)
SQLite's Features and Philosophy
8(3)
Zero Configuration
8(1)
Portability
8(1)
Compactness
8(1)
Simplicity
9(1)
Flexibility
9(1)
Liberal Licensing
9(1)
Reliability
10(1)
Convenience
10(1)
Performance and Limitations
11(3)
Who Should Read This Book
14(1)
How This Book Is Organized
14(2)
Additional Information
16(1)
Summary
16(1)
Getting Started
17(30)
Where to Get SQLite
17(1)
SQLite on Windows
18(13)
Getting the Command-Line Program
18(2)
Getting the SQLite DLL
20(1)
Compiling the SQLite Source Code on Windows
21(4)
Building the SQLite DLL with Microsoft Visual C++
25(3)
Building a Dynamically Linked SQLite Client with Visual C++
28(1)
Building SQLite with MinGW
29(2)
SQLite on POSIX Systems
31(3)
Binaries and Packages
31(2)
Compiling SQLite from Source
33(1)
Working with SQLite Databases
34(8)
The CLP in Shell Mode
34(7)
The CLP in Command-Line Mode
41(1)
Database Administration
42(3)
Creating, Backing Up, and Dropping Databases
42(1)
Getting Database File Information
43(2)
Other SQLite Tools
45(1)
Summary
45(2)
The Relational Model
47(26)
Background
47(2)
The Three Components
48(1)
SQL and the Relational Model
48(1)
The Structural Component
49(11)
The Information Principle
49(1)
The Sanctity of the Logical Level
50(1)
The Anatomy of the Logical Level
51(1)
Tuples
52(1)
Relations
52(4)
Tables: Relation Variables
56(2)
Views: Virtual Tables
58(1)
The System Catalog
59(1)
The Integrity Component
60(3)
Primary Keys
60(1)
Foreign Keys
61(1)
Constraints
62(1)
Null Values
63(1)
Normalization
63(5)
Normal Forms
64(1)
First Normal Form
64(1)
Functional Dependencies
64(1)
Second Normal Form
65(2)
Third Normal Form
67(1)
The Manipulative Component
68(3)
Relational Algebra and Calculus
68(1)
Relational Query Language
69(1)
The Advent of SQL
70(1)
The Meaning of Relational
71(1)
Summary
71(1)
References
72(1)
SQL
73(98)
The Relational Model
73(2)
Query Languages
74(1)
The Growth of SQL
74(1)
The Example Database
75(2)
Installation
76(1)
Running the Examples
76(1)
Syntax
77(3)
Commands
79(1)
Literals
79(1)
Keywords and Identifiers
80(1)
Comments
80(1)
Creating a Database
80(2)
Creating Tables
80(2)
Altering Tables
82(1)
Querying the Database
82(41)
Relational Operations
82(2)
The Operational Pipeline
84(3)
Filtering
87(6)
Limiting and Ordering
93(1)
Functions and Aggregates
94(3)
Grouping
97(4)
Removing Duplicates
101(1)
Joining Tables
101(8)
Names and Aliases
109(2)
Subqueries
111(3)
Compound Queries
114(3)
Conditional Results
117(2)
The Thing Called Null
119(3)
Set Operations
122(1)
Modifying Data
123(5)
Inserting Records
123(4)
Updating Records
127(1)
Deleting Records
128(1)
Data Integrity
128(19)
Entity Integrity
128(5)
Domain Integrity
133(3)
Storage Classes
136(3)
Manifest Typing
139(2)
Type Affinity
141(6)
Transactions
147(6)
Transaction Scopes
147(1)
Conflict Resolution
148(3)
Database Locks
151(1)
Deadlocks
151(1)
Transaction Types
152(1)
Database Administration
153(16)
Views
153(2)
Indexes
155(3)
Triggers
158(5)
Attaching Databases
163(1)
Cleaning Databases
164(1)
Database Configuration
165(3)
The System Catalog
168(1)
Viewing Query Plans
168(1)
Summary
169(2)
Design and Concepts
171(34)
The API
171(15)
What's New in SQLite Version 3
172(1)
The Principal Data Structures
172(2)
The Core API
174(8)
Operational Control
182(1)
The Extension API
183(3)
Transactions
186(11)
Transaction Lifecycles
186(1)
Lock States
187(1)
Read Transactions
188(1)
Write Transactions
189(3)
Tuning the Page Cache
192(2)
Waiting for Locks
194(3)
Code
197(6)
Using Multiple Connections
197(1)
Table Locks
198(1)
Fun with Temporary Tables
199(2)
The Importance of Finalizing
201(1)
Shared Cache Mode
202(1)
Summary
203(2)
The Core C API
205(50)
Wrapped Queries
205(9)
Connecting and Disconnecting
206(1)
The exec Query
207(4)
String Handling
211(2)
The Get Table Query
213(1)
Prepared Queries
214(15)
Compilation
216(1)
Execution
216(1)
Finalization and Reset
217(2)
Fetching Records
219(5)
Parameterized Queries
224(5)
Errors and the Unexpected
229(6)
Handling Errors
229(3)
Handling Busy Conditions
232(1)
Handling Schema Changes
233(2)
Operational Control
235(11)
Commit Hooks
235(1)
Rollback Hooks
236(1)
Update Hooks
236(1)
Authorizer Functions
237(9)
Threads
246(7)
Shared Cache Mode
247(5)
Threads and Memory Management
252(1)
Summary
253(2)
The Extension C API
255(46)
The API
256(3)
Registering Functions
256(2)
The Step Function
258(1)
Return Values
258(1)
Functions
259(19)
Return Values
262(2)
A Complete Example
264(3)
A Practical Application
267(11)
Aggregates
278(5)
A Practical Example
280(3)
Collating Sequences
283(16)
Collation Defined
284(2)
A Simple Example
286(5)
Collation on Demand
291(1)
A Practical Application
292(7)
Summary
299(2)
Language Extensions
301(40)
Selecting an Extension
302(1)
Perl
303(7)
Installation
303(1)
Connecting
304(1)
Query Processing
304(2)
Parameter Binding
306(1)
User-Defined Functions and Aggregates
307(3)
Python
310(9)
PySQLite
310(6)
APSW
316(3)
Ruby
319(5)
Installation
319(1)
Connecting
319(1)
Query Processing
320(2)
User-Defined Functions and Aggregates
322(2)
Java
324(7)
Installation
325(1)
Connecting
325(1)
Query Processing
326(2)
User-Defined Functions and Aggregates
328(1)
JDBC
329(2)
Tcl
331(4)
Installation
331(1)
Connecting
331(1)
Query Processing
332(2)
User-Defined Functions
334(1)
PHP
335(5)
Installation
336(1)
Connections
336(1)
Queries
336(3)
User-Defined Functions and Aggregates
339(1)
Summary
340(1)
SQLite Internals
341(24)
The Virtual Database Engine
341(8)
The Stack
343(1)
Program Body
343(2)
Program Startup and Shutdown
345(2)
Instruction Types
347(2)
The B-Tree and Pager Modules
349(6)
Database File Format
349(4)
The B-Tree API
353(2)
The Compiler
355(7)
The Tokenizer
355(2)
The Parser
357(1)
The Code Generator
358(2)
The Optimizer
360(2)
Summary
362(3)
Appendix A SQL Reference 365(30)
Appendix B C API Reference 395(28)
Appendix C Codd's 12 Rules 423(2)
Index 425
Mike Owens is the information technology director for a major real estate firm in Fort Worth, Texas, where he's charged with the development and management of the company's core systems. His prior experience includes time spent at Oak Ridge National Laboratory as a process design engineer, and at Nova Information Systems as a C++ programmer. He is the original creator of Pysqlite, the Python extension for SQLite. Mike earned his bachelor's degree in chemical engineering from the University of Tennessee in Knoxville.