Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | :-) (CVS 37) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
2b55f9b790e2914bbd2fd27ef23bbab7 |
User & Date: | drh 2000-06-02 13:27:59.000 |
Context
2000-06-02
| ||
14:27 | :-) (CVS 38) (check-in: 46c4b792e0 user: drh tags: trunk) | |
13:27 | :-) (CVS 37) (check-in: 2b55f9b790 user: drh tags: trunk) | |
02:09 | :-) (CVS 1696) (check-in: 80d925b82b user: drh tags: trunk) | |
Changes
Changes to Makefile.in.
︙ | ︙ | |||
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 | LIBREADLINE = @TARGET_READLINE_LIBS@ # Object files for the SQLite library. # LIBOBJ = build.o dbbe.o delete.o expr.o insert.o \ main.o parse.o select.o tokenize.o update.o \ util.o vdbe.o where.o # This is the default Makefile target. The objects listed here # are what get build when you type just "make" with no arguments. # all: libsqlite.a sqlite.h sqlite libsqlite.a: $(LIBOBJ) $(AR) libsqlite.a $(LIBOBJ) $(RANLIB) libsqlite.a sqlite: $(TOP)/src/shell.c libsqlite.a sqlite.h $(TCC) $(READLINE_FLAGS) -o sqlite $(TOP)/src/shell.c \ | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 | LIBREADLINE = @TARGET_READLINE_LIBS@ # Object files for the SQLite library. # LIBOBJ = build.o dbbe.o delete.o expr.o insert.o \ main.o parse.o select.o tokenize.o update.o \ util.o vdbe.o where.o # All of the source code files. # SRC = \ $(TOP)/src/build.c \ $(TOP)/src/dbbe.c \ $(TOP)/src/dbbe.h \ $(TOP)/src/delete.c \ $(TOP)/src/expr.c \ $(TOP)/src/insert.c \ $(TOP)/src/main.c \ $(TOP)/src/parse.y \ $(TOP)/src/select.c \ $(TOP)/src/shell.c \ $(TOP)/src/sqlite.h \ $(TOP)/src/sqliteInt.h \ $(TOP)/src/tclsqlite.c \ $(TOP)/src/tokenize.c \ $(TOP)/src/update.c \ $(TOP)/src/util.c \ $(TOP)/src/vdbe.c \ $(TOP)/src/vdbe.h \ $(TOP)/src/where.c # This is the default Makefile target. The objects listed here # are what get build when you type just "make" with no arguments. # all: libsqlite.a sqlite.h sqlite # Generate the file "last_change" which contains the date of change # of the most recently modified source code file # last_change: $(SRC) cat $(SRC) | grep '$$Id: ' | sort +4 | tail -1 \ | awk '{print $$5,$$6}' >last_change libsqlite.a: $(LIBOBJ) $(AR) libsqlite.a $(LIBOBJ) $(RANLIB) libsqlite.a sqlite: $(TOP)/src/shell.c libsqlite.a sqlite.h $(TCC) $(READLINE_FLAGS) -o sqlite $(TOP)/src/shell.c \ |
︙ | ︙ | |||
149 150 151 152 153 154 155 | sqlite.tar.gz: pwd=`pwd`; cd $(TOP)/..; tar czf $$pwd/sqlite.tar.gz $(TARBALL) all.tar.gz: pwd=`pwd`; cd $(TOP)/..; tar czf $$pwd/all.tar.gz sqlite | | | 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 | sqlite.tar.gz: pwd=`pwd`; cd $(TOP)/..; tar czf $$pwd/sqlite.tar.gz $(TARBALL) all.tar.gz: pwd=`pwd`; cd $(TOP)/..; tar czf $$pwd/all.tar.gz sqlite index.html: $(TOP)/www/index.tcl sqlite.tar.gz all.tar.gz last_change tclsh $(TOP)/www/index.tcl >index.html sqlite.html: $(TOP)/www/sqlite.tcl tclsh $(TOP)/www/sqlite.tcl >sqlite.html c_interface.html: $(TOP)/www/c_interface.tcl tclsh $(TOP)/www/c_interface.tcl >c_interface.html |
︙ | ︙ |
Changes to README.
1 2 | This directory contains source code to | | | 1 2 3 4 5 6 7 8 9 10 | This directory contains source code to SQLite: An SQL Database Built Upon GDBM To compile the project, first create a directory in which to place the build products. The build directory must be separate from the source tree. Cd into the build directory and then from the build directory run the configure script found at the root of the source tree. Then run "make". |
︙ | ︙ |
Changes to src/build.c.
︙ | ︙ | |||
18 19 20 21 22 23 24 | ** ** Author contact information: ** drh@hwaci.com ** http://www.hwaci.com/drh/ ** ************************************************************************* ** This file contains C code routines that are called by the parser | | > > > > > > > > > | | 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 | ** ** Author contact information: ** drh@hwaci.com ** http://www.hwaci.com/drh/ ** ************************************************************************* ** This file contains C code routines that are called by the parser ** when syntax rules are reduced. The routines in this file handle ** the following kinds of rules: ** ** CREATE TABLE ** DROP TABLE ** CREATE INDEX ** DROP INDEX ** creating expressions and ID lists ** COPY ** VACUUM ** ** $Id: build.c,v 1.13 2000/06/02 13:27:59 drh Exp $ */ #include "sqliteInt.h" /* ** This routine is called after a single SQL statement has been ** parsed and we want to execute the code to implement ** the statement. Prior action routines should have already |
︙ | ︙ | |||
525 526 527 528 529 530 531 | ** command. The initFlag is 1 when a database is opened and ** CREATE INDEX statements are read out of the master table. In ** the latter case the index already exists on disk, which is why ** we don't want to recreate it. */ if( pParse->initFlag==0 ){ static VdbeOp addTable[] = { | | | | | > > < < | | | 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 | ** command. The initFlag is 1 when a database is opened and ** CREATE INDEX statements are read out of the master table. In ** the latter case the index already exists on disk, which is why ** we don't want to recreate it. */ if( pParse->initFlag==0 ){ static VdbeOp addTable[] = { { OP_Open, 2, 1, MASTER_NAME}, { OP_New, 2, 0, 0}, { OP_String, 0, 0, "index"}, { OP_String, 0, 0, 0}, /* 3 */ { OP_String, 0, 0, 0}, /* 4 */ { OP_String, 0, 0, 0}, /* 5 */ { OP_MakeRecord, 4, 0, 0}, { OP_Put, 2, 0, 0}, { OP_Close, 2, 0, 0}, }; int n; Vdbe *v = pParse->pVdbe; int lbl1, lbl2; int i; if( v==0 ){ v = pParse->pVdbe = sqliteVdbeCreate(pParse->db->pBe); } if( v==0 ) goto exit_create_index; sqliteVdbeAddOp(v, OP_Open, 0, 0, pTab->zName, 0); sqliteVdbeAddOp(v, OP_Open, 1, 1, pIndex->zName, 0); if( pStart && pEnd ){ int base; n = (int)pEnd->z - (int)pStart->z + 1; base = sqliteVdbeAddOpList(v, ArraySize(addTable), addTable); sqliteVdbeChangeP3(v, base+3, pIndex->zName, 0); sqliteVdbeChangeP3(v, base+4, pTab->zName, 0); sqliteVdbeChangeP3(v, base+5, pStart->z, n); } lbl1 = sqliteVdbeMakeLabel(v); lbl2 = sqliteVdbeMakeLabel(v); sqliteVdbeAddOp(v, OP_Next, 0, lbl2, 0, lbl1); sqliteVdbeAddOp(v, OP_Key, 0, 0, 0, 0); for(i=0; i<pIndex->nField; i++){ sqliteVdbeAddOp(v, OP_Field, 0, pIndex->aiField[i], 0, 0); } sqliteVdbeAddOp(v, OP_MakeKey, pIndex->nField, 0, 0, 0); sqliteVdbeAddOp(v, OP_PutIdx, 1, 0, 0, 0); sqliteVdbeAddOp(v, OP_Goto, 0, lbl1, 0, 0); sqliteVdbeAddOp(v, OP_Noop, 0, 0, 0, lbl2); sqliteVdbeAddOp(v, OP_Close, 1, 0, 0, 0); sqliteVdbeAddOp(v, OP_Close, 0, 0, 0, 0); } /* Reclaim memory on an EXPLAIN call. */ if( pParse->explain ){ sqliteFree(pIndex); } |
︙ | ︙ |
Changes to src/dbbe.c.
︙ | ︙ | |||
26 27 28 29 30 31 32 | ** sqlite and the code that does the actually reading and writing ** of information to the disk. ** ** This file uses GDBM as the database backend. It should be ** relatively simple to convert to a different database such ** as NDBM, SDBM, or BerkeleyDB. ** | | | 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | ** sqlite and the code that does the actually reading and writing ** of information to the disk. ** ** This file uses GDBM as the database backend. It should be ** relatively simple to convert to a different database such ** as NDBM, SDBM, or BerkeleyDB. ** ** $Id: dbbe.c,v 1.11 2000/06/02 13:27:59 drh Exp $ */ #include "sqliteInt.h" #include <gdbm.h> #include <sys/stat.h> #include <unistd.h> #include <ctype.h> #include <time.h> |
︙ | ︙ | |||
120 121 122 123 124 125 126 | p->s[p->i] = p->s[p->j]; p->s[p->j] = t; t = p->s[p->i] + p->s[p->j]; return t & 0xff; } /* | | | > > > > | > | 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 | p->s[p->i] = p->s[p->j]; p->s[p->j] = t; t = p->s[p->i] + p->s[p->j]; return t & 0xff; } /* ** This routine opens a new database. For the GDBM driver ** implemented here, the database name is the name of the directory ** containing all the files of the database. ** ** If successful, a pointer to the Dbbe structure is returned. ** If there are errors, an appropriate error message is left ** in *pzErrMsg and NULL is returned. */ Dbbe *sqliteDbbeOpen( const char *zName, /* The name of the database */ int writeFlag, /* True if we will be writing to the database */ int createFlag, /* True to create database if it doesn't exist */ char **pzErrMsg /* Write error messages (if any) here */ ){ Dbbe *pNew; struct stat statbuf; char *zMaster; if( !writeFlag ) createFlag = 0; if( stat(zName, &statbuf)!=0 ){ if( createFlag ) mkdir(zName, 0750); if( stat(zName, &statbuf)!=0 ){ sqliteSetString(pzErrMsg, createFlag ? "can't find or create directory \"" : "can't find directory \"", zName, "\"", 0); return 0; } } if( !S_ISDIR(statbuf.st_mode) ){ sqliteSetString(pzErrMsg, "not a directory: \"", zName, "\"", 0); return 0; |
︙ | ︙ | |||
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 | } } return zFile; } /* ** Generate a random filename with the given prefix. */ static void randomName(struct rc4 *pRc4, char *zBuf, char *zPrefix){ int i, j; static const char zRandomChars[] = "abcdefghijklmnopqrstuvwxyz0123456789"; strcpy(zBuf, zPrefix); j = strlen(zBuf); for(i=0; i<15; i++){ int c = rc4byte(pRc4) % (sizeof(zRandomChars) - 1); zBuf[j++] = zRandomChars[c]; } zBuf[j] = 0; } | > > > < | > > > > > > > > > > > > > > > > > > > > | 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 | } } return zFile; } /* ** Generate a random filename with the given prefix. ** ** Very random names are chosen so that the chance of a ** collision with an existing filename is very very small. */ static void randomName(struct rc4 *pRc4, char *zBuf, char *zPrefix){ int i, j; static const char zRandomChars[] = "abcdefghijklmnopqrstuvwxyz0123456789"; strcpy(zBuf, zPrefix); j = strlen(zBuf); for(i=0; i<15; i++){ int c = rc4byte(pRc4) % (sizeof(zRandomChars) - 1); zBuf[j++] = zRandomChars[c]; } zBuf[j] = 0; } /* ** Open a new table cursor. Write a pointer to the corresponding ** DbbeTable structure into *ppTable. Return an integer success ** code: ** ** SQLITE_OK It worked! ** ** SQLITE_NOMEM sqliteMalloc() failed ** ** SQLITE_PERM Attempt to access a file for which file ** access permission is denied ** ** SQLITE_BUSY Another thread or process is already using ** the corresponding file and has that file locked. ** ** SQLITE_READONLY The current thread already has this file open ** readonly but you are trying to open for writing. ** (This can happen if a SELECT callback tries to ** do an UPDATE or DELETE.) ** ** If zTable is 0 or "", then a temporary table is created and opened. ** This table will be deleted from the disk when it is closed. */ int sqliteDbbeOpenTable( Dbbe *pBe, /* The database the table belongs to */ const char *zTable, /* The name of the table */ int writeable, /* True to open for writing */ DbbeTable **ppTable /* Write the resulting table pointer here */ ){ |
︙ | ︙ | |||
331 332 333 334 335 336 337 | pTable->readPending = 0; pTable->needRewind = 1; *ppTable = pTable; return rc; } /* | | > < | 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 | pTable->readPending = 0; pTable->needRewind = 1; *ppTable = pTable; return rc; } /* ** Drop a table from the database. The file on the disk that corresponds ** to this table is deleted. */ void sqliteDbbeDropTable(Dbbe *pBe, const char *zTable){ char *zFile; /* Name of the table file */ zFile = sqliteFileOfTable(pBe, zTable); unlink(zFile); sqliteFree(zFile); } /* ** Reorganize a table to reduce search times and disk usage. */ void sqliteDbbeReorganizeTable(Dbbe *pBe, const char *zTable){ DbbeTable *pTab; if( sqliteDbbeOpenTable(pBe, zTable, 1, &pTab)!=SQLITE_OK ){ return; } if( pTab && pTab->pFile && pTab->pFile->dbf ){ gdbm_reorganize(pTab->pFile->dbf); |
︙ | ︙ | |||
599 600 601 602 603 604 605 | key.dptr = pKey; rc = gdbm_delete(pTable->pFile->dbf, key); if( rc ) rc = SQLITE_ERROR; return rc; } /* | | > > > > | | | | | | 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 | key.dptr = pKey; rc = gdbm_delete(pTable->pFile->dbf, key); if( rc ) rc = SQLITE_ERROR; return rc; } /* ** Open a temporary file. The file should be deleted when closed. ** ** Note that we can't use the old Unix trick of opening the file ** and then immediately unlinking the file. That works great ** under Unix, but fails when we try to port to Windows. */ int sqliteDbbeOpenTempFile(Dbbe *pBe, FILE **ppFile){ char *zFile; /* Full name of the temporary file */ char zBuf[50]; /* Base name of the temporary file */ int i; /* Loop counter */ int limit; /* Prevent an infinite loop */ int rc = SQLITE_OK; /* Value returned by this function */ for(i=0; i<pBe->nTemp; i++){ if( pBe->apTemp[i]==0 ) break; } if( i>=pBe->nTemp ){ pBe->nTemp++; pBe->apTemp = sqliteRealloc(pBe->apTemp, pBe->nTemp*sizeof(FILE*) ); |
︙ | ︙ |
Changes to src/expr.c.
︙ | ︙ | |||
19 20 21 22 23 24 25 | ** Author contact information: ** drh@hwaci.com ** http://www.hwaci.com/drh/ ** ************************************************************************* ** This file contains C code routines used for processing expressions ** | | | 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | ** Author contact information: ** drh@hwaci.com ** http://www.hwaci.com/drh/ ** ************************************************************************* ** This file contains C code routines used for processing expressions ** ** $Id: expr.c,v 1.2 2000/06/02 13:27:59 drh Exp $ */ #include "sqliteInt.h" /* ** This routine walks an expression tree and resolves references to ** table fields. Nodes of the form ID.ID or ID resolve into an ** index to the table in the table list and a field offset. The opcode |
︙ | ︙ | |||
73 74 75 76 77 78 79 | } pExpr->op = TK_FIELD; break; } /* A table name and field name: ID.ID */ case TK_DOT: { | | | < | 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 | } pExpr->op = TK_FIELD; break; } /* A table name and field name: ID.ID */ case TK_DOT: { int cnt = 0; /* Number of matches */ int i; /* Loop counter */ Expr *pLeft, *pRight; /* Left and right subbranches of the expr */ char *zLeft, *zRight; /* Text of an identifier */ pLeft = pExpr->pLeft; pRight = pExpr->pRight; assert( pLeft && pLeft->op==TK_ID ); assert( pRight && pRight->op==TK_ID ); zLeft = 0; |
︙ | ︙ |
Changes to src/insert.c.
︙ | ︙ | |||
20 21 22 23 24 25 26 | ** drh@hwaci.com ** http://www.hwaci.com/drh/ ** ************************************************************************* ** This file contains C code routines that are called by the parser ** to handle INSERT statements. ** | | | | 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 | ** drh@hwaci.com ** http://www.hwaci.com/drh/ ** ************************************************************************* ** This file contains C code routines that are called by the parser ** to handle INSERT statements. ** ** $Id: insert.c,v 1.3 2000/06/02 13:27:59 drh Exp $ */ #include "sqliteInt.h" /* ** This routine is call to handle SQL of the following form: ** ** insert into TABLE (IDLIST) values(EXPRLIST) ** ** The parameters are the table name and the expression list. */ void sqliteInsert( Parse *pParse, /* Parser context */ Token *pTableName, /* Name of table into which we are inserting */ ExprList *pList, /* List of values to be inserted */ IdList *pField /* Field name corresponding to pList. Might be NULL */ ){ Table *pTab; char *zTab; int i, j, idx; Vdbe *v; zTab = sqliteTableNameFromToken(pTableName); pTab = sqliteFindTable(pParse->db, zTab); sqliteFree(zTab); if( pTab==0 ){ sqliteSetNString(&pParse->zErrMsg, "no such table: ", 0, |
︙ | ︙ | |||
101 102 103 104 105 106 107 108 109 110 111 112 113 114 | } } } v = pParse->pVdbe = sqliteVdbeCreate(pParse->db->pBe); if( v ){ Index *pIdx; sqliteVdbeAddOp(v, OP_Open, 0, 1, pTab->zName, 0); sqliteVdbeAddOp(v, OP_New, 0, 0, 0, 0); if( pTab->pIndex ){ sqliteVdbeAddOp(v, OP_Dup, 0, 0, 0, 0); } for(i=0; i<pTab->nCol; i++){ if( pField==0 ){ j = i; | > > > | 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 | } } } v = pParse->pVdbe = sqliteVdbeCreate(pParse->db->pBe); if( v ){ Index *pIdx; sqliteVdbeAddOp(v, OP_Open, 0, 1, pTab->zName, 0); for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){ sqliteVdbeAddOp(v, OP_Open, idx, 1, pIdx->zName, 0); } sqliteVdbeAddOp(v, OP_New, 0, 0, 0, 0); if( pTab->pIndex ){ sqliteVdbeAddOp(v, OP_Dup, 0, 0, 0, 0); } for(i=0; i<pTab->nCol; i++){ if( pField==0 ){ j = i; |
︙ | ︙ | |||
122 123 124 125 126 127 128 | }else{ sqliteExprCode(pParse, pList->a[j].pExpr); } } sqliteVdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0, 0, 0); sqliteVdbeAddOp(v, OP_Put, 0, 0, 0, 0); sqliteVdbeAddOp(v, OP_Close, 0, 0, 0, 0); | | < | | | 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 | }else{ sqliteExprCode(pParse, pList->a[j].pExpr); } } sqliteVdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0, 0, 0); sqliteVdbeAddOp(v, OP_Put, 0, 0, 0, 0); sqliteVdbeAddOp(v, OP_Close, 0, 0, 0, 0); for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){ if( pIdx->pNext ){ sqliteVdbeAddOp(v, OP_Dup, 0, 0, 0, 0); } for(i=0; i<pIdx->nField; i++){ int idx = pIdx->aiField[i]; if( pField==0 ){ j = idx; }else{ for(j=0; j<pField->nId; j++){ if( pField->a[j].idx==idx ) break; } } if( pField && j>=pField->nId ){ sqliteVdbeAddOp(v, OP_String, 0, 0, "", 0); }else{ sqliteExprCode(pParse, pList->a[j].pExpr); } } sqliteVdbeAddOp(v, OP_MakeKey, pIdx->nField, 0, 0, 0); sqliteVdbeAddOp(v, OP_PutIdx, idx, 0, 0, 0); sqliteVdbeAddOp(v, OP_Close, idx, 0, 0, 0); } } insert_cleanup: sqliteExprListDelete(pList); sqliteIdListDelete(pField); } |
Changes to src/main.c.
︙ | ︙ | |||
22 23 24 25 26 27 28 | ** ************************************************************************* ** 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. ** | | | 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | ** ************************************************************************* ** 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.6 2000/06/02 13:27:59 drh Exp $ */ #include "sqliteInt.h" /* ** This is the callback routine for the code that initializes the ** database. Each callback contains text of a CREATE TABLE or ** CREATE INDEX statement that must be parsed to yield the internal |
︙ | ︙ | |||
50 51 52 53 54 55 56 57 58 59 60 61 62 63 | return nErr; } /* ** Attempt to read the database schema and initialize internal ** data structures. Return one of the SQLITE_ error codes to ** indicate success or failure. */ static int sqliteInit(sqlite *db, char **pzErrMsg){ Vdbe *vdbe; int rc; /* ** The master database table has a structure like this | > > > > > > > | 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 | return nErr; } /* ** Attempt to read the database schema and initialize internal ** data structures. Return one of the SQLITE_ error codes to ** indicate success or failure. ** ** After the database is initialized, the SQLITE_Initialized ** bit is set in the flags field of the sqlite structure. An ** attempt is made to initialize the database as soon as it ** is opened. If that fails (perhaps because another process ** has the sqlite_master table locked) than another attempt ** is made the first time the database is accessed. */ static int sqliteInit(sqlite *db, char **pzErrMsg){ Vdbe *vdbe; int rc; /* ** The master database table has a structure like this |
︙ | ︙ | |||
173 174 175 176 177 178 179 180 181 182 183 184 185 186 | } /* Attempt to read the schema */ rc = sqliteInit(db, pzErrMsg); if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){ sqlite_close(db); return 0; } return db; } /* ** Close an existing SQLite database */ | > > > | 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 | } /* Attempt to read the schema */ rc = sqliteInit(db, pzErrMsg); if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){ sqlite_close(db); return 0; }else{ sqliteFree(pzErrMsg); *pzErrMsg = 0; } return db; } /* ** Close an existing SQLite database */ |
︙ | ︙ | |||
226 227 228 229 230 231 232 | } i += n; } return lastWasSemi; } /* | | > > > > > > > | 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 | } i += n; } return lastWasSemi; } /* ** Execute SQL code. Return one of the SQLITE_ success/failure ** codes. Also write an error message into memory obtained from ** malloc() and make *pzErrMsg point to that message. ** ** If the SQL is a query, then for each row in the query result ** the xCallback() function is called. pArg becomes the first ** argument to xCallback(). If xCallback=NULL then no callback ** is invoked, even for queries. */ int sqlite_exec( sqlite *db, /* The database on which the SQL executes */ char *zSql, /* The SQL to be executed */ sqlite_callback xCallback, /* Invoke this callback routine */ void *pArg, /* First argument to xCallback() */ char **pzErrMsg /* Write error messages here */ |
︙ | ︙ |
Changes to src/shell.c.
︙ | ︙ | |||
20 21 22 23 24 25 26 | ** drh@hwaci.com ** http://www.hwaci.com/drh/ ** ************************************************************************* ** This file contains code to implement the "sqlite" command line ** utility for accessing SQLite databases. ** | | | 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | ** drh@hwaci.com ** http://www.hwaci.com/drh/ ** ************************************************************************* ** This file contains code to implement the "sqlite" command line ** utility for accessing SQLite databases. ** ** $Id: shell.c,v 1.6 2000/06/02 13:27:59 drh Exp $ */ #include <stdlib.h> #include <string.h> #include <stdio.h> #include "sqlite.h" #include <unistd.h> #include <ctype.h> |
︙ | ︙ | |||
49 50 51 52 53 54 55 | ** ** The interface is like "readline" but no command-line editing ** is done. */ static char *getline(char *zPrompt){ char *zLine; int nLine; | < | 49 50 51 52 53 54 55 56 57 58 59 60 61 62 | ** ** The interface is like "readline" but no command-line editing ** is done. */ static char *getline(char *zPrompt){ char *zLine; int nLine; int n; int eol; if( zPrompt && *zPrompt ){ printf("%s",zPrompt); fflush(stdout); } |
︙ | ︙ | |||
429 430 431 432 433 434 435 | argc--; argv++; }else if( strcmp(argv[1],"-line")==0 ){ data.mode = MODE_Line; argc--; argv++; }else if( argc>=3 && strcmp(argv[0],"-separator")==0 ){ | | | 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 | argc--; argv++; }else if( strcmp(argv[1],"-line")==0 ){ data.mode = MODE_Line; argc--; argv++; }else if( argc>=3 && strcmp(argv[0],"-separator")==0 ){ sprintf(data.separator,"%.*s",(int)sizeof(data.separator)-1,argv[2]); argc -= 2; argv += 2; }else if( strcmp(argv[1],"-header")==0 ){ data.showHeader = 1; argc--; argv++; }else if( strcmp(argv[1],"-noheader")==0 ){ |
︙ | ︙ |
Changes to src/sqliteInt.h.
︙ | ︙ | |||
19 20 21 22 23 24 25 | ** Author contact information: ** drh@hwaci.com ** http://www.hwaci.com/drh/ ** ************************************************************************* ** Internal interface definitions for SQLite. ** | | | 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | ** Author contact information: ** drh@hwaci.com ** http://www.hwaci.com/drh/ ** ************************************************************************* ** Internal interface definitions for SQLite. ** ** @(#) $Id: sqliteInt.h,v 1.10 2000/06/02 13:28:00 drh Exp $ */ #include "sqlite.h" #include "dbbe.h" #include "vdbe.h" #include "parse.h" #include <gdbm.h> #include <stdio.h> |
︙ | ︙ | |||
265 266 267 268 269 270 271 | void sqliteCopy(Parse*, Token*, Token*, Token*); void sqliteVacuum(Parse*, Token*); int sqliteGlobCompare(const char*,const char*); int sqliteLikeCompare(const unsigned char*,const unsigned char*); char *sqliteTableNameFromToken(Token*); int sqliteExprCheck(Parse*, Expr*, int, int*); int sqliteFuncId(Token*); | > | 265 266 267 268 269 270 271 272 | void sqliteCopy(Parse*, Token*, Token*, Token*); void sqliteVacuum(Parse*, Token*); int sqliteGlobCompare(const char*,const char*); int sqliteLikeCompare(const unsigned char*,const unsigned char*); char *sqliteTableNameFromToken(Token*); int sqliteExprCheck(Parse*, Expr*, int, int*); int sqliteFuncId(Token*); int sqliteExprResolveIds(Parse*, IdList*, Expr*); |
Changes to src/util.c.
︙ | ︙ | |||
22 23 24 25 26 27 28 | ** ************************************************************************* ** Utility functions used throughout sqlite. ** ** This file contains functions for allocating memory, comparing ** strings, and stuff like that. ** | | | 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | ** ************************************************************************* ** Utility functions used throughout sqlite. ** ** This file contains functions for allocating memory, comparing ** strings, and stuff like that. ** ** $Id: util.c,v 1.9 2000/06/02 13:28:00 drh Exp $ */ #include "sqliteInt.h" #include <stdarg.h> #include <ctype.h> #ifdef MEMORY_DEBUG |
︙ | ︙ | |||
679 680 681 682 683 684 685 | ** ** This routine is just an adaptation of the sqliteGlobCompare() ** routine above. */ int sqliteLikeCompare(const unsigned char *zPattern, const unsigned char *zString){ register char c; | < < | 679 680 681 682 683 684 685 686 687 688 689 690 691 692 | ** ** This routine is just an adaptation of the sqliteGlobCompare() ** routine above. */ int sqliteLikeCompare(const unsigned char *zPattern, const unsigned char *zString){ register char c; char c2; while( (c = UpperToLower[*zPattern])!=0 ){ switch( c ){ case '%': while( zPattern[1]=='%' ) zPattern++; if( zPattern[1]==0 ) return 1; |
︙ | ︙ |
Added test/select2.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 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 54 55 56 57 58 59 60 61 62 63 64 65 66 67 | # Copyright (c) 1999, 2000 D. Richard Hipp # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public # License along with this library; if not, write to the # Free Software Foundation, Inc., 59 Temple Place - Suite 330, # Boston, MA 02111-1307, USA. # # Author contact information: # drh@hwaci.com # http://www.hwaci.com/drh/ # #*********************************************************************** # This file implements regression tests for SQLite library. The # focus of this file is testing the SELECT statement. # # $Id: select2.test,v 1.1 2000/06/02 13:28:16 drh Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl execsql {CREATE TABLE tbl1(f1 int, f2 int)} for {set i 0} {$i<=30} {incr i} { execsql "INSERT INTO tbl1 VALUES([expr {$i%9}],[expr {$i%10}])" } # Do a second query inside a first. # do_test select2-1.1 { set sql {SELECT DISTINCT f1 FROM tbl1 ORDER BY f1} set r {} db eval $sql data { set f1 $data(f1) lappend r $f1: set sql2 "SELECT f2 FROM tbl1 WHERE f1=$f1 ORDER BY f2" db eval $sql2 d2 { lappend r $d2(f2) } } set r } {0: 0 7 8 9 1: 0 1 8 9 2: 0 1 2 9 3: 0 1 2 3 4: 2 3 4 5: 3 4 5 6: 4 5 6 7: 5 6 7 8: 6 7 8} do_test select2-1.2 { set sql {SELECT DISTINCT f1 FROM tbl1 WHERE f1>3 AND f1<5} set r {} db eval $sql data { set f1 $data(f1) lappend r $f1: set sql2 "SELECT f2 FROM tbl1 WHERE f1=$f1 ORDER BY f2" db eval $sql2 d2 { lappend r $d2(f2) } } set r } {4: 2 3 4} finish_test |
Changes to www/c_interface.tcl.
1 2 3 | # # Run this Tcl script to generate the sqlite.html file. # | | | | > > > > > > > > > > | | 1 2 3 4 5 6 7 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 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 | # # Run this Tcl script to generate the sqlite.html file. # set rcsid {$Id: c_interface.tcl,v 1.3 2000/06/02 13:28:00 drh Exp $} puts {<html> <head> <title>The C language interface to the SQLite library</title> </head> <body bgcolor=white> <h1 align=center> The C language interface to the SQLite library </h1>} puts "<p align=center> (This page was last modified on [lrange $rcsid 3 4] GMT) </p>" puts { <p>The SQLite library is designed to be very easy to use from a C or C++ program. This document gives an overview of the C/C++ programming interface.</p> <h2>The API</h2> <p>The interface to the SQLite library consists of 4 functions, one opaque data structure, and some constants used as return values from sqlite_exec():</p> <blockquote><pre> typedef struct sqlite sqlite; sqlite *sqlite_open(const char *filename, int mode, char **errmsg); void sqlite_close(sqlite*); int sqlite_exec( sqlite*, char *sql, int (*)(void*,int,char**,char**), void*, char **errmsg ); int sqlite_complete(const char *sql); #define SQLITE_OK 0 /* Successful result */ #define SQLITE_INTERNAL 1 /* An internal logic error in SQLite */ #define SQLITE_ERROR 2 /* SQL error or missing database */ #define SQLITE_PERM 3 /* Access permission denied */ #define SQLITE_ABORT 4 /* Callback routine requested an abort */ #define SQLITE_BUSY 5 /* One or more database files are locked */ #define SQLITE_NOMEM 6 /* A malloc() failed */ #define SQLITE_READONLY 7 /* Attempt to write a readonly database */ </pre></blockquote> <p>All of the above definitions are included in the "sqlite.h" header file that comes in the source tree.</p> <h2>Opening a database</h2> <p>Use the <b>sqlite_open()</b> function to open an existing SQLite database or to create a new SQLite database. The first argument is the database name. The second argument is a constant 0666 to open the database for reading and writing and 0444 to open the database read only. The third argument is a pointer to a string pointer. If the third argument is not NULL and an error occurs while trying to open the database, then an error message will be written to memory obtained from malloc() and *errmsg will be made |
︙ | ︙ | |||
69 70 71 72 73 74 75 | <p>To create a new SQLite database, all you have to do is call <b>sqlite_open()</b> with the first parameter set to the name of an empty directory and the second parameter set to 0666.</p> <p>The return value of the <b>sqlite_open()</b> function is a pointer to an opaque <b>sqlite</b> structure. This pointer will be the first argument to all subsequent SQLite function calls that | | > | | | | > > > | | | | | > > > > > > > > > | | | | 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 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 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 170 171 172 173 174 175 176 177 178 179 | <p>To create a new SQLite database, all you have to do is call <b>sqlite_open()</b> with the first parameter set to the name of an empty directory and the second parameter set to 0666.</p> <p>The return value of the <b>sqlite_open()</b> function is a pointer to an opaque <b>sqlite</b> structure. This pointer will be the first argument to all subsequent SQLite function calls that deal with the same database. NULL is returned if the open fails for any reason.</p> <h2>Closing the database</h2> <p>To close an SQLite database, just call the <b>sqlite_close()</b> function passing it the sqlite structure pointer that was obtained from a prior call to <b>sqlite_open</b>. <h2>Executing SQL statements</h2> <p>The <b>sqlite_exec()</b> function is used to process SQL statements and queries. This function requires 5 parameters as follows:</p> <ol> <li><p>A pointer to the sqlite structure obtained from a prior call to <b>sqlite_open()</b>.</p></li> <li><p>A null-terminated string containing the text of one or more SQL statements and/or queries to be processed.</p></li> <li><p>A pointer to a callback function which is invoked once for each row in the result of a query. This argument may be NULL, in which case no callbacks will ever be invoked.</p></li> <li><p>A pointer that is forwarded to become the first argument to the callback function.</p></li> <li><p>A pointer to an error string. Error messages are written to space obtained from malloc() and the error string is made to point to the malloced space. The calling function is responsible for freeing this space when it has finished with it. This argument may be NULL, in which case error messages are not reported back to the calling function.</p></li> </ol> <p> The callback function is used to receive the results of a query. A prototype for the callback function is as follows:</p> <blockquote><pre> int Callback(void *pArg, int argc, char **argv, char **columnNames){ return 0; } </pre></blockquote> <p>The first argument to the callback is just a copy of the fourth argument to <b>sqlite_exec()</b> This parameter can be used to pass arbitrary information through to the callback function from client code. The second argument is the number columns in the query result. The third argument is an array of pointers to strings where each string is a single column of the result for that record. The names of the columns are contained in the fourth argument.</p> <p>The callback function should normally return 0. If the callback function returns non-zero, the query is immediately aborted and <b>sqlite_exec()</b> will return SQLITE_ABORT.</p> <h2>Testing for a complete SQL statement</h2> <p>The last interface routine to SQLite is a convenience function used to test whether or not a string forms a complete SQL statement. If the <b>sqlite_complete()</b> function returns true when its input is a string, then the argument forms a complete SQL statement. There are no guarantees that the syntax of that statement is correct, but we at least know the statement is complete. If <b>sqlite_complete()</b> returns false, then more text is required to complete the SQL statement.</p> <p>For the purpose of the <b>sqlite_complete()</b> function, an SQL statement is complete if it ends in a semicolon.</p> <p>The <b>sqlite</b> command-line utility uses the <b>sqlite_complete()</b> function to know when it needs to call <b>sqlite_exec()</b>. After each line of input is received, <b>sqlite</b> calls <b>sqlite_complete()</b> on all input in its buffer. If <b>sqlite_complete()</b> returns true, then <b>sqlite_exec()</b> is called and the input buffer is reset. If <b>sqlite_complete()</b> returns false, then the prompt is changed to the continuation prompt and another line of text is read and added to the input buffer.</p> <h2>Usage Examples</h2> <p>For examples of how the SQLite C/C++ interface can be used, refer to the source code for the <b>sqlite</b> program in the file <b>src/shell.c</b> of the source tree. Additional information about sqlite is available at <a href="sqlite.html">sqlite.html</a>. See also the sources to the Tcl interface for SQLite in the source file <b>src/tclsqlite.c</b>.</p> } puts { <p><hr /></p> <p><a href="index.html"><img src="/goback.jpg" border=0 /> Back to the SQLite Home Page</a> </p> </body></html>} |
Changes to www/changes.tcl.
︙ | ︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | } proc chng {date desc} { puts "<DT><B>$date</B></DT>" puts "<DD><P><UL>$desc</UL></P></DD>" } chng {2000 May 31} { <li>Added support for aggregate functions (Ex: <b>COUNT(*)</b>, <b>MIN(...)</b>) to the SELECT statement.</li> <li>Added support for <B>SELECT DISTINCT ...</B></li> } | > > > > > > > > > > > > > > > | 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 | } proc chng {date desc} { puts "<DT><B>$date</B></DT>" puts "<DD><P><UL>$desc</UL></P></DD>" } chng {2000 June 2} { <li>All database files to be modified by an UPDATE, INSERT or DELETE are now locked before any changes are made to any files. This makes it safe (I think) to access the same database simultaneously from multiple processes.</li> <li>The code appears stable so we are now calling it "beta".</li> } chng {2000 June 1} { <li>Better support for file locking so that two or more processes (or threads) can access the same database simultaneously. More work needed in this area, though.</li> } chng {2000 May 31} { <li>Added support for aggregate functions (Ex: <b>COUNT(*)</b>, <b>MIN(...)</b>) to the SELECT statement.</li> <li>Added support for <B>SELECT DISTINCT ...</B></li> } |
︙ | ︙ |
Changes to www/index.tcl.
1 2 3 | # # Run this TCL script to generate HTML for the index.html file. # | | | | > | > > | > | < > | < < | | < | > > | > | | | > | > | | 1 2 3 4 5 6 7 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 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | # # Run this TCL script to generate HTML for the index.html file. # set rcsid {$Id: index.tcl,v 1.10 2000/06/02 13:28:00 drh Exp $} puts {<html> <head><title>SQLite: An SQL Database Built Atop GDBM</title></head> <body bgcolor=white> <h1 align=center>SQLite: An SQL Database Built Upon <a href="http://www.gnu.org/software/gdbm/gdbm.html">GDBM</a></h1> <p align=center>} puts "This page was last modified on [lrange $rcsid 3 4] GMT<br>" puts "The SQLite source code was last modifed on [exec cat last_change] GMT" puts {</p>} puts { <h2>News</h2> <p> Though still relatively new, the SQLite code base appears to be working well and has therefore been upgraded to "beta" status. There are currently no known errors in the code. One very large database (1M+ records in 50+ separate tables) has been converted from PostgreSQL and gives every appearance of working correctly.</p> <p>Your constructive comments are still very important to us. Please visit the <a href="#mailinglist">mailing list</a> to offer feedback.</p> } puts {<h2>Introduction</h2> <p>SQLite is an SQL database built atop the <a href="http://www.gnu.org/software/gdbm/gdbm.html">GDBM library</a>. The SQLite distribution includes both a interactive command-line access program (<b>sqlite</b>) and a C library (<b>libsqlite.a</b>) that can be linked with a C/C++ program to provide SQL database access without having to rely on an external RDBMS.</p> <p>The C interface to SQLite is very simple, consisting of only four functions, a single opaque data structure, and a handful of constants that define error return codes. See <a href="c_interface.html">c_interface.html</a> for details. A Tcl interface to SQLite is also available and is included in the source tree. Documentation on the Tcl interface is pending. Interfaces for perl and python may be supplied in future releases.</p> <p>The standalone program <b>sqlite</b> can be used to interactively create, update and/or query an SQLite database. The sources to the sqlite program are part of the source tree and can be used as an example of how to interact with the SQLite C library. For more information on the sqlite program, see <a href="sqlite.html">sqlite.html</a>.</p> <p>A history of changes to SQLite is found <a href="changes.html">here</a>.</p> <p>SQLite is intended to be small and light-weight. It does not try to implement every feature of SQL. A few of the many SQL features that SQLite does not (currently) implement are as follows:</p> <p> <ul> <li>The GROUP BY or HAVING clauses of a SELECT</li> <li>Constraints</li> |
︙ | ︙ | |||
92 93 94 95 96 97 98 99 100 101 102 103 104 105 | puts {<h2>Download</h2> <p>You can download a tarball containing all C source code for SQLite at <a href="sqlite.tar.gz">sqlite.tar.gz</a>.} puts "This is a [file size sqlite.tar.gz] byte download. The tarball was last modified at [clock format [file mtime sqlite.tar.gz]]" puts {</p> <p>You can also download a larger tarball that contains everything in the source tarball plus all of the sources for the text that appears on this website, and other miscellaneous files. The complete tarball is found at <a href="all.tar.gz">all.tar.gz</a>.} puts "This is a [file size all.tar.gz] byte download and was was last modified at [clock format [file mtime sqlite.tar.gz]]</p>" | > > > > > > > > > > > > > | 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 | puts {<h2>Download</h2> <p>You can download a tarball containing all C source code for SQLite at <a href="sqlite.tar.gz">sqlite.tar.gz</a>.} puts "This is a [file size sqlite.tar.gz] byte download. The tarball was last modified at [clock format [file mtime sqlite.tar.gz]]" puts {</p> <p>To build sqlite, just unwrap the tarball, create a separate build directory, run configure from the build directory and then type "make". For example:</p> <blockquote><pre> $ tar xzf sqlite.tar.gz ;# Unpacks into directory named "sqlite" $ mkdir bld ;# Create a separate build directory $ cd bld $ ../sqlite/configure $ make ;# Builds "sqlite" and "libsqlite.a" $ make test ;# Optional: run regression tests </pre></blockquote> <p>You can also download a larger tarball that contains everything in the source tarball plus all of the sources for the text that appears on this website, and other miscellaneous files. The complete tarball is found at <a href="all.tar.gz">all.tar.gz</a>.} puts "This is a [file size all.tar.gz] byte download and was was last modified at [clock format [file mtime sqlite.tar.gz]]</p>" |
︙ | ︙ | |||
113 114 115 116 117 118 119 | <li><p>Someday, we would like to port SQLite to work with the Berkeley DB library in addition to GDBM. For information about the Berkeley DB library, see <a href="http://www.sleepycat.com/">http://www.sleepycat.com/</a> </p></li> | | > > > | 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 | <li><p>Someday, we would like to port SQLite to work with the Berkeley DB library in addition to GDBM. For information about the Berkeley DB library, see <a href="http://www.sleepycat.com/">http://www.sleepycat.com/</a> </p></li> <li><p>Here is a good <a href="http://w3.one.net/~jhoffman/sqltut.htm"> tutorial on SQL</a>.</p></li> <li><p><a href="http://www.postgresql.org/">PostgreSQL</a> is a full-blown SQL RDBMS that is also open source.</p></li> </ul>} puts { <p><hr /></p> <p> <a href="../index.html"><img src="/goback.jpg" border=0 /> More Open Source Software</a> from Hwaci. </p> </body></html>} |
Changes to www/sqlite.tcl.
1 2 3 | # # Run this Tcl script to generate the sqlite.html file. # | | | 1 2 3 4 5 6 7 8 9 10 11 | # # Run this Tcl script to generate the sqlite.html file. # set rcsid {$Id: sqlite.tcl,v 1.6 2000/06/02 13:28:00 drh Exp $} puts {<html> <head> <title>sqlite: A program of interacting with SQLite databases</title> </head> <body bgcolor=white> <h1 align=center> |
︙ | ︙ | |||
26 27 28 29 30 31 32 | <p>To start the <b>sqlite</b> program, just type "sqlite" followed by the name of an SQLite database. An SQLite database is really just a directory full of GDBM files, so the argument to the sqlite command should really be the name of a directory on your disk. If that directory did not previously contain an SQLite database, a new one is created for you automatically. The <b>sqlite</b> program will prompt you to enter SQL. Type in SQL statements (terminated by a | | | 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | <p>To start the <b>sqlite</b> program, just type "sqlite" followed by the name of an SQLite database. An SQLite database is really just a directory full of GDBM files, so the argument to the sqlite command should really be the name of a directory on your disk. If that directory did not previously contain an SQLite database, a new one is created for you automatically. The <b>sqlite</b> program will prompt you to enter SQL. Type in SQL statements (terminated by a semicolon), press "Enter" and the SQL will be executed. It's as simple as that!</p> <p>For example, to create a new SQLite database named "ex1" with a single table named "tbl1", you might do this:</p> } proc Code {body} { |
︙ | ︙ | |||
52 53 54 55 56 57 58 | $ (((mkdir ex1))) $ (((sqlite ex1))) Enter ".help" for instructions sql> (((create table tbl1(one varchar(10), two smallint);))) sql> (((insert into tbl1 values('hello!',10);))) sql> (((insert into tbl1 values('goodbye', 20);))) sql> (((select * from tbl1;))) | | < < | < | | 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 | $ (((mkdir ex1))) $ (((sqlite ex1))) Enter ".help" for instructions sql> (((create table tbl1(one varchar(10), two smallint);))) sql> (((insert into tbl1 values('hello!',10);))) sql> (((insert into tbl1 values('goodbye', 20);))) sql> (((select * from tbl1;))) hello!|10 goodbye|20 sql> } puts { <p>(In the example above, and in all subsequent examples, the commands you type are shown with a green tint in an italic font and the responses from the computer are shown in black with a constant-width font.)</p> <p>You can terminate the sqlite program by typing your systems End-Of-File character (usually a Control-D) or the interrupt character (usually a Control-C).</p> <p>Make sure you type a semicolon at the end of each SQL command! The sqlite looks for a semicolon to know when your SQL command is complete. If you omit the semicolon, sqlite will give you a continuation prompt and wait for you to enter more text to be added to the current SQL command. This feature allows you to enter SQL commands that span multiple lines. For example:</p> } |
︙ | ︙ | |||
118 119 120 121 122 123 124 | sql = create table tbl1(one varchar(10), two smallint) sql> } puts { <p> But you cannot execute DROP TABLE, UPDATE, INSERT or DELETE against | | | | | | 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 | sql = create table tbl1(one varchar(10), two smallint) sql> } puts { <p> But you cannot execute DROP TABLE, UPDATE, INSERT or DELETE against the sqlite_master table. The sqlite_master table is updated automatically as you create or drop tables and indices from the database. You can not make manual changes to the sqlite_master table. </p> <h2>Special commands to sqlite</h2> <p> Most of the time, sqlite just reads lines of input and passes them on to the SQLite library for execution. But if an input line begins with a dot ("."), then that line is intercepted and interpreted by the sqlite program itself. These "dot commands" are typically used to change the output format of queries, or to execute certain prepackaged query statements. </p> <p> For a listing of the available dot commands, you can enter ".help" at any time. For example: </p>} |
︙ | ︙ | |||
183 184 185 186 187 188 189 | one = goodbye two = 20 sql> } puts { | | > | | 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 | one = goodbye two = 20 sql> } puts { <p>Line mode used to be the default mode setting. But after some experience using the utility, it was decided that "list" mode made a better default and so now the default mode is "list".</p> } puts { <p>In column mode, each record is shown on a separate line with the data aligned in columns. For example:</p>} Code { |
︙ | ︙ | |||
217 218 219 220 221 222 223 | ------------ ------ hello 10 goodbye 20 sql> } puts { | | | 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 | ------------ ------ hello 10 goodbye 20 sql> } puts { <p>The ".width" command in the example above sets the width of the first column to 12 and the width of the second column to 6. All other column widths were unaltered. You can gives as many arguments to ".width" as necessary to specify the widths of as many columns as are in your query results.</p> <p>The column labels that appear on the first two lines of output can be turned on and off using the ".header" dot command. In the |
︙ | ︙ | |||
242 243 244 245 246 247 248 | puts { <p>The third output mode supported by sqlite is called "list". In list mode, each record of a query result is written on one line of output and each field within that record is separated by a specific separator string. The default separator is a pipe symbol ("|"). List mode is especially useful when you are going to send the output | | | 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 | puts { <p>The third output mode supported by sqlite is called "list". In list mode, each record of a query result is written on one line of output and each field within that record is separated by a specific separator string. The default separator is a pipe symbol ("|"). List mode is especially useful when you are going to send the output of a query to another program (such as AWK) for additional processing.</p>} Code { sql> (((.mode list))) sql> (((select * from tbl1;))) hello|10 goodbye|20 sql> |
︙ | ︙ | |||
364 365 366 367 368 369 370 | list mode, then entering the following query:</p> <blockquote><pre> SELECT sql FROM sqlite_master ORDER BY tbl_name, type DESC, name </pre></blockquote> | | | | | | 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 | list mode, then entering the following query:</p> <blockquote><pre> SELECT sql FROM sqlite_master ORDER BY tbl_name, type DESC, name </pre></blockquote> <p>Or, if you give an argument to ".schema" because you only want the schema for a single table, the query looks like this:</p> <blockquote><pre> SELECT sql FROM sqlite_master WHERE tbl_name LIKE '%s' ORDER BY type DESC, name </pre></blockquote> <p>The <b>%s</b> in the query above is replaced by the argument to ".schema", of course.</p> <h2>Other Dot Commands</h2> <p>The ".explain" dot command can be used to set the output mode to "column" and to set the column widths to values that are reasonable for looking at the output of an EXPLAIN command. The EXPLAIN command is an SQLite-specific SQL extension that is useful for debugging. If any regular SQL is prefaced by EXPLAIN, then the SQL command is parsed and analyzed but is not executed. Instead, the sequence of virtual machine instructions that would have been used to execute the SQL command are returned like a query result. For example:</p>} Code { sql> (((.explain))) sql> (((explain delete from tbl1 where two<20;))) addr opcode p1 p2 p3 ---- ------------ ----- ----- ------------------------------------- 0 ListOpen 0 0 1 Open 0 1 tbl1 2 Next 0 9 3 Field 0 1 4 Integer 20 0 5 Ge 0 2 6 Key 0 0 7 ListWrite 0 0 8 Goto 0 2 |
︙ | ︙ |