Remove the COPY command. (CVS 1477)
FossilOrigin-Name: 287f86731c71401dbac098e08357367b4f8e5a43
This commit is contained in:
drh
parent
6d88bad4f9
commit
5f3b4ab53c
6
main.mk
6
main.mk
@ -54,7 +54,7 @@ TCCX = $(TCC) $(OPTS) $(THREADSAFE) $(USLEEP) -I. -I$(TOP)/src
|
||||
|
||||
# Object files for the SQLite library.
|
||||
#
|
||||
LIBOBJ = attach.o auth.o btree.o build.o copy.o date.o delete.o \
|
||||
LIBOBJ = attach.o auth.o btree.o build.o date.o delete.o \
|
||||
expr.o func.o hash.o insert.o \
|
||||
main.o opcodes.o os_mac.o os_unix.o os_win.o \
|
||||
pager.o parse.o pragma.o printf.o random.o \
|
||||
@ -70,7 +70,6 @@ SRC = \
|
||||
$(TOP)/src/btree.c \
|
||||
$(TOP)/src/btree.h \
|
||||
$(TOP)/src/build.c \
|
||||
$(TOP)/src/copy.c \
|
||||
$(TOP)/src/date.c \
|
||||
$(TOP)/src/delete.c \
|
||||
$(TOP)/src/encode.c \
|
||||
@ -219,9 +218,6 @@ config.h:
|
||||
echo >>config.h
|
||||
rm -f temp.c temp
|
||||
|
||||
copy.o: $(TOP)/src/copy.c $(HDR)
|
||||
$(TCCX) -c $(TOP)/src/copy.c
|
||||
|
||||
date.o: $(TOP)/src/date.c $(HDR)
|
||||
$(TCCX) -c $(TOP)/src/date.c
|
||||
|
||||
|
||||
49
manifest
49
manifest
@ -1,5 +1,5 @@
|
||||
C Enhance\sthe\sC\sfunction\sused\sto\stest\ssqlite3_create_function()\sfrom\sTcl.\s(CVS\s1476)
|
||||
D 2004-05-27T14:23:36
|
||||
C Remove\sthe\sCOPY\scommand.\s(CVS\s1477)
|
||||
D 2004-05-27T17:22:55
|
||||
F Makefile.in ab7b0d5118e2da97bac66be8684a1034e3500f5a
|
||||
F Makefile.linux-gcc b86a99c493a5bfb402d1d9178dcdc4bd4b32f906
|
||||
F README f1de682fbbd94899d50aca13d387d1b3fd3be2dd
|
||||
@ -16,7 +16,7 @@ F doc/lemon.html f0f682f50210928c07e562621c3b7e8ab912a538
|
||||
F doc/report1.txt a031aaf37b185e4fa540223cb516d3bccec7eeac
|
||||
F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895
|
||||
F ltmain.sh f6b283068efa69f06eb8aa1fe4bddfdbdeb35826
|
||||
F main.mk 466f12b816527d5bb1cf5dac4f23da77a02f99ad
|
||||
F main.mk d742c15aa8fac4a83aa807a7c47c76e5ea9af089
|
||||
F publish.sh 1cd5c982388560fa91eedf6a338e210f713b35c8
|
||||
F spec.template a38492f1c1dd349fc24cb0565e08afc53045304b
|
||||
F sqlite.1 83f4a9d37bdf2b7ef079a82d54eaf2e3509ee6ea
|
||||
@ -27,7 +27,6 @@ F src/auth.c 5c2f0bea4729c98c2be3b69d6b466fc51448fe79
|
||||
F src/btree.c 6db76fbf63efd6008c5e6cb038ea40f94abffcf7
|
||||
F src/btree.h b65140b5ae891f30d2a39e64b9f0343225553545
|
||||
F src/build.c 35cbeb439b49cca5eb5e8a1de010a5194f4523e8
|
||||
F src/copy.c 6eb7cc08ae6dc60bf83ecadf4508a0bef909dbd2
|
||||
F src/date.c 0eb922af5c5f5e2455f8dc2f98023ed3e04a857e
|
||||
F src/delete.c 66c5ab98cbad7e6b315fc997bfe6c8080784a701
|
||||
F src/encode.c a876af473d1d636faa3dca51c7571f2e007eea37
|
||||
@ -49,14 +48,14 @@ F src/os_win.c 92b51a38437b98d8aa3ac05b57c71e1d1092e5be
|
||||
F src/os_win.h 5d41af24caaef6c13a2d8e2399caa1c57d45c84d
|
||||
F src/pager.c 6ff6b906427d4824099140776cb8768f922f3dc5
|
||||
F src/pager.h 78a00ac280899bcba1a89dc51585dcae6b7b3253
|
||||
F src/parse.y 1a39b21982af48cf5c61a4085eece9cab84f9b71
|
||||
F src/parse.y 63d39b6fe17d0c2c2c1f691e75a119a71d25439a
|
||||
F src/pragma.c f2b05b087a5764802296a28d7abdd75728beedee
|
||||
F src/printf.c ef750e8e2398ca7e8b58be991075f08c6a7f0e53
|
||||
F src/random.c eff68e3f257e05e81eae6c4d50a51eb88beb4ff3
|
||||
F src/select.c 2ba142a490ab2777b6a086e7c0d078a952331109
|
||||
F src/shell.c ed4d237b3e52a0a42512bfcc53530e46de20c28f
|
||||
F src/sqlite.h.in cda883efb11c6f767eaf3fea06b3e3419d9cfe7f
|
||||
F src/sqliteInt.h 9c528cc7a41efafb0443655d29eafd10d8378952
|
||||
F src/sqliteInt.h 7978f406b41819f37fb6fb1be64115a2e7a28ab5
|
||||
F src/table.c af14284fa36c8d41f6829e3f2819dce07d3e2de2
|
||||
F src/tclsqlite.c 877d0b96013a25b03ed6bd2d32917c42e84403bc
|
||||
F src/test1.c 32934478366531503d634968db414df17cb38238
|
||||
@ -64,13 +63,13 @@ F src/test2.c 6195a1ca2c8d0d2d93644e86da3289b403486872
|
||||
F src/test3.c 5e4a6d596f982f6f47a5f9f75ede9b4a3b739968
|
||||
F src/test4.c 34848a9fd31aa65857b20a8bfc03aff77d8c3426
|
||||
F src/test5.c 9a1f15133f6955f067c5246e564723b5f23ff221
|
||||
F src/tokenize.c d40f90119182bf1a026a008453f28fcc6b101738
|
||||
F src/tokenize.c 76eebcab0fad3e983935f833de757818a866a64f
|
||||
F src/trigger.c 11afe9abfba13a2ba142944c797c952e162d117f
|
||||
F src/update.c 96461bcf4e946697e83c09c77c7e61b545a2f66e
|
||||
F src/utf.c 59b5c8f06a4384a9f64933d6c57a2de02ce3673b
|
||||
F src/util.c d299404febd509556e720fbecadd880756b0f899
|
||||
F src/vacuum.c 8734f89742f246abd91dbd3e087fc153bddbfbad
|
||||
F src/vdbe.c 54a758cc50b7eb9fe67fab9f2804d3b900536538
|
||||
F src/vdbe.c 2f2c9859ad19836b31825d2d70c4a8e6a9eba0d1
|
||||
F src/vdbe.h e73f890e0f2a6c42b183d7d6937947930fe4fdeb
|
||||
F src/vdbeInt.h fab8bb7f7a7f4e0714d9b3217c3db97366e16b99
|
||||
F src/vdbeapi.c b0bb1f98c899ba00c8a5cbca612c2a28a1bb79de
|
||||
@ -80,7 +79,7 @@ F src/where.c efe5d25fe18cd7381722457898cd863e84097a0c
|
||||
F test/all.test 569a92a8ee88f5300c057cc4a8f50fbbc69a3242
|
||||
F test/attach.test cb9b884344e6cfa5e165965d5b1adea679a24c83
|
||||
F test/attach2.test 5472d442bb2ef1ee587e0ae7472bb68b52509a38
|
||||
F test/auth.test 5c4d95cdaf539c0c236e20ce1f71a93e7dde9185
|
||||
F test/auth.test 95809b8f6a9bec18b94d28cafd03fe27d2f8a9e9
|
||||
F test/bigfile.test ea904b853ce2d703b16c5ce90e2b54951bc1ae81
|
||||
F test/bigrow.test 8ab252dba108f12ad64e337b0f2ff31a807ac578
|
||||
F test/bind.test 4f5a19e84077b61ea797644b4942bb98b17bdd42
|
||||
@ -93,32 +92,30 @@ F test/btree6.test a5ede6bfbbb2ec8b27e62813612c0f28e8f3e027
|
||||
F test/capi2.test 8fb64e8ab7f78b8254cd4d04bb96822167f731b2
|
||||
F test/capi3.test 3d4d431c3b889893504d59064a018642013fd740
|
||||
F test/conflict.test 0911bb2f079046914a6e9c3341b36658c4e2103e
|
||||
F test/copy.test f07ea8d60878da7a67416ab62f78e9706b9d3c45
|
||||
F test/crashtest1.c 09c1c7d728ccf4feb9e481671e29dda5669bbcc2
|
||||
F test/date.test aed5030482ebc02bd8d386c6c86a29f694ab068d
|
||||
F test/delete.test 92256384f1801760180ded129f7427884cf28886
|
||||
F test/delete.test ddb1d4e172a01c0165804f82f81df556fb48a856
|
||||
F test/enc.test a55481d45ff493804e8d88357feb4642fc50a6b2
|
||||
F test/enc2.test 669f46b4e298a22fb515cb52c55eb8dca57d8b4a
|
||||
F test/enc2.test 8ab83839b73ce3a571b1396379f2f8ae3c895d74
|
||||
F test/expr.test 8b62f3fcac64fbd5c3d43d7a7984245743dcbe65
|
||||
F test/fkey1.test d65c824459916249bee501532d6154ddab0b5db7
|
||||
F test/format3.test 149cc166c97923fa60def047e90dd3fb32bba916
|
||||
F test/func.test b6d87075ff65babd6466b8a8dfc0d44f6a92df0c
|
||||
F test/hook.test 1a67ce0cd64a6455d016962542f2822458dccc49
|
||||
F test/in.test 0de39b02ceeca90993b096822fb5a884661c5b47
|
||||
F test/in.test b92a2df9162e1cbd33c6449a29a05e6955b1741a
|
||||
F test/index.test 3d50e19807186682de60c53f507a831c1b4a38a2
|
||||
F test/insert.test 6ec324659656f4a86e4abfcf1a1fd2795ba6b603
|
||||
F test/insert2.test c288375a64dad3295044714f0dfed4a193cf067f
|
||||
F test/interrupt.test 9142ce4448605127640eda5e283952f75f67ed91
|
||||
F test/intpkey.test 9320af48415c594afd4e15f8ef0daa272e05502e
|
||||
F test/intpkey.test e93d739c8a49f5f63748d4ed1c8084c33dc4c0a1
|
||||
F test/ioerr.test 5dbaf09f96b56ee01cf3edd762b96eb4ad2c9ca4
|
||||
F test/join.test 9ef6aabaac9de51d5fc41e68d1f4355da05a84cd
|
||||
F test/join2.test c97e4c5aa65dea462145529e58212a709b4722b8
|
||||
F test/lastinsert.test 31382f88b9b0270333ac9e4a17f2c2f4732da718
|
||||
F test/laststmtchanges.test cabd11bdfbaf73a4486c50b58297d9c2038ccc18
|
||||
F test/limit.test 94c5dca1e81b7503ce90262ec5a2dc6c4e38d313
|
||||
F test/limit.test 60d7f856ee7846f7130dee67f10f0e726cd70b5d
|
||||
F test/lock.test 226ef831dad60ad4d200dc83e25479ba952aac7e
|
||||
F test/main.test 6a851b5992c4881a725a3d9647e629199df8de9d
|
||||
F test/malloc.test 2cfcffb7c858640e01e6520ee1cd54ca57d98e80
|
||||
F test/malloc.test 4e19b96d9cd7d61f4826e6fce03849ad5ad526dd
|
||||
F test/memdb.test 6ece25c7c0e6500199d3662607a3edca081abb2a
|
||||
F test/memleak.test 4d5d374c8ea1fc5ac634aed58cac1047848ce65e
|
||||
F test/minmax.test 9dcf52f713b1b9e61d0a88a51eb8bb2e3c52d0ab
|
||||
@ -137,12 +134,12 @@ F test/quick.test 8800cd2f6b45ce2cafadb0e3d5161688c61c946a
|
||||
F test/quote.test 08f23385c685d3dc7914ec760d492cacea7f6e3d
|
||||
F test/rowid.test 863e6e75878cccf03d166fe52023f20e09508683
|
||||
F test/select1.test 3bfcccd2eadcddbb07f1f5da6550aee8484ea4fb
|
||||
F test/select2.test bafe576b76616f101c06a780a8155d5a6c363127
|
||||
F test/select3.test 9779f01f68bb3804261331557047e5a3334ce5b0
|
||||
F test/select4.test d2443e558c5013b22eaa25533fa22ef0ff0b1095
|
||||
F test/select5.test c2a6c4a003316ee42cbbd689eebef8fdce0db2ac
|
||||
F test/select2.test a7226dc9de4ae713943a408bb8f9d3de46ee8015
|
||||
F test/select3.test f8ff60d98c7b4898f5e7326f0c5929ba56f5d047
|
||||
F test/select4.test 86e72fc3b07de4fe11439aa419e37db3c49467e2
|
||||
F test/select5.test 3f3f0f31e674fa61f8a3bdb6af1517dfae674081
|
||||
F test/select6.test a9e31906e700e7c7592c4d0acfc022808f718baf
|
||||
F test/sort.test 0ed7ff33d8435dde289342d0a5fed662f762f700
|
||||
F test/sort.test 863f07884fb68a70b738998e9a548132a0d0b7d9
|
||||
F test/subselect.test f0fea8cf9f386d416d64d152e3c65f9116d0f50f
|
||||
F test/table.test 71f808817b50ae3a9a693a88b3ea003f1031cdbb
|
||||
F test/tableapi.test e0c4cce61e58343caa84dab33fa6823cb35fe1e1
|
||||
@ -206,7 +203,7 @@ F www/sqlite.tcl 3c83b08cf9f18aa2d69453ff441a36c40e431604
|
||||
F www/tclsqlite.tcl b9271d44dcf147a93c98f8ecf28c927307abd6da
|
||||
F www/vdbe.tcl 9b9095d4495f37697fd1935d10e14c6015e80aa1
|
||||
F www/whentouse.tcl a8335bce47cc2fddb07f19052cb0cb4d9129a8e4
|
||||
P 42247b2fb0c94e75a432b3e067fff9a1be328fc8
|
||||
R 7d62fd5bc03776e1e9a987c53ee143b8
|
||||
U danielk1977
|
||||
Z b23a568694419f227d6a8be83fed4002
|
||||
P c85e5f1528d098ea330ed0cf7e3c01cf9be93c10
|
||||
R 0f424c162c35b47a72bb56f63064dff2
|
||||
U drh
|
||||
Z 4f618cbd73c341429c69a19968301445
|
||||
|
||||
@ -1 +1 @@
|
||||
c85e5f1528d098ea330ed0cf7e3c01cf9be93c10
|
||||
287f86731c71401dbac098e08357367b4f8e5a43
|
||||
113
src/copy.c
113
src/copy.c
@ -1,113 +0,0 @@
|
||||
/*
|
||||
** 2003 April 6
|
||||
**
|
||||
** 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.
|
||||
**
|
||||
*************************************************************************
|
||||
** This file contains code used to implement the COPY command.
|
||||
**
|
||||
** $Id: copy.c,v 1.13 2004/05/26 10:11:05 danielk1977 Exp $
|
||||
*/
|
||||
#include "sqliteInt.h"
|
||||
|
||||
/*
|
||||
** The COPY command is for compatibility with PostgreSQL and specificially
|
||||
** for the ability to read the output of pg_dump. The format is as
|
||||
** follows:
|
||||
**
|
||||
** COPY table FROM file [USING DELIMITERS string]
|
||||
**
|
||||
** "table" is an existing table name. We will read lines of code from
|
||||
** file to fill this table with data. File might be "stdin". The optional
|
||||
** delimiter string identifies the field separators. The default is a tab.
|
||||
*/
|
||||
void sqlite3Copy(
|
||||
Parse *pParse, /* The parser context */
|
||||
SrcList *pTableName, /* The name of the table into which we will insert */
|
||||
Token *pFilename, /* The file from which to obtain information */
|
||||
Token *pDelimiter, /* Use this as the field delimiter */
|
||||
int onError /* What to do if a constraint fails */
|
||||
){
|
||||
Table *pTab;
|
||||
int i;
|
||||
Vdbe *v;
|
||||
int addr, end;
|
||||
char *zFile = 0;
|
||||
const char *zDb;
|
||||
sqlite *db = pParse->db;
|
||||
|
||||
|
||||
if( sqlite3_malloc_failed ) goto copy_cleanup;
|
||||
assert( pTableName->nSrc==1 );
|
||||
pTab = sqlite3SrcListLookup(pParse, pTableName);
|
||||
if( pTab==0 || sqlite3IsReadOnly(pParse, pTab, 0) ) goto copy_cleanup;
|
||||
zFile = sqliteStrNDup(pFilename->z, pFilename->n);
|
||||
sqlite3Dequote(zFile);
|
||||
assert( pTab->iDb<db->nDb );
|
||||
zDb = db->aDb[pTab->iDb].zName;
|
||||
if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb)
|
||||
|| sqlite3AuthCheck(pParse, SQLITE_COPY, pTab->zName, zFile, zDb) ){
|
||||
goto copy_cleanup;
|
||||
}
|
||||
v = sqlite3GetVdbe(pParse);
|
||||
if( v ){
|
||||
sqlite3BeginWriteOperation(pParse, 1, pTab->iDb);
|
||||
addr = sqlite3VdbeOp3(v, OP_FileOpen, 0, 0, pFilename->z, pFilename->n);
|
||||
sqlite3VdbeDequoteP3(v, addr);
|
||||
sqlite3OpenTableAndIndices(pParse, pTab, 0);
|
||||
if( db->flags & SQLITE_CountRows ){
|
||||
sqlite3VdbeAddOp(v, OP_Integer, 0, 0); /* Initialize the row count */
|
||||
}
|
||||
end = sqlite3VdbeMakeLabel(v);
|
||||
addr = sqlite3VdbeAddOp(v, OP_FileRead, pTab->nCol, end);
|
||||
if( pDelimiter ){
|
||||
sqlite3VdbeChangeP3(v, addr, pDelimiter->z, pDelimiter->n);
|
||||
sqlite3VdbeDequoteP3(v, addr);
|
||||
}else{
|
||||
sqlite3VdbeChangeP3(v, addr, "\t", 1);
|
||||
}
|
||||
if( pTab->iPKey>=0 ){
|
||||
sqlite3VdbeAddOp(v, OP_FileColumn, pTab->iPKey, 0);
|
||||
sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0);
|
||||
}else{
|
||||
sqlite3VdbeAddOp(v, OP_NewRecno, 0, 0);
|
||||
}
|
||||
for(i=0; i<pTab->nCol; i++){
|
||||
if( i==pTab->iPKey ){
|
||||
/* The integer primary key column is filled with NULL since its
|
||||
** value is always pulled from the record number */
|
||||
sqlite3VdbeAddOp(v, OP_String, 0, 0);
|
||||
}else{
|
||||
sqlite3VdbeAddOp(v, OP_FileColumn, i, 0);
|
||||
}
|
||||
}
|
||||
sqlite3GenerateConstraintChecks(pParse, pTab, 0, 0, pTab->iPKey>=0,
|
||||
0, onError, addr);
|
||||
sqlite3CompleteInsertion(pParse, pTab, 0, 0, 0, 0, -1);
|
||||
if( (db->flags & SQLITE_CountRows)!=0 ){
|
||||
sqlite3VdbeAddOp(v, OP_AddImm, 1, 0); /* Increment row count */
|
||||
}
|
||||
sqlite3VdbeAddOp(v, OP_Goto, 0, addr);
|
||||
sqlite3VdbeResolveLabel(v, end);
|
||||
sqlite3VdbeAddOp(v, OP_Noop, 0, 0);
|
||||
sqlite3EndWriteOperation(pParse);
|
||||
if( db->flags & SQLITE_CountRows ){
|
||||
sqlite3VdbeAddOp(v, OP_Callback, 1, 0);
|
||||
sqlite3VdbeSetNumCols(v, 1);
|
||||
sqlite3VdbeSetColName(v, 0, "rows inserted", P3_STATIC);
|
||||
}
|
||||
}
|
||||
|
||||
copy_cleanup:
|
||||
sqlite3SrcListDelete(pTableName);
|
||||
sqliteFree(zFile);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
|
||||
12
src/parse.y
12
src/parse.y
@ -14,7 +14,7 @@
|
||||
** the parser. Lemon will also generate a header file containing
|
||||
** numeric codes for all of the tokens.
|
||||
**
|
||||
** @(#) $Id: parse.y,v 1.118 2004/05/27 09:28:43 danielk1977 Exp $
|
||||
** @(#) $Id: parse.y,v 1.119 2004/05/27 17:22:55 drh Exp $
|
||||
*/
|
||||
%token_prefix TK_
|
||||
%token_type {Token}
|
||||
@ -122,7 +122,7 @@ id(A) ::= ID(X). {A = X;}
|
||||
//
|
||||
%fallback ID
|
||||
ABORT AFTER ASC ATTACH BEFORE BEGIN CASCADE CLUSTER CONFLICT
|
||||
COPY DATABASE DEFERRED DELIMITERS DESC DETACH EACH END EXPLAIN FAIL FOR
|
||||
DATABASE DEFERRED DESC DETACH EACH END EXPLAIN FAIL FOR
|
||||
GLOB IGNORE IMMEDIATE INITIALLY INSTEAD LIKE MATCH KEY
|
||||
OF OFFSET PRAGMA RAISE REPLACE RESTRICT ROW STATEMENT
|
||||
TEMP TRIGGER VACUUM VIEW.
|
||||
@ -758,14 +758,6 @@ cmd ::= DROP INDEX nm(X) dbnm(Y). {
|
||||
sqlite3DropIndex(pParse, sqlite3SrcListAppend(0,&X,&Y));
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////// The COPY command ///////////////////////////////
|
||||
//
|
||||
cmd ::= COPY orconf(R) nm(X) dbnm(D) FROM nm(Y) USING DELIMITERS STRING(Z).
|
||||
{sqlite3Copy(pParse,sqlite3SrcListAppend(0,&X,&D),&Y,&Z,R);}
|
||||
cmd ::= COPY orconf(R) nm(X) dbnm(D) FROM nm(Y).
|
||||
{sqlite3Copy(pParse,sqlite3SrcListAppend(0,&X,&D),&Y,0,R);}
|
||||
|
||||
///////////////////////////// The VACUUM command /////////////////////////////
|
||||
//
|
||||
cmd ::= VACUUM. {sqlite3Vacuum(pParse,0);}
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
*************************************************************************
|
||||
** Internal interface definitions for SQLite.
|
||||
**
|
||||
** @(#) $Id: sqliteInt.h,v 1.255 2004/05/27 13:35:20 danielk1977 Exp $
|
||||
** @(#) $Id: sqliteInt.h,v 1.256 2004/05/27 17:22:56 drh Exp $
|
||||
*/
|
||||
#include "config.h"
|
||||
#include "sqlite.h"
|
||||
@ -1244,7 +1244,6 @@ Table *sqlite3FindTable(sqlite*,const char*, const char*);
|
||||
Table *sqlite3LocateTable(Parse*,const char*, const char*);
|
||||
Index *sqlite3FindIndex(sqlite*,const char*, const char*);
|
||||
void sqlite3UnlinkAndDeleteIndex(sqlite*,Index*);
|
||||
void sqlite3Copy(Parse*, SrcList*, Token*, Token*, int);
|
||||
void sqlite3Vacuum(Parse*, Token*);
|
||||
int sqlite3RunVacuum(char**, sqlite*);
|
||||
int sqlite3GlobCompare(const unsigned char*,const unsigned char*);
|
||||
|
||||
@ -15,7 +15,7 @@
|
||||
** individual tokens and sends those tokens one-by-one over to the
|
||||
** parser for analysis.
|
||||
**
|
||||
** $Id: tokenize.c,v 1.72 2004/05/27 13:35:20 danielk1977 Exp $
|
||||
** $Id: tokenize.c,v 1.73 2004/05/27 17:22:56 drh Exp $
|
||||
*/
|
||||
#include "sqliteInt.h"
|
||||
#include "os.h"
|
||||
@ -57,7 +57,6 @@ static Keyword aKeywordTable[] = {
|
||||
{ "COMMIT", TK_COMMIT, },
|
||||
{ "CONFLICT", TK_CONFLICT, },
|
||||
{ "CONSTRAINT", TK_CONSTRAINT, },
|
||||
{ "COPY", TK_COPY, },
|
||||
{ "CREATE", TK_CREATE, },
|
||||
{ "CROSS", TK_JOIN_KW, },
|
||||
{ "DATABASE", TK_DATABASE, },
|
||||
@ -65,7 +64,6 @@ static Keyword aKeywordTable[] = {
|
||||
{ "DEFERRED", TK_DEFERRED, },
|
||||
{ "DEFERRABLE", TK_DEFERRABLE, },
|
||||
{ "DELETE", TK_DELETE, },
|
||||
{ "DELIMITERS", TK_DELIMITERS, },
|
||||
{ "DESC", TK_DESC, },
|
||||
{ "DETACH", TK_DETACH, },
|
||||
{ "DISTINCT", TK_DISTINCT, },
|
||||
@ -696,6 +694,3 @@ int sqlite3_complete(const char *zSql){
|
||||
}
|
||||
return state==0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
176
src/vdbe.c
176
src/vdbe.c
@ -43,7 +43,7 @@
|
||||
** in this file for details. If in doubt, do not deviate from existing
|
||||
** commenting and indentation practices when changing or adding code.
|
||||
**
|
||||
** $Id: vdbe.c,v 1.339 2004/05/27 09:28:43 danielk1977 Exp $
|
||||
** $Id: vdbe.c,v 1.340 2004/05/27 17:22:56 drh Exp $
|
||||
*/
|
||||
#include "sqliteInt.h"
|
||||
#include "os.h"
|
||||
@ -4251,180 +4251,6 @@ case OP_SortReset: {
|
||||
break;
|
||||
}
|
||||
|
||||
/* Opcode: FileOpen * * P3
|
||||
**
|
||||
** Open the file named by P3 for reading using the FileRead opcode.
|
||||
** If P3 is "stdin" then open standard input for reading.
|
||||
*/
|
||||
case OP_FileOpen: {
|
||||
assert( pOp->p3!=0 );
|
||||
if( p->pFile ){
|
||||
if( p->pFile!=stdin ) fclose(p->pFile);
|
||||
p->pFile = 0;
|
||||
}
|
||||
if( sqlite3StrICmp(pOp->p3,"stdin")==0 ){
|
||||
p->pFile = stdin;
|
||||
}else{
|
||||
p->pFile = fopen(pOp->p3, "r");
|
||||
}
|
||||
if( p->pFile==0 ){
|
||||
sqlite3SetString(&p->zErrMsg,"unable to open file: ", pOp->p3, (char*)0);
|
||||
rc = SQLITE_ERROR;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
/* Opcode: FileRead P1 P2 P3
|
||||
**
|
||||
** Read a single line of input from the open file (the file opened using
|
||||
** FileOpen). If we reach end-of-file, jump immediately to P2. If
|
||||
** we are able to get another line, split the line apart using P3 as
|
||||
** a delimiter. There should be P1 fields. If the input line contains
|
||||
** more than P1 fields, ignore the excess. If the input line contains
|
||||
** fewer than P1 fields, assume the remaining fields contain NULLs.
|
||||
**
|
||||
** Input ends if a line consists of just "\.". A field containing only
|
||||
** "\N" is a null field. The backslash \ character can be used be used
|
||||
** to escape newlines or the delimiter.
|
||||
*/
|
||||
case OP_FileRead: {
|
||||
int n, eol, nField, i, c, nDelim;
|
||||
char *zDelim, *z;
|
||||
CHECK_FOR_INTERRUPT;
|
||||
if( p->pFile==0 ) goto fileread_jump;
|
||||
nField = pOp->p1;
|
||||
if( nField<=0 ) goto fileread_jump;
|
||||
if( nField!=p->nField || p->azField==0 ){
|
||||
char **azField = sqliteRealloc(p->azField, sizeof(char*)*nField+1);
|
||||
if( azField==0 ){ goto no_mem; }
|
||||
p->azField = azField;
|
||||
p->nField = nField;
|
||||
}
|
||||
n = 0;
|
||||
eol = 0;
|
||||
while( eol==0 ){
|
||||
if( p->zLine==0 || n+200>p->nLineAlloc ){
|
||||
char *zLine;
|
||||
p->nLineAlloc = p->nLineAlloc*2 + 300;
|
||||
zLine = sqliteRealloc(p->zLine, p->nLineAlloc);
|
||||
if( zLine==0 ){
|
||||
p->nLineAlloc = 0;
|
||||
sqliteFree(p->zLine);
|
||||
p->zLine = 0;
|
||||
goto no_mem;
|
||||
}
|
||||
p->zLine = zLine;
|
||||
}
|
||||
if( vdbe_fgets(&p->zLine[n], p->nLineAlloc-n, p->pFile)==0 ){
|
||||
eol = 1;
|
||||
p->zLine[n] = 0;
|
||||
}else{
|
||||
int c;
|
||||
while( (c = p->zLine[n])!=0 ){
|
||||
if( c=='\\' ){
|
||||
if( p->zLine[n+1]==0 ) break;
|
||||
n += 2;
|
||||
}else if( c=='\n' ){
|
||||
p->zLine[n] = 0;
|
||||
eol = 1;
|
||||
break;
|
||||
}else{
|
||||
n++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if( n==0 ) goto fileread_jump;
|
||||
z = p->zLine;
|
||||
if( z[0]=='\\' && z[1]=='.' && z[2]==0 ){
|
||||
goto fileread_jump;
|
||||
}
|
||||
zDelim = pOp->p3;
|
||||
if( zDelim==0 ) zDelim = "\t";
|
||||
c = zDelim[0];
|
||||
nDelim = strlen(zDelim);
|
||||
p->azField[0] = z;
|
||||
for(i=1; *z!=0 && i<=nField; i++){
|
||||
int from, to;
|
||||
from = to = 0;
|
||||
if( z[0]=='\\' && z[1]=='N'
|
||||
&& (z[2]==0 || strncmp(&z[2],zDelim,nDelim)==0) ){
|
||||
if( i<=nField ) p->azField[i-1] = 0;
|
||||
z += 2 + nDelim;
|
||||
if( i<nField ) p->azField[i] = z;
|
||||
continue;
|
||||
}
|
||||
while( z[from] ){
|
||||
if( z[from]=='\\' && z[from+1]!=0 ){
|
||||
int tx = z[from+1];
|
||||
switch( tx ){
|
||||
case 'b': tx = '\b'; break;
|
||||
case 'f': tx = '\f'; break;
|
||||
case 'n': tx = '\n'; break;
|
||||
case 'r': tx = '\r'; break;
|
||||
case 't': tx = '\t'; break;
|
||||
case 'v': tx = '\v'; break;
|
||||
default: break;
|
||||
}
|
||||
z[to++] = tx;
|
||||
from += 2;
|
||||
continue;
|
||||
}
|
||||
if( z[from]==c && strncmp(&z[from],zDelim,nDelim)==0 ) break;
|
||||
z[to++] = z[from++];
|
||||
}
|
||||
if( z[from] ){
|
||||
z[to] = 0;
|
||||
z += from + nDelim;
|
||||
if( i<nField ) p->azField[i] = z;
|
||||
}else{
|
||||
z[to] = 0;
|
||||
z = "";
|
||||
}
|
||||
}
|
||||
while( i<nField ){
|
||||
p->azField[i++] = 0;
|
||||
}
|
||||
break;
|
||||
|
||||
/* If we reach end-of-file, or if anything goes wrong, jump here.
|
||||
** This code will cause a jump to P2 */
|
||||
fileread_jump:
|
||||
pc = pOp->p2 - 1;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Opcode: FileColumn P1 * *
|
||||
**
|
||||
** Push onto the stack the P1-th column of the most recently read line
|
||||
** from the input file.
|
||||
*/
|
||||
case OP_FileColumn: {
|
||||
/*
|
||||
** FIX ME: This will be deleted, but loads of test case files have
|
||||
** to be updated first...
|
||||
*/
|
||||
int i = pOp->p1;
|
||||
char *z;
|
||||
assert( i>=0 && i<p->nField );
|
||||
if( p->azField ){
|
||||
z = p->azField[i];
|
||||
}else{
|
||||
z = 0;
|
||||
}
|
||||
pTos++;
|
||||
if( z ){
|
||||
pTos->n = strlen(z);
|
||||
pTos->z = z;
|
||||
pTos->flags = MEM_Str | MEM_Ephem | MEM_Term;
|
||||
pTos->enc = TEXT_Utf8;
|
||||
sqlite3VdbeChangeEncoding(pTos, db->enc);
|
||||
}else{
|
||||
pTos->flags = MEM_Null;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
/* Opcode: MemStore P1 P2 *
|
||||
**
|
||||
** Write the top of the stack into memory location P1.
|
||||
|
||||
@ -12,7 +12,7 @@
|
||||
# focus of this script is testing the ATTACH and DETACH commands
|
||||
# and related functionality.
|
||||
#
|
||||
# $Id: auth.test,v 1.12 2003/12/07 00:24:35 drh Exp $
|
||||
# $Id: auth.test,v 1.13 2004/05/27 17:22:56 drh Exp $
|
||||
#
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
@ -417,57 +417,6 @@ do_test auth-1.53 {
|
||||
catchsql {SELECT * FROM t2}
|
||||
} {0 {11 2 33}}
|
||||
|
||||
set f [open data1.txt w]
|
||||
puts $f "7:8:9"
|
||||
close $f
|
||||
do_test auth-1.54 {
|
||||
proc auth {code arg1 arg2 arg3 arg4} {
|
||||
if {$code=="SQLITE_COPY"} {
|
||||
set ::authargs [list $arg1 $arg2 $arg3 $arg4]
|
||||
return SQLITE_DENY
|
||||
}
|
||||
return SQLITE_OK
|
||||
}
|
||||
catchsql {COPY t2 FROM 'data1.txt' USING DELIMITERS ':'}
|
||||
} {1 {not authorized}}
|
||||
do_test auth-1.55 {
|
||||
set ::authargs
|
||||
} {t2 data1.txt main {}}
|
||||
do_test auth-1.56 {
|
||||
execsql {SELECT * FROM t2}
|
||||
} {11 2 33}
|
||||
do_test auth-1.57 {
|
||||
proc auth {code arg1 arg2 arg3 arg4} {
|
||||
if {$code=="SQLITE_COPY"} {
|
||||
set ::authargs [list $arg1 $arg2 $arg3 $arg4]
|
||||
return SQLITE_IGNORE
|
||||
}
|
||||
return SQLITE_OK
|
||||
}
|
||||
catchsql {COPY t2 FROM 'data1.txt' USING DELIMITERS ':'}
|
||||
} {0 {}}
|
||||
do_test auth-1.58 {
|
||||
set ::authargs
|
||||
} {t2 data1.txt main {}}
|
||||
do_test auth-1.59 {
|
||||
execsql {SELECT * FROM t2}
|
||||
} {11 2 33}
|
||||
do_test auth-1.60 {
|
||||
proc auth {code arg1 arg2 arg3 arg4} {
|
||||
if {$code=="SQLITE_COPY"} {
|
||||
set ::authargs [list $arg1 $arg2 $arg3 $arg4]
|
||||
return SQLITE_OK
|
||||
}
|
||||
return SQLITE_OK
|
||||
}
|
||||
catchsql {COPY t2 FROM 'data1.txt' USING DELIMITERS ':'}
|
||||
} {0 {}}
|
||||
do_test auth-1.61 {
|
||||
set ::authargs
|
||||
} {t2 data1.txt main {}}
|
||||
do_test auth-1.62 {
|
||||
execsql {SELECT * FROM t2}
|
||||
} {11 2 33 7 8 9}
|
||||
|
||||
do_test auth-1.63 {
|
||||
proc auth {code arg1 arg2 arg3 arg4} {
|
||||
|
||||
265
test/copy.test
265
test/copy.test
@ -1,265 +0,0 @@
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
# This file implements regression tests for SQLite library. The
|
||||
# focus of this file is testing the COPY statement.
|
||||
#
|
||||
# $Id: copy.test,v 1.17 2004/02/17 18:26:57 dougcurrie Exp $
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
|
||||
# Create a file of data from which to copy.
|
||||
#
|
||||
set f [open data1.txt w]
|
||||
puts $f "11\t22\t33"
|
||||
puts $f "22\t33\t11"
|
||||
close $f
|
||||
set f [open data2.txt w]
|
||||
puts $f "11\t22\t33"
|
||||
puts $f "\\."
|
||||
puts $f "22\t33\t11"
|
||||
close $f
|
||||
set f [open data3.txt w]
|
||||
puts $f "11\t22\t33\t44"
|
||||
puts $f "22\t33\t11"
|
||||
close $f
|
||||
set f [open data4.txt w]
|
||||
puts $f "11 | 22 | 33"
|
||||
puts $f "22 | 33 | 11"
|
||||
close $f
|
||||
set f [open data5.txt w]
|
||||
puts $f "11|22|33"
|
||||
puts $f "22|33|11"
|
||||
close $f
|
||||
set f [open dataX.txt w]
|
||||
fconfigure $f -translation binary
|
||||
puts -nonewline $f "11|22|33\r"
|
||||
puts -nonewline $f "22|33|44\r\n"
|
||||
puts -nonewline $f "33|44|55\n"
|
||||
puts -nonewline $f "44|55|66\r"
|
||||
puts -nonewline $f "55|66|77\r\n"
|
||||
puts -nonewline $f "66|77|88\n"
|
||||
close $f
|
||||
|
||||
# Try to COPY into a non-existant table.
|
||||
#
|
||||
do_test copy-1.1 {
|
||||
set v [catch {execsql {COPY test1 FROM 'data1.txt'}} msg]
|
||||
lappend v $msg
|
||||
} {1 {no such table: test1}}
|
||||
|
||||
# Try to insert into sqlite_master
|
||||
#
|
||||
do_test copy-1.2 {
|
||||
set v [catch {execsql {COPY sqlite_master FROM 'data2.txt'}} msg]
|
||||
lappend v $msg
|
||||
} {1 {table sqlite_master may not be modified}}
|
||||
|
||||
# Do some actual inserts
|
||||
#
|
||||
do_test copy-1.3 {
|
||||
execsql {CREATE TABLE test1(one int, two int, three int)}
|
||||
execsql {COPY test1 FROM 'data1.txt'}
|
||||
execsql {SELECT * FROM test1 ORDER BY one}
|
||||
} {11 22 33 22 33 11}
|
||||
|
||||
# Make sure input terminates at \.
|
||||
#
|
||||
do_test copy-1.4 {
|
||||
execsql {DELETE FROM test1}
|
||||
execsql {COPY test1 FROM 'data2.txt'}
|
||||
execsql {SELECT * FROM test1 ORDER BY one}
|
||||
} {11 22 33}
|
||||
|
||||
# Test out the USING DELIMITERS clause
|
||||
#
|
||||
do_test copy-1.5 {
|
||||
execsql {DELETE FROM test1}
|
||||
execsql {COPY test1 FROM 'data4.txt' USING DELIMITERS ' | '}
|
||||
execsql {SELECT * FROM test1 ORDER BY one}
|
||||
} {11 22 33 22 33 11}
|
||||
do_test copy-1.6 {
|
||||
execsql {DELETE FROM test1}
|
||||
execsql {COPY test1 FROM 'data5.txt' USING DELIMITERS '|'}
|
||||
execsql {SELECT * FROM test1 ORDER BY one}
|
||||
} {11 22 33 22 33 11}
|
||||
do_test copy-1.7 {
|
||||
execsql {DELETE FROM test1}
|
||||
execsql {COPY test1 FROM 'data4.txt' USING DELIMITERS '|'}
|
||||
execsql {SELECT * FROM test1 ORDER BY one}
|
||||
} {{11 } { 22 } { 33} {22 } { 33 } { 11}}
|
||||
|
||||
# Try copying into a table that has one or more indices.
|
||||
#
|
||||
do_test copy-1.8 {
|
||||
execsql {DELETE FROM test1}
|
||||
execsql {CREATE INDEX index1 ON test1(one)}
|
||||
execsql {CREATE INDEX index2 ON test1(two)}
|
||||
execsql {CREATE INDEX index3 ON test1(three)}
|
||||
execsql {COPY test1 from 'data1.txt'}
|
||||
execsql {SELECT * FROM test1 WHERE one=11}
|
||||
} {11 22 33}
|
||||
do_test copy-1.8b {
|
||||
execsql {SELECT * FROM test1 WHERE one=22}
|
||||
} {22 33 11}
|
||||
do_test copy-1.8c {
|
||||
execsql {SELECT * FROM test1 WHERE two=22}
|
||||
} {11 22 33}
|
||||
do_test copy-1.8d {
|
||||
execsql {SELECT * FROM test1 WHERE three=11}
|
||||
} {22 33 11}
|
||||
|
||||
|
||||
# Try inserting really long data
|
||||
#
|
||||
set x {}
|
||||
for {set i 0} {$i<100} {incr i} {
|
||||
append x "($i)-abcdefghijklmnopqrstyvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ-"
|
||||
}
|
||||
do_test copy-2.1 {
|
||||
execsql {CREATE TABLE test2(a int, x text)}
|
||||
set f [open data21.txt w]
|
||||
puts $f "123\t$x"
|
||||
close $f
|
||||
execsql {COPY test2 FROM 'data21.txt'}
|
||||
execsql {SELECT x from test2}
|
||||
} $x
|
||||
file delete -force data21.txt
|
||||
|
||||
# Test the escape character mechanism
|
||||
#
|
||||
do_test copy-3.1 {
|
||||
set fd [open data6.txt w]
|
||||
puts $fd "hello\\\tworld\t1"
|
||||
puts $fd "hello\tworld\\\t2"
|
||||
close $fd
|
||||
execsql {
|
||||
CREATE TABLE t1(a text, b text);
|
||||
COPY t1 FROM 'data6.txt';
|
||||
SELECT * FROM t1 ORDER BY a;
|
||||
}
|
||||
} {hello {world 2} {hello world} 1}
|
||||
do_test copy-3.2 {
|
||||
set fd [open data6.txt w]
|
||||
puts $fd "1\thello\\\nworld"
|
||||
puts $fd "2\thello world"
|
||||
close $fd
|
||||
execsql {
|
||||
DELETE FROM t1;
|
||||
COPY t1 FROM 'data6.txt';
|
||||
SELECT * FROM t1 ORDER BY a;
|
||||
}
|
||||
} {1 {hello
|
||||
world} 2 {hello world}}
|
||||
do_test copy-3.3 {
|
||||
set fd [open data6.txt w]
|
||||
puts $fd "1:hello\\b\\f\\n\\r\\t\\vworld"
|
||||
puts $fd "2:hello world"
|
||||
close $fd
|
||||
execsql {
|
||||
DELETE FROM t1;
|
||||
COPY t1 FROM 'data6.txt' USING DELIMITERS ':';
|
||||
SELECT * FROM t1 ORDER BY a;
|
||||
}
|
||||
} [list 1 "hello\b\f\n\r\t\vworld" 2 "hello world"]
|
||||
|
||||
# Test the embedded NULL logic.
|
||||
#
|
||||
do_test copy-4.1 {
|
||||
set fd [open data6.txt w]
|
||||
puts $fd "1\t\\N"
|
||||
puts $fd "\\N\thello world"
|
||||
close $fd
|
||||
execsql {
|
||||
DELETE FROM t1;
|
||||
COPY t1 FROM 'data6.txt';
|
||||
SELECT * FROM t1 WHERE a IS NULL;
|
||||
}
|
||||
} {{} {hello world}}
|
||||
do_test copy-4.2 {
|
||||
execsql {
|
||||
SELECT * FROM t1 WHERE b IS NULL;
|
||||
}
|
||||
} {1 {}}
|
||||
|
||||
# Test the conflict resolution logic for COPY
|
||||
#
|
||||
do_test copy-5.1 {
|
||||
execsql {
|
||||
DROP TABLE t1;
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b UNIQUE, c);
|
||||
COPY t1 FROM 'data5.txt' USING DELIMITERS '|';
|
||||
SELECT * FROM t1;
|
||||
}
|
||||
} {11 22 33 22 33 11}
|
||||
do_test copy-5.2 {
|
||||
set fd [open data6.txt w]
|
||||
puts $fd "33|22|44"
|
||||
close $fd
|
||||
catchsql {
|
||||
COPY t1 FROM 'data6.txt' USING DELIMITERS '|';
|
||||
SELECT * FROM t1;
|
||||
}
|
||||
} {1 {column b is not unique}}
|
||||
do_test copy-5.3 {
|
||||
set fd [open data6.txt w]
|
||||
puts $fd "33|22|44"
|
||||
close $fd
|
||||
catchsql {
|
||||
COPY OR IGNORE t1 FROM 'data6.txt' USING DELIMITERS '|';
|
||||
SELECT * FROM t1;
|
||||
}
|
||||
} {0 {11 22 33 22 33 11}}
|
||||
do_test copy-5.4 {
|
||||
set fd [open data6.txt w]
|
||||
puts $fd "33|22|44"
|
||||
close $fd
|
||||
catchsql {
|
||||
COPY OR REPLACE t1 FROM 'data6.txt' USING DELIMITERS '|';
|
||||
SELECT * FROM t1;
|
||||
}
|
||||
} {0 {22 33 11 33 22 44}}
|
||||
|
||||
do_test copy-5.5 {
|
||||
execsql {
|
||||
DELETE FROM t1;
|
||||
PRAGMA count_changes=on;
|
||||
COPY t1 FROM 'data5.txt' USING DELIMITERS '|';
|
||||
}
|
||||
} {2}
|
||||
do_test copy-5.6 {
|
||||
execsql {
|
||||
COPY OR REPLACE t1 FROM 'data5.txt' USING DELIMITERS '|';
|
||||
}
|
||||
} {2}
|
||||
do_test copy-5.7 {
|
||||
execsql {
|
||||
COPY OR IGNORE t1 FROM 'data5.txt' USING DELIMITERS '|';
|
||||
}
|
||||
} {0}
|
||||
|
||||
do_test copy-6.1 {
|
||||
execsql {
|
||||
PRAGMA count_changes=off;
|
||||
CREATE TABLE t2(a,b,c);
|
||||
COPY t2 FROM 'dataX.txt' USING DELIMITERS '|';
|
||||
SELECT * FROM t2;
|
||||
}
|
||||
} {11 22 33 22 33 44 33 44 55 44 55 66 55 66 77 66 77 88}
|
||||
|
||||
integrity_check copy-7.1
|
||||
|
||||
# Cleanup
|
||||
#
|
||||
#file delete -force data1.txt data2.txt data3.txt data4.txt data5.txt \
|
||||
data6.txt dataX.txt
|
||||
|
||||
finish_test
|
||||
@ -11,7 +11,7 @@
|
||||
# This file implements regression tests for SQLite library. The
|
||||
# focus of this file is testing the DELETE FROM statement.
|
||||
#
|
||||
# $Id: delete.test,v 1.13 2003/06/15 23:42:25 drh Exp $
|
||||
# $Id: delete.test,v 1.14 2004/05/27 17:22:56 drh Exp $
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
@ -152,16 +152,15 @@ integrity_check delete-5.8
|
||||
# mechanism in the vdbe.
|
||||
#
|
||||
do_test delete-6.1 {
|
||||
set fd [open data1.txt w]
|
||||
execsql {BEGIN; DELETE FROM table1}
|
||||
for {set i 1} {$i<=3000} {incr i} {
|
||||
puts $fd "[expr {$i}]\t[expr {$i*$i}]"
|
||||
execsql "INSERT INTO table1 VALUES($i,[expr {$i*$i}])"
|
||||
}
|
||||
close $fd
|
||||
execsql {DELETE FROM table1}
|
||||
execsql {COPY table1 FROM 'data1.txt'}
|
||||
execsql {DELETE FROM table2}
|
||||
execsql {COPY table2 FROM 'data1.txt'}
|
||||
file delete data1.txt
|
||||
for {set i 1} {$i<=3000} {incr i} {
|
||||
execsql "INSERT INTO table2 VALUES($i,[expr {$i*$i}])"
|
||||
}
|
||||
execsql {COMMIT}
|
||||
execsql {SELECT count(*) FROM table1}
|
||||
} {3000}
|
||||
do_test delete-6.2 {
|
||||
|
||||
@ -13,7 +13,7 @@
|
||||
# various suported unicode encodings (UTF-8, UTF-16, UTF-16le and
|
||||
# UTF-16be).
|
||||
#
|
||||
# $Id: enc2.test,v 1.3 2004/05/27 01:53:56 drh Exp $
|
||||
# $Id: enc2.test,v 1.4 2004/05/27 17:22:56 drh Exp $
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
@ -59,14 +59,13 @@ do_test $t.2 {
|
||||
execsql {SELECT * FROM t1}
|
||||
} {one I 1 two II 2}
|
||||
|
||||
# Insert some data using the COPY command.
|
||||
# Insert some data
|
||||
do_test $t.3 {
|
||||
set f [open data.txt w]
|
||||
puts $f "three\tIII\t3"
|
||||
puts $f "four\tIV\t4"
|
||||
puts $f "five\tV\t5"
|
||||
close $f
|
||||
execsql {COPY t1 FROM 'data.txt'}
|
||||
execsql {
|
||||
INSERT INTO t1 VALUES('three','III',3);
|
||||
INSERT INTO t1 VALUES('four','IV',4);
|
||||
INSERT INTO t1 VALUES('five','V',5);
|
||||
}
|
||||
execsql {SELECT * FROM t1}
|
||||
} {one I 1 two II 2 three III 3 four IV 4 five V 5}
|
||||
|
||||
|
||||
@ -1,738 +0,0 @@
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
# This file implements regression tests for SQLite library. The
|
||||
# focus of this file is testing the the library is able to correctly
|
||||
# handle file-format 3 (version 2.6.x) databases.
|
||||
#
|
||||
# $Id: format3.test,v 1.4 2003/12/23 02:17:35 drh Exp $
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
|
||||
# Create a bunch of data to sort against
|
||||
#
|
||||
do_test format3-1.0 {
|
||||
set fd [open data.txt w]
|
||||
puts $fd "1\tone\t0\tI\t3.141592653"
|
||||
puts $fd "2\ttwo\t1\tII\t2.15"
|
||||
puts $fd "3\tthree\t1\tIII\t4221.0"
|
||||
puts $fd "4\tfour\t2\tIV\t-0.0013442"
|
||||
puts $fd "5\tfive\t2\tV\t-11"
|
||||
puts $fd "6\tsix\t2\tVI\t0.123"
|
||||
puts $fd "7\tseven\t2\tVII\t123.0"
|
||||
puts $fd "8\teight\t3\tVIII\t-1.6"
|
||||
close $fd
|
||||
execsql {
|
||||
CREATE TABLE t1(
|
||||
n int,
|
||||
v varchar(10),
|
||||
log int,
|
||||
roman varchar(10),
|
||||
flt real
|
||||
);
|
||||
COPY t1 FROM 'data.txt'
|
||||
}
|
||||
file delete data.txt
|
||||
db close
|
||||
set ::bt [btree_open test.db]
|
||||
btree_begin_transaction $::bt
|
||||
set m [btree_get_meta $::bt]
|
||||
set m [lreplace $m 2 2 3]
|
||||
eval btree_update_meta $::bt $m
|
||||
btree_commit $::bt
|
||||
btree_close $::bt
|
||||
sqlite db test.db
|
||||
execsql {SELECT count(*) FROM t1}
|
||||
} {8}
|
||||
|
||||
do_test format3-1.1 {
|
||||
execsql {SELECT n FROM t1 ORDER BY n}
|
||||
} {1 2 3 4 5 6 7 8}
|
||||
do_test format3-1.1.1 {
|
||||
execsql {SELECT n FROM t1 ORDER BY n ASC}
|
||||
} {1 2 3 4 5 6 7 8}
|
||||
do_test format3-1.1.1 {
|
||||
execsql {SELECT ALL n FROM t1 ORDER BY n ASC}
|
||||
} {1 2 3 4 5 6 7 8}
|
||||
do_test format3-1.2 {
|
||||
execsql {SELECT n FROM t1 ORDER BY n DESC}
|
||||
} {8 7 6 5 4 3 2 1}
|
||||
do_test format3-1.3a {
|
||||
execsql {SELECT v FROM t1 ORDER BY v}
|
||||
} {eight five four one seven six three two}
|
||||
do_test format3-1.3b {
|
||||
execsql {SELECT n FROM t1 ORDER BY v}
|
||||
} {8 5 4 1 7 6 3 2}
|
||||
do_test format3-1.4 {
|
||||
execsql {SELECT n FROM t1 ORDER BY v DESC}
|
||||
} {2 3 6 7 1 4 5 8}
|
||||
do_test format3-1.5 {
|
||||
execsql {SELECT flt FROM t1 ORDER BY flt}
|
||||
} {-11 -1.6 -0.0013442 0.123 2.15 3.141592653 123.0 4221.0}
|
||||
do_test format3-1.6 {
|
||||
execsql {SELECT flt FROM t1 ORDER BY flt DESC}
|
||||
} {4221.0 123.0 3.141592653 2.15 0.123 -0.0013442 -1.6 -11}
|
||||
do_test format3-1.7 {
|
||||
execsql {SELECT roman FROM t1 ORDER BY roman}
|
||||
} {I II III IV V VI VII VIII}
|
||||
do_test format3-1.8 {
|
||||
execsql {SELECT n FROM t1 ORDER BY log, flt}
|
||||
} {1 2 3 5 4 6 7 8}
|
||||
do_test format3-1.8.1 {
|
||||
execsql {SELECT n FROM t1 ORDER BY log asc, flt}
|
||||
} {1 2 3 5 4 6 7 8}
|
||||
do_test format3-1.8.2 {
|
||||
execsql {SELECT n FROM t1 ORDER BY log, flt ASC}
|
||||
} {1 2 3 5 4 6 7 8}
|
||||
do_test format3-1.8.3 {
|
||||
execsql {SELECT n FROM t1 ORDER BY log ASC, flt asc}
|
||||
} {1 2 3 5 4 6 7 8}
|
||||
do_test format3-1.9 {
|
||||
execsql {SELECT n FROM t1 ORDER BY log, flt DESC}
|
||||
} {1 3 2 7 6 4 5 8}
|
||||
do_test format3-1.9.1 {
|
||||
execsql {SELECT n FROM t1 ORDER BY log ASC, flt DESC}
|
||||
} {1 3 2 7 6 4 5 8}
|
||||
do_test format3-1.10 {
|
||||
execsql {SELECT n FROM t1 ORDER BY log DESC, flt}
|
||||
} {8 5 4 6 7 2 3 1}
|
||||
do_test format3-1.11 {
|
||||
execsql {SELECT n FROM t1 ORDER BY log DESC, flt DESC}
|
||||
} {8 7 6 4 5 3 2 1}
|
||||
|
||||
# These tests are designed to reach some hard-to-reach places
|
||||
# inside the string comparison routines.
|
||||
#
|
||||
# (Later) The sorting behavior changed in 2.7.0. But we will
|
||||
# keep these tests. You can never have too many test cases!
|
||||
#
|
||||
do_test format3-2.1.1 {
|
||||
execsql {
|
||||
UPDATE t1 SET v='x' || -flt;
|
||||
UPDATE t1 SET v='x-2b' where v=='x-0.123';
|
||||
SELECT v FROM t1 ORDER BY v;
|
||||
}
|
||||
} {x-123 x-2.15 x-2b x-3.141592653 x-4221 x0.0013442 x1.6 x11}
|
||||
do_test format3-2.1.2 {
|
||||
execsql {
|
||||
SELECT v FROM t1 ORDER BY substr(v,2,999);
|
||||
}
|
||||
} {x-4221 x-123 x-3.141592653 x-2.15 x0.0013442 x1.6 x11 x-2b}
|
||||
do_test format3-2.1.3 {
|
||||
execsql {
|
||||
SELECT v FROM t1 ORDER BY substr(v,2,999)+0.0;
|
||||
}
|
||||
} {x-4221 x-123 x-3.141592653 x-2.15 x-2b x0.0013442 x1.6 x11}
|
||||
do_test format3-2.1.4 {
|
||||
execsql {
|
||||
SELECT v FROM t1 ORDER BY substr(v,2,999) DESC;
|
||||
}
|
||||
} {x-2b x11 x1.6 x0.0013442 x-2.15 x-3.141592653 x-123 x-4221}
|
||||
do_test format3-2.1.5 {
|
||||
execsql {
|
||||
SELECT v FROM t1 ORDER BY substr(v,2,999)+0.0 DESC;
|
||||
}
|
||||
} {x11 x1.6 x0.0013442 x-2b x-2.15 x-3.141592653 x-123 x-4221}
|
||||
|
||||
# This is a bug fix for 2.2.4.
|
||||
# Strings are normally mapped to upper-case for a caseless comparison.
|
||||
# But this can cause problems for characters in between 'Z' and 'a'.
|
||||
#
|
||||
do_test format3-3.1 {
|
||||
execsql {
|
||||
CREATE TABLE t2(a,b);
|
||||
INSERT INTO t2 VALUES('AGLIENTU',1);
|
||||
INSERT INTO t2 VALUES('AGLIE`',2);
|
||||
INSERT INTO t2 VALUES('AGNA',3);
|
||||
SELECT a, b FROM t2 ORDER BY a;
|
||||
}
|
||||
} {AGLIENTU 1 AGLIE` 2 AGNA 3}
|
||||
do_test format3-3.2 {
|
||||
execsql {
|
||||
SELECT a, b FROM t2 ORDER BY a DESC;
|
||||
}
|
||||
} {AGNA 3 AGLIE` 2 AGLIENTU 1}
|
||||
do_test format3-3.3 {
|
||||
execsql {
|
||||
DELETE FROM t2;
|
||||
INSERT INTO t2 VALUES('aglientu',1);
|
||||
INSERT INTO t2 VALUES('aglie`',2);
|
||||
INSERT INTO t2 VALUES('agna',3);
|
||||
SELECT a, b FROM t2 ORDER BY a;
|
||||
}
|
||||
} {aglie` 2 aglientu 1 agna 3}
|
||||
do_test format3-3.4 {
|
||||
execsql {
|
||||
SELECT a, b FROM t2 ORDER BY a DESC;
|
||||
}
|
||||
} {agna 3 aglientu 1 aglie` 2}
|
||||
|
||||
# Version 2.7.0 testing.
|
||||
#
|
||||
do_test format3-4.1 {
|
||||
execsql {
|
||||
INSERT INTO t1 VALUES(9,'x2.7',3,'IX',4.0e5);
|
||||
INSERT INTO t1 VALUES(10,'x5.0e10',3,'X',-4.0e5);
|
||||
INSERT INTO t1 VALUES(11,'x-4.0e9',3,'XI',4.1e4);
|
||||
INSERT INTO t1 VALUES(12,'x01234567890123456789',3,'XII',-4.2e3);
|
||||
SELECT n FROM t1 ORDER BY n;
|
||||
}
|
||||
} {1 2 3 4 5 6 7 8 9 10 11 12}
|
||||
do_test format3-4.2 {
|
||||
execsql {
|
||||
SELECT n||'' FROM t1 ORDER BY 1;
|
||||
}
|
||||
} {1 2 3 4 5 6 7 8 9 10 11 12}
|
||||
do_test format3-4.3 {
|
||||
execsql {
|
||||
SELECT n+0 FROM t1 ORDER BY 1;
|
||||
}
|
||||
} {1 2 3 4 5 6 7 8 9 10 11 12}
|
||||
do_test format3-4.4 {
|
||||
execsql {
|
||||
SELECT n||'' FROM t1 ORDER BY 1 DESC;
|
||||
}
|
||||
} {12 11 10 9 8 7 6 5 4 3 2 1}
|
||||
do_test format3-4.5 {
|
||||
execsql {
|
||||
SELECT n+0 FROM t1 ORDER BY 1 DESC;
|
||||
}
|
||||
} {12 11 10 9 8 7 6 5 4 3 2 1}
|
||||
do_test format3-4.6 {
|
||||
execsql {
|
||||
SELECT v FROM t1 ORDER BY 1;
|
||||
}
|
||||
} {x-123 x-2.15 x-2b x-3.141592653 x-4.0e9 x-4221 x0.0013442 x01234567890123456789 x1.6 x11 x2.7 x5.0e10}
|
||||
do_test format3-4.7 {
|
||||
execsql {
|
||||
SELECT v FROM t1 ORDER BY 1 DESC;
|
||||
}
|
||||
} {x5.0e10 x2.7 x11 x1.6 x01234567890123456789 x0.0013442 x-4221 x-4.0e9 x-3.141592653 x-2b x-2.15 x-123}
|
||||
do_test format3-4.8 {
|
||||
execsql {
|
||||
SELECT substr(v,2,99) FROM t1 ORDER BY 1;
|
||||
}
|
||||
} {-4.0e9 -4221 -123 -3.141592653 -2.15 0.0013442 1.6 2.7 11 5.0e10 01234567890123456789 -2b}
|
||||
|
||||
# Build some new test data, this time with indices.
|
||||
#
|
||||
do_test format3-5.0 {
|
||||
execsql {
|
||||
DROP TABLE t1;
|
||||
CREATE TABLE t1(w int, x text, y blob);
|
||||
DROP TABLE t2;
|
||||
CREATE TABLE t2(p varchar(1), q clob, r real, s numeric(8));
|
||||
}
|
||||
for {set i 1} {$i<=100} {incr i} {
|
||||
set w $i
|
||||
set x [expr {int(log($i)/log(2))}]
|
||||
set y [expr {$i*$i + 2*$i + 1}]
|
||||
execsql "INSERT INTO t1 VALUES($w,$x,$y)"
|
||||
}
|
||||
execsql {
|
||||
INSERT INTO t2 SELECT 101-w, x, (SELECT max(y) FROM t1)+1-y, y FROM t1;
|
||||
CREATE INDEX i1w ON t1(w);
|
||||
CREATE INDEX i1xy ON t1(x,y);
|
||||
CREATE INDEX i2p ON t2(p);
|
||||
CREATE INDEX i2r ON t2(r);
|
||||
CREATE INDEX i2qs ON t2(q, s);
|
||||
}
|
||||
} {}
|
||||
|
||||
# Do an SQL statement. Append the search count to the end of the result.
|
||||
#
|
||||
proc count sql {
|
||||
set ::sqlite_search_count 0
|
||||
return [concat [execsql $sql] $::sqlite_search_count]
|
||||
}
|
||||
|
||||
# Verify that queries use an index. We are using the special variable
|
||||
# "sqlite_search_count" which tallys the number of executions of MoveTo
|
||||
# and Next operators in the VDBE. By verifing that the search count is
|
||||
# small we can be assured that indices are being used properly.
|
||||
#
|
||||
do_test format3-5.1 {
|
||||
db close
|
||||
sqlite db test.db
|
||||
count {SELECT x, y FROM t1 WHERE w=10}
|
||||
} {3 121 3}
|
||||
do_test format3-5.2 {
|
||||
count {SELECT x, y FROM t1 WHERE w=11}
|
||||
} {3 144 3}
|
||||
do_test format3-5.3 {
|
||||
count {SELECT x, y FROM t1 WHERE 11=w}
|
||||
} {3 144 3}
|
||||
do_test format3-5.4 {
|
||||
count {SELECT x, y FROM t1 WHERE 11=w AND x>2}
|
||||
} {3 144 3}
|
||||
do_test format3-5.5 {
|
||||
count {SELECT x, y FROM t1 WHERE y<200 AND w=11 AND x>2}
|
||||
} {3 144 3}
|
||||
do_test format3-5.6 {
|
||||
count {SELECT x, y FROM t1 WHERE y<200 AND x>2 AND w=11}
|
||||
} {3 144 3}
|
||||
do_test format3-5.7 {
|
||||
count {SELECT x, y FROM t1 WHERE w=11 AND y<200 AND x>2}
|
||||
} {3 144 3}
|
||||
do_test format3-5.8 {
|
||||
count {SELECT x, y FROM t1 WHERE w>10 AND y=144 AND x=3}
|
||||
} {3 144 3}
|
||||
do_test format3-5.9 {
|
||||
count {SELECT x, y FROM t1 WHERE y=144 AND w>10 AND x=3}
|
||||
} {3 144 3}
|
||||
do_test format3-5.10 {
|
||||
count {SELECT x, y FROM t1 WHERE x=3 AND w>=10 AND y=121}
|
||||
} {3 121 3}
|
||||
do_test format3-5.11 {
|
||||
count {SELECT x, y FROM t1 WHERE x=3 AND y=100 AND w<10}
|
||||
} {3 100 3}
|
||||
|
||||
# New for SQLite version 2.1: Verify that that inequality constraints
|
||||
# are used correctly.
|
||||
#
|
||||
do_test format3-5.12 {
|
||||
count {SELECT w FROM t1 WHERE x=3 AND y<100}
|
||||
} {8 3}
|
||||
do_test format3-5.13 {
|
||||
count {SELECT w FROM t1 WHERE x=3 AND 100>y}
|
||||
} {8 3}
|
||||
do_test format3-5.14 {
|
||||
count {SELECT w FROM t1 WHERE 3=x AND y<100}
|
||||
} {8 3}
|
||||
do_test format3-5.15 {
|
||||
count {SELECT w FROM t1 WHERE 3=x AND 100>y}
|
||||
} {8 3}
|
||||
do_test format3-5.16 {
|
||||
count {SELECT w FROM t1 WHERE x=3 AND y<=100}
|
||||
} {8 9 5}
|
||||
do_test format3-5.17 {
|
||||
count {SELECT w FROM t1 WHERE x=3 AND 100>=y}
|
||||
} {8 9 5}
|
||||
do_test format3-5.18 {
|
||||
count {SELECT w FROM t1 WHERE x=3 AND y>225}
|
||||
} {15 3}
|
||||
do_test format3-5.19 {
|
||||
count {SELECT w FROM t1 WHERE x=3 AND 225<y}
|
||||
} {15 3}
|
||||
do_test format3-5.20 {
|
||||
count {SELECT w FROM t1 WHERE x=3 AND y>=225}
|
||||
} {14 15 5}
|
||||
do_test format3-5.21 {
|
||||
count {SELECT w FROM t1 WHERE x=3 AND 225<=y}
|
||||
} {14 15 5}
|
||||
do_test format3-5.22 {
|
||||
count {SELECT w FROM t1 WHERE x=3 AND y>121 AND y<196}
|
||||
} {11 12 5}
|
||||
do_test format3-5.23 {
|
||||
count {SELECT w FROM t1 WHERE x=3 AND y>=121 AND y<=196}
|
||||
} {10 11 12 13 9}
|
||||
do_test format3-5.24 {
|
||||
count {SELECT w FROM t1 WHERE x=3 AND 121<y AND 196>y}
|
||||
} {11 12 5}
|
||||
do_test format3-5.25 {
|
||||
count {SELECT w FROM t1 WHERE x=3 AND 121<=y AND 196>=y}
|
||||
} {10 11 12 13 9}
|
||||
|
||||
# Need to work on optimizing the BETWEEN operator.
|
||||
#
|
||||
# do_test format3-5.26 {
|
||||
# count {SELECT w FROM t1 WHERE x=3 AND y BETWEEN 121 AND 196}
|
||||
# } {10 11 12 13 9}
|
||||
|
||||
do_test format3-5.27 {
|
||||
count {SELECT w FROM t1 WHERE x=3 AND y+1==122}
|
||||
} {10 17}
|
||||
do_test format3-5.28 {
|
||||
count {SELECT w FROM t1 WHERE x+1=4 AND y+1==122}
|
||||
} {10 99}
|
||||
do_test format3-5.29 {
|
||||
count {SELECT w FROM t1 WHERE y==121}
|
||||
} {10 99}
|
||||
|
||||
|
||||
do_test format3-5.30 {
|
||||
count {SELECT w FROM t1 WHERE w>97}
|
||||
} {98 99 100 6}
|
||||
do_test format3-5.31 {
|
||||
count {SELECT w FROM t1 WHERE w>=97}
|
||||
} {97 98 99 100 8}
|
||||
do_test format3-5.33 {
|
||||
count {SELECT w FROM t1 WHERE w==97}
|
||||
} {97 3}
|
||||
do_test format3-5.34 {
|
||||
count {SELECT w FROM t1 WHERE w+1==98}
|
||||
} {97 99}
|
||||
do_test format3-5.35 {
|
||||
count {SELECT w FROM t1 WHERE w<3}
|
||||
} {1 2 4}
|
||||
do_test format3-5.36 {
|
||||
count {SELECT w FROM t1 WHERE w<=3}
|
||||
} {1 2 3 6}
|
||||
do_test format3-5.37 {
|
||||
count {SELECT w FROM t1 WHERE w+1<=4 ORDER BY w}
|
||||
} {1 2 3 199}
|
||||
|
||||
|
||||
# Do the same kind of thing except use a join as the data source.
|
||||
#
|
||||
do_test format3-6.1 {
|
||||
db close
|
||||
sqlite db test.db
|
||||
count {
|
||||
SELECT w, p FROM t2, t1
|
||||
WHERE x=q AND y=s AND r=8977
|
||||
}
|
||||
} {34 67 6}
|
||||
do_test format3-6.2 {
|
||||
count {
|
||||
SELECT w, p FROM t2, t1
|
||||
WHERE x=q AND s=y AND r=8977
|
||||
}
|
||||
} {34 67 6}
|
||||
do_test format3-6.3 {
|
||||
count {
|
||||
SELECT w, p FROM t2, t1
|
||||
WHERE x=q AND s=y AND r=8977 AND w>10
|
||||
}
|
||||
} {34 67 6}
|
||||
do_test format3-6.4 {
|
||||
count {
|
||||
SELECT w, p FROM t2, t1
|
||||
WHERE p<80 AND x=q AND s=y AND r=8977 AND w>10
|
||||
}
|
||||
} {34 67 6}
|
||||
do_test format3-6.5 {
|
||||
count {
|
||||
SELECT w, p FROM t2, t1
|
||||
WHERE p<80 AND x=q AND 8977=r AND s=y AND w>10
|
||||
}
|
||||
} {34 67 6}
|
||||
do_test format3-6.6 {
|
||||
count {
|
||||
SELECT w, p FROM t2, t1
|
||||
WHERE x=q AND p=77 AND s=y AND w>5
|
||||
}
|
||||
} {24 77 6}
|
||||
do_test format3-6.7 {
|
||||
count {
|
||||
SELECT w, p FROM t1, t2
|
||||
WHERE x=q AND p>77 AND s=y AND w=5
|
||||
}
|
||||
} {5 96 6}
|
||||
|
||||
# Lets do a 3-way join.
|
||||
#
|
||||
do_test format3-7.1 {
|
||||
count {
|
||||
SELECT A.w, B.p, C.w FROM t1 as A, t2 as B, t1 as C
|
||||
WHERE C.w=101-B.p AND B.r=10202-A.y AND A.w=11
|
||||
}
|
||||
} {11 90 11 9}
|
||||
do_test format3-7.2 {
|
||||
count {
|
||||
SELECT A.w, B.p, C.w FROM t1 as A, t2 as B, t1 as C
|
||||
WHERE C.w=101-B.p AND B.r=10202-A.y AND A.w=12
|
||||
}
|
||||
} {12 89 12 9}
|
||||
do_test format3-7.3 {
|
||||
count {
|
||||
SELECT A.w, B.p, C.w FROM t1 as A, t2 as B, t1 as C
|
||||
WHERE A.w=15 AND B.p=C.w AND B.r=10202-A.y
|
||||
}
|
||||
} {15 86 86 9}
|
||||
|
||||
# Test to see that the special case of a constant WHERE clause is
|
||||
# handled.
|
||||
#
|
||||
do_test format3-8.1 {
|
||||
count {
|
||||
SELECT * FROM t1 WHERE 0
|
||||
}
|
||||
} {0}
|
||||
do_test format3-8.2 {
|
||||
count {
|
||||
SELECT * FROM t1 WHERE 1 LIMIT 1
|
||||
}
|
||||
} {1 0 4 1}
|
||||
do_test format3-8.3 {
|
||||
execsql {
|
||||
SELECT 99 WHERE 0
|
||||
}
|
||||
} {}
|
||||
do_test format3-8.4 {
|
||||
execsql {
|
||||
SELECT 99 WHERE 1
|
||||
}
|
||||
} {99}
|
||||
|
||||
# Verify that IN operators in a WHERE clause are handled correctly.
|
||||
#
|
||||
do_test format3-9.1 {
|
||||
count {
|
||||
SELECT * FROM t1 WHERE rowid IN (1,2,3,1234) order by 1;
|
||||
}
|
||||
} {1 0 4 2 1 9 3 1 16 0}
|
||||
do_test format3-9.2 {
|
||||
count {
|
||||
SELECT * FROM t1 WHERE rowid+0 IN (1,2,3,1234) order by 1;
|
||||
}
|
||||
} {1 0 4 2 1 9 3 1 16 199}
|
||||
do_test format3-9.3 {
|
||||
count {
|
||||
SELECT * FROM t1 WHERE w IN (-1,1,2,3) order by 1;
|
||||
}
|
||||
} {1 0 4 2 1 9 3 1 16 10}
|
||||
do_test format3-9.4 {
|
||||
count {
|
||||
SELECT * FROM t1 WHERE w+0 IN (-1,1,2,3) order by 1;
|
||||
}
|
||||
} {1 0 4 2 1 9 3 1 16 199}
|
||||
do_test format3-9.5 {
|
||||
count {
|
||||
SELECT * FROM t1 WHERE rowid IN
|
||||
(select rowid from t1 where rowid IN (-1,2,4))
|
||||
ORDER BY 1;
|
||||
}
|
||||
} {2 1 9 4 2 25 1}
|
||||
do_test format3-9.6 {
|
||||
count {
|
||||
SELECT * FROM t1 WHERE rowid+0 IN
|
||||
(select rowid from t1 where rowid IN (-1,2,4))
|
||||
ORDER BY 1;
|
||||
}
|
||||
} {2 1 9 4 2 25 199}
|
||||
do_test format3-9.7 {
|
||||
count {
|
||||
SELECT * FROM t1 WHERE w IN
|
||||
(select rowid from t1 where rowid IN (-1,2,4))
|
||||
ORDER BY 1;
|
||||
}
|
||||
} {2 1 9 4 2 25 7}
|
||||
do_test format3-9.8 {
|
||||
count {
|
||||
SELECT * FROM t1 WHERE w+0 IN
|
||||
(select rowid from t1 where rowid IN (-1,2,4))
|
||||
ORDER BY 1;
|
||||
}
|
||||
} {2 1 9 4 2 25 199}
|
||||
do_test format3-9.9 {
|
||||
count {
|
||||
SELECT * FROM t1 WHERE x IN (1,7) ORDER BY 1;
|
||||
}
|
||||
} {2 1 9 3 1 16 6}
|
||||
do_test format3-9.10 {
|
||||
count {
|
||||
SELECT * FROM t1 WHERE x+0 IN (1,7) ORDER BY 1;
|
||||
}
|
||||
} {2 1 9 3 1 16 199}
|
||||
do_test format3-9.11 {
|
||||
count {
|
||||
SELECT * FROM t1 WHERE y IN (6400,8100) ORDER BY 1;
|
||||
}
|
||||
} {79 6 6400 89 6 8100 199}
|
||||
do_test format3-9.12 {
|
||||
count {
|
||||
SELECT * FROM t1 WHERE x=6 AND y IN (6400,8100) ORDER BY 1;
|
||||
}
|
||||
} {79 6 6400 89 6 8100 74}
|
||||
do_test format3-9.13 {
|
||||
count {
|
||||
SELECT * FROM t1 WHERE x IN (1,7) AND y NOT IN (6400,8100) ORDER BY 1;
|
||||
}
|
||||
} {2 1 9 3 1 16 6}
|
||||
do_test format3-9.14 {
|
||||
count {
|
||||
SELECT * FROM t1 WHERE x IN (1,7) AND y IN (9,10) ORDER BY 1;
|
||||
}
|
||||
} {2 1 9 6}
|
||||
|
||||
# This procedure executes the SQL. Then it checks the generated program
|
||||
# for the SQL and appends a "nosort" to the result if the program contains the
|
||||
# SortCallback opcode. If the program does not contain the SortCallback
|
||||
# opcode it appends "sort"
|
||||
#
|
||||
proc cksort {sql} {
|
||||
set data [execsql $sql]
|
||||
set prog [execsql "EXPLAIN $sql"]
|
||||
if {[regexp SortCallback $prog]} {set x sort} {set x nosort}
|
||||
lappend data $x
|
||||
return $data
|
||||
}
|
||||
# Check out the logic that attempts to implement the ORDER BY clause
|
||||
# using an index rather than by sorting.
|
||||
#
|
||||
do_test format3-10.1 {
|
||||
execsql {
|
||||
CREATE TABLE t3(a,b,c);
|
||||
CREATE INDEX t3a ON t3(a);
|
||||
CREATE INDEX t3bc ON t3(b,c);
|
||||
CREATE INDEX t3acb ON t3(a,c,b);
|
||||
INSERT INTO t3 SELECT w, 101-w, y FROM t1;
|
||||
SELECT count(*), sum(a), sum(b), sum(c) FROM t3;
|
||||
}
|
||||
} {100 5050 5050 348550}
|
||||
do_test format3-10.2 {
|
||||
cksort {
|
||||
SELECT * FROM t3 ORDER BY a LIMIT 3
|
||||
}
|
||||
} {1 100 4 2 99 9 3 98 16 nosort}
|
||||
do_test format3-10.3 {
|
||||
cksort {
|
||||
SELECT * FROM t3 ORDER BY a+1 LIMIT 3
|
||||
}
|
||||
} {1 100 4 2 99 9 3 98 16 sort}
|
||||
do_test format3-10.4 {
|
||||
cksort {
|
||||
SELECT * FROM t3 WHERE a<10 ORDER BY a LIMIT 3
|
||||
}
|
||||
} {1 100 4 2 99 9 3 98 16 nosort}
|
||||
do_test format3-10.5 {
|
||||
cksort {
|
||||
SELECT * FROM t3 WHERE a>0 AND a<10 ORDER BY a LIMIT 3
|
||||
}
|
||||
} {1 100 4 2 99 9 3 98 16 nosort}
|
||||
do_test format3-10.6 {
|
||||
cksort {
|
||||
SELECT * FROM t3 WHERE a>0 ORDER BY a LIMIT 3
|
||||
}
|
||||
} {1 100 4 2 99 9 3 98 16 nosort}
|
||||
do_test format3-10.7 {
|
||||
cksort {
|
||||
SELECT * FROM t3 WHERE b>0 ORDER BY a LIMIT 3
|
||||
}
|
||||
} {1 100 4 2 99 9 3 98 16 sort}
|
||||
do_test format3-10.8 {
|
||||
cksort {
|
||||
SELECT * FROM t3 WHERE a IN (3,5,7,1,9,4,2) ORDER BY a LIMIT 3
|
||||
}
|
||||
} {1 100 4 2 99 9 3 98 16 sort}
|
||||
do_test format3-10.9 {
|
||||
cksort {
|
||||
SELECT * FROM t3 WHERE a=1 AND c>0 ORDER BY a LIMIT 3
|
||||
}
|
||||
} {1 100 4 nosort}
|
||||
do_test format3-10.10 {
|
||||
cksort {
|
||||
SELECT * FROM t3 WHERE a=1 AND c>0 ORDER BY a LIMIT 3
|
||||
}
|
||||
} {1 100 4 nosort}
|
||||
do_test format3-10.11 {
|
||||
cksort {
|
||||
SELECT * FROM t3 WHERE a=1 AND c>0 ORDER BY a,c LIMIT 3
|
||||
}
|
||||
} {1 100 4 nosort}
|
||||
do_test format3-10.12 {
|
||||
cksort {
|
||||
SELECT * FROM t3 WHERE a=1 AND c>0 ORDER BY a,c,b LIMIT 3
|
||||
}
|
||||
} {1 100 4 nosort}
|
||||
do_test format3-10.13 {
|
||||
cksort {
|
||||
SELECT * FROM t3 WHERE a>0 ORDER BY a DESC LIMIT 3
|
||||
}
|
||||
} {100 1 10201 99 2 10000 98 3 9801 nosort}
|
||||
do_test format3-10.13.1 {
|
||||
cksort {
|
||||
SELECT * FROM t3 WHERE a>0 ORDER BY a+1 DESC LIMIT 3
|
||||
}
|
||||
} {100 1 10201 99 2 10000 98 3 9801 sort}
|
||||
do_test format3-10.14 {
|
||||
cksort {
|
||||
SELECT * FROM t3 ORDER BY b LIMIT 3
|
||||
}
|
||||
} {100 1 10201 99 2 10000 98 3 9801 nosort}
|
||||
do_test format3-10.15 {
|
||||
cksort {
|
||||
SELECT t3.a, t1.x FROM t3, t1 WHERE t3.a=t1.w ORDER BY t3.a LIMIT 3
|
||||
}
|
||||
} {1 0 2 1 3 1 nosort}
|
||||
do_test format3-10.16 {
|
||||
cksort {
|
||||
SELECT t3.a, t1.x FROM t3, t1 WHERE t3.a=t1.w ORDER BY t1.x, t3.a LIMIT 3
|
||||
}
|
||||
} {1 0 2 1 3 1 sort}
|
||||
do_test format3-10.17 {
|
||||
cksort {
|
||||
SELECT y FROM t1 ORDER BY w COLLATE text LIMIT 3;
|
||||
}
|
||||
} {4 121 10201 sort}
|
||||
do_test format3-10.18 {
|
||||
cksort {
|
||||
SELECT y FROM t1 ORDER BY w COLLATE numeric LIMIT 3;
|
||||
}
|
||||
} {4 9 16 sort}
|
||||
do_test format3-10.19 {
|
||||
cksort {
|
||||
SELECT y FROM t1 ORDER BY w LIMIT 3;
|
||||
}
|
||||
} {4 9 16 nosort}
|
||||
|
||||
# Check that all comparisons are numeric. Similar tests in misc1.test
|
||||
# check the same comparisons on a format4+ database and find that some
|
||||
# are numeric and some are text.
|
||||
#
|
||||
do_test format3-11.1 {
|
||||
execsql {SELECT '0'=='0.0'}
|
||||
} {1}
|
||||
do_test format3-11.2 {
|
||||
execsql {SELECT '0'==0.0}
|
||||
} {1}
|
||||
do_test format3-11.3 {
|
||||
execsql {SELECT '123456789012345678901'=='123456789012345678900'}
|
||||
} {1}
|
||||
do_test format3-11.4 {
|
||||
execsql {
|
||||
CREATE TABLE t6(a INT UNIQUE, b TEXT UNIQUE);
|
||||
INSERT INTO t6 VALUES('0','0.0');
|
||||
SELECT * FROM t6;
|
||||
}
|
||||
} {0 0.0}
|
||||
do_test format3-11.5 {
|
||||
execsql {
|
||||
INSERT OR IGNORE INTO t6 VALUES(0.0,'x');
|
||||
SELECT * FROM t6;
|
||||
}
|
||||
} {0 0.0}
|
||||
do_test format3-11.6 {
|
||||
execsql {
|
||||
INSERT OR IGNORE INTO t6 VALUES('y',0);
|
||||
SELECT * FROM t6;
|
||||
}
|
||||
} {0 0.0}
|
||||
do_test format3-11.7 {
|
||||
execsql {
|
||||
CREATE TABLE t7(x INTEGER, y TEXT, z);
|
||||
INSERT INTO t7 VALUES(0,0,1);
|
||||
INSERT INTO t7 VALUES(0.0,0,2);
|
||||
INSERT INTO t7 VALUES(0,0.0,3);
|
||||
INSERT INTO t7 VALUES(0.0,0.0,4);
|
||||
SELECT DISTINCT x, y FROM t7 ORDER BY z;
|
||||
}
|
||||
} {0 0}
|
||||
|
||||
# Make sure attempts to attach a format 3 database fail.
|
||||
#
|
||||
do_test format3-12.1 {
|
||||
file delete -force test2.db
|
||||
sqlite db2 test2.db
|
||||
catchsql {
|
||||
CREATE TABLE t8(x,y);
|
||||
ATTACH DATABASE 'test.db' AS format3;
|
||||
} db2;
|
||||
} {1 {incompatible file format in auxiliary database: format3}}
|
||||
do_test format3-12.2 {
|
||||
catchsql {
|
||||
ATTACH DATABASE 'test2.db' AS test2;
|
||||
}
|
||||
} {1 {cannot attach auxiliary databases to an older format master database}}
|
||||
db2 close
|
||||
|
||||
finish_test
|
||||
18
test/in.test
18
test/in.test
@ -11,7 +11,7 @@
|
||||
# This file implements regression tests for SQLite library. The
|
||||
# focus of this file is testing the IN and BETWEEN operator.
|
||||
#
|
||||
# $Id: in.test,v 1.11 2004/01/15 03:30:25 drh Exp $
|
||||
# $Id: in.test,v 1.12 2004/05/27 17:22:56 drh Exp $
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
@ -19,17 +19,17 @@ source $testdir/tester.tcl
|
||||
# Generate the test data we will need for the first squences of tests.
|
||||
#
|
||||
do_test in-1.0 {
|
||||
set fd [open data1.txt w]
|
||||
for {set i 1} {$i<=10} {incr i} {
|
||||
puts $fd "$i\t[expr {int(pow(2,$i))}]"
|
||||
}
|
||||
close $fd
|
||||
execsql {
|
||||
BEGIN;
|
||||
CREATE TABLE t1(a int, b int);
|
||||
COPY t1 FROM 'data1.txt';
|
||||
}
|
||||
file delete -force data1.txt
|
||||
execsql {SELECT count(*) FROM t1}
|
||||
for {set i 1} {$i<=10} {incr i} {
|
||||
execsql "INSERT INTO t1 VALUES($i,[expr {int(pow(2,$i))}])"
|
||||
}
|
||||
execsql {
|
||||
COMMIT;
|
||||
SELECT count(*) FROM t1;
|
||||
}
|
||||
} {10}
|
||||
|
||||
# Do basic testing of BETWEEN.
|
||||
|
||||
@ -13,7 +13,7 @@
|
||||
# This file implements tests for the special processing associated
|
||||
# with INTEGER PRIMARY KEY columns.
|
||||
#
|
||||
# $Id: intpkey.test,v 1.14 2003/06/15 23:42:25 drh Exp $
|
||||
# $Id: intpkey.test,v 1.15 2004/05/27 17:22:56 drh Exp $
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
@ -380,14 +380,16 @@ do_test intpkey=5.2 {
|
||||
# Test the ability of the COPY command to put data into a
|
||||
# table that contains an integer primary key.
|
||||
#
|
||||
# COPY command has been removed. But we retain these tests so
|
||||
# that the tables will contain the right data for tests that follow.
|
||||
#
|
||||
do_test intpkey-6.1 {
|
||||
set f [open ./data1.txt w]
|
||||
puts $f "20\tb-20\tc-20"
|
||||
puts $f "21\tb-21\tc-21"
|
||||
puts $f "22\tb-22\tc-22"
|
||||
close $f
|
||||
execsql {
|
||||
COPY t1 FROM 'data1.txt';
|
||||
BEGIN;
|
||||
INSERT INTO t1 VALUES(20,'b-20','c-20');
|
||||
INSERT INTO t1 VALUES(21,'b-21','c-21');
|
||||
INSERT INTO t1 VALUES(22,'b-22','c-22');
|
||||
COMMIT;
|
||||
SELECT * FROM t1 WHERE a>=20;
|
||||
}
|
||||
} {20 b-20 c-20 21 b-21 c-21 22 b-22 c-22}
|
||||
|
||||
@ -12,24 +12,24 @@
|
||||
# focus of this file is testing the LIMIT ... OFFSET ... clause
|
||||
# of SELECT statements.
|
||||
#
|
||||
# $Id: limit.test,v 1.12 2004/05/14 21:12:24 drh Exp $
|
||||
# $Id: limit.test,v 1.13 2004/05/27 17:22:56 drh Exp $
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
|
||||
# Build some test data
|
||||
#
|
||||
set fd [open data1.txt w]
|
||||
for {set i 1} {$i<=32} {incr i} {
|
||||
for {set j 0} {pow(2,$j)<$i} {incr j} {}
|
||||
puts $fd "[expr {32-$i}]\t[expr {10-$j}]"
|
||||
}
|
||||
close $fd
|
||||
execsql {
|
||||
CREATE TABLE t1(x int, y int);
|
||||
COPY t1 FROM 'data1.txt'
|
||||
BEGIN;
|
||||
}
|
||||
for {set i 1} {$i<=32} {incr i} {
|
||||
for {set j 0} {pow(2,$j)<$i} {incr j} {}
|
||||
execsql "INSERT INTO t1 VALUES([expr {32-$i}],[expr {10-$j}])"
|
||||
}
|
||||
execsql {
|
||||
COMMIT;
|
||||
}
|
||||
file delete data1.txt
|
||||
|
||||
do_test limit-1.0 {
|
||||
execsql {SELECT count(*) FROM t1}
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
# special feature is used to see what happens in the library if a malloc
|
||||
# were to really fail due to an out-of-memory situation.
|
||||
#
|
||||
# $Id: malloc.test,v 1.6 2004/02/14 01:39:50 drh Exp $
|
||||
# $Id: malloc.test,v 1.7 2004/05/27 17:22:56 drh Exp $
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
@ -67,7 +67,7 @@ for {set go 1; set i 1} {$go} {incr i} {
|
||||
|
||||
set fd [open ./data.tmp w]
|
||||
for {set i 1} {$i<=20} {incr i} {
|
||||
puts $fd "$i\t[expr {$i*$i}]\t[expr {100-$i}] abcdefghijklmnopqrstuvwxyz"
|
||||
puts $fd "$i\t[expr {$i*$i}]\t[expr {100-$i}] abcdefghijklmnopqrstuvwxyz"
|
||||
}
|
||||
close $fd
|
||||
|
||||
@ -85,7 +85,12 @@ for {set go 1; set i 1} {$go} {incr i} {
|
||||
set v [catch {execsql {
|
||||
CREATE TABLE t1(a int, b int, c int);
|
||||
CREATE INDEX i1 ON t1(a,b);
|
||||
COPY t1 FROM 'data.tmp';
|
||||
INSERT INTO t1 VALUES(1,1,'99 abcdefghijklmnopqrstuvwxyz');
|
||||
INSERT INTO t1 VALUES(2,4,'98 abcdefghijklmnopqrstuvwxyz');
|
||||
INSERT INTO t1 VALUES(3,9,'97 abcdefghijklmnopqrstuvwxyz');
|
||||
INSERT INTO t1 VALUES(4,16,'96 abcdefghijklmnopqrstuvwxyz');
|
||||
INSERT INTO t1 VALUES(5,25,'95 abcdefghijklmnopqrstuvwxyz');
|
||||
INSERT INTO t1 VALUES(6,36,'94 abcdefghijklmnopqrstuvwxyz');
|
||||
SELECT 'stuff', count(*) as 'other stuff', max(a+10) FROM t1;
|
||||
UPDATE t1 SET b=b||b||b||b;
|
||||
UPDATE t1 SET b=a WHERE a in (10,12,22);
|
||||
@ -110,12 +115,6 @@ for {set go 1; set i 1} {$go} {incr i} {
|
||||
} {1 1}
|
||||
}
|
||||
|
||||
set fd [open ./data.tmp w]
|
||||
for {set i 1} {$i<=10} {incr i} {
|
||||
puts $fd "$i\t[expr {$i*$i}]\t[expr {100-$i}]"
|
||||
}
|
||||
close $fd
|
||||
|
||||
for {set go 1; set i 1} {$go} {incr i} {
|
||||
do_test malloc-3.$i {
|
||||
sqlite_malloc_fail 0
|
||||
@ -131,7 +130,12 @@ for {set go 1; set i 1} {$go} {incr i} {
|
||||
BEGIN TRANSACTION;
|
||||
CREATE TABLE t1(a int, b int, c int);
|
||||
CREATE INDEX i1 ON t1(a,b);
|
||||
COPY t1 FROM 'data.tmp';
|
||||
INSERT INTO t1 VALUES(1,1,99);
|
||||
INSERT INTO t1 VALUES(2,4,98);
|
||||
INSERT INTO t1 VALUES(3,9,97);
|
||||
INSERT INTO t1 VALUES(4,16,96);
|
||||
INSERT INTO t1 VALUES(5,25,95);
|
||||
INSERT INTO t1 VALUES(6,36,94);
|
||||
INSERT INTO t1(c,b,a) VALUES(20,10,5);
|
||||
DELETE FROM t1 WHERE a>=10;
|
||||
DROP INDEX i1;
|
||||
@ -166,7 +170,12 @@ for {set go 1; set i 1} {$go} {incr i} {
|
||||
BEGIN TRANSACTION;
|
||||
CREATE TABLE t1(a int, b int, c int);
|
||||
CREATE INDEX i1 ON t1(a,b);
|
||||
COPY t1 FROM 'data.tmp';
|
||||
INSERT INTO t1 VALUES(1,1,99);
|
||||
INSERT INTO t1 VALUES(2,4,98);
|
||||
INSERT INTO t1 VALUES(3,9,97);
|
||||
INSERT INTO t1 VALUES(4,16,96);
|
||||
INSERT INTO t1 VALUES(5,25,95);
|
||||
INSERT INTO t1 VALUES(6,36,94);
|
||||
UPDATE t1 SET b=a WHERE a in (10,12,22);
|
||||
INSERT INTO t1 SELECT * FROM t1
|
||||
WHERE a IN (SELECT a FROM t1 WHERE a<10);
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
# This file implements regression tests for SQLite library. The
|
||||
# focus of this file is testing the SELECT statement.
|
||||
#
|
||||
# $Id: select2.test,v 1.20 2004/05/14 11:00:53 danielk1977 Exp $
|
||||
# $Id: select2.test,v 1.21 2004/05/27 17:22:56 drh Exp $
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
@ -19,14 +19,11 @@ source $testdir/tester.tcl
|
||||
# Create a table with some data
|
||||
#
|
||||
execsql {CREATE TABLE tbl1(f1 int, f2 int)}
|
||||
set f [open ./testdata1.txt w]
|
||||
execsql {BEGIN}
|
||||
for {set i 0} {$i<=30} {incr i} {
|
||||
puts $f "[expr {$i%9}]\t[expr {$i%10}]"
|
||||
execsql "INSERT INTO tbl1 VALUES([expr {$i%9}],[expr {$i%10}])"
|
||||
}
|
||||
close $f
|
||||
execsql {COPY tbl1 FROM './testdata1.txt'}
|
||||
file delete -force ./testdata1.txt
|
||||
catch {unset data}
|
||||
execsql {COMMIT}
|
||||
|
||||
# Do a second query inside a first.
|
||||
#
|
||||
@ -61,15 +58,11 @@ do_test select2-1.2 {
|
||||
# Create a largish table
|
||||
#
|
||||
do_test select2-2.0 {
|
||||
execsql {CREATE TABLE tbl2(f1 int, f2 int, f3 int)}
|
||||
set f [open ./testdata1.txt w]
|
||||
execsql {CREATE TABLE tbl2(f1 int, f2 int, f3 int); BEGIN;}
|
||||
for {set i 1} {$i<=30000} {incr i} {
|
||||
puts $f "$i\t[expr {$i*2}]\t[expr {$i*3}]"
|
||||
execsql "INSERT INTO tbl2 VALUES($i,[expr {$i*2}],[expr {$i*3}])"
|
||||
}
|
||||
close $f
|
||||
# execsql {--vdbe-trace-on--}
|
||||
execsql {COPY tbl2 FROM './testdata1.txt'}
|
||||
file delete -force ./testdata1.txt
|
||||
execsql {COMMIT}
|
||||
} {}
|
||||
|
||||
do_test select2-2.1 {
|
||||
|
||||
@ -12,7 +12,7 @@
|
||||
# focus of this file is testing aggregate functions and the
|
||||
# GROUP BY and HAVING clauses of SELECT statements.
|
||||
#
|
||||
# $Id: select3.test,v 1.9 2004/05/21 02:14:25 drh Exp $
|
||||
# $Id: select3.test,v 1.10 2004/05/27 17:22:56 drh Exp $
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
@ -20,17 +20,17 @@ source $testdir/tester.tcl
|
||||
# Build some test data
|
||||
#
|
||||
do_test select3-1.0 {
|
||||
set fd [open data1.txt w]
|
||||
for {set i 1} {$i<32} {incr i} {
|
||||
for {set j 0} {pow(2,$j)<$i} {incr j} {}
|
||||
puts $fd "$i\t$j"
|
||||
}
|
||||
close $fd
|
||||
execsql {
|
||||
CREATE TABLE t1(n int, log int);
|
||||
COPY t1 FROM 'data1.txt'
|
||||
BEGIN;
|
||||
}
|
||||
for {set i 1} {$i<32} {incr i} {
|
||||
for {set j 0} {pow(2,$j)<$i} {incr j} {}
|
||||
execsql "INSERT INTO t1 VALUES($i,$j)"
|
||||
}
|
||||
execsql {
|
||||
COMMIT
|
||||
}
|
||||
file delete data1.txt
|
||||
execsql {SELECT DISTINCT log FROM t1 ORDER BY log}
|
||||
} {0 1 2 3 4 5}
|
||||
|
||||
|
||||
@ -12,24 +12,24 @@
|
||||
# focus of this file is testing UNION, INTERSECT and EXCEPT operators
|
||||
# in SELECT statements.
|
||||
#
|
||||
# $Id: select4.test,v 1.15 2004/05/14 11:00:53 danielk1977 Exp $
|
||||
# $Id: select4.test,v 1.16 2004/05/27 17:22:56 drh Exp $
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
|
||||
# Build some test data
|
||||
#
|
||||
set fd [open data1.txt w]
|
||||
for {set i 1} {$i<32} {incr i} {
|
||||
for {set j 0} {pow(2,$j)<$i} {incr j} {}
|
||||
puts $fd "$i\t$j"
|
||||
}
|
||||
close $fd
|
||||
execsql {
|
||||
CREATE TABLE t1(n int, log int);
|
||||
COPY t1 FROM 'data1.txt'
|
||||
BEGIN;
|
||||
}
|
||||
for {set i 1} {$i<32} {incr i} {
|
||||
for {set j 0} {pow(2,$j)<$i} {incr j} {}
|
||||
execsql "INSERT INTO t1 VALUES($i,$j)"
|
||||
}
|
||||
execsql {
|
||||
COMMIT;
|
||||
}
|
||||
file delete data1.txt
|
||||
|
||||
do_test select4-1.0 {
|
||||
execsql {SELECT DISTINCT log FROM t1 ORDER BY log}
|
||||
|
||||
@ -12,24 +12,24 @@
|
||||
# focus of this file is testing aggregate functions and the
|
||||
# GROUP BY and HAVING clauses of SELECT statements.
|
||||
#
|
||||
# $Id: select5.test,v 1.6 2001/10/15 00:44:36 drh Exp $
|
||||
# $Id: select5.test,v 1.7 2004/05/27 17:22:56 drh Exp $
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
|
||||
# Build some test data
|
||||
#
|
||||
set fd [open data1.txt w]
|
||||
for {set i 1} {$i<32} {incr i} {
|
||||
for {set j 0} {pow(2,$j)<$i} {incr j} {}
|
||||
puts $fd "[expr {32-$i}]\t[expr {10-$j}]"
|
||||
}
|
||||
close $fd
|
||||
execsql {
|
||||
CREATE TABLE t1(x int, y int);
|
||||
COPY t1 FROM 'data1.txt'
|
||||
BEGIN;
|
||||
}
|
||||
for {set i 1} {$i<32} {incr i} {
|
||||
for {set j 0} {pow(2,$j)<$i} {incr j} {}
|
||||
execsql "INSERT INTO t1 VALUES([expr {32-$i}],[expr {10-$j}])"
|
||||
}
|
||||
execsql {
|
||||
COMMIT
|
||||
}
|
||||
file delete data1.txt
|
||||
|
||||
do_test select5-1.0 {
|
||||
execsql {SELECT DISTINCT y FROM t1 ORDER BY y}
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
# This file implements regression tests for SQLite library. The
|
||||
# focus of this file is testing the CREATE TABLE statement.
|
||||
#
|
||||
# $Id: sort.test,v 1.11 2004/05/21 02:14:25 drh Exp $
|
||||
# $Id: sort.test,v 1.12 2004/05/27 17:22:56 drh Exp $
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
@ -19,16 +19,6 @@ source $testdir/tester.tcl
|
||||
# Create a bunch of data to sort against
|
||||
#
|
||||
do_test sort-1.0 {
|
||||
set fd [open data.txt w]
|
||||
puts $fd "1\tone\t0\tI\t3.141592653"
|
||||
puts $fd "2\ttwo\t1\tII\t2.15"
|
||||
puts $fd "3\tthree\t1\tIII\t4221.0"
|
||||
puts $fd "4\tfour\t2\tIV\t-0.0013442"
|
||||
puts $fd "5\tfive\t2\tV\t-11"
|
||||
puts $fd "6\tsix\t2\tVI\t0.123"
|
||||
puts $fd "7\tseven\t2\tVII\t123.0"
|
||||
puts $fd "8\teight\t3\tVIII\t-1.6"
|
||||
close $fd
|
||||
execsql {
|
||||
CREATE TABLE t1(
|
||||
n int,
|
||||
@ -37,9 +27,15 @@ do_test sort-1.0 {
|
||||
roman varchar(10),
|
||||
flt real
|
||||
);
|
||||
COPY t1 FROM 'data.txt'
|
||||
INSERT INTO t1 VALUES(1,'one',0,'I',3.141592653);
|
||||
INSERT INTO t1 VALUES(2,'two',1,'II',2.15);
|
||||
INSERT INTO t1 VALUES(3,'three',1,'III',4221.0);
|
||||
INSERT INTO t1 VALUES(4,'four',2,'IV',-0.0013442);
|
||||
INSERT INTO t1 VALUES(5,'five',2,'V',-11);
|
||||
INSERT INTO t1 VALUES(6,'six',2,'VI',0.123);
|
||||
INSERT INTO t1 VALUES(7,'seven',2,'VII',123.0);
|
||||
INSERT INTO t1 VALUES(8,'eight',3,'VIII',-1.6);
|
||||
}
|
||||
file delete data.txt
|
||||
execsql {SELECT count(*) FROM t1}
|
||||
} {8}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user