Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Fix various collation sequence issues. (CVS 1568) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
66835ee67051027456a536e33b2f88a7 |
User & Date: | danielk1977 2004-06-11 10:51:27.000 |
Context
2004-06-11
| ||
13:19 | Have the vdbe aggregator use a btree table instead of a hash table. (CVS 1569) (check-in: 8d56118f64 user: danielk1977 tags: trunk) | |
10:51 | Fix various collation sequence issues. (CVS 1568) (check-in: 66835ee670 user: danielk1977 tags: trunk) | |
2004-06-10
| ||
23:35 | Comment changes in pager.c. (CVS 1567) (check-in: 0e420f72cd user: drh tags: trunk) | |
Changes
Changes to src/expr.c.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains routines used for analyzing expressions and ** for generating VDBE code that evaluates expressions in SQLite. ** | | | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains routines used for analyzing expressions and ** for generating VDBE code that evaluates expressions in SQLite. ** ** $Id: expr.c,v 1.139 2004/06/11 10:51:27 danielk1977 Exp $ */ #include "sqliteInt.h" #include <ctype.h> char const *sqlite3AffinityString(char affinity){ switch( affinity ){ case SQLITE_AFF_INTEGER: return "i"; |
︙ | ︙ | |||
382 383 384 385 386 387 388 389 390 391 392 393 394 395 | pNew->op = p->op; pNew->pPrior = sqlite3SelectDup(p->pPrior); pNew->nLimit = p->nLimit; pNew->nOffset = p->nOffset; pNew->zSelect = 0; pNew->iLimit = -1; pNew->iOffset = -1; return pNew; } /* ** Add a new element to the end of an expression list. If pList is ** initially NULL, then create a new expression list. | > | 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 | pNew->op = p->op; pNew->pPrior = sqlite3SelectDup(p->pPrior); pNew->nLimit = p->nLimit; pNew->nOffset = p->nOffset; pNew->zSelect = 0; pNew->iLimit = -1; pNew->iOffset = -1; pNew->ppOpenTemp = 0; return pNew; } /* ** Add a new element to the end of an expression list. If pList is ** initially NULL, then create a new expression list. |
︙ | ︙ | |||
1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 | int nExpr = pList ? pList->nExpr : 0; FuncDef *pDef; int nId; const char *zId; int p2 = 0; int i; int iPrefEnc = (pParse->db->enc==TEXT_Utf8)?0:1; getFunctionName(pExpr, &zId, &nId); pDef = sqlite3FindFunction(pParse->db, zId, nId, nExpr, iPrefEnc, 0); assert( pDef!=0 ); nExpr = sqlite3ExprCodeExprList(pParse, pList); for(i=0; i<nExpr && i<32; i++){ if( sqlite3ExprIsConstant(pList->a[i].pExpr) ){ p2 |= (1<<i); } } sqlite3VdbeOp3(v, OP_Function, nExpr, p2, (char*)pDef, P3_FUNCDEF); break; } case TK_SELECT: { sqlite3VdbeAddOp(v, OP_MemLoad, pExpr->iColumn, 0); break; | > > > > > > > > | 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 | int nExpr = pList ? pList->nExpr : 0; FuncDef *pDef; int nId; const char *zId; int p2 = 0; int i; int iPrefEnc = (pParse->db->enc==TEXT_Utf8)?0:1; CollSeq *pColl = 0; getFunctionName(pExpr, &zId, &nId); pDef = sqlite3FindFunction(pParse->db, zId, nId, nExpr, iPrefEnc, 0); assert( pDef!=0 ); nExpr = sqlite3ExprCodeExprList(pParse, pList); for(i=0; i<nExpr && i<32; i++){ if( sqlite3ExprIsConstant(pList->a[i].pExpr) ){ p2 |= (1<<i); } if( pDef->needCollSeq && !pColl ){ pColl = sqlite3ExprCollSeq(pParse, pList->a[i].pExpr); } } if( pDef->needCollSeq ){ if( !pColl ) pColl = pParse->db->pDfltColl; sqlite3VdbeOp3(v, OP_CollSeq, 0, 0, pColl, P3_COLLSEQ); } sqlite3VdbeOp3(v, OP_Function, nExpr, p2, (char*)pDef, P3_FUNCDEF); break; } case TK_SELECT: { sqlite3VdbeAddOp(v, OP_MemLoad, pExpr->iColumn, 0); break; |
︙ | ︙ |
Changes to src/func.c.
︙ | ︙ | |||
12 13 14 15 16 17 18 | ** This file contains the C functions that implement various SQL ** functions of SQLite. ** ** There is only one exported symbol in this file - the function ** sqliteRegisterBuildinFunctions() found at the bottom of the file. ** All other code has file scope. ** | | > > > > > > > | | 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 | ** This file contains the C functions that implement various SQL ** functions of SQLite. ** ** There is only one exported symbol in this file - the function ** sqliteRegisterBuildinFunctions() found at the bottom of the file. ** All other code has file scope. ** ** $Id: func.c,v 1.66 2004/06/11 10:51:32 danielk1977 Exp $ */ #include <ctype.h> #include <math.h> #include <stdlib.h> #include <assert.h> #include "sqliteInt.h" #include "vdbeInt.h" #include "os.h" static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){ return context->pColl; } /* ** Implementation of the non-aggregate min() and max() functions */ static void minmaxFunc( sqlite3_context *context, int argc, sqlite3_value **argv ){ int i; int mask; /* 0 for min() or 0xffffffff for max() */ int iBest; CollSeq *pColl; if( argc==0 ) return; mask = (int)sqlite3_user_data(context); pColl = sqlite3GetFuncCollSeq(context); assert( pColl ); assert( mask==-1 || mask==0 ); iBest = 0; if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; for(i=1; i<argc; i++){ if( sqlite3_value_type(argv[i])==SQLITE_NULL ) return; if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){ iBest = i; } } sqlite3_result_value(context, argv[iBest]); } /* |
︙ | ︙ | |||
560 561 562 563 564 565 566 | ** arguments are equal to each other. */ static void nullifFunc( sqlite3_context *context, int argc, sqlite3_value **argv ){ | > | | 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 | ** arguments are equal to each other. */ static void nullifFunc( sqlite3_context *context, int argc, sqlite3_value **argv ){ CollSeq *pColl = sqlite3GetFuncCollSeq(context); if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){ sqlite3_result_value(context, argv[0]); } } /* ** Implementation of the VERSION(*) function. The result is the version ** of the SQLite library that is running. |
︙ | ︙ | |||
853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 | int cmp = 0; Mem *pArg = (Mem *)argv[0]; Mem *pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest)); if( SQLITE_NULL==sqlite3_value_type(argv[0]) ) return; if( pBest->flags ){ /* This step function is used for both the min() and max() aggregates, ** the only difference between the two being that the sense of the ** comparison is inverted. For the max() aggregate, the ** sqlite3_user_data() function returns (void *)-1. For min() it ** returns (void *)db, where db is the sqlite3* database pointer. ** Therefore the next statement sets variable 'max' to 1 for the max() ** aggregate, or 0 for min(). */ max = ((sqlite3_user_data(context)==(void *)-1)?1:0); | > | | 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 | int cmp = 0; Mem *pArg = (Mem *)argv[0]; Mem *pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest)); if( SQLITE_NULL==sqlite3_value_type(argv[0]) ) return; if( pBest->flags ){ CollSeq *pColl = sqlite3GetFuncCollSeq(context); /* This step function is used for both the min() and max() aggregates, ** the only difference between the two being that the sense of the ** comparison is inverted. For the max() aggregate, the ** sqlite3_user_data() function returns (void *)-1. For min() it ** returns (void *)db, where db is the sqlite3* database pointer. ** Therefore the next statement sets variable 'max' to 1 for the max() ** aggregate, or 0 for min(). */ max = ((sqlite3_user_data(context)==(void *)-1)?1:0); cmp = sqlite3MemCompare(pBest, pArg, pColl); if( (max && cmp<0) || (!max && cmp>0) ){ sqlite3VdbeMemCopy(pBest, pArg); } }else{ sqlite3VdbeMemCopy(pBest, pArg); } } |
︙ | ︙ | |||
889 890 891 892 893 894 895 896 897 | */ void sqlite3RegisterBuiltinFunctions(sqlite *db){ static struct { char *zName; signed char nArg; u8 argType; /* 0: none. 1: db 2: (-1) */ u8 eTextRep; /* 1: UTF-16. 0: UTF-8 */ void (*xFunc)(sqlite3_context*,int,sqlite3_value **); } aFuncs[] = { | > | | | | | | | | | | | | | | | | | | | | | | | | | | | | > | | | | | | > > > > > > > > > > > > > > > | 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 | */ void sqlite3RegisterBuiltinFunctions(sqlite *db){ static struct { char *zName; signed char nArg; u8 argType; /* 0: none. 1: db 2: (-1) */ u8 eTextRep; /* 1: UTF-16. 0: UTF-8 */ u8 needCollSeq; void (*xFunc)(sqlite3_context*,int,sqlite3_value **); } aFuncs[] = { { "min", -1, 0, 0, 1, minmaxFunc }, { "min", 0, 0, 0, 1, 0 }, { "max", -1, 2, 0, 1, minmaxFunc }, { "max", 0, 2, 0, 1, 0 }, { "typeof", 1, 0, 0, 0, typeofFunc }, { "length", 1, 0, 0, 0, lengthFunc }, { "substr", 3, 0, 0, 0, substrFunc }, { "abs", 1, 0, 0, 0, absFunc }, { "round", 1, 0, 0, 0, roundFunc }, { "round", 2, 0, 0, 0, roundFunc }, { "upper", 1, 0, 0, 0, upperFunc }, { "lower", 1, 0, 0, 0, lowerFunc }, { "coalesce", -1, 0, 0, 0, ifnullFunc }, { "coalesce", 0, 0, 0, 0, 0 }, { "coalesce", 1, 0, 0, 0, 0 }, { "ifnull", 2, 0, 0, 1, ifnullFunc }, { "random", -1, 0, 0, 0, randomFunc }, { "like", 2, 0, 0, 0, likeFunc }, /* UTF-8 */ { "like", 2, 2, 1, 0, likeFunc }, /* UTF-16 */ { "glob", 2, 0, 0, 0, globFunc }, { "nullif", 2, 0, 0, 0, nullifFunc }, { "sqlite_version", 0, 0, 0, 0, versionFunc}, { "quote", 1, 0, 0, 0, quoteFunc }, { "last_insert_rowid", 0, 1, 0, 0, last_insert_rowid }, { "change_count", 0, 1, 0, 0, change_count }, { "last_statement_change_count", 0, 1, 0, 0, last_statement_change_count }, #ifdef SQLITE_SOUNDEX { "soundex", 1, 0, 0, 0, soundexFunc}, #endif #ifdef SQLITE_TEST { "randstr", 2, 0, 0, 0, randStr }, #endif }; static struct { char *zName; signed char nArg; u8 argType; u8 needCollSeq; void (*xStep)(sqlite3_context*,int,sqlite3_value**); void (*xFinalize)(sqlite3_context*); } aAggs[] = { { "min", 1, 0, 1, minmaxStep, minMaxFinalize }, { "max", 1, 2, 1, minmaxStep, minMaxFinalize }, { "sum", 1, 0, 0, sumStep, sumFinalize }, { "avg", 1, 0, 0, sumStep, avgFinalize }, { "count", 0, 0, 0, countStep, countFinalize }, { "count", 1, 0, 0, countStep, countFinalize }, #if 0 { "stddev", 1, 0, stdDevStep, stdDevFinalize }, #endif }; int i; for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ void *pArg = 0; switch( aFuncs[i].argType ){ case 1: pArg = db; break; case 2: pArg = (void *)(-1); break; } sqlite3_create_function(db, aFuncs[i].zName, aFuncs[i].nArg, aFuncs[i].eTextRep, 0, pArg, aFuncs[i].xFunc, 0, 0); if( aFuncs[i].needCollSeq ){ FuncDef *pFunc = sqlite3FindFunction(db, aFuncs[i].zName, strlen(aFuncs[i].zName), aFuncs[i].nArg, aFuncs[i].eTextRep, 0); if( pFunc && aFuncs[i].needCollSeq ){ pFunc->needCollSeq = 1; } } } for(i=0; i<sizeof(aAggs)/sizeof(aAggs[0]); i++){ void *pArg = 0; switch( aAggs[i].argType ){ case 1: pArg = db; break; case 2: pArg = (void *)(-1); break; } sqlite3_create_function(db, aAggs[i].zName, aAggs[i].nArg, 0, 0, pArg, 0, aAggs[i].xStep, aAggs[i].xFinalize); if( aAggs[i].needCollSeq ){ FuncDef *pFunc = sqlite3FindFunction( db, aAggs[i].zName, strlen(aAggs[i].zName), aAggs[i].nArg, 0, 0); if( pFunc && aAggs[i].needCollSeq ){ pFunc->needCollSeq = 1; } } } sqlite3RegisterDateTimeFunctions(db); } |
Changes to src/main.c.
︙ | ︙ | |||
10 11 12 13 14 15 16 | ** ************************************************************************* ** Main file for the SQLite library. The routines in this file ** implement the programmer interface to the library. Routines in ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** | | | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** ************************************************************************* ** Main file for the SQLite library. The routines in this file ** implement the programmer interface to the library. Routines in ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** ** $Id: main.c,v 1.215 2004/06/11 10:51:32 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" #include <ctype.h> /* ** A pointer to this structure is used to communicate information |
︙ | ︙ | |||
416 417 418 419 420 421 422 | if( rc==0 ){ rc = nKey1 - nKey2; } return rc; } /* | | > > > > > | | 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 | if( rc==0 ){ rc = nKey1 - nKey2; } return rc; } /* ** Another built-in collating sequence: NOCASE. ** ** This collating sequence is intended to be used for "case independant ** comparison". SQLite's knowledge of upper and lower case equivalents ** extends only to the 26 characters used in the English language. ** ** At the moment there is only a UTF-8 implementation. */ static int nocaseCollatingFunc( void *NotUsed, int nKey1, const void *pKey1, int nKey2, const void *pKey2 ){ int r = sqlite3StrNICmp( |
︙ | ︙ |
Changes to src/select.c.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains C code routines that are called by the parser ** to handle SELECT statements in SQLite. ** | | | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains C code routines that are called by the parser ** to handle SELECT statements in SQLite. ** ** $Id: select.c,v 1.187 2004/06/11 10:51:35 danielk1977 Exp $ */ #include "sqliteInt.h" /* ** Allocate a new Select structure and return a pointer to that ** structure. |
︙ | ︙ | |||
1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 | /* ** Generate VDBE instructions that will open a transient table that ** will be used for an index or to store keyed results for a compound ** select. In other words, open a transient table that needs a ** KeyInfo structure. The number of columns in the KeyInfo is determined ** by the result set of the SELECT statement in the second argument. ** ** Make the new table a KeyAsData table if keyAsData is true. */ | > > > > > > | > | | > > > | | > > | > > > > > > > > > > > > > > > > > > > > > > > > > > | 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 | /* ** Generate VDBE instructions that will open a transient table that ** will be used for an index or to store keyed results for a compound ** select. In other words, open a transient table that needs a ** KeyInfo structure. The number of columns in the KeyInfo is determined ** by the result set of the SELECT statement in the second argument. ** ** Specifically, this routine is called to open an index table for ** DISTINCT, UNION, INTERSECT and EXCEPT select statements (but not ** UNION ALL). ** ** Make the new table a KeyAsData table if keyAsData is true. ** ** The value returned is the address of the OP_OpenTemp instruction. */ static int openTempIndex(Parse *pParse, Select *p, int iTab, int keyAsData){ KeyInfo *pKeyInfo; int nColumn; sqlite *db = pParse->db; int i; Vdbe *v = pParse->pVdbe; int addr; if( fillInColumnList(pParse, p) ){ return 0; } nColumn = p->pEList->nExpr; pKeyInfo = sqliteMalloc( sizeof(*pKeyInfo)+nColumn*sizeof(CollSeq*) ); if( pKeyInfo==0 ) return 0; pKeyInfo->enc = pParse->db->enc; pKeyInfo->nField = nColumn; for(i=0; i<nColumn; i++){ pKeyInfo->aColl[i] = sqlite3ExprCollSeq(pParse, p->pEList->a[i].pExpr); if( !pKeyInfo->aColl[i] ){ pKeyInfo->aColl[i] = db->pDfltColl; } } addr = sqlite3VdbeOp3(v, OP_OpenTemp, iTab, 0, (char*)pKeyInfo, P3_KEYINFO_HANDOFF); if( keyAsData ){ sqlite3VdbeAddOp(v, OP_KeyAsData, iTab, 1); } return addr; } static int multiSelectOpenTempAddr(Select *p, int addr, IdList **ppOpenTemp){ if( !p->ppOpenTemp ){ *ppOpenTemp = sqlite3IdListAppend(0, 0); p->ppOpenTemp = ppOpenTemp; }else{ *p->ppOpenTemp = sqlite3IdListAppend(*p->ppOpenTemp, 0); } if( !(*p->ppOpenTemp) ){ return SQLITE_NOMEM; } (*p->ppOpenTemp)->a[(*p->ppOpenTemp)->nId-1].idx = addr; return SQLITE_OK; } static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){ CollSeq *pRet = 0; if( p->pPrior ){ pRet = multiSelectCollSeq(pParse, p->pPrior, iCol); } if( !pRet ){ pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr); } return pRet; } /* ** This routine is called to process a query that is really the union ** or intersection of two or more separate queries. ** ** "p" points to the right-most of the two queries. the query on the |
︙ | ︙ | |||
1290 1291 1292 1293 1294 1295 1296 | int eDest, int iParm, char *aff /* If eDest is SRT_Union, the affinity string */ ){ int rc = SQLITE_OK; /* Success code from a subroutine */ Select *pPrior; /* Another SELECT immediately to our left */ Vdbe *v; /* Generate code to this VDBE */ | < < | < < < < < < < < < < < < < < < < | 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 | int eDest, int iParm, char *aff /* If eDest is SRT_Union, the affinity string */ ){ int rc = SQLITE_OK; /* Success code from a subroutine */ Select *pPrior; /* Another SELECT immediately to our left */ Vdbe *v; /* Generate code to this VDBE */ IdList *pOpenTemp = 0; /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only ** the last SELECT in the series may have an ORDER BY or LIMIT. */ if( p==0 || p->pPrior==0 ){ rc = 1; goto multi_select_end; |
︙ | ︙ | |||
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 | /* Generate code for the left and right SELECT statements. */ switch( p->op ){ case TK_ALL: { if( p->pOrderBy==0 ){ pPrior->nLimit = p->nLimit; pPrior->nOffset = p->nOffset; rc = sqlite3Select(pParse, pPrior, eDest, iParm, 0, 0, 0, aff); if( rc ){ goto multi_select_end; } p->pPrior = 0; p->iLimit = pPrior->iLimit; p->iOffset = pPrior->iOffset; | > | 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 | /* Generate code for the left and right SELECT statements. */ switch( p->op ){ case TK_ALL: { if( p->pOrderBy==0 ){ pPrior->nLimit = p->nLimit; pPrior->nOffset = p->nOffset; pPrior->ppOpenTemp = p->ppOpenTemp; rc = sqlite3Select(pParse, pPrior, eDest, iParm, 0, 0, 0, aff); if( rc ){ goto multi_select_end; } p->pPrior = 0; p->iLimit = pPrior->iLimit; p->iOffset = pPrior->iOffset; |
︙ | ︙ | |||
1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 | case TK_EXCEPT: case TK_UNION: { int unionTab; /* Cursor number of the temporary table holding result */ int op; /* One of the SRT_ operations to apply to self */ int priorOp; /* The SRT_ operation to apply to prior selects */ int nLimit, nOffset; /* Saved values of p->nLimit and p->nOffset */ ExprList *pOrderBy; /* The ORDER BY clause for the right SELECT */ priorOp = p->op==TK_ALL ? SRT_Table : SRT_Union; if( eDest==priorOp && p->pOrderBy==0 && p->nLimit<0 && p->nOffset==0 ){ /* We can reuse a temporary table generated by a SELECT to our ** right. */ unionTab = iParm; }else{ /* We will need to create our own temporary table to hold the ** intermediate results. */ unionTab = pParse->nTab++; if( p->pOrderBy && matchOrderbyToColumn(pParse, p, p->pOrderBy, unionTab, 1) ){ rc = 1; goto multi_select_end; } if( p->op!=TK_ALL ){ | > > | > | > | > | 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 | case TK_EXCEPT: case TK_UNION: { int unionTab; /* Cursor number of the temporary table holding result */ int op; /* One of the SRT_ operations to apply to self */ int priorOp; /* The SRT_ operation to apply to prior selects */ int nLimit, nOffset; /* Saved values of p->nLimit and p->nOffset */ ExprList *pOrderBy; /* The ORDER BY clause for the right SELECT */ int addr; priorOp = p->op==TK_ALL ? SRT_Table : SRT_Union; if( eDest==priorOp && p->pOrderBy==0 && p->nLimit<0 && p->nOffset==0 ){ /* We can reuse a temporary table generated by a SELECT to our ** right. */ unionTab = iParm; }else{ /* We will need to create our own temporary table to hold the ** intermediate results. */ unionTab = pParse->nTab++; if( p->pOrderBy && matchOrderbyToColumn(pParse, p, p->pOrderBy, unionTab, 1) ){ rc = 1; goto multi_select_end; } addr = sqlite3VdbeAddOp(v, OP_OpenTemp, unionTab, 0); if( p->op!=TK_ALL ){ rc = multiSelectOpenTempAddr(p, addr, &pOpenTemp); if( rc!=SQLITE_OK ){ goto multi_select_end; } sqlite3VdbeAddOp(v, OP_KeyAsData, unionTab, 1); } assert( p->pEList ); } /* Code the SELECT statements to our left */ pPrior->ppOpenTemp = p->ppOpenTemp; rc = sqlite3Select(pParse, pPrior, priorOp, unionTab, 0, 0, 0, aff); if( rc ){ goto multi_select_end; } if( p->op==TK_ALL ){ sqlite3VdbeAddOp(v, OP_SetNumColumns, unionTab, pPrior->pEList->nExpr); } |
︙ | ︙ | |||
1464 1465 1466 1467 1468 1469 1470 | rc = 1; goto multi_select_end; } sqlite3VdbeResolveLabel(v, iCont); sqlite3VdbeAddOp(v, OP_Next, unionTab, iStart); sqlite3VdbeResolveLabel(v, iBreak); sqlite3VdbeAddOp(v, OP_Close, unionTab, 0); | < < < > | > > > > > > > > > > > > | | 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 | rc = 1; goto multi_select_end; } sqlite3VdbeResolveLabel(v, iCont); sqlite3VdbeAddOp(v, OP_Next, unionTab, iStart); sqlite3VdbeResolveLabel(v, iBreak); sqlite3VdbeAddOp(v, OP_Close, unionTab, 0); } break; } case TK_INTERSECT: { int tab1, tab2; int iCont, iBreak, iStart; int nLimit, nOffset; int addr; /* INTERSECT is different from the others since it requires ** two temporary tables. Hence it has its own case. Begin ** by allocating the tables we will need. */ tab1 = pParse->nTab++; tab2 = pParse->nTab++; if( p->pOrderBy && matchOrderbyToColumn(pParse,p,p->pOrderBy,tab1,1) ){ rc = 1; goto multi_select_end; } addr = sqlite3VdbeAddOp(v, OP_OpenTemp, tab1, 0); rc = multiSelectOpenTempAddr(p, addr, &pOpenTemp); if( rc!=SQLITE_OK ){ goto multi_select_end; } sqlite3VdbeAddOp(v, OP_KeyAsData, tab1, 1); assert( p->pEList ); /* Code the SELECTs to our left into temporary table "tab1". */ pPrior->ppOpenTemp = p->ppOpenTemp; rc = sqlite3Select(pParse, pPrior, SRT_Union, tab1, 0, 0, 0, aff); if( rc ){ goto multi_select_end; } /* Code the current SELECT into temporary table "tab2" */ addr = sqlite3VdbeAddOp(v, OP_OpenTemp, tab2, 0); rc = multiSelectOpenTempAddr(p, addr, &pOpenTemp); if( rc!=SQLITE_OK ){ goto multi_select_end; } sqlite3VdbeAddOp(v, OP_KeyAsData, tab2, 1); p->pPrior = 0; nLimit = p->nLimit; p->nLimit = -1; nOffset = p->nOffset; p->nOffset = 0; rc = sqlite3Select(pParse, p, SRT_Union, tab2, 0, 0, 0, aff); p->pPrior = pPrior; |
︙ | ︙ | |||
1536 1537 1538 1539 1540 1541 1542 | goto multi_select_end; } sqlite3VdbeResolveLabel(v, iCont); sqlite3VdbeAddOp(v, OP_Next, tab1, iStart); sqlite3VdbeResolveLabel(v, iBreak); sqlite3VdbeAddOp(v, OP_Close, tab2, 0); sqlite3VdbeAddOp(v, OP_Close, tab1, 0); | < < < > > > > > > | > | > > | > > > > > > | > > > > > | > > > > > > > > | > > > > > | > > | | > > > > > | 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 | goto multi_select_end; } sqlite3VdbeResolveLabel(v, iCont); sqlite3VdbeAddOp(v, OP_Next, tab1, iStart); sqlite3VdbeResolveLabel(v, iBreak); sqlite3VdbeAddOp(v, OP_Close, tab2, 0); sqlite3VdbeAddOp(v, OP_Close, tab1, 0); break; } } assert( p->pEList && pPrior->pEList ); if( p->pEList->nExpr!=pPrior->pEList->nExpr ){ sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s" " do not have the same number of result columns", selectOpName(p->op)); rc = 1; goto multi_select_end; } if( p->pOrderBy || (pOpenTemp && pOpenTemp->nId>0) ){ int nCol = p->pEList->nExpr; int i; KeyInfo *pKeyInfo = sqliteMalloc(sizeof(*pKeyInfo)+nCol*sizeof(CollSeq*)); if( !pKeyInfo ){ rc = SQLITE_NOMEM; goto multi_select_end; } pKeyInfo->enc = pParse->db->enc; pKeyInfo->nField = nCol; for(i=0; i<nCol; i++){ pKeyInfo->aColl[i] = multiSelectCollSeq(pParse, p, i); if( !pKeyInfo->aColl[i] ){ pKeyInfo->aColl[i] = pParse->db->pDfltColl; } } for(i=0; pOpenTemp && i<pOpenTemp->nId; i++){ int p3type = (i==0?P3_KEYINFO_HANDOFF:P3_KEYINFO); int addr = pOpenTemp->a[i].idx; sqlite3VdbeChangeP3(v, addr, (char *)pKeyInfo, p3type); } if( p->pOrderBy ){ for(i=0; i<p->pOrderBy->nExpr; i++){ Expr *pExpr = p->pOrderBy->a[i].pExpr; char *zName = p->pOrderBy->a[i].zName; assert( pExpr->op==TK_COLUMN && pExpr->iColumn<nCol ); assert( !pExpr->pColl ); if( zName ){ pExpr->pColl = sqlite3LocateCollSeq(pParse, zName, -1); }else{ pExpr->pColl = pKeyInfo->aColl[pExpr->iColumn]; } } generateSortTail(pParse, p, v, p->pEList->nExpr, eDest, iParm); } if( !pOpenTemp ){ /* This happens for UNION ALL ... ORDER BY */ sqliteFree(pKeyInfo); } } multi_select_end: if( pOpenTemp ){ sqlite3IdListDelete(pOpenTemp); } p->ppOpenTemp = 0; return rc; } /* ** Scan through the expression pExpr. Replace every reference to ** a column in table number iTable with a copy of the iColumn-th ** entry in pEList. (But leave references to the ROWID column |
︙ | ︙ | |||
1945 1946 1947 1948 1949 1950 1951 1952 1953 | ** appropriate index. If the min() or max() is on an INTEGER PRIMARY ** key column, no index is necessary so set pIdx to NULL. If no ** usable index is found, return 0. */ if( iCol<0 ){ pIdx = 0; }else{ for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ assert( pIdx->nColumn>=1 ); | > | | 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 | ** appropriate index. If the min() or max() is on an INTEGER PRIMARY ** key column, no index is necessary so set pIdx to NULL. If no ** usable index is found, return 0. */ if( iCol<0 ){ pIdx = 0; }else{ CollSeq *pColl = sqlite3ExprCollSeq(pParse, pExpr); for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ assert( pIdx->nColumn>=1 ); if( pIdx->aiColumn[0]==iCol && pIdx->keyInfo.aColl[0]==pColl ) break; } if( pIdx==0 ) return 0; } /* Identify column types if we will be using the callback. This ** step is skipped if the output is going to a table or a memory cell. ** The column names have already been generated in the calling function. |
︙ | ︙ | |||
2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 | assert( pAgg->pFunc->xStep!=0 ); pDef = pAgg->pFunc; pE = pAgg->pExpr; assert( pE!=0 ); assert( pE->op==TK_AGG_FUNCTION ); nExpr = sqlite3ExprCodeExprList(pParse, pE->pList); sqlite3VdbeAddOp(v, OP_Integer, i, 0); sqlite3VdbeOp3(v, OP_AggFunc, 0, nExpr, (char*)pDef, P3_POINTER); } } /* End the database scan loop. */ sqlite3WhereEnd(pWInfo); | > > > > > > > > > | 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 | assert( pAgg->pFunc->xStep!=0 ); pDef = pAgg->pFunc; pE = pAgg->pExpr; assert( pE!=0 ); assert( pE->op==TK_AGG_FUNCTION ); nExpr = sqlite3ExprCodeExprList(pParse, pE->pList); sqlite3VdbeAddOp(v, OP_Integer, i, 0); if( pDef->needCollSeq ){ CollSeq *pColl = 0; int j; for(j=0; !pColl && j<nExpr; j++){ pColl = sqlite3ExprCollSeq(pParse, pE->pList->a[j].pExpr); } if( !pColl ) pColl = pParse->db->pDfltColl; sqlite3VdbeOp3(v, OP_CollSeq, 0, 0, (char *)pColl, P3_COLLSEQ); } sqlite3VdbeOp3(v, OP_AggFunc, 0, nExpr, (char*)pDef, P3_POINTER); } } /* End the database scan loop. */ sqlite3WhereEnd(pWInfo); |
︙ | ︙ |
Changes to src/sqliteInt.h.
1 2 3 4 5 6 7 8 9 10 11 12 13 | /* ** 2001 September 15 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: ** ** May you do good and not evil. ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** Internal interface definitions for SQLite. ** | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | /* ** 2001 September 15 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: ** ** May you do good and not evil. ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** Internal interface definitions for SQLite. ** ** @(#) $Id: sqliteInt.h,v 1.282 2004/06/11 10:51:35 danielk1977 Exp $ */ #include "config.h" #include "sqlite3.h" #include "hash.h" #include "parse.h" #include <stdio.h> #include <stdlib.h> |
︙ | ︙ | |||
471 472 473 474 475 476 477 478 479 480 481 482 483 484 | int nArg; /* Number of arguments. -1 means unlimited */ int iPrefEnc; /* Preferred text encoding */ void *pUserData; /* User data parameter */ FuncDef *pNext; /* Next function with same name */ void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */ void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */ void (*xFinalize)(sqlite3_context*); /* Aggregate finializer */ }; /* ** information about each column of an SQL table is held in an instance ** of this structure. */ struct Column { | > | 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 | int nArg; /* Number of arguments. -1 means unlimited */ int iPrefEnc; /* Preferred text encoding */ void *pUserData; /* User data parameter */ FuncDef *pNext; /* Next function with same name */ void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */ void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */ void (*xFinalize)(sqlite3_context*); /* Aggregate finializer */ u8 needCollSeq; /* True if sqlite3GetFuncCollSeq() might be called */ }; /* ** information about each column of an SQL table is held in an instance ** of this structure. */ struct Column { |
︙ | ︙ | |||
949 950 951 952 953 954 955 956 957 958 959 960 961 962 | ExprList *pGroupBy; /* The GROUP BY clause */ Expr *pHaving; /* The HAVING clause */ ExprList *pOrderBy; /* The ORDER BY clause */ Select *pPrior; /* Prior select in a compound select statement */ int nLimit, nOffset; /* LIMIT and OFFSET values. -1 means not used */ int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */ char *zSelect; /* Complete text of the SELECT command */ }; /* ** The results of a select can be distributed in several ways. */ #define SRT_Callback 1 /* Invoke a callback with each row of result */ #define SRT_Mem 2 /* Store result in a memory cell */ | > | 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 | ExprList *pGroupBy; /* The GROUP BY clause */ Expr *pHaving; /* The HAVING clause */ ExprList *pOrderBy; /* The ORDER BY clause */ Select *pPrior; /* Prior select in a compound select statement */ int nLimit, nOffset; /* LIMIT and OFFSET values. -1 means not used */ int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */ char *zSelect; /* Complete text of the SELECT command */ IdList **ppOpenTemp; /* OP_OpenTemp addresses used by multi-selects */ }; /* ** The results of a select can be distributed in several ways. */ #define SRT_Callback 1 /* Invoke a callback with each row of result */ #define SRT_Mem 2 /* Store result in a memory cell */ |
︙ | ︙ |
Changes to src/vdbe.c.
︙ | ︙ | |||
39 40 41 42 43 44 45 | ** ** Various scripts scan this source file in order to generate HTML ** documentation, headers files, or other derived files. The formatting ** of the code in this file is, therefore, important. See other comments ** in this file for details. If in doubt, do not deviate from existing ** commenting and indentation practices when changing or adding code. ** | | | 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 | ** ** Various scripts scan this source file in order to generate HTML ** documentation, headers files, or other derived files. The formatting ** of the code in this file is, therefore, important. See other comments ** 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.364 2004/06/11 10:51:37 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" #include <ctype.h> #include "vdbeInt.h" /* |
︙ | ︙ | |||
1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 | divide_by_zero: Release(pTos); pTos--; Release(pTos); pTos->flags = MEM_Null; break; } /* Opcode: Function P1 P2 P3 ** ** Invoke a user function (P3 is a pointer to a Function structure that ** defines the function) with P1 arguments taken from the stack. Pop all ** arguments from the stack and push back the result. ** | > > > > > > > > > > > > > > > > | 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 | divide_by_zero: Release(pTos); pTos--; Release(pTos); pTos->flags = MEM_Null; break; } /* Opcode: CollSeq * * P3 ** ** P3 is a pointer to a CollSeq struct. If the next call to a user function ** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will ** be returned. This is used by the built-in min(), max() and nullif() ** built-in functions. ** ** The interface used by the implementation of the aforementioned functions ** to retrieve the collation sequence set by this opcode is not available ** publicly, only to user functions defined in func.c. */ case OP_CollSeq: { assert( pOp->p3type==P3_COLLSEQ ); break; } /* Opcode: Function P1 P2 P3 ** ** Invoke a user function (P3 is a pointer to a Function structure that ** defines the function) with P1 arguments taken from the stack. Pop all ** arguments from the stack and push back the result. ** |
︙ | ︙ | |||
1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 | ctx.pFunc = ctx.pVdbeFunc->pFunc; } ctx.s.flags = MEM_Null; ctx.s.z = 0; ctx.isError = 0; ctx.isStep = 0; if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse; (*ctx.pFunc->xFunc)(&ctx, n, apVal); if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse; popStack(&pTos, n); /* If any auxilary data functions have been called by this user function, ** immediately call the destructor for any non-static values. | > > > > > > | 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 | ctx.pFunc = ctx.pVdbeFunc->pFunc; } ctx.s.flags = MEM_Null; ctx.s.z = 0; ctx.isError = 0; ctx.isStep = 0; if( ctx.pFunc->needCollSeq ){ assert( pOp>p->aOp ); assert( pOp[-1].p3type==P3_COLLSEQ ); assert( pOp[-1].opcode==OP_CollSeq ); ctx.pColl = (CollSeq *)pOp[-1].p3; } if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse; (*ctx.pFunc->xFunc)(&ctx, n, apVal); if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse; popStack(&pTos, n); /* If any auxilary data functions have been called by this user function, ** immediately call the destructor for any non-static values. |
︙ | ︙ | |||
4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 | ctx.pFunc = (FuncDef*)pOp->p3; pMem = &p->agg.pCurrent->aMem[i]; ctx.s.z = pMem->zShort; /* Space used for small aggregate contexts */ ctx.pAgg = pMem->z; ctx.cnt = ++pMem->i; ctx.isError = 0; ctx.isStep = 1; (ctx.pFunc->xStep)(&ctx, n, apVal); pMem->z = ctx.pAgg; pMem->flags = MEM_AggCtx; popStack(&pTos, n+1); if( ctx.isError ){ rc = SQLITE_ERROR; } | > > > > > > > | 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 | ctx.pFunc = (FuncDef*)pOp->p3; pMem = &p->agg.pCurrent->aMem[i]; ctx.s.z = pMem->zShort; /* Space used for small aggregate contexts */ ctx.pAgg = pMem->z; ctx.cnt = ++pMem->i; ctx.isError = 0; ctx.isStep = 1; ctx.pColl = 0; if( ctx.pFunc->needCollSeq ){ assert( pOp>p->aOp ); assert( pOp[-1].p3type==P3_COLLSEQ ); assert( pOp[-1].opcode==OP_CollSeq ); ctx.pColl = (CollSeq *)pOp[-1].p3; } (ctx.pFunc->xStep)(&ctx, n, apVal); pMem->z = ctx.pAgg; pMem->flags = MEM_AggCtx; popStack(&pTos, n+1); if( ctx.isError ){ rc = SQLITE_ERROR; } |
︙ | ︙ |
Changes to src/vdbeInt.h.
︙ | ︙ | |||
204 205 206 207 208 209 210 211 212 213 214 215 216 217 | FuncDef *pFunc; /* Pointer to function information. MUST BE FIRST */ VdbeFunc *pVdbeFunc; /* Auxilary data, if created. */ Mem s; /* The return value is stored here */ void *pAgg; /* Aggregate context */ u8 isError; /* Set to true for an error */ u8 isStep; /* Current in the step function */ int cnt; /* Number of times that the step function has been called */ }; /* ** An Agg structure describes an Aggregator. Each Agg consists of ** zero or more Aggregator elements (AggElem). Each AggElem contains ** a key and one or more values. The values are used in processing ** aggregate functions in a SELECT. The key is used to implement | > | 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 | FuncDef *pFunc; /* Pointer to function information. MUST BE FIRST */ VdbeFunc *pVdbeFunc; /* Auxilary data, if created. */ Mem s; /* The return value is stored here */ void *pAgg; /* Aggregate context */ u8 isError; /* Set to true for an error */ u8 isStep; /* Current in the step function */ int cnt; /* Number of times that the step function has been called */ CollSeq *pColl; }; /* ** An Agg structure describes an Aggregator. Each Agg consists of ** zero or more Aggregator elements (AggElem). Each AggElem contains ** a key and one or more values. The values are used in processing ** aggregate functions in a SELECT. The key is used to implement |
︙ | ︙ |
Changes to test/collate1.test.
1 | # | > > | < < | > > > > | | < | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | # # 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 script is page cache subsystem. # # $Id: collate1.test,v 1.2 2004/06/11 10:51:41 danielk1977 Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl # # Tests are roughly organised as follows: # |
︙ | ︙ |
Changes to test/collate2.test.
1 | # | > > | < < | > > > > | | < > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | # # 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 script is page cache subsystem. # # $Id: collate2.test,v 1.2 2004/06/11 10:51:41 danielk1977 Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl # # Tests are organised as follows: # |
︙ | ︙ |
Changes to test/collate3.test.
1 | # | > | < | < > > > > | | | < < > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | # 2001 September 15 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # This file implements regression tests for SQLite library. The # focus of this script is page cache subsystem. # # $Id: collate3.test,v 1.2 2004/06/11 10:51:41 danielk1977 Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl # # Tests are organised as follows: # |
︙ | ︙ | |||
103 104 105 106 107 108 109 | } } {1 {no such collation sequence: string_compare}} do_test collate3-2.6 { catchsql { SELECT * FROM collate3t1; } } {0 {}} | < < < < > | 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 | } } {1 {no such collation sequence: string_compare}} do_test collate3-2.6 { catchsql { SELECT * FROM collate3t1; } } {0 {}} do_test collate3-2.7 { catchsql { SELECT * FROM collate3t1 GROUP BY c1; } } {1 {no such collation sequence: string_compare}} do_test collate3-2.8 { catchsql { SELECT DISTINCT c1 FROM collate3t1; } } {1 {no such collation sequence: string_compare}} do_test collate3-2.9 { catchsql { SELECT c1 FROM collate3t1 UNION SELECT c1 FROM collate3t1; } } {1 {no such collation sequence: string_compare}} do_test collate3-2.10 { catchsql { |
︙ | ︙ | |||
162 163 164 165 166 167 168 | } } {1 {no such collation sequence: string_compare}} do_test collate3-2.17 { catchsql { SELECT c1 FROM collate3t1 UNION ALL SELECT c1 FROM collate3t1 ORDER BY 1; } } {1 {no such collation sequence: string_compare}} | < < < | 161 162 163 164 165 166 167 168 169 170 171 172 173 174 | } } {1 {no such collation sequence: string_compare}} do_test collate3-2.17 { catchsql { SELECT c1 FROM collate3t1 UNION ALL SELECT c1 FROM collate3t1 ORDER BY 1; } } {1 {no such collation sequence: string_compare}} # # Create an index that uses a collation sequence then close and # re-open the database without re-registering the collation # sequence. Then check that for the table with the index # * An INSERT fails, # * An UPDATE on the column with the index fails, |
︙ | ︙ |
Changes to test/collate4.test.
1 | # | > > | < < | > > > > | | < > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | # # 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 script is page cache subsystem. # # $Id: collate4.test,v 1.2 2004/06/11 10:51:41 danielk1977 Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl db collate TEXT text_collate proc text_collate {a b} { return [string compare $a $b] |
︙ | ︙ | |||
540 541 542 543 544 545 546 547 548 549 550 551 552 553 | do_test collate4-3.15 { execsql { DROP TABLE collate4t1; } } {} # # These tests - collate4-4.* check that min() and max() only ever # use indices constructed with built-in collation type numeric. # # CHANGED: min() and max() now use the collation type. If there # is an indice that can be used, it is used. # | > > > > > > > < < < < | | | | | 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 | do_test collate4-3.15 { execsql { DROP TABLE collate4t1; } } {} # Mimic the SQLite 2 collation type NUMERIC. db collate numeric numeric_collate proc numeric_collate {lhs rhs} { if {$lhs == $rhs} {return 0} return [expr ($lhs>$rhs)?1:-1] } # # These tests - collate4-4.* check that min() and max() only ever # use indices constructed with built-in collation type numeric. # # CHANGED: min() and max() now use the collation type. If there # is an indice that can be used, it is used. # do_test collate4-4.0 { execsql { CREATE TABLE collate4t1(a COLLATE TEXT); INSERT INTO collate4t1 VALUES('2'); INSERT INTO collate4t1 VALUES('10'); INSERT INTO collate4t1 VALUES('20'); INSERT INTO collate4t1 VALUES('104'); } } {} do_test collate4-4.1 { count { SELECT max(a) FROM collate4t1 } } {20 3} |
︙ | ︙ | |||
609 610 611 612 613 614 615 | } } {} # Also test the scalar min() and max() functions. # do_test collate4-4.8 { execsql { | | < | | < < < < < < < < < < < < < < < < < < < < < < < < < | | < < < < < < < < < < < < < < < | | | | < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < | < < < < | < < < < < | < < < < | | | < < < < < | < < < < < < | < < < < < < < < < < < < < < < < < < < | < < < < < < < < < < < < < < < < < < < < < < | < < < < < < < < | < < < | < < < | < < | 616 617 618 619 620 621 622 623 624 625 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 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 | } } {} # Also test the scalar min() and max() functions. # do_test collate4-4.8 { execsql { CREATE TABLE collate4t1(a COLLATE TEXT, b COLLATE NUMERIC); INSERT INTO collate4t1 VALUES('11', '101'); INSERT INTO collate4t1 VALUES('101', '11') } } {} do_test collate4-4.9 { execsql { SELECT max(a, b) FROM collate4t1; } } {11 11} do_test collate4-4.10 { execsql { SELECT max(b, a) FROM collate4t1; } } {101 101} do_test collate4-4.11 { execsql { SELECT max(a, '101') FROM collate4t1; } } {11 101} do_test collate4-4.12 { execsql { SELECT max('101', a) FROM collate4t1; } } {11 101} do_test collate4-4.13 { execsql { SELECT max(b, '101') FROM collate4t1; } } {101 101} do_test collate4-4.14 { execsql { SELECT max('101', b) FROM collate4t1; } } {101 101} do_test collate4-4.15 { execsql { DROP TABLE collate4t1; } } {} # # These tests - collate4.6.* - ensure that implict INTEGER PRIMARY KEY # indices do not confuse collation sequences. # # These indices are never used for sorting in SQLite. And you can't # create another index on an INTEGER PRIMARY KEY column, so we don't have |
︙ | ︙ |
Added test/collate5.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 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 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 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 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 | # # 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 DISTINCT, UNION, INTERSECT and EXCEPT # SELECT statements that use user-defined collation sequences. Also # GROUP BY clauses that use user-defined collation sequences. # # $Id: collate5.test,v 1.1 2004/06/11 10:51:41 danielk1977 Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl # # Tests are organised as follows: # collate5-1.* - DISTINCT # collate5-2.* - Compound SELECT # collate5-3.* - ORDER BY on compound SELECT # collate5-4.* - GROUP BY # Create the collation sequence 'TEXT', purely for asthetic reasons. The # test cases in this script could just as easily use BINARY. db collate TEXT [list string compare] # Mimic the SQLite 2 collation type NUMERIC. db collate numeric numeric_collate proc numeric_collate {lhs rhs} { if {$lhs == $rhs} {return 0} return [expr ($lhs>$rhs)?1:-1] } # # These tests - collate5-1.* - focus on the DISTINCT keyword. # do_test collate5-1.0 { execsql { CREATE TABLE collate5t1(a COLLATE nocase, b COLLATE text); INSERT INTO collate5t1 VALUES('a', 'apple'); INSERT INTO collate5t1 VALUES('A', 'Apple'); INSERT INTO collate5t1 VALUES('b', 'banana'); INSERT INTO collate5t1 VALUES('B', 'banana'); INSERT INTO collate5t1 VALUES('n', NULL); INSERT INTO collate5t1 VALUES('N', NULL); } } {} do_test collate5-1.1 { execsql { SELECT DISTINCT a FROM collate5t1; } } {a b n} do_test collate5-1.2 { execsql { SELECT DISTINCT b FROM collate5t1; } } {apple Apple banana {}} do_test collate5-1.3 { execsql { SELECT DISTINCT a, b FROM collate5t1; } } {a apple A Apple b banana n {}} # # Tests named collate5-2.* focus on UNION, EXCEPT and INTERSECT # queries that use user-defined collation sequences. # # collate5-2.1.* - UNION # collate5-2.2.* - INTERSECT # collate5-2.3.* - EXCEPT # do_test collate5-2.0 { execsql { CREATE TABLE collate5t2(a COLLATE text, b COLLATE nocase); INSERT INTO collate5t2 VALUES('a', 'apple'); INSERT INTO collate5t2 VALUES('A', 'apple'); INSERT INTO collate5t2 VALUES('b', 'banana'); INSERT INTO collate5t2 VALUES('B', 'Banana'); } } {} do_test collate5-2.1.1 { execsql { SELECT a FROM collate5t1 UNION select a FROM collate5t2; } } {A B N} do_test collate5-2.1.2 { execsql { SELECT a FROM collate5t2 UNION select a FROM collate5t1; } } {A B N a b n} do_test collate5-2.1.3 { execsql { SELECT a, b FROM collate5t1 UNION select a, b FROM collate5t2; } } {A Apple A apple B Banana b banana N {}} do_test collate5-2.1.4 { execsql { SELECT a, b FROM collate5t2 UNION select a, b FROM collate5t1; } } {A Apple B banana N {} a apple b banana n {}} do_test collate5-2.2.1 { execsql { SELECT a FROM collate5t1 EXCEPT select a FROM collate5t2; } } {N} do_test collate5-2.2.2 { execsql { SELECT a FROM collate5t2 EXCEPT select a FROM collate5t1 WHERE a != 'a'; } } {A a} do_test collate5-2.2.3 { execsql { SELECT a, b FROM collate5t1 EXCEPT select a, b FROM collate5t2; } } {A Apple N {}} do_test collate5-2.2.4 { execsql { SELECT a, b FROM collate5t2 EXCEPT select a, b FROM collate5t1 where a != 'a'; } } {A apple a apple} do_test collate5-2.3.1 { execsql { SELECT a FROM collate5t1 INTERSECT select a FROM collate5t2; } } {A B} do_test collate5-2.3.2 { execsql { SELECT a FROM collate5t2 INTERSECT select a FROM collate5t1 WHERE a != 'a'; } } {B b} do_test collate5-2.3.3 { execsql { SELECT a, b FROM collate5t1 INTERSECT select a, b FROM collate5t2; } } {a apple B banana} do_test collate5-2.3.4 { execsql { SELECT a, b FROM collate5t2 INTERSECT select a, b FROM collate5t1; } } {A apple B Banana a apple b banana} # # This test ensures performs a UNION operation with a bunch of different # length records. The goal is to test that the logic that compares records # for the compound SELECT operators works with record lengths that lie # either side of the troublesome 256 and 65536 byte marks. # set ::lens [list \ 0 1 2 3 4 5 6 7 8 9 \ 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 \ 65520 65521 65522 65523 65524 65525 65526 65527 65528 65529 65530 \ 65531 65532 65533 65534 65535 65536 65537 65538 65539 65540 65541 \ 65542 65543 65544 65545 65546 65547 65548 65549 65550 65551 ] do_test collate5-2.4.0 { execsql { BEGIN; CREATE TABLE collate5t3(a, b); } foreach ii $::lens { execsql "INSERT INTO collate5t3 VALUES($ii, '[string repeat a $ii]');" } execsql { COMMIT; SELECT count(*) FROM (SELECT * FROM collate5t3 UNION SELECT * FROM collate5t3); } } [llength $::lens] do_test collate5-2.4.1 { execsql {DROP TABLE collate5t3;} } {} unset ::lens # # These tests - collate5-3.* - focus on compound SELECT queries that # feature ORDER BY clauses. # do_test collate5-3.0 { execsql { SELECT a FROM collate5t1 UNION ALL SELECT a FROM collate5t2 ORDER BY 1; } } {A a A a B b B b N n} do_test collate5-3.1 { execsql { SELECT a FROM collate5t2 UNION ALL SELECT a FROM collate5t1 ORDER BY 1; } } {A A B B N a a b b n} do_test collate5-3.2 { execsql { SELECT a FROM collate5t1 UNION ALL SELECT a FROM collate5t2 ORDER BY 1 COLLATE TEXT; } } {A A B B N a a b b n} do_test collate5-3.3 { execsql { CREATE TABLE collate5t_cn(a COLLATE NUMERIC); CREATE TABLE collate5t_ct(a COLLATE TEXT); INSERT INTO collate5t_cn VALUES('1'); INSERT INTO collate5t_cn VALUES('11'); INSERT INTO collate5t_cn VALUES('101'); INSERT INTO collate5t_ct SELECT * FROM collate5t_cn; } } {} do_test collate5-3.4 { execsql { SELECT a FROM collate5t_cn INTERSECT SELECT a FROM collate5t_ct ORDER BY 1; } } {1 11 101} do_test collate5-3.5 { execsql { SELECT a FROM collate5t_ct INTERSECT SELECT a FROM collate5t_cn ORDER BY 1; } } {1 101 11} do_test collate5-3.20 { execsql { DROP TABLE collate5t_cn; DROP TABLE collate5t_ct; DROP TABLE collate5t1; DROP TABLE collate5t2; } } {} do_test collate5-4.0 { execsql { CREATE TABLE collate5t1(a COLLATE NOCASE, b COLLATE NUMERIC); INSERT INTO collate5t1 VALUES('a', '1'); INSERT INTO collate5t1 VALUES('A', '1.0'); INSERT INTO collate5t1 VALUES('b', '2'); INSERT INTO collate5t1 VALUES('B', '3'); } } {} do_test collate5-4.1 { execsql { SELECT a, count(*) FROM collate5t1 GROUP BY a; } } {a 2 b 2} do_test collate5-4.2 { execsql { SELECT a, b, count(*) FROM collate5t1 GROUP BY a, b; } } {a 1 2 b 2 1 B 3 1} do_test collate5-4.3 { execsql { DROP TABLE collate5t1; } } {} finish_test |
Added test/collate6.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 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 95 96 97 98 99 100 101 102 103 104 105 106 | # # 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 script is collation sequences in concert with triggers. # # $Id: collate6.test,v 1.1 2004/06/11 10:51:41 danielk1977 Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl # Create a case-insensitive collation type NOCASE for use in testing. # Normally, capital letters are less than their lower-case counterparts. db collate NOCASE nocase_collate proc nocase_collate {a b} { return [string compare -nocase $a $b] } # # Tests are organized as follows: # collate6-1.* - triggers. # do_test collate6-1.0 { execsql { CREATE TABLE collate6log(a, b); CREATE TABLE collate6tab(a COLLATE NOCASE, b COLLATE BINARY); } } {} # Test that the default collation sequence applies to new.* references # in WHEN clauses. do_test collate6-1.1 { execsql { CREATE TRIGGER collate6trig BEFORE INSERT ON collate6tab WHEN new.a = 'a' BEGIN INSERT INTO collate6log VALUES(new.a, new.b); END; } } {} do_test collate6-1.2 { execsql { INSERT INTO collate6tab VALUES('a', 'b'); SELECT * FROM collate6log; } } {a b} do_test collate6-1.3 { execsql { INSERT INTO collate6tab VALUES('A', 'B'); SELECT * FROM collate6log; } } {a b A B} do_test collate6-1.4 { execsql { DROP TRIGGER collate6trig; DELETE FROM collate6log; } } {} # Test that the default collation sequence applies to new.* references # in the body of triggers. do_test collate6-1.5 { execsql { CREATE TRIGGER collate6trig BEFORE INSERT ON collate6tab BEGIN INSERT INTO collate6log VALUES(new.a='a', new.b='b'); END; } } {} do_test collate6-1.6 { execsql { INSERT INTO collate6tab VALUES('a', 'b'); SELECT * FROM collate6log; } } {1 1} do_test collate6-1.7 { execsql { INSERT INTO collate6tab VALUES('A', 'B'); SELECT * FROM collate6log; } } {1 1 1 0} do_test collate6-1.8 { execsql { DROP TRIGGER collate6trig; DELETE FROM collate6log; } } {} do_test collate6-1.9 { execsql { DROP TABLE collate6tab; } } {} finish_test |