Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Comment updates most. Also some small changes to the VDBE. (CVS 339) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
9b0be4fcc1cbca69f5fee906f86dfb36 |
User & Date: | drh 2002-01-06 17:07:40.000 |
Context
2002-01-07
| ||
19:04 | Makefile changes from Andreas Rottmann (CVS 340) (check-in: e7004afbf8 user: drh tags: trunk) | |
2002-01-06
| ||
17:07 | Comment updates most. Also some small changes to the VDBE. (CVS 339) (check-in: 9b0be4fcc1 user: drh tags: trunk) | |
2002-01-04
| ||
03:09 | An attempt to delete a single row using a WHERE clause that specifies the rowid would result in an error if the rowid did not exist. This problem has been resolved. (CVS 338) (check-in: 011be9a9d2 user: drh tags: trunk) | |
Changes
Changes to src/expr.c.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains routines used for analyzing expressions and ** for generating VDBE code that evaluates expressions in SQLite. ** | | | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains routines used for analyzing expressions and ** for generating VDBE code that evaluates expressions in SQLite. ** ** $Id: expr.c,v 1.37 2002/01/06 17:07:40 drh Exp $ */ #include "sqliteInt.h" /* ** Walk an expression tree. Return 1 if the expression is constant ** and 0 if it involves variables. */ |
︙ | ︙ | |||
45 46 47 48 49 50 51 | ** Walk the expression tree and process operators of the form: ** ** expr IN (SELECT ...) ** ** These operators have to be processed before column names are ** resolved because each such operator increments pParse->nTab ** to reserve cursor numbers for its own use. But pParse->nTab | | > > | 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 | ** Walk the expression tree and process operators of the form: ** ** expr IN (SELECT ...) ** ** These operators have to be processed before column names are ** resolved because each such operator increments pParse->nTab ** to reserve cursor numbers for its own use. But pParse->nTab ** needs to be constant once we begin resolving column names. For ** that reason, this procedure needs to be called on every expression ** before sqliteExprResolveIds() is called on any expression. ** ** Actually, the processing of IN-SELECT is only started by this ** routine. This routine allocates a cursor number to the IN-SELECT ** and then moves on. The code generation is done by ** sqliteExprResolveIds() which must be called afterwards. */ void sqliteExprResolveInSelect(Parse *pParse, Expr *pExpr){ |
︙ | ︙ | |||
82 83 84 85 86 87 88 | if( sqliteStrICmp(z, "OID")==0 ) return 1; return 0; } /* ** This routine walks an expression tree and resolves references to ** table columns. Nodes of the form ID.ID or ID resolve into an | | | | > > | | > > | 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 | if( sqliteStrICmp(z, "OID")==0 ) return 1; return 0; } /* ** This routine walks an expression tree and resolves references to ** table columns. Nodes of the form ID.ID or ID resolve into an ** index to the table in the table list and a column offset. The ** Expr.opcode for such nodes is changed to TK_COLUMN. The Expr.iTable ** value is changed to the index of the referenced table in pTabList ** plus the pParse->nTab value. This value will ultimately become the ** VDBE cursor number for a cursor that is pointing into the referenced ** table. The Expr.iColumn value is changed to the index of the column ** of the referenced table. The Expr.iColumn value for the special ** ROWID column is -1. Any INTEGER PRIMARY KEY column is tried as an ** alias for ROWID. ** ** We also check for instances of the IN operator. IN comes in two ** forms: ** ** expr IN (exprlist) ** and ** expr IN (SELECT ...) |
︙ | ︙ |
Changes to src/hash.c.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This is the implementation of generic hash-tables ** used in SQLite. ** | | > > > > > > > > > > > | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This is the implementation of generic hash-tables ** used in SQLite. ** ** $Id: hash.c,v 1.5 2002/01/06 17:07:40 drh Exp $ */ #include "sqliteInt.h" #include <assert.h> /* Turn bulk memory into a hash table object by initializing the ** fields of the Hash structure. ** ** "new" is a pointer to the hash table that is to be initialized. ** keyClass is one of the constants SQLITE_HASH_INT, SQLITE_HASH_POINTER, ** SQLITE_HASH_BINARY, or SQLITE_HASH_STRING. The value of keyClass ** determines what kind of key the hash table will use. "copyKey" is ** true if the hash table should make its own private copy of keys and ** false if it should just use the supplied pointer. CopyKey only makes ** sense for SQLITE_HASH_STRING and SQLITE_HASH_BINARY and is ignored ** for other key classes. */ void sqliteHashInit(Hash *new, int keyClass, int copyKey){ assert( new!=0 ); assert( keyClass>=SQLITE_HASH_INT && keyClass<=SQLITE_HASH_BINARY ); new->keyClass = keyClass; new->copyKey = copyKey && (keyClass==SQLITE_HASH_STRING || keyClass==SQLITE_HASH_BINARY); new->first = 0; new->count = 0; new->htsize = 0; new->ht = 0; } /* Remove all entries from a hash table. Reclaim all memory. ** Call this routine to delete a hash table or to reset a hash table ** to the empty state. */ void sqliteHashClear(Hash *pH){ HashElem *elem; /* For looping over all elements of the table */ assert( pH!=0 ); elem = pH->first; pH->first = 0; |
︙ | ︙ | |||
103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 | static int binCompare(const void *pKey1, int n1, const void *pKey2, int n2){ if( n1!=n2 ) return n2-n1; return memcmp(pKey1,pKey2,n1); } /* ** Return a pointer to the appropriate hash function given the key class. */ static int (*hashFunction(int keyClass))(const void*,int){ switch( keyClass ){ case SQLITE_HASH_INT: return intHash; case SQLITE_HASH_POINTER: return ptrHash; case SQLITE_HASH_STRING: return strHash; case SQLITE_HASH_BINARY: return binHash;; default: break; } return 0; } /* ** Return a pointer to the appropriate hash function given the key class. */ static int (*compareFunction(int keyClass))(const void*,int,const void*,int){ switch( keyClass ){ case SQLITE_HASH_INT: return intCompare; case SQLITE_HASH_POINTER: return ptrCompare; case SQLITE_HASH_STRING: return strCompare; case SQLITE_HASH_BINARY: return binCompare; default: break; } return 0; } | > > > > > > > > > > > > | > | | 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 | static int binCompare(const void *pKey1, int n1, const void *pKey2, int n2){ if( n1!=n2 ) return n2-n1; return memcmp(pKey1,pKey2,n1); } /* ** Return a pointer to the appropriate hash function given the key class. ** ** The C syntax in this function definition may be unfamilar to some ** programmers, so we provide the following additional explanation: ** ** The name of the function is "hashFunction". The function takes a ** single parameter "keyClass". The return value of hashFunction() ** is a pointer to another function. Specifically, the return value ** of hashFunction() is a pointer to a function that takes two parameters ** with types "const void*" and "int" and returns an "int". */ static int (*hashFunction(int keyClass))(const void*,int){ switch( keyClass ){ case SQLITE_HASH_INT: return intHash; case SQLITE_HASH_POINTER: return ptrHash; case SQLITE_HASH_STRING: return strHash; case SQLITE_HASH_BINARY: return binHash;; default: break; } return 0; } /* ** Return a pointer to the appropriate hash function given the key class. ** ** For help in interpreted the obscure C code in the function definition, ** see the header comment on the previous function. */ static int (*compareFunction(int keyClass))(const void*,int,const void*,int){ switch( keyClass ){ case SQLITE_HASH_INT: return intCompare; case SQLITE_HASH_POINTER: return ptrCompare; case SQLITE_HASH_STRING: return strCompare; case SQLITE_HASH_BINARY: return binCompare; default: break; } return 0; } /* Resize the hash table so that it cantains "new_size" buckets. ** "new_size" must be a power of 2. The hash table might fail ** to resize if sqliteMalloc() fails. */ static void rehash(Hash *pH, int new_size){ struct _ht *new_ht; /* The new hash table */ HashElem *elem, *next_elem; /* For looping over existing elements */ HashElem *x; /* Element being copied to new hash table */ int (*xHash)(const void*,int); /* The hash function */ |
︙ | ︙ | |||
168 169 170 171 172 173 174 | } new_ht[h].chain = elem; new_ht[h].count++; } } /* This function (for internal use only) locates an element in an | | | | 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 | } new_ht[h].chain = elem; new_ht[h].count++; } } /* This function (for internal use only) locates an element in an ** hash table that matches the given key. The hash for this key has ** already been computed and is passed as the 4th parameter. */ static HashElem *findElementGivenHash( const Hash *pH, /* The pH to be searched */ const void *pKey, /* The key we are searching for */ int nKey, int h /* The hash for this key. */ ){ |
︙ | ︙ | |||
201 202 203 204 205 206 207 | /* Remove a single entry from the hash table given a pointer to that ** element and a hash on the element's key. */ static void removeElementGivenHash( Hash *pH, /* The pH containing "elem" */ HashElem* elem, /* The element to be removed from the pH */ | | | 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 | /* Remove a single entry from the hash table given a pointer to that ** element and a hash on the element's key. */ static void removeElementGivenHash( Hash *pH, /* The pH containing "elem" */ HashElem* elem, /* The element to be removed from the pH */ int h /* Hash value for the element */ ){ if( elem->prev ){ elem->prev->next = elem->next; }else{ pH->first = elem->next; } if( elem->next ){ |
︙ | ︙ | |||
225 226 227 228 229 230 231 | if( pH->copyKey && elem->pKey ){ sqliteFree(elem->pKey); } sqliteFree( elem ); pH->count--; } | | | | 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 | if( pH->copyKey && elem->pKey ){ sqliteFree(elem->pKey); } sqliteFree( elem ); pH->count--; } /* Attempt to locate an element of the hash table pH with a key ** that matches pKey,nKey. Return the data for this element if it is ** found, or NULL if there is no match. */ void *sqliteHashFind(const Hash *pH, const void *pKey, int nKey){ int h; /* A hash on key */ HashElem *elem; /* The element that matches key */ int (*xHash)(const void*,int); /* The hash function */ if( pH==0 || pH->ht==0 ) return 0; |
︙ | ︙ | |||
253 254 255 256 257 258 259 | ** If no element exists with a matching key, then a new ** element is created. A copy of the key is made if the copyKey ** flag is set. NULL is returned. ** ** If another element already exists with the same key, then the ** new data replaces the old data and the old data is returned. ** The key is not copied in this instance. If a malloc fails, then | | | 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 | ** If no element exists with a matching key, then a new ** element is created. A copy of the key is made if the copyKey ** flag is set. NULL is returned. ** ** If another element already exists with the same key, then the ** new data replaces the old data and the old data is returned. ** The key is not copied in this instance. If a malloc fails, then ** the new data is returned and the hash table is unchanged. ** ** If the "data" parameter to this function is NULL, then the ** element corresponding to "key" is removed from the hash table. */ void *sqliteHashInsert(Hash *pH, void *pKey, int nKey, void *data){ int hraw; /* Raw hash value of the key */ int h; /* the hash of the key modulo hash table size */ |
︙ | ︙ |
Changes to src/insert.c.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains C code routines that are called by the parser ** to handle INSERT statements in SQLite. ** | | | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains C code routines that are called by the parser ** to handle INSERT statements in SQLite. ** ** $Id: insert.c,v 1.32 2002/01/06 17:07:40 drh Exp $ */ #include "sqliteInt.h" /* ** This routine is call to handle SQL of the following forms: ** ** insert into TABLE (IDLIST) values(EXPRLIST) |
︙ | ︙ | |||
159 160 161 162 163 164 165 | " has no column named ", pColumn->a[i].zName, 0); pParse->nErr++; goto insert_cleanup; } } } | | | 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 | " has no column named ", pColumn->a[i].zName, 0); pParse->nErr++; goto insert_cleanup; } } } /* If there is no IDLIST term but the table has an integer primary ** key, the set the keyColumn variable to the primary key column index ** in the original table definition. */ if( pColumn==0 ){ keyColumn = pTab->iPKey; } |
︙ | ︙ | |||
216 217 218 219 220 221 222 | /* If there are indices, we'll need the new record number again, so make ** a copy. */ if( pTab->pIndex ){ sqliteVdbeAddOp(v, OP_Dup, 0, 0); } | | | | | | 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 | /* If there are indices, we'll need the new record number again, so make ** a copy. */ if( pTab->pIndex ){ sqliteVdbeAddOp(v, OP_Dup, 0, 0); } /* Push onto the stack, data for all columns of the new entry, beginning ** with the first column. */ for(i=0; i<pTab->nCol; i++){ if( i==pTab->iPKey ){ /* The value of the INTEGER PRIMARY KEY column is always a NULL. ** Whenever this column is read, the record number will be substituted ** in its place. So will fill this column with a NULL to avoid ** taking up data space with information that will never be used. */ sqliteVdbeAddOp(v, OP_String, 0, 0); continue; } if( pColumn==0 ){ j = i; }else{ for(j=0; j<pColumn->nId; j++){ |
︙ | ︙ |
Changes to src/main.c.
︙ | ︙ | |||
10 11 12 13 14 15 16 | ** ************************************************************************* ** Main file for the SQLite library. The routines in this file ** implement the programmer interface to the library. Routines in ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** | | | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** ************************************************************************* ** Main file for the SQLite library. The routines in this file ** implement the programmer interface to the library. Routines in ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** ** $Id: main.c,v 1.53 2002/01/06 17:07:40 drh Exp $ */ #include "sqliteInt.h" #include "os.h" /* ** This is the callback routine for the code that initializes the ** database. See sqliteInit() below for additional information. |
︙ | ︙ | |||
63 64 65 66 67 68 69 | sParse.db = db; sParse.initFlag = 1; sParse.newTnum = atoi(argv[2]); sqliteRunParser(&sParse, argv[3], 0); }else{ /* If the SQL column is blank it means this is an index that ** was created to be the PRIMARY KEY or to fulfill a UNIQUE | | | | 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 | sParse.db = db; sParse.initFlag = 1; sParse.newTnum = atoi(argv[2]); sqliteRunParser(&sParse, argv[3], 0); }else{ /* If the SQL column is blank it means this is an index that ** was created to be the PRIMARY KEY or to fulfill a UNIQUE ** constraint for a CREATE TABLE. The index should have already ** been created when we processed the CREATE TABLE. All we have ** to do here is record the root page number for that index. */ Index *pIndex = sqliteFindIndex(db, argv[1]); if( pIndex==0 || pIndex->tnum!=0 ){ nErr++; }else{ pIndex->tnum = atoi(argv[2]); } |
︙ | ︙ | |||
114 115 116 117 118 119 120 | " name text,\n" " tbl_name text,\n" " rootpage integer,\n" " sql text\n" ")" ; | | | 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 | " name text,\n" " tbl_name text,\n" " rootpage integer,\n" " sql text\n" ")" ; /* The following VDBE program is used to initialize the internal ** structure holding the tables and indexes of the database. ** The database contains a special table named "sqlite_master" ** defined as follows: ** ** CREATE TABLE sqlite_master ( ** type text, -- Either "table" or "index" or "meta" ** name text, -- Name of table or index |
︙ | ︙ | |||
206 207 208 209 210 211 212 213 214 215 216 217 218 219 | if( rc==SQLITE_OK && db->nTable==0 ){ db->file_format = FILE_FORMAT; } if( rc==SQLITE_OK && db->file_format>FILE_FORMAT ){ sqliteSetString(pzErrMsg, "unsupported file format", 0); rc = SQLITE_ERROR; } if( rc==SQLITE_OK ){ Table *pTab; char *azArg[6]; azArg[0] = "table"; azArg[1] = MASTER_NAME; azArg[2] = "2"; azArg[3] = master_schema; | > > > > > | 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 | if( rc==SQLITE_OK && db->nTable==0 ){ db->file_format = FILE_FORMAT; } if( rc==SQLITE_OK && db->file_format>FILE_FORMAT ){ sqliteSetString(pzErrMsg, "unsupported file format", 0); rc = SQLITE_ERROR; } /* The schema for the SQLITE_MASTER table is not stored in the ** database itself. We have to invoke the callback one extra ** time to get it to process the SQLITE_MASTER table defintion. */ if( rc==SQLITE_OK ){ Table *pTab; char *azArg[6]; azArg[0] = "table"; azArg[1] = MASTER_NAME; azArg[2] = "2"; azArg[3] = master_schema; |
︙ | ︙ | |||
266 267 268 269 270 271 272 | db->nextRowid = sqliteRandomInteger(); /* Open the backend database driver */ rc = sqliteBtreeOpen(zFilename, mode, MAX_PAGES, &db->pBe); if( rc!=SQLITE_OK ){ switch( rc ){ default: { | < | < | | | 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 | db->nextRowid = sqliteRandomInteger(); /* Open the backend database driver */ rc = sqliteBtreeOpen(zFilename, mode, MAX_PAGES, &db->pBe); if( rc!=SQLITE_OK ){ switch( rc ){ default: { sqliteSetString(pzErrMsg, "unable to open database: ", zFilename, 0); } } sqliteFree(db); sqliteStrRealloc(pzErrMsg); return 0; } /* Attempt to read the schema */ rc = sqliteInit(db, pzErrMsg); if( sqlite_malloc_failed ){ sqlite_close(db); goto no_mem_on_open; }else if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){ sqlite_close(db); sqliteStrRealloc(pzErrMsg); return 0; }else if( pzErrMsg ){ sqliteFree(*pzErrMsg); *pzErrMsg = 0; } return db; no_mem_on_open: sqliteSetString(pzErrMsg, "out of memory", 0); sqliteStrRealloc(pzErrMsg); return 0; } /* ** Erase all schema information from the schema hash table. Except ** tables that are created using CREATE TEMPORARY TABLE are preserved ** if the preserveTemps flag is true. ** ** The database schema is normally read in once when the database ** is first opened and stored in a hash table in the sqlite structure. ** This routine erases the stored schema. This erasure occurs because ** either the database is being closed or because some other process ** changed the schema and this process needs to reread it. */ |
︙ | ︙ |
Changes to src/pager.c.
︙ | ︙ | |||
14 15 16 17 18 19 20 | ** The pager is used to access a database disk file. It implements ** atomic commit and rollback through the use of a journal file that ** is separate from the database file. The pager also implements file ** locking to prevent two processes from writing the same database ** file simultaneously, or one process from reading the database while ** another is writing. ** | | | 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | ** The pager is used to access a database disk file. It implements ** atomic commit and rollback through the use of a journal file that ** is separate from the database file. The pager also implements file ** locking to prevent two processes from writing the same database ** file simultaneously, or one process from reading the database while ** another is writing. ** ** @(#) $Id: pager.c,v 1.35 2002/01/06 17:07:40 drh Exp $ */ #include "sqliteInt.h" #include "pager.h" #include "os.h" #include <assert.h> #include <string.h> |
︙ | ︙ | |||
989 990 991 992 993 994 995 | if( pPager->dbSize<pPg->pgno ){ pPager->dbSize = pPg->pgno; } return rc; } /* | | | 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 | if( pPager->dbSize<pPg->pgno ){ pPager->dbSize = pPg->pgno; } return rc; } /* ** Return TRUE if the page given in the argument was previously passed ** to sqlitepager_write(). In other words, return TRUE if it is ok ** to change the content of the page. */ int sqlitepager_iswriteable(void *pData){ PgHdr *pPg = DATA_TO_PGHDR(pData); return pPg->dirty; } |
︙ | ︙ |
Changes to src/parse.y.
︙ | ︙ | |||
10 11 12 13 14 15 16 | ** ************************************************************************* ** This file contains SQLite's grammar for SQL. Process this file ** using the lemon parser generator to generate C code that runs ** the parser. Lemon will also generate a header file containing ** numeric codes for all of the tokens. ** | | | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** ************************************************************************* ** This file contains SQLite's grammar for SQL. Process this file ** using the lemon parser generator to generate C code that runs ** the parser. Lemon will also generate a header file containing ** numeric codes for all of the tokens. ** ** @(#) $Id: parse.y,v 1.42 2002/01/06 17:07:40 drh Exp $ */ %token_prefix TK_ %token_type {Token} %default_type {Token} %extra_argument {Parse *pParse} %syntax_error { sqliteSetString(&pParse->zErrMsg,"syntax error",0); |
︙ | ︙ | |||
98 99 100 101 102 103 104 105 106 107 108 109 110 111 | id(A) ::= BEGIN(X). {A = X;} id(A) ::= END(X). {A = X;} id(A) ::= PRAGMA(X). {A = X;} id(A) ::= CLUSTER(X). {A = X;} id(A) ::= ID(X). {A = X;} id(A) ::= TEMP(X). {A = X;} id(A) ::= OFFSET(X). {A = X;} // And "ids" is an identifer-or-string. // %type ids {Token} ids(A) ::= id(X). {A = X;} ids(A) ::= STRING(X). {A = X;} | > | 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 | id(A) ::= BEGIN(X). {A = X;} id(A) ::= END(X). {A = X;} id(A) ::= PRAGMA(X). {A = X;} id(A) ::= CLUSTER(X). {A = X;} id(A) ::= ID(X). {A = X;} id(A) ::= TEMP(X). {A = X;} id(A) ::= OFFSET(X). {A = X;} id(A) ::= KEY(X). {A = X;} // And "ids" is an identifer-or-string. // %type ids {Token} ids(A) ::= id(X). {A = X;} ids(A) ::= STRING(X). {A = X;} |
︙ | ︙ |
Changes to src/shell.c.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains code to implement the "sqlite" command line ** utility for accessing SQLite databases. ** | | | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains code to implement the "sqlite" command line ** utility for accessing SQLite databases. ** ** $Id: shell.c,v 1.41 2002/01/06 17:07:40 drh Exp $ */ #include <stdlib.h> #include <string.h> #include <stdio.h> #include "sqlite.h" #include <ctype.h> #ifdef OS_UNIX |
︙ | ︙ | |||
88 89 90 91 92 93 94 | return zLine; } /* ** Retrieve a single line of input text. "isatty" is true if text ** is coming from a terminal. In that case, we issue a prompt and ** attempt to use "readline" for command-line editing. If "isatty" | | | 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 | return zLine; } /* ** Retrieve a single line of input text. "isatty" is true if text ** is coming from a terminal. In that case, we issue a prompt and ** attempt to use "readline" for command-line editing. If "isatty" ** is false, use "getline" instead of "readline" and issue no prompt. ** ** zPrior is a string of prior text retrieved. If not the empty ** string, then issue a continuation prompt. */ static char *one_input_line(const char *zPrior, FILE *in){ char *zPrompt; char *zResult; |
︙ | ︙ |
Changes to src/sqliteInt.h.
1 2 3 4 5 6 7 8 9 10 11 12 13 | /* ** 2001 September 15 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: ** ** May you do good and not evil. ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** Internal interface definitions for SQLite. ** | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | /* ** 2001 September 15 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: ** ** May you do good and not evil. ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** Internal interface definitions for SQLite. ** ** @(#) $Id: sqliteInt.h,v 1.75 2002/01/06 17:07:40 drh Exp $ */ #include "sqlite.h" #include "hash.h" #include "vdbe.h" #include "parse.h" #include "btree.h" #include <stdio.h> |
︙ | ︙ | |||
115 116 117 118 119 120 121 | */ #ifdef MEMORY_DEBUG extern int sqlite_nMalloc; /* Number of sqliteMalloc() calls */ extern int sqlite_nFree; /* Number of sqliteFree() calls */ extern int sqlite_iMallocFail; /* Fail sqliteMalloc() after this many calls */ #endif | < < < < < < < | 115 116 117 118 119 120 121 122 123 124 125 126 127 128 | */ #ifdef MEMORY_DEBUG extern int sqlite_nMalloc; /* Number of sqliteMalloc() calls */ extern int sqlite_nFree; /* Number of sqliteFree() calls */ extern int sqlite_iMallocFail; /* Fail sqliteMalloc() after this many calls */ #endif /* ** Name of the master database table. The master database table ** is a special table that holds the names and attributes of all ** user tables and indices. */ #define MASTER_NAME "sqlite_master" |
︙ | ︙ |
Changes to src/vdbe.c.
︙ | ︙ | |||
26 27 28 29 30 31 32 | ** type to the other occurs as necessary. ** ** Most of the code in this file is taken up by the sqliteVdbeExec() ** function which does the work of interpreting a VDBE program. ** But other routines are also provided to help in building up ** a program instruction by instruction. ** | | | 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | ** type to the other occurs as necessary. ** ** Most of the code in this file is taken up by the sqliteVdbeExec() ** function which does the work of interpreting a VDBE program. ** But other routines are also provided to help in building up ** a program instruction by instruction. ** ** $Id: vdbe.c,v 1.105 2002/01/06 17:07:41 drh Exp $ */ #include "sqliteInt.h" #include <ctype.h> /* ** The following global variable is incremented every time a cursor ** moves, either by the OP_MoveTo or the OP_Next opcode. The test |
︙ | ︙ | |||
452 453 454 455 456 457 458 459 460 461 | */ void sqliteVdbeCompressSpace(Vdbe *p, int addr){ char *z; int i, j; Op *pOp; if( p->aOp==0 || addr<0 || addr>=p->nOp ) return; pOp = &p->aOp[addr]; if( pOp->p3type!=P3_DYNAMIC ){ pOp->p3 = sqliteStrDup(pOp->p3); pOp->p3type = P3_DYNAMIC; | > > > < < | | < < | 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 | */ void sqliteVdbeCompressSpace(Vdbe *p, int addr){ char *z; int i, j; Op *pOp; if( p->aOp==0 || addr<0 || addr>=p->nOp ) return; pOp = &p->aOp[addr]; if( pOp->p3type==P3_POINTER ){ return; } if( pOp->p3type!=P3_DYNAMIC ){ pOp->p3 = sqliteStrDup(pOp->p3); pOp->p3type = P3_DYNAMIC; } z = pOp->p3; if( z==0 ) return; i = j = 0; while( isspace(z[i]) ){ i++; } while( z[i] ){ if( isspace(z[i]) ){ z[j++] = ' '; while( isspace(z[++i]) ){} }else{ z[j++] = z[i++]; } } while( j>0 && isspace(z[j-1]) ){ j--; } z[j] = 0; } /* ** Reset an Agg structure. Delete all its contents. */ static void AggReset(Agg *pAgg){ int i; |
︙ | ︙ | |||
918 919 920 921 922 923 924 | if( xCallback==0 ) return 0; azValue[0] = zAddr; azValue[2] = zP1; azValue[3] = zP2; azValue[5] = 0; rc = SQLITE_OK; | < | 917 918 919 920 921 922 923 924 925 926 927 928 929 930 | if( xCallback==0 ) return 0; azValue[0] = zAddr; azValue[2] = zP1; azValue[3] = zP2; azValue[5] = 0; rc = SQLITE_OK; for(i=0; rc==SQLITE_OK && i<p->nOp; i++){ if( p->db->flags & SQLITE_Interrupt ){ p->db->flags &= ~SQLITE_Interrupt; sqliteSetString(pzErrMsg, "interrupted", 0); rc = SQLITE_INTERRUPT; break; } |
︙ | ︙ | |||
1024 1025 1026 1027 1028 1029 1030 | /* ** Execute the program in the VDBE. ** ** If an error occurs, an error message is written to memory obtained ** from sqliteMalloc() and *pzErrMsg is made to point to that memory. ** The return parameter is the number of errors. ** | | > | | 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 | /* ** Execute the program in the VDBE. ** ** If an error occurs, an error message is written to memory obtained ** from sqliteMalloc() and *pzErrMsg is made to point to that memory. ** The return parameter is the number of errors. ** ** If the callback ever returns non-zero, then the program exits ** immediately. There will be no error message but the function ** does return SQLITE_ABORT. ** ** A memory allocation error causes this routine to return SQLITE_NOMEM ** and abandon furture processing. ** ** Other fatal errors return SQLITE_ERROR. ** ** If a database file could not be opened because it is locked by |
︙ | ︙ | |||
1085 1086 1087 1088 1089 1090 1091 | rc = SQLITE_OK; #ifdef MEMORY_DEBUG if( access("vdbe_trace",0)==0 ){ p->trace = stdout; } #endif | < | 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 | rc = SQLITE_OK; #ifdef MEMORY_DEBUG if( access("vdbe_trace",0)==0 ){ p->trace = stdout; } #endif if( sqlite_malloc_failed ) goto no_mem; for(pc=0; !sqlite_malloc_failed && rc==SQLITE_OK && pc<p->nOp VERIFY(&& pc>=0); pc++){ pOp = &p->aOp[pc]; /* Interrupt processing if requested. */ |
︙ | ︙ |
Changes to src/where.c.
︙ | ︙ | |||
9 10 11 12 13 14 15 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** This module contains C code that generates VDBE code used to process ** the WHERE clause of SQL statements. Also found here are subroutines ** to generate VDBE code to evaluate expressions. ** | | | 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** This module contains C code that generates VDBE code used to process ** the WHERE clause of SQL statements. Also found here are subroutines ** to generate VDBE code to evaluate expressions. ** ** $Id: where.c,v 1.31 2002/01/06 17:07:41 drh Exp $ */ #include "sqliteInt.h" /* ** The query generator uses an array of instances of this structure to ** help it analyze the subexpressions of the WHERE clause. Each WHERE ** clause subexpression is separated from the others by an AND operator. |
︙ | ︙ | |||
568 569 570 571 572 573 574 | sqliteVdbeAddOp(v, OP_Rewind, base+idx, brk); start = sqliteVdbeCurrentAddr(v); pLevel->op = OP_Next; pLevel->p1 = base+idx; pLevel->p2 = start; haveKey = 0; }else{ | | | | 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 | sqliteVdbeAddOp(v, OP_Rewind, base+idx, brk); start = sqliteVdbeCurrentAddr(v); pLevel->op = OP_Next; pLevel->p1 = base+idx; pLevel->p2 = start; haveKey = 0; }else{ /* Case 5: The contraint on the right-most index field is ** an inequality. */ int score = pLevel->score; int nEqColumn = score/4; int start; int leFlag, geFlag; int testOp; |
︙ | ︙ |