Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Changes In Branch table-valued-functions Excluding Merge-Ins
This is equivalent to a diff from c573b0a1 to 3efc7942
|
2015-08-20
| ||
| 19:55 | Add support for table-valued functions in the FROM clause implemented as virtual tables. check-in: 9b718b06 user: drh tags: trunk | |
| 18:28 | Prevent the series.c extension from loading on older versions of SQLite that do not support xCreate==NULL. Closed-Leaf check-in: 3efc7942 user: drh tags: table-valued-functions | |
| 17:18 | Make SQLITE_BUSY_SNAPSHOT and SQLITE_BUSY_RECOVERY retryable, just as a plain SQLITE_BUSY is. check-in: fd13dd95 user: drh tags: trunk | |
| 16:16 | Fix a typo in series.c. check-in: 23db7f50 user: dan tags: table-valued-functions | |
|
2015-08-19
| ||
| 12:52 | Merge changes from trunk. check-in: dddd792d user: drh tags: table-valued-functions | |
| 12:45 | Simplification to error handling in addModuleArgument() in the virtual table processing. check-in: c573b0a1 user: drh tags: trunk | |
| 08:34 | When updating a zipvfs database with RBU, set journal_mode=off to prevent the upper-level pager from creating a large temporary file. check-in: dec14a39 user: dan tags: trunk | |
Changes to Makefile.in.
416 416 $(TOP)/ext/misc/fuzzer.c \ 417 417 $(TOP)/ext/fts5/fts5_tcl.c \ 418 418 $(TOP)/ext/fts5/fts5_test_mi.c \ 419 419 $(TOP)/ext/misc/ieee754.c \ 420 420 $(TOP)/ext/misc/nextchar.c \ 421 421 $(TOP)/ext/misc/percentile.c \ 422 422 $(TOP)/ext/misc/regexp.c \ 423 + $(TOP)/ext/misc/series.c \ 423 424 $(TOP)/ext/misc/spellfix.c \ 424 425 $(TOP)/ext/misc/totype.c \ 425 426 $(TOP)/ext/misc/wholenumber.c 426 427 427 428 # Source code to the library files needed by the test fixture 428 429 # 429 430 TESTSRC2 = \
Changes to Makefile.msc.
1082 1082 fts5.c \ 1083 1083 $(TOP)\ext\fts5\fts5_tcl.c \ 1084 1084 $(TOP)\ext\fts5\fts5_test_mi.c \ 1085 1085 $(TOP)\ext\misc\ieee754.c \ 1086 1086 $(TOP)\ext\misc\nextchar.c \ 1087 1087 $(TOP)\ext\misc\percentile.c \ 1088 1088 $(TOP)\ext\misc\regexp.c \ 1089 + $(TOP)\ext\misc\series.c \ 1089 1090 $(TOP)\ext\misc\spellfix.c \ 1090 1091 $(TOP)\ext\misc\totype.c \ 1091 1092 $(TOP)\ext\misc\wholenumber.c 1092 1093 1093 1094 1094 1095 # Source code to the library files needed by the test fixture 1095 1096 #
Added ext/misc/series.c.
1 +/* 2 +** 2015-08-18 3 +** 4 +** The author disclaims copyright to this source code. In place of 5 +** a legal notice, here is a blessing: 6 +** 7 +** May you do good and not evil. 8 +** May you find forgiveness for yourself and forgive others. 9 +** May you share freely, never taking more than you give. 10 +** 11 +************************************************************************* 12 +** 13 +** This file demonstrates how to create a table-valued-function using 14 +** a virtual table. This demo implements the generate_series() function 15 +** which gives similar results to the eponymous function in PostgreSQL. 16 +** Examples: 17 +** 18 +** SELECT * FROM generate_series(0,100,5); 19 +** 20 +** The query above returns integers from 0 through 100 counting by steps 21 +** of 5. 22 +** 23 +** SELECT * FROM generate_series(0,100); 24 +** 25 +** Integers from 0 through 100 with a step size of 1. 26 +** 27 +** SELECT * FROM generate_series(20) LIMIT 10; 28 +** 29 +** Integers 20 through 29. 30 +** 31 +** HOW IT WORKS 32 +** 33 +** The generate_series "function" is really a virtual table with the 34 +** following schema: 35 +** 36 +** CREATE FUNCTION generate_series( 37 +** value, 38 +** start HIDDEN, 39 +** stop HIDDEN, 40 +** step HIDDEN 41 +** ); 42 +** 43 +** Function arguments in queries against this virtual table are translated 44 +** into equality constraints against successive hidden columns. In other 45 +** words, the following pairs of queries are equivalent to each other: 46 +** 47 +** SELECT * FROM generate_series(0,100,5); 48 +** SELECT * FROM generate_series WHERE start=0 AND stop=100 AND step=5; 49 +** 50 +** SELECT * FROM generate_series(0,100); 51 +** SELECT * FROM generate_series WHERE start=0 AND stop=100; 52 +** 53 +** SELECT * FROM generate_series(20) LIMIT 10; 54 +** SELECT * FROM generate_series WHERE start=20 LIMIT 10; 55 +** 56 +** The generate_series virtual table implementation leaves the xCreate method 57 +** set to NULL. This means that it is not possible to do a CREATE VIRTUAL 58 +** TABLE command with "generate_series" as the USING argument. Instead, there 59 +** is a single generate_series virtual table that is always available without 60 +** having to be created first. 61 +** 62 +** The xBestIndex method looks for equality constraints against the hidden 63 +** start, stop, and step columns, and if present, it uses those constraints 64 +** to bound the sequence of generated values. If the equality constraints 65 +** are missing, it uses 0 for start, 4294967295 for stop, and 1 for step. 66 +** xBestIndex returns a small cost when both start and stop are available, 67 +** and a very large cost if either start or stop are unavailable. This 68 +** encourages the query planner to order joins such that the bounds of the 69 +** series are well-defined. 70 +*/ 71 +#include "sqlite3ext.h" 72 +SQLITE_EXTENSION_INIT1 73 +#include <assert.h> 74 +#include <string.h> 75 + 76 +#ifndef SQLITE_OMIT_VIRTUALTABLE 77 + 78 + 79 +/* series_cursor is a subclass of sqlite3_vtab_cursor which will 80 +** serve as the underlying representation of a cursor that scans 81 +** over rows of the result 82 +*/ 83 +typedef struct series_cursor series_cursor; 84 +struct series_cursor { 85 + sqlite3_vtab_cursor base; /* Base class - must be first */ 86 + int isDesc; /* True to count down rather than up */ 87 + sqlite3_int64 iRowid; /* The rowid */ 88 + sqlite3_int64 iValue; /* Current value ("value") */ 89 + sqlite3_int64 mnValue; /* Mimimum value ("start") */ 90 + sqlite3_int64 mxValue; /* Maximum value ("stop") */ 91 + sqlite3_int64 iStep; /* Increment ("step") */ 92 +}; 93 + 94 +/* 95 +** The seriesConnect() method is invoked to create a new 96 +** series_vtab that describes the generate_series virtual table. 97 +** 98 +** Think of this routine as the constructor for series_vtab objects. 99 +** 100 +** All this routine needs to do is: 101 +** 102 +** (1) Allocate the series_vtab object and initialize all fields. 103 +** 104 +** (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the 105 +** result set of queries against generate_series will look like. 106 +*/ 107 +static int seriesConnect( 108 + sqlite3 *db, 109 + void *pAux, 110 + int argc, const char *const*argv, 111 + sqlite3_vtab **ppVtab, 112 + char **pzErr 113 +){ 114 + sqlite3_vtab *pNew; 115 + pNew = *ppVtab = sqlite3_malloc( sizeof(*pNew) ); 116 + if( pNew==0 ) return SQLITE_NOMEM; 117 + 118 +/* Column numbers */ 119 +#define SERIES_COLUMN_VALUE 0 120 +#define SERIES_COLUMN_START 1 121 +#define SERIES_COLUMN_STOP 2 122 +#define SERIES_COLUMN_STEP 3 123 + 124 + sqlite3_declare_vtab(db, 125 + "CREATE TABLE x(value,start hidden,stop hidden,step hidden)"); 126 + memset(pNew, 0, sizeof(*pNew)); 127 + return SQLITE_OK; 128 +} 129 + 130 +/* 131 +** This method is the destructor for series_cursor objects. 132 +*/ 133 +static int seriesDisconnect(sqlite3_vtab *pVtab){ 134 + sqlite3_free(pVtab); 135 + return SQLITE_OK; 136 +} 137 + 138 +/* 139 +** Constructor for a new series_cursor object. 140 +*/ 141 +static int seriesOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ 142 + series_cursor *pCur; 143 + pCur = sqlite3_malloc( sizeof(*pCur) ); 144 + if( pCur==0 ) return SQLITE_NOMEM; 145 + memset(pCur, 0, sizeof(*pCur)); 146 + *ppCursor = &pCur->base; 147 + return SQLITE_OK; 148 +} 149 + 150 +/* 151 +** Destructor for a series_cursor. 152 +*/ 153 +static int seriesClose(sqlite3_vtab_cursor *cur){ 154 + sqlite3_free(cur); 155 + return SQLITE_OK; 156 +} 157 + 158 + 159 +/* 160 +** Advance a series_cursor to its next row of output. 161 +*/ 162 +static int seriesNext(sqlite3_vtab_cursor *cur){ 163 + series_cursor *pCur = (series_cursor*)cur; 164 + if( pCur->isDesc ){ 165 + pCur->iValue -= pCur->iStep; 166 + }else{ 167 + pCur->iValue += pCur->iStep; 168 + } 169 + pCur->iRowid++; 170 + return SQLITE_OK; 171 +} 172 + 173 +/* 174 +** Return values of columns for the row at which the series_cursor 175 +** is currently pointing. 176 +*/ 177 +static int seriesColumn( 178 + sqlite3_vtab_cursor *cur, /* The cursor */ 179 + sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ 180 + int i /* Which column to return */ 181 +){ 182 + series_cursor *pCur = (series_cursor*)cur; 183 + sqlite3_int64 x = 0; 184 + switch( i ){ 185 + case SERIES_COLUMN_START: x = pCur->mnValue; break; 186 + case SERIES_COLUMN_STOP: x = pCur->mxValue; break; 187 + case SERIES_COLUMN_STEP: x = pCur->iStep; break; 188 + default: x = pCur->iValue; break; 189 + } 190 + sqlite3_result_int64(ctx, x); 191 + return SQLITE_OK; 192 +} 193 + 194 +/* 195 +** Return the rowid for the current row. In this implementation, the 196 +** rowid is the same as the output value. 197 +*/ 198 +static int seriesRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ 199 + series_cursor *pCur = (series_cursor*)cur; 200 + *pRowid = pCur->iRowid; 201 + return SQLITE_OK; 202 +} 203 + 204 +/* 205 +** Return TRUE if the cursor has been moved off of the last 206 +** row of output. 207 +*/ 208 +static int seriesEof(sqlite3_vtab_cursor *cur){ 209 + series_cursor *pCur = (series_cursor*)cur; 210 + if( pCur->isDesc ){ 211 + return pCur->iValue < pCur->mnValue; 212 + }else{ 213 + return pCur->iValue > pCur->mxValue; 214 + } 215 +} 216 + 217 +/* 218 +** This method is called to "rewind" the series_cursor object back 219 +** to the first row of output. This method is always called at least 220 +** once prior to any call to seriesColumn() or seriesRowid() or 221 +** seriesEof(). 222 +** 223 +** The query plan selected by seriesBestIndex is passed in the idxNum 224 +** parameter. (idxStr is not used in this implementation.) idxNum 225 +** is a bitmask showing which constraints are available: 226 +** 227 +** 1: start=VALUE 228 +** 2: stop=VALUE 229 +** 4: step=VALUE 230 +** 231 +** Also, if bit 8 is set, that means that the series should be output 232 +** in descending order rather than in ascending order. 233 +** 234 +** This routine should initialize the cursor and position it so that it 235 +** is pointing at the first row, or pointing off the end of the table 236 +** (so that seriesEof() will return true) if the table is empty. 237 +*/ 238 +static int seriesFilter( 239 + sqlite3_vtab_cursor *pVtabCursor, 240 + int idxNum, const char *idxStr, 241 + int argc, sqlite3_value **argv 242 +){ 243 + series_cursor *pCur = (series_cursor *)pVtabCursor; 244 + int i = 0; 245 + if( idxNum & 1 ){ 246 + pCur->mnValue = sqlite3_value_int64(argv[i++]); 247 + }else{ 248 + pCur->mnValue = 0; 249 + } 250 + if( idxNum & 2 ){ 251 + pCur->mxValue = sqlite3_value_int64(argv[i++]); 252 + }else{ 253 + pCur->mxValue = 0xffffffff; 254 + } 255 + if( idxNum & 4 ){ 256 + pCur->iStep = sqlite3_value_int64(argv[i++]); 257 + if( pCur->iStep<1 ) pCur->iStep = 1; 258 + }else{ 259 + pCur->iStep = 1; 260 + } 261 + if( idxNum & 8 ){ 262 + pCur->isDesc = 1; 263 + pCur->iValue = pCur->mxValue; 264 + if( pCur->iStep>0 ){ 265 + pCur->iValue -= (pCur->mxValue - pCur->mnValue)%pCur->iStep; 266 + } 267 + }else{ 268 + pCur->isDesc = 0; 269 + pCur->iValue = pCur->mnValue; 270 + } 271 + pCur->iRowid = 1; 272 + return SQLITE_OK; 273 +} 274 + 275 +/* 276 +** SQLite will invoke this method one or more times while planning a query 277 +** that uses the generate_series virtual table. This routine needs to create 278 +** a query plan for each invocation and compute an estimated cost for that 279 +** plan. 280 +** 281 +** In this implementation idxNum is used to represent the 282 +** query plan. idxStr is unused. 283 +** 284 +** The query plan is represented by bits in idxNum: 285 +** 286 +** (1) start = $value -- constraint exists 287 +** (2) stop = $value -- constraint exists 288 +** (4) step = $value -- constraint exists 289 +** (8) output in descending order 290 +*/ 291 +static int seriesBestIndex( 292 + sqlite3_vtab *tab, 293 + sqlite3_index_info *pIdxInfo 294 +){ 295 + int i; /* Loop over constraints */ 296 + int idxNum = 0; /* The query plan bitmask */ 297 + int startIdx = -1; /* Index of the start= constraint, or -1 if none */ 298 + int stopIdx = -1; /* Index of the stop= constraint, or -1 if none */ 299 + int stepIdx = -1; /* Index of the step= constraint, or -1 if none */ 300 + int nArg = 0; /* Number of arguments that seriesFilter() expects */ 301 + 302 + const struct sqlite3_index_constraint *pConstraint; 303 + pConstraint = pIdxInfo->aConstraint; 304 + for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){ 305 + if( pConstraint->usable==0 ) continue; 306 + if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue; 307 + switch( pConstraint->iColumn ){ 308 + case SERIES_COLUMN_START: 309 + startIdx = i; 310 + idxNum |= 1; 311 + break; 312 + case SERIES_COLUMN_STOP: 313 + stopIdx = i; 314 + idxNum |= 2; 315 + break; 316 + case SERIES_COLUMN_STEP: 317 + stepIdx = i; 318 + idxNum |= 4; 319 + break; 320 + } 321 + } 322 + if( startIdx>=0 ){ 323 + pIdxInfo->aConstraintUsage[startIdx].argvIndex = ++nArg; 324 + pIdxInfo->aConstraintUsage[startIdx].omit = 1; 325 + } 326 + if( stopIdx>=0 ){ 327 + pIdxInfo->aConstraintUsage[stopIdx].argvIndex = ++nArg; 328 + pIdxInfo->aConstraintUsage[stopIdx].omit = 1; 329 + } 330 + if( stepIdx>=0 ){ 331 + pIdxInfo->aConstraintUsage[stepIdx].argvIndex = ++nArg; 332 + pIdxInfo->aConstraintUsage[stepIdx].omit = 1; 333 + } 334 + if( pIdxInfo->nOrderBy==1 ){ 335 + if( pIdxInfo->aOrderBy[0].desc ) idxNum |= 8; 336 + pIdxInfo->orderByConsumed = 1; 337 + } 338 + if( (idxNum & 3)==3 ){ 339 + /* Both start= and stop= boundaries are available. This is the 340 + ** the preferred case */ 341 + pIdxInfo->estimatedCost = (double)1; 342 + }else{ 343 + /* If either boundary is missing, we have to generate a huge span 344 + ** of numbers. Make this case very expensive so that the query 345 + ** planner will work hard to avoid it. */ 346 + pIdxInfo->estimatedCost = (double)2000000000; 347 + } 348 + pIdxInfo->idxNum = idxNum; 349 + return SQLITE_OK; 350 +} 351 + 352 +/* 353 +** This following structure defines all the methods for the 354 +** generate_series virtual table. 355 +*/ 356 +static sqlite3_module seriesModule = { 357 + 0, /* iVersion */ 358 + 0, /* xCreate */ 359 + seriesConnect, /* xConnect */ 360 + seriesBestIndex, /* xBestIndex */ 361 + seriesDisconnect, /* xDisconnect */ 362 + 0, /* xDestroy */ 363 + seriesOpen, /* xOpen - open a cursor */ 364 + seriesClose, /* xClose - close a cursor */ 365 + seriesFilter, /* xFilter - configure scan constraints */ 366 + seriesNext, /* xNext - advance a cursor */ 367 + seriesEof, /* xEof - check for end of scan */ 368 + seriesColumn, /* xColumn - read data */ 369 + seriesRowid, /* xRowid - read data */ 370 + 0, /* xUpdate */ 371 + 0, /* xBegin */ 372 + 0, /* xSync */ 373 + 0, /* xCommit */ 374 + 0, /* xRollback */ 375 + 0, /* xFindMethod */ 376 + 0, /* xRename */ 377 +}; 378 + 379 +#endif /* SQLITE_OMIT_VIRTUALTABLE */ 380 + 381 +#ifdef _WIN32 382 +__declspec(dllexport) 383 +#endif 384 +int sqlite3_series_init( 385 + sqlite3 *db, 386 + char **pzErrMsg, 387 + const sqlite3_api_routines *pApi 388 +){ 389 + int rc = SQLITE_OK; 390 + SQLITE_EXTENSION_INIT2(pApi); 391 +#ifndef SQLITE_OMIT_VIRTUALTABLE 392 + if( sqlite3_libversion_number()<3008012 ){ 393 + *pzErrMsg = sqlite3_mprintf( 394 + "generate_series() requires SQLite 3.8.12 or later"); 395 + return SQLITE_ERROR; 396 + } 397 + rc = sqlite3_create_module(db, "generate_series", &seriesModule, 0); 398 +#endif 399 + return rc; 400 +}
Changes to main.mk.
296 296 $(TOP)/ext/misc/eval.c \ 297 297 $(TOP)/ext/misc/fileio.c \ 298 298 $(TOP)/ext/misc/fuzzer.c \ 299 299 $(TOP)/ext/misc/ieee754.c \ 300 300 $(TOP)/ext/misc/nextchar.c \ 301 301 $(TOP)/ext/misc/percentile.c \ 302 302 $(TOP)/ext/misc/regexp.c \ 303 + $(TOP)/ext/misc/series.c \ 303 304 $(TOP)/ext/misc/spellfix.c \ 304 305 $(TOP)/ext/misc/totype.c \ 305 306 $(TOP)/ext/misc/wholenumber.c \ 306 307 $(TOP)/ext/misc/vfslog.c \ 307 308 $(TOP)/ext/fts5/fts5_tcl.c \ 308 309 $(TOP)/ext/fts5/fts5_test_mi.c \ 309 310 fts5.c
Changes to src/build.c.
351 351 ** and code in pParse and return NULL. */ 352 352 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ 353 353 return 0; 354 354 } 355 355 356 356 p = sqlite3FindTable(pParse->db, zName, zDbase); 357 357 if( p==0 ){ 358 +#ifndef SQLITE_OMIT_VIRTUAL_TABLE 359 + /* If zName is the not the name of a table in the schema created using 360 + ** CREATE, then check to see if it is the name of an virtual table that 361 + ** can be an eponymous virtual table. */ 362 + Module *pMod = (Module*)sqlite3HashFind(&pParse->db->aModule, zName); 363 + if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){ 364 + return pMod->pEpoTab; 365 + } 366 +#endif 358 367 const char *zMsg = isView ? "no such view" : "no such table"; 359 368 if( zDbase ){ 360 369 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName); 361 370 }else{ 362 371 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName); 363 372 } 364 373 pParse->checkSchema = 1; ................................................................................ 556 565 db->flags &= ~SQLITE_InternChanges; 557 566 } 558 567 559 568 /* 560 569 ** Delete memory allocated for the column names of a table or view (the 561 570 ** Table.aCol[] array). 562 571 */ 563 -static void sqliteDeleteColumnNames(sqlite3 *db, Table *pTable){ 572 +void sqlite3DeleteColumnNames(sqlite3 *db, Table *pTable){ 564 573 int i; 565 574 Column *pCol; 566 575 assert( pTable!=0 ); 567 576 if( (pCol = pTable->aCol)!=0 ){ 568 577 for(i=0; i<pTable->nCol; i++, pCol++){ 569 578 sqlite3DbFree(db, pCol->zName); 570 579 sqlite3ExprDelete(db, pCol->pDflt); ................................................................................ 623 632 } 624 633 625 634 /* Delete any foreign keys attached to this table. */ 626 635 sqlite3FkDelete(db, pTable); 627 636 628 637 /* Delete the Table structure itself. 629 638 */ 630 - sqliteDeleteColumnNames(db, pTable); 639 + sqlite3DeleteColumnNames(db, pTable); 631 640 sqlite3DbFree(db, pTable->zName); 632 641 sqlite3DbFree(db, pTable->zColAff); 633 642 sqlite3SelectDelete(db, pTable->pSelect); 634 643 #ifndef SQLITE_OMIT_CHECK 635 644 sqlite3ExprListDelete(db, pTable->pCheck); 636 645 #endif 637 646 #ifndef SQLITE_OMIT_VIRTUALTABLE ................................................................................ 2214 2223 static void sqliteViewResetAll(sqlite3 *db, int idx){ 2215 2224 HashElem *i; 2216 2225 assert( sqlite3SchemaMutexHeld(db, idx, 0) ); 2217 2226 if( !DbHasProperty(db, idx, DB_UnresetViews) ) return; 2218 2227 for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){ 2219 2228 Table *pTab = sqliteHashData(i); 2220 2229 if( pTab->pSelect ){ 2221 - sqliteDeleteColumnNames(db, pTab); 2230 + sqlite3DeleteColumnNames(db, pTab); 2222 2231 pTab->aCol = 0; 2223 2232 pTab->nCol = 0; 2224 2233 } 2225 2234 } 2226 2235 DbClearProperty(db, idx, DB_UnresetViews); 2227 2236 } 2228 2237 #else ................................................................................ 3696 3705 int i; 3697 3706 struct SrcList_item *pItem; 3698 3707 if( pList==0 ) return; 3699 3708 for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){ 3700 3709 sqlite3DbFree(db, pItem->zDatabase); 3701 3710 sqlite3DbFree(db, pItem->zName); 3702 3711 sqlite3DbFree(db, pItem->zAlias); 3703 - sqlite3DbFree(db, pItem->zIndexedBy); 3712 + if( pItem->fg.isIndexedBy ) sqlite3DbFree(db, pItem->u1.zIndexedBy); 3713 + if( pItem->fg.isTabFunc ) sqlite3ExprListDelete(db, pItem->u1.pFuncArg); 3704 3714 sqlite3DeleteTable(db, pItem->pTab); 3705 3715 sqlite3SelectDelete(db, pItem->pSelect); 3706 3716 sqlite3ExprDelete(db, pItem->pOn); 3707 3717 sqlite3IdListDelete(db, pItem->pUsing); 3708 3718 } 3709 3719 sqlite3DbFree(db, pList); 3710 3720 } ................................................................................ 3769 3779 ** Add an INDEXED BY or NOT INDEXED clause to the most recently added 3770 3780 ** element of the source-list passed as the second argument. 3771 3781 */ 3772 3782 void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){ 3773 3783 assert( pIndexedBy!=0 ); 3774 3784 if( p && ALWAYS(p->nSrc>0) ){ 3775 3785 struct SrcList_item *pItem = &p->a[p->nSrc-1]; 3776 - assert( pItem->notIndexed==0 && pItem->zIndexedBy==0 ); 3786 + assert( pItem->fg.notIndexed==0 ); 3787 + assert( pItem->fg.isIndexedBy==0 ); 3788 + assert( pItem->fg.isTabFunc==0 ); 3777 3789 if( pIndexedBy->n==1 && !pIndexedBy->z ){ 3778 3790 /* A "NOT INDEXED" clause was supplied. See parse.y 3779 3791 ** construct "indexed_opt" for details. */ 3780 - pItem->notIndexed = 1; 3792 + pItem->fg.notIndexed = 1; 3781 3793 }else{ 3782 - pItem->zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy); 3794 + pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy); 3795 + pItem->fg.isIndexedBy = (pItem->u1.zIndexedBy!=0); 3783 3796 } 3784 3797 } 3785 3798 } 3799 + 3800 +/* 3801 +** Add the list of function arguments to the SrcList entry for a 3802 +** table-valued-function. 3803 +*/ 3804 +void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){ 3805 + if( p && ALWAYS(p->nSrc>0) ){ 3806 + struct SrcList_item *pItem = &p->a[p->nSrc-1]; 3807 + assert( pItem->fg.notIndexed==0 ); 3808 + assert( pItem->fg.isIndexedBy==0 ); 3809 + assert( pItem->fg.isTabFunc==0 ); 3810 + pItem->u1.pFuncArg = pList; 3811 + pItem->fg.isTabFunc = 1; 3812 + } 3813 +} 3786 3814 3787 3815 /* 3788 3816 ** When building up a FROM clause in the parser, the join operator 3789 3817 ** is initially attached to the left operand. But the code generator 3790 3818 ** expects the join operator to be on the right operand. This routine 3791 3819 ** Shifts all join operators from left to right for an entire FROM 3792 3820 ** clause. ................................................................................ 3799 3827 ** in p->a[0] and p->a[1], respectively. The parser initially stores the 3800 3828 ** operator with A. This routine shifts that operator over to B. 3801 3829 */ 3802 3830 void sqlite3SrcListShiftJoinType(SrcList *p){ 3803 3831 if( p ){ 3804 3832 int i; 3805 3833 for(i=p->nSrc-1; i>0; i--){ 3806 - p->a[i].jointype = p->a[i-1].jointype; 3834 + p->a[i].fg.jointype = p->a[i-1].fg.jointype; 3807 3835 } 3808 - p->a[0].jointype = 0; 3836 + p->a[0].fg.jointype = 0; 3809 3837 } 3810 3838 } 3811 3839 3812 3840 /* 3813 3841 ** Begin a transaction 3814 3842 */ 3815 3843 void sqlite3BeginTransaction(Parse *pParse, int type){
Changes to src/expr.c.
1030 1030 struct SrcList_item *pNewItem = &pNew->a[i]; 1031 1031 struct SrcList_item *pOldItem = &p->a[i]; 1032 1032 Table *pTab; 1033 1033 pNewItem->pSchema = pOldItem->pSchema; 1034 1034 pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase); 1035 1035 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName); 1036 1036 pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias); 1037 - pNewItem->jointype = pOldItem->jointype; 1037 + pNewItem->fg = pOldItem->fg; 1038 1038 pNewItem->iCursor = pOldItem->iCursor; 1039 1039 pNewItem->addrFillSub = pOldItem->addrFillSub; 1040 1040 pNewItem->regReturn = pOldItem->regReturn; 1041 - pNewItem->isCorrelated = pOldItem->isCorrelated; 1042 - pNewItem->viaCoroutine = pOldItem->viaCoroutine; 1043 - pNewItem->isRecursive = pOldItem->isRecursive; 1044 - pNewItem->zIndexedBy = sqlite3DbStrDup(db, pOldItem->zIndexedBy); 1045 - pNewItem->notIndexed = pOldItem->notIndexed; 1046 - pNewItem->pIndex = pOldItem->pIndex; 1041 + if( pNewItem->fg.isIndexedBy ){ 1042 + pNewItem->u1.zIndexedBy = sqlite3DbStrDup(db, pOldItem->u1.zIndexedBy); 1043 + } 1044 + pNewItem->pIBIndex = pOldItem->pIBIndex; 1045 + if( pNewItem->fg.isTabFunc ){ 1046 + pNewItem->u1.pFuncArg = 1047 + sqlite3ExprListDup(db, pOldItem->u1.pFuncArg, flags); 1048 + } 1047 1049 pTab = pNewItem->pTab = pOldItem->pTab; 1048 1050 if( pTab ){ 1049 1051 pTab->nRef++; 1050 1052 } 1051 1053 pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags); 1052 1054 pNewItem->pOn = sqlite3ExprDup(db, pOldItem->pOn, flags); 1053 1055 pNewItem->pUsing = sqlite3IdListDup(db, pOldItem->pUsing);
Changes to src/main.c.
928 928 /* 929 929 ** Disconnect all sqlite3_vtab objects that belong to database connection 930 930 ** db. This is called when db is being closed. 931 931 */ 932 932 static void disconnectAllVtab(sqlite3 *db){ 933 933 #ifndef SQLITE_OMIT_VIRTUALTABLE 934 934 int i; 935 + HashElem *p; 935 936 sqlite3BtreeEnterAll(db); 936 937 for(i=0; i<db->nDb; i++){ 937 938 Schema *pSchema = db->aDb[i].pSchema; 938 939 if( db->aDb[i].pSchema ){ 939 - HashElem *p; 940 940 for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){ 941 941 Table *pTab = (Table *)sqliteHashData(p); 942 942 if( IsVirtual(pTab) ) sqlite3VtabDisconnect(db, pTab); 943 943 } 944 944 } 945 + } 946 + for(p=sqliteHashFirst(&db->aModule); p; p=sqliteHashNext(p)){ 947 + Module *pMod = (Module *)sqliteHashData(p); 948 + if( pMod->pEpoTab ){ 949 + sqlite3VtabDisconnect(db, pMod->pEpoTab); 950 + } 945 951 } 946 952 sqlite3VtabUnlockList(db); 947 953 sqlite3BtreeLeaveAll(db); 948 954 #else 949 955 UNUSED_PARAMETER(db); 950 956 #endif 951 957 } ................................................................................ 1116 1122 sqlite3HashClear(&db->aCollSeq); 1117 1123 #ifndef SQLITE_OMIT_VIRTUALTABLE 1118 1124 for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){ 1119 1125 Module *pMod = (Module *)sqliteHashData(i); 1120 1126 if( pMod->xDestroy ){ 1121 1127 pMod->xDestroy(pMod->pAux); 1122 1128 } 1129 + sqlite3VtabEponymousTableClear(db, pMod); 1123 1130 sqlite3DbFree(db, pMod); 1124 1131 } 1125 1132 sqlite3HashClear(&db->aModule); 1126 1133 #endif 1127 1134 1128 1135 sqlite3Error(db, SQLITE_OK); /* Deallocates any cached error strings. */ 1129 1136 sqlite3ValueFree(db->pErr);
Changes to src/parse.y.
582 582 } 583 583 584 584 // "seltablist" is a "Select Table List" - the content of the FROM clause 585 585 // in a SELECT statement. "stl_prefix" is a prefix of this list. 586 586 // 587 587 stl_prefix(A) ::= seltablist(X) joinop(Y). { 588 588 A = X; 589 - if( ALWAYS(A && A->nSrc>0) ) A->a[A->nSrc-1].jointype = (u8)Y; 589 + if( ALWAYS(A && A->nSrc>0) ) A->a[A->nSrc-1].fg.jointype = (u8)Y; 590 590 } 591 591 stl_prefix(A) ::= . {A = 0;} 592 592 seltablist(A) ::= stl_prefix(X) nm(Y) dbnm(D) as(Z) indexed_opt(I) 593 593 on_opt(N) using_opt(U). { 594 594 A = sqlite3SrcListAppendFromTerm(pParse,X,&Y,&D,&Z,0,N,U); 595 595 sqlite3SrcListIndexedBy(pParse, A, &I); 596 +} 597 +seltablist(A) ::= stl_prefix(X) nm(Y) dbnm(D) LP exprlist(E) RP as(Z) 598 + on_opt(N) using_opt(U). { 599 + A = sqlite3SrcListAppendFromTerm(pParse,X,&Y,&D,&Z,0,N,U); 600 + sqlite3SrcListFuncArgs(pParse, A, E); 596 601 } 597 602 %ifndef SQLITE_OMIT_SUBQUERY 598 603 seltablist(A) ::= stl_prefix(X) LP select(S) RP 599 604 as(Z) on_opt(N) using_opt(U). { 600 605 A = sqlite3SrcListAppendFromTerm(pParse,X,0,0,&Z,S,N,U); 601 606 } 602 607 seltablist(A) ::= stl_prefix(X) LP seltablist(F) RP
Changes to src/resolve.c.
302 302 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){ 303 303 if( sqlite3StrICmp(pCol->zName, zCol)==0 ){ 304 304 /* If there has been exactly one prior match and this match 305 305 ** is for the right-hand table of a NATURAL JOIN or is in a 306 306 ** USING clause, then skip this match. 307 307 */ 308 308 if( cnt==1 ){ 309 - if( pItem->jointype & JT_NATURAL ) continue; 309 + if( pItem->fg.jointype & JT_NATURAL ) continue; 310 310 if( nameInUsingClause(pItem->pUsing, zCol) ) continue; 311 311 } 312 312 cnt++; 313 313 pMatch = pItem; 314 314 /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */ 315 315 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j; 316 316 break; ................................................................................ 317 317 } 318 318 } 319 319 } 320 320 if( pMatch ){ 321 321 pExpr->iTable = pMatch->iCursor; 322 322 pExpr->pTab = pMatch->pTab; 323 323 /* RIGHT JOIN not (yet) supported */ 324 - assert( (pMatch->jointype & JT_RIGHT)==0 ); 325 - if( (pMatch->jointype & JT_LEFT)!=0 ){ 324 + assert( (pMatch->fg.jointype & JT_RIGHT)==0 ); 325 + if( (pMatch->fg.jointype & JT_LEFT)!=0 ){ 326 326 ExprSetProperty(pExpr, EP_CanBeNull); 327 327 } 328 328 pSchema = pExpr->pTab->pSchema; 329 329 } 330 330 } /* if( pSrcList ) */ 331 331 332 332 #ifndef SQLITE_OMIT_TRIGGER ................................................................................ 1138 1138 */ 1139 1139 static int resolveSelectStep(Walker *pWalker, Select *p){ 1140 1140 NameContext *pOuterNC; /* Context that contains this SELECT */ 1141 1141 NameContext sNC; /* Name context of this SELECT */ 1142 1142 int isCompound; /* True if p is a compound select */ 1143 1143 int nCompound; /* Number of compound terms processed so far */ 1144 1144 Parse *pParse; /* Parsing context */ 1145 - ExprList *pEList; /* Result set expression list */ 1146 1145 int i; /* Loop counter */ 1147 1146 ExprList *pGroupBy; /* The GROUP BY clause */ 1148 1147 Select *pLeftmost; /* Left-most of SELECT of a compound */ 1149 1148 sqlite3 *db; /* Database connection */ 1150 1149 1151 1150 1152 1151 assert( p!=0 ); ................................................................................ 1211 1210 int nRef = 0; /* Refcount for pOuterNC and outer contexts */ 1212 1211 const char *zSavedContext = pParse->zAuthContext; 1213 1212 1214 1213 /* Count the total number of references to pOuterNC and all of its 1215 1214 ** parent contexts. After resolving references to expressions in 1216 1215 ** pItem->pSelect, check if this value has changed. If so, then 1217 1216 ** SELECT statement pItem->pSelect must be correlated. Set the 1218 - ** pItem->isCorrelated flag if this is the case. */ 1217 + ** pItem->fg.isCorrelated flag if this is the case. */ 1219 1218 for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef += pNC->nRef; 1220 1219 1221 1220 if( pItem->zName ) pParse->zAuthContext = pItem->zName; 1222 1221 sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC); 1223 1222 pParse->zAuthContext = zSavedContext; 1224 1223 if( pParse->nErr || db->mallocFailed ) return WRC_Abort; 1225 1224 1226 1225 for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef -= pNC->nRef; 1227 - assert( pItem->isCorrelated==0 && nRef<=0 ); 1228 - pItem->isCorrelated = (nRef!=0); 1226 + assert( pItem->fg.isCorrelated==0 && nRef<=0 ); 1227 + pItem->fg.isCorrelated = (nRef!=0); 1229 1228 } 1230 1229 } 1231 1230 1232 1231 /* Set up the local name-context to pass to sqlite3ResolveExprNames() to 1233 1232 ** resolve the result-set expression list. 1234 1233 */ 1235 1234 sNC.ncFlags = NC_AllowAgg; 1236 1235 sNC.pSrcList = p->pSrc; 1237 1236 sNC.pNext = pOuterNC; 1238 1237 1239 1238 /* Resolve names in the result set. */ 1240 - pEList = p->pEList; 1241 - assert( pEList!=0 ); 1242 - for(i=0; i<pEList->nExpr; i++){ 1243 - Expr *pX = pEList->a[i].pExpr; 1244 - if( sqlite3ResolveExprNames(&sNC, pX) ){ 1245 - return WRC_Abort; 1246 - } 1247 - } 1239 + if( sqlite3ResolveExprListNames(&sNC, p->pEList) ) return WRC_Abort; 1248 1240 1249 1241 /* If there are no aggregate functions in the result-set, and no GROUP BY 1250 1242 ** expression, do not allow aggregates in any of the other expressions. 1251 1243 */ 1252 1244 assert( (p->selFlags & SF_Aggregate)==0 ); 1253 1245 pGroupBy = p->pGroupBy; 1254 1246 if( pGroupBy || (sNC.ncFlags & NC_HasAgg)!=0 ){ ................................................................................ 1272 1264 ** 1273 1265 ** Minor point: If this is the case, then the expression will be 1274 1266 ** re-evaluated for each reference to it. 1275 1267 */ 1276 1268 sNC.pEList = p->pEList; 1277 1269 if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort; 1278 1270 if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort; 1271 + 1272 + /* Resolve names in table-valued-function arguments */ 1273 + for(i=0; i<p->pSrc->nSrc; i++){ 1274 + struct SrcList_item *pItem = &p->pSrc->a[i]; 1275 + if( pItem->fg.isTabFunc 1276 + && sqlite3ResolveExprListNames(&sNC, pItem->u1.pFuncArg) 1277 + ){ 1278 + return WRC_Abort; 1279 + } 1280 + } 1279 1281 1280 1282 /* The ORDER BY and GROUP BY clauses may not refer to terms in 1281 1283 ** outer queries 1282 1284 */ 1283 1285 sNC.pNext = 0; 1284 1286 sNC.ncFlags |= NC_AllowAgg; 1285 1287 ................................................................................ 1436 1438 if( pNC->ncFlags & NC_HasAgg ){ 1437 1439 ExprSetProperty(pExpr, EP_Agg); 1438 1440 } 1439 1441 pNC->ncFlags |= savedHasAgg; 1440 1442 return ExprHasProperty(pExpr, EP_Error); 1441 1443 } 1442 1444 1445 +/* 1446 +** Resolve all names for all expression in an expression list. This is 1447 +** just like sqlite3ResolveExprNames() except that it works for an expression 1448 +** list rather than a single expression. 1449 +*/ 1450 +int sqlite3ResolveExprListNames( 1451 + NameContext *pNC, /* Namespace to resolve expressions in. */ 1452 + ExprList *pList /* The expression list to be analyzed. */ 1453 +){ 1454 + int i; 1455 + for(i=0; i<pList->nExpr; i++){ 1456 + if( sqlite3ResolveExprNames(pNC, pList->a[i].pExpr) ) return WRC_Abort; 1457 + } 1458 + return WRC_Continue; 1459 +} 1443 1460 1444 1461 /* 1445 1462 ** Resolve all names in all expressions of a SELECT and in all 1446 1463 ** decendents of the SELECT, including compounds off of p->pPrior, 1447 1464 ** subqueries in expressions, and subqueries used as FROM clause 1448 1465 ** terms. 1449 1466 **
Changes to src/select.c.
402 402 pRight = &pLeft[1]; 403 403 for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){ 404 404 Table *pLeftTab = pLeft->pTab; 405 405 Table *pRightTab = pRight->pTab; 406 406 int isOuter; 407 407 408 408 if( NEVER(pLeftTab==0 || pRightTab==0) ) continue; 409 - isOuter = (pRight->jointype & JT_OUTER)!=0; 409 + isOuter = (pRight->fg.jointype & JT_OUTER)!=0; 410 410 411 411 /* When the NATURAL keyword is present, add WHERE clause terms for 412 412 ** every column that the two tables have in common. 413 413 */ 414 - if( pRight->jointype & JT_NATURAL ){ 414 + if( pRight->fg.jointype & JT_NATURAL ){ 415 415 if( pRight->pOn || pRight->pUsing ){ 416 416 sqlite3ErrorMsg(pParse, "a NATURAL join may not have " 417 417 "an ON or USING clause", 0); 418 418 return 1; 419 419 } 420 420 for(j=0; j<pRightTab->nCol; j++){ 421 421 char *zName; /* Name of column in the right table */ ................................................................................ 1929 1929 ** 1930 1930 ** <recursive-table> AS (<setup-query> UNION [ALL] <recursive-query>) 1931 1931 ** \___________/ \_______________/ 1932 1932 ** p->pPrior p 1933 1933 ** 1934 1934 ** 1935 1935 ** There is exactly one reference to the recursive-table in the FROM clause 1936 -** of recursive-query, marked with the SrcList->a[].isRecursive flag. 1936 +** of recursive-query, marked with the SrcList->a[].fg.isRecursive flag. 1937 1937 ** 1938 1938 ** The setup-query runs once to generate an initial set of rows that go 1939 1939 ** into a Queue table. Rows are extracted from the Queue table one by 1940 1940 ** one. Each row extracted from Queue is output to pDest. Then the single 1941 1941 ** extracted row (now in the iCurrent table) becomes the content of the 1942 1942 ** recursive-table for a recursive-query run. The output of the recursive-query 1943 1943 ** is added back into the Queue table. Then another row is extracted from Queue ................................................................................ 1994 1994 regOffset = p->iOffset; 1995 1995 p->pLimit = p->pOffset = 0; 1996 1996 p->iLimit = p->iOffset = 0; 1997 1997 pOrderBy = p->pOrderBy; 1998 1998 1999 1999 /* Locate the cursor number of the Current table */ 2000 2000 for(i=0; ALWAYS(i<pSrc->nSrc); i++){ 2001 - if( pSrc->a[i].isRecursive ){ 2001 + if( pSrc->a[i].fg.isRecursive ){ 2002 2002 iCurrent = pSrc->a[i].iCursor; 2003 2003 break; 2004 2004 } 2005 2005 } 2006 2006 2007 2007 /* Allocate cursors numbers for Queue and Distinct. The cursor number for 2008 2008 ** the Distinct table must be exactly one greater than Queue in order ................................................................................ 3409 3409 ** effectively converts the OUTER JOIN into an INNER JOIN. 3410 3410 ** 3411 3411 ** THIS OVERRIDES OBSOLETE COMMENTS 1 AND 2 ABOVE: 3412 3412 ** Ticket #3300 shows that flattening the right term of a LEFT JOIN 3413 3413 ** is fraught with danger. Best to avoid the whole thing. If the 3414 3414 ** subquery is the right term of a LEFT JOIN, then do not flatten. 3415 3415 */ 3416 - if( (pSubitem->jointype & JT_OUTER)!=0 ){ 3416 + if( (pSubitem->fg.jointype & JT_OUTER)!=0 ){ 3417 3417 return 0; 3418 3418 } 3419 3419 3420 3420 /* Restriction 17: If the sub-query is a compound SELECT, then it must 3421 3421 ** use only the UNION ALL operator. And none of the simple select queries 3422 3422 ** that make up the compound SELECT are allowed to be aggregate or distinct 3423 3423 ** queries. ................................................................................ 3580 3580 u8 jointype = 0; 3581 3581 pSubSrc = pSub->pSrc; /* FROM clause of subquery */ 3582 3582 nSubSrc = pSubSrc->nSrc; /* Number of terms in subquery FROM clause */ 3583 3583 pSrc = pParent->pSrc; /* FROM clause of the outer query */ 3584 3584 3585 3585 if( pSrc ){ 3586 3586 assert( pParent==p ); /* First time through the loop */ 3587 - jointype = pSubitem->jointype; 3587 + jointype = pSubitem->fg.jointype; 3588 3588 }else{ 3589 3589 assert( pParent!=p ); /* 2nd and subsequent times through the loop */ 3590 3590 pSrc = pParent->pSrc = sqlite3SrcListAppend(db, 0, 0, 0); 3591 3591 if( pSrc==0 ){ 3592 3592 assert( db->mallocFailed ); 3593 3593 break; 3594 3594 } ................................................................................ 3620 3620 ** outer query. 3621 3621 */ 3622 3622 for(i=0; i<nSubSrc; i++){ 3623 3623 sqlite3IdListDelete(db, pSrc->a[i+iFrom].pUsing); 3624 3624 pSrc->a[i+iFrom] = pSubSrc->a[i]; 3625 3625 memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i])); 3626 3626 } 3627 - pSrc->a[iFrom].jointype = jointype; 3627 + pSrc->a[iFrom].fg.jointype = jointype; 3628 3628 3629 3629 /* Now begin substituting subquery result set expressions for 3630 3630 ** references to the iParent in the outer query. 3631 3631 ** 3632 3632 ** Example: 3633 3633 ** 3634 3634 ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b; ................................................................................ 3871 3871 ** If the source-list item passed as an argument was augmented with an 3872 3872 ** INDEXED BY clause, then try to locate the specified index. If there 3873 3873 ** was such a clause and the named index cannot be found, return 3874 3874 ** SQLITE_ERROR and leave an error in pParse. Otherwise, populate 3875 3875 ** pFrom->pIndex and return SQLITE_OK. 3876 3876 */ 3877 3877 int sqlite3IndexedByLookup(Parse *pParse, struct SrcList_item *pFrom){ 3878 - if( pFrom->pTab && pFrom->zIndexedBy ){ 3878 + if( pFrom->pTab && pFrom->fg.isIndexedBy ){ 3879 3879 Table *pTab = pFrom->pTab; 3880 - char *zIndexedBy = pFrom->zIndexedBy; 3880 + char *zIndexedBy = pFrom->u1.zIndexedBy; 3881 3881 Index *pIdx; 3882 3882 for(pIdx=pTab->pIndex; 3883 3883 pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy); 3884 3884 pIdx=pIdx->pNext 3885 3885 ); 3886 3886 if( !pIdx ){ 3887 3887 sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy, 0); 3888 3888 pParse->checkSchema = 1; 3889 3889 return SQLITE_ERROR; 3890 3890 } 3891 - pFrom->pIndex = pIdx; 3891 + pFrom->pIBIndex = pIdx; 3892 3892 } 3893 3893 return SQLITE_OK; 3894 3894 } 3895 3895 /* 3896 3896 ** Detect compound SELECT statements that use an ORDER BY clause with 3897 3897 ** an alternative collating sequence. 3898 3898 ** ................................................................................ 4079 4079 for(i=0; i<pSrc->nSrc; i++){ 4080 4080 struct SrcList_item *pItem = &pSrc->a[i]; 4081 4081 if( pItem->zDatabase==0 4082 4082 && pItem->zName!=0 4083 4083 && 0==sqlite3StrICmp(pItem->zName, pCte->zName) 4084 4084 ){ 4085 4085 pItem->pTab = pTab; 4086 - pItem->isRecursive = 1; 4086 + pItem->fg.isRecursive = 1; 4087 4087 pTab->nRef++; 4088 4088 pSel->selFlags |= SF_Recursive; 4089 4089 } 4090 4090 } 4091 4091 } 4092 4092 4093 4093 /* Only one recursive reference is permitted. */ ................................................................................ 4209 4209 4210 4210 /* Look up every table named in the FROM clause of the select. If 4211 4211 ** an entry of the FROM clause is a subquery instead of a table or view, 4212 4212 ** then create a transient table structure to describe the subquery. 4213 4213 */ 4214 4214 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){ 4215 4215 Table *pTab; 4216 - assert( pFrom->isRecursive==0 || pFrom->pTab ); 4217 - if( pFrom->isRecursive ) continue; 4216 + assert( pFrom->fg.isRecursive==0 || pFrom->pTab ); 4217 + if( pFrom->fg.isRecursive ) continue; 4218 4218 if( pFrom->pTab!=0 ){ 4219 4219 /* This statement has already been prepared. There is no need 4220 4220 ** to go further. */ 4221 4221 assert( i==0 ); 4222 4222 #ifndef SQLITE_OMIT_CTE 4223 4223 selectPopWith(pWalker, p); 4224 4224 #endif ................................................................................ 4373 4373 if( IsHiddenColumn(&pTab->aCol[j]) ){ 4374 4374 assert(IsVirtual(pTab)); 4375 4375 continue; 4376 4376 } 4377 4377 tableSeen = 1; 4378 4378 4379 4379 if( i>0 && zTName==0 ){ 4380 - if( (pFrom->jointype & JT_NATURAL)!=0 4380 + if( (pFrom->fg.jointype & JT_NATURAL)!=0 4381 4381 && tableAndColumnIndex(pTabList, i, zName, 0, 0) 4382 4382 ){ 4383 4383 /* In a NATURAL join, omit the join columns from the 4384 4384 ** table to the right of the join */ 4385 4385 continue; 4386 4386 } 4387 4387 if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){ ................................................................................ 4900 4900 /* Sometimes the code for a subquery will be generated more than 4901 4901 ** once, if the subquery is part of the WHERE clause in a LEFT JOIN, 4902 4902 ** for example. In that case, do not regenerate the code to manifest 4903 4903 ** a view or the co-routine to implement a view. The first instance 4904 4904 ** is sufficient, though the subroutine to manifest the view does need 4905 4905 ** to be invoked again. */ 4906 4906 if( pItem->addrFillSub ){ 4907 - if( pItem->viaCoroutine==0 ){ 4907 + if( pItem->fg.viaCoroutine==0 ){ 4908 4908 sqlite3VdbeAddOp2(v, OP_Gosub, pItem->regReturn, pItem->addrFillSub); 4909 4909 } 4910 4910 continue; 4911 4911 } 4912 4912 4913 4913 /* Increment Parse.nHeight by the height of the largest expression 4914 4914 ** tree referred to by this, the parent select. The child select ................................................................................ 4918 4918 ** an exact limit. 4919 4919 */ 4920 4920 pParse->nHeight += sqlite3SelectExprHeight(p); 4921 4921 4922 4922 /* Make copies of constant WHERE-clause terms in the outer query down 4923 4923 ** inside the subquery. This can help the subquery to run more efficiently. 4924 4924 */ 4925 - if( (pItem->jointype & JT_OUTER)==0 4925 + if( (pItem->fg.jointype & JT_OUTER)==0 4926 4926 && pushDownWhereTerms(db, pSub, p->pWhere, pItem->iCursor) 4927 4927 ){ 4928 4928 #if SELECTTRACE_ENABLED 4929 4929 if( sqlite3SelectTrace & 0x100 ){ 4930 4930 SELECTTRACE(0x100,pParse,p,("After WHERE-clause push-down:\n")); 4931 4931 sqlite3TreeViewSelect(0, p, 0); 4932 4932 } ................................................................................ 4947 4947 sqlite3VdbeAddOp3(v, OP_InitCoroutine, pItem->regReturn, 0, addrTop); 4948 4948 VdbeComment((v, "%s", pItem->pTab->zName)); 4949 4949 pItem->addrFillSub = addrTop; 4950 4950 sqlite3SelectDestInit(&dest, SRT_Coroutine, pItem->regReturn); 4951 4951 explainSetInteger(pItem->iSelectId, (u8)pParse->iNextSelectId); 4952 4952 sqlite3Select(pParse, pSub, &dest); 4953 4953 pItem->pTab->nRowLogEst = sqlite3LogEst(pSub->nSelectRow); 4954 - pItem->viaCoroutine = 1; 4954 + pItem->fg.viaCoroutine = 1; 4955 4955 pItem->regResult = dest.iSdst; 4956 4956 sqlite3VdbeAddOp1(v, OP_EndCoroutine, pItem->regReturn); 4957 4957 sqlite3VdbeJumpHere(v, addrTop-1); 4958 4958 sqlite3ClearTempRegCache(pParse); 4959 4959 }else{ 4960 4960 /* Generate a subroutine that will fill an ephemeral table with 4961 4961 ** the content of this subquery. pItem->addrFillSub will point ................................................................................ 4965 4965 int topAddr; 4966 4966 int onceAddr = 0; 4967 4967 int retAddr; 4968 4968 assert( pItem->addrFillSub==0 ); 4969 4969 pItem->regReturn = ++pParse->nMem; 4970 4970 topAddr = sqlite3VdbeAddOp2(v, OP_Integer, 0, pItem->regReturn); 4971 4971 pItem->addrFillSub = topAddr+1; 4972 - if( pItem->isCorrelated==0 ){ 4972 + if( pItem->fg.isCorrelated==0 ){ 4973 4973 /* If the subquery is not correlated and if we are not inside of 4974 4974 ** a trigger, then we only need to compute the value of the subquery 4975 4975 ** once. */ 4976 4976 onceAddr = sqlite3CodeOnce(pParse); VdbeCoverage(v); 4977 4977 VdbeComment((v, "materialize \"%s\"", pItem->pTab->zName)); 4978 4978 }else{ 4979 4979 VdbeNoopComment((v, "materialize \"%s\"", pItem->pTab->zName));
Changes to src/sqliteInt.h.
1475 1475 ** hash table. 1476 1476 */ 1477 1477 struct Module { 1478 1478 const sqlite3_module *pModule; /* Callback pointers */ 1479 1479 const char *zName; /* Name passed to create_module() */ 1480 1480 void *pAux; /* pAux passed to create_module() */ 1481 1481 void (*xDestroy)(void *); /* Module destructor function */ 1482 + Table *pEpoTab; /* Eponymous table for this module */ 1482 1483 }; 1483 1484 1484 1485 /* 1485 1486 ** information about each column of an SQL table is held in an instance 1486 1487 ** of this structure. 1487 1488 */ 1488 1489 struct Column { ................................................................................ 1645 1646 u8 tabFlags; /* Mask of TF_* values */ 1646 1647 u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */ 1647 1648 #ifndef SQLITE_OMIT_ALTERTABLE 1648 1649 int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */ 1649 1650 #endif 1650 1651 #ifndef SQLITE_OMIT_VIRTUALTABLE 1651 1652 int nModuleArg; /* Number of arguments to the module */ 1652 - char **azModuleArg; /* Text of all module args. [0] is module name */ 1653 + char **azModuleArg; /* 0: module 1: schema 2: vtab name 3...: args */ 1653 1654 VTable *pVTable; /* List of VTable objects. */ 1654 1655 #endif 1655 1656 Trigger *pTrigger; /* List of triggers stored in pSchema */ 1656 1657 Schema *pSchema; /* Schema that contains this table */ 1657 1658 Table *pNextZombie; /* Next on the Parse.pZombieTab list */ 1658 1659 }; 1659 1660 ................................................................................ 2280 2281 char *zName; /* Name of the table */ 2281 2282 char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */ 2282 2283 Table *pTab; /* An SQL table corresponding to zName */ 2283 2284 Select *pSelect; /* A SELECT statement used in place of a table name */ 2284 2285 int addrFillSub; /* Address of subroutine to manifest a subquery */ 2285 2286 int regReturn; /* Register holding return address of addrFillSub */ 2286 2287 int regResult; /* Registers holding results of a co-routine */ 2287 - u8 jointype; /* Type of join between this able and the previous */ 2288 - unsigned notIndexed :1; /* True if there is a NOT INDEXED clause */ 2289 - unsigned isCorrelated :1; /* True if sub-query is correlated */ 2290 - unsigned viaCoroutine :1; /* Implemented as a co-routine */ 2291 - unsigned isRecursive :1; /* True for recursive reference in WITH */ 2288 + struct { 2289 + u8 jointype; /* Type of join between this able and the previous */ 2290 + unsigned notIndexed :1; /* True if there is a NOT INDEXED clause */ 2291 + unsigned isIndexedBy :1; /* True if there is an INDEXED BY clause */ 2292 + unsigned isTabFunc :1; /* True if table-valued-function syntax */ 2293 + unsigned isCorrelated :1; /* True if sub-query is correlated */ 2294 + unsigned viaCoroutine :1; /* Implemented as a co-routine */ 2295 + unsigned isRecursive :1; /* True for recursive reference in WITH */ 2296 + } fg; 2292 2297 #ifndef SQLITE_OMIT_EXPLAIN 2293 2298 u8 iSelectId; /* If pSelect!=0, the id of the sub-select in EQP */ 2294 2299 #endif 2295 2300 int iCursor; /* The VDBE cursor number used to access this table */ 2296 2301 Expr *pOn; /* The ON clause of a join */ 2297 2302 IdList *pUsing; /* The USING clause of a join */ 2298 2303 Bitmask colUsed; /* Bit N (1<<N) set if column N of pTab is used */ 2299 - char *zIndexedBy; /* Identifier from "INDEXED BY <zIndex>" clause */ 2300 - Index *pIndex; /* Index structure corresponding to zIndex, if any */ 2304 + union { 2305 + char *zIndexedBy; /* Identifier from "INDEXED BY <zIndex>" clause */ 2306 + ExprList *pFuncArg; /* Arguments to table-valued-function */ 2307 + } u1; 2308 + Index *pIBIndex; /* Index structure corresponding to u1.zIndexedBy */ 2301 2309 } a[1]; /* One entry for each identifier on the list */ 2302 2310 }; 2303 2311 2304 2312 /* 2305 2313 ** Permitted values of the SrcList.a.jointype field 2306 2314 */ 2307 2315 #define JT_INNER 0x0001 /* Any kind of inner or cross join */ ................................................................................ 3244 3252 int sqlite3InitCallback(void*, int, char**, char**); 3245 3253 void sqlite3Pragma(Parse*,Token*,Token*,Token*,int); 3246 3254 void sqlite3ResetAllSchemasOfConnection(sqlite3*); 3247 3255 void sqlite3ResetOneSchema(sqlite3*,int); 3248 3256 void sqlite3CollapseDatabaseArray(sqlite3*); 3249 3257 void sqlite3BeginParse(Parse*,int); 3250 3258 void sqlite3CommitInternalChanges(sqlite3*); 3259 +void sqlite3DeleteColumnNames(sqlite3*,Table*); 3251 3260 Table *sqlite3ResultSetOfSelect(Parse*,Select*); 3252 3261 void sqlite3OpenMasterTable(Parse *, int); 3253 3262 Index *sqlite3PrimaryKeyIndex(Table*); 3254 3263 i16 sqlite3ColumnOfIndex(Index*, i16); 3255 3264 void sqlite3StartTable(Parse*,Token*,Token*,int,int,int,int); 3256 3265 void sqlite3AddColumn(Parse*,Token*); 3257 3266 void sqlite3AddNotNull(Parse*, int); ................................................................................ 3315 3324 IdList *sqlite3IdListAppend(sqlite3*, IdList*, Token*); 3316 3325 int sqlite3IdListIndex(IdList*,const char*); 3317 3326 SrcList *sqlite3SrcListEnlarge(sqlite3*, SrcList*, int, int); 3318 3327 SrcList *sqlite3SrcListAppend(sqlite3*, SrcList*, Token*, Token*); 3319 3328 SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*, 3320 3329 Token*, Select*, Expr*, IdList*); 3321 3330 void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *); 3331 +void sqlite3SrcListFuncArgs(Parse*, SrcList*, ExprList*); 3322 3332 int sqlite3IndexedByLookup(Parse *, struct SrcList_item *); 3323 3333 void sqlite3SrcListShiftJoinType(SrcList*); 3324 3334 void sqlite3SrcListAssignCursors(Parse*, SrcList*); 3325 3335 void sqlite3IdListDelete(sqlite3*, IdList*); 3326 3336 void sqlite3SrcListDelete(sqlite3*, SrcList*); 3327 3337 Index *sqlite3AllocateIndexObject(sqlite3*,i16,int,char**); 3328 3338 Index *sqlite3CreateIndex(Parse*,Token*,Token*,SrcList*,ExprList*,int,Token*, ................................................................................ 3606 3616 void sqlite3NestedParse(Parse*, const char*, ...); 3607 3617 void sqlite3ExpirePreparedStatements(sqlite3*); 3608 3618 int sqlite3CodeSubselect(Parse *, Expr *, int, int); 3609 3619 void sqlite3SelectPrep(Parse*, Select*, NameContext*); 3610 3620 void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p); 3611 3621 int sqlite3MatchSpanName(const char*, const char*, const char*, const char*); 3612 3622 int sqlite3ResolveExprNames(NameContext*, Expr*); 3623 +int sqlite3ResolveExprListNames(NameContext*, ExprList*); 3613 3624 void sqlite3ResolveSelectNames(Parse*, Select*, NameContext*); 3614 3625 void sqlite3ResolveSelfReference(Parse*,Table*,int,Expr*,ExprList*); 3615 3626 int sqlite3ResolveOrderGroupBy(Parse*, Select*, ExprList*, const char*); 3616 3627 void sqlite3ColumnDefault(Vdbe *, Table *, int, int); 3617 3628 void sqlite3AlterFinishAddColumn(Parse *, Token *); 3618 3629 void sqlite3AlterBeginAddColumn(Parse *, SrcList *); 3619 3630 CollSeq *sqlite3GetCollSeq(Parse*, u8, CollSeq *, const char*); ................................................................................ 3714 3725 void sqlite3VtabUnlock(VTable *); 3715 3726 void sqlite3VtabUnlockList(sqlite3*); 3716 3727 int sqlite3VtabSavepoint(sqlite3 *, int, int); 3717 3728 void sqlite3VtabImportErrmsg(Vdbe*, sqlite3_vtab*); 3718 3729 VTable *sqlite3GetVTable(sqlite3*, Table*); 3719 3730 # define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0) 3720 3731 #endif 3732 +int sqlite3VtabEponymousTableInit(Parse*,Module*); 3733 +void sqlite3VtabEponymousTableClear(sqlite3*,Module*); 3721 3734 void sqlite3VtabMakeWritable(Parse*,Table*); 3722 3735 void sqlite3VtabBeginParse(Parse*, Token*, Token*, Token*, int); 3723 3736 void sqlite3VtabFinishParse(Parse*, Token*); 3724 3737 void sqlite3VtabArgInit(Parse*); 3725 3738 void sqlite3VtabArgExtend(Parse*, Token*); 3726 3739 int sqlite3VtabCallCreate(sqlite3*, int, const char *, char **); 3727 3740 int sqlite3VtabCallConnect(Parse*, Table*);
Changes to src/test1.c.
6376 6376 extern int sqlite3_eval_init(sqlite3*,char**,const sqlite3_api_routines*); 6377 6377 extern int sqlite3_fileio_init(sqlite3*,char**,const sqlite3_api_routines*); 6378 6378 extern int sqlite3_fuzzer_init(sqlite3*,char**,const sqlite3_api_routines*); 6379 6379 extern int sqlite3_ieee_init(sqlite3*,char**,const sqlite3_api_routines*); 6380 6380 extern int sqlite3_nextchar_init(sqlite3*,char**,const sqlite3_api_routines*); 6381 6381 extern int sqlite3_percentile_init(sqlite3*,char**,const sqlite3_api_routines*); 6382 6382 extern int sqlite3_regexp_init(sqlite3*,char**,const sqlite3_api_routines*); 6383 + extern int sqlite3_series_init(sqlite3*,char**,const sqlite3_api_routines*); 6383 6384 extern int sqlite3_spellfix_init(sqlite3*,char**,const sqlite3_api_routines*); 6384 6385 extern int sqlite3_totype_init(sqlite3*,char**,const sqlite3_api_routines*); 6385 6386 extern int sqlite3_wholenumber_init(sqlite3*,char**,const sqlite3_api_routines*); 6386 6387 extern int sqlite3_fts5_init(sqlite3*,char**,const sqlite3_api_routines*); 6387 6388 static const struct { 6388 6389 const char *zExtName; 6389 6390 int (*pInit)(sqlite3*,char**,const sqlite3_api_routines*); ................................................................................ 6396 6397 #endif 6397 6398 { "fileio", sqlite3_fileio_init }, 6398 6399 { "fuzzer", sqlite3_fuzzer_init }, 6399 6400 { "ieee754", sqlite3_ieee_init }, 6400 6401 { "nextchar", sqlite3_nextchar_init }, 6401 6402 { "percentile", sqlite3_percentile_init }, 6402 6403 { "regexp", sqlite3_regexp_init }, 6404 + { "series", sqlite3_series_init }, 6403 6405 { "spellfix", sqlite3_spellfix_init }, 6404 6406 { "totype", sqlite3_totype_init }, 6405 6407 { "wholenumber", sqlite3_wholenumber_init }, 6406 6408 }; 6407 6409 sqlite3 *db; 6408 6410 const char *zName; 6409 6411 int i, j, rc;
Changes to src/treeview.c.
116 116 } 117 117 if( pItem->pTab ){ 118 118 sqlite3XPrintf(&x, 0, " tabname=%Q", pItem->pTab->zName); 119 119 } 120 120 if( pItem->zAlias ){ 121 121 sqlite3XPrintf(&x, 0, " (AS %s)", pItem->zAlias); 122 122 } 123 - if( pItem->jointype & JT_LEFT ){ 123 + if( pItem->fg.jointype & JT_LEFT ){ 124 124 sqlite3XPrintf(&x, 0, " LEFT-JOIN"); 125 125 } 126 126 sqlite3StrAccumFinish(&x); 127 127 sqlite3TreeViewItem(pView, zLine, i<p->pSrc->nSrc-1); 128 128 if( pItem->pSelect ){ 129 129 sqlite3TreeViewSelect(pView, pItem->pSelect, 0); 130 130 } 131 + if( pItem->fg.isTabFunc ){ 132 + sqlite3TreeViewExprList(pView, pItem->u1.pFuncArg, 0, "func-args:"); 133 + } 131 134 sqlite3TreeViewPop(pView); 132 135 } 133 136 sqlite3TreeViewPop(pView); 134 137 } 135 138 if( p->pWhere ){ 136 139 sqlite3TreeViewItem(pView, "WHERE", (n--)>0); 137 140 sqlite3TreeViewExpr(pView, p->pWhere, 0);
Changes to src/vtab.c.
54 54 Module *pDel; 55 55 char *zCopy = (char *)(&pMod[1]); 56 56 memcpy(zCopy, zName, nName+1); 57 57 pMod->zName = zCopy; 58 58 pMod->pModule = pModule; 59 59 pMod->pAux = pAux; 60 60 pMod->xDestroy = xDestroy; 61 + pMod->pEpoTab = 0; 61 62 pDel = (Module *)sqlite3HashInsert(&db->aModule,zCopy,(void*)pMod); 62 63 assert( pDel==0 || pDel==pMod ); 63 64 if( pDel ){ 64 65 db->mallocFailed = 1; 65 66 sqlite3DbFree(db, pDel); 66 67 } 67 68 } ................................................................................ 694 695 zMod = pTab->azModuleArg[0]; 695 696 pMod = (Module*)sqlite3HashFind(&db->aModule, zMod); 696 697 697 698 /* If the module has been registered and includes a Create method, 698 699 ** invoke it now. If the module has not been registered, return an 699 700 ** error. Otherwise, do nothing. 700 701 */ 701 - if( !pMod ){ 702 + if( pMod==0 || pMod->pModule->xCreate==0 ){ 702 703 *pzErr = sqlite3MPrintf(db, "no such module: %s", zMod); 703 704 rc = SQLITE_ERROR; 704 705 }else{ 705 706 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr); 706 707 } 707 708 708 709 /* Justification of ALWAYS(): The xConstructor method is required to ................................................................................ 1081 1082 if( apVtabLock ){ 1082 1083 pToplevel->apVtabLock = apVtabLock; 1083 1084 pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab; 1084 1085 }else{ 1085 1086 pToplevel->db->mallocFailed = 1; 1086 1087 } 1087 1088 } 1089 + 1090 +/* 1091 +** Check to see if virtual tale module pMod can be have an eponymous 1092 +** virtual table instance. If it can, create one if one does not already 1093 +** exist. Return non-zero if the eponymous virtual table instance exists 1094 +** when this routine returns, and return zero if it does not exist. 1095 +** 1096 +** An eponymous virtual table instance is one that is named after its 1097 +** module, and more importantly, does not require a CREATE VIRTUAL TABLE 1098 +** statement in order to come into existance. Eponymous virtual table 1099 +** instances always exist. They cannot be DROP-ed. 1100 +** 1101 +** Any virtual table module for which xConnect and xCreate are the same 1102 +** method can have an eponymous virtual table instance. 1103 +*/ 1104 +int sqlite3VtabEponymousTableInit(Parse *pParse, Module *pMod){ 1105 + const sqlite3_module *pModule = pMod->pModule; 1106 + Table *pTab; 1107 + char *zErr = 0; 1108 + int nName; 1109 + int rc; 1110 + sqlite3 *db = pParse->db; 1111 + if( pMod->pEpoTab ) return 1; 1112 + if( pModule->xCreate!=0 && pModule->xCreate!=pModule->xConnect ) return 0; 1113 + nName = sqlite3Strlen30(pMod->zName) + 1; 1114 + pTab = sqlite3DbMallocZero(db, sizeof(Table) + nName); 1115 + if( pTab==0 ) return 0; 1116 + pMod->pEpoTab = pTab; 1117 + pTab->zName = (char*)&pTab[1]; 1118 + memcpy(pTab->zName, pMod->zName, nName); 1119 + pTab->nRef = 1; 1120 + pTab->pSchema = db->aDb[0].pSchema; 1121 + pTab->tabFlags |= TF_Virtual; 1122 + pTab->nModuleArg = 0; 1123 + pTab->iPKey = -1; 1124 + addModuleArgument(db, pTab, pTab->zName); 1125 + addModuleArgument(db, pTab, 0); 1126 + addModuleArgument(db, pTab, pTab->zName); 1127 + rc = vtabCallConstructor(db, pTab, pMod, pModule->xConnect, &zErr); 1128 + if( rc ){ 1129 + sqlite3ErrorMsg(pParse, "%s", zErr); 1130 + sqlite3DbFree(db, zErr); 1131 + sqlite3VtabEponymousTableClear(db, pMod); 1132 + return 0; 1133 + } 1134 + return 1; 1135 +} 1136 + 1137 +/* 1138 +** Erase the eponymous virtual table instance associated with 1139 +** virtual table module pMod, if it exists. 1140 +*/ 1141 +void sqlite3VtabEponymousTableClear(sqlite3 *db, Module *pMod){ 1142 + Table *pTab = pMod->pEpoTab; 1143 + if( (pTab = pMod->pEpoTab)!=0 ){ 1144 + sqlite3DeleteColumnNames(db, pTab); 1145 + sqlite3DbFree(db, pTab->azModuleArg); 1146 + sqlite3DbFree(db, pTab); 1147 + pMod->pEpoTab = 0; 1148 + } 1149 +} 1088 1150 1089 1151 /* 1090 1152 ** Return the ON CONFLICT resolution mode in effect for the virtual 1091 1153 ** table update operation currently in progress. 1092 1154 ** 1093 1155 ** The results of this routine are undefined unless it is called from 1094 1156 ** within an xUpdate method.
Changes to src/walker.c.
100 100 struct SrcList_item *pItem; 101 101 102 102 pSrc = p->pSrc; 103 103 if( ALWAYS(pSrc) ){ 104 104 for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){ 105 105 if( sqlite3WalkSelect(pWalker, pItem->pSelect) ){ 106 106 return WRC_Abort; 107 + } 108 + if( pItem->fg.isTabFunc 109 + && sqlite3WalkExprList(pWalker, pItem->u1.pFuncArg) 110 + ){ 111 + return WRC_Abort; 107 112 } 108 113 } 109 114 } 110 115 return WRC_Continue; 111 116 } 112 117 113 118 /*
Changes to src/where.c.
705 705 sqlite3VdbeAddOp2(v, OP_OpenAutoindex, pLevel->iIdxCur, nKeyCol+1); 706 706 sqlite3VdbeSetP4KeyInfo(pParse, pIdx); 707 707 VdbeComment((v, "for %s", pTable->zName)); 708 708 709 709 /* Fill the automatic index with content */ 710 710 sqlite3ExprCachePush(pParse); 711 711 pTabItem = &pWC->pWInfo->pTabList->a[pLevel->iFrom]; 712 - if( pTabItem->viaCoroutine ){ 712 + if( pTabItem->fg.viaCoroutine ){ 713 713 int regYield = pTabItem->regReturn; 714 714 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub); 715 715 addrTop = sqlite3VdbeAddOp1(v, OP_Yield, regYield); 716 716 VdbeCoverage(v); 717 717 VdbeComment((v, "next row of \"%s\"", pTabItem->pTab->zName)); 718 718 }else{ 719 719 addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, pLevel->iTabCur); VdbeCoverage(v); ................................................................................ 724 724 pLoop->wsFlags |= WHERE_PARTIALIDX; 725 725 } 726 726 regRecord = sqlite3GetTempReg(pParse); 727 727 sqlite3GenerateIndexKey(pParse, pIdx, pLevel->iTabCur, regRecord, 0, 0, 0, 0); 728 728 sqlite3VdbeAddOp2(v, OP_IdxInsert, pLevel->iIdxCur, regRecord); 729 729 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); 730 730 if( pPartial ) sqlite3VdbeResolveLabel(v, iContinue); 731 - if( pTabItem->viaCoroutine ){ 731 + if( pTabItem->fg.viaCoroutine ){ 732 732 translateColumnToCopy(v, addrTop, pLevel->iTabCur, pTabItem->regResult); 733 733 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrTop); 734 - pTabItem->viaCoroutine = 0; 734 + pTabItem->fg.viaCoroutine = 0; 735 735 }else{ 736 736 sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1); VdbeCoverage(v); 737 737 } 738 738 sqlite3VdbeChangeP5(v, SQLITE_STMTSTATUS_AUTOINDEX); 739 739 sqlite3VdbeJumpHere(v, addrTop); 740 740 sqlite3ReleaseTempReg(pParse, regRecord); 741 741 sqlite3ExprCachePop(pParse); ................................................................................ 2124 2124 pNew = pBuilder->pNew; 2125 2125 if( db->mallocFailed ) return SQLITE_NOMEM; 2126 2126 2127 2127 assert( (pNew->wsFlags & WHERE_VIRTUALTABLE)==0 ); 2128 2128 assert( (pNew->wsFlags & WHERE_TOP_LIMIT)==0 ); 2129 2129 if( pNew->wsFlags & WHERE_BTM_LIMIT ){ 2130 2130 opMask = WO_LT|WO_LE; 2131 - }else if( /*pProbe->tnum<=0 ||*/ (pSrc->jointype & JT_LEFT)!=0 ){ 2131 + }else if( /*pProbe->tnum<=0 ||*/ (pSrc->fg.jointype & JT_LEFT)!=0 ){ 2132 2132 opMask = WO_EQ|WO_IN|WO_GT|WO_GE|WO_LT|WO_LE; 2133 2133 }else{ 2134 2134 opMask = WO_EQ|WO_IN|WO_GT|WO_GE|WO_LT|WO_LE|WO_ISNULL|WO_IS; 2135 2135 } 2136 2136 if( pProbe->bUnordered ) opMask &= ~(WO_GT|WO_GE|WO_LT|WO_LE); 2137 2137 2138 2138 assert( pNew->u.btree.nEq<pProbe->nColumn ); ................................................................................ 2498 2498 pWInfo = pBuilder->pWInfo; 2499 2499 pTabList = pWInfo->pTabList; 2500 2500 pSrc = pTabList->a + pNew->iTab; 2501 2501 pTab = pSrc->pTab; 2502 2502 pWC = pBuilder->pWC; 2503 2503 assert( !IsVirtual(pSrc->pTab) ); 2504 2504 2505 - if( pSrc->pIndex ){ 2505 + if( pSrc->pIBIndex ){ 2506 2506 /* An INDEXED BY clause specifies a particular index to use */ 2507 - pProbe = pSrc->pIndex; 2507 + pProbe = pSrc->pIBIndex; 2508 2508 }else if( !HasRowid(pTab) ){ 2509 2509 pProbe = pTab->pIndex; 2510 2510 }else{ 2511 2511 /* There is no INDEXED BY clause. Create a fake Index object in local 2512 2512 ** variable sPk to represent the rowid primary key index. Make this 2513 2513 ** fake index the first in a chain of Index objects with all of the real 2514 2514 ** indices to follow */ ................................................................................ 2520 2520 sPk.aiRowLogEst = aiRowEstPk; 2521 2521 sPk.onError = OE_Replace; 2522 2522 sPk.pTable = pTab; 2523 2523 sPk.szIdxRow = pTab->szTabRow; 2524 2524 aiRowEstPk[0] = pTab->nRowLogEst; 2525 2525 aiRowEstPk[1] = 0; 2526 2526 pFirst = pSrc->pTab->pIndex; 2527 - if( pSrc->notIndexed==0 ){ 2527 + if( pSrc->fg.notIndexed==0 ){ 2528 2528 /* The real indices of the table are only considered if the 2529 2529 ** NOT INDEXED qualifier is omitted from the FROM clause */ 2530 2530 sPk.pNext = pFirst; 2531 2531 } 2532 2532 pProbe = &sPk; 2533 2533 } 2534 2534 rSize = pTab->nRowLogEst; 2535 2535 rLogSize = estLog(rSize); 2536 2536 2537 2537 #ifndef SQLITE_OMIT_AUTOMATIC_INDEX 2538 2538 /* Automatic indexes */ 2539 - if( !pBuilder->pOrSet /* Not part of an OR optimization */ 2539 + if( !pBuilder->pOrSet /* Not part of an OR optimization */ 2540 2540 && (pWInfo->wctrlFlags & WHERE_NO_AUTOINDEX)==0 2541 2541 && (pWInfo->pParse->db->flags & SQLITE_AutoIndex)!=0 2542 - && pSrc->pIndex==0 /* Has no INDEXED BY clause */ 2543 - && !pSrc->notIndexed /* Has no NOT INDEXED clause */ 2544 - && HasRowid(pTab) /* Is not a WITHOUT ROWID table. (FIXME: Why not?) */ 2545 - && !pSrc->isCorrelated /* Not a correlated subquery */ 2546 - && !pSrc->isRecursive /* Not a recursive common table expression. */ 2542 + && pSrc->pIBIndex==0 /* Has no INDEXED BY clause */ 2543 + && !pSrc->fg.notIndexed /* Has no NOT INDEXED clause */ 2544 + && HasRowid(pTab) /* Is not a WITHOUT ROWID table. (FIXME: Why not?) */ 2545 + && !pSrc->fg.isCorrelated /* Not a correlated subquery */ 2546 + && !pSrc->fg.isRecursive /* Not a recursive common table expression. */ 2547 2547 ){ 2548 2548 /* Generate auto-index WhereLoops */ 2549 2549 WhereTerm *pTerm; 2550 2550 WhereTerm *pWCEnd = pWC->a + pWC->nTerm; 2551 2551 for(pTerm=pWC->a; rc==SQLITE_OK && pTerm<pWCEnd; pTerm++){ 2552 2552 if( pTerm->prereqRight & pNew->maskSelf ) continue; 2553 2553 if( termCanDriveIndex(pTerm, pSrc, 0) ){ ................................................................................ 2660 2660 sqlite3Stat4ProbeFree(pBuilder->pRec); 2661 2661 pBuilder->nRecValid = 0; 2662 2662 pBuilder->pRec = 0; 2663 2663 #endif 2664 2664 2665 2665 /* If there was an INDEXED BY clause, then only that one index is 2666 2666 ** considered. */ 2667 - if( pSrc->pIndex ) break; 2667 + if( pSrc->pIBIndex ) break; 2668 2668 } 2669 2669 return rc; 2670 2670 } 2671 2671 2672 2672 #ifndef SQLITE_OMIT_VIRTUALTABLE 2673 2673 /* 2674 2674 ** Add all WhereLoop objects for a table of the join identified by ................................................................................ 3006 3006 /* Loop over the tables in the join, from left to right */ 3007 3007 pNew = pBuilder->pNew; 3008 3008 whereLoopInit(pNew); 3009 3009 for(iTab=0, pItem=pTabList->a; pItem<pEnd; iTab++, pItem++){ 3010 3010 Bitmask mUnusable = 0; 3011 3011 pNew->iTab = iTab; 3012 3012 pNew->maskSelf = sqlite3WhereGetMask(&pWInfo->sMaskSet, pItem->iCursor); 3013 - if( ((pItem->jointype|priorJointype) & (JT_LEFT|JT_CROSS))!=0 ){ 3013 + if( ((pItem->fg.jointype|priorJointype) & (JT_LEFT|JT_CROSS))!=0 ){ 3014 3014 /* This condition is true when pItem is the FROM clause term on the 3015 3015 ** right-hand-side of a LEFT or CROSS JOIN. */ 3016 3016 mExtra = mPrior; 3017 3017 } 3018 - priorJointype = pItem->jointype; 3018 + priorJointype = pItem->fg.jointype; 3019 3019 if( IsVirtual(pItem->pTab) ){ 3020 3020 struct SrcList_item *p; 3021 3021 for(p=&pItem[1]; p<pEnd; p++){ 3022 - if( mUnusable || (p->jointype & (JT_LEFT|JT_CROSS)) ){ 3022 + if( mUnusable || (p->fg.jointype & (JT_LEFT|JT_CROSS)) ){ 3023 3023 mUnusable |= sqlite3WhereGetMask(&pWInfo->sMaskSet, p->iCursor); 3024 3024 } 3025 3025 } 3026 3026 rc = whereLoopAddVirtual(pBuilder, mExtra, mUnusable); 3027 3027 }else{ 3028 3028 rc = whereLoopAddBtree(pBuilder, mExtra); 3029 3029 } ................................................................................ 3745 3745 3746 3746 pWInfo = pBuilder->pWInfo; 3747 3747 if( pWInfo->wctrlFlags & WHERE_FORCE_TABLE ) return 0; 3748 3748 assert( pWInfo->pTabList->nSrc>=1 ); 3749 3749 pItem = pWInfo->pTabList->a; 3750 3750 pTab = pItem->pTab; 3751 3751 if( IsVirtual(pTab) ) return 0; 3752 - if( pItem->zIndexedBy ) return 0; 3752 + if( pItem->fg.isIndexedBy ) return 0; 3753 3753 iCur = pItem->iCursor; 3754 3754 pWC = &pWInfo->sWC; 3755 3755 pLoop = pBuilder->pNew; 3756 3756 pLoop->wsFlags = 0; 3757 3757 pLoop->nSkip = 0; 3758 3758 pTerm = sqlite3WhereFindTerm(pWC, iCur, -1, 0, WO_EQ|WO_IS, 0); 3759 3759 if( pTerm ){ ................................................................................ 4026 4026 ** Note that bitmasks are created for all pTabList->nSrc tables in 4027 4027 ** pTabList, not just the first nTabList tables. nTabList is normally 4028 4028 ** equal to pTabList->nSrc but might be shortened to 1 if the 4029 4029 ** WHERE_ONETABLE_ONLY flag is set. 4030 4030 */ 4031 4031 for(ii=0; ii<pTabList->nSrc; ii++){ 4032 4032 createMask(pMaskSet, pTabList->a[ii].iCursor); 4033 + sqlite3WhereTabFuncArgs(pParse, &pTabList->a[ii], &pWInfo->sWC); 4033 4034 } 4034 4035 #ifndef NDEBUG 4035 4036 { 4036 4037 Bitmask toTheLeft = 0; 4037 4038 for(ii=0; ii<pTabList->nSrc; ii++){ 4038 4039 Bitmask m = sqlite3WhereGetMask(pMaskSet, pTabList->a[ii].iCursor); 4039 4040 assert( (m-1)==toTheLeft ); ................................................................................ 4132 4133 Bitmask tabUsed = sqlite3WhereExprListUsage(pMaskSet, pResultSet); 4133 4134 if( sWLB.pOrderBy ){ 4134 4135 tabUsed |= sqlite3WhereExprListUsage(pMaskSet, sWLB.pOrderBy); 4135 4136 } 4136 4137 while( pWInfo->nLevel>=2 ){ 4137 4138 WhereTerm *pTerm, *pEnd; 4138 4139 pLoop = pWInfo->a[pWInfo->nLevel-1].pWLoop; 4139 - if( (pWInfo->pTabList->a[pLoop->iTab].jointype & JT_LEFT)==0 ) break; 4140 + if( (pWInfo->pTabList->a[pLoop->iTab].fg.jointype & JT_LEFT)==0 ) break; 4140 4141 if( (wctrlFlags & WHERE_WANT_DISTINCT)==0 4141 4142 && (pLoop->wsFlags & WHERE_ONEROW)==0 4142 4143 ){ 4143 4144 break; 4144 4145 } 4145 4146 if( (tabUsed & pLoop->maskSelf)!=0 ) break; 4146 4147 pEnd = sWLB.pWC->a + sWLB.pWC->nTerm; ................................................................................ 4425 4426 assert( pTab!=0 ); 4426 4427 pLoop = pLevel->pWLoop; 4427 4428 4428 4429 /* For a co-routine, change all OP_Column references to the table of 4429 4430 ** the co-routine into OP_Copy of result contained in a register. 4430 4431 ** OP_Rowid becomes OP_Null. 4431 4432 */ 4432 - if( pTabItem->viaCoroutine && !db->mallocFailed ){ 4433 + if( pTabItem->fg.viaCoroutine && !db->mallocFailed ){ 4433 4434 translateColumnToCopy(v, pLevel->addrBody, pLevel->iTabCur, 4434 4435 pTabItem->regResult); 4435 4436 continue; 4436 4437 } 4437 4438 4438 4439 /* Close all of the cursors that were opened by sqlite3WhereBegin. 4439 4440 ** Except, do not close cursors that will be reused by the OR optimization
Changes to src/whereInt.h.
471 471 /* whereexpr.c: */ 472 472 void sqlite3WhereClauseInit(WhereClause*,WhereInfo*); 473 473 void sqlite3WhereClauseClear(WhereClause*); 474 474 void sqlite3WhereSplit(WhereClause*,Expr*,u8); 475 475 Bitmask sqlite3WhereExprUsage(WhereMaskSet*, Expr*); 476 476 Bitmask sqlite3WhereExprListUsage(WhereMaskSet*, ExprList*); 477 477 void sqlite3WhereExprAnalyze(SrcList*, WhereClause*); 478 +void sqlite3WhereTabFuncArgs(Parse*, struct SrcList_item*, WhereClause*); 478 479 479 480 480 481 481 482 482 483 483 484 /* 484 485 ** Bitmasks for the operators on WhereTerm objects. These are all
Changes to src/wherecode.c.
642 642 addrBrk = pLevel->addrBrk = pLevel->addrNxt = sqlite3VdbeMakeLabel(v); 643 643 addrCont = pLevel->addrCont = sqlite3VdbeMakeLabel(v); 644 644 645 645 /* If this is the right table of a LEFT OUTER JOIN, allocate and 646 646 ** initialize a memory cell that records if this table matches any 647 647 ** row of the left table of the join. 648 648 */ 649 - if( pLevel->iFrom>0 && (pTabItem[0].jointype & JT_LEFT)!=0 ){ 649 + if( pLevel->iFrom>0 && (pTabItem[0].fg.jointype & JT_LEFT)!=0 ){ 650 650 pLevel->iLeftJoin = ++pParse->nMem; 651 651 sqlite3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin); 652 652 VdbeComment((v, "init LEFT JOIN no-match flag")); 653 653 } 654 654 655 655 /* Special case of a FROM clause subquery implemented as a co-routine */ 656 - if( pTabItem->viaCoroutine ){ 656 + if( pTabItem->fg.viaCoroutine ){ 657 657 int regYield = pTabItem->regReturn; 658 658 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub); 659 659 pLevel->p2 = sqlite3VdbeAddOp2(v, OP_Yield, regYield, addrBrk); 660 660 VdbeCoverage(v); 661 661 VdbeComment((v, "next row of \"%s\"", pTabItem->pTab->zName)); 662 662 pLevel->op = OP_Goto; 663 663 }else ................................................................................ 1391 1391 { 1392 1392 /* Case 6: There is no usable index. We must do a complete 1393 1393 ** scan of the entire table. 1394 1394 */ 1395 1395 static const u8 aStep[] = { OP_Next, OP_Prev }; 1396 1396 static const u8 aStart[] = { OP_Rewind, OP_Last }; 1397 1397 assert( bRev==0 || bRev==1 ); 1398 - if( pTabItem->isRecursive ){ 1398 + if( pTabItem->fg.isRecursive ){ 1399 1399 /* Tables marked isRecursive have only a single row that is stored in 1400 1400 ** a pseudo-cursor. No need to Rewind or Next such cursors. */ 1401 1401 pLevel->op = OP_Noop; 1402 1402 }else{ 1403 1403 pLevel->op = aStep[bRev]; 1404 1404 pLevel->p1 = iCur; 1405 1405 pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrBrk);
Changes to src/whereexpr.c.
1243 1243 WhereClause *pWC /* the WHERE clause to be analyzed */ 1244 1244 ){ 1245 1245 int i; 1246 1246 for(i=pWC->nTerm-1; i>=0; i--){ 1247 1247 exprAnalyze(pTabList, pWC, i); 1248 1248 } 1249 1249 } 1250 + 1251 +/* 1252 +** For table-valued-functions, transform the function arguments into 1253 +** new WHERE clause terms. 1254 +** 1255 +** Each function argument translates into an equality constraint against 1256 +** a HIDDEN column in the table. 1257 +*/ 1258 +void sqlite3WhereTabFuncArgs( 1259 + Parse *pParse, /* Parsing context */ 1260 + struct SrcList_item *pItem, /* The FROM clause term to process */ 1261 + WhereClause *pWC /* Xfer function arguments to here */ 1262 +){ 1263 + Table *pTab; 1264 + int j, k; 1265 + ExprList *pArgs; 1266 + Expr *pColRef; 1267 + Expr *pTerm; 1268 + if( pItem->fg.isTabFunc==0 ) return; 1269 + pTab = pItem->pTab; 1270 + assert( pTab!=0 ); 1271 + pArgs = pItem->u1.pFuncArg; 1272 + assert( pArgs!=0 ); 1273 + for(j=k=0; j<pArgs->nExpr; j++){ 1274 + while( k<pTab->nCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){ k++; } 1275 + if( k>=pTab->nCol ){ 1276 + sqlite3ErrorMsg(pParse, "too many arguments on %s - max %d", 1277 + pTab->zName, j); 1278 + return; 1279 + } 1280 + pColRef = sqlite3PExpr(pParse, TK_COLUMN, 0, 0, 0); 1281 + if( pColRef==0 ) return; 1282 + pColRef->iTable = pItem->iCursor; 1283 + pColRef->iColumn = k++; 1284 + pTerm = sqlite3PExpr(pParse, TK_EQ, pColRef, 1285 + sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0); 1286 + whereClauseInsert(pWC, pTerm, TERM_DYNAMIC); 1287 + } 1288 +}
Added test/tabfunc01.test.
1 +# 2015-08-19 2 +# 3 +# The author disclaims copyright to this source code. In place of 4 +# a legal notice, here is a blessing: 5 +# 6 +# May you do good and not evil. 7 +# May you find forgiveness for yourself and forgive others. 8 +# May you share freely, never taking more than you give. 9 +# 10 +#*********************************************************************** 11 +# 12 +# This file implements tests for table-valued-functions implemented using 13 +# eponymous virtual tables. 14 +# 15 + 16 +set testdir [file dirname $argv0] 17 +source $testdir/tester.tcl 18 +set testprefix tabfunc01 19 + 20 +ifcapable !vtab { 21 + finish_test 22 + return 23 +} 24 +load_static_extension db series 25 + 26 +do_execsql_test tabfunc01-1.1 { 27 + SELECT *, '|' FROM generate_series WHERE start=1 AND stop=9 AND step=2; 28 +} {1 | 3 | 5 | 7 | 9 |} 29 +do_execsql_test tabfunc01-1.2 { 30 + SELECT *, '|' FROM generate_series LIMIT 5; 31 +} {0 | 1 | 2 | 3 | 4 |} 32 +do_catchsql_test tabfunc01-1.3 { 33 + CREATE VIRTUAL TABLE t1 USING generate_series; 34 +} {1 {no such module: generate_series}} 35 +do_execsql_test tabfunc01-1.4 { 36 + SELECT * FROM generate_series(1,9,2); 37 +} {1 3 5 7 9} 38 +do_execsql_test tabfunc01-1.5 { 39 + SELECT * FROM generate_series(1,9); 40 +} {1 2 3 4 5 6 7 8 9} 41 +do_execsql_test tabfunc01-1.6 { 42 + SELECT * FROM generate_series(1,10) WHERE step=3; 43 +} {1 4 7 10} 44 +do_catchsql_test tabfunc01-1.7 { 45 + SELECT * FROM generate_series(1,9,2,11); 46 +} {1 {too many arguments on generate_series - max 3}} 47 + 48 +do_execsql_test tabfunc01-1.8 { 49 + SELECT * FROM generate_series(0,32,5) ORDER BY rowid DESC; 50 +} {30 25 20 15 10 5 0} 51 +do_execsql_test tabfunc01-1.9 { 52 + SELECT rowid, * FROM generate_series(0,32,5) ORDER BY value DESC; 53 +} {1 30 2 25 3 20 4 15 5 10 6 5 7 0} 54 +do_execsql_test tabfunc01-1.10 { 55 + SELECT rowid, * FROM generate_series(0,32,5) ORDER BY +value DESC; 56 +} {7 30 6 25 5 20 4 15 3 10 2 5 1 0} 57 + 58 +do_execsql_test tabfunc01-2.1 { 59 + CREATE TABLE t1(x); 60 + INSERT INTO t1(x) VALUES(2),(3); 61 + SELECT *, '|' FROM t1, generate_series(1,x) ORDER BY 1, 2 62 +} {2 1 | 2 2 | 3 1 | 3 2 | 3 3 |} 63 + 64 +finish_test