-C New\slinks\son\sthe\scommon\sheader\spage\sof\sthe\swebsite.\s(CVS\s2013)
-D 2004-10-09T15:54:33
+C Typos\sand\sspelling\serrors\sin\sdocumention.\s(CVS\s2014)
+D 2004-10-10T17:24:54
F Makefile.in 52c1cc106cad9148d4b7cb387b458e82dc86b339
F Makefile.linux-gcc a9e5a0d309fa7c38e7c14d3ecf7690879d3a5457
F README f1de682fbbd94899d50aca13d387d1b3fd3be2dd
F www/arch.fig d5f9752a4dbf242e9cfffffd3f5762b6c63b3bcf
F www/arch.gif f845a64772062e82d17980a349f95f1f0b4c8054
F www/arch.png 82ef36db1143828a7abc88b1e308a5f55d4336f4
-F www/arch.tcl 126611ffd57e0dfac28d71ab04d7a78697ab4b80
+F www/arch.tcl 03a6c66b1b34209d2897352e058377b421f0b80e
F www/arch2.fig ae2432145c26cfa148fa0116589517ad3cd5fc65
F www/arch2.gif 6f2d47c4e0c5842c0d6b5513fd8249393d7c7003
F www/arch2b.fig d22a2c9642d584b89d4088b1e51e2bb0f7c04bed
F www/audit.tcl 90e09d580f79c7efec0c7d6f447b7ec5c2dce5c0
F www/c_interface.tcl 83b39203e1ded4c2dab97f42edf31279a308efcb
F www/capi3.tcl 5c1cb163f4d2a54e2d0e22dcc399dd71245c8b89
-F www/capi3ref.tcl 3d34b40270f126a98d09c3613ab31f609c47c79b
-F www/changes.tcl 16a490bbe5520705861abf36387a5e6b8c18456a
+F www/capi3ref.tcl aa8b12a1c633c5aaca03657e8ed04c963cb698c6
+F www/changes.tcl 9450fb133517433442bf7c6395537a55f7ec957f
F www/common.tcl 2ea19d725e67bac2cd0fb67c375ae9ce1d4b3e5b
-F www/conflict.tcl fb8a2ba83746c7fdfd9e52fa7f6aaf5c422b8246
+F www/conflict.tcl cdd0f4b59b0ba6d61f67e6a38f3ae45853bacb30
F www/copyright-release.html 294e011760c439c44951a6bfecd4c81a1ae359e8
F www/copyright-release.pdf cfca3558fc97095e57c6117d08f1f5b80d95125a
F www/copyright.tcl 82c9670c7ddb0311912ab7fe24703f33c531066c
-F www/datatype3.tcl 2bb7dbfa4dd518a6e5fb3cb1cd8296797976d205
-F www/datatypes.tcl 566004b81c36877397ddbe6e1907aae6065f6b41
+F www/datatype3.tcl dea659d2dcc1f3d6eefdb8a2f52c04de3cdb6476
+F www/datatypes.tcl 7c786d2e8ff434346764534ec015966d17efce60
F www/docs.tcl 4b5f7fca464e66ed7f929063a8b2b9e101ba902d
-F www/download.tcl 958931d67680a2ff7044d5ed77ced1825a2a8c63
+F www/download.tcl e9cebc67ac35c9c026b94ec01383ab8a7cf367f0
F www/dynload.tcl 02eb8273aa78cfa9070dd4501dca937fb22b466c
-F www/faq.tcl 8cf9f59fd93868c9954223a99db244c9975fa43b
-F www/fileformat.tcl f71a06a0d533c7df408539c64113b4adeaf29764
-F www/formatchng.tcl d1dfecedfb25e122ab513a1e0948b15cb4f0be46
+F www/faq.tcl bce6f03a9d00366e7f9eba9174167930b9f1b4ad
+F www/fileformat.tcl 900c95b9633abc3dcfc384d9ddd8eb4876793059
+F www/formatchng.tcl bfbf14dbf5181e771d06da7797767b0200b36d8a
F www/index.tcl ae29ea8a5bdde5a8031a9ac0935ac16dd921b4ef
-F www/lang.tcl dde78c1415ee2d19fc30360808ca6f0e2ea71c30
+F www/lang.tcl ba4fbca6342938f0240efdd84e83d5badcd72667
F www/lockingv3.tcl afcd22f0f063989cff2f4d57bbc38d719b4c6e75
F www/mingw.tcl d96b451568c5d28545fefe0c80bee3431c73f69c
-F www/nulls.tcl ede975a29def48838c606d4a0c0185d44f90a789
-F www/oldnews.tcl 6566f0a25fa6244ec68d0cf8cc5af2318c6bba1e
+F www/nulls.tcl ec35193f92485b87b90a994a01d0171b58823fcf
+F www/oldnews.tcl 6e8d41458e591de980fb29659c0d80b721be2aff
F www/omitted.tcl 7bd62b6f0f53b60c5360895b16b3af8407bbca03
-F www/opcode.tcl e8c421fd2c70c503b25cedb3f9617a1f387ac7ea
+F www/opcode.tcl dafa030a5a3cc24a2f9fd4cfbfb7d7323d2151b0
F www/quickstart.tcl 2ed129615479870b9f1f8b1527f21ebfcfb71e76
-F www/speed.tcl 19cf0c1bf73c4b534dfafc95b3eacff4825740b4
+F www/speed.tcl de99c82c4729a10b6733463636f15473c4ec95bc
F www/sqlite.tcl b51fd15f0531a54874de785a9efba323eecd5975
F www/support.tcl 96c8324cea27b5ded53ff5c60c127ba2053f688e
F www/tclsqlite.tcl 560ecd6a916b320e59f2917317398f3d59b7cc25
F www/vdbe.tcl 59288db1ac5c0616296b26dce071c36cb611dfe9
F www/version3.tcl 092a01f5ef430d2c4acc0ae558d74c4bb89638a0
-F www/whentouse.tcl a8335bce47cc2fddb07f19052cb0cb4d9129a8e4
-P 3d04eef9b7decd21acc30d47af1bb1386333c351
-R 5b6e3a4730a036c9637fe30fe0a20361
+F www/whentouse.tcl fdacb0ba2d39831e8a6240d05a490026ad4c4e4c
+P 6d6246f150f27042b8ede0fe73ecca1aefd2c3e4
+R 88d9ee15725dd536964fb7018cab9c17
U drh
-Z 28d561798961c31e6211cf6a4a66c43a
+Z fed8782376658a7d3a3b9ac3e74ac16d
-6d6246f150f27042b8ede0fe73ecca1aefd2c3e4
\ No newline at end of file
+16e2ace2db5c051aefe7f72504ad6c1cc5e7a0f4
\ No newline at end of file
#
# Run this Tcl script to generate the sqlite.html file.
#
-set rcsid {$Id: arch.tcl,v 1.15 2004/09/08 13:06:21 drh Exp $}
+set rcsid {$Id: arch.tcl,v 1.16 2004/10/10 17:24:54 drh Exp $}
source common.tcl
header {Architecture of SQLite}
puts {
<p>The B-tree module requests information from the disk in fixed-size
chunks. The default chunk size is 1024 bytes but can vary between 512
and 65536 bytes.
-The page cache is reponsible for reading, writing, and
+The page cache is responsible for reading, writing, and
caching these chunks.
The page cache also provides the rollback and atomic commit abstraction
and takes care of locking of the database file. The
-set rcsid {$Id: capi3ref.tcl,v 1.13 2004/09/30 13:43:14 drh Exp $}
+set rcsid {$Id: capi3ref.tcl,v 1.14 2004/10/10 17:24:54 drh Exp $}
source common.tcl
header {C/C++ Interface For SQLite Version 3}
puts {
#define SQLITE_EMPTY 16 /* (Internal Only) Database table is empty */
#define SQLITE_SCHEMA 17 /* The database schema changed */
#define SQLITE_TOOBIG 18 /* Too much data for one row of a table */
-#define SQLITE_CONSTRAINT 19 /* Abort due to contraint violation */
+#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */
#define SQLITE_MISMATCH 20 /* Data type mismatch */
#define SQLITE_MISUSE 21 /* Library used incorrectly */
#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */
} {
This routine sets a busy handler that sleeps for a while when a
table is locked. The handler will sleep multiple times until
- at least "ms" milleseconds of sleeping have been done. After
- "ms" milleseconds of sleeping, the handler returns 0 which
+ at least "ms" milliseconds of sleeping have been done. After
+ "ms" milliseconds of sleeping, the handler returns 0 which
causes sqlite3_exec() to return SQLITE_BUSY.
Calling this routine with an argument less than or equal to zero
#define SQLITE_ANY 5
} {
These two functions are used to add user functions or aggregates
- implemented in C to the SQL langauge interpreted by SQLite. The
+ implemented in C to the SQL language interpreted by SQLite. The
difference only between the two is that the second parameter, the
name of the (scalar) function or aggregate, is encoded in UTF-8 for
sqlite3_create_function() and UTF-16 for sqlite3_create_function16().
and xFinal parameters. An aggregate function requires an implementation
of xStep and xFinal, but NULL should be passed for xFunc. To delete an
existing user function or aggregate, pass NULL for all three function
- callback. Specifying an inconstent set of callback values, such as an
+ callback. Specifying an inconstant set of callback values, such as an
xFunc and an xFinal, or an xStep but no xFinal, SQLITE_ERROR is
returned.
}
virtual machine. If the virtual machine has not completed execution
when this routine is called, that is like encountering an error or
an interrupt. (See sqlite3_interrupt().) Incomplete updates may be
- rolled back and transactions cancelled, depending on the circumstances,
+ rolled back and transactions canceled, depending on the circumstances,
and the result code returned will be SQLITE_ABORT.
}
} {
These routines are variants of the "sprintf()" from the
standard C library. The resulting string is written into memory
- obtained from malloc() so that there is never a possiblity of buffer
+ obtained from malloc() so that there is never a possibility of buffer
overflow. These routines also implement some additional formatting
options that are useful for constructing SQL statements.
Perhaps it was called on a virtual machine that had already been
finalized or on one that had previously returned SQLITE_ERROR or
SQLITE_DONE. Or it could be the case the the same database connection
- is being used simulataneously by two or more threads.
+ is being used simultaneously by two or more threads.
}
api {} {
<li>Honor the ORDER BY and LIMIT clause of a SELECT even if the
result set is used for an INSERT.</li>
<li>Do not put write locks on the file used to hold TEMP tables.</li>
-<li>Added documention on SELECT DISTINCT and on how SQLite handles NULLs.</li>
+<li>Added documentation on SELECT DISTINCT and on how SQLite handles NULLs.</li>
<li>Fix a problem that was causing poor performance when many thousands
of SQL statements were executed by a single sqlite_exec() call.</li>
}
<li>Make a distinction between numeric and text values when sorting.
Text values sort according to memcmp(). Numeric values sort in
numeric order.</li>
-<li>Allow multiple simulataneous readers under windows by simulating
+<li>Allow multiple simultaneous readers under windows by simulating
the reader/writers locks that are missing from Win95/98/ME.</li>
<li>An error is now returned when trying to start a transaction if
another transaction is already active.</li>
<li>Add support for the full SQL-92 join syntax and LEFT OUTER JOINs.</li>
<li>Double-quoted strings interpreted as column names not text literals.</li>
<li>Parse (but do not implement) foreign keys.</li>
-<li>Performance improvemenets in the parser, pager, and WHERE clause code
+<li>Performance improvements in the parser, pager, and WHERE clause code
generator.</li>
<li>Make the LIMIT clause work on subqueries. (ORDER BY still does not
work, though.)</li>
<li>Added the "%Q" expansion to sqlite_*_printf().</li>
-<li>Bug fixes too numerious to mention (see the change log).</li>
+<li>Bug fixes too numerous to mention (see the change log).</li>
}
chng {2002 May 09 (2.4.12)} {
SELECT statement.</li>
<li>Permit SELECT statements without a FROM clause.</li>
<li>Added the <b>last_insert_rowid()</b> SQL function.</li>
-<li>Do not count rows where the IGNORE conflict resultion occurs in
+<li>Do not count rows where the IGNORE conflict resolution occurs in
the row count.</li>
<li>Make sure functions expressions in the VALUES clause of an INSERT
are correct.</li>
<li>Added support for VIEWs.</li>
<li>Added the subquery flattening optimizer.</li>
<li>Modified the B-Tree and Pager modules so that disk pages that do not
- contain real data (free pages) are not journalled and are not
+ contain real data (free pages) are not journaled and are not
written from memory back to the disk when they change. This does not
impact database integrity, since the
pages contain no real data, but it does make large INSERT operations
}
chng {2001 Nov 13 (2.1.1)} {
-<li>Bug fix: Sometimes arbirary strings were passed to the callback
+<li>Bug fix: Sometimes arbitrary strings were passed to the callback
function when the actual value of a column was NULL.</li>
}
}
chng {2001 Oct 13 (2.0.4)} {
-<li>Bug fix: an abscure and relatively harmless bug was causing one of
+<li>Bug fix: an obscure and relatively harmless bug was causing one of
the tests to fail when gcc optimizations are turned on. This release
fixes the problem.</li>
}
#
# Run this Tcl script to generate the constraint.html file.
#
-set rcsid {$Id: conflict.tcl,v 1.3 2004/05/31 15:06:30 drh Exp $ }
+set rcsid {$Id: conflict.tcl,v 1.4 2004/10/10 17:24:55 drh Exp $ }
source common.tcl
header {Constraint Conflict Resolution in SQLite}
puts {
By supporting all five alternatives, SQLite provides maximum
portability.</p>
-<p>Another reason for supporing multiple algorithms is that sometimes
+<p>Another reason for supporting multiple algorithms is that sometimes
it is useful to use an algorithm other than the default.
Suppose, for example, you are
inserting 1000 records into a database, all within a single
a constraint error. Under PostgreSQL or Oracle, none of the
1000 records would get inserted. In MySQL, some subset of the
records that appeared before the malformed record would be inserted
-but the rest would not. Neither behavior is espeically helpful.
+but the rest would not. Neither behavior is especially helpful.
What you really want is to use the IGNORE algorithm to insert
all but the malformed record.</p>
-set rcsid {$Id: datatype3.tcl,v 1.7 2004/07/19 00:39:46 drh Exp $}
+set rcsid {$Id: datatype3.tcl,v 1.8 2004/10/10 17:24:55 drh Exp $}
source common.tcl
header {Datatypes In SQLite Version 3}
puts {
<LI><P>A TEXT value is less than a BLOB value. When two TEXT values
are compared, the C library function memcmp() is usually used to
- determine the result. However this can be overriden, as described
+ determine the result. However this can be overridden, as described
under 'User-defined collation Sequences' below.</P>
<LI><P>When two BLOB values are compared, the result is always
#
# Run this script to generated a datatypes.html output file
#
-set rcsid {$Id: datatypes.tcl,v 1.7 2004/05/31 15:06:30 drh Exp $}
+set rcsid {$Id: datatypes.tcl,v 1.8 2004/10/10 17:24:55 drh Exp $}
source common.tcl
header {Datatypes In SQLite version 2}
puts {
<p>
For an expression, the datatype of the result is often determined by
-the outermost operator. For example, arithmatic operators ("+", "*", "%")
+the outermost operator. For example, arithmetic operators ("+", "*", "%")
always return a numeric results. The string concatenation operator
("||") returns a text result. And so forth. If you are ever in doubt
about the datatype of an expression you can use the special <b>typeof()</b>
#
# Run this TCL script to generate HTML for the download.html file.
#
-set rcsid {$Id: download.tcl,v 1.14 2004/08/29 18:14:18 drh Exp $}
+set rcsid {$Id: download.tcl,v 1.15 2004/10/10 17:24:55 drh Exp $}
source common.tcl
header {SQLite Download Page}
<a href="http://www.cvshome.org/">CVS</a> repository that is
available for read-only access by anyone. You can
interactively view the
-respository contents and download individual files
+repository contents and download individual files
by visiting
<a href="http://www.sqlite.org/cvstrac/dir?d=sqlite">
http://www.sqlite.org/cvstrac/dir?d=sqlite</a>.
-To access the respository directly, use the following
+To access the repository directly, use the following
commands:
</p>
#
# Run this script to generated a faq.html output file
#
-set rcsid {$Id: faq.tcl,v 1.25 2004/09/18 18:00:24 drh Exp $}
+set rcsid {$Id: faq.tcl,v 1.26 2004/10/10 17:24:55 drh Exp $}
source common.tcl
header {SQLite Frequently Asked Questions</title>}
What is the maximum size of a VARCHAR in SQLite?
} {
<p>SQLite does not enforce datatype constraints.
- A VARCHAR column can hold as much data as you care to put it in.</p>
+ A VARCHAR column can hold as much data as you care to put in it.</p>
}
faq {
<p>SQLite version 3.0 lets you puts BLOB data into any column, even
columns that are declared to hold some other type.</p>
- <p>SQLite version 2.8 would hold store text data without embedded
+ <p>SQLite version 2.8 will store any text data without embedded
'\000' characters. If you need to store BLOB data in SQLite version
2.8 you'll want to encode that data first.
There is a source file named
}
faq {
- Can I use SQLite in my commerical product without paying royalties?
+ Can I use SQLite in my commercial product without paying royalties?
} {
<p>Yes. SQLite is in the public domain. No claim of ownership is made
to any part of the code. You can do anything you want with it.</p>
#
# Run this script to generated a fileformat.html output file
#
-set rcsid {$Id: fileformat.tcl,v 1.12 2004/05/31 15:06:30 drh Exp $}
+set rcsid {$Id: fileformat.tcl,v 1.13 2004/10/10 17:24:55 drh Exp $}
source common.tcl
header {SQLite Database File Format (Version 2)}
puts {
</ul>
<p>
-We wil describe each layer beginning with the bottom (pager)
+We will describe each layer beginning with the bottom (pager)
layer and working upwards.
</p>
the byte index for Value 0, Offset 1 contains the byte offset
of Value 1, and so forth. The number of bytes in a column value can
always be found by subtracting offsets. This allows NULLs to be
-recovered from the record unabiguously.
+recovered from the record unambiguously.
</p>
<p>
Text values consists of the character 'c' followed by a copy of the
text string and a nul-terminator. These encoding rules result in
NULLs being sorted first, followed by numerical values in numerical
-order, followed by text values in lexigraphical order.
+order, followed by text values in lexicographical order.
</p>
<h4>4.4 SQL Schema Storage And Root B-Tree Page Numbers</h4>
#
# Run this Tcl script to generate the formatchng.html file.
#
-set rcsid {$Id: formatchng.tcl,v 1.11 2004/06/16 03:02:04 drh Exp $ }
+set rcsid {$Id: formatchng.tcl,v 1.12 2004/10/10 17:24:55 drh Exp $ }
source common.tcl
header {File Format Changes in SQLite}
puts {
<td><p>Version 2.8.0 introduces a change to the format of the rollback
journal file. The main database file format is unchanged. Versions
2.7.6 and earlier can read and write 2.8.0 databases and vice versa.
- Version 2.8.0 can rollback a transation that was started by version
+ Version 2.8.0 can rollback a transaction that was started by version
2.7.6 and earlier. But version 2.7.6 and earlier cannot rollback a
transaction started by version 2.8.0 or later.</p>
#
# Run this Tcl script to generate the sqlite.html file.
#
-set rcsid {$Id: lang.tcl,v 1.73 2004/10/05 02:41:43 drh Exp $}
+set rcsid {$Id: lang.tcl,v 1.74 2004/10/10 17:24:55 drh Exp $}
source common.tcl
header {Query Language Understood by SQLite}
puts {
language. But it does <a href="omitted.html">omit some features</a>
while at the same time
adding a few features of its own. This document attempts to
-describe percisely what parts of the SQL language SQLite does
+describe precisely what parts of the SQL language SQLite does
and does not support. A list of <a href="#keywords">keywords</a> is
given at the end.</p>
COMMIT or ROLLBACK command. But a transaction will also
ROLLBACK if the database is closed or if an error occurs
and the ROLLBACK conflict resolution algorithm is specified.
-See the documention on the <a href="#conflict">ON CONFLICT</a>
+See the document
ation on the <a href="#conflict">ON CONFLICT</a>
clause for additional information about the ROLLBACK
conflict resolution algorithm.
</p>
locks is deferred until they are needed, it is possible that another
thread or process could create a separate transaction and write to
the database after the BEGIN on the current thread has executed.
-If the transation is immediate, then RESERVED locks
+If the transaction is immediate, then RESERVED locks
are acquired on all databases as soon as the BEGIN command is
executed, without waiting for the
database to be used. After a BEGIN IMMEDIATE, you are guaranteed that
<p>The exact text
of each CREATE INDEX statement is stored in the <b>sqlite_master</b>
or <b>sqlite_temp_master</b> table, depending on whether the table
-being indexed is temporary. Everytime the database is opened,
+being indexed is temporary. Every time the database is opened,
all CREATE INDEX statements
are read from the <b>sqlite_master</b> table and used to regenerate
SQLite's internal representation of the index layout.</p>
<p>The exact text
of each CREATE TABLE statement is stored in the <b>sqlite_master</b>
-table. Everytime the database is opened, all CREATE TABLE statements
+table. Every time the database is opened, all CREATE TABLE statements
are read from the <b>sqlite_master</b> table and used to regenerate
SQLite's internal representation of the table layout.
If the original command was a CREATE TABLE AS then then an equivalent
OR</font>
</pre></blockquote>
-<p>Supported unary operaters are these:</p>
+<p>Supported unary operators are these:</p>
<blockquote><pre>
<font color="#2c2cf0"><big>- + ! ~</big></font>
puts {
<a name="like"></a>
-<p>The LIKE operator does a wildcard comparision. The operand
+<p>The LIKE operator does a wildcard comparison. The operand
to the right contains the wildcards.}
puts "A percent symbol [Operator %] in the right operand
matches any sequence of zero or more characters on the left.
operand of an IN operator, then the first row of the result of the
SELECT becomes the value used in the expression. If the SELECT yields
more than one result row, all rows after the first are ignored. If
-the SELECT yeilds no rows, then the value of the SELECT is NULL.</p>
+the SELECT yields no rows, then the value of the SELECT is NULL.</p>
<p>Both simple and aggregate functions are supported. A simple
function can be used in any expression. Simple functions return
<tr>
<td valign="top" align="right">min(<i>X</i>,<i>Y</i>,...)</td>
<td valign="top">Return the argument with the minimum value. Arguments
-may be strings in addition to numbers. The mminimum value is determined
+may be strings in addition to numbers. The minimum value is determined
by the usual sort order. Note that <b>min()</b> is a simple function when
it has 2 or more arguments but converts to an aggregate function if given
only a single argument.</td>
value, then the ABORT algorithm is used.</p>
<p>When this conflict resolution strategy deletes rows in order to
-statisfy a constraint, it does not invoke delete triggers on those
+satisfy a constraint, it does not invoke delete triggers on those
rows. But that may change in a future release.</p>
<p>The algorithm specified in the OR clause of a COPY, INSERT, or UPDATE
<li><p><b>PRAGMA database_list;</b></p>
<p>For each open database, invoke the callback function once with
information about that database. Arguments include the index and
- the name the datbase was attached with. The first row will be for
+ the name the database was attached with. The first row will be for
the main database. The second row will be for the database used to
store temporary tables.</p></li>
pragma with the additional
feature that it changes the cache size persistently. With this pragma,
you can set the cache size once and that setting is retained and reused
- everytime you reopen the database.</p></li>
+ every time you reopen the database.</p></li>
<a name="pragma_default_synchronous"></a>
<li><p><b>PRAGMA default_synchronous;
<p>The DISTINCT keyword causes a subset of result rows to be returned,
in which each result row is different. NULL values are not treated as
-distinct from eachother. The default behavior is that all result rows
+distinct from each other. The default behavior is that all result rows
be returned, which can be made explicit with the keyword ALL.</p>
<p>The query is executed against one or more tables specified after
}
puts {
-<p>The VACUUM command is an SQLite extension modelled after a similar
+<p>The VACUUM command is an SQLite extension modeled after a similar
command found in PostgreSQL. If VACUUM is invoked with the name of a
table or index then it is suppose to clean up the named table or index.
In version 1.0 of SQLite, the VACUUM command would invoke
<p>
VACUUM became a no-op when the GDBM backend was removed from
SQLITE in version 2.0.0.
-VACUUM was reimplimented in version 2.8.1.
+VACUUM was reimplemented in version 2.8.1.
The index or table name argument is now ignored.
</p>
<td>Interpreted as an identifier if it matches a known identifier
and occurs in a legal identifier context, otherwise as a string.
<tr> <td> [keyword]
- <td> Always interpreted as an identifer. (This notation is used
+ <td> Always interpreted as an identifier. (This notation is used
by MS Access and SQL Server.)
</table>
#
# Run this script to generated a nulls.html output file
#
-set rcsid {$Id: nulls.tcl,v 1.7 2004/08/30 14:58:12 drh Exp $}
+set rcsid {$Id: nulls.tcl,v 1.8 2004/10/10 17:24:55 drh Exp $}
source common.tcl
header {NULL Handling in SQLite}
puts {
<p>
SQLite was originally coded in such a way that the answer to
all questions in the chart below would be "Yes". But the
-expriments run on other SQL engines showed that none of them
+experiments run on other SQL engines showed that none of them
worked this way. So SQLite was modified to work the same as
Oracle, PostgreSQL, and DB2. This involved making NULLs
indistinct for the purposes of the SELECT DISTINCT statement and
newsitem {2004-Jun-09} {Version 2.8.14 Released} {
SQLite version 2.8.14 is a patch release to the stable 2.8 series.
There is no reason to upgrade if 2.8.13 is working ok for you.
- This is only a bug-fix release. Most developement effort is
+ This is only a bug-fix release. Most development effort is
going into version 3.0.0 which is due out soon.
}
Plans are to continue to support SQLite version 2.8 with
bug fixes. But all new development will occur in version 3.0.
}
-footer {$Id: oldnews.tcl,v 1.5 2004/09/18 18:00:24 drh Exp $}
+footer {$Id: oldnews.tcl,v 1.6 2004/10/10 17:24:55 drh Exp $}
#
# Run this Tcl script to generate the sqlite.html file.
#
-set rcsid {$Id: opcode.tcl,v 1.13 2004/05/31 15:06:30 drh Exp $}
+set rcsid {$Id: opcode.tcl,v 1.14 2004/10/10 17:24:55 drh Exp $}
source common.tcl
header {SQLite Virtual Machine Opcodes}
puts {
was generated by scanning the <b>vdbe.c</b> source file
and extracting the necessary information from comments. So the
source code comments are really the canonical source of information
-about the virtual macchine. When in doubt, refer to the source code.</p>
+about the virtual machine. When in doubt, refer to the source code.</p>
<p>Each instruction in the virtual machine consists of an opcode and
up to three operands named P1, P2 and P3. P1 may be an arbitrary
#
# Run this Tcl script to generate the speed.html file.
#
-set rcsid {$Id: speed.tcl,v 1.14 2004/05/31 15:06:30 drh Exp $ }
+set rcsid {$Id: speed.tcl,v 1.15 2004/10/10 17:24:55 drh Exp $ }
source common.tcl
header {SQLite Database Speed Comparison}
I am told that the default PostgreSQL configuration in RedHat 7.3
is unnecessarily conservative (it is designed to
work on a machine with 8MB of RAM) and that PostgreSQL could
-be made to run a lot faster with some knowledgable configuration
+be made to run a lot faster with some knowledgeable configuration
tuning.
Matt Sergeant reports that he has tuned his PostgreSQL installation
and rerun the tests shown below. His results show that
<p>
This test still does 100 full table scans but it uses
-uses string comparisons instead of numerical comparisions.
+uses string comparisons instead of numerical comparisons.
SQLite is over three times faster than PostgreSQL here and about 30%
faster than MySQL.
</p>
#
# Run this TCL script to generate HTML for the goals.html file.
#
-set rcsid {$Id: whentouse.tcl,v 1.1 2004/01/27 15:58:38 drh Exp $}
+set rcsid {$Id: whentouse.tcl,v 1.2 2004/10/10 17:24:55 drh Exp $}
puts {<html>
<head><title>Appropriate Uses of SQLite</title></head>
Simplicity in a database engine can be either a strength or a
weakness, depending on what you are trying to do. In order to
achieve simplicity, SQLite has had to sacrifice other characteristics
-that some people find useful, such as high concurrancy, fine-grained
+that some people find useful, such as high concurrency, fine-grained
access control, a rich set of built-in functions, stored procedures,
esoteric SQL language features, XML and/or Java extensions,
tera- or peta-byte scalability, and so forth. If you need these
<li><p><b>Stand-in for an enterprise database during demos or testing</b></p>
<p>
-If you are writting a client application for an enterprise database engine,
+If you are writing a client application for an enterprise database engine,
it makes sense to use a generic database backend that allows you to connect
to many different kinds of SQL database engines. It makes even better
sense to
can do to prevent it.</p>
<p>A good rule of thumb is that you should avoid using SQLite
-in situations where the same database will be accessed simultenously
+in situations where the same database will be accessed simultaneously
from many computers over a network filesystem.</p>
</li>
<li><p><b>High-volume Websites</b></p>
<p>SQLite will normally work fine as the database backend to a website.
-But if you website is so busy that your are thinking of splitted the
+But if you website is so busy that your are thinking of splitting the
database component off onto a separate machine, then you should
definitely consider using an enterprise-class client/server database
engine instead of SQLite.</p>
</p>
</li>
-<li><p><b>High Concurrancy</b></p>
+<li><p><b>High Concurrency</b></p>
<p>
SQLite uses reader/writer locks on the entire database file. That means
For many situations, this is not a problem. Each application
does its database work quickly and moves on, and no lock lasts for more
than a few dozen milliseconds. But there are some problems that require
-more concurrancy, and those problems will need to seek a different
+more concurrency, and those problems will need to seek a different
solution.
</p>
</li>
projects / thirdparty / sqlite.git / commitdiff
