1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
|
<!DOCTYPE html>
<html><head>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<link href="sqlite.css" rel="stylesheet">
<title>SQLite Documentation</title>
<!-- path= -->
</head>
<body>
<div class=nosearch>
<a href="index.html">
<img class="logo" src="images/sqlite370_banner.gif" alt="SQLite" border="0">
</a>
<div><!-- IE hack to prevent disappearing logo --></div>
<div class="tagline desktoponly">
Small. Fast. Reliable.<br>Choose any three.
</div>
<div class="menu mainmenu">
<ul>
<li><a href="index.html">Home</a>
<li class='mobileonly'><a href="javascript:void(0)" onclick='toggle_div("submenu")'>Menu</a>
<li class='wideonly'><a href='about.html'>About</a>
<li class='desktoponly'><a href="docs.html">Documentation</a>
<li class='desktoponly'><a href="download.html">Download</a>
<li class='wideonly'><a href='copyright.html'>License</a>
<li class='desktoponly'><a href="support.html">Support</a>
<li class='desktoponly'><a href="prosupport.html">Purchase</a>
<li class='search' id='search_menubutton'>
<a href="javascript:void(0)" onclick='toggle_search()'>Search</a>
</ul>
</div>
<div class="menu submenu" id="submenu">
<ul>
<li><a href='about.html'>About</a>
<li><a href='docs.html'>Documentation</a>
<li><a href='download.html'>Download</a>
<li><a href='support.html'>Support</a>
<li><a href='prosupport.html'>Purchase</a>
</ul>
</div>
<div class="searchmenu" id="searchmenu">
<form method="GET" action="search">
<select name="s" id="searchtype">
<option value="d">Search Documentation</option>
<option value="c">Search Changelog</option>
</select>
<input type="text" name="q" id="searchbox" value="">
<input type="submit" value="Go">
</form>
</div>
</div>
<script>
function toggle_div(nm) {
var w = document.getElementById(nm);
if( w.style.display=="block" ){
w.style.display = "none";
}else{
w.style.display = "block";
}
}
function toggle_search() {
var w = document.getElementById("searchmenu");
if( w.style.display=="block" ){
w.style.display = "none";
} else {
w.style.display = "block";
setTimeout(function(){
document.getElementById("searchbox").focus()
}, 30);
}
}
function div_off(nm){document.getElementById(nm).style.display="none";}
window.onbeforeunload = function(e){div_off("submenu");}
/* Disable the Search feature if we are not operating from CGI, since */
/* Search is accomplished using CGI and will not work without it. */
if( !location.origin || !location.origin.match || !location.origin.match(/http/) ){
document.getElementById("search_menubutton").style.display = "none";
}
/* Used by the Hide/Show button beside syntax diagrams, to toggle the */
function hideorshow(btn,obj){
var x = document.getElementById(obj);
var b = document.getElementById(btn);
if( x.style.display!='none' ){
x.style.display = 'none';
b.innerHTML='show';
}else{
x.style.display = '';
b.innerHTML='hide';
}
return false;
}
var antiRobot = 0;
function antiRobotGo(){
if( antiRobot!=3 ) return;
antiRobot = 7;
var j = document.getElementById("mtimelink");
if(j && j.hasAttribute("data-href")) j.href=j.getAttribute("data-href");
}
function antiRobotDefense(){
document.body.onmousedown=function(){
antiRobot |= 2;
antiRobotGo();
document.body.onmousedown=null;
}
document.body.onmousemove=function(){
antiRobot |= 2;
antiRobotGo();
document.body.onmousemove=null;
}
setTimeout(function(){
antiRobot |= 1;
antiRobotGo();
}, 100)
antiRobotGo();
}
antiRobotDefense();
</script>
<div class="rightsidebar desktoponly border2px">
<h3 align="center">Common Links</h3>
<ul class=nounderline>
<li> <a href="features.html">Features</a> </li>
<li> <a href="whentouse.html">When to use SQLite</a> </li>
<li> <a href="quickstart.html">Getting Started</a> </li>
<li> <a href="https://sqlite.org/fiddle">Try it live!</li>
<li> <a href="chronology.html">Prior Releases</a>
<li> <a href="lang.html">SQL Syntax</a>
<ul>
<li> <a href="pragma.html#toc">Pragmas</a>
<li> <a href="lang_corefunc.html">SQL functions</a>
<li> <a href="lang_datefunc.html">Date & time functions</a>
<li> <a href="lang_aggfunc.html#aggfunclist">Aggregate functions</a>
<li> <a href="windowfunctions.html#biwinfunc">Window functions</a>
<li> <a href="lang_mathfunc.html">Math functions</a>
<li> <a href="json1.html">JSON functions</a>
</ul>
</li>
<li> <a href="c3ref/intro.html">C/C++ Interface Spec</a>
<ul>
<li> <a href="cintro.html">Introduction</a>
<li> <a href="c3ref/funclist.html">List of C-language APIs</a>
</ul>
</li>
<li> <a href="tclsqlite.html">The TCL Interface Spec</a>
<li> <a href="quirks.html">Quirks and Gotchas</a> </li>
<li> <a href="faq.html">Frequently Asked Questions</a> </li>
<li> <a href="http://www.sqlite.org/src/timeline?n=100&y=ci">Commit History</a> </li>
<li> <a href="http://www.sqlite.org/src/wiki?name=Bug+Reports">Bugs</a> </li>
<li> <a href="news.html">News</a> </li>
</ul>
</div>
<h2 align="center">Documentation</h1>
<div class="docsearch" id="docsearch">
<form method="GET" action="./search">
<select name="s" id="searchtype">
<option value="d">Search Documentation</option>
<option value="c">Search Changelog</option>
</select>
<input type="text" name="q" id="searchbox">
<input type="submit" value="Go">
</form>
</div>
<style>
.showhide {
margin-left: 0;
padding-left: 0;
list-style-type: none;
}
.showhide > li {
padding-left: 1em;
text-indent: -1em;
}
.showhide > li li {
padding-left: 0;
text-indent: 0;
padding-top: 1ex;
padding-bottom: 1ex;
}
.showhide ul {
display: none;
list-style-type: disc;
}
.showhide > li > a {
text-decoration: none;
color: black;
cursor: pointer;
}
.sh_mark {
float: left;
width: 1em;
}
.sh_link {
font-weight: bold;
}
.docsearch {
margin: auto;
width: 450px;
padding-bottom: 1.5em;
}
</style>
<script>
function showhide(n){
var ul = document.getElementById("sh_sub_"+n)
var mk = document.getElementById("sh_mark_"+n)
if( ul.style.display!="block" ){
ul.style.display = "block";
mk.innerHTML = "▼";
} else {
ul.style.display = "none";
mk.innerHTML = "►";
}
}
if( !location.origin || !location.origin.match || !location.origin.match(/http/) ){
document.getElementById("docsearch").style.display = "none";
}
</script>
<ul class="showhide">
<li><a onclick='showhide(1)'><span class='sh_mark' id='sh_mark_1'>▼</span> Document Lists And Indexes</a>
<ul id='sh_sub_1' style='display:block;'>
<li><a class='sh_link' href='doclist.html'>Alphabetical Listing Of All Documents</a>
<li><a class='sh_link' href='keyword_index.html'>Website Keyword Index</a>
<li><a class='sh_link' href='sitemap.html#pindex'>Permuted Title Index</a>
</ul>
<li><a onclick='showhide(2)'><span class='sh_mark' id='sh_mark_2'>►</span> Overview Documents</a>
<ul id='sh_sub_2'>
<li><a class='sh_link' href='about.html'>About SQLite</a>
<span class='desktoponly'>→
A high-level overview of what SQLite is and why you might be
interested in using it.
</span>
<li><a class='sh_link' href='whentouse.html'>Appropriate Uses For SQLite</a>
<span class='desktoponly'>→
This document describes situations where SQLite is an appropriate
database engine to use versus situations where a client/server
database engine might be a better choice.
</span>
<li><a class='sh_link' href='different.html'>Distinctive Features</a>
<span class='desktoponly'>→
This document enumerates and describes some of the features of
SQLite that make it different from other SQL database engines.
</span>
<li><a class='sh_link' href='quirks.html'>Quirks of SQLite</a>
<span class='desktoponly'>→
This document is a short list of some unusual features of SQLite
that tend to cause misunderstandings and confusion. The list includes
both deliberate innovations and "misfeatures" that are retained only
for backwards compatibility.
</span>
<li><a class='sh_link' href='testing.html'>How SQLite Is Tested</a>
<span class='desktoponly'>→
The reliability and robustness of SQLite is achieved in large part
by thorough and careful testing. This document identifies the
many tests that occur before every release of SQLite.
</span>
<li><a class='sh_link' href='copyright.html'>Copyright</a>
<span class='desktoponly'>→
SQLite is in the public domain. This document describes what that means
and the implications for contributors.
</span>
<li><a class='sh_link' href='faq.html'>Frequently Asked Questions</a>
<span class='desktoponly'>→
The title of the document says all...
</span>
<li><a class='sh_link' href='books.html'>Books About SQLite</a>
<span class='desktoponly'>→
A list of independently written books about SQLite.
</span>
</ul>
<li><a onclick='showhide(3)'><span class='sh_mark' id='sh_mark_3'>►</span> Programming Interfaces</a>
<ul id='sh_sub_3'>
<li><a class='sh_link' href='quickstart.html'>SQLite In 5 Minutes Or Less</a>
<span class='desktoponly'>→
A very quick introduction to programming with SQLite.
</span>
<li><a class='sh_link' href='cintro.html'>Introduction to the C/C++ API </a>
<span class='desktoponly'>→
This document introduces the C/C++ API. Users should read this document
before the C/C++ API Reference Guide linked below.
</span>
<li><a class='sh_link' href='howtocompile.html'>How To Compile SQLite</a>
<span class='desktoponly'>→
Instructions and hints for compiling SQLite C code and integrating
that code with your own application.
</span>
<li><a class='sh_link' href='c3ref/intro.html'>C/C++ API Reference</a>
<span class='desktoponly'>→
This document describes each API function separately.
</span>
<li><a class='sh_link' href='rescode.html'>Result and Error Codes</a>
<span class='desktoponly'>→
A description of the meanings of the numeric result codes
returned by various C/C++ interfaces.
</span>
<li><a class='sh_link' href='lang.html'>SQL Syntax</a>
<span class='desktoponly'>→
This document describes the SQL language that is understood by
SQLite.
</span>
<li><a class='sh_link' href='pragma.html'>Pragma commands</a>
<span class='desktoponly'>→
This document describes SQLite performance tuning options and other
special purpose database commands.
</span>
<li><a class='sh_link' href='lang_corefunc.html'>Core SQL Functions</a>
<span class='desktoponly'>→
General-purpose built-in scalar SQL functions.
</span>
<li><a class='sh_link' href='lang_aggfunc.html'>Aggregate SQL Functions</a>
<span class='desktoponly'>→
General-purpose built-in aggregate SQL functions.
</span>
<li><a class='sh_link' href='lang_datefunc.html'>Date and Time SQL Functions</a>
<span class='desktoponly'>→
SQL functions for manipulating dates and times.
</span>
<li><a class='sh_link' href='windowfunctions.html'>Window Functions</a>
<span class='desktoponly'>→
SQL Window functions.
</span>
<li><a class='sh_link' href='gencol.html'>Generated Columns</a>
<span class='desktoponly'>→
Stored and virtual columns in table definitions.
</span>
<li><a class='sh_link' href='http://system.data.sqlite.org/'>System.Data.SQLite</a>
<span class='desktoponly'>→
C#/.NET bindings for SQLite
</span>
<li><a class='sh_link' href='tclsqlite.html'>Tcl API</a>
<span class='desktoponly'>→
A description of the TCL interface bindings for SQLite.
</span>
<li><a class='sh_link' href='datatype3.html'>DataTypes</a>
<span class='desktoponly'>→
SQLite version 3 introduces the concept of manifest typing, where the
type of a value is associated with the value itself, not the column that
it is stored in.
This page describes data typing for SQLite version 3 in further detail.
</span>
</ul>
<li><a onclick='showhide(4)'><span class='sh_mark' id='sh_mark_4'>►</span> Extensions</a>
<ul id='sh_sub_4'>
<li><a class='sh_link' href='json1.html'>Json1 - JSON Integration</a>
<span class='desktoponly'>→
SQL functions for creating, parsing, and querying JSON content.
</span>
<li><a class='sh_link' href='fts5.html'>FTS5 - Full Text Search</a>
<span class='desktoponly'>→
A description of the SQLite Full Text Search (FTS5) extension.
</span>
<li><a class='sh_link' href='fts3.html'>FTS3 - Full Text Search</a>
<span class='desktoponly'>→
A description of the SQLite Full Text Search (FTS3) extension.
</span>
<li><a class='sh_link' href='rtree.html'>R-Tree Module</a>
<span class='desktoponly'>→
A description of the SQLite R-Tree extension. An R-Tree is a specialized
data structure that supports fast multi-dimensional range queries often
used in geospatial systems.
</span>
<li><a class='sh_link' href='sessionintro.html'>Sessions</a>
<span class='desktoponly'>→
The Sessions extension allows change to an SQLite database to be
captured in a compact file which can be reverted on the original
database (to implement "undo") or transferred and applied to another
similar database.
</span>
<li><a class='sh_link' href='loadext.html'>Run-Time Loadable Extensions</a>
<span class='desktoponly'>→
A general overview on how run-time loadable extensions work, how they
are compiled, and how developers can create their own run-time loadable
extensions for SQLite.
</span>
<li><a class='sh_link' href='http://sqlite.org/android/'>SQLite Android Bindings</a>
<span class='desktoponly'>→
Information on how to deploy your own private copy of SQLite on
Android, bypassing the built-in SQLite, but using the same Java
interface.
</span>
<li><a class='sh_link' href='dbstat.html'>Dbstat Virtual Table</a>
<span class='desktoponly'>→
The DBSTAT virtual table reports on the sizes and geometries of tables
storing content in an SQLite database, and is the basis for the
[sqlite3_analyzer] utility program.
</span>
<li><a class='sh_link' href='csv.html'>Csv Virtual Table</a>
<span class='desktoponly'>→
The CSV virtual table allows SQLite to directly read and query
[https://www.ietf.org/rfc/rfc4180.txt|RFC 4180] formatted files.
</span>
<li><a class='sh_link' href='carray.html'>Carray</a>
<span class='desktoponly'>→
CARRAY is a [table-valued function] that allows C-language arrays to
be used in SQL queries.
</span>
<li><a class='sh_link' href='series.html'>generate_series</a>
<span class='desktoponly'>→
A description of the generate_series() [table-valued function].
</span>
<li><a class='sh_link' href='spellfix1.html'>Spellfix1</a>
<span class='desktoponly'>→
The spellfix1 extension is an experiment in doing spelling correction
for [full-text search].
</span>
</ul>
<li><a onclick='showhide(5)'><span class='sh_mark' id='sh_mark_5'>►</span> Features</a>
<ul id='sh_sub_5'>
<li><a class='sh_link' href='shortnames.html'>8+3 Filenames</a>
<span class='desktoponly'>→
How to make SQLite work on filesystems that only support
8+3 filenames.
</span>
<li><a class='sh_link' href='autoinc.html'>Autoincrement</a>
<span class='desktoponly'>→
A description of the AUTOINCREMENT keyword in SQLite, what it does,
why it is sometimes useful, and why it should be avoided if not
strictly necessary.
</span>
<li><a class='sh_link' href='backup.html'>Backup API</a>
<span class='desktoponly'>→
The [sqlite3_backup_init | online-backup interface] can be used to
copy content from a disk file into an in-memory database or vice
versa and it can make a hot backup of a live database. This application
note gives examples of how.
</span>
<li><a class='sh_link' href='errlog.html'>Error and Warning Log</a>
<span class='desktoponly'>→
SQLite supports an "error and warning log" design to capture information
about suspicious and/or error events during operation. Embedded applications
are encouraged to enable the error and warning log to help with debugging
application problems that arise in the field. This document explains how
to do that.
</span>
<li><a class='sh_link' href='foreignkeys.html'>Foreign Key Support</a>
<span class='desktoponly'>→
This document describes the support for foreign key constraints introduced
in version 3.6.19.
</span>
<li><a class='sh_link' href='expridx.html'>Indexes On Expressions</a>
<span class='desktoponly'>→
Notes on how to create indexes on expressions instead of just
individual columns.
</span>
<li><a class='sh_link' href='intern-v-extern-blob.html'>Internal versus External Blob Storage</a>
<span class='desktoponly'>→
Should you store large BLOBs directly in the database, or store them
in files and just record the filename in the database? This document
seeks to shed light on that question.
</span>
<li><a class='sh_link' href='limits.html'>Limits In SQLite</a>
<span class='desktoponly'>→
This document describes limitations of SQLite (the maximum length of a
string or blob, the maximum size of a database, the maximum number of
tables in a database, etc.) and how these limits can be altered at
compile-time and run-time.
</span>
<li><a class='sh_link' href='mmap.html'>Memory-Mapped I/O</a>
<span class='desktoponly'>→
SQLite supports memory-mapped I/O. Learn how to enable memory-mapped
I/O and about the various advantages and disadvantages to using
memory-mapped I/O in this document.
</span>
<li><a class='sh_link' href='threadsafe.html'>Multi-threaded Programs and SQLite</a>
<span class='desktoponly'>→
SQLite is safe to use in multi-threaded programs. This document
provides the details and hints on how to maximize performance.
</span>
<li><a class='sh_link' href='nulls.html'>Null Handling</a>
<span class='desktoponly'>→
Different SQL database engines handle NULLs in different ways. The
SQL standards are ambiguous. This (circa 2003) document describes
how SQLite handles NULLs in comparison with other SQL database engines.
</span>
<li><a class='sh_link' href='partialindex.html'>Partial Indexes</a>
<span class='desktoponly'>→
A partial index is an index that only covers a subset of the rows in
a table. Learn how to use partial indexes in SQLite from this document.
</span>
<li><a class='sh_link' href='sharedcache.html'>Shared Cache Mode</a>
<span class='desktoponly'>→
Version 3.3.0 and later supports the ability for two or more
database connections to share the same page and schema cache.
This feature is useful for certain specialized applications.
</span>
<li><a class='sh_link' href='unlock_notify.html'>Unlock Notify</a>
<span class='desktoponly'>→
The "unlock notify" feature can be used in conjunction with
[shared cache mode] to more efficiently manage resource conflict (database
table locks).
</span>
<li><a class='sh_link' href='uri.html'>URI Filenames</a>
<span class='desktoponly'>→
The names of database files can be specified using either an ordinary
filename or a URI. Using URI filenames provides additional capabilities,
as this document describes.
</span>
<li><a class='sh_link' href='withoutrowid.html'>WITHOUT ROWID Tables</a>
<span class='desktoponly'>→
The WITHOUT ROWID optimization is a option that can sometimes result
in smaller and faster databases.
</span>
<li><a class='sh_link' href='wal.html'>Write-Ahead Log (WAL) Mode</a>
<span class='desktoponly'>→
Transaction control using a write-ahead log offers more concurrency and
is often faster than the default rollback transactions. This document
explains how to use WAL mode for improved performance.
</span>
</ul>
<li><a onclick='showhide(6)'><span class='sh_mark' id='sh_mark_6'>►</span> Tools</a>
<ul id='sh_sub_6'>
<li><a class='sh_link' href='cli.html'>Command-Line Shell (sqlite3.exe)</a>
<span class='desktoponly'>→
Notes on using the "sqlite3.exe" command-line interface that
can be used to create, modify, and query arbitrary SQLite
database files.
</span>
<li><a class='sh_link' href='sqlanalyze.html'>SQLite Database Analyzer (sqlite3_analyzer.exe)</a>
<span class='desktoponly'>→
This stand-alone program reads an SQLite database and outputs a file
showing the space used by each table and index and other statistics.
Built using the [dbstat virtual table].
</span>
<li><a class='sh_link' href='rbu.html'>RBU</a>
<span class='desktoponly'>→
The "Resumable Bulk Update" utility program allows a batch of changes
to be applied to a remote database running on embedded hardware in a
way that is resumeable and does not interrupt ongoing operation.
</span>
<li><a class='sh_link' href='sqldiff.html'>SQLite Database Diff (sqldiff.exe)</a>
<span class='desktoponly'>→
This stand-alone program compares two SQLite database files and
outputs the SQL needed to convert one into the other.
</span>
<li><a class='sh_link' href='dbhash.html'>Database Hash (dbhash.exe)</a>
<span class='desktoponly'>→
This program demonstrates how to compute a hash over the content
of an SQLite database.
</span>
<li><a class='sh_link' href='http://www.fossil-scm.org/'>Fossil</a>
<span class='desktoponly'>→
The Fossil Version Control System is a distributed VCS designed specifically
to support SQLite development. Fossil uses SQLite as for storage.
</span>
<li><a class='sh_link' href='http://www.sqlite.org/sqlar/'>SQLite Archiver (sqlar.exe)</a>
<span class='desktoponly'>→
A ZIP-like archive program that uses SQLite for storage.
</span>
</ul>
<li><a onclick='showhide(7)'><span class='sh_mark' id='sh_mark_7'>►</span> Advocacy</a>
<ul id='sh_sub_7'>
<li><a class='sh_link' href='appfileformat.html'>SQLite As An Application File Format</a>
<span class='desktoponly'>→
This article advocates using SQLite as an application file format
in place of XML or JSON or a "pile-of-file".
</span>
<li><a class='sh_link' href='famous.html'>Well Known Users</a>
<span class='desktoponly'>→
This page lists a small subset of the many thousands of devices
and application programs that make use of SQLite.
</span>
<li><a class='sh_link' href='fasterthanfs.html'>35% Faster Than The Filesystem</a>
<span class='desktoponly'>→
This article points out that reading blobs out of an SQLite database
is often faster than reading the same blobs from individual files in
the filesystem.
</span>
</ul>
<li><a onclick='showhide(8)'><span class='sh_mark' id='sh_mark_8'>►</span> Technical and Design Documentation</a>
<ul id='sh_sub_8'>
<li><a class='sh_link' href='howtocorrupt.html'>How Database Corruption Can Occur</a>
<span class='desktoponly'>→
SQLite is highly resistant to database corruption. But application,
OS, and hardware bugs can still result in corrupt database files.
This article describes many of the ways that SQLite database files
can go corrupt.
</span>
<li><a class='sh_link' href='tempfiles.html'>Temporary Files Used By SQLite</a>
<span class='desktoponly'>→
SQLite can potentially use many different temporary files when
processing certain SQL statements. This document describes the
many kinds of temporary files that SQLite uses and offers suggestions
for avoiding them on systems where creating a temporary file is an
expensive operation.
</span>
<li><a class='sh_link' href='inmemorydb.html'>In-Memory Databases</a>
<span class='desktoponly'>→
SQLite normally stores content in a disk file. However, it can also
be used as an in-memory database engine. This document explains how.
</span>
<li><a class='sh_link' href='atomiccommit.html'>How SQLite Implements Atomic Commit</a>
<span class='desktoponly'>→
A description of the logic within SQLite that implements
transactions with atomic commit, even in the face of power
failures.
</span>
<li><a class='sh_link' href='malloc.html'>Dynamic Memory Allocation in SQLite</a>
<span class='desktoponly'>→
SQLite has a sophisticated memory allocation subsystem that can be
configured and customized to meet memory usage requirements of the
application and that is robust against out-of-memory conditions and
leak-free. This document provides the details.
</span>
<li><a class='sh_link' href='custombuild.html'>Customizing And Porting SQLite</a>
<span class='desktoponly'>→
This document explains how to customize the build of SQLite and
how to port SQLite to new platforms.
</span>
<li><a class='sh_link' href='lockingv3.html'>Locking And Concurrency<br>In SQLite Version 3</a>
<span class='desktoponly'>→
A description of how the new locking code in version 3 increases
concurrency and decreases the problem of writer starvation.
</span>
<li><a class='sh_link' href='isolation.html'>Isolation In SQLite</a>
<span class='desktoponly'>→
When we say that SQLite transactions are "serializable" what exactly
does that mean? How and when are changes made visible within the
same database connection and to other database connections?
</span>
<li><a class='sh_link' href='optoverview.html'>Overview Of The Optimizer</a>
<span class='desktoponly'>→
A quick overview of the various query optimizations that are
attempted by the SQLite code generator.
</span>
<li><a class='sh_link' href='queryplanner-ng.html'>The Next-Generation Query Planner</a>
<span class='desktoponly'>→
Additional information about the SQLite query planner, and in particular
the redesign of the query planner that occurred for version 3.8.0.
</span>
<li><a class='sh_link' href='arch.html'>Architecture</a>
<span class='desktoponly'>→
An architectural overview of the SQLite library, useful for those who want
to hack the code.
</span>
<li><a class='sh_link' href='opcode.html'>VDBE Opcodes</a>
<span class='desktoponly'>→
This document is an automatically generated description of the various
opcodes that the VDBE understands. Programmers can use this document as
a reference to better understand the output of EXPLAIN listings from
SQLite.
</span>
<li><a class='sh_link' href='vfs.html'>Virtual Filesystem</a>
<span class='desktoponly'>→
The "VFS" object is the interface between the SQLite core and the
underlying operating system. Learn more about how the VFS object
works and how to create new VFS objects from this article.
</span>
<li><a class='sh_link' href='vtab.html'>Virtual Tables</a>
<span class='desktoponly'>→
This article describes the virtual table mechanism and API in SQLite and how
it can be used to add new capabilities to the core SQLite library.
</span>
<li><a class='sh_link' href='fileformat2.html'>SQLite File Format</a>
<span class='desktoponly'>→
A description of the format used for SQLite database and journal files, and
other details required to create software to read and write SQLite
databases without using SQLite.
</span>
<li><a class='sh_link' href='compile.html'>Compilation Options</a>
<span class='desktoponly'>→
This document describes the compile time options that may be set to
modify the default behavior of the library or omit optional features
in order to reduce binary size.
</span>
<li><a class='sh_link' href='https://sqlite.org/android/'>Android Bindings for SQLite</a>
<span class='desktoponly'>→
A description of how to compile your own SQLite for Android
(bypassing the SQLite that is built into Android) together with
code and makefiles.
</span>
<li><a class='sh_link' href='debugging.html'>Debugging Hints</a>
<span class='desktoponly'>→
A list of tricks and techniques used to trace, examine, and understand
the operation of the core SQLite library.
</span>
</ul>
<li><a onclick='showhide(9)'><span class='sh_mark' id='sh_mark_9'>►</span> Upgrading SQLite, Backwards Compatibility</a>
<ul id='sh_sub_9'>
<li><a class='sh_link' href='35to36.html'>Moving From SQLite 3.5 to 3.6</a>
<span class='desktoponly'>→
A document describing the differences between SQLite version 3.5.9
and 3.6.0.
</span>
<li><a class='sh_link' href='34to35.html'>Moving From SQLite 3.4 to 3.5</a>
<span class='desktoponly'>→
A document describing the differences between SQLite version 3.4.2
and 3.5.0.
</span>
<li><a class='sh_link' href='changes.html'>Release History</a>
<span class='desktoponly'>→
A chronology of SQLite releases going back to version 1.0.0
</span>
<li><a class='sh_link' href='formatchng.html'>Backwards Compatibility</a>
<span class='desktoponly'>→
This document details all of the incompatible changes to the SQLite
file format that have occurred since version 1.0.0.
</span>
<li><a class='sh_link' href='privatebranch.html'>Private Branches</a>
<span class='desktoponly'>→
This document suggests procedures for maintaining a private branch
or fork of SQLite and keeping that branch or fork in sync with the
public SQLite source tree.
</span>
</ul>
<li><a onclick='showhide(10)'><span class='sh_mark' id='sh_mark_10'>►</span> Obsolete Documents</a>
<ul id='sh_sub_10'>
<li><a class='sh_link' href='asyncvfs.html'>Asynchronous IO Mode</a>
<span class='desktoponly'>→
This page describes the asynchronous IO extension developed alongside
SQLite. Using asynchronous IO can cause SQLite to appear more responsive
by delegating database writes to a background thread. <i>NB: This
extension is deprecated. [WAL mode] is recommended as a replacement.</i>
</span>
<li><a class='sh_link' href='c_interface.html'>Version 2 C/C++ API</a>
<span class='desktoponly'>→
A description of the C/C++ interface bindings for SQLite through version
2.8
</span>
<li><a class='sh_link' href='datatypes.html'>Version 2 DataTypes </a>
<span class='desktoponly'>→
A description of how SQLite version 2 handles SQL datatypes.
Short summary: Everything is a string.
</span>
<li><a class='sh_link' href='vdbe.html'>VDBE Tutorial</a>
<span class='desktoponly'>→
The VDBE is the subsystem within SQLite that does the actual work of
executing SQL statements. This page describes the principles of operation
for the VDBE in SQLite version 2.7. This is essential reading for anyone
who want to modify the SQLite sources.
</span>
<li><a class='sh_link' href='version3.html'>SQLite Version 3</a>
<span class='desktoponly'>→
A summary of the changes between SQLite version 2.8 and SQLite version 3.0.
</span>
<li><a class='sh_link' href='capi3.html'>Version 3 C/C++ API</a>
<span class='desktoponly'>→
A summary of the API related changes between SQLite version 2.8 and
SQLite version 3.0.
</span>
<li><a class='sh_link' href='speed.html'>Speed Comparison</a>
<span class='desktoponly'>→
The speed of version 2.7.6 of SQLite is compared against PostgreSQL and
MySQL.
</span>
</ul>
</ul>
<br clear="both">
|
