-C Change\sthe\snames\sof\sthe\sPushList\sand\sPopList\sopcodes\sto\sListPush\sand\sListPop\nso\sthat\sthey\swill\sappear\stogether\swith\sthe\sother\sList\sopcodes\sin\sthe\ndocumentation.\s(CVS\s583)
-D 2002-05-23T22:07:03
+C Split\sthe\sIdList\sstructure\sinto\sIdList\sand\sSrcList.\s\sSrcList\sis\sused\sto\nrepresent\sa\sFROM\sclause\sand\sIdList\sis\sused\sfor\severything\selse.\s\sThis\schange\nallows\sSrcList\sto\sgrow\sto\ssupport\souter\sjoins\swithout\sburdening\sthe\sother\nuses\sof\sIdList.\s(CVS\s584)
+D 2002-05-24T02:04:33
F Makefile.in 6291a33b87d2a395aafd7646ee1ed562c6f2c28c
F Makefile.template 4e11752e0b5c7a043ca50af4296ec562857ba495
F README a4c0ba11354ef6ba0776b400d057c59da47a4cc0
F src/TODO af7f3cab0228e34149cf98e073aa83d45878e7e6
F src/btree.c c01b404b9373ae1c0daf7d1f9211c72ead67638e
F src/btree.h 8abeabfe6e0b1a990b64fa457592a6482f6674f3
-F src/build.c d88ad651bedecba69510d87d734040730305c528
-F src/delete.c 1dba1dd7fb7a477b44178f4990c20fa673ceb5be
+F src/build.c 48bb306676b77711919adc3578655e3ebf2ac8f0
+F src/delete.c a2b098cbbf518e6b641847e26de85827793bc523
F src/encode.c 346b12b46148506c32038524b95c4631ab46d760
-F src/expr.c 535c2468cfa9a8d043c6bbe50488849943da237b
+F src/expr.c 818a702ba93e444813b8935a7ab509f6e3352b49
F src/func.c a31dcba85bc2ecb9b752980289cf7e6cd0cafbce
F src/hash.c 6a6236b89c8c060c65dabd300a1c8ce7c10edb72
F src/hash.h dca065dda89d4575f3176e75e9a3dc0f4b4fb8b9
-F src/insert.c 5b6586bb5d8306280253829f42f5f98b1455e757
+F src/insert.c bbbd803da8b125ec5a5f881f4d559887eb922c57
F src/main.c 6e53c49a390fabd5fecce9e3b128c61c85208000
F src/md5.c 0ae1f3e2cac92d06fc6246d1b4b8f61a2fe66d3b
F src/os.c 5ab8b6b4590d0c1ab8e96c67996c170e4462e0fc
F src/os.h 4a361fccfbc4e7609b3e1557f604f94c1e96ad10
F src/pager.c ba5740104cc27b342cd43eebfdc44d60f64a3ded
F src/pager.h 6fddfddd3b73aa8abc081b973886320e3c614f0e
-F src/parse.y 3f2f7334aa1460bf5b208f51b9e1f53747e552ff
+F src/parse.y 8053fead169ad8345b5a2cfc39749b63995daffb
F src/printf.c d8032ee18b860c812eeff596c9bebfdacb7930fd
F src/random.c 19e8e00fe0df32a742f115773f57651be327cabe
-F src/select.c 1b623a7d826ec7c245bc542b665d61724da2a62d
+F src/select.c c46f4e0784175f2a8ec9fde26b7b4f8090cab9cb
F src/shell.c 1d22fe870ee852cfb975fd000dbe3973713d0a15
F src/shell.tcl 27ecbd63dd88396ad16d81ab44f73e6c0ea9d20e
F src/sqlite.h.in 0038faa6d642de06b91143ee65a131bd831d020b
-F src/sqliteInt.h 7ef986dab669bf334bd90aac0cb73f8ef3254ca4
+F src/sqliteInt.h 02d9d16c3eea463ff9bcbd13426627cb79d6d190
F src/table.c eed2098c9b577aa17f8abe89313a9c4413f57d63
F src/tclsqlite.c 9300c9606a38bc0c75d6c0bc8a6197ab979353d1
F src/test1.c 09d95048b66ce6dcd2bae90f443589043d7d631e
F src/test3.c 4e52fff8b01f08bd202f7633feda5639b7ba2b5e
F src/threadtest.c 81f0598e0f031c1bd506af337fdc1b7e8dff263f
F src/tokenize.c 5892a8eb8f0063718f5bec1a1b24f4c6029eba9b
-F src/trigger.c a7990d424af58d809501a393f72c12d4b039eb63
-F src/update.c 1f8f7fde797bd607fe0afb4f96a6ad83c9e8ab7b
+F src/trigger.c bf1a4f6653e482be0052bc9ade9261cf814c705b
+F src/update.c f68375173bf5338cae3e97012708e10f206aedd9
F src/util.c 707c30f8c13cddace7c08556ac450c0b786660b3
-F src/vdbe.c 6c2eae8a1d03f41aa51e40772aebf581cf62d5b8
+F src/vdbe.c 46fd7cbefdb788195c978e5d2f480d86ea1416e5
F src/vdbe.h def669b9f2728589aabcb5db756429db02465c9a
-F src/where.c 293985b6cf8391c3dcef9efcac4654884370513a
+F src/where.c 1516eb1c06ca6d15cd5cf982ae974cf58e5431ed
F test/all.test e4d3821eeba751829b419cd47814bd20af4286d1
F test/bigrow.test 8ab252dba108f12ad64e337b0f2ff31a807ac578
F test/btree.test bf326f546a666617367a7033fa2c07451bd4f8e1
F www/sqlite.tcl 8b5884354cb615049aed83039f8dfe1552a44279
F www/tclsqlite.tcl 1db15abeb446aad0caf0b95b8b9579720e4ea331
F www/vdbe.tcl 2013852c27a02a091d39a766bc87cff329f21218
-P 82b74a494ac7c751a13e67dcfa7fffb1b98ec808
-R 3e1a04e4d6e0a4fb68b8a11229bc1cc1
+P c53b0b9283c5c34def87d58b03fd979d03dc0890
+R 95dc28a2322a37ee9ed8c63d2402b526
U drh
-Z 8e8caac647d0d1fcfa3e14c75f0d3c35
+Z 694384ea6b2e1a364fadbb314a03dd97
-c53b0b9283c5c34def87d58b03fd979d03dc0890
\ No newline at end of file
+a167b71d8c27e870bc3079c6132e483bffc83298
\ No newline at end of file
** ROLLBACK
** PRAGMA
**
-** $Id: build.c,v 1.93 2002/05/22 21:27:03 drh Exp $
+** $Id: build.c,v 1.94 2002/05/24 02:04:33 drh Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
return pList;
}
+/*
+** Append a new table name to the given SrcList. Create a new SrcList if
+** need be. A new entry is created in the SrcList even if pToken is NULL.
+**
+** A new SrcList is returned, or NULL if malloc() fails.
+*/
+SrcList *sqliteSrcListAppend(SrcList *pList, Token *pToken){
+ if( pList==0 ){
+ pList = sqliteMalloc( sizeof(IdList) );
+ if( pList==0 ) return 0;
+ }
+ if( (pList->nSrc & 7)==0 ){
+ struct SrcList_item *a;
+ a = sqliteRealloc(pList->a, (pList->nSrc+8)*sizeof(pList->a[0]) );
+ if( a==0 ){
+ sqliteSrcListDelete(pList);
+ return 0;
+ }
+ pList->a = a;
+ }
+ memset(&pList->a[pList->nSrc], 0, sizeof(pList->a[0]));
+ if( pToken ){
+ char **pz = &pList->a[pList->nSrc].zName;
+ sqliteSetNString(pz, pToken->z, pToken->n, 0);
+ if( *pz==0 ){
+ sqliteSrcListDelete(pList);
+ return 0;
+ }else{
+ sqliteDequote(*pz);
+ }
+ }
+ pList->nSrc++;
+ return pList;
+}
+
/*
** Add an alias to the last identifier on the given identifier list.
*/
-void sqliteIdListAddAlias(IdList *pList, Token *pToken){
- if( pList && pList->nId>0 ){
- int i = pList->nId - 1;
+void sqliteSrcListAddAlias(SrcList *pList, Token *pToken){
+ if( pList && pList->nSrc>0 ){
+ int i = pList->nSrc - 1;
sqliteSetNString(&pList->a[i].zAlias, pToken->z, pToken->n, 0);
sqliteDequote(pList->a[i].zAlias);
}
}
/*
-** Delete an entire IdList.
+** Delete an IdList.
*/
void sqliteIdListDelete(IdList *pList){
int i;
if( pList==0 ) return;
for(i=0; i<pList->nId; i++){
sqliteFree(pList->a[i].zName);
+ }
+ sqliteFree(pList->a);
+ sqliteFree(pList);
+}
+
+/*
+** Delete an entire SrcList including all its substructure.
+*/
+void sqliteSrcListDelete(SrcList *pList){
+ int i;
+ if( pList==0 ) return;
+ for(i=0; i<pList->nSrc; i++){
+ sqliteFree(pList->a[i].zName);
sqliteFree(pList->a[i].zAlias);
if( pList->a[i].pTab && pList->a[i].pTab->isTransient ){
sqliteDeleteTable(0, pList->a[i].pTab);
}
sqliteSelectDelete(pList->a[i].pSelect);
+ sqliteExprDelete(pList->a[i].pOn);
+ sqliteIdListDelete(pList->a[i].pUsing);
}
sqliteFree(pList->a);
sqliteFree(pList);
** This file contains C code routines that are called by the parser
** to handle DELETE FROM statements.
**
-** $Id: delete.c,v 1.35 2002/05/23 12:50:18 drh Exp $
+** $Id: delete.c,v 1.36 2002/05/24 02:04:33 drh Exp $
*/
#include "sqliteInt.h"
/*
** Given a table name, check to make sure the table exists, is writable
-** and is not a view. If everything is OK, construct an IdList holding
-** the table and return a pointer to the IdList. The calling function
-** is responsible for freeing the IdList when it has finished with it.
+** and is not a view. If everything is OK, construct an SrcList holding
+** the table and return a pointer to the SrcList. The calling function
+** is responsible for freeing the SrcList when it has finished with it.
** If there is an error, leave a message on pParse->zErrMsg and return
** NULL.
*/
-IdList *sqliteTableTokenToIdList(Parse *pParse, Token *pTableName){
+SrcList *sqliteTableTokenToSrcList(Parse *pParse, Token *pTableName){
Table *pTab;
- IdList *pTabList;
+ SrcList *pTabList;
- pTabList = sqliteIdListAppend(0, pTableName);
+ pTabList = sqliteSrcListAppend(0, pTableName);
if( pTabList==0 ) return 0;
- assert( pTabList->nId==1 );
+ assert( pTabList->nSrc==1 );
pTab = sqliteTableNameToTable(pParse, pTabList->a[0].zName);
if( pTab==0 ){
- sqliteIdListDelete(pTabList);
+ sqliteSrcListDelete(pTabList);
return 0;
}
pTabList->a[0].pTab = pTab;
Vdbe *v; /* The virtual database engine */
Table *pTab; /* The table from which records will be deleted */
char *zTab; /* Name of the table from which we are deleting */
- IdList *pTabList; /* An ID list holding pTab and nothing else */
+ SrcList *pTabList; /* A fake FROM clause holding just pTab */
int end, addr; /* A couple addresses of generated code */
int i; /* Loop counter */
WhereInfo *pWInfo; /* Information about the WHERE clause */
}
/* Locate the table which we want to delete. This table has to be
- ** put in an IdList structure because some of the subroutines we
+ ** put in an SrcList structure because some of the subroutines we
** will be calling are designed to work with multiple tables and expect
- ** an IdList* parameter instead of just a Table* parameter.
+ ** an SrcList* parameter instead of just a Table* parameter.
*/
- pTabList = sqliteTableTokenToIdList(pParse, pTableName);
+ pTabList = sqliteTableTokenToSrcList(pParse, pTableName);
if( pTabList==0 ) goto delete_from_cleanup;
- assert( pTabList->nId==1 );
+ assert( pTabList->nSrc==1 );
pTab = pTabList->a[0].pTab;
assert( pTab->pSelect==0 ); /* This table is not a view */
}
delete_from_cleanup:
- sqliteIdListDelete(pTabList);
+ sqliteSrcListDelete(pTabList);
sqliteExprDelete(pWhere);
return;
}
** This file contains routines used for analyzing expressions and
** for generating VDBE code that evaluates expressions in SQLite.
**
-** $Id: expr.c,v 1.62 2002/05/23 02:09:04 drh Exp $
+** $Id: expr.c,v 1.63 2002/05/24 02:04:33 drh Exp $
*/
#include "sqliteInt.h"
** string space that is allocated separately from the expression tree
** itself. These routines do NOT duplicate that string space.
**
-** The expression list and ID list return by sqliteExprListDup() and
-** sqliteIdListDup() can not be further expanded by subsequent calls
-** to sqliteExprListAppend() or sqliteIdListAppend().
+** The expression list, ID, and source lists return by sqliteExprListDup(),
+** sqliteIdListDup(), and sqliteSrcListDup() can not be further expanded
+** by subsequent calls to sqlite*ListAppend() routines.
**
-** Any tables that the ID list might point to are not duplicated.
+** Any tables that the SrcList might point to are not duplicated.
*/
Expr *sqliteExprDup(Expr *p){
Expr *pNew;
}
return pNew;
}
+SrcList *sqliteSrcListDup(SrcList *p){
+ SrcList *pNew;
+ int i;
+ if( p==0 ) return 0;
+ pNew = sqliteMalloc( sizeof(*pNew) );
+ if( pNew==0 ) return 0;
+ pNew->nSrc = p->nSrc;
+ pNew->a = sqliteMalloc( p->nSrc*sizeof(p->a[0]) );
+ if( pNew->a==0 ) return 0;
+ for(i=0; i<p->nSrc; i++){
+ pNew->a[i].zName = sqliteStrDup(p->a[i].zName);
+ pNew->a[i].zAlias = sqliteStrDup(p->a[i].zAlias);
+ pNew->a[i].jointype = p->a[i].jointype;
+ pNew->a[i].pTab = 0;
+ pNew->a[i].pSelect = sqliteSelectDup(p->a[i].pSelect);
+ pNew->a[i].pOn = sqliteExprDup(p->a[i].pOn);
+ pNew->a[i].pUsing = sqliteIdListDup(p->a[i].pUsing);
+ }
+ return pNew;
+}
IdList *sqliteIdListDup(IdList *p){
IdList *pNew;
int i;
if( pNew->a==0 ) return 0;
for(i=0; i<p->nId; i++){
pNew->a[i].zName = sqliteStrDup(p->a[i].zName);
- pNew->a[i].zAlias = sqliteStrDup(p->a[i].zAlias);
pNew->a[i].idx = p->a[i].idx;
- pNew->a[i].pTab = 0;
- pNew->a[i].pSelect = sqliteSelectDup(p->a[i].pSelect);
}
return pNew;
}
if( pNew==0 ) return 0;
pNew->isDistinct = p->isDistinct;
pNew->pEList = sqliteExprListDup(p->pEList);
- pNew->pSrc = sqliteIdListDup(p->pSrc);
+ pNew->pSrc = sqliteSrcListDup(p->pSrc);
pNew->pWhere = sqliteExprDup(p->pWhere);
pNew->pGroupBy = sqliteExprListDup(p->pGroupBy);
pNew->pHaving = sqliteExprDup(p->pHaving);
int sqliteExprResolveIds(
Parse *pParse, /* The parser context */
int base, /* VDBE cursor number for first entry in pTabList */
- IdList *pTabList, /* List of tables used to resolve column names */
+ SrcList *pTabList, /* List of tables used to resolve column names */
ExprList *pEList, /* List of expressions used to resolve "AS" */
Expr *pExpr /* The expression to be analyzed. */
){
if( pExpr==0 || pTabList==0 ) return 0;
- assert( base+pTabList->nId<=pParse->nTab );
+ assert( base+pTabList->nSrc<=pParse->nTab );
switch( pExpr->op ){
/* Double-quoted strings (ex: "abc") are used as identifiers if
** possible. Otherwise they remain as strings. Single-quoted
z = sqliteStrNDup(pExpr->token.z, pExpr->token.n);
sqliteDequote(z);
if( z==0 ) return 1;
- for(i=0; i<pTabList->nId; i++){
+ for(i=0; i<pTabList->nSrc; i++){
int j;
Table *pTab = pTabList->a[i].pTab;
if( pTab==0 ) continue;
if( cnt==0 && sqliteIsRowid(z) ){
pExpr->iColumn = -1;
pExpr->iTable = base;
- cnt = 1 + (pTabList->nId>1);
+ cnt = 1 + (pTabList->nSrc>1);
pExpr->op = TK_COLUMN;
}
sqliteFree(z);
sqliteDequote(zLeft);
sqliteDequote(zRight);
pExpr->iTable = -1;
- for(i=0; i<pTabList->nId; i++){
+ for(i=0; i<pTabList->nSrc; i++){
int j;
char *zTab;
Table *pTab = pTabList->a[i].pTab;
** This file contains C code routines that are called by the parser
** to handle INSERT statements in SQLite.
**
-** $Id: insert.c,v 1.57 2002/05/21 12:56:43 drh Exp $
+** $Id: insert.c,v 1.58 2002/05/24 02:04:33 drh Exp $
*/
#include "sqliteInt.h"
assert( pSelect->pEList );
nColumn = pSelect->pEList->nExpr;
}else{
- IdList dummy;
+ SrcList dummy;
assert( pList!=0 );
srcTab = -1;
assert( pList );
nColumn = pList->nExpr;
- dummy.nId = 0;
+ dummy.nSrc = 0;
for(i=0; i<nColumn; i++){
if( sqliteExprResolveIds(pParse, 0, &dummy, 0, pList->a[i].pExpr) ){
goto insert_cleanup;
** the parser. Lemon will also generate a header file containing
** numeric codes for all of the tokens.
**
-** @(#) $Id: parse.y,v 1.67 2002/05/23 00:30:31 drh Exp $
+** @(#) $Id: parse.y,v 1.68 2002/05/24 02:04:33 drh Exp $
*/
%token_prefix TK_
%token_type {Token}
#include "parse.h"
/*
-** A structure for holding two integers
+** An instance of this structure holds information about the
+** LIMIT clause of a SELECT statement.
*/
-struct twoint { int a,b; };
+struct LimitVal {
+ int limit; /* The LIMIT value. -1 if there is no limit */
+ int offset; /* The OFFSET. 0 if there is none */
+};
/*
-** A structure for holding an integer and an IdList
+** An instance of the following structure describes the event of a
+** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT,
+** TK_DELETE, or TK_INSTEAD. If the event is of the form
+**
+** UPDATE ON (a,b,c)
+**
+** Then the "b" IdList records the list "a,b,c".
*/
-struct int_idlist { int a; IdList * b; };
+struct TrigEvent { int a; IdList * b; };
}
// These are extra tokens used by the lexer but never seen by the
multiselect_op(A) ::= EXCEPT. {A = TK_EXCEPT;}
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 = sqliteSelectNew(W,X,Y,P,Q,Z,D,L.a,L.b);
+ A = sqliteSelectNew(W,X,Y,P,Q,Z,D,L.limit,L.offset);
}
// The "distinct" nonterminal is true (1) if the DISTINCT keyword is
as ::= AS.
-%type seltablist {IdList*}
-%destructor seltablist {sqliteIdListDelete($$);}
-%type stl_prefix {IdList*}
-%destructor stl_prefix {sqliteIdListDelete($$);}
-%type from {IdList*}
-%destructor from {sqliteIdListDelete($$);}
+%type seltablist {SrcList*}
+%destructor seltablist {sqliteSrcListDelete($$);}
+%type stl_prefix {SrcList*}
+%destructor stl_prefix {sqliteSrcListDelete($$);}
+%type from {SrcList*}
+%destructor from {sqliteSrcListDelete($$);}
from(A) ::= . {A = sqliteMalloc(sizeof(*A));}
from(A) ::= FROM seltablist(X). {A = X;}
stl_prefix(A) ::= seltablist(X) COMMA. {A = X;}
stl_prefix(A) ::= . {A = 0;}
-seltablist(A) ::= stl_prefix(X) ids(Y). {A = sqliteIdListAppend(X,&Y);}
+seltablist(A) ::= stl_prefix(X) ids(Y). {A = sqliteSrcListAppend(X,&Y);}
seltablist(A) ::= stl_prefix(X) ids(Y) as ids(Z). {
- A = sqliteIdListAppend(X,&Y);
- sqliteIdListAddAlias(A,&Z);
+ A = sqliteSrcListAppend(X,&Y);
+ sqliteSrcListAddAlias(A,&Z);
}
seltablist(A) ::= stl_prefix(X) LP select(S) RP. {
- A = sqliteIdListAppend(X,0);
- A->a[A->nId-1].pSelect = S;
+ A = sqliteSrcListAppend(X,0);
+ A->a[A->nSrc-1].pSelect = S;
if( S->pOrderBy ){
sqliteExprListDelete(S->pOrderBy);
S->pOrderBy = 0;
}
}
seltablist(A) ::= stl_prefix(X) LP select(S) RP as ids(Z). {
- A = sqliteIdListAppend(X,0);
- A->a[A->nId-1].pSelect = S;
+ A = sqliteSrcListAppend(X,0);
+ A->a[A->nSrc-1].pSelect = S;
if( S->pOrderBy ){
sqliteExprListDelete(S->pOrderBy);
S->pOrderBy = 0;
}
- sqliteIdListAddAlias(A,&Z);
+ sqliteSrcListAddAlias(A,&Z);
}
%type orderby_opt {ExprList*}
having_opt(A) ::= . {A = 0;}
having_opt(A) ::= HAVING expr(X). {A = X;}
-%type limit_opt {struct twoint}
-limit_opt(A) ::= . {A.a = -1; A.b = 0;}
-limit_opt(A) ::= LIMIT INTEGER(X). {A.a = atoi(X.z); A.b = 0;}
+%type limit_opt {struct LimitVal}
+limit_opt(A) ::= . {A.limit = -1; A.offset = 0;}
+limit_opt(A) ::= LIMIT INTEGER(X). {A.limit = atoi(X.z); A.offset = 0;}
limit_opt(A) ::= LIMIT INTEGER(X) limit_sep INTEGER(Y).
- {A.a = atoi(X.z); A.b = atoi(Y.z);}
+ {A.limit = atoi(X.z); A.offset = atoi(Y.z);}
limit_sep ::= OFFSET.
limit_sep ::= COMMA.
trigger_time(A) ::= INSTEAD OF. { A = TK_INSTEAD;}
trigger_time(A) ::= . { A = TK_BEFORE; }
-%type trigger_event {struct int_idlist}
+%type trigger_event {struct TrigEvent}
+%destructor trigger_event {sqliteIdListDelete($$.b);}
trigger_event(A) ::= DELETE. { A.a = TK_DELETE; A.b = 0; }
trigger_event(A) ::= INSERT. { A.a = TK_INSERT; A.b = 0; }
trigger_event(A) ::= UPDATE. { A.a = TK_UPDATE; A.b = 0;}
** This file contains C code routines that are called by the parser
** to handle SELECT statements in SQLite.
**
-** $Id: select.c,v 1.81 2002/05/08 11:54:15 drh Exp $
+** $Id: select.c,v 1.82 2002/05/24 02:04:33 drh Exp $
*/
#include "sqliteInt.h"
*/
Select *sqliteSelectNew(
ExprList *pEList, /* which columns to include in the result */
- IdList *pSrc, /* the FROM clause -- which tables to scan */
+ SrcList *pSrc, /* the FROM clause -- which tables to scan */
Expr *pWhere, /* the WHERE clause */
ExprList *pGroupBy, /* the GROUP BY clause */
Expr *pHaving, /* the HAVING clause */
pNew = sqliteMalloc( sizeof(*pNew) );
if( pNew==0 ){
sqliteExprListDelete(pEList);
- sqliteIdListDelete(pSrc);
+ sqliteSrcListDelete(pSrc);
sqliteExprDelete(pWhere);
sqliteExprListDelete(pGroupBy);
sqliteExprDelete(pHaving);
void sqliteSelectDelete(Select *p){
if( p==0 ) return;
sqliteExprListDelete(p->pEList);
- sqliteIdListDelete(p->pSrc);
+ sqliteSrcListDelete(p->pSrc);
sqliteExprDelete(p->pWhere);
sqliteExprListDelete(p->pGroupBy);
sqliteExprDelete(p->pHaving);
static void generateColumnNames(
Parse *pParse, /* Parser context */
int base, /* VDBE cursor corresponding to first entry in pTabList */
- IdList *pTabList, /* List of tables */
+ SrcList *pTabList, /* List of tables */
ExprList *pEList /* Expressions defining the result set */
){
Vdbe *v = pParse->pVdbe;
if( iCol<0 ) iCol = pTab->iPKey;
assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
zCol = iCol<0 ? "_ROWID_" : pTab->aCol[iCol].zName;
- if( pTabList->nId>1 || showFullNames ){
+ if( pTabList->nSrc>1 || showFullNames ){
char *zName = 0;
char *zTab;
/*
** For the given SELECT statement, do two things.
**
-** (1) Fill in the pTabList->a[].pTab fields in the IdList that
+** (1) Fill in the pTabList->a[].pTab fields in the SrcList that
** defines the set of tables that should be scanned.
**
** (2) Scan the list of columns in the result set (pEList) looking
*/
static int fillInColumnList(Parse *pParse, Select *p){
int i, j, k, rc;
- IdList *pTabList;
+ SrcList *pTabList;
ExprList *pEList;
Table *pTab;
/* Look up every table in the table list.
*/
- for(i=0; i<pTabList->nId; i++){
+ for(i=0; i<pTabList->nSrc; i++){
if( pTabList->a[i].pTab ){
/* This routine has run before! No need to continue */
return 0;
}else{
pName = 0;
}
- for(i=0; i<pTabList->nId; i++){
+ for(i=0; i<pTabList->nSrc; i++){
Table *pTab = pTabList->a[i].pTab;
char *zTabName = pTabList->a[i].zAlias;
if( zTabName==0 || zTabName[0]==0 ){
*/
void sqliteSelectUnbind(Select *p){
int i;
- IdList *pSrc = p->pSrc;
+ SrcList *pSrc = p->pSrc;
Table *pTab;
if( p==0 ) return;
- for(i=0; i<pSrc->nId; i++){
+ for(i=0; i<pSrc->nSrc; i++){
if( (pTab = pSrc->a[i].pTab)!=0 ){
if( pTab->isTransient ){
sqliteDeleteTable(0, pTab);
*/
int flattenSubquery(Select *p, int iFrom, int isAgg, int subqueryIsAgg){
Select *pSub; /* The inner query or "subquery" */
- IdList *pSrc; /* The FROM clause of the outer query */
- IdList *pSubSrc; /* The FROM clause of the subquery */
+ SrcList *pSrc; /* The FROM clause of the outer query */
+ SrcList *pSubSrc; /* The FROM clause of the subquery */
ExprList *pList; /* The result set of the outer query */
int i;
int iParent, iSub;
*/
if( p==0 ) return 0;
pSrc = p->pSrc;
- assert( pSrc && iFrom>=0 && iFrom<pSrc->nId );
+ assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
pSub = pSrc->a[iFrom].pSelect;
assert( pSub!=0 );
if( isAgg && subqueryIsAgg ) return 0;
- if( subqueryIsAgg && pSrc->nId>1 ) return 0;
+ if( subqueryIsAgg && pSrc->nSrc>1 ) return 0;
pSubSrc = pSub->pSrc;
assert( pSubSrc );
- if( pSubSrc->nId!=1 ) return 0;
- if( pSub->isDistinct && pSrc->nId>1 ) return 0;
+ if( pSubSrc->nSrc!=1 ) return 0;
+ if( pSub->isDistinct && pSrc->nSrc>1 ) return 0;
if( pSub->isDistinct && isAgg ) return 0;
if( p->isDistinct && subqueryIsAgg ) return 0;
** zero if it is not.
*/
if( p->pGroupBy || p->pHaving || p->pWhere ) return 0;
- if( p->pSrc->nId!=1 ) return 0;
+ if( p->pSrc->nSrc!=1 ) return 0;
if( p->pEList->nExpr!=1 ) return 0;
pExpr = p->pEList->a[0].pExpr;
if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
Vdbe *v;
int isAgg = 0; /* True for select lists like "count(*)" */
ExprList *pEList; /* List of columns to extract. */
- IdList *pTabList; /* List of tables to select from */
+ SrcList *pTabList; /* List of tables to select from */
Expr *pWhere; /* The WHERE clause. May be NULL */
ExprList *pOrderBy; /* The ORDER BY clause. May be NULL */
ExprList *pGroupBy; /* The GROUP BY clause. May be NULL */
** FROM clause be consecutive.
*/
base = p->base = pParse->nTab;
- pParse->nTab += pTabList->nId;
+ pParse->nTab += pTabList->nSrc;
/*
** Do not even attempt to generate any code if we have already seen
/* Generate code for all sub-queries in the FROM clause
*/
- for(i=0; i<pTabList->nId; i++){
+ for(i=0; i<pTabList->nSrc; i++){
if( pTabList->a[i].pSelect==0 ) continue;
sqliteSelect(pParse, pTabList->a[i].pSelect, SRT_TempTable, base+i,
p, i, &isAgg);
*************************************************************************
** Internal interface definitions for SQLite.
**
-** @(#) $Id: sqliteInt.h,v 1.112 2002/05/21 13:18:26 drh Exp $
+** @(#) $Id: sqliteInt.h,v 1.113 2002/05/24 02:04:33 drh Exp $
*/
#include "sqlite.h"
#include "hash.h"
typedef struct Parse Parse;
typedef struct Token Token;
typedef struct IdList IdList;
+typedef struct SrcList SrcList;
typedef struct WhereInfo WhereInfo;
typedef struct WhereLevel WhereLevel;
typedef struct Select Select;
** name. An expr/name combination can be used in several ways, such
** as the list of "expr AS ID" fields following a "SELECT" or in the
** list of "ID = expr" items in an UPDATE. A list of expressions can
-** also be used as the argument to a function, in which case the azName
+** also be used as the argument to a function, in which case the a.zName
** field is not used.
*/
struct ExprList {
};
/*
-** A list of identifiers.
+** An instance of this structure can hold a simple list of identifiers,
+** such as the list "a,b,c" in the following statements:
+**
+** INSERT INTO t(a,b,c) VALUES ...;
+** CREATE INDEX idx ON t(a,b,c);
+** CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...;
+**
+** The IdList.a.idx field is used when the IdList represents the list of
+** column names after a table name in an INSERT statement. In the statement
+**
+** INSERT INTO t(a,b,c) ...
+**
+** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.
*/
struct IdList {
int nId; /* Number of identifiers on the list */
struct IdList_item {
- char *zName; /* Text of the identifier. */
- char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */
+ char *zName; /* Name of the identifier */
int idx; /* Index in some Table.aCol[] of a column named zName */
+ } *a;
+};
+
+/*
+** The following structure describes the FROM clause of a SELECT statement.
+** Each table or subquery in the FROM clause is a separate element of
+** the SrcList.a[] array.
+*/
+struct SrcList {
+ int nSrc; /* Number of tables or subqueries in the FROM clause */
+ struct SrcList_item {
+ char *zName; /* Name of the table */
+ char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */
Table *pTab; /* An SQL table corresponding to zName */
Select *pSelect; /* A SELECT statement used in place of a table name */
+ int jointype; /* Type of join between this table and the next */
+ Expr *pOn; /* The ON clause of a join */
+ IdList *pUsing; /* The USING clause of a join */
} *a; /* One entry for each identifier on the list */
};
*/
struct WhereInfo {
Parse *pParse;
- IdList *pTabList; /* List of tables in the join */
+ SrcList *pTabList; /* List of tables in the join */
int iContinue; /* Jump here to continue with next record */
int iBreak; /* Jump here to break out of the loop */
int base; /* Index of first Open opcode */
struct Select {
int isDistinct; /* True if the DISTINCT keyword is present */
ExprList *pEList; /* The fields of the result */
- IdList *pSrc; /* The FROM clause */
+ SrcList *pSrc; /* The FROM clause */
Expr *pWhere; /* The WHERE clause */
ExprList *pGroupBy; /* The GROUP BY clause */
Expr *pHaving; /* The HAVING clause */
* 1. In the "trigHash" hash table (part of the sqlite* that represents the
* database). This allows Trigger structures to be retrieved by name.
* 2. All triggers associated with a single table form a linked list, using the
- * pNext member of struct Trigger. A pointer to the first element of the linked
- * list is stored as the "pTrigger" member of the associated struct Table.
+ * pNext member of struct Trigger. A pointer to the first element of the
+ * linked list is stored as the "pTrigger" member of the associated
+ * struct Table.
*
* The "strings" member of struct Trigger contains a pointer to the memory
* referenced by the various Token structures referenced indirectly by the
* "pWhen", "pColumns" and "step_list" members. (ie. the memory allocated for
* use in conjunction with the sqliteExprMoveStrings() etc. interface).
*
- * The "step_list" member points to the first element of a linked list containing
- * the SQL statements specified as the trigger program.
+ * The "step_list" member points to the first element of a linked list
+ * containing the SQL statements specified as the trigger program.
*
* When a trigger is initially created, the "isCommit" member is set to FALSE.
* When a transaction is rolled back, any Trigger structures with "isCommit" set
* Trigger structures for which it is FALSE.
*
* When a trigger is dropped, using the sqliteDropTrigger() interfaced, it is
- * removed from the trigHash hash table and added to the trigDrop hash table. If
- * the transaction is rolled back, the trigger is re-added into the trigHash
+ * removed from the trigHash hash table and added to the trigDrop hash table.
+ * If the transaction is rolled back, the trigger is re-added into the trigHash
* hash table (and hence the database schema). If the transaction is commited,
* then the Trigger structure is deleted permanently.
*/
* pExprList -> If this is an INSERT INTO ... VALUES ... statement, then
* this stores values to be inserted. Otherwise NULL.
* pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ...
- * statement, then this stores the column-names to be inserted into.
+ * statement, then this stores the column-names to be
+ * inserted into.
*
* (op == TK_DELETE)
* target -> A token holding the name of the table to delete from.
* pWhere -> The WHERE clause of the UPDATE statement if one is specified.
* Otherwise NULL.
* pExprList -> A list of the columns to update and the expressions to update
- * them to. See sqliteUpdate() documentation of "pChanges" argument.
+ * them to. See sqliteUpdate() documentation of "pChanges"
+ * argument.
*
*/
struct TriggerStep {
void sqliteDeleteTable(sqlite*, Table*);
void sqliteInsert(Parse*, Token*, ExprList*, Select*, IdList*, int);
IdList *sqliteIdListAppend(IdList*, Token*);
-void sqliteIdListAddAlias(IdList*, Token*);
+SrcList *sqliteSrcListAppend(SrcList*, Token*);
+void sqliteSrcListAddAlias(SrcList*, Token*);
void sqliteIdListDelete(IdList*);
+void sqliteSrcListDelete(SrcList*);
void sqliteCreateIndex(Parse*, Token*, Token*, IdList*, int, Token*, Token*);
void sqliteDropIndex(Parse*, Token*);
int sqliteSelect(Parse*, Select*, int, int, Select*, int, int*);
-Select *sqliteSelectNew(ExprList*,IdList*,Expr*,ExprList*,Expr*,ExprList*,
+Select *sqliteSelectNew(ExprList*,SrcList*,Expr*,ExprList*,Expr*,ExprList*,
int,int,int);
void sqliteSelectDelete(Select*);
void sqliteSelectUnbind(Select*);
Table *sqliteTableNameToTable(Parse*, const char*);
-IdList *sqliteTableTokenToIdList(Parse*, Token*);
+SrcList *sqliteTableTokenToSrcList(Parse*, Token*);
void sqliteDeleteFrom(Parse*, Token*, Expr*);
void sqliteUpdate(Parse*, Token*, ExprList*, Expr*, int);
-WhereInfo *sqliteWhereBegin(Parse*, int, IdList*, Expr*, int);
+WhereInfo *sqliteWhereBegin(Parse*, int, SrcList*, Expr*, int);
void sqliteWhereEnd(WhereInfo*);
void sqliteExprCode(Parse*, Expr*);
void sqliteExprIfTrue(Parse*, Expr*, int);
int sqliteExprCheck(Parse*, Expr*, int, int*);
int sqliteExprCompare(Expr*, Expr*);
int sqliteFuncId(Token*);
-int sqliteExprResolveIds(Parse*, int, IdList*, ExprList*, Expr*);
+int sqliteExprResolveIds(Parse*, int, SrcList*, ExprList*, Expr*);
int sqliteExprAnalyzeAggregates(Parse*, Expr*);
Vdbe *sqliteGetVdbe(Parse*);
int sqliteRandomByte(void);
void sqliteSelectMoveStrings(Select*, int);
Expr *sqliteExprDup(Expr*);
ExprList *sqliteExprListDup(ExprList*);
+SrcList *sqliteSrcListDup(SrcList*);
IdList *sqliteIdListDup(IdList*);
Select *sqliteSelectDup(Select*);
FuncDef *sqliteFindFunction(sqlite*,const char*,int,int,int);
if( fire_this && (pTriggerStack = sqliteMalloc(sizeof(TriggerStack)))!=0 ){
int endTrigger;
- IdList dummyTablist;
+ SrcList dummyTablist;
Expr * whenExpr;
- dummyTablist.nId = 0;
+ dummyTablist.nSrc = 0;
dummyTablist.a = 0;
/* Push an entry on to the trigger stack */
theSelect.isDistinct = 0;
theSelect.pEList = sqliteExprListAppend(0, sqliteExpr(TK_ALL, 0, 0, 0), 0);
- theSelect.pSrc = sqliteIdListAppend(0, &tblNameToken);
+ theSelect.pSrc = sqliteSrcListAppend(0, &tblNameToken);
theSelect.pWhere = pWhere; pWhere = 0;
theSelect.pGroupBy = 0;
theSelect.pHaving = 0;
sqliteExprListDelete(pChanges);
sqliteExprDelete(pWhere);
sqliteExprListDelete(theSelect.pEList);
- sqliteIdListDelete(theSelect.pSrc);
+ sqliteSrcListDelete(theSelect.pSrc);
sqliteExprDelete(theSelect.pWhere);
return;
}
** This file contains C code routines that are called by the parser
** to handle UPDATE statements.
**
-** $Id: update.c,v 1.42 2002/05/23 22:07:03 drh Exp $
+** $Id: update.c,v 1.43 2002/05/24 02:04:34 drh Exp $
*/
#include "sqliteInt.h"
){
int i, j; /* Loop counters */
Table *pTab; /* The table to be updated */
- IdList *pTabList = 0; /* List containing only pTab */
+ SrcList *pTabList = 0; /* Fake FROM clause containing only pTab */
int addr; /* VDBE instruction address of the start of the loop */
WhereInfo *pWInfo; /* Information about the WHERE clause */
Vdbe *v; /* The virtual database engine */
}
/* Locate the table which we want to update. This table has to be
- ** put in an IdList structure because some of the subroutines we
+ ** put in an SrcList structure because some of the subroutines we
** will be calling are designed to work with multiple tables and expect
- ** an IdList* parameter instead of just a Table* parameter.
+ ** an SrcList* parameter instead of just a Table* parameter.
*/
- pTabList = sqliteTableTokenToIdList(pParse, pTableName);
+ pTabList = sqliteTableTokenToSrcList(pParse, pTableName);
if( pTabList==0 ) goto update_cleanup;
pTab = pTabList->a[0].pTab;
assert( pTab->pSelect==0 ); /* This table is not a VIEW */
update_cleanup:
sqliteFree(apIdx);
sqliteFree(aXRef);
- sqliteIdListDelete(pTabList);
+ sqliteSrcListDelete(pTabList);
sqliteExprListDelete(pChanges);
sqliteExprDelete(pWhere);
return;
** But other routines are also provided to help in building up
** a program instruction by instruction.
**
-** $Id: vdbe.c,v 1.146 2002/05/23 22:07:03 drh Exp $
+** $Id: vdbe.c,v 1.147 2002/05/24 02:04:34 drh Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
char **zStack; /* Text or binary values of the stack */
char **azColName; /* Becomes the 4th parameter to callbacks */
int nCursor; /* Number of slots in aCsr[] */
- Cursor *aCsr; /* On element of this array for each open cursor */
+ Cursor *aCsr; /* One element of this array for each open cursor */
Keylist *pList; /* A list of ROWIDs */
Sorter *pSort; /* A linked list of objects to be sorted */
FILE *pFile; /* At most one open file handler */
/* Opcode: ListPush * * *
**
-** Save the current Vdbe list such that it can be restored by a PopList
+** Save the current Vdbe list such that it can be restored by a ListPop
** opcode. The list is empty after this is executed.
*/
case OP_ListPush: {
/* Opcode: ListPop * * *
**
-** Restore the Vdbe list to the state it was in when PushList was last
+** Restore the Vdbe list to the state it was in when ListPush was last
** executed.
*/
case OP_ListPop: {
** the WHERE clause of SQL statements. Also found here are subroutines
** to generate VDBE code to evaluate expressions.
**
-** $Id: where.c,v 1.45 2002/05/21 13:18:26 drh Exp $
+** $Id: where.c,v 1.46 2002/05/24 02:04:34 drh Exp $
*/
#include "sqliteInt.h"
WhereInfo *sqliteWhereBegin(
Parse *pParse, /* The parser context */
int base, /* VDBE cursor index for left-most table in pTabList */
- IdList *pTabList, /* A list of all tables */
+ 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 */
){
ExprInfo aExpr[50]; /* The WHERE clause is divided into these expressions */
/* Allocate space for aOrder[] and aiMem[]. */
- aOrder = sqliteMalloc( sizeof(int) * pTabList->nId );
+ aOrder = sqliteMalloc( sizeof(int) * pTabList->nSrc );
/* Allocate and initialize the WhereInfo structure that will become the
** return value.
*/
- pWInfo = sqliteMalloc( sizeof(WhereInfo) + pTabList->nId*sizeof(WhereLevel) );
+ pWInfo = sqliteMalloc( sizeof(WhereInfo) + pTabList->nSrc*sizeof(WhereLevel));
if( sqlite_malloc_failed ){
sqliteFree(aOrder);
sqliteFree(pWInfo);
/* Figure out a good nesting order for the tables. aOrder[0] will
** be the index in pTabList of the outermost table. aOrder[1] will
- ** be the first nested loop and so on. aOrder[pTabList->nId-1] will
+ ** be the first nested loop and so on. aOrder[pTabList->nSrc-1] will
** be the innermost loop.
**
** Someday we will put in a good algorithm here to reorder the loops
** for an effiecient query. But for now, just use whatever order the
** tables appear in in the pTabList.
*/
- for(i=0; i<pTabList->nId; i++){
+ for(i=0; i<pTabList->nSrc; i++){
aOrder[i] = i;
}
/* Figure out what index to use (if any) for each nested loop.
** Make pWInfo->a[i].pIdx point to the index to use for the i-th nested
- ** loop where i==0 is the outer loop and i==pTabList->nId-1 is the inner
+ ** loop where i==0 is the outer loop and i==pTabList->nSrc-1 is the inner
** loop.
**
** If terms exist that use the ROWID of any table, then set the
** to the limit of 32 bits in an integer bitmask.
*/
loopMask = 0;
- for(i=0; i<pTabList->n
Id && i<ARRAYSIZE(aDirect); i++){
+ for(i=0; i<pTabList->n
Src && i<ARRAYSIZE(aDirect); i++){
int j;
int idx = aOrder[i];
Table *pTab = pTabList->a[idx].pTab;
/* Open all tables in the pTabList and all indices used by those tables.
*/
- for(i=0; i<pTabList->nId; i++){
+ for(i=0; i<pTabList->nSrc; i++){
int openOp;
Table *pTab;
/* Generate the code to do the search
*/
loopMask = 0;
- for(i=0; i<pTabList->nId; i++){
+ for(i=0; i<pTabList->nSrc; i++){
int j, k;
int idx = aOrder[i];
Index *pIdx;
brk = pLevel->brk = sqliteVdbeMakeLabel(v);
cont = pLevel->cont = brk;
sqliteVdbeAddOp(v, OP_MustBeInt, 0, brk);
- if( i==pTabList->nId-1 && pushKey ){
+ if( i==pTabList->nSrc-1 && pushKey ){
/* Note: The OP_Dup below will cause the recno to be left on the
** stack if the record does not exists and the OP_NotExists jump is
** taken. This violates a general rule of the VDBE that you should
start = sqliteVdbeAddOp(v, OP_MemLoad, pLevel->iMem, 0);
sqliteVdbeAddOp(v, testOp, pLevel->iCur, brk);
sqliteVdbeAddOp(v, OP_IdxRecno, pLevel->iCur, 0);
- if( i==pTabList->nId-1 && pushKey ){
+ if( i==pTabList->nSrc-1 && pushKey ){
haveKey = 1;
}else{
sqliteVdbeAddOp(v, OP_MoveTo, base+idx, 0);
sqliteVdbeAddOp(v, testOp, pLevel->iCur, brk);
}
sqliteVdbeAddOp(v, OP_IdxRecno, pLevel->iCur, 0);
- if( i==pTabList->nId-1 && pushKey ){
+ if( i==pTabList->nSrc-1 && pushKey ){
haveKey = 1;
}else{
sqliteVdbeAddOp(v, OP_MoveTo, base+idx, 0);
int i;
int base = pWInfo->base;
WhereLevel *pLevel;
- IdList *pTabList = pWInfo->pTabList;
+ SrcList *pTabList = pWInfo->pTabList;
- for(i=pTabList->nId-1; i>=0; i--){
+ for(i=pTabList->nSrc-1; i>=0; i--){
pLevel = &pWInfo->a[i];
sqliteVdbeResolveLabel(v, pLevel->cont);
if( pLevel->op!=OP_Noop ){
sqliteVdbeResolveLabel(v, pLevel->brk);
}
sqliteVdbeResolveLabel(v, pWInfo->iBreak);
- for(i=0; i<pTabList->nId; i++){
+ for(i=0; i<pTabList->nSrc; i++){
if( pTabList->a[i].pTab->isTransient ) continue;
pLevel = &pWInfo->a[i];
sqliteVdbeAddOp(v, OP_Close, base+i, 0);
projects / thirdparty / sqlite.git / commitdiff
