-C Version\s2.5.0\s(CVS\s627)
-D 2002-06-17T17:26:39
+C The\squery\soptimizer\snow\sattempts\sto\ssatisfy\san\sORDER\sBY\sclause\susing\nan\sindex.\s\sSorting\sis\sstill\sused\sif\sthere\sare\sno\ssuitable\sindices.\s(CVS\s628)
+D 2002-06-19T14:27:05
F Makefile.in 6291a33b87d2a395aafd7646ee1ed562c6f2c28c
F Makefile.template 4e11752e0b5c7a043ca50af4296ec562857ba495
F README a4c0ba11354ef6ba0776b400d057c59da47a4cc0
-F VERSION 4d924d02a7c61b0eb53a6fc5c6fc9536b9b6f212
+F VERSION 9a1a4bc4ca9e44b3ccf4c764cb670aae41b078a0
F aclocal.m4 11faa843caa38fd451bc6aeb43e248d1723a269d
F config.guess f38b1e93d1e0fa6f5a6913e9e7b12774b9232588
F config.sub f14b07d544ca26b5d698259045136b783e18fc7f
F src/btree.c 8b86be8f234c1c5dab3186f69cee2544ec9d7257
F src/btree.h 8abeabfe6e0b1a990b64fa457592a6482f6674f3
F src/build.c f4633493f57660587c35c76dc7948f5da691a718
-F src/delete.c 15789fc723a6776309945b13a79f9a0e78275fc0
+F src/delete.c 44c45460b1e03033756e35adc6d569ffbf30b725
F src/encode.c 346b12b46148506c32038524b95c4631ab46d760
F src/expr.c ec0689af4e355356df47dc1514ff17523d2f9c71
F src/func.c b8d0fd3011f53ea0e46b6bab857612eb36b5d1ea
F src/parse.y 2285d8967d7334d52a2188089e5a881d73ba56f6
F src/printf.c 236ed7a79386feed4456fa728fff8be793f1547c
F src/random.c 19e8e00fe0df32a742f115773f57651be327cabe
-F src/select.c 6c3a92d7a0bdf3448265d530cc0e6f6e5a764997
+F src/select.c 514b4b12f72df68e0c8b4187af302b7c22b22cf6
F src/shell.c 1d22fe870ee852cfb975fd000dbe3973713d0a15
F src/shell.tcl 27ecbd63dd88396ad16d81ab44f73e6c0ea9d20e
F src/sqlite.h.in 0038faa6d642de06b91143ee65a131bd831d020b
-F src/sqliteInt.h ea5c5ce4c321d66934fa1341caf4f32b61e96bec
+F src/sqliteInt.h 1e9904f9baa536333d9d1168e075abf96426baad
F src/table.c eed2098c9b577aa17f8abe89313a9c4413f57d63
F src/tclsqlite.c 9300c9606a38bc0c75d6c0bc8a6197ab979353d1
F src/test1.c 5cc4f0bbf38237e04e1b2077e285b41bfb4c4cbf
F src/threadtest.c 81f0598e0f031c1bd506af337fdc1b7e8dff263f
F src/tokenize.c ac4c46f190346b87da54ec3e2605d160af80c619
F src/trigger.c 21342af6ac031fece39c8fc6eabd1739ca5327c1
-F src/update.c 05431e23a9c83502fd7911e771c8366fc2b90b4c
+F src/update.c 6f6a4dcd71cd9ff730b7f12c83de5498cde4924f
F src/util.c 876b259f9186e84b944b72e793dd3dad50e63e95
F src/vdbe.c 7d9bb3701ea00576c5d5fb3f3de63af7b7304241
F src/vdbe.h fba15f3280688f6f32f11d1042078e3c557bac43
-F src/where.c aa5d9d83abf0f7dda06fdd4235020f2b72d58dec
+F src/where.c 1fdb7aca26c1963eb42615a95e0fc2978eec566a
F test/all.test e4d3821eeba751829b419cd47814bd20af4286d1
F test/bigrow.test 8ab252dba108f12ad64e337b0f2ff31a807ac578
F test/btree.test bf326f546a666617367a7033fa2c07451bd4f8e1
F test/update.test a0aa0bf83e6fad8407d0e4ad25ebb09b513f5bf4
F test/vacuum.test 059871b312eb910bbe49dafde1d01490cc2c6bbe
F test/view.test b9851e9142de5e5831fdf18f125cbe1256cb550a
-F test/where.test 367d7911ee0522f1bb8a2daf17fb985e06cfe8bb
+F test/where.test 1f87bec674bf85d74ac1cc5b2cd3d89be1e87b1d
F tool/lemon.c 459cb2bb3738a1ad5cb0ad8b805587a88a885d95
F tool/lempar.c 73a991cc3017fb34804250fa901488b5147b3717
F tool/memleak.awk 296dfbce7a9ca499b95ce04e30334e64a50052e0
F www/arch.png 82ef36db1143828a7abc88b1e308a5f55d4336f4
F www/arch.tcl 72a0c80e9054cc7025a50928d28d9c75c02c2b8b
F www/c_interface.tcl 58cf4d128dcae08d91d0011c6d4d11de323f470f
-F www/changes.tcl c828c925a15c197f542296d001a07fab705518ab
+F www/changes.tcl 31a8fec4f078a60b7de5f19859297f375e9ec8da
F www/conflict.tcl 81dd21f9a679e60aae049e9dd8ab53d59570cda2
F www/crosscompile.tcl 3622ebbe518927a3854a12de51344673eb2dd060
F www/download.tcl 29aa6679ca29621d10613f60ebbbda18f4b91c49
F www/sqlite.tcl 8b5884354cb615049aed83039f8dfe1552a44279
F www/tclsqlite.tcl 1db15abeb446aad0caf0b95b8b9579720e4ea331
F www/vdbe.tcl 2013852c27a02a091d39a766bc87cff329f21218
-P 7a216adea5aa5a82718f8c85f8961ba36ab51bb4
-R ec45ebcb2d24be890f6c54c516b827ad
+P 9baef3e240c4ffd90881ac4664efd205bd9e65f4
+R e3b8c707333c1ebbf7616bf0a643f3ed
U drh
-Z 42ee4973064a93c98cc24a8792507f93
+Z 9b74fdbff1dc04448a39217a6e95f99b
-9baef3e240c4ffd90881ac4664efd205bd9e65f4
\ No newline at end of file
+f09e19b43ef61073713cf32282c90ea666229eba
\ No newline at end of file
** This file contains C code routines that are called by the parser
** to handle DELETE FROM statements.
**
-** $Id: delete.c,v 1.37 2002/06/11 02:25:41 danielk1977 Exp $
+** $Id: delete.c,v 1.38 2002/06/19 14:27:05 drh Exp $
*/
#include "sqliteInt.h"
else{
/* Begin the database scan
*/
- pWInfo = sqliteWhereBegin(pParse, base, pTabList, pWhere, 1);
+ pWInfo = sqliteWhereBegin(pParse, base, pTabList, pWhere, 1, 0);
if( pWInfo==0 ) goto delete_from_cleanup;
/* Remember the key of every item to be deleted.
** This file contains C code routines that are called by the parser
** to handle SELECT statements in SQLite.
**
-** $Id: select.c,v 1.93 2002/06/14 22:38:42 drh Exp $
+** $Id: select.c,v 1.94 2002/06/19 14:27:05 drh Exp $
*/
#include "sqliteInt.h"
/* Begin the database scan
*/
- pWInfo = sqliteWhereBegin(pParse, p->base, pTabList, pWhere, 0);
+ pWInfo = sqliteWhereBegin(pParse, p->base, pTabList, pWhere, 0, &pOrderBy);
if( pWInfo==0 ) goto select_end;
/* Use the standard inner loop if we are not dealing with
}
}
- /* If we are dealing with aggregates, then to the special aggregate
+ /* If we are dealing with aggregates, then do the special aggregate
** processing.
*/
else{
*************************************************************************
** Internal interface definitions for SQLite.
**
-** @(#) $Id: sqliteInt.h,v 1.125 2002/06/17 17:07:20 drh Exp $
+** @(#) $Id: sqliteInt.h,v 1.126 2002/06/19 14:27:05 drh Exp $
*/
#include "sqlite.h"
#include "hash.h"
SrcList *sqliteTableTokenToSrcList(Parse*, Token*);
void sqliteDeleteFrom(Parse*, Token*, Expr*);
void sqliteUpdate(Parse*, Token*, ExprList*, Expr*, int);
-WhereInfo *sqliteWhereBegin(Parse*, int, SrcList*, Expr*, int);
+WhereInfo *sqliteWhereBegin(Parse*, int, SrcList*, Expr*, int, ExprList**);
void sqliteWhereEnd(WhereInfo*);
void sqliteExprCode(Parse*, Expr*);
void sqliteExprIfTrue(Parse*, Expr*, int, int);
** This file contains C code routines that are called by the parser
** to handle UPDATE statements.
**
-** $Id: update.c,v 1.44 2002/06/11 02:25:42 danielk1977 Exp $
+** $Id: update.c,v 1.45 2002/06/19 14:27:06 drh Exp $
*/
#include "sqliteInt.h"
/* Begin the database scan
*/
- pWInfo = sqliteWhereBegin(pParse, base, pTabList, pWhere, 1);
+ pWInfo = sqliteWhereBegin(pParse, base, pTabList, pWhere, 1, 0);
if( pWInfo==0 ) goto update_cleanup;
/* Remember the index of every item to be updated.
** the WHERE clause of SQL statements. Also found here are subroutines
** to generate VDBE code to evaluate expressions.
**
-** $Id: where.c,v 1.52 2002/06/14 22:38:43 drh Exp $
+** $Id: where.c,v 1.53 2002/06/19 14:27:06 drh Exp $
*/
#include "sqliteInt.h"
typedef struct ExprInfo ExprInfo;
struct ExprInfo {
Expr *p; /* Pointer to the subexpression */
- int indexable; /* True if this subexprssion is usable by an index */
- int idxLeft; /* p->pLeft is a column in this table number. -1 if
+ u8 indexable; /* True if this subexprssion is usable by an index */
+ short int idxLeft; /* p->pLeft is a column in this table number. -1 if
** p->pLeft is not the column of any table */
- int idxRight; /* p->pRight is a column in this table number. -1 if
+ short int idxRight; /* p->pRight is a column in this table number. -1 if
** p->pRight is not the column of any table */
- unsigned prereqLeft; /* Tables referenced by p->pLeft */
- unsigned prereqRight; /* Tables referenced by p->pRight */
- unsigned prereqAll; /* Tables referenced by this expression in any way */
+ unsigned prereqLeft; /* Bitmask of tables referenced by p->pLeft */
+ unsigned prereqRight; /* Bitmask of tables referenced by p->pRight */
+ unsigned prereqAll; /* Bitmask of tables referenced by p */
};
/*
/*
** This routine walks (recursively) an expression tree and generates
** a bitmask indicating which tables are used in that expression
-** tree. Bit 0 of the mask is set if table 0 is used. But 1 is set
-** if table 1 is used. And so forth.
+** tree. Bit 0 of the mask is set if table base+0 is used. Bit 1
+** is set if table base+1 is used. And so forth.
**
** In order for this routine to work, the calling function must have
** previously invoked sqliteExprResolveIds() on the expression. See
** the header comment on that routine for additional information.
**
** "base" is the cursor number (the value of the iTable field) that
-** corresponds to the first entry in the table list.
+** corresponds to the first entry in the list of tables that appear
+** in the FROM clause of a SELECT. For UPDATE and DELETE statements
+** there is just a single table with "base" as the cursor number.
*/
static int exprTableUsage(int base, Expr *p){
unsigned int mask = 0;
}
/*
-** Generating the beginning of the loop used for WHERE clause processing.
+** pOrderBy is an ORDER BY clause from a SELECT statement. pTab is the
+** left-most table in the FROM clause of that same SELECT statement and
+** the table has a cursor number of "base".
+**
+** This routine attempts to find an index for pTab that generates the
+** correct record sequence for the given ORDER BY clause. The return value
+** is a pointer to an index that does the job. NULL is returned if the
+** table has no index that will generate the correct sort order.
+**
+** If there are two or more indices that generate the correct sort order
+** and pPreferredIdx is one of those indices, then return pPreferredIdx.
+*/
+static Index *findSortingIndex(
+ Table *pTab, /* The table to be sorted */
+ int base, /* Cursor number for pTab */
+ ExprList *pOrderBy, /* The ORDER BY clause */
+ Index *pPreferredIdx /* Use this index, if possible and not NULL */
+){
+ int i;
+ Index *pMatch;
+ Index *pIdx;
+
+ assert( pOrderBy!=0 );
+ assert( pOrderBy->nExpr>0 );
+ for(i=0; i<pOrderBy->nExpr; i++){
+ Expr *p;
+ if( (pOrderBy->a[i].sortOrder & SQLITE_SO_DIRMASK)!=SQLITE_SO_ASC ){
+ /* Indices can only be used for ascending sort order */
+ return 0;
+ }
+ p = pOrderBy->a[i].pExpr;
+ if( p->op!=TK_COLUMN || p->iTable!=base ){
+ /* Can not use an index sort on anything that is not a column in the
+ ** left-most table of the FROM clause */
+ return 0;
+ }
+ }
+
+ /* If we get this far, it means the ORDER BY clause consists only of
+ ** ascending columns in the left-most table of the FROM clause. Now
+ ** check for a matching index.
+ */
+ pMatch = 0;
+ for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
+ if( pIdx->nColumn<pOrderBy->nExpr ) continue;
+ for(i=0; i<pOrderBy->nExpr; i++){
+ if( pOrderBy->a[i].pExpr->iColumn!=pIdx->aiColumn[i] ) break;
+ }
+ if( i>=pOrderBy->nExpr ){
+ pMatch = pIdx;
+ if( pIdx==pPreferredIdx ) break;
+ }
+ }
+ return pMatch;
+}
+
+/*
+** Generate the beginning of the loop used for WHERE clause processing.
** The return value is a pointer to an (opaque) structure that contains
** information needed to terminate the loop. Later, the calling routine
** should invoke sqliteWhereEnd() with the return value of this function
** ...
** flag = 1
** end
-** if flag==0 goto start
+** if flag==0 then
+** move the row2 cursor to a null row
+** goto start
+** fi
** end
**
-** In words, if the right
+** ORDER BY CLAUSE PROCESSING
+**
+** *ppOrderBy is a pointer to the ORDER BY clause of a SELECT statement,
+** if there is one. If there is no ORDER BY clause or if this routine
+** is called from an UPDATE or DELETE statement, then ppOrderBy is NULL.
+**
+** If an index can be used so that the natural output order of the table
+** scan is correct for the ORDER BY clause, then that index is used and
+** *ppOrderBy is set to NULL. This is an optimization that prevents an
+** unnecessary sort of the result set if an index appropriate for the
+** ORDER BY clause already exists.
+**
+** If the where clause loops cannot be arranged to provide the correct
+** output order, then the *ppOrderBy is unchanged.
*/
WhereInfo *sqliteWhereBegin(
Parse *pParse, /* The parser context */
int base, /* VDBE cursor index for left-most table in pTabList */
SrcList *pTabList, /* A list of all tables to be scanned */
Expr *pWhere, /* The WHERE clause */
- int pushKey /* If TRUE, leave the table key on the stack */
+ int pushKey, /* If TRUE, leave the table key on the stack */
+ ExprList **ppOrderBy /* An ORDER BY clause, or NULL */
){
int i; /* Loop counter */
WhereInfo *pWInfo; /* Will become the return value of this function */
*/
assert( pushKey==0 || pTabList->nSrc==1 );
- /* Allocate space for aOrder[] and aiMem[]. */
+ /* Allocate space for aOrder[] */
aOrder = sqliteMalloc( sizeof(int) * pTabList->nSrc );
/* Allocate and initialize the WhereInfo structure that will become the
}
}
+ /* Check to see if the ORDER BY clause is or can be satisfied by the
+ ** use of an index on the first table.
+ */
+ if( ppOrderBy && *ppOrderBy && pTabList->nSrc>0 ){
+ Index *pSortIdx;
+ Index *pIdx;
+ Table *pTab;
+
+ pTab = pTabList->a[0].pTab;
+ pIdx = pWInfo->a[0].pIdx;
+ if( pIdx && pWInfo->a[0].score==4 ){
+ /* If there is already an index on the left-most column and it is
+ ** an equality index, then either sorting is not helpful, or the
+ ** index is an IN operator, in which case the index does not give
+ ** the correct sort order. Either way, pretend that no suitable
+ ** index is found.
+ */
+ pSortIdx = 0;
+ }else if( iDirectEq[0]>=0 || iDirectLt[0]>=0 || iDirectGt[0]>=0 ){
+ /* If the left-most column is accessed using its ROWID, then do
+ ** not try to sort by index.
+ */
+ pSortIdx = 0;
+ }else{
+ pSortIdx = findSortingIndex(pTab, base, *ppOrderBy, pIdx);
+ }
+ if( pSortIdx && (pIdx==0 || pIdx==pSortIdx) ){
+ if( pIdx==0 ){
+ pWInfo->a[0].pIdx = pSortIdx;
+ pWInfo->a[0].iCur = pParse->nTab++;
+ pWInfo->peakNTab = pParse->nTab;
+ }
+ *ppOrderBy = 0;
+ }
+ }
+
/* Open all tables in the pTabList and all indices used by those tables.
*/
for(i=0; i<pTabList->nSrc; i++){
haveKey = 0;
sqliteVdbeAddOp(v, OP_NotExists, base+idx, brk);
pLevel->op = OP_Noop;
- }else if( pIdx!=0 && pLevel->score%4==0 ){
+ }else if( pIdx!=0 && pLevel->score>0 && pLevel->score%4==0 ){
/* Case 2: There is an index and all terms of the WHERE clause that
** refer to the index use the "==" or "IN" operators.
*/
** form "x=5 AND y<10" then this case is used. Only the
** right-most column can be an inequality - the rest must
** use the "==" operator.
+ **
+ ** This case is also used when there are no WHERE clause
+ ** constraints but an index is selected anyway, in order
+ ** to force the output order to conform to an ORDER BY.
*/
int score = pLevel->score;
int nEqColumn = score/4;
# This file implements regression tests for SQLite library. The
# focus of this file is testing the use of indices in WHERE clases.
#
-# $Id: where.test,v 1.8 2002/06/14 22:38:43 drh Exp $
+# $Id: where.test,v 1.9 2002/06/19 14:27:06 drh Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
} {1 2 3 6}
do_test where-1.37 {
count {SELECT w FROM t1 WHERE w+1<=4 ORDER BY w}
-} {1 2 3 99}
+} {1 2 3 199}
# Do the same kind of thing except use a join as the data source.
count {
SELECT * FROM t1 WHERE rowid+0 IN (1,2,3,1234) order by 1;
}
-} {1 0 4 2 1 9 3 1 16 99}
+} {1 0 4 2 1 9 3 1 16 199}
do_test where-5.3 {
count {
SELECT * FROM t1 WHERE w IN (-1,1,2,3) order by 1;
count {
SELECT * FROM t1 WHERE w+0 IN (-1,1,2,3) order by 1;
}
-} {1 0 4 2 1 9 3 1 16 99}
+} {1 0 4 2 1 9 3 1 16 199}
do_test where-5.5 {
count {
SELECT * FROM t1 WHERE rowid IN
(select rowid from t1 where rowid IN (-1,2,4))
ORDER BY 1;
}
-} {2 1 9 4 2 25 99}
+} {2 1 9 4 2 25 199}
do_test where-5.7 {
count {
SELECT * FROM t1 WHERE w IN
(select rowid from t1 where rowid IN (-1,2,4))
ORDER BY 1;
}
-} {2 1 9 4 2 25 99}
+} {2 1 9 4 2 25 199}
do_test where-5.9 {
count {
SELECT * FROM t1 WHERE x IN (1,7) ORDER BY 1;
count {
SELECT * FROM t1 WHERE x+0 IN (1,7) ORDER BY 1;
}
-} {2 1 9 3 1 16 99}
+} {2 1 9 3 1 16 199}
do_test where-5.11 {
count {
SELECT * FROM t1 WHERE y IN (6400,8100) ORDER BY 1;
}
-} {79 6 6400 89 6 8100 99}
+} {79 6 6400 89 6 8100 199}
do_test where-5.12 {
count {
SELECT * FROM t1 WHERE x=6 AND y IN (6400,8100) ORDER BY 1;
}
} {2 1 9 6}
+# This procedure executes the SQL. Then it checks the generated program
+# for the SQL and appends a "nosort" to the result if the program contains the
+# SortCallback opcode. If the program does not contain the SortCallback
+# opcode it appends "sort"
+#
+proc cksort {sql} {
+ set data [execsql $sql]
+ set prog [execsql "EXPLAIN $sql"]
+ if {[regexp SortCallback $prog]} {set x sort} {set x nosort}
+ lappend data $x
+ return $data
+}
+# Check out the logic that attempts to implement the ORDER BY clause
+# using an index rather than by sorting.
+#
+do_test where-6.1 {
+ execsql {
+ CREATE TABLE t3(a,b,c);
+ CREATE INDEX t3a ON t3(a);
+ CREATE INDEX t3bc ON t3(b,c);
+ CREATE INDEX t3acb ON t3(a,c,b);
+ INSERT INTO t3 SELECT w, 101-w, y FROM t1;
+ SELECT count(*), sum(a), sum(b), sum(c) FROM t3;
+ }
+} {100 5050 5050 348550}
+do_test where-6.2 {
+ cksort {
+ SELECT * FROM t3 ORDER BY a LIMIT 3
+ }
+} {1 100 4 2 99 9 3 98 16 nosort}
+do_test where-6.3 {
+ cksort {
+ SELECT * FROM t3 ORDER BY a+1 LIMIT 3
+ }
+} {1 100 4 2 99 9 3 98 16 sort}
+do_test where-6.4 {
+ cksort {
+ SELECT * FROM t3 WHERE a<10 ORDER BY a LIMIT 3
+ }
+} {1 100 4 2 99 9 3 98 16 nosort}
+do_test where-6.5 {
+ cksort {
+ SELECT * FROM t3 WHERE a>0 AND a<10 ORDER BY a LIMIT 3
+ }
+} {1 100 4 2 99 9 3 98 16 nosort}
+do_test where-6.6 {
+ cksort {
+ SELECT * FROM t3 WHERE a>0 ORDER BY a LIMIT 3
+ }
+} {1 100 4 2 99 9 3 98 16 nosort}
+do_test where-6.7 {
+ cksort {
+ SELECT * FROM t3 WHERE b>0 ORDER BY a LIMIT 3
+ }
+} {1 100 4 2 99 9 3 98 16 sort}
+do_test where-6.8 {
+ cksort {
+ SELECT * FROM t3 WHERE a IN (3,5,7,1,9,4,2) ORDER BY a LIMIT 3
+ }
+} {1 100 4 2 99 9 3 98 16 sort}
+do_test where-6.9 {
+ cksort {
+ SELECT * FROM t3 WHERE a=1 AND c>0 ORDER BY a LIMIT 3
+ }
+} {1 100 4 nosort}
+do_test where-6.10 {
+ cksort {
+ SELECT * FROM t3 WHERE a=1 AND c>0 ORDER BY a LIMIT 3
+ }
+} {1 100 4 nosort}
+do_test where-6.11 {
+ cksort {
+ SELECT * FROM t3 WHERE a=1 AND c>0 ORDER BY a,c LIMIT 3
+ }
+} {1 100 4 nosort}
+do_test where-6.12 {
+ cksort {
+ SELECT * FROM t3 WHERE a=1 AND c>0 ORDER BY a,c,b LIMIT 3
+ }
+} {1 100 4 nosort}
+do_test where-6.13 {
+ cksort {
+ SELECT * FROM t3 WHERE a>0 ORDER BY a DESC LIMIT 3
+ }
+} {100 1 10201 99 2 10000 98 3 9801 sort}
+do_test where-6.14 {
+ cksort {
+ SELECT * FROM t3 ORDER BY b LIMIT 3
+ }
+} {100 1 10201 99 2 10000 98 3 9801 nosort}
+do_test where-6.15 {
+ cksort {
+ SELECT t3.a, t1.x FROM t3, t1 WHERE t3.a=t1.w ORDER BY t3.a LIMIT 3
+ }
+} {1 0 2 1 3 1 nosort}
+do_test where-6.16 {
+ cksort {
+ SELECT t3.a, t1.x FROM t3, t1 WHERE t3.a=t1.w ORDER BY t1.x, t3.a LIMIT 3
+ }
+} {1 0 2 1 3 1 sort}
finish_test
puts "<DD><P><UL>$desc</UL></P></DD>"
}
+chng {2002 Jun 19 (2.5.1)} {
+<li>The query optimizer now attempts to implement the ORDER BY clause
+ using an index. Sorting is still used if not suitable index is
+ available.</li>
+}
+
chng {2002 Jun 17 (2.5.0)} {
<li>Added support for row triggers.</li>
<li>Added SQL-92 compliant handling of NULLs.</li>
projects / thirdparty / sqlite.git / commitdiff
