|
- SQLite is a software library that implements a
-self-contained,
-serverless,
-zero-configuration,
-transactional
+
+
+SQLite is a high-reliablity,
+[serverless|embedded], [zero-configuration], [public-domain],
SQL database engine.
-SQLite is the [most widely deployed]
-database engine in the world.
-The source code for SQLite is in the
-public domain.
-More...
-
-
-
-Sponsors
-Continuing enhancement and maintenance of SQLite is made possible
-by SQLite Consortium members, including:
-
-
-
-
+SQLite is the [most used] database engine in the world.
+More Info
+
+
+Latest Release:
+Version 3.14.1 on
+2016-08-11.
+Download
+Prior Releases
+
+
+
+Common Links
+common_links
+
+
+
+Sponsors
+Ongoing development and support of SQLite is made possible in part
+by SQLite Consortium members, including:
+
+
+
+"
-
-
-
- | | |
-
-Current Status
-
-
-- Version 3.14.1
-of SQLite is recommended for all new development.
-
-
-
-Common Links
-
-
-
- |
-
-
-
-source [file normalize [file join $::DOC pages footer.tcl]]
-
-
+ var h = "";
+ for(var i=0; i
+
+
+
Index: pages/json1.in
==================================================================
--- pages/json1.in
+++ pages/json1.in
@@ -4,52 +4,33 @@
Overview
The json1 extension is a [loadable extension] that
-implements thirteen [application-defined SQL functions] and
+implements fourteen [application-defined SQL functions] and
two [table-valued functions] that are useful for
managing [http://json.org/ | JSON] content stored in an SQLite database.
-These are the scalar SQL functions implemented by json1:
+Twelve of the fourteen SQL functions are scalar functions:
-
-
+
set tabcnt 0
proc tabentry {fx desc lnk} {
global tabcnt
incr tabcnt
- hd_puts "| $tabcnt. | "
- hd_puts "\n"
+ hd_puts "- \n"
set fx [string trim $fx]
set hlink ""
regsub -all {^json\(} $fx "${hlink}json(" fx
regsub -all {(json_[a-z_]+)} $fx "$hlink\\1" fx
regsub -all {(value[1-9]?|path|label[1-9]?)} $fx "\\1" fx
regsub -all {\((json)} $fx "(\\1" fx
- hd_puts $fx\n
- hd_puts "
| \n"
- hd_puts [string trim $desc]\n
- hd_puts " | \n\n"
+ hd_puts "$fx\n"
+ # hd_puts "[string trim $desc]\n"
+ hd_puts "\n\n"
}
set tsctr 100
-proc jexample {args} {
- hd_puts "\n"
- foreach {sql res} $args {
- ### uncomment to generate test cases from the examples
- # global tsctr
- # puts "do_execsql_test json102-$tsctr \173"
- # incr tsctr 10
- # puts " SELECT [string trim $sql];"
- # set x \173[string trim $res ']\175
- # puts "\175 \173$x\175"
- hd_puts "| [string trim $sql] | \n"
- hd_puts "→ | \n"
- hd_puts "[string trim $res] | \n"
- }
- hd_puts "
\n"
-}
tabentry {json(json)} {
Validate and minify a JSON string
} jmini
@@ -99,15 +80,15 @@
tabentry {json_quote(value)} {
Convert an SQL value (a number or a string) into its corresponding JSON
representation.
} jvalid
-
+
There are two aggregate SQL functions:
-
+
tabentry {json_group_array(value)} {
Return a JSON array composed of all value elements
in the aggregation.
} jgrouparray
@@ -115,15 +96,15 @@
tabentry {json_group_object(name,value)} {
Return a JSON object composed of all name and value pairs
in the aggregation.
} jgroupobject
-
+
-The [table-valued functions] implemented by this routine are:
+ The two [table-valued functions] are:
-
+
tabentry {json_each(json)
json_each(json,path)} {
Return one row describing each element in an array or object
at the top-level or at "path" within the input JSON.
} jeach
@@ -131,11 +112,36 @@
tabentry {json_tree(json)
json_tree(json,path)} {
Walk the JSON recursively starting at the top-level or at the
specified "path" and return one row for each element.
} jtree
-
+
+
+
+
+hd_puts {
+
+}
+proc jexample {args} {
+ hd_puts "\n"
+ foreach {sql res} $args {
+ ### uncomment to generate test cases from the examples
+ # global tsctr
+ # puts "do_execsql_test json102-$tsctr \173"
+ # incr tsctr 10
+ # puts " SELECT [string trim $sql];"
+ # set x \173[string trim $res ']\175
+ # puts "\175 \173$x\175"
+ hd_putsnl "- [string trim $sql]"
+ hd_putsnl "→ [string trim $res]
\n"
+ }
+ hd_puts " \n"
+}
+
hd_fragment howtocompile
Compiling the JSON1 Extension
@@ -250,11 +256,12 @@
Compatibility
The json1 extension uses the [sqlite3_value_subtype()] and
[sqlite3_result_subtype()] interfaces that were introduced with
-SQLite version 3.9.0. Therefore the json1 extension will not work
+SQLite version 3.9.0 (circa 2015-10-14).
+The json1 extension will not work
in earlier versions of SQLite.
Function Details
The following sections provide additional detail on the operation of
@@ -376,11 +383,11 @@
by updating the input JSON by the path/value pairs. The functions
differ only in how they deal with creating new values and overwriting
preexisting values.
-
+
| Function | Overwrite if already exists? | Create if does not exist?
|
| json_insert() | No | Yes
|
Index: pages/keyword_index.in
==================================================================
--- pages/keyword_index.in
+++ pages/keyword_index.in
@@ -1,19 +1,19 @@
Website Keyword Index
-Website Keyword Index
+Keyword Index
-
-| Other Documentation Indices:
+ |
+
-
+
hd_keywords {keyword index}
db eval {
UPDATE keyword SET indexKw=0
WHERE kw GLOB '*s' AND indexKw
Index: pages/lang.in
==================================================================
--- pages/lang.in
+++ pages/lang.in
@@ -55,27 +55,20 @@
{{aggregate functions} aggfunc aggfunc}
{{core functions} corefunc corefunc}
{{date and time functions} datefunc datefunc}
{keywords keywords {SQL keywords}}
}
- set lang_section_break [expr {([llength $lang_section_list]+2)/3}]
+ set lx {}
foreach {section} [lsort -index 0 -dictionary $lang_section_list] {
- foreach {s_title s_tag s_kw} $section {}
- if {$s_kw == ""} {
- set s_kw $s_title
- }
- if {$s_tag=="pragma.html"} {
- set url $s_tag
- } else {
- set url lang_$s_tag.html
- }
- hd_resolve "- \[$s_kw|$s_title\]
"
- incr i
- if {$i==$lang_section_break || $i==2*$lang_section_break} {
- hd_puts " "
- }
-}
+ foreach {s_title s_tag s_kw} $section {}
+ if {$s_kw == ""} {
+ set s_kw $s_title
+ }
+ lappend lx [list $s_kw $s_title 0]
+ }
+ # The output_list proc is implemented in capi3ref.in.
+ output_list {} 340 $lx
|
^The routines [sqlite3_prepare_v2()], [sqlite3_prepare()],
[sqlite3_prepare16()], [sqlite3_prepare16_v2()],
@@ -2327,43 +2320,16 @@
arguments is a simple function.
##############################################################################
Section {Core Functions} corefunc {*corefunc}
+unset -nocomplain corefuncset
proc funcdef {syntax keywords desc} {
- hd_puts {}
- regsub -all {\s+} [string trim $syntax] {
} syntax
- regsub -all {\(([^*)]+)\)} $syntax {(\1)} syntax
- regsub -all {,} $syntax {,} syntax
- regsub -all {\.\.\.} $syntax {...} syntax
- hd_puts ""
- if {[llength $keywords]==0} {
- regexp {[a-z_]+} $syntax name
- hd_fragment $name *$name "${name}() SQL function"
- } else {
- set fragname [lindex $keywords 0]
- regsub -all {[^a-z]} $fragname {} fragname
- hd_fragment $fragname
- eval hd_keywords [string map {\n { }} $keywords]
- }
- hd_puts "$syntax | "
- hd_puts {}
- hd_resolve $desc
- hd_puts { | }
-}
-
-
- The core functions shown below are available by default.
-[datefunc | Date & Time functions],
-[aggfunc | aggregate functions], and
-[json1 | JSON functions] are documented separately. An
-application may define additional
-functions written in C and added to the database engine using
-the [sqlite3_create_function()] API.
-
-
-
+ global corefuncset
+ regexp {^[a-z_]+} $syntax basesyntax
+ set corefuncset($basesyntax) [list $syntax $keywords $desc]
+}
funcdef {abs(X)} {} {
^The abs(X) function returns the absolute value of the numeric
argument X. ^Abs(X) returns NULL if X is NULL.
^(Abs(X) returns 0.0 if X is a string or blob
that cannot be converted to a numeric value.)^ ^If X is the
@@ -2718,13 +2684,53 @@
[sqlite3_blob_open() | incremental BLOB I/O].
^This SQL function is implemented using the [sqlite3_result_zeroblob()]
routine from the C/C++ interface.
}
-
+
+The core functions shown below are available by default.
+[datefunc | Date & Time functions],
+[aggfunc | aggregate functions], and
+[json1 | JSON functions] are documented separately. An
+application may define additional
+functions written in C and added to the database engine using
+the [sqlite3_create_function()] API.
+set lx {}
+foreach basesyntax [array names corefuncset] {
+ foreach {syntax keywords desc} $corefuncset($basesyntax) break
+ regexp {^[a-z_]+} $basesyntax fragment
+ foreach coresyntax $syntax {
+ lappend lx [list $fragment $coresyntax 0]
+ }
+}
+output_list {} 225 [lsort -index 1 $lx]
+
+hd_putsnl "
"
+hd_putsnl ""
+foreach basesyntax [lsort [array names corefuncset]] {
+ foreach {syntax keywords desc} $corefuncset($basesyntax) break
+ regsub -all {\s+} [string trim $syntax] {
} syntax
+ regsub -all {\(([^*)]+)\)} $syntax {(\1)} syntax
+ regsub -all {,} $syntax {,} syntax
+ regsub -all {\.\.\.} $syntax {...} syntax
+ regexp {^[a-z]+} $basesyntax fragment
+ if {[llength $keywords]==0} {
+ regexp {[a-z_]+} $syntax name
+ hd_fragment $name *$name "${name}() SQL function"
+ } else {
+ set fragname [lindex $keywords 0]
+ regsub -all {[^a-z]} $fragname {} fragname
+ hd_fragment $fragname
+ eval hd_keywords [string map {\n { }} $keywords]
+ }
+ hd_puts "$syntax $desc "
+
##############################################################################
Section {Date And Time Functions} datefunc {*datefunc {date and time functions}}
hd_keywords {date() SQL function} {time() SQL function}
hd_keywords {datetime() SQL function} {julianday() SQL function}
hd_keywords {strftime() SQL function}
@@ -3028,29 +3034,12 @@
day is exactly 86400 seconds in duration.
##############################################################################
Section {Aggregate Functions} aggfunc {*aggfunc}
-
-
-
-The aggregate functions shown below are available by default. Additional
-aggregate functions written in C may be added using the
-[sqlite3_create_function()]
-API.
-
-
-^In any aggregate function that takes a single argument, that argument
-can be preceded by the keyword DISTINCT. ^In such cases, duplicate
-elements are filtered before being passed into the aggregate function.
-^For example, the function "count(distinct X)" will return the number
-of distinct values of column X instead of the total number of non-null
-values in column X.
-
-
-
-
+unset -nocomplain corefuncset
+
funcdef {avg(X)} {*avg {avg() aggregate function}} {
^The avg() function
returns the average value of all non-NULL X within a
group. ^String and BLOB values that do not look like numbers are
interpreted as 0.
@@ -3122,13 +3111,61 @@
are integers or NULL
and an integer overflow occurs at any point during the computation.
^Total() never throws an integer overflow.
}
-
+
+
+
+The aggregate functions shown below are available by default. Additional
+aggregate functions written in C may be added using the
+[sqlite3_create_function()]
+API.
+
+
+^In any aggregate function that takes a single argument, that argument
+can be preceded by the keyword DISTINCT. ^In such cases, duplicate
+elements are filtered before being passed into the aggregate function.
+^For example, the function "count(distinct X)" will return the number
+of distinct values of column X instead of the total number of non-null
+values in column X.
+
+set lx {}
+foreach basesyntax [array names corefuncset] {
+ foreach {syntax keywords desc} $corefuncset($basesyntax) break
+ regexp {^[a-z_]+} $basesyntax fragment
+ foreach coresyntax $syntax {
+ lappend lx [list $fragment $coresyntax 0]
+ }
+}
+output_list {} 225 [lsort -index 1 $lx]
+
+hd_putsnl "
"
+hd_putsnl ""
+foreach basesyntax [lsort [array names corefuncset]] {
+ foreach {syntax keywords desc} $corefuncset($basesyntax) break
+ regsub -all {\s+} [string trim $syntax] {
} syntax
+ regsub -all {\(([^*)]+)\)} $syntax {(\1)} syntax
+ regsub -all {,} $syntax {,} syntax
+ regsub -all {\.\.\.} $syntax {...} syntax
+ regexp {^[a-z]+} $basesyntax fragment
+ if {[llength $keywords]==0} {
+ regexp {[a-z_]+} $syntax name
+ hd_fragment $name *$name "${name}() SQL function"
+ } else {
+ set fragname [lindex $keywords 0]
+ regsub -all {[^a-z]} $fragname {} fragname
+ hd_fragment $fragname
+ eval hd_keywords [string map {\n { }} $keywords]
+ }
+ hd_puts "$syntax $desc "
+
##############################################################################
Section INSERT insert {INSERT *INSERTs}
RecursiveBubbleDiagram insert-stmt
@@ -4852,24 +4889,16 @@
^(Regardless of the compile-time configuration, any identifier that is not on
the following hd_puts [llength $keyword_list] element
list is not a keyword to the SQL parser in SQLite:
+
+set lx {}
+foreach word $keyword_list {
+ lappend lx [list {} $word 0]
+}
+output_list {} 200 $lx
+
|
-set n [llength $keyword_list]
-set nCol 5
-set nRow [expr {($n+$nCol-1)/$nCol}]
-set i 0
-foreach word $keyword_list {
- if {$i==$nRow} {
- hd_puts " | "
- set i 1
- } else {
- incr i
- }
- hd_puts "$word
\n"
-}
-
- |
)^
Index: pages/mostdeployed.in
==================================================================
--- pages/mostdeployed.in
+++ pages/mostdeployed.in
@@ -1,7 +1,7 @@
Most Widely Deployed SQL Database Engine
-hd_keywords {most widely deployed}
+hd_keywords {most widely deployed} {most used} {most widely used}
Most Widely Deployed and Used Database Engine
SQLite is likely used more than all other database engines
combined. Billions and billions of copies
Index: pages/pragma.in
==================================================================
--- pages/pragma.in
+++ pages/pragma.in
@@ -1544,43 +1544,30 @@
statements.)^ ^Warning: misuse of this pragma can easily result in
a corrupt database file.
}
Section {List Of PRAGMAs} {toc} {{pragma list}}
-
-
-
-
-set allprag [lsort [array names PragmaRef]]
-set nprag [llength $allprag]
-set nrow [expr {($nprag+2)/3}]
-for {set i 0} {$i<$nprag} {incr i} {
- set prag [lindex $allprag $i]
+set lx {}
+foreach prag [array names PragmaRef] {
set ref $PragmaRef($prag)
if {[info exists PragmaLegacy($prag)]} {
- hd_puts "$prag¹\n"
- } elseif {[info exists PragmaDebug($prag)]} {
- hd_puts "- $prag²\n"
- } elseif {[info exists PragmaTest($prag)]} {
- hd_puts "
- $prag³\n"
- } else {
- hd_puts "
- $prag\n"
- }
- if {$i%$nrow==($nrow-1) && $i+1<$nprag} {
- hd_puts "
| |
-Notes:
-
-- Pragmas whose names are marked through in the list above
-are deprecated. They are not maintained. They continue to exist
-for historical compatibility only.
-Do not use the deprecated pragmas in new applications.
-Remove deprecated pragmas
-from existing applications at your earliest opportunity.
+ lappend lx [list "PRAGMA $ref" $prag 3]
+ } elseif {[info exists PragmaDebug($prag)]} {
+ lappend lx [list "PRAGMA $ref" $prag 4]
+ } elseif {[info exists PragmaTest($prag)]} {
+ lappend lx [list "PRAGMA $ref" $prag 5]
+ } else {
+ lappend lx [list "PRAGMA $ref" $prag 0]
+ }
+}
+output_list {} 250 [lsort -index 1 $lx]
+
+
Notes:
+
+- Pragmas whose names are
struck through
+are deprecated. Do not use them. They exist
+for historical compatibility.
- These pragmas are used for debugging SQLite and
are only available when SQLite is compiled using [SQLITE_DEBUG].
- These pragmas are used for testing SQLite and are not recommended
for use in application programs.
ADDED pages/prosupport.in
Index: pages/prosupport.in
==================================================================
--- /dev/null
+++ pages/prosupport.in
@@ -0,0 +1,275 @@
+SQLite Pro Support
+hd_keywords {professional support}
+
+
+Professional Support & Extension Products
+
+
+
+set entrylist {}
+proc support_entry {itemno title desc cost link1 link2} {
+ global entrylist
+ lappend entrylist $itemno $title $desc $cost $link1 $link2
+}
+proc generate_support_html {} {
+ global entrylist
+
+ hd_putsnl ""
+ hd_putsnl " "
+ foreach {itemno title desc cost link1 link2} $entrylist {
+ hd_puts "| $itemno. | "
+ hd_putsnl "$title. $desc | "
+ hd_putsnl "$cost | "
+ foreach {tag url} $link1 break
+ hd_puts ""
+ hd_putsnl "$tag
"
+ foreach {tag url} $link2 break
+ hd_putsnl "$tag | "
+ hd_putsnl " "
+ }
+ hd_putsnl " "
+ hd_putsnl " "
+ foreach {itemno title desc cost link1 link2} $entrylist {
+ hd_putsnl ""
+ hd_putsnl "$title. $desc"
+ hd_putsnl " Cost: $cost"
+ foreach {tag url} $link1 break
+ hd_putsnl " $tag"
+ foreach {tag url} $link2 break
+ hd_putsnl "$tag"
+ hd_putsnl " Further Information
+
+SQLite is free and works great.
+Most people use SQLite without
+any kind of license or support.
+
+Free support for SQLite is available on the public
+SQLite mailing list:
+sqlite-users@mailinglists.sqlite.org.
+The mailing list is monitored by a large
+community of experts, including the core SQLite development team,
+who are able to resolve just about
+any problems with SQLite that you are likely to have.
+
+You can browse the
+
+mailing list archives or
+
+sign-up as a mailing list member.
+To send a question to the mailing list, it is recommended that you
+
+sign-up, but you can simply send an email message to
+sqlite-users@mailinglists.sqlite.org and
+your question will probably appear on the mailing list in about 24 hours.
+(Questions from non-members are moderated, which is the reason for the
+24-hour delay.)
+
+ If you do not want to discuss your issues on a public and open forum, an
+Annual Maintenance
+Subscription or "AMS" might
+serve your needs better.
+An AMS entitles you to private email support directly from the developers of
+SQLite. The level of support with an AMS is similar to the support one
+gets from the public mail list except that an AMS includes a unilateral
+promise of non-disclosure, so with an AMS you can discuss your issues
+with the SQLite developers in private, without the whole world watching.
+An AMS costs $1500 per year.
+
+Users with more advanced support needs can opt for a
+Technical Support
+Agreement.
+Technical support agreements are customized to the needs of each
+individual client, but generally include direct telephone support
+and priority handling of issues and bugs. Guaranteed response time
+is available as an option. The cost of
+technical support varies but is generally
+in the range of $8000 to $35000 per year.
+
+If SQLite is "mission critical" to your company, then you may
+want to becoming an
+SQLite Consortium
+Member. The SQLite
+Consortium is a collaboration of companies who sponsor ongoing development
+of SQLite in exchange for enterprise-level technical support, on-site
+visits from the SQLite developers, unlimited access to all licensed
+products, and strong guarantees that SQLite will remain in the public
+domain, free and independent, and will not come under the control of
+a competitor. The cost of consortium membership is $75000 per year.
+
+
+Software Licenses
+
+The SQLite source code is in the
+public domain,
+and is free for use
+by anyone and for any purpose. No license is required. However, some
+users desire a license so that they can have warranty of title, or just
+because their company lawyers say they need one. A
+perpetual license
+and warranty
+of title for the core SQLite source code is available for this purpose.
+
+The
+SQLite Encryption
+Extension (SEE),
+the ZIPVFS Extension,
+and the Compressed and
+Encrypted ReadOnly Database (CEROD) extension are enhanced versions
+of SQLite that handle encrypted
+and/or compressed databases. SEE can read and write encrypted databases.
+SEE encrypts all database content, including metadata, so that the database
+file appears as white noise. ZIPVFS
+compresses the database on-the-fly using application-supplied
+compression and decompression functions.
+CEROD reads a compressed database that is
+also optionally encrypted. All of SEE, ZIPVFS, and CEROD are
+supplied in source code form only; the licensee is responsible for
+compiling the products for their chosen platform. It is not difficult
+to compile any of these extension. All products come in the form of an
+amalgamated source file
+named "sqlite3.c". So compiling SEE, ZIPVFS, or CEROD into an application
+is simply a matter of substituting the SEE-, ZIPVFS-, or CEROD-enabled sqlite3.c
+source file in place of the public-domain sqlite3.c source file and recompiling.
+Licenses for SEE, ZIPVFS, and CEROD are perpetual.
+All three extension can read and write ordinary,
+uncompressed and unencrypted database files.
+
+
+Testing Services
+
+The Test Harness #3 (TH3) is
+a suite of test cases for SQLite that provide 100% branch test coverage
+(and 100% modified condition/decision coverage) for the core SQLite in
+an as-deployed configuration using only published and documented interfaces.
+TH3 is designed for use with embedded devices, and is compatible with
+DO-178B. Every release of the public-domain SQLite is tested using TH3,
+and so all users benefit from the TH3 tests. But the TH3 tests are not
+themselves public. Hardware or system manufactures who want to have
+TH3 test run on their systems can negotiation a service agreement to have
+the SQLite Developers run those tests.
+
+About The SQLite Team
+
+Paid support options and products are provided by
+Hipp, Wyrick & Company, Inc., (Hwaci), a
+Georgia
+corporation
+with headquarters in
+
+Charlotte, North Carolina and has been in business since
+1992.
+Hwaci has an international team of
+employees and associates representing the best available talent.
+We are a 100% engineering company. There is
+no sales staff.
+Our goal is to provide outstanding service and honest advice
+without spin or sales-talk.
+
+Hwaci is a small company but it is
+also closely held and debt-free and has low
+fixed costs, which means that it is largely immune to buy-outs,
+take-overs, and market down-turns. Hwaci intends to
+continue operating in its current form, and at roughly its current
+size until at least the year 2050.
+We expect to be here when you need us,
+even if that need is many years in the future.
+ |
-
- 