SQLite Supply Repository
This repository comprises the entire supply code for the
SQLite database engine. Some take a look at scripts
are additionally included. Nevertheless, many different take a look at scripts
and a lot of the documentation are managed individually.
SQLite sources are managed utilizing the
Fossil, a distributed model management system
that was particularly designed and written to assist SQLite growth.
The Fossil repository comprises the urtext.
If you’re studying this on GitHub or another Git repository or service,
then you’re looking at a mirror. The names of check-ins and
different artifacts in a Git mirror are completely different from the official
names for these objects. The offical names for check-ins are
present in a footer on the check-in remark for approved mirrors.
The official check-in title will also be seen within the
within the root of the tree. All the time use the official title, not the
Git-name, when speaking about an SQLite check-in.
Should you pulled your SQLite supply code from a secondary supply and wish to
confirm its integrity, there are hints on how to do this within the
Verifying Code Authenticity part under.
Acquiring The Code
If you don’t want to make use of Fossil, you’ll be able to obtain tarballs or ZIP
archives or SQLite archives as follows:
Lastest trunk check-in as
Newest launch as
For different check-ins, substitute an applicable department title or
tag or hash prefix instead of “release” within the URLs of the earlier
bullet. Or browse the timeline
to find the check-in desired, click on on its info web page hyperlink,
then click on on the “Tarball” or “ZIP Archive” hyperlinks on the knowledge
Should you do wish to use Fossil to take a look at the supply tree,
first set up Fossil model 2.0 or later.
(Supply tarballs and precompiled binaries accessible
right here. Fossil is
a stand-alone program. To put in, merely obtain or construct the one
executable file and put that file someplace in your $PATH.)
Then run instructions like this:
mkdir -p ~/sqlite ~/Fossils cd ~/sqlite fossil clone https://www.sqlite.org/src ~/Fossils/sqlite.fossil fossil open ~/Fossils/sqlite.fossil
After establishing a repository utilizing the steps above, you’ll be able to all the time
replace to the lastest model utilizing:
fossil replace trunk ;# newest trunk check-in fossil replace launch ;# newest official launch
Or sort “fossil ui” to get a web-based consumer interface.
First create a listing through which to put
the construct merchandise. It’s endorsed, however not required, that the
construct listing be separate from the supply listing. Cd into the
construct listing after which from the construct listing run the configure
script discovered on the root of the supply tree. Then run “make”.
tar xzf sqlite.tar.gz ;# Unpack the supply tree into "sqlite" mkdir bld ;# Construct will happen in a sibling listing cd bld ;# Change to the construct listing ../sqlite/configure ;# Run the configure script make ;# Run the makefile. make sqlite3.c ;# Construct the "amalgamation" supply file make take a look at ;# Run some exams (requires Tcl)
See the makefile for extra targets.
The configure script makes use of autoconf 2.61 and libtool. If the configure
script doesn’t work out for you, there’s a generic makefile named
“Makefile.linux-gcc” within the prime listing of the supply tree that you just
can copy and edit to fit your wants. Feedback on the generic makefile
present what modifications are wanted.
On Home windows, all relevant construct merchandise could be compiled with MSVC.
First open the command immediate window related to the specified compiler
model (e.g. “Developer Command Prompt for VS2013”). Subsequent, use NMAKE
with the offered “Makefile.msc” to construct one of many supported targets.
mkdir bld cd bld nmake /f Makefile.msc TOP=..sqlite nmake /f Makefile.msc sqlite3.c TOP=..sqlite nmake /f Makefile.msc sqlite3.dll TOP=..sqlite nmake /f Makefile.msc sqlite3.exe TOP=..sqlite nmake /f Makefile.msc take a look at TOP=..sqlite
There are a number of construct choices that may be set by way of the NMAKE command
line. For instance, to construct for WinRT, merely add “FOR_WINRT=1” argument
to the “sqlite3.dll” command line above. When debugging into the SQLite
code, including the “DEBUG=1” argument to one of many above command traces is
SQLite doesn’t require Tcl to run, however a Tcl set up
is required by the makefiles (together with these for MSVC). SQLite comprises
plenty of generated code and Tcl is used to do a lot of that code technology.
Supply Code Tour
A lot of the core supply information are within the src/ subdirectory. The
src/ folder additionally comprises information used to construct the “testfixture” take a look at
harness. The names of the supply information utilized by “testfixture” all start
The src/ additionally comprises the “shell.c” file
which is the primary program for the “sqlite3.exe”
command-line shell and
the “tclsqlite.c” file which implements the
Tcl bindings for SQLite.
(Historic notice: SQLite started as a Tcl
extension and solely later escaped to the wild as an unbiased library.)
Take a look at scripts and packages are discovered within the take a look at/ subdirectory.
Addtional take a look at code is present in different supply repositories.
See How SQLite Is Examined for
The ext/ subdirectory comprises code for extensions. The
Full-text search engine is in ext/fts3. The R-Tree engine is in
ext/rtree. The ext/misc subdirectory comprises numerous
smaller, single-file extensions, reminiscent of a REGEXP operator.
The instrument/ subdirectory comprises varied scripts and packages used
for constructing generated supply code information or for testing or for producing
accent packages reminiscent of “sqlite3_analyzer(.exe)”.
Generated Supply Code Recordsdata
A number of of the C-language supply information utilized by SQLite are generated from
different sources quite than being typed in manually by a programmer. This
part will summarize these automatically-generated information. To create all
of the automatically-generated information, merely run “make target_source”.
The “target_source” make goal will create a subdirectory “tsrc/” and
fill it with all of the supply information wanted to construct SQLite, each
manually-edited information and automatically-generated information.
The SQLite interface is outlined by the sqlite3.h header file, which is
generated from src/sqlite.h.in, ./manifest.uuid, and ./VERSION. The
Tcl script at instrument/mksqlite3h.tcl does the conversion.
The manifest.uuid file comprises the SHA3 hash of the actual check-in
and is used to generate the SQLITE_SOURCE_ID macro. The VERSION file
comprises the present SQLite model quantity. The sqlite3.h header is absolutely
only a copy of src/sqlite.h.in with the source-id and model quantity inserted
at simply the correct spots. Be aware that remark textual content within the sqlite3.h file is
used to generate a lot of the SQLite API documentation. The Tcl scripts
used to generate that documentation are in a separate supply repository.
The SQL language parser is parse.c which is generate from a grammar in
the src/parse.y file. The conversion of “parse.y” into “parse.c” is finished
by the [lemon](./doc/lemon.html) LALR(1) parser generator. The supply code
for lemon is at instrument/lemon.c. Lemon makes use of the instrument/lempar.c file as a
template for producing its parser.
Lemon additionally generates the parse.h header file, on the identical time it
The opcodes.h header file comprises macros that outline the numbers
equivalent to opcodes within the “VDBE” digital machine. The opcodes.h
file is generated by the scanning the src/vdbe.c supply file. The
Tcl script at ./mkopcodeh.tcl does this scan and generates opcodes.h.
A second Tcl script, ./mkopcodec.tcl, then scans opcodes.h to generate
the opcodes.c supply file, which comprises a reverse mapping from
opcode-number to opcode-name that’s used for EXPLAIN output.
The keywordhash.h header file comprises the definition of a hash desk
that maps SQL language key phrases (ex: “CREATE”, “SELECT”, “INDEX”, and so forth.) into
the numeric codes utilized by the parse.c parser. The keywordhash.h file is
generated by a C-language program at instrument mkkeywordhash.c.
The pragma.h header file comprises varied definitions used to parse
and implement the PRAGMA statements. The header is generated by a
script instrument/mkpragmatab.tcl. If you wish to add a brand new PRAGMA, edit
the instrument/mkpragmatab.tcl file to insert the knowledge wanted by the
parser on your new PRAGMA, then run the script to regenerate the
pragma.h header file.
All the particular person C supply code and header information (each manually-edited
and automatically-generated) could be mixed right into a single large supply file
sqlite3.c referred to as “the amalgamation”. The amalgamation is the really useful
means of utilizing SQLite in a bigger software. Combining all particular person
supply code information right into a single large supply code file permits the C compiler
to carry out extra cross-procedure evaluation and generate higher code. SQLite
runs about 5% sooner when compiled from the amalgamation versus when compiled
from particular person supply information.
The amalgamation is generated from the instrument/mksqlite3c.tcl Tcl script.
First, the entire particular person supply information have to be gathered into the tsrc/
subdirectory (utilizing the equal of “make target_source”) then the
instrument/mksqlite3c.tcl script is run to repeat all of them collectively in simply the
proper order whereas resolving inner “#include” references.
The amalgamation supply file is greater than 200K traces lengthy. Some symbolic
debuggers (most notably MSVC) are unable to take care of information longer than 64K
traces. To work round this, a separate Tcl script, instrument/split-sqlite3c.tcl,
could be run on the amalgamation to interrupt it up right into a single small C file
referred to as sqlite3-all.c that does #embrace on about seven different information
named sqlite3-1.c, sqlite3-2.c, …, sqlite3-7.c. On this means,
the entire supply code is contained inside a single translation unit so
that the compiler can do additional cross-procedure optimization, however no
particular person supply file exceeds 32K traces in size.
How It All Matches Collectively
SQLite is modular in design.
See the architectural description
for particulars. Different paperwork which can be helpful in
(serving to to know how SQLite works embrace the
file format description,
the digital machine that runs
ready statements, the outline of
how transactions work, and
the overview of the question planner.
Years of effort have gone into optimizating SQLite, each
for small dimension and excessive efficiency. And optimizations are likely to end in
advanced code. So there’s plenty of complexity within the present SQLite
implementation. It won’t be the simplest library on the earth to hack.
sqlite.h.in – This file defines the general public interface to the SQLite
library. Readers will should be acquainted with this interface earlier than
attempting to know how the library works internally.
sqliteInt.h – this header file defines most of the information objects
used internally by SQLite. Along with “sqliteInt.h”, some
subsystems have their very own header information.
parse.y – This file describes the LALR(1) grammar that SQLite makes use of
to parse SQL statements, and the actions which can be taken at every step
within the parsing course of.
vdbe.c – This file implements the digital machine that runs
ready statements. There are numerous helper information whose names
start with “vdbe”. The VDBE has entry to the vdbeInt.h header file
which defines inner information objects. The remainder of SQLite interacts
with the VDBE by means of an interface outlined by vdbe.h.
the place.c – This file (along with its helper information named
by “where*.c”) analyzes the WHERE clause and generates
digital machine code to run queries effectively. This file is
typically referred to as the “query optimizer”. It has its personal personal
header file, whereInt.h, that defines information objects used internally.
btree.c – This file comprises the implementation of the B-Tree
storage engine utilized by SQLite. The interface to the remainder of the system
is outlined by “btree.h”. The “btreeInt.h” header defines objects
used internally by btree.c and never printed to the remainder of the system.
pager.c – This file comprises the “pager” implementation, the
module that implements transactions. The “pager.h” header file
defines the interface between pager.c and the remainder of the system.
os_unix.c and os_win.c – These two information implement the interface
between SQLite and the underlying working system utilizing the run-time
pluggable VFS interface.
shell.c.in – This file just isn’t a part of the core SQLite library. This
is the file that, when linked towards sqlite3.a, generates the
“sqlite3.exe” command-line shell. The “shell.c.in” file is reworked
into “shell.c” as a part of the construct course of.
tclsqlite.c – This file implements the Tcl bindings for SQLite. It
just isn’t a part of the core SQLite library. However as a lot of the exams on this
repository are written in Tcl, the Tcl language bindings are vital.
take a look at*.c – Recordsdata within the src/ folder that start with “test” go into
constructing the “testfixture.exe” program. The testfixture.exe program is
an enhanced Tcl shell. The testfixture.exe program runs scripts within the
take a look at/ folder to validate the core SQLite code. The testfixture program
(and another take a look at packages too) is construct and run once you sort
ext/misc/json1.c – This file implements the assorted JSON features
which can be construct into SQLite.
There are various different supply information. Every has a succinct header remark that
describes its goal and position inside the bigger system.
Verifying Code Authenticity
manifest file on the root listing of the supply tree
comprises both a SHA3-256 hash (for newer information) or a SHA1 hash (for
older information) for each supply file within the repository.
The SHA3-256 hash of the
file itself is the official title of the model of the supply tree that you just
manifest.uuid file ought to include the SHA3-256 hash of the
manifest file. If the entire above hash comparisons are right, then
you could be assured that your supply tree is genuine and unadulterated.
The format of the
manifest file must be largely self-explanatory, however
if you would like particulars, they’re accessible
The principle SQLite web site is http://www.sqlite.org/
with geographically distributed backups at