-C Add\sa\snumeric\sversion\snumber.\sTicket\s#1097.\s(CVS\s2315)
-D 2005-02-05T07:33:34
+C Allow\sexpressions\s(including\svariables)\sin\sLIMIT\sand\sOFFSET\sclauses.\sTicket\s#1096.\s(CVS\s2316)
+D 2005-02-05T12:48:48
F Makefile.in d928187101fa3d78426cf48ca30e39d0fb714e57
F Makefile.linux-gcc a9e5a0d309fa7c38e7c14d3ecf7690879d3a5457
F README a01693e454a00cc117967e3f9fdab2d4d52e9bc1
F src/date.c f3d1f5cd1503dabf426a198f3ebef5afbc122a7f
F src/delete.c 4b94395b52a8f7785acd71135c2ce54f3f5550b3
F src/experimental.c 8cc66b2be6a011055d75ef19ed2584bcfbb585ad
-F src/expr.c 2ed29dc4f8feeb55eafa40d41941ad7909666863
+F src/expr.c 1b6b6b16bcb6a6dcc4a5df451d9e652f84b269ae
F src/func.c f096b6771cc0aaa11790aca95773a50a8f74ba73
F src/hash.c 2b1b13f7400e179631c83a1be0c664608c8f021f
F src/hash.h 1b0c445e1c89ff2aaad9b4605ba61375af001e84
F src/os_win.h 41a946bea10f61c158ce8645e7646b29d44f122b
F src/pager.c d21565d0e844712809140632062a7b72b768fdff
F src/pager.h 9eba8c53dd91eae7f3f90743b2ee242da02a9862
-F src/parse.y 7a4965d65c6c8a1f5012bf365c54c8dea09a3921
+F src/parse.y ee046c1ea30425a817285e52fb1993c2f955e766
F src/pragma.c 572d7dd4f9c9d020ca2967a1c3ec02c3126e9631
F src/printf.c 3d20b21cfecadacecac3fb7274e746cb81d3d357
F src/random.c eff68e3f257e05e81eae6c4d50a51eb88beb4ff3
-F src/select.c 16c750c000f0d6aa543c778e2c752154b7272336
+F src/select.c 6217e1f72cee7e173b21b252fd42a052f3b4decc
F src/shell.c 3cb0ef124ed9cd582ce89aec59ff7c659bc6e61b
F src/sqlite.h.in c85f6bad9ca7de29f505fe886646cfff7df4c55e
-F src/sqliteInt.h f10da39b6407af63002401c7f9cee4a1313f4d2d
+F src/sqliteInt.h 58e9365c0f575ef42973439caf3bbab450ad700b
F src/table.c 25b3ff2b39b7d87e8d4a5da0713d68dfc06cbee9
F src/tclsqlite.c 101994a2c4c0eaa69f1de9bfe4a02167f6049e7d
F src/test1.c feac8a742aca920c8ab18a43b3208ae3a834fe9d
F src/update.c b6f4668c11059f86b71581187d09197fa28ec4be
F src/utf.c bda5eb85039ef16f2d17004c1e18c96e1ab0a80c
F src/util.c 1b7b9a127b66743ab6cba8d44597aeb570723c99
-F src/vacuum.c 14d1c346234fc64b326c19ea1ffe8f9e4c73d19a
-F src/vdbe.c d2c29d2ada955818afa910c3204e5a5d145ceaea
+F src/vacuum.c 4dbe45a5c41674a04ac45a7586031583386ab119
+F src/vdbe.c 5acf43749f44b0813d47f4b1801538f4aaa7ddbb
F src/vdbe.h bb9186484f749a839c6c43953e79a6530253f7cd
F src/vdbeInt.h e80721cd8ff611789e20743eec43363a9fb5a48e
F src/vdbeapi.c 467caa6e6fb9247528b1c7ab9132ae1b4748e8ac
F test/collate5.test 581775b94604b7435dc6a5c6e72fbbf7d69e3830
F test/collate6.test 6c9470d1606ee3e564675b229653e320c49ec638
F test/conflict.test c5b849b01cfbe0a4f63a90cba6f68e2fe3a75f87
-F test/corrupt.test 34e031add52cb1f50aff722f7d4ebd7b972637d3
+F test/corrupt.test c34304baf2f027e05942af2efeb26844adca9a53
F test/corrupt2.test 88342570828f2b8cbbd8369eff3891f5c0bdd5ba
F test/crash.test f38b980a0508655d08c957a6dd27d66bca776504
F test/crashtest1.c 09c1c7d728ccf4feb9e481671e29dda5669bbcc2
F test/join4.test cc6cafe85e11aacacd0abcd247a46bed251308f8
F test/lastinsert.test b6a1db3e1ce2d3f0d6afe99d445084f543b6feaa
F test/laststmtchanges.test 07cbdabc52407c29e40abc25050f2434f044a6b1
-F test/limit.test f833e610ab26c618487c36f62baf6458f9284ce6
+F test/limit.test 270b076f31c5c32f7187de5727e74da4de43e477
F test/lock.test a19aab9a963273fe61c1058e3d1b648d6a0a2425
F test/lock2.test 59c3dd7d9b24d1bf7ec91b2d1541c37e97939d5f
F test/lock3.test 615111293cf32aa2ed16d01c6611737651c96fb9
F www/vdbe.tcl 095f106d93875c94b47367384ebc870517431618
F www/version3.tcl 092a01f5ef430d2c4acc0ae558d74c4bb89638a0
F www/whentouse.tcl 3e522a06ad41992023c80ca29a048ae2331ca5bd
-P 6d91a1e91bf0e8b4a0f5f78d079031f3ee69603b
-R 752d291cdd1da93d3f1d71a58abca891
+P a9c33a804d572dd9df15be2029637b10e5a65cc4
+R 0ba525d8e5e37833bac3706da6208349
U danielk1977
-Z bc43e9a2df7fa6f5203156118f2ad652
+Z 5a32f92efa7eeaf1966c77064b18ce7a
-a9c33a804d572dd9df15be2029637b10e5a65cc4
\ No newline at end of file
+515e5033a5482f55e7edb66d69ff3da7e234ff2e
\ No newline at end of file
** This file contains routines used for analyzing expressions and
** for generating VDBE code that evaluates expressions in SQLite.
**
-** $Id: expr.c,v 1.191 2005/02/04 04:07:17 danielk1977 Exp $
+** $Id: expr.c,v 1.192 2005/02/05 12:48:48 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
pNew->pOrderBy = sqlite3ExprListDup(p->pOrderBy);
pNew->op = p->op;
pNew->pPrior = sqlite3SelectDup(p->pPrior);
- pNew->nLimit = p->nLimit;
- pNew->nOffset = p->nOffset;
+ pNew->pLimit = sqlite3ExprDup(p->pLimit);
+ pNew->pOffset = sqlite3ExprDup(p->pOffset);
pNew->iLimit = -1;
pNew->iOffset = -1;
pNew->ppOpenTemp = 0;
** the parser. Lemon will also generate a header file containing
** numeric codes for all of the tokens.
**
-** @(#) $Id: parse.y,v 1.164 2005/02/04 04:07:17 danielk1977 Exp $
+** @(#) $Id: parse.y,v 1.165 2005/02/05 12:48:48 danielk1977 Exp $
*/
%token_prefix TK_
%token_type {Token}
** LIMIT clause of a SELECT statement.
*/
struct LimitVal {
- int limit; /* The LIMIT value. -1 if there is no limit */
- int offset; /* The OFFSET. 0 if there is none */
+ Expr *pLimit; /* The LIMIT expression. NULL if there is no limit */
+ Expr *pOffset; /* The OFFSET expression. NULL if there is none */
};
/*
%endif // SQLITE_OMIT_COMPOUND_SELECT
oneselect(A) ::= SELECT distinct(D) selcollist(W) from(X) where_opt(Y)
groupby_opt(P) having_opt(Q) orderby_opt(Z) limit_opt(L). {
- A = sqlite3SelectNew(W,X,Y,P,Q,Z,D,L.limit,L.offset);
+ A = sqlite3SelectNew(W,X,Y,P,Q,Z,D,L.pLimit,L.pOffset);
}
// The "distinct" nonterminal is true (1) if the DISTINCT keyword is
%destructor seltablist_paren {sqlite3SelectDelete($$);}
seltablist_paren(A) ::= select(S). {A = S;}
seltablist_paren(A) ::= seltablist(F). {
- A = sqlite3SelectNew(0,F,0,0,0,0,0,-1,0);
+ A = sqlite3SelectNew(0,F,0,0,0,0,0,0,0);
}
%endif // SQLITE_OMIT_SUBQUERY
having_opt(A) ::= HAVING expr(X). {A = X;}
%type limit_opt {struct LimitVal}
-limit_opt(A) ::= . {A.limit = -1; A.offset = 0;}
-limit_opt(A) ::= LIMIT signed(X). {A.limit = X; A.offset = 0;}
-limit_opt(A) ::= LIMIT signed(X) OFFSET signed(Y).
- {A.limit = X; A.offset = Y;}
-limit_opt(A) ::= LIMIT signed(X) COMMA signed(Y).
- {A.limit = Y; A.offset = X;}
+%destructor limit_opt {
+ sqlite3ExprDelete($$.pLimit);
+ sqlite3ExprDelete($$.pOffset);
+}
+limit_opt(A) ::= . {A.pLimit = 0; A.pOffset = 0;}
+limit_opt(A) ::= LIMIT expr(X). {A.pLimit = X; A.pOffset = 0;}
+limit_opt(A) ::= LIMIT expr(X) OFFSET expr(Y).
+ {A.pLimit = X; A.pOffset = Y;}
+limit_opt(A) ::= LIMIT expr(X) COMMA expr(Y).
+ {A.pOffset = X; A.pLimit = Y;}
/////////////////////////// The DELETE statement /////////////////////////////
//
expr(A) ::= expr(X) in_op(N) nm(Y) dbnm(Z). [IN] {
SrcList *pSrc = sqlite3SrcListAppend(0,&Y,&Z);
A = sqlite3Expr(TK_IN, X, 0, 0);
- if( A ) A->pSelect = sqlite3SelectNew(0,pSrc,0,0,0,0,0,-1,0);
+ if( A ) A->pSelect = sqlite3SelectNew(0,pSrc,0,0,0,0,0,0,0);
if( N ) A = sqlite3Expr(TK_NOT, A, 0, 0);
sqlite3ExprSpan(A,&X->span,Z.z?&Z:&Y);
}
** This file contains C code routines that are called by the parser
** to handle SELECT statements in SQLite.
**
-** $Id: select.c,v 1.238 2005/02/04 04:07:17 danielk1977 Exp $
+** $Id: select.c,v 1.239 2005/02/05 12:48:48 danielk1977 Exp $
*/
#include "sqliteInt.h"
Expr *pHaving, /* the HAVING clause */
ExprList *pOrderBy, /* the ORDER BY clause */
int isDistinct, /* true if the DISTINCT keyword is present */
- int nLimit, /* LIMIT value. -1 means not used */
- int nOffset /* OFFSET value. 0 means no offset */
+ Expr *pLimit, /* LIMIT value. NULL means not used */
+ Expr *pOffset /* OFFSET value. NULL means no offset */
){
Select *pNew;
pNew = sqliteMalloc( sizeof(*pNew) );
+ assert( !pOffset || pLimit ); /* Can't have OFFSET without LIMIT. */
if( pNew==0 ){
sqlite3ExprListDelete(pEList);
sqlite3SrcListDelete(pSrc);
sqlite3ExprListDelete(pGroupBy);
sqlite3ExprDelete(pHaving);
sqlite3ExprListDelete(pOrderBy);
+ sqlite3ExprDelete(pLimit);
+ sqlite3ExprDelete(pOffset);
}else{
if( pEList==0 ){
pEList = sqlite3ExprListAppend(0, sqlite3Expr(TK_ALL,0,0,0), 0);
pNew->pOrderBy = pOrderBy;
pNew->isDistinct = isDistinct;
pNew->op = TK_SELECT;
- pNew->nLimit = nLimit;
- pNew->nOffset = nOffset;
+ pNew->pLimit = pLimit;
+ pNew->pOffset = pOffset;
pNew->iLimit = -1;
pNew->iOffset = -1;
}
sqlite3ExprDelete(p->pHaving);
sqlite3ExprListDelete(p->pOrderBy);
sqlite3SelectDelete(p->pPrior);
+ sqlite3ExprDelete(p->pLimit);
+ sqlite3ExprDelete(p->pOffset);
sqliteFree(p);
}
-/*
-** Delete the aggregate information from the parse structure.
-*/
-#if 0
-static void sqliteAggregateInfoReset(Parse *pParse){
- sqliteFree(pParse->aAgg);
- pParse->aAgg = 0;
- pParse->nAgg = 0;
- pParse->useAgg = 0;
-}
-#endif
-
/*
** Insert code into "v" that will push the record on the top of the
** stack into the sorter.
int nPop /* Number of times to pop stack when jumping */
){
if( p->iOffset>=0 ){
- int addr = sqlite3VdbeCurrentAddr(v) + 2;
+ int addr = sqlite3VdbeCurrentAddr(v) + 3;
if( nPop>0 ) addr++;
- sqlite3VdbeAddOp(v, OP_MemIncr, p->iOffset, addr);
+ sqlite3VdbeAddOp(v, OP_MemIncr, p->iOffset, 0);
+ sqlite3VdbeAddOp(v, OP_IfMemPos, p->iOffset, addr);
if( nPop>0 ){
sqlite3VdbeAddOp(v, OP_Pop, nPop, 0);
}
/*
** Compute the iLimit and iOffset fields of the SELECT based on the
-** nLimit and nOffset fields. nLimit and nOffset hold the integers
+** pLimit and pOffset expressions. nLimit and nOffset hold the expressions
** 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.
+** keywords. Or NULL 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
*/
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 ){
+ if( p->pLimit ){
int iMem = pParse->nMem++;
Vdbe *v = sqlite3GetVdbe(pParse);
if( v==0 ) return;
- sqlite3VdbeAddOp(v, OP_Integer, -p->nLimit, 0);
+ sqlite3ExprCode(pParse, p->pLimit);
+ sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0);
+ sqlite3VdbeAddOp(v, OP_Negative, 0, 0);
sqlite3VdbeAddOp(v, OP_MemStore, iMem, 1);
VdbeComment((v, "# LIMIT counter"));
p->iLimit = iMem;
}
- if( p->nOffset>0 ){
+ if( p->pOffset ){
int iMem = pParse->nMem++;
Vdbe *v = sqlite3GetVdbe(pParse);
if( v==0 ) return;
- sqlite3VdbeAddOp(v, OP_Integer, -p->nOffset, 0);
+ sqlite3ExprCode(pParse, p->pOffset);
+ sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0);
+ sqlite3VdbeAddOp(v, OP_Negative, 0, 0);
sqlite3VdbeAddOp(v, OP_MemStore, iMem, 1);
VdbeComment((v, "# OFFSET counter"));
p->iOffset = iMem;
rc = 1;
goto multi_select_end;
}
- if( pPrior->nLimit>=0 || pPrior->nOffset>0 ){
+ if( pPrior->pLimit ){
sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before",
selectOpName(p->op));
rc = 1;
switch( p->op ){
case TK_ALL: {
if( p->pOrderBy==0 ){
- pPrior->nLimit = p->nLimit;
- pPrior->nOffset = p->nOffset;
+ assert( !pPrior->pLimit );
+ pPrior->pLimit = p->pLimit;
+ pPrior->pOffset = p->pOffset;
rc = sqlite3Select(pParse, pPrior, eDest, iParm, 0, 0, 0, aff);
if( rc ){
goto multi_select_end;
p->pPrior = 0;
p->iLimit = pPrior->iLimit;
p->iOffset = pPrior->iOffset;
- p->nLimit = -1;
- p->nOffset = 0;
+ p->pLimit = 0;
+ p->pOffset = 0;
rc = sqlite3Select(pParse, p, eDest, iParm, 0, 0, 0, aff);
p->pPrior = pPrior;
if( rc ){
int unionTab; /* Cursor number of the temporary table holding result */
int op = 0; /* 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 */
+ Expr *pLimit, *pOffset; /* Saved values of p->nLimit and p->nOffset */
+ ExprList *pOrderBy; /* The ORDER BY clause for the right SELECT */
int addr;
priorOp = p->op==TK_ALL ? SRT_Table : SRT_Union;
- if( eDest==priorOp && p->pOrderBy==0 && p->nLimit<0 && p->nOffset==0 ){
+ if( eDest==priorOp && p->pOrderBy==0 && !p->pLimit && !p->pOffset ){
/* We can reuse a temporary table generated by a SELECT to our
** right.
*/
p->pPrior = 0;
pOrderBy = p->pOrderBy;
p->pOrderBy = 0;
- nLimit = p->nLimit;
- p->nLimit = -1;
- nOffset = p->nOffset;
- p->nOffset = 0;
+ pLimit = p->pLimit;
+ p->pLimit = 0;
+ pOffset = p->pOffset;
+ p->pOffset = 0;
rc = sqlite3Select(pParse, p, op, unionTab, 0, 0, 0, aff);
p->pPrior = pPrior;
p->pOrderBy = pOrderBy;
- p->nLimit = nLimit;
- p->nOffset = nOffset;
+ sqlite3ExprDelete(p->pLimit);
+ p->pLimit = pLimit;
+ p->pOffset = pOffset;
p->iLimit = -1;
p->iOffset = -1;
if( rc ){
case TK_INTERSECT: {
int tab1, tab2;
int iCont, iBreak, iStart;
- int nLimit, nOffset;
+ Expr *pLimit, *pOffset;
int addr;
/* INTERSECT is different from the others since it requires
assert( nAddr<sizeof(aAddr)/sizeof(aAddr[0]) );
aAddr[nAddr++] = sqlite3VdbeAddOp(v, OP_SetNumColumns, tab2, 0);
p->pPrior = 0;
- nLimit = p->nLimit;
- p->nLimit = -1;
- nOffset = p->nOffset;
- p->nOffset = 0;
+ pLimit = p->pLimit;
+ p->pLimit = 0;
+ pOffset = p->pOffset;
+ p->pOffset = 0;
rc = sqlite3Select(pParse, p, SRT_Union, tab2, 0, 0, 0, aff);
p->pPrior = pPrior;
- p->nLimit = nLimit;
- p->nOffset = nOffset;
+ sqlite3ExprDelete(p->pLimit);
+ p->pLimit = pLimit;
+ p->pOffset = pOffset;
if( rc ){
goto multi_select_end;
}
if( subqueryIsAgg && pSrc->nSrc>1 ) return 0;
pSubSrc = pSub->pSrc;
assert( pSubSrc );
+ if( (pSub->pLimit && p->pLimit) || pSub->pOffset ||
+ (pSub->pLimit && isAgg) ) return 0;
if( pSubSrc->nSrc==0 ) return 0;
- if( (pSub->isDistinct || pSub->nLimit>=0) && (pSrc->nSrc>1 || isAgg) ){
+ if( pSub->isDistinct && (pSrc->nSrc>1 || isAgg) ){
return 0;
}
- if( (p->isDistinct || p->nLimit>=0) && subqueryIsAgg ) return 0;
+ if( p->isDistinct && subqueryIsAgg ) return 0;
if( p->pOrderBy && pSub->pOrderBy ) return 0;
/* Restriction 3: If the subquery is a join, make sure the subquery is
*/
p->isDistinct = p->isDistinct || pSub->isDistinct;
- /* Transfer the limit expression from the subquery to the outer
- ** query.
- */
- if( pSub->nLimit>=0 ){
- if( p->nLimit<0 ){
- p->nLimit = pSub->nLimit;
- }else if( p->nLimit+p->nOffset > pSub->nLimit+pSub->nOffset ){
- p->nLimit = pSub->nLimit + pSub->nOffset - p->nOffset;
- }
+ if( pSub->pLimit ){
+ p->pLimit = pSub->pLimit;
+ pSub->pLimit = 0;
}
- p->nOffset += pSub->nOffset;
/* Finially, delete what is left of the subquery and return
** success.
return SQLITE_ERROR;
}
- /* Set up the local name-context to pass to ExprResolveNames(). */
- sNC.pNext = pOuterNC;
+ /* Resolve the expressions in the LIMIT and OFFSET clauses. These
+ ** are not allowed to refer to any names, so pass an empty NameContext.
+ */
sNC.pParse = pParse;
- sNC.pSrcList = p->pSrc;
- sNC.allowAgg = 1;
sNC.hasAgg = 0;
sNC.nErr = 0;
sNC.nRef = 0;
sNC.pEList = 0;
+ sNC.allowAgg = 0;
+ sNC.pSrcList = 0;
+ sNC.pNext = 0;
+ if( sqlite3ExprResolveNames(&sNC, p->pLimit) ||
+ sqlite3ExprResolveNames(&sNC, p->pOffset) ){
+ return SQLITE_ERROR;
+ }
+
+ /* Set up the local name-context to pass to ExprResolveNames() to
+ ** resolve the expression-list.
+ */
+ sNC.allowAgg = 1;
+ sNC.pSrcList = p->pSrc;
+ sNC.pNext = pOuterNC;
/* NameContext.nDepth stores the depth of recursion for this query. For
** an outer query (e.g. SELECT * FROM sqlite_master) this is 1. For
*************************************************************************
** Internal interface definitions for SQLite.
**
-** @(#) $Id: sqliteInt.h,v 1.366 2005/02/04 04:07:17 danielk1977 Exp $
+** @(#) $Id: sqliteInt.h,v 1.367 2005/02/05 12:48:48 danielk1977 Exp $
*/
#ifndef _SQLITEINT_H_
#define _SQLITEINT_H_
Expr *pHaving; /* The HAVING clause */
ExprList *pOrderBy; /* The ORDER BY clause */
Select *pPrior; /* Prior select in a compound select statement */
- int nLimit, nOffset; /* LIMIT and OFFSET values. -1 means not used */
+ Expr *pLimit; /* LIMIT expression. NULL means not used. */
+ Expr *pOffset; /* OFFSET expression. NULL means not used. */
int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */
IdList **ppOpenTemp; /* OP_OpenTemp addresses used by multi-selects */
Fetch *pFetch; /* If this stmt is part of a FETCH command */
void sqlite3AddIdxKeyType(Vdbe*, Index*);
int sqlite3Select(Parse*, Select*, int, int, Select*, int, int*, char *aff);
Select *sqlite3SelectNew(ExprList*,SrcList*,Expr*,ExprList*,Expr*,ExprList*,
- int,int,int);
+ int,Expr*,Expr*);
void sqlite3SelectDelete(Select*);
void sqlite3SelectUnbind(Select*);
Table *sqlite3SrcListLookup(Parse*, SrcList*);
** Most of the code in this file may be omitted by defining the
** SQLITE_OMIT_VACUUM macro.
**
-** $Id: vacuum.c,v 1.37 2005/02/03 01:08:20 drh Exp $
+** $Id: vacuum.c,v 1.38 2005/02/05 12:48:48 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "os.h"
rc = execExecSql(db,
"SELECT 'DELETE FROM vacuum_db.' || quote(name) || ';' "
"FROM sqlite_master WHERE name='sqlite_sequence' "
- "UNION ALL "
+ );
+ if( rc!=SQLITE_OK ) goto end_of_vacuum;
+ rc = execExecSql(db,
"SELECT 'INSERT INTO vacuum_db.' || quote(name) "
"|| ' SELECT * FROM ' || quote(name) || ';' "
"FROM sqlite_master WHERE name=='sqlite_sequence';"
** in this file for details. If in doubt, do not deviate from existing
** commenting and indentation practices when changing or adding code.
**
-** $Id: vdbe.c,v 1.452 2005/02/05 06:49:54 danielk1977 Exp $
+** $Id: vdbe.c,v 1.453 2005/02/05 12:48:48 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "os.h"
/* Opcode: MemIncr P1 P2 *
**
** Increment the integer valued memory cell P1 by 1. If P2 is not zero
-** and the result after the increment is greater than zero, then jump
+** and the result after the increment is exactly 1, then jump
** to P2.
**
** This instruction throws an error if the memory cell is not initially
pMem = &p->aMem[i];
assert( pMem->flags==MEM_Int );
pMem->i++;
- if( pOp->p2>0 && pMem->i>0 ){
+ if( pOp->p2>0 && pMem->i==1 ){
+ pc = pOp->p2 - 1;
+ }
+ break;
+}
+
+/* Opcode: IfMemPos P1 P2 *
+**
+** If the value of memory cell P1 is 1 or greater, jump to P2. This
+** opcode assumes that memory cell P1 holds an integer value.
+*/
+case OP_IfMemPos: {
+ int i = pOp->p1;
+ Mem *pMem;
+ assert( i>=0 && i<p->nMem );
+ pMem = &p->aMem[i];
+ assert( pMem->flags==MEM_Int );
+ if( pMem->i>0 ){
pc = pOp->p2 - 1;
}
break;
# This file implements tests to make sure SQLite does not crash or
# segfault if it sees a corrupt database file.
#
-# $Id: corrupt.test,v 1.6 2005/02/05 06:49:55 danielk1977 Exp $
+# $Id: corrupt.test,v 1.7 2005/02/05 12:48:49 danielk1977 Exp $
catch {file delete -force test.db}
catch {file delete -force test.db-journal}
db close
copy_file test.bu test.db
sqlite3 db test.db
- execsql {
- SELECT name, rootpage FROM sqlite_master
- }
-} {t1 2 t1i1 85 t2 177}
+ list
+} {}
do_test corrupt-3.2 {
set t1_r [execsql {SELECT rootpage FROM sqlite_master WHERE name = 't1i1'}]
set t1i1_r [execsql {SELECT rootpage FROM sqlite_master WHERE name = 't1'}]
UPDATE sqlite_master SET rootpage = $t1i1_r WHERE name = 't1i1';
PRAGMA writable_schema = 0;
PRAGMA schema_version = $cookie;
- SELECT name, rootpage FROM sqlite_master;
"
-} {t1 85 t1i1 2 t2 177}
+} {}
# This one tests the case caught by code in checkin [2313].
do_test corrupt-3.3 {
# focus of this file is testing the LIMIT ... OFFSET ... clause
# of SELECT statements.
#
-# $Id: limit.test,v 1.23 2005/01/21 04:25:47 danielk1977 Exp $
+# $Id: limit.test,v 1.24 2005/02/05 12:48:49 danielk1977 Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
} {1 {LIMIT clause should come after UNION not before}}
}
+# Test LIMIT and OFFSET using SQL variables.
+do_test limit-10.1 {
+ set limit 10
+ db eval {
+ SELECT x FROM t1 LIMIT $limit;
+ }
+} {31 30 29 28 27 26 25 24 23 22}
+do_test limit-10.2 {
+ set limit 5
+ set offset 5
+ db eval {
+ SELECT x FROM t1 LIMIT $limit OFFSET $offset;
+ }
+} {26 25 24 23 22}
+do_test limit-10.3 {
+ set limit -1
+ db eval {
+ SELECT x FROM t1 WHERE x<10 LIMIT $limit;
+ }
+} {9 8 7 6 5 4 3 2 1 0}
+do_test limit-10.4 {
+ set limit 1.5
+ set rc [catch {
+ db eval {
+ SELECT x FROM t1 WHERE x<10 LIMIT $limit;
+ } } msg]
+ list $rc $msg
+} {1 {datatype mismatch}}
+do_test limit-10.5 {
+ set limit "hello world"
+ set rc [catch {
+ db eval {
+ SELECT x FROM t1 WHERE x<10 LIMIT $limit;
+ } } msg]
+ list $rc $msg
+} {1 {datatype mismatch}}
+
finish_test
projects / thirdparty / sqlite.git / commitdiff
