Avoid an unnecessary branch when not using pre-update hooks.
[sqlite.git] / README.md
blobf70b512d41f0cae2d3e8cde634aae26c269f3db0
1 <h1 align="center">SQLite Source Repository</h1>
3 This repository contains the complete source code for the SQLite database
4 engine.  Some test scripts are also include.  However, many other test scripts
5 and most of the documentation are managed separately.
7 If you are reading this on a Git mirror someplace, you are doing it wrong.
8 The [official repository](https://www.sqlite.org/src/) is better.  Go there
9 now.
11 ## Obtaining The Code
13 SQLite sources are managed using the
14 [Fossil](https://www.fossil-scm.org/), a distributed version control system
15 that was specifically designed to support SQLite development.
16 If you do not want to use Fossil, you can download tarballs or ZIP
17 archives as follows:
19   *  Lastest trunk check-in:
20      <https://www.sqlite.org/src/tarball/sqlite.tar.gz> or
21      <https://www.sqlite.org/src/zip/sqlite.zip>.
23   *  Latest release:
24      <https://www.sqlite.org/src/tarball/sqlite.tar.gz?r=release> or
25      <https://www.sqlite.org/src/zip/sqlite.zip?r=release>.
27   *  For other check-ins, substitute an appropriate branch name or
28      tag or hash prefix for "release" in the URLs of the previous
29      bullet.  Or browse the [timeline](https://www.sqlite.org/src/timeline)
30      to locate the check-in desired, click on its information page link,
31      then click on the "Tarball" or "ZIP Archive" links on the information
32      page.
34 If you do want to use Fossil to check out the source tree, 
35 first install Fossil version 2.0 or later.
36 (Source tarballs and precompiled binaries available
37 [here](https://www.fossil-scm.org/fossil/uv/download.html).  Fossil is
38 a stand-alone program.  To install, simply download or build the single 
39 executable file and put that file someplace on your $PATH.)
40 Then run commands like this:
42         mkdir ~/sqlite
43         cd ~/sqlite
44         fossil clone https://www.sqlite.org/src sqlite.fossil
45         fossil open sqlite.fossil
46     
47 After setting up a repository using the steps above, you can always
48 update to the lastest version using:
50         fossil update trunk   ;# latest trunk check-in
51         fossil update release ;# latest official release
53 Or type "fossil ui" to get a web-based user interface.
55 ## Compiling
57 First create a directory in which to place
58 the build products.  It is recommended, but not required, that the
59 build directory be separate from the source directory.  Cd into the
60 build directory and then from the build directory run the configure
61 script found at the root of the source tree.  Then run "make".
63 For example:
65         tar xzf sqlite.tar.gz    ;#  Unpack the source tree into "sqlite"
66         mkdir bld                ;#  Build will occur in a sibling directory
67         cd bld                   ;#  Change to the build directory
68         ../sqlite/configure      ;#  Run the configure script
69         make                     ;#  Run the makefile.
70         make sqlite3.c           ;#  Build the "amalgamation" source file
71         make test                ;#  Run some tests (requires Tcl)
73 See the makefile for additional targets.
75 The configure script uses autoconf 2.61 and libtool.  If the configure
76 script does not work out for you, there is a generic makefile named
77 "Makefile.linux-gcc" in the top directory of the source tree that you
78 can copy and edit to suit your needs.  Comments on the generic makefile
79 show what changes are needed.
81 ## Using MSVC
83 On Windows, all applicable build products can be compiled with MSVC.
84 First open the command prompt window associated with the desired compiler
85 version (e.g. "Developer Command Prompt for VS2013").  Next, use NMAKE
86 with the provided "Makefile.msc" to build one of the supported targets.
88 For example:
90         mkdir bld
91         cd bld
92         nmake /f Makefile.msc TOP=..\sqlite
93         nmake /f Makefile.msc sqlite3.c TOP=..\sqlite
94         nmake /f Makefile.msc sqlite3.dll TOP=..\sqlite
95         nmake /f Makefile.msc sqlite3.exe TOP=..\sqlite
96         nmake /f Makefile.msc test TOP=..\sqlite
98 There are several build options that can be set via the NMAKE command
99 line.  For example, to build for WinRT, simply add "FOR_WINRT=1" argument
100 to the "sqlite3.dll" command line above.  When debugging into the SQLite
101 code, adding the "DEBUG=1" argument to one of the above command lines is
102 recommended.
104 SQLite does not require [Tcl](http://www.tcl.tk/) to run, but a Tcl installation
105 is required by the makefiles (including those for MSVC).  SQLite contains
106 a lot of generated code and Tcl is used to do much of that code generation.
107 The makefiles also require AWK.
109 ## Source Code Tour
111 Most of the core source files are in the **src/** subdirectory.  The
112 **src/** folder also contains files used to build the "testfixture" test
113 harness. The names of the source files used by "testfixture" all begin
114 with "test".
115 The **src/** also contains the "shell.c" file
116 which is the main program for the "sqlite3.exe"
117 [command-line shell](https://sqlite.org/cli.html) and
118 the "tclsqlite.c" file which implements the
119 [TCL bindings](https://sqlite.org/tclsqlite.html) for SQLite.
120 (Historical note:  SQLite began as a Tcl
121 extension and only later escaped to the wild as an independent library.)
123 Test scripts and programs are found in the **test/** subdirectory.
124 Addtional test code is found in other source repositories.
125 See [How SQLite Is Tested](http://www.sqlite.org/testing.html) for
126 additional information.
128 The **ext/** subdirectory contains code for extensions.  The
129 Full-text search engine is in **ext/fts3**.  The R-Tree engine is in
130 **ext/rtree**.  The **ext/misc** subdirectory contains a number of
131 smaller, single-file extensions, such as a REGEXP operator.
133 The **tool/** subdirectory contains various scripts and programs used
134 for building generated source code files or for testing or for generating
135 accessory programs such as "sqlite3_analyzer(.exe)".
137 ### Generated Source Code Files
139 Several of the C-language source files used by SQLite are generated from
140 other sources rather than being typed in manually by a programmer.  This
141 section will summarize those automatically-generated files.  To create all
142 of the automatically-generated files, simply run "make target&#95;source".
143 The "target&#95;source" make target will create a subdirectory "tsrc/" and
144 fill it with all the source files needed to build SQLite, both
145 manually-edited files and automatically-generated files.
147 The SQLite interface is defined by the **sqlite3.h** header file, which is
148 generated from src/sqlite.h.in, ./manifest.uuid, and ./VERSION.  The
149 [Tcl script](http://www.tcl.tk) at tool/mksqlite3h.tcl does the conversion.
150 The manifest.uuid file contains the SHA3 hash of the particular check-in
151 and is used to generate the SQLITE\_SOURCE\_ID macro.  The VERSION file
152 contains the current SQLite version number.  The sqlite3.h header is really
153 just a copy of src/sqlite.h.in with the source-id and version number inserted
154 at just the right spots. Note that comment text in the sqlite3.h file is
155 used to generate much of the SQLite API documentation.  The Tcl scripts
156 used to generate that documentation are in a separate source repository.
158 The SQL language parser is **parse.c** which is generate from a grammar in
159 the src/parse.y file.  The conversion of "parse.y" into "parse.c" is done
160 by the [lemon](./doc/lemon.html) LALR(1) parser generator.  The source code
161 for lemon is at tool/lemon.c.  Lemon uses the tool/lempar.c file as a
162 template for generating its parser.
164 Lemon also generates the **parse.h** header file, at the same time it
165 generates parse.c. But the parse.h header file is
166 modified further (to add additional symbols) using the ./addopcodes.awk
167 AWK script.
169 The **opcodes.h** header file contains macros that define the numbers
170 corresponding to opcodes in the "VDBE" virtual machine.  The opcodes.h
171 file is generated by the scanning the src/vdbe.c source file.  The
172 AWK script at ./mkopcodeh.awk does this scan and generates opcodes.h.
173 A second AWK script, ./mkopcodec.awk, then scans opcodes.h to generate
174 the **opcodes.c** source file, which contains a reverse mapping from
175 opcode-number to opcode-name that is used for EXPLAIN output.
177 The **keywordhash.h** header file contains the definition of a hash table
178 that maps SQL language keywords (ex: "CREATE", "SELECT", "INDEX", etc.) into
179 the numeric codes used by the parse.c parser.  The keywordhash.h file is
180 generated by a C-language program at tool mkkeywordhash.c.
182 The **pragma.h** header file contains various definitions used to parse
183 and implement the PRAGMA statements.  The header is generated by a
184 script **tool/mkpragmatab.tcl**. If you want to add a new PRAGMA, edit
185 the **tool/mkpragmatab.tcl** file to insert the information needed by the
186 parser for your new PRAGMA, then run the script to regenerate the
187 **pragma.h** header file.
189 ### The Amalgamation
191 All of the individual C source code and header files (both manually-edited
192 and automatically-generated) can be combined into a single big source file
193 **sqlite3.c** called "the amalgamation".  The amalgamation is the recommended
194 way of using SQLite in a larger application.  Combining all individual
195 source code files into a single big source code file allows the C compiler
196 to perform more cross-procedure analysis and generate better code.  SQLite
197 runs about 5% faster when compiled from the amalgamation versus when compiled
198 from individual source files.
200 The amalgamation is generated from the tool/mksqlite3c.tcl Tcl script.
201 First, all of the individual source files must be gathered into the tsrc/
202 subdirectory (using the equivalent of "make target_source") then the
203 tool/mksqlite3c.tcl script is run to copy them all together in just the
204 right order while resolving internal "#include" references.
206 The amalgamation source file is more than 200K lines long.  Some symbolic
207 debuggers (most notably MSVC) are unable to deal with files longer than 64K
208 lines.  To work around this, a separate Tcl script, tool/split-sqlite3c.tcl,
209 can be run on the amalgamation to break it up into a single small C file
210 called **sqlite3-all.c** that does #include on about seven other files
211 named **sqlite3-1.c**, **sqlite3-2.c**, ..., **sqlite3-7.c**.  In this way,
212 all of the source code is contained within a single translation unit so
213 that the compiler can do extra cross-procedure optimization, but no
214 individual source file exceeds 32K lines in length.
216 ## How It All Fits Together
218 SQLite is modular in design.
219 See the [architectural description](http://www.sqlite.org/arch.html)
220 for details. Other documents that are useful in
221 (helping to understand how SQLite works include the
222 [file format](http://www.sqlite.org/fileformat2.html) description,
223 the [virtual machine](http://www.sqlite.org/opcode.html) that runs
224 prepared statements, the description of
225 [how transactions work](http://www.sqlite.org/atomiccommit.html), and
226 the [overview of the query planner](http://www.sqlite.org/optoverview.html).
228 Years of effort have gone into optimizating SQLite, both
229 for small size and high performance.  And optimizations tend to result in
230 complex code.  So there is a lot of complexity in the current SQLite
231 implementation.  It will not be the easiest library in the world to hack.
233 Key files:
235   *  **sqlite.h.in** - This file defines the public interface to the SQLite
236      library.  Readers will need to be familiar with this interface before
237      trying to understand how the library works internally.
239   *  **sqliteInt.h** - this header file defines many of the data objects
240      used internally by SQLite.  In addition to "sqliteInt.h", some
241      subsystems have their own header files.
243   *  **parse.y** - This file describes the LALR(1) grammar that SQLite uses
244      to parse SQL statements, and the actions that are taken at each step
245      in the parsing process.
247   *  **vdbe.c** - This file implements the virtual machine that runs
248      prepared statements.  There are various helper files whose names
249      begin with "vdbe".  The VDBE has access to the vdbeInt.h header file
250      which defines internal data objects.  The rest of SQLite interacts
251      with the VDBE through an interface defined by vdbe.h.
253   *  **where.c** - This file (together with its helper files named
254      by "where*.c") analyzes the WHERE clause and generates
255      virtual machine code to run queries efficiently.  This file is
256      sometimes called the "query optimizer".  It has its own private
257      header file, whereInt.h, that defines data objects used internally.
259   *  **btree.c** - This file contains the implementation of the B-Tree
260      storage engine used by SQLite.  The interface to the rest of the system
261      is defined by "btree.h".  The "btreeInt.h" header defines objects
262      used internally by btree.c and not published to the rest of the system.
264   *  **pager.c** - This file contains the "pager" implementation, the
265      module that implements transactions.  The "pager.h" header file
266      defines the interface between pager.c and the rest of the system.
268   *  **os_unix.c** and **os_win.c** - These two files implement the interface
269      between SQLite and the underlying operating system using the run-time
270      pluggable VFS interface.
272   *  **shell.c.in** - This file is not part of the core SQLite library.  This
273      is the file that, when linked against sqlite3.a, generates the
274      "sqlite3.exe" command-line shell.  The "shell.c.in" file is transformed
275      into "shell.c" as part of the build process.
277   *  **tclsqlite.c** - This file implements the Tcl bindings for SQLite.  It
278      is not part of the core SQLite library.  But as most of the tests in this
279      repository are written in Tcl, the Tcl language bindings are important.
281   *  **test*.c** - Files in the src/ folder that begin with "test" go into
282      building the "testfixture.exe" program.  The testfixture.exe program is
283      an enhanced TCL shell.  The testfixture.exe program runs scripts in the
284      test/ folder to validate the core SQLite code.  The testfixture program
285      (and some other test programs too) is build and run when you type
286      "make test".
288   *  **ext/misc/json1.c** - This file implements the various JSON functions
289      that are build into SQLite.
291 There are many other source files.  Each has a succinct header comment that
292 describes its purpose and role within the larger system.
295 ## Contacts
297 The main SQLite webpage is [http://www.sqlite.org/](http://www.sqlite.org/)
298 with geographically distributed backups at
299 [http://www2.sqlite.org/](http://www2.sqlite.org) and
300 [http://www3.sqlite.org/](http://www3.sqlite.org).