From 7b58daeafec267b11b11bb327e15188767e2bdfd Mon Sep 17 00:00:00 2001 From: drh Date: Sun, 20 Jul 2003 01:16:46 +0000 Subject: [PATCH] Fix the LIMIT clause so that it applies to the entire query in a compound query. Prior to this change LIMITs on compound queries did not work at all. Ticket #393. (CVS 1058) FossilOrigin-Name: 543479e3aed77976a0c689cf40811bf88353f706 --- manifest | 20 +++---- manifest.uuid | 2 +- src/expr.c | 4 +- src/select.c | 137 ++++++++++++++++++++++++++++++++---------------- src/sqliteInt.h | 7 +-- test/limit.test | 82 ++++++++++++++++++++++++++++- www/lang.tcl | 9 +++- 7 files changed, 198 insertions(+), 63 deletions(-) diff --git a/manifest b/manifest index 56d0b212a6..650b73ef71 100644 --- a/manifest +++ b/manifest @@ -1,5 +1,5 @@ -C Make\ssure\sthe\smin()\sand\smax()\soptimizer\sworks\scorrectly\swhen\sthere\nis\sa\sLIMIT\sclause.\s\sTicket\s#396.\s(CVS\s1057) -D 2003-07-19T00:44:14 +C Fix\sthe\sLIMIT\sclause\sso\sthat\sit\sapplies\sto\sthe\sentire\squery\sin\sa\scompound\nquery.\s\sPrior\sto\sthis\schange\sLIMITs\son\scompound\squeries\sdid\snot\swork\sat\nall.\s\sTicket\s#393.\s(CVS\s1058) +D 2003-07-20T01:16:47 F Makefile.in 9ad23ed4ca97f9670c4496432e3fbd4b3760ebde F Makefile.linux-gcc b86a99c493a5bfb402d1d9178dcdc4bd4b32f906 F README f1de682fbbd94899d50aca13d387d1b3fd3be2dd @@ -28,7 +28,7 @@ F src/build.c 13b6ae48ce71a0f59368f548dba2a662375aeaf6 F src/copy.c 9e47975ea96751c658bcf1a0c4f0bb7c6ee61e73 F src/delete.c 0f81e6799c089487615d38e042a2de4d2d6192bc F src/encode.c 25ea901a9cefb3d93774afa4a06b57cb58acf544 -F src/expr.c ebdb0f3ee039c8030de25935ce2df030966540a6 +F src/expr.c 3c07e7b5374649c4921b4ff1287f57d513876c3f F src/func.c 6b23578d48a8be98a664db145a635c2fa9ddb57b F src/hash.c 058f077c1f36f266581aa16f907a3903abf64aa3 F src/hash.h cd0433998bc1a3759d244e1637fe5a3c13b53bf8 @@ -43,11 +43,11 @@ F src/parse.y 16aed0e3ed05445fa7f6a4209cc054208c7083c0 F src/pragma.c 3b4f5a800e7a2145bc1930f323232e297d4eb782 F src/printf.c 12e45d482ac8abcc6f786fc99e5bed7dd9a51af0 F src/random.c 19e8e00fe0df32a742f115773f57651be327cabe -F src/select.c f1f3b2c2f4f30db30d03af2d0ec629ef32cb5a08 +F src/select.c 2fa83d6c972d3e3f379faee32e3621411490dedb F src/shell.c c2ba26c850874964f5ec1ebf6c43406f28e44c4a F src/shell.tcl 27ecbd63dd88396ad16d81ab44f73e6c0ea9d20e F src/sqlite.h.in 54619fa5df4c83b22def66bb3d24808fd03dcbae -F src/sqliteInt.h fed31c3e6d21b7a8a38048f8f8a07599360f8946 +F src/sqliteInt.h e3c756e5aa7bcbf7fbcd20e6aef640c9359c23f2 F src/table.c 4301926464d88d2c2c7cd21c3360aa75bf068b95 F src/tclsqlite.c d6860dcd56348b9521726280b72c412d2a33ae97 F src/test1.c b12b585bfb4763df3262975ed8d3f4f274b5eaed @@ -89,7 +89,7 @@ F test/insert2.test c288375a64dad3295044714f0dfed4a193cf067f F test/intpkey.test 9320af48415c594afd4e15f8ef0daa272e05502e F test/ioerr.test 5dbaf09f96b56ee01cf3edd762b96eb4ad2c9ca4 F test/join.test 54e770b74fc8cfc7769d5d0bb05657085641b3c4 -F test/limit.test 87ca391044ae5387cf697f5e3b21acabb03771a3 +F test/limit.test fa2a8b3fe377ebe60e0bc9a6a35af9ac4eb3d2b3 F test/lock.test 388a3a10962d2d571c0c1821cc35bf069ee73473 F test/main.test 6a851b5992c4881a725a3d9647e629199df8de9d F test/malloc.test 7ba32a9ebd3aeed52ae4aaa6d42ca37e444536fd @@ -158,7 +158,7 @@ F www/faq.tcl 88d3b95d9cd8e374772daa3a646c4d107e7f3e9b F www/fileformat.tcl ae6ccf3ffddb180a5af173cd6ee102169629762b F www/formatchng.tcl ca6cc1cb1bef9bc36f0619049d3c95e749bc6983 F www/index.tcl 30adca2dc9aba782f9188c29165129789df521f0 -F www/lang.tcl 06b825c1e88266866da3a915d0e039249ea2e4e0 +F www/lang.tcl 5f39bbda1ba38a28f18f97bd98c81f40355393b2 F www/mingw.tcl d96b451568c5d28545fefe0c80bee3431c73f69c F www/nulls.tcl 4ac1c9bbb8a20a76500d18d63b383f51bb7d8be7 F www/omitted.tcl fe59eaa9c1459cbf08fa7daa83421bfc814331bb @@ -168,7 +168,7 @@ F www/speed.tcl 2f6b1155b99d39adb185f900456d1d592c4832b3 F www/sqlite.tcl 3c83b08cf9f18aa2d69453ff441a36c40e431604 F www/tclsqlite.tcl 1db15abeb446aad0caf0b95b8b9579720e4ea331 F www/vdbe.tcl 9b9095d4495f37697fd1935d10e14c6015e80aa1 -P 558969ee8697180c74308f3f880d3240eb575af1 -R 90dfb91d095ee0113e81156a9aa2c6cc +P c35e50717678703763c696e3e9b265add2ca6454 +R b4eed2ab716bec174fb746f718cb9bae U drh -Z 4035d7869ab09e0fd1a4cac271ac32dd +Z 22959393424831715116c486cae1faab diff --git a/manifest.uuid b/manifest.uuid index 7338626804..a4cf6a2960 100644 --- a/manifest.uuid +++ b/manifest.uuid @@ -1 +1 @@ -c35e50717678703763c696e3e9b265add2ca6454 \ No newline at end of file +543479e3aed77976a0c689cf40811bf88353f706 \ No newline at end of file diff --git a/src/expr.c b/src/expr.c index d6b9b12797..7f3f96f603 100644 --- a/src/expr.c +++ b/src/expr.c @@ -12,7 +12,7 @@ ** This file contains routines used for analyzing expressions and ** for generating VDBE code that evaluates expressions in SQLite. ** -** $Id: expr.c,v 1.96 2003/05/31 16:21:12 drh Exp $ +** $Id: expr.c,v 1.97 2003/07/20 01:16:47 drh Exp $ */ #include "sqliteInt.h" #include @@ -235,6 +235,8 @@ Select *sqliteSelectDup(Select *p){ pNew->nLimit = p->nLimit; pNew->nOffset = p->nOffset; pNew->zSelect = 0; + pNew->iLimit = -1; + pNew->iOffset = -1; return pNew; } diff --git a/src/select.c b/src/select.c index b5d1727f25..e648df2daf 100644 --- a/src/select.c +++ b/src/select.c @@ -12,7 +12,7 @@ ** This file contains C code routines that are called by the parser ** to handle SELECT statements in SQLite. ** -** $Id: select.c,v 1.144 2003/07/19 00:44:14 drh Exp $ +** $Id: select.c,v 1.145 2003/07/20 01:16:47 drh Exp $ */ #include "sqliteInt.h" @@ -52,6 +52,8 @@ Select *sqliteSelectNew( pNew->op = TK_SELECT; pNew->nLimit = nLimit; pNew->nOffset = nOffset; + pNew->iLimit = -1; + pNew->iOffset = -1; } return pNew; } @@ -450,13 +452,13 @@ static int selectInnerLoop( ** to see if this row should be output. */ if( pOrderBy==0 ){ - if( p->nOffset>0 ){ + if( p->iOffset>=0 ){ int addr = sqliteVdbeCurrentAddr(v); - sqliteVdbeAddOp(v, OP_MemIncr, p->nOffset, addr+2); + sqliteVdbeAddOp(v, OP_MemIncr, p->iOffset, addr+2); sqliteVdbeAddOp(v, OP_Goto, 0, iContinue); } - if( p->nLimit>=0 ){ - sqliteVdbeAddOp(v, OP_MemIncr, p->nLimit, iBreak); + if( p->iLimit>=0 ){ + sqliteVdbeAddOp(v, OP_MemIncr, p->iLimit, iBreak); } } @@ -620,13 +622,13 @@ static void generateSortTail( if( eDest==SRT_Sorter ) return; sqliteVdbeAddOp(v, OP_Sort, 0, 0); addr = sqliteVdbeAddOp(v, OP_SortNext, 0, end); - if( p->nOffset>0 ){ - sqliteVdbeAddOp(v, OP_MemIncr, p->nOffset, addr+4); + if( p->iOffset>=0 ){ + sqliteVdbeAddOp(v, OP_MemIncr, p->iOffset, addr+4); sqliteVdbeAddOp(v, OP_Pop, 1, 0); sqliteVdbeAddOp(v, OP_Goto, 0, addr); } - if( p->nLimit>=0 ){ - sqliteVdbeAddOp(v, OP_MemIncr, p->nLimit, end); + if( p->iLimit>=0 ){ + sqliteVdbeAddOp(v, OP_MemIncr, p->iLimit, end); } switch( eDest ){ case SRT_Callback: { @@ -1244,6 +1246,52 @@ static void multiSelectSortOrder(Select *p, ExprList *pOrderBy){ } } +/* +** Compute the iLimit and iOffset fields of the SELECT based on the +** nLimit and nOffset fields. nLimit and nOffset hold the integers +** that appear in the original SQL statement after the LIMIT and OFFSET +** keywords. Or that hold -1 and 0 if those keywords are omitted. +** iLimit and iOffset are the integer memory register numbers for +** counters used to compute the limit and offset. If there is no +** limit and/or offset, then iLimit and iOffset are negative. +** +** This routine changes the values if iLimit and iOffset only if +** a limit or offset is defined by nLimit and nOffset. iLimit and +** iOffset should have been preset to appropriate default values +** (usually but not always -1) prior to calling this routine. +** Only if nLimit>=0 or nOffset>0 do the limit registers get +** redefined. The UNION ALL operator uses this property to force +** the reuse of the same limit and offset registers across multiple +** SELECT statements. +*/ +static void computeLimitRegisters(Parse *pParse, Select *p){ + /* + ** If the comparison is p->nLimit>0 then "LIMIT 0" shows + ** all rows. It is the same as no limit. If the comparision is + ** p->nLimit>=0 then "LIMIT 0" show no rows at all. + ** "LIMIT -1" always shows all rows. There is some + ** contraversy about what the correct behavior should be. + ** The current implementation interprets "LIMIT 0" to mean + ** no rows. + */ + if( p->nLimit>=0 ){ + int iMem = pParse->nMem++; + Vdbe *v = sqliteGetVdbe(pParse); + if( v==0 ) return; + sqliteVdbeAddOp(v, OP_Integer, -p->nLimit, 0); + sqliteVdbeAddOp(v, OP_MemStore, iMem, 1); + p->iLimit = iMem; + } + if( p->nOffset>0 ){ + int iMem = pParse->nMem++; + Vdbe *v = sqliteGetVdbe(pParse); + if( v==0 ) return; + sqliteVdbeAddOp(v, OP_Integer, -p->nOffset, 0); + sqliteVdbeAddOp(v, OP_MemStore, iMem, 1); + p->iOffset = iMem; + } +} + /* ** This routine is called to process a query that is really the union ** or intersection of two or more separate queries. @@ -1279,8 +1327,8 @@ static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ Select *pPrior; /* Another SELECT immediately to our left */ Vdbe *v; /* Generate code to this VDBE */ - /* Make sure there is no ORDER BY clause on prior SELECTs. Only the - ** last SELECT in the series may have an ORDER BY. + /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only + ** the last SELECT in the series may have an ORDER BY or LIMIT. */ if( p==0 || p->pPrior==0 ) return 1; pPrior = p->pPrior; @@ -1289,6 +1337,11 @@ static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ selectOpName(p->op)); return 1; } + if( pPrior->nLimit>=0 || pPrior->nOffset>0 ){ + sqliteErrorMsg(pParse,"LIMIT clause should come after %s not before", + selectOpName(p->op)); + return 1; + } /* Make sure we have a valid query engine. If not, create a new one. */ @@ -1307,9 +1360,15 @@ static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ switch( p->op ){ case TK_ALL: { if( p->pOrderBy==0 ){ + pPrior->nLimit = p->nLimit; + pPrior->nOffset = p->nOffset; rc = sqliteSelect(pParse, pPrior, eDest, iParm, 0, 0, 0); if( rc ) return rc; p->pPrior = 0; + p->iLimit = pPrior->iLimit; + p->iOffset = pPrior->iOffset; + p->nLimit = -1; + p->nOffset = 0; rc = sqliteSelect(pParse, p, eDest, iParm, 0, 0, 0); p->pPrior = pPrior; if( rc ) return rc; @@ -1322,10 +1381,11 @@ static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ int unionTab; /* Cursor number of the temporary table holding result */ int op; /* One of the SRT_ operations to apply to self */ int priorOp; /* The SRT_ operation to apply to prior selects */ + int nLimit, nOffset; /* Saved values of p->nLimit and p->nOffset */ ExprList *pOrderBy; /* The ORDER BY clause for the right SELECT */ priorOp = p->op==TK_ALL ? SRT_Table : SRT_Union; - if( eDest==priorOp && p->pOrderBy==0 ){ + if( eDest==priorOp && p->pOrderBy==0 && p->nLimit<0 && p->nOffset==0 ){ /* We can reuse a temporary table generated by a SELECT to our ** right. */ @@ -1362,9 +1422,15 @@ static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ p->pPrior = 0; pOrderBy = p->pOrderBy; p->pOrderBy = 0; + nLimit = p->nLimit; + p->nLimit = -1; + nOffset = p->nOffset; + p->nOffset = 0; rc = sqliteSelect(pParse, p, op, unionTab, 0, 0, 0); p->pPrior = pPrior; p->pOrderBy = pOrderBy; + p->nLimit = nLimit; + p->nOffset = nOffset; if( rc ) return rc; /* Convert the data in the temporary table into whatever form @@ -1380,6 +1446,7 @@ static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ iBreak = sqliteVdbeMakeLabel(v); iCont = sqliteVdbeMakeLabel(v); sqliteVdbeAddOp(v, OP_Rewind, unionTab, iBreak); + computeLimitRegisters(pParse, p); iStart = sqliteVdbeCurrentAddr(v); multiSelectSortOrder(p, p->pOrderBy); rc = selectInnerLoop(pParse, p, p->pEList, unionTab, p->pEList->nExpr, @@ -1399,6 +1466,7 @@ static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ case TK_INTERSECT: { int tab1, tab2; int iCont, iBreak, iStart; + int nLimit, nOffset; /* INTERSECT is different from the others since it requires ** two temporary tables. Hence it has its own case. Begin @@ -1422,8 +1490,14 @@ static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ sqliteVdbeAddOp(v, OP_OpenTemp, tab2, 1); sqliteVdbeAddOp(v, OP_KeyAsData, tab2, 1); p->pPrior = 0; + nLimit = p->nLimit; + p->nLimit = -1; + nOffset = p->nOffset; + p->nOffset = 0; rc = sqliteSelect(pParse, p, SRT_Union, tab2, 0, 0, 0); p->pPrior = pPrior; + p->nLimit = nLimit; + p->nOffset = nOffset; if( rc ) return rc; /* Generate code to take the intersection of the two temporary @@ -1437,6 +1511,7 @@ static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ iBreak = sqliteVdbeMakeLabel(v); iCont = sqliteVdbeMakeLabel(v); sqliteVdbeAddOp(v, OP_Rewind, tab1, iBreak); + computeLimitRegisters(pParse, p); iStart = sqliteVdbeAddOp(v, OP_FullKey, tab1, 0); sqliteVdbeAddOp(v, OP_NotFound, tab2, iCont); multiSelectSortOrder(p, p->pOrderBy); @@ -1869,6 +1944,7 @@ static int simpleMinMaxQuery(Parse *pParse, Select *p, int eDest, int iParm){ */ sqliteCodeVerifySchema(pParse, pTab->iDb); base = p->pSrc->a[0].iCursor; + computeLimitRegisters(pParse, p); sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); sqliteVdbeAddOp(v, OP_OpenRead, base, pTab->tnum); sqliteVdbeChangeP3(v, -1, pTab->zName, P3_STATIC); @@ -2132,39 +2208,6 @@ int sqliteSelect( generateColumnNames(pParse, pTabList, pEList); } - /* Set the limiter. - ** - ** The phrase "LIMIT 0" means all rows are shown, not zero rows. - ** If the comparison is p->nLimit<=0 then "LIMIT 0" shows - ** all rows. It is the same as no limit. If the comparision is - ** p->nLimit<0 then "LIMIT 0" show no rows at all. - ** "LIMIT -1" always shows all rows. There is some - ** contraversy about what the correct behavior should be. - ** - ** Note that up until this point, the nLimit and nOffset hold - ** the numeric values of the limit and offset that appeared in - ** the original SQL. After this code, the nLimit and nOffset hold - ** the register number of counters used to track the limit and - ** offset. - */ - if( p->nLimit<0 ){ - p->nLimit = -1; - }else{ - int iMem = pParse->nMem++; - sqliteVdbeAddOp(v, OP_Integer, -p->nLimit, 0); - sqliteVdbeAddOp(v, OP_MemStore, iMem, 1); - p->nLimit = iMem; - } - if( p->nOffset<=0 ){ - p->nOffset = 0; - }else{ - int iMem = pParse->nMem++; - if( iMem==0 ) iMem = pParse->nMem++; - sqliteVdbeAddOp(v, OP_Integer, -p->nOffset, 0); - sqliteVdbeAddOp(v, OP_MemStore, iMem, 1); - p->nOffset = iMem; - } - /* Check for the special case of a min() or max() function by itself ** in the result set. */ @@ -2211,6 +2254,10 @@ int sqliteSelect( return rc; } + /* Set the limiter. + */ + computeLimitRegisters(pParse, p); + /* Identify column types if we will be using a callback. This ** step is skipped if the output is going to a destination other ** than a callback. diff --git a/src/sqliteInt.h b/src/sqliteInt.h index ceb54c727a..465f6af48c 100644 --- a/src/sqliteInt.h +++ b/src/sqliteInt.h @@ -11,7 +11,7 @@ ************************************************************************* ** Internal interface definitions for SQLite. ** -** @(#) $Id: sqliteInt.h,v 1.193 2003/06/23 11:06:02 drh Exp $ +** @(#) $Id: sqliteInt.h,v 1.194 2003/07/20 01:16:47 drh Exp $ */ #include "config.h" #include "sqlite.h" @@ -778,16 +778,17 @@ struct WhereInfo { ** in the VDBE that record the limit and offset counters. */ struct Select { - int isDistinct; /* True if the DISTINCT keyword is present */ ExprList *pEList; /* The fields of the result */ + u8 op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */ + u8 isDistinct; /* True if the DISTINCT keyword is present */ SrcList *pSrc; /* The FROM clause */ Expr *pWhere; /* The WHERE clause */ ExprList *pGroupBy; /* The GROUP BY clause */ Expr *pHaving; /* The HAVING clause */ ExprList *pOrderBy; /* The ORDER BY clause */ - int op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */ Select *pPrior; /* Prior select in a compound select statement */ int nLimit, nOffset; /* LIMIT and OFFSET values. -1 means not used */ + int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */ char *zSelect; /* Complete text of the SELECT command */ }; diff --git a/test/limit.test b/test/limit.test index aabab4fce6..66d6d51155 100644 --- a/test/limit.test +++ b/test/limit.test @@ -12,7 +12,7 @@ # focus of this file is testing the LIMIT ... OFFSET ... clause # of SELECT statements. # -# $Id: limit.test,v 1.9 2003/07/16 11:51:36 drh Exp $ +# $Id: limit.test,v 1.10 2003/07/20 01:16:48 drh Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl @@ -213,4 +213,84 @@ do_test limit-6.8 { } } {} +# Make sure LIMIT works well with compound SELECT statements. +# Ticket #393 +# +do_test limit-7.1.1 { + catchsql { + SELECT x FROM t2 LIMIT 5 UNION ALL SELECT a FROM t6; + } +} {1 {LIMIT clause should come after UNION ALL not before}} +do_test limit-7.1.2 { + catchsql { + SELECT x FROM t2 LIMIT 5 UNION SELECT a FROM t6; + } +} {1 {LIMIT clause should come after UNION not before}} +do_test limit-7.1.3 { + catchsql { + SELECT x FROM t2 LIMIT 5 EXCEPT SELECT a FROM t6 LIMIT 3; + } +} {1 {LIMIT clause should come after EXCEPT not before}} +do_test limit-7.1.4 { + catchsql { + SELECT x FROM t2 LIMIT 0,5 INTERSECT SELECT a FROM t6; + } +} {1 {LIMIT clause should come after INTERSECT not before}} +do_test limit-7.2 { + execsql { + SELECT x FROM t2 UNION ALL SELECT a FROM t6 LIMIT 5; + } +} {31 30 1 2 3} +do_test limit-7.3 { + execsql { + SELECT x FROM t2 UNION ALL SELECT a FROM t6 LIMIT 3 OFFSET 1; + } +} {30 1 2} +do_test limit-7.4 { + execsql { + SELECT x FROM t2 UNION ALL SELECT a FROM t6 ORDER BY 1 LIMIT 3 OFFSET 1; + } +} {2 3 4} +do_test limit-7.5 { + execsql { + SELECT x FROM t2 UNION SELECT x+2 FROM t2 LIMIT 2 OFFSET 1; + } +} {31 32} +do_test limit-7.6 { + execsql { + SELECT x FROM t2 UNION SELECT x+2 FROM t2 ORDER BY 1 DESC LIMIT 2 OFFSET 1; + } +} {32 31} +do_test limit-7.7 { + execsql { + SELECT a+9 FROM t6 EXCEPT SELECT y FROM t2 LIMIT 2; + } +} {11 12} +do_test limit-7.8 { + execsql { + SELECT a+9 FROM t6 EXCEPT SELECT y FROM t2 ORDER BY 1 DESC LIMIT 2; + } +} {13 12} +do_test limit-7.9 { + execsql { + SELECT a+26 FROM t6 INTERSECT SELECT x FROM t2 LIMIT 1; + } +} {30} +do_test limit-7.10 { + execsql { + SELECT a+27 FROM t6 INTERSECT SELECT x FROM t2 LIMIT 1; + } +} {30} +do_test limit-7.11 { + execsql { + SELECT a+27 FROM t6 INTERSECT SELECT x FROM t2 LIMIT 1 OFFSET 1; + } +} {31} +do_test limit-7.12 { + execsql { + SELECT a+27 FROM t6 INTERSECT SELECT x FROM t2 + ORDER BY 1 DESC LIMIT 1 OFFSET 1; + } +} {30} + finish_test diff --git a/www/lang.tcl b/www/lang.tcl index f7b0f32ce2..7321db114e 100644 --- a/www/lang.tcl +++ b/www/lang.tcl @@ -1,7 +1,7 @@ # # Run this Tcl script to generate the sqlite.html file. # -set rcsid {$Id: lang.tcl,v 1.64 2003/07/16 11:51:36 drh Exp $} +set rcsid {$Id: lang.tcl,v 1.65 2003/07/20 01:16:48 drh Exp $} puts { @@ -1552,7 +1552,12 @@ the sort order.

The LIMIT clause places an upper bound on the number of rows returned in the result. A negative LIMIT indicates no upper bound. The optional OFFSET following LIMIT specifies how many -rows to skip at the beginning of the result set.

+rows to skip at the beginning of the result set. +In a compound query, the LIMIT clause may only appear on the +final SELECT statement. +The limit is applied to the entire query not +to the individual SELECT statement to which it is attached. +

A compound SELECT is formed from two or more simple SELECTs connected by one of the operators UNION, UNION ALL, INTERSECT, or EXCEPT. In