| | @@ -16,11 +16,11 @@ |
| 16 | 16 | ** if you want a wrapper to interface SQLite with your choice of programming |
| 17 | 17 | ** language. The code for the "sqlite3" command-line shell is also in a |
| 18 | 18 | ** separate file. This file contains only code for the core SQLite library. |
| 19 | 19 | ** |
| 20 | 20 | ** The content in this amalgamation comes from Fossil check-in |
| 21 | | -** 4384c9a108b58a0b8c38c51678aad871f088 with changes in files: |
| 21 | +** aa0a28776bbeafb71b2db20ac8c16377ba07 with changes in files: |
| 22 | 22 | ** |
| 23 | 23 | ** |
| 24 | 24 | */ |
| 25 | 25 | #ifndef SQLITE_AMALGAMATION |
| 26 | 26 | #define SQLITE_CORE 1 |
| | @@ -467,14 +467,14 @@ |
| 467 | 467 | ** [sqlite3_libversion_number()], [sqlite3_sourceid()], |
| 468 | 468 | ** [sqlite_version()] and [sqlite_source_id()]. |
| 469 | 469 | */ |
| 470 | 470 | #define SQLITE_VERSION "3.52.0" |
| 471 | 471 | #define SQLITE_VERSION_NUMBER 3052000 |
| 472 | | -#define SQLITE_SOURCE_ID "2025-11-28 17:56:22 4384c9a108b58a0b8c38c51678aad871f088358b9bff3922299cc7ddb3d247ce" |
| 472 | +#define SQLITE_SOURCE_ID "2025-12-05 12:22:23 aa0a28776bbeafb71b2db20ac8c16377ba07b7d3d58e46cfd11f60c694759a90" |
| 473 | 473 | #define SQLITE_SCM_BRANCH "trunk" |
| 474 | 474 | #define SQLITE_SCM_TAGS "" |
| 475 | | -#define SQLITE_SCM_DATETIME "2025-11-28T17:56:22.595Z" |
| 475 | +#define SQLITE_SCM_DATETIME "2025-12-05T12:22:23.299Z" |
| 476 | 476 | |
| 477 | 477 | /* |
| 478 | 478 | ** CAPI3REF: Run-Time Library Version Numbers |
| 479 | 479 | ** KEYWORDS: sqlite3_version sqlite3_sourceid |
| 480 | 480 | ** |
| | @@ -1809,11 +1809,11 @@ |
| 1809 | 1809 | ** ^SQLite will use the xCurrentTimeInt64() method to get the current |
| 1810 | 1810 | ** date and time if that method is available (if iVersion is 2 or |
| 1811 | 1811 | ** greater and the function pointer is not NULL) and will fall back |
| 1812 | 1812 | ** to xCurrentTime() if xCurrentTimeInt64() is unavailable. |
| 1813 | 1813 | ** |
| 1814 | | -** ^The xSetSystemCall(), xGetSystemCall(), and xNestSystemCall() interfaces |
| 1814 | +** ^The xSetSystemCall(), xGetSystemCall(), and xNextSystemCall() interfaces |
| 1815 | 1815 | ** are not used by the SQLite core. These optional interfaces are provided |
| 1816 | 1816 | ** by some VFSes to facilitate testing of the VFS code. By overriding |
| 1817 | 1817 | ** system calls with functions under its control, a test program can |
| 1818 | 1818 | ** simulate faults and error conditions that would otherwise be difficult |
| 1819 | 1819 | ** or impossible to induce. The set of system calls that can be overridden |
| | @@ -4493,10 +4493,11 @@ |
| 4493 | 4493 | ** <li> sqlite3_errcode() |
| 4494 | 4494 | ** <li> sqlite3_extended_errcode() |
| 4495 | 4495 | ** <li> sqlite3_errmsg() |
| 4496 | 4496 | ** <li> sqlite3_errmsg16() |
| 4497 | 4497 | ** <li> sqlite3_error_offset() |
| 4498 | +** <li> sqlite3_db_handle() |
| 4498 | 4499 | ** </ul> |
| 4499 | 4500 | ** |
| 4500 | 4501 | ** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language |
| 4501 | 4502 | ** text that describes the error, as either UTF-8 or UTF-16 respectively, |
| 4502 | 4503 | ** or NULL if no error message is available. |
| | @@ -9049,11 +9050,11 @@ |
| 9049 | 9050 | ** and returns a pointer to a memory buffer obtained from [sqlite3_malloc64()] |
| 9050 | 9051 | ** that contains the constructed string. The calling application should |
| 9051 | 9052 | ** pass the returned value to [sqlite3_free()] to avoid a memory leak. |
| 9052 | 9053 | ** ^The [sqlite3_str_finish(X)] interface may return a NULL pointer if any |
| 9053 | 9054 | ** errors were encountered during construction of the string. ^The |
| 9054 | | -** [sqlite3_str_finish(X)] interface will also return a NULL pointer if the |
| 9055 | +** [sqlite3_str_finish(X)] interface might also return a NULL pointer if the |
| 9055 | 9056 | ** string in [sqlite3_str] object X is zero bytes long. |
| 9056 | 9057 | ** |
| 9057 | 9058 | ** ^The [sqlite3_str_free(X)] interface destroys both the sqlite3_str object |
| 9058 | 9059 | ** X and the string content it contains. Calling sqlite3_str_free(X) is |
| 9059 | 9060 | ** the equivalent of calling [sqlite3_free](sqlite3_str_finish(X)). |
| | @@ -14386,10 +14387,13 @@ |
| 14386 | 14387 | ** The maximum length of a single SQL statement in bytes. |
| 14387 | 14388 | ** |
| 14388 | 14389 | ** It used to be the case that setting this value to zero would |
| 14389 | 14390 | ** turn the limit off. That is no longer true. It is not possible |
| 14390 | 14391 | ** to turn this limit off. |
| 14392 | +** |
| 14393 | +** The hard limit is the largest possible 32-bit signed integer less |
| 14394 | +** 1024, or 2147482624. |
| 14391 | 14395 | */ |
| 14392 | 14396 | #ifndef SQLITE_MAX_SQL_LENGTH |
| 14393 | 14397 | # define SQLITE_MAX_SQL_LENGTH 1000000000 |
| 14394 | 14398 | #endif |
| 14395 | 14399 | |
| | @@ -20765,23 +20769,23 @@ |
| 20765 | 20769 | ** |
| 20766 | 20770 | ** (op == TK_INSERT) |
| 20767 | 20771 | ** orconf -> stores the ON CONFLICT algorithm |
| 20768 | 20772 | ** pSelect -> The content to be inserted - either a SELECT statement or |
| 20769 | 20773 | ** a VALUES clause. |
| 20770 | | -** zTarget -> Dequoted name of the table to insert into. |
| 20774 | +** pSrc -> Table to insert into. |
| 20771 | 20775 | ** pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ... |
| 20772 | 20776 | ** statement, then this stores the column-names to be |
| 20773 | 20777 | ** inserted into. |
| 20774 | 20778 | ** pUpsert -> The ON CONFLICT clauses for an Upsert |
| 20775 | 20779 | ** |
| 20776 | 20780 | ** (op == TK_DELETE) |
| 20777 | | -** zTarget -> Dequoted name of the table to delete from. |
| 20781 | +** pSrc -> Table to delete from |
| 20778 | 20782 | ** pWhere -> The WHERE clause of the DELETE statement if one is specified. |
| 20779 | 20783 | ** Otherwise NULL. |
| 20780 | 20784 | ** |
| 20781 | 20785 | ** (op == TK_UPDATE) |
| 20782 | | -** zTarget -> Dequoted name of the table to update. |
| 20786 | +** pSrc -> Table to update, followed by any FROM clause tables. |
| 20783 | 20787 | ** pWhere -> The WHERE clause of the UPDATE statement if one is specified. |
| 20784 | 20788 | ** Otherwise NULL. |
| 20785 | 20789 | ** pExprList -> A list of the columns to update and the expressions to update |
| 20786 | 20790 | ** them to. See sqlite3Update() documentation of "pChanges" |
| 20787 | 20791 | ** argument. |
| | @@ -20797,12 +20801,11 @@ |
| 20797 | 20801 | u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT, |
| 20798 | 20802 | ** or TK_RETURNING */ |
| 20799 | 20803 | u8 orconf; /* OE_Rollback etc. */ |
| 20800 | 20804 | Trigger *pTrig; /* The trigger that this step is a part of */ |
| 20801 | 20805 | Select *pSelect; /* SELECT statement or RHS of INSERT INTO SELECT ... */ |
| 20802 | | - char *zTarget; /* Target table for DELETE, UPDATE, INSERT */ |
| 20803 | | - SrcList *pFrom; /* FROM clause for UPDATE statement (if any) */ |
| 20806 | + SrcList *pSrc; /* Table to insert/update/delete */ |
| 20804 | 20807 | Expr *pWhere; /* The WHERE clause for DELETE or UPDATE steps */ |
| 20805 | 20808 | ExprList *pExprList; /* SET clause for UPDATE, or RETURNING clause */ |
| 20806 | 20809 | IdList *pIdList; /* Column names for INSERT */ |
| 20807 | 20810 | Upsert *pUpsert; /* Upsert clauses on an INSERT */ |
| 20808 | 20811 | char *zSpan; /* Original SQL text of this command */ |
| | @@ -21547,10 +21550,11 @@ |
| 21547 | 21550 | #ifdef SQLITE_DEBUG |
| 21548 | 21551 | SQLITE_PRIVATE int sqlite3NoTempsInRange(Parse*,int,int); |
| 21549 | 21552 | #endif |
| 21550 | 21553 | SQLITE_PRIVATE Expr *sqlite3ExprAlloc(sqlite3*,int,const Token*,int); |
| 21551 | 21554 | SQLITE_PRIVATE Expr *sqlite3Expr(sqlite3*,int,const char*); |
| 21555 | +SQLITE_PRIVATE Expr *sqlite3ExprInt32(sqlite3*,int); |
| 21552 | 21556 | SQLITE_PRIVATE void sqlite3ExprAttachSubtrees(sqlite3*,Expr*,Expr*,Expr*); |
| 21553 | 21557 | SQLITE_PRIVATE Expr *sqlite3PExpr(Parse*, int, Expr*, Expr*); |
| 21554 | 21558 | SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse*, Expr*, Select*); |
| 21555 | 21559 | SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse*,Expr*, Expr*); |
| 21556 | 21560 | SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr*); |
| | @@ -21865,21 +21869,20 @@ |
| 21865 | 21869 | SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect(Parse *, Trigger *, Table *, int, int, int); |
| 21866 | 21870 | void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*); |
| 21867 | 21871 | SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3*, TriggerStep*); |
| 21868 | 21872 | SQLITE_PRIVATE TriggerStep *sqlite3TriggerSelectStep(sqlite3*,Select*, |
| 21869 | 21873 | const char*,const char*); |
| 21870 | | -SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep(Parse*,Token*, IdList*, |
| 21874 | +SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep(Parse*,SrcList*, IdList*, |
| 21871 | 21875 | Select*,u8,Upsert*, |
| 21872 | 21876 | const char*,const char*); |
| 21873 | | -SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep(Parse*,Token*,SrcList*,ExprList*, |
| 21877 | +SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep(Parse*,SrcList*,SrcList*,ExprList*, |
| 21874 | 21878 | Expr*, u8, const char*,const char*); |
| 21875 | | -SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep(Parse*,Token*, Expr*, |
| 21879 | +SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep(Parse*,SrcList*, Expr*, |
| 21876 | 21880 | const char*,const char*); |
| 21877 | 21881 | SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3*, Trigger*); |
| 21878 | 21882 | SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3*,int,const char*); |
| 21879 | 21883 | SQLITE_PRIVATE u32 sqlite3TriggerColmask(Parse*,Trigger*,ExprList*,int,int,Table*,int); |
| 21880 | | -SQLITE_PRIVATE SrcList *sqlite3TriggerStepSrc(Parse*, TriggerStep*); |
| 21881 | 21884 | # define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p)) |
| 21882 | 21885 | # define sqlite3IsToplevel(p) ((p)->pToplevel==0) |
| 21883 | 21886 | #else |
| 21884 | 21887 | # define sqlite3TriggersExist(B,C,D,E,F) 0 |
| 21885 | 21888 | # define sqlite3DeleteTrigger(A,B) |
| | @@ -21889,11 +21892,10 @@ |
| 21889 | 21892 | # define sqlite3CodeRowTriggerDirect(A,B,C,D,E,F) |
| 21890 | 21893 | # define sqlite3TriggerList(X, Y) 0 |
| 21891 | 21894 | # define sqlite3ParseToplevel(p) p |
| 21892 | 21895 | # define sqlite3IsToplevel(p) 1 |
| 21893 | 21896 | # define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0 |
| 21894 | | -# define sqlite3TriggerStepSrc(A,B) 0 |
| 21895 | 21897 | #endif |
| 21896 | 21898 | |
| 21897 | 21899 | SQLITE_PRIVATE int sqlite3JoinType(Parse*, Token*, Token*, Token*); |
| 21898 | 21900 | SQLITE_PRIVATE int sqlite3ColumnIndex(Table *pTab, const char *zCol); |
| 21899 | 21901 | SQLITE_PRIVATE void sqlite3SrcItemColumnUsed(SrcItem*,int); |
| | @@ -41286,15 +41288,21 @@ |
| 41286 | 41288 | }else{ |
| 41287 | 41289 | pFile->eFileLock = SHARED_LOCK; |
| 41288 | 41290 | pInode->nLock++; |
| 41289 | 41291 | pInode->nShared = 1; |
| 41290 | 41292 | } |
| 41291 | | - }else if( (eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1) |
| 41292 | | - || unixIsSharingShmNode(pFile) |
| 41293 | | - ){ |
| 41293 | + }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){ |
| 41294 | 41294 | /* We are trying for an exclusive lock but another thread in this |
| 41295 | 41295 | ** same process is still holding a shared lock. */ |
| 41296 | + rc = SQLITE_BUSY; |
| 41297 | + }else if( unixIsSharingShmNode(pFile) ){ |
| 41298 | + /* We are in WAL mode and attempting to delete the SHM and WAL |
| 41299 | + ** files due to closing the connection or changing out of WAL mode, |
| 41300 | + ** but another process still holds locks on the SHM file, thus |
| 41301 | + ** indicating that database locks have been broken, perhaps due |
| 41302 | + ** to a rogue close(open(dbFile)) or similar. |
| 41303 | + */ |
| 41296 | 41304 | rc = SQLITE_BUSY; |
| 41297 | 41305 | }else{ |
| 41298 | 41306 | /* The request was for a RESERVED or EXCLUSIVE lock. It is |
| 41299 | 41307 | ** assumed that there is a SHARED or greater lock on the file |
| 41300 | 41308 | ** already. |
| | @@ -43930,30 +43938,25 @@ |
| 43930 | 43938 | ** connection from running "PRAGMA journal_mode=DELETE" in order to take |
| 43931 | 43939 | ** the database out of WAL mode, which is perhaps more serious, but is |
| 43932 | 43940 | ** still not a disaster. |
| 43933 | 43941 | */ |
| 43934 | 43942 | static int unixIsSharingShmNode(unixFile *pFile){ |
| 43935 | | - int rc; |
| 43936 | 43943 | unixShmNode *pShmNode; |
| 43944 | + struct flock lock; |
| 43937 | 43945 | if( pFile->pShm==0 ) return 0; |
| 43938 | 43946 | if( pFile->ctrlFlags & UNIXFILE_EXCL ) return 0; |
| 43939 | 43947 | pShmNode = pFile->pShm->pShmNode; |
| 43940 | | - rc = 1; |
| 43941 | | - unixEnterMutex(); |
| 43942 | | - if( ALWAYS(pShmNode->nRef==1) ){ |
| 43943 | | - struct flock lock; |
| 43944 | | - lock.l_whence = SEEK_SET; |
| 43945 | | - lock.l_start = UNIX_SHM_DMS; |
| 43946 | | - lock.l_len = 1; |
| 43947 | | - lock.l_type = F_WRLCK; |
| 43948 | | - osFcntl(pShmNode->hShm, F_GETLK, &lock); |
| 43949 | | - if( lock.l_type==F_UNLCK ){ |
| 43950 | | - rc = 0; |
| 43951 | | - } |
| 43952 | | - } |
| 43953 | | - unixLeaveMutex(); |
| 43954 | | - return rc; |
| 43948 | +#if SQLITE_ATOMIC_INTRINSICS |
| 43949 | + assert( AtomicLoad(&pShmNode->nRef)==1 ); |
| 43950 | +#endif |
| 43951 | + memset(&lock, 0, sizeof(lock)); |
| 43952 | + lock.l_whence = SEEK_SET; |
| 43953 | + lock.l_start = UNIX_SHM_DMS; |
| 43954 | + lock.l_len = 1; |
| 43955 | + lock.l_type = F_WRLCK; |
| 43956 | + osFcntl(pShmNode->hShm, F_GETLK, &lock); |
| 43957 | + return (lock.l_type!=F_UNLCK); |
| 43955 | 43958 | } |
| 43956 | 43959 | |
| 43957 | 43960 | /* |
| 43958 | 43961 | ** Apply posix advisory locks for all bytes from ofst through ofst+n-1. |
| 43959 | 43962 | ** |
| | @@ -110848,14 +110851,12 @@ |
| 110848 | 110851 | } |
| 110849 | 110852 | if( iCol>0 ){ |
| 110850 | 110853 | /* Convert the ORDER BY term into an integer column number iCol, |
| 110851 | 110854 | ** taking care to preserve the COLLATE clause if it exists. */ |
| 110852 | 110855 | if( !IN_RENAME_OBJECT ){ |
| 110853 | | - Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0); |
| 110856 | + Expr *pNew = sqlite3ExprInt32(db, iCol); |
| 110854 | 110857 | if( pNew==0 ) return 1; |
| 110855 | | - pNew->flags |= EP_IntValue; |
| 110856 | | - pNew->u.iValue = iCol; |
| 110857 | 110858 | if( pItem->pExpr==pE ){ |
| 110858 | 110859 | pItem->pExpr = pNew; |
| 110859 | 110860 | }else{ |
| 110860 | 110861 | Expr *pParent = pItem->pExpr; |
| 110861 | 110862 | assert( pParent->op==TK_COLLATE ); |
| | @@ -112447,38 +112448,26 @@ |
| 112447 | 112448 | int op, /* Expression opcode */ |
| 112448 | 112449 | const Token *pToken, /* Token argument. Might be NULL */ |
| 112449 | 112450 | int dequote /* True to dequote */ |
| 112450 | 112451 | ){ |
| 112451 | 112452 | Expr *pNew; |
| 112452 | | - int nExtra = 0; |
| 112453 | | - int iValue = 0; |
| 112453 | + int nExtra = pToken ? pToken->n+1 : 0; |
| 112454 | 112454 | |
| 112455 | 112455 | assert( db!=0 ); |
| 112456 | | - if( pToken ){ |
| 112457 | | - if( op!=TK_INTEGER || pToken->z==0 |
| 112458 | | - || sqlite3GetInt32(pToken->z, &iValue)==0 ){ |
| 112459 | | - nExtra = pToken->n+1; /* tag-20240227-a */ |
| 112460 | | - assert( iValue>=0 ); |
| 112461 | | - } |
| 112462 | | - } |
| 112463 | 112456 | pNew = sqlite3DbMallocRawNN(db, sizeof(Expr)+nExtra); |
| 112464 | 112457 | if( pNew ){ |
| 112465 | 112458 | memset(pNew, 0, sizeof(Expr)); |
| 112466 | 112459 | pNew->op = (u8)op; |
| 112467 | 112460 | pNew->iAgg = -1; |
| 112468 | | - if( pToken ){ |
| 112469 | | - if( nExtra==0 ){ |
| 112470 | | - pNew->flags |= EP_IntValue|EP_Leaf|(iValue?EP_IsTrue:EP_IsFalse); |
| 112471 | | - pNew->u.iValue = iValue; |
| 112472 | | - }else{ |
| 112473 | | - pNew->u.zToken = (char*)&pNew[1]; |
| 112474 | | - assert( pToken->z!=0 || pToken->n==0 ); |
| 112475 | | - if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n); |
| 112476 | | - pNew->u.zToken[pToken->n] = 0; |
| 112477 | | - if( dequote && sqlite3Isquote(pNew->u.zToken[0]) ){ |
| 112478 | | - sqlite3DequoteExpr(pNew); |
| 112479 | | - } |
| 112461 | + if( nExtra ){ |
| 112462 | + assert( pToken!=0 ); |
| 112463 | + pNew->u.zToken = (char*)&pNew[1]; |
| 112464 | + assert( pToken->z!=0 || pToken->n==0 ); |
| 112465 | + if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n); |
| 112466 | + pNew->u.zToken[pToken->n] = 0; |
| 112467 | + if( dequote && sqlite3Isquote(pNew->u.zToken[0]) ){ |
| 112468 | + sqlite3DequoteExpr(pNew); |
| 112480 | 112469 | } |
| 112481 | 112470 | } |
| 112482 | 112471 | #if SQLITE_MAX_EXPR_DEPTH>0 |
| 112483 | 112472 | pNew->nHeight = 1; |
| 112484 | 112473 | #endif |
| | @@ -112498,10 +112487,28 @@ |
| 112498 | 112487 | Token x; |
| 112499 | 112488 | x.z = zToken; |
| 112500 | 112489 | x.n = sqlite3Strlen30(zToken); |
| 112501 | 112490 | return sqlite3ExprAlloc(db, op, &x, 0); |
| 112502 | 112491 | } |
| 112492 | + |
| 112493 | +/* |
| 112494 | +** Allocate an expression for a 32-bit signed integer literal. |
| 112495 | +*/ |
| 112496 | +SQLITE_PRIVATE Expr *sqlite3ExprInt32(sqlite3 *db, int iVal){ |
| 112497 | + Expr *pNew = sqlite3DbMallocRawNN(db, sizeof(Expr)); |
| 112498 | + if( pNew ){ |
| 112499 | + memset(pNew, 0, sizeof(Expr)); |
| 112500 | + pNew->op = TK_INTEGER; |
| 112501 | + pNew->iAgg = -1; |
| 112502 | + pNew->flags = EP_IntValue|EP_Leaf|(iVal?EP_IsTrue:EP_IsFalse); |
| 112503 | + pNew->u.iValue = iVal; |
| 112504 | +#if SQLITE_MAX_EXPR_DEPTH>0 |
| 112505 | + pNew->nHeight = 1; |
| 112506 | +#endif |
| 112507 | + } |
| 112508 | + return pNew; |
| 112509 | +} |
| 112503 | 112510 | |
| 112504 | 112511 | /* |
| 112505 | 112512 | ** Attach subtrees pLeft and pRight to the Expr node pRoot. |
| 112506 | 112513 | ** |
| 112507 | 112514 | ** If pRoot==NULL that means that a memory allocation error has occurred. |
| | @@ -112661,11 +112668,11 @@ |
| 112661 | 112668 | if( (f&(EP_OuterON|EP_InnerON|EP_IsFalse|EP_HasFunc))==EP_IsFalse |
| 112662 | 112669 | && !IN_RENAME_OBJECT |
| 112663 | 112670 | ){ |
| 112664 | 112671 | sqlite3ExprDeferredDelete(pParse, pLeft); |
| 112665 | 112672 | sqlite3ExprDeferredDelete(pParse, pRight); |
| 112666 | | - return sqlite3Expr(db, TK_INTEGER, "0"); |
| 112673 | + return sqlite3ExprInt32(db, 0); |
| 112667 | 112674 | }else{ |
| 112668 | 112675 | return sqlite3PExpr(pParse, TK_AND, pLeft, pRight); |
| 112669 | 112676 | } |
| 112670 | 112677 | } |
| 112671 | 112678 | } |
| | @@ -114136,11 +114143,11 @@ |
| 114136 | 114143 | return w.eCode; |
| 114137 | 114144 | } |
| 114138 | 114145 | |
| 114139 | 114146 | /* |
| 114140 | 114147 | ** Walk an expression tree. Return non-zero if the expression is constant |
| 114141 | | -** and 0 if it involves variables or function calls. |
| 114148 | +** or return zero if the expression involves variables or function calls. |
| 114142 | 114149 | ** |
| 114143 | 114150 | ** For the purposes of this function, a double-quoted string (ex: "abc") |
| 114144 | 114151 | ** is considered a variable but a single-quoted string (ex: 'abc') is |
| 114145 | 114152 | ** a constant. |
| 114146 | 114153 | ** |
| | @@ -115403,13 +115410,26 @@ |
| 115403 | 115410 | nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1; |
| 115404 | 115411 | sqlite3SelectDestInit(&dest, 0, pParse->nMem+1); |
| 115405 | 115412 | pParse->nMem += nReg; |
| 115406 | 115413 | if( pExpr->op==TK_SELECT ){ |
| 115407 | 115414 | dest.eDest = SRT_Mem; |
| 115408 | | - dest.iSdst = dest.iSDParm; |
| 115415 | + if( (pSel->selFlags&SF_Distinct) && pSel->pLimit && pSel->pLimit->pRight ){ |
| 115416 | + /* If there is both a DISTINCT and an OFFSET clause, then allocate |
| 115417 | + ** a separate dest.iSdst array for sqlite3Select() and other |
| 115418 | + ** routines to populate. In this case results will be copied over |
| 115419 | + ** into the dest.iSDParm array only after OFFSET processing. This |
| 115420 | + ** ensures that in the case where OFFSET excludes all rows, the |
| 115421 | + ** dest.iSDParm array is not left populated with the contents of the |
| 115422 | + ** last row visited - it should be all NULLs if all rows were |
| 115423 | + ** excluded by OFFSET. */ |
| 115424 | + dest.iSdst = pParse->nMem+1; |
| 115425 | + pParse->nMem += nReg; |
| 115426 | + }else{ |
| 115427 | + dest.iSdst = dest.iSDParm; |
| 115428 | + } |
| 115409 | 115429 | dest.nSdst = nReg; |
| 115410 | | - sqlite3VdbeAddOp3(v, OP_Null, 0, dest.iSDParm, dest.iSDParm+nReg-1); |
| 115430 | + sqlite3VdbeAddOp3(v, OP_Null, 0, dest.iSDParm, pParse->nMem); |
| 115411 | 115431 | VdbeComment((v, "Init subquery result")); |
| 115412 | 115432 | }else{ |
| 115413 | 115433 | dest.eDest = SRT_Exists; |
| 115414 | 115434 | sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iSDParm); |
| 115415 | 115435 | VdbeComment((v, "Init EXISTS result")); |
| | @@ -115421,11 +115441,11 @@ |
| 115421 | 115441 | Expr *pLeft = pSel->pLimit->pLeft; |
| 115422 | 115442 | if( ExprHasProperty(pLeft, EP_IntValue)==0 |
| 115423 | 115443 | || (pLeft->u.iValue!=1 && pLeft->u.iValue!=0) |
| 115424 | 115444 | ){ |
| 115425 | 115445 | sqlite3 *db = pParse->db; |
| 115426 | | - pLimit = sqlite3Expr(db, TK_INTEGER, "0"); |
| 115446 | + pLimit = sqlite3ExprInt32(db, 0); |
| 115427 | 115447 | if( pLimit ){ |
| 115428 | 115448 | pLimit->affExpr = SQLITE_AFF_NUMERIC; |
| 115429 | 115449 | pLimit = sqlite3PExpr(pParse, TK_NE, |
| 115430 | 115450 | sqlite3ExprDup(db, pLeft, 0), pLimit); |
| 115431 | 115451 | } |
| | @@ -115432,11 +115452,11 @@ |
| 115432 | 115452 | sqlite3ExprDeferredDelete(pParse, pLeft); |
| 115433 | 115453 | pSel->pLimit->pLeft = pLimit; |
| 115434 | 115454 | } |
| 115435 | 115455 | }else{ |
| 115436 | 115456 | /* If there is no pre-existing limit add a limit of 1 */ |
| 115437 | | - pLimit = sqlite3Expr(pParse->db, TK_INTEGER, "1"); |
| 115457 | + pLimit = sqlite3ExprInt32(pParse->db, 1); |
| 115438 | 115458 | pSel->pLimit = sqlite3PExpr(pParse, TK_LIMIT, pLimit, 0); |
| 115439 | 115459 | } |
| 115440 | 115460 | pSel->iLimit = 0; |
| 115441 | 115461 | if( sqlite3Select(pParse, pSel, &dest) ){ |
| 115442 | 115462 | pExpr->op2 = pExpr->op; |
| | @@ -120551,12 +120571,12 @@ |
| 120551 | 120571 | for(pStep=pNew->step_list; rc==SQLITE_OK && pStep; pStep=pStep->pNext){ |
| 120552 | 120572 | if( pStep->pSelect ){ |
| 120553 | 120573 | sqlite3SelectPrep(pParse, pStep->pSelect, &sNC); |
| 120554 | 120574 | if( pParse->nErr ) rc = pParse->rc; |
| 120555 | 120575 | } |
| 120556 | | - if( rc==SQLITE_OK && pStep->zTarget ){ |
| 120557 | | - SrcList *pSrc = sqlite3TriggerStepSrc(pParse, pStep); |
| 120576 | + if( rc==SQLITE_OK && pStep->pSrc ){ |
| 120577 | + SrcList *pSrc = sqlite3SrcListDup(db, pStep->pSrc, 0); |
| 120558 | 120578 | if( pSrc ){ |
| 120559 | 120579 | Select *pSel = sqlite3SelectNew( |
| 120560 | 120580 | pParse, pStep->pExprList, pSrc, 0, 0, 0, 0, 0, 0 |
| 120561 | 120581 | ); |
| 120562 | 120582 | if( pSel==0 ){ |
| | @@ -120580,14 +120600,14 @@ |
| 120580 | 120600 | assert( pSrc==pSel->pSrc ); |
| 120581 | 120601 | if( pStep->pExprList ) pSel->pEList = 0; |
| 120582 | 120602 | pSel->pSrc = 0; |
| 120583 | 120603 | sqlite3SelectDelete(db, pSel); |
| 120584 | 120604 | } |
| 120585 | | - if( pStep->pFrom ){ |
| 120605 | + if( ALWAYS(pStep->pSrc) ){ |
| 120586 | 120606 | int i; |
| 120587 | | - for(i=0; i<pStep->pFrom->nSrc && rc==SQLITE_OK; i++){ |
| 120588 | | - SrcItem *p = &pStep->pFrom->a[i]; |
| 120607 | + for(i=0; i<pStep->pSrc->nSrc && rc==SQLITE_OK; i++){ |
| 120608 | + SrcItem *p = &pStep->pSrc->a[i]; |
| 120589 | 120609 | if( p->fg.isSubquery ){ |
| 120590 | 120610 | assert( p->u4.pSubq!=0 ); |
| 120591 | 120611 | sqlite3SelectPrep(pParse, p->u4.pSubq->pSelect, 0); |
| 120592 | 120612 | } |
| 120593 | 120613 | } |
| | @@ -120652,17 +120672,17 @@ |
| 120652 | 120672 | sqlite3WalkExprList(pWalker, pUpsert->pUpsertTarget); |
| 120653 | 120673 | sqlite3WalkExprList(pWalker, pUpsert->pUpsertSet); |
| 120654 | 120674 | sqlite3WalkExpr(pWalker, pUpsert->pUpsertWhere); |
| 120655 | 120675 | sqlite3WalkExpr(pWalker, pUpsert->pUpsertTargetWhere); |
| 120656 | 120676 | } |
| 120657 | | - if( pStep->pFrom ){ |
| 120677 | + if( pStep->pSrc ){ |
| 120658 | 120678 | int i; |
| 120659 | | - SrcList *pFrom = pStep->pFrom; |
| 120660 | | - for(i=0; i<pFrom->nSrc; i++){ |
| 120661 | | - if( pFrom->a[i].fg.isSubquery ){ |
| 120662 | | - assert( pFrom->a[i].u4.pSubq!=0 ); |
| 120663 | | - sqlite3WalkSelect(pWalker, pFrom->a[i].u4.pSubq->pSelect); |
| 120679 | + SrcList *pSrc = pStep->pSrc; |
| 120680 | + for(i=0; i<pSrc->nSrc; i++){ |
| 120681 | + if( pSrc->a[i].fg.isSubquery ){ |
| 120682 | + assert( pSrc->a[i].u4.pSubq!=0 ); |
| 120683 | + sqlite3WalkSelect(pWalker, pSrc->a[i].u4.pSubq->pSelect); |
| 120664 | 120684 | } |
| 120665 | 120685 | } |
| 120666 | 120686 | } |
| 120667 | 120687 | } |
| 120668 | 120688 | } |
| | @@ -120829,12 +120849,12 @@ |
| 120829 | 120849 | TriggerStep *pStep; |
| 120830 | 120850 | rc = renameResolveTrigger(&sParse); |
| 120831 | 120851 | if( rc!=SQLITE_OK ) goto renameColumnFunc_done; |
| 120832 | 120852 | |
| 120833 | 120853 | for(pStep=sParse.pNewTrigger->step_list; pStep; pStep=pStep->pNext){ |
| 120834 | | - if( pStep->zTarget ){ |
| 120835 | | - Table *pTarget = sqlite3LocateTable(&sParse, 0, pStep->zTarget, zDb); |
| 120854 | + if( pStep->pSrc ){ |
| 120855 | + Table *pTarget = sqlite3LocateTableItem(&sParse, 0, &pStep->pSrc->a[0]); |
| 120836 | 120856 | if( pTarget==pTab ){ |
| 120837 | 120857 | if( pStep->pUpsert ){ |
| 120838 | 120858 | ExprList *pUpsertSet = pStep->pUpsert->pUpsertSet; |
| 120839 | 120859 | renameColumnElistNames(&sParse, &sCtx, pUpsertSet, zOld); |
| 120840 | 120860 | } |
| | @@ -120841,11 +120861,10 @@ |
| 120841 | 120861 | renameColumnIdlistNames(&sParse, &sCtx, pStep->pIdList, zOld); |
| 120842 | 120862 | renameColumnElistNames(&sParse, &sCtx, pStep->pExprList, zOld); |
| 120843 | 120863 | } |
| 120844 | 120864 | } |
| 120845 | 120865 | } |
| 120846 | | - |
| 120847 | 120866 | |
| 120848 | 120867 | /* Find tokens to edit in UPDATE OF clause */ |
| 120849 | 120868 | if( sParse.pTriggerTab==pTab ){ |
| 120850 | 120869 | renameColumnIdlistNames(&sParse, &sCtx,sParse.pNewTrigger->pColumns,zOld); |
| 120851 | 120870 | } |
| | @@ -121044,17 +121063,14 @@ |
| 121044 | 121063 | if( isLegacy==0 ){ |
| 121045 | 121064 | rc = renameResolveTrigger(&sParse); |
| 121046 | 121065 | if( rc==SQLITE_OK ){ |
| 121047 | 121066 | renameWalkTrigger(&sWalker, pTrigger); |
| 121048 | 121067 | for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){ |
| 121049 | | - if( pStep->zTarget && 0==sqlite3_stricmp(pStep->zTarget, zOld) ){ |
| 121050 | | - renameTokenFind(&sParse, &sCtx, pStep->zTarget); |
| 121051 | | - } |
| 121052 | | - if( pStep->pFrom ){ |
| 121068 | + if( pStep->pSrc ){ |
| 121053 | 121069 | int i; |
| 121054 | | - for(i=0; i<pStep->pFrom->nSrc; i++){ |
| 121055 | | - SrcItem *pItem = &pStep->pFrom->a[i]; |
| 121070 | + for(i=0; i<pStep->pSrc->nSrc; i++){ |
| 121071 | + SrcItem *pItem = &pStep->pSrc->a[i]; |
| 121056 | 121072 | if( 0==sqlite3_stricmp(pItem->zName, zOld) ){ |
| 121057 | 121073 | renameTokenFind(&sParse, &sCtx, pItem->zName); |
| 121058 | 121074 | } |
| 121059 | 121075 | } |
| 121060 | 121076 | } |
| | @@ -121297,10 +121313,61 @@ |
| 121297 | 121313 | #ifndef SQLITE_OMIT_AUTHORIZATION |
| 121298 | 121314 | db->xAuth = xAuth; |
| 121299 | 121315 | #endif |
| 121300 | 121316 | } |
| 121301 | 121317 | |
| 121318 | + |
| 121319 | +/* |
| 121320 | +** Return the number of bytes until the end of the next non-whitespace and |
| 121321 | +** non-comment token. For the purpose of this function, a "(" token includes |
| 121322 | +** all of the bytes through and including the matching ")", or until the |
| 121323 | +** first illegal token, whichever comes first. |
| 121324 | +** |
| 121325 | +** Write the token type into *piToken. |
| 121326 | +** |
| 121327 | +** The value returned is the number of bytes in the token itself plus |
| 121328 | +** the number of bytes of leading whitespace and comments skipped plus |
| 121329 | +** all bytes through the next matching ")" if the token is TK_LP. |
| 121330 | +** |
| 121331 | +** Example: (Note: '.' used in place of '*' in the example z[] text) |
| 121332 | +** |
| 121333 | +** ,--------- *piToken := TK_RP |
| 121334 | +** v |
| 121335 | +** z[] = " /.comment./ --comment\n (two three four) five" |
| 121336 | +** | | |
| 121337 | +** |<-------------------------------------->| |
| 121338 | +** | |
| 121339 | +** `--- return value |
| 121340 | +*/ |
| 121341 | +static int getConstraintToken(const u8 *z, int *piToken){ |
| 121342 | + int iOff = 0; |
| 121343 | + int t = 0; |
| 121344 | + do { |
| 121345 | + iOff += sqlite3GetToken(&z[iOff], &t); |
| 121346 | + }while( t==TK_SPACE || t==TK_COMMENT ); |
| 121347 | + |
| 121348 | + *piToken = t; |
| 121349 | + |
| 121350 | + if( t==TK_LP ){ |
| 121351 | + int nNest = 1; |
| 121352 | + while( nNest>0 ){ |
| 121353 | + iOff += sqlite3GetToken(&z[iOff], &t); |
| 121354 | + if( t==TK_LP ){ |
| 121355 | + nNest++; |
| 121356 | + }else if( t==TK_RP ){ |
| 121357 | + t = TK_LP; |
| 121358 | + nNest--; |
| 121359 | + }else if( t==TK_ILLEGAL ){ |
| 121360 | + break; |
| 121361 | + } |
| 121362 | + } |
| 121363 | + } |
| 121364 | + |
| 121365 | + *piToken = t; |
| 121366 | + return iOff; |
| 121367 | +} |
| 121368 | + |
| 121302 | 121369 | /* |
| 121303 | 121370 | ** The implementation of internal UDF sqlite_drop_column(). |
| 121304 | 121371 | ** |
| 121305 | 121372 | ** Arguments: |
| 121306 | 121373 | ** |
| | @@ -121341,19 +121408,28 @@ |
| 121341 | 121408 | /* This can happen if the sqlite_schema table is corrupt */ |
| 121342 | 121409 | rc = SQLITE_CORRUPT_BKPT; |
| 121343 | 121410 | goto drop_column_done; |
| 121344 | 121411 | } |
| 121345 | 121412 | |
| 121346 | | - pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol].zCnName); |
| 121347 | 121413 | if( iCol<pTab->nCol-1 ){ |
| 121348 | 121414 | RenameToken *pEnd; |
| 121415 | + pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol].zCnName); |
| 121349 | 121416 | pEnd = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol+1].zCnName); |
| 121350 | 121417 | zEnd = (const char*)pEnd->t.z; |
| 121351 | 121418 | }else{ |
| 121419 | + int eTok; |
| 121352 | 121420 | assert( IsOrdinaryTable(pTab) ); |
| 121421 | + assert( iCol!=0 ); |
| 121422 | + /* Point pCol->t.z at the "," immediately preceding the definition of |
| 121423 | + ** the column being dropped. To do this, start at the name of the |
| 121424 | + ** previous column, and tokenize until the next ",". */ |
| 121425 | + pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol-1].zCnName); |
| 121426 | + do { |
| 121427 | + pCol->t.z += getConstraintToken((const u8*)pCol->t.z, &eTok); |
| 121428 | + }while( eTok!=TK_COMMA ); |
| 121429 | + pCol->t.z--; |
| 121353 | 121430 | zEnd = (const char*)&zSql[pTab->u.tab.addColOffset]; |
| 121354 | | - while( ALWAYS(pCol->t.z[0]!=0) && pCol->t.z[0]!=',' ) pCol->t.z--; |
| 121355 | 121431 | } |
| 121356 | 121432 | |
| 121357 | 121433 | zNew = sqlite3MPrintf(db, "%.*s%s", pCol->t.z-zSql, zSql, zEnd); |
| 121358 | 121434 | sqlite3_result_text(context, zNew, -1, SQLITE_TRANSIENT); |
| 121359 | 121435 | sqlite3_free(zNew); |
| | @@ -121533,60 +121609,10 @@ |
| 121533 | 121609 | } |
| 121534 | 121610 | return nRet; |
| 121535 | 121611 | } |
| 121536 | 121612 | |
| 121537 | 121613 | |
| 121538 | | -/* |
| 121539 | | -** Return the number of bytes until the end of the next non-whitespace and |
| 121540 | | -** non-comment token. For the purpose of this function, a "(" token includes |
| 121541 | | -** all of the bytes through and including the matching ")", or until the |
| 121542 | | -** first illegal token, whichever comes first. |
| 121543 | | -** |
| 121544 | | -** Write the token type into *piToken. |
| 121545 | | -** |
| 121546 | | -** The value returned is the number of bytes in the token itself plus |
| 121547 | | -** the number of bytes of leading whitespace and comments skipped plus |
| 121548 | | -** all bytes through the next matching ")" if the token is TK_LP. |
| 121549 | | -** |
| 121550 | | -** Example: (Note: '.' used in place of '*' in the example z[] text) |
| 121551 | | -** |
| 121552 | | -** ,--------- *piToken := TK_RP |
| 121553 | | -** v |
| 121554 | | -** z[] = " /.comment./ --comment\n (two three four) five" |
| 121555 | | -** | | |
| 121556 | | -** |<-------------------------------------->| |
| 121557 | | -** | |
| 121558 | | -** `--- return value |
| 121559 | | -*/ |
| 121560 | | -static int getConstraintToken(const u8 *z, int *piToken){ |
| 121561 | | - int iOff = 0; |
| 121562 | | - int t = 0; |
| 121563 | | - do { |
| 121564 | | - iOff += sqlite3GetToken(&z[iOff], &t); |
| 121565 | | - }while( t==TK_SPACE || t==TK_COMMENT ); |
| 121566 | | - |
| 121567 | | - *piToken = t; |
| 121568 | | - |
| 121569 | | - if( t==TK_LP ){ |
| 121570 | | - int nNest = 1; |
| 121571 | | - while( nNest>0 ){ |
| 121572 | | - iOff += sqlite3GetToken(&z[iOff], &t); |
| 121573 | | - if( t==TK_LP ){ |
| 121574 | | - nNest++; |
| 121575 | | - }else if( t==TK_RP ){ |
| 121576 | | - t = TK_LP; |
| 121577 | | - nNest--; |
| 121578 | | - }else if( t==TK_ILLEGAL ){ |
| 121579 | | - break; |
| 121580 | | - } |
| 121581 | | - } |
| 121582 | | - } |
| 121583 | | - |
| 121584 | | - *piToken = t; |
| 121585 | | - return iOff; |
| 121586 | | -} |
| 121587 | | - |
| 121588 | 121614 | /* |
| 121589 | 121615 | ** Argument z points into the body of a constraint - specifically the |
| 121590 | 121616 | ** second token of the constraint definition. For a named constraint, |
| 121591 | 121617 | ** z points to the first token past the CONSTRAINT keyword. For an |
| 121592 | 121618 | ** unnamed NOT NULL constraint, z points to the first byte past the NOT |
| | @@ -121632,17 +121658,22 @@ |
| 121632 | 121658 | ** non-zero if they differ. Normally return SQLITE_OK, except if there |
| 121633 | 121659 | ** is an OOM, set the OOM error condition on ctx and return SQLITE_NOMEM. |
| 121634 | 121660 | */ |
| 121635 | 121661 | static int quotedCompare( |
| 121636 | 121662 | sqlite3_context *ctx, /* Function context on which to report errors */ |
| 121663 | + int t, /* Token type */ |
| 121637 | 121664 | const u8 *zQuote, /* Possibly quoted text. Not zero-terminated. */ |
| 121638 | 121665 | int nQuote, /* Length of zQuote in bytes */ |
| 121639 | 121666 | const u8 *zCmp, /* Zero-terminated, unquoted name to compare against */ |
| 121640 | 121667 | int *pRes /* OUT: Set to 0 if equal, non-zero if unequal */ |
| 121641 | 121668 | ){ |
| 121642 | 121669 | char *zCopy = 0; /* De-quoted, zero-terminated copy of zQuote[] */ |
| 121643 | 121670 | |
| 121671 | + if( t==TK_ILLEGAL ){ |
| 121672 | + *pRes = 1; |
| 121673 | + return SQLITE_OK; |
| 121674 | + } |
| 121644 | 121675 | zCopy = sqlite3MallocZero(nQuote+1); |
| 121645 | 121676 | if( zCopy==0 ){ |
| 121646 | 121677 | sqlite3_result_error_nomem(ctx); |
| 121647 | 121678 | return SQLITE_NOMEM_BKPT; |
| 121648 | 121679 | } |
| | @@ -121737,11 +121768,11 @@ |
| 121737 | 121768 | |
| 121738 | 121769 | /* Compare the next token - which may be quoted - with the name of |
| 121739 | 121770 | ** the constraint being dropped. */ |
| 121740 | 121771 | nTok = getConstraintToken(&zSql[iOff], &t); |
| 121741 | 121772 | if( zCons ){ |
| 121742 | | - if( quotedCompare(ctx, &zSql[iOff], nTok, zCons, &cmp) ) return; |
| 121773 | + if( quotedCompare(ctx, t, &zSql[iOff], nTok, zCons, &cmp) ) return; |
| 121743 | 121774 | } |
| 121744 | 121775 | iOff += nTok; |
| 121745 | 121776 | |
| 121746 | 121777 | /* The next token is usually the first token of the constraint |
| 121747 | 121778 | ** definition. This is enough to tell the type of the constraint - |
| | @@ -122131,11 +122162,11 @@ |
| 122131 | 122162 | if( t==TK_CONSTRAINT ){ |
| 122132 | 122163 | int nTok = 0; |
| 122133 | 122164 | int cmp = 0; |
| 122134 | 122165 | iOff += getWhitespace(&zSql[iOff]); |
| 122135 | 122166 | nTok = getConstraintToken(&zSql[iOff], &t); |
| 122136 | | - if( quotedCompare(ctx, &zSql[iOff], nTok, zCons, &cmp) ) return; |
| 122167 | + if( quotedCompare(ctx, t, &zSql[iOff], nTok, zCons, &cmp) ) return; |
| 122137 | 122168 | if( cmp==0 ){ |
| 122138 | 122169 | sqlite3_result_int(ctx, 1); |
| 122139 | 122170 | return; |
| 122140 | 122171 | } |
| 122141 | 122172 | }else if( t==TK_ILLEGAL ){ |
| | @@ -124842,11 +124873,11 @@ |
| 124842 | 124873 | ){ |
| 124843 | 124874 | while( pStep ){ |
| 124844 | 124875 | if( sqlite3WalkSelect(&pFix->w, pStep->pSelect) |
| 124845 | 124876 | || sqlite3WalkExpr(&pFix->w, pStep->pWhere) |
| 124846 | 124877 | || sqlite3WalkExprList(&pFix->w, pStep->pExprList) |
| 124847 | | - || sqlite3FixSrcList(pFix, pStep->pFrom) |
| 124878 | + || sqlite3FixSrcList(pFix, pStep->pSrc) |
| 124848 | 124879 | ){ |
| 124849 | 124880 | return 1; |
| 124850 | 124881 | } |
| 124851 | 124882 | #ifndef SQLITE_OMIT_UPSERT |
| 124852 | 124883 | { |
| | @@ -136687,10 +136718,11 @@ |
| 136687 | 136718 | ** the lookaside buffer belonging to database handle dbMem. |
| 136688 | 136719 | */ |
| 136689 | 136720 | static void fkTriggerDelete(sqlite3 *dbMem, Trigger *p){ |
| 136690 | 136721 | if( p ){ |
| 136691 | 136722 | TriggerStep *pStep = p->step_list; |
| 136723 | + sqlite3SrcListDelete(dbMem, pStep->pSrc); |
| 136692 | 136724 | sqlite3ExprDelete(dbMem, pStep->pWhere); |
| 136693 | 136725 | sqlite3ExprListDelete(dbMem, pStep->pExprList); |
| 136694 | 136726 | sqlite3SelectDelete(dbMem, pStep->pSelect); |
| 136695 | 136727 | sqlite3ExprDelete(dbMem, p->pWhen); |
| 136696 | 136728 | sqlite3DbFree(dbMem, p); |
| | @@ -137353,18 +137385,18 @@ |
| 137353 | 137385 | /* Disable lookaside memory allocation */ |
| 137354 | 137386 | DisableLookaside; |
| 137355 | 137387 | |
| 137356 | 137388 | pTrigger = (Trigger *)sqlite3DbMallocZero(db, |
| 137357 | 137389 | sizeof(Trigger) + /* struct Trigger */ |
| 137358 | | - sizeof(TriggerStep) + /* Single step in trigger program */ |
| 137359 | | - nFrom + 1 /* Space for pStep->zTarget */ |
| 137390 | + sizeof(TriggerStep) /* Single step in trigger program */ |
| 137360 | 137391 | ); |
| 137361 | 137392 | if( pTrigger ){ |
| 137362 | 137393 | pStep = pTrigger->step_list = (TriggerStep *)&pTrigger[1]; |
| 137363 | | - pStep->zTarget = (char *)&pStep[1]; |
| 137364 | | - memcpy((char *)pStep->zTarget, zFrom, nFrom); |
| 137365 | | - |
| 137394 | + pStep->pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); |
| 137395 | + if( pStep->pSrc ){ |
| 137396 | + pStep->pSrc->a[0].zName = sqlite3DbStrNDup(db, zFrom, nFrom); |
| 137397 | + } |
| 137366 | 137398 | pStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); |
| 137367 | 137399 | pStep->pExprList = sqlite3ExprListDup(db, pList, EXPRDUP_REDUCE); |
| 137368 | 137400 | pStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); |
| 137369 | 137401 | if( pWhen ){ |
| 137370 | 137402 | pWhen = sqlite3PExpr(pParse, TK_NOT, pWhen, 0); |
| | @@ -148998,13 +149030,18 @@ |
| 148998 | 149030 | case SRT_Mem: { |
| 148999 | 149031 | if( pSort ){ |
| 149000 | 149032 | assert( nResultCol<=pDest->nSdst ); |
| 149001 | 149033 | pushOntoSorter( |
| 149002 | 149034 | pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg); |
| 149035 | + pDest->iSDParm = regResult; |
| 149003 | 149036 | }else{ |
| 149004 | 149037 | assert( nResultCol==pDest->nSdst ); |
| 149005 | | - assert( regResult==iParm ); |
| 149038 | + if( regResult!=iParm ){ |
| 149039 | + /* This occurs in cases where the SELECT had both a DISTINCT and |
| 149040 | + ** an OFFSET clause. */ |
| 149041 | + sqlite3VdbeAddOp3(v, OP_Copy, regResult, iParm, nResultCol-1); |
| 149042 | + } |
| 149006 | 149043 | /* The LIMIT clause will jump out of the loop for us */ |
| 149007 | 149044 | } |
| 149008 | 149045 | break; |
| 149009 | 149046 | } |
| 149010 | 149047 | #endif /* #ifndef SQLITE_OMIT_SUBQUERY */ |
| | @@ -151165,14 +151202,12 @@ |
| 151165 | 151202 | assert( pItem!=0 ); |
| 151166 | 151203 | assert( pItem->u.x.iOrderByCol>0 ); |
| 151167 | 151204 | if( pItem->u.x.iOrderByCol==i ) break; |
| 151168 | 151205 | } |
| 151169 | 151206 | if( j==nOrderBy ){ |
| 151170 | | - Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0); |
| 151207 | + Expr *pNew = sqlite3ExprInt32(db, i); |
| 151171 | 151208 | if( pNew==0 ) return SQLITE_NOMEM_BKPT; |
| 151172 | | - pNew->flags |= EP_IntValue; |
| 151173 | | - pNew->u.iValue = i; |
| 151174 | 151209 | p->pOrderBy = pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew); |
| 151175 | 151210 | if( pOrderBy ) pOrderBy->a[nOrderBy++].u.x.iOrderByCol = (u16)i; |
| 151176 | 151211 | } |
| 151177 | 151212 | } |
| 151178 | 151213 | } |
| | @@ -154684,11 +154719,11 @@ |
| 154684 | 154719 | if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy) |
| 154685 | 154720 | && ExprAlwaysFalse(pExpr)==0 |
| 154686 | 154721 | && pExpr->pAggInfo==0 |
| 154687 | 154722 | ){ |
| 154688 | 154723 | sqlite3 *db = pWalker->pParse->db; |
| 154689 | | - Expr *pNew = sqlite3Expr(db, TK_INTEGER, "1"); |
| 154724 | + Expr *pNew = sqlite3ExprInt32(db, 1); |
| 154690 | 154725 | if( pNew ){ |
| 154691 | 154726 | Expr *pWhere = pS->pWhere; |
| 154692 | 154727 | SWAP(Expr, *pNew, *pExpr); |
| 154693 | 154728 | pNew = sqlite3ExprAnd(pWalker->pParse, pWhere, pNew); |
| 154694 | 154729 | pS->pWhere = pNew; |
| | @@ -156843,11 +156878,11 @@ |
| 156843 | 156878 | sqlite3ExprDelete(db, pTmp->pWhere); |
| 156844 | 156879 | sqlite3ExprListDelete(db, pTmp->pExprList); |
| 156845 | 156880 | sqlite3SelectDelete(db, pTmp->pSelect); |
| 156846 | 156881 | sqlite3IdListDelete(db, pTmp->pIdList); |
| 156847 | 156882 | sqlite3UpsertDelete(db, pTmp->pUpsert); |
| 156848 | | - sqlite3SrcListDelete(db, pTmp->pFrom); |
| 156883 | + sqlite3SrcListDelete(db, pTmp->pSrc); |
| 156849 | 156884 | sqlite3DbFree(db, pTmp->zSpan); |
| 156850 | 156885 | |
| 156851 | 156886 | sqlite3DbFree(db, pTmp); |
| 156852 | 156887 | } |
| 156853 | 156888 | } |
| | @@ -157182,16 +157217,16 @@ |
| 157182 | 157217 | ** are read-only, and the trigger makes a change to a shadow table, |
| 157183 | 157218 | ** then raise an error - do not allow the trigger to be created. */ |
| 157184 | 157219 | if( sqlite3ReadOnlyShadowTables(db) ){ |
| 157185 | 157220 | TriggerStep *pStep; |
| 157186 | 157221 | for(pStep=pTrig->step_list; pStep; pStep=pStep->pNext){ |
| 157187 | | - if( pStep->zTarget!=0 |
| 157188 | | - && sqlite3ShadowTableName(db, pStep->zTarget) |
| 157222 | + if( pStep->pSrc!=0 |
| 157223 | + && sqlite3ShadowTableName(db, pStep->pSrc->a[0].zName) |
| 157189 | 157224 | ){ |
| 157190 | 157225 | sqlite3ErrorMsg(pParse, |
| 157191 | 157226 | "trigger \"%s\" may not write to shadow table \"%s\"", |
| 157192 | | - pTrig->zName, pStep->zTarget); |
| 157227 | + pTrig->zName, pStep->pSrc->a[0].zName); |
| 157193 | 157228 | goto triggerfinish_cleanup; |
| 157194 | 157229 | } |
| 157195 | 157230 | } |
| 157196 | 157231 | } |
| 157197 | 157232 | |
| | @@ -157278,30 +157313,43 @@ |
| 157278 | 157313 | ** If an OOM error occurs, NULL is returned and db->mallocFailed is set. |
| 157279 | 157314 | */ |
| 157280 | 157315 | static TriggerStep *triggerStepAllocate( |
| 157281 | 157316 | Parse *pParse, /* Parser context */ |
| 157282 | 157317 | u8 op, /* Trigger opcode */ |
| 157283 | | - Token *pName, /* The target name */ |
| 157318 | + SrcList *pTabList, /* Target table */ |
| 157284 | 157319 | const char *zStart, /* Start of SQL text */ |
| 157285 | 157320 | const char *zEnd /* End of SQL text */ |
| 157286 | 157321 | ){ |
| 157322 | + Trigger *pNew = pParse->pNewTrigger; |
| 157287 | 157323 | sqlite3 *db = pParse->db; |
| 157288 | | - TriggerStep *pTriggerStep; |
| 157289 | | - |
| 157290 | | - if( pParse->nErr ) return 0; |
| 157291 | | - pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep) + pName->n + 1); |
| 157292 | | - if( pTriggerStep ){ |
| 157293 | | - char *z = (char*)&pTriggerStep[1]; |
| 157294 | | - memcpy(z, pName->z, pName->n); |
| 157295 | | - sqlite3Dequote(z); |
| 157296 | | - pTriggerStep->zTarget = z; |
| 157297 | | - pTriggerStep->op = op; |
| 157298 | | - pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd); |
| 157299 | | - if( IN_RENAME_OBJECT ){ |
| 157300 | | - sqlite3RenameTokenMap(pParse, pTriggerStep->zTarget, pName); |
| 157301 | | - } |
| 157302 | | - } |
| 157324 | + TriggerStep *pTriggerStep = 0; |
| 157325 | + |
| 157326 | + if( pParse->nErr==0 ){ |
| 157327 | + if( pNew |
| 157328 | + && pNew->pSchema!=db->aDb[1].pSchema |
| 157329 | + && pTabList->a[0].u4.zDatabase |
| 157330 | + ){ |
| 157331 | + sqlite3ErrorMsg(pParse, |
| 157332 | + "qualified table names are not allowed on INSERT, UPDATE, and DELETE " |
| 157333 | + "statements within triggers"); |
| 157334 | + }else{ |
| 157335 | + pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep)); |
| 157336 | + if( pTriggerStep ){ |
| 157337 | + pTriggerStep->pSrc = sqlite3SrcListDup(db, pTabList, EXPRDUP_REDUCE); |
| 157338 | + pTriggerStep->op = op; |
| 157339 | + pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd); |
| 157340 | + if( pTriggerStep->pSrc && IN_RENAME_OBJECT ){ |
| 157341 | + sqlite3RenameTokenRemap(pParse, |
| 157342 | + pTriggerStep->pSrc->a[0].zName, |
| 157343 | + pTabList->a[0].zName |
| 157344 | + ); |
| 157345 | + } |
| 157346 | + } |
| 157347 | + } |
| 157348 | + } |
| 157349 | + |
| 157350 | + sqlite3SrcListDelete(db, pTabList); |
| 157303 | 157351 | return pTriggerStep; |
| 157304 | 157352 | } |
| 157305 | 157353 | |
| 157306 | 157354 | /* |
| 157307 | 157355 | ** Build a trigger step out of an INSERT statement. Return a pointer |
| | @@ -157310,11 +157358,11 @@ |
| 157310 | 157358 | ** The parser calls this routine when it sees an INSERT inside the |
| 157311 | 157359 | ** body of a trigger. |
| 157312 | 157360 | */ |
| 157313 | 157361 | SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep( |
| 157314 | 157362 | Parse *pParse, /* Parser */ |
| 157315 | | - Token *pTableName, /* Name of the table into which we insert */ |
| 157363 | + SrcList *pTabList, /* Table to INSERT into */ |
| 157316 | 157364 | IdList *pColumn, /* List of columns in pTableName to insert into */ |
| 157317 | 157365 | Select *pSelect, /* A SELECT statement that supplies values */ |
| 157318 | 157366 | u8 orconf, /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */ |
| 157319 | 157367 | Upsert *pUpsert, /* ON CONFLICT clauses for upsert */ |
| 157320 | 157368 | const char *zStart, /* Start of SQL text */ |
| | @@ -157323,11 +157371,11 @@ |
| 157323 | 157371 | sqlite3 *db = pParse->db; |
| 157324 | 157372 | TriggerStep *pTriggerStep; |
| 157325 | 157373 | |
| 157326 | 157374 | assert(pSelect != 0 || db->mallocFailed); |
| 157327 | 157375 | |
| 157328 | | - pTriggerStep = triggerStepAllocate(pParse, TK_INSERT, pTableName,zStart,zEnd); |
| 157376 | + pTriggerStep = triggerStepAllocate(pParse, TK_INSERT, pTabList, zStart, zEnd); |
| 157329 | 157377 | if( pTriggerStep ){ |
| 157330 | 157378 | if( IN_RENAME_OBJECT ){ |
| 157331 | 157379 | pTriggerStep->pSelect = pSelect; |
| 157332 | 157380 | pSelect = 0; |
| 157333 | 157381 | }else{ |
| | @@ -157355,11 +157403,11 @@ |
| 157355 | 157403 | ** a pointer to that trigger step. The parser calls this routine when it |
| 157356 | 157404 | ** sees an UPDATE statement inside the body of a CREATE TRIGGER. |
| 157357 | 157405 | */ |
| 157358 | 157406 | SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep( |
| 157359 | 157407 | Parse *pParse, /* Parser */ |
| 157360 | | - Token *pTableName, /* Name of the table to be updated */ |
| 157408 | + SrcList *pTabList, /* Name of the table to be updated */ |
| 157361 | 157409 | SrcList *pFrom, /* FROM clause for an UPDATE-FROM, or NULL */ |
| 157362 | 157410 | ExprList *pEList, /* The SET clause: list of column and new values */ |
| 157363 | 157411 | Expr *pWhere, /* The WHERE clause */ |
| 157364 | 157412 | u8 orconf, /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */ |
| 157365 | 157413 | const char *zStart, /* Start of SQL text */ |
| | @@ -157366,25 +157414,40 @@ |
| 157366 | 157414 | const char *zEnd /* End of SQL text */ |
| 157367 | 157415 | ){ |
| 157368 | 157416 | sqlite3 *db = pParse->db; |
| 157369 | 157417 | TriggerStep *pTriggerStep; |
| 157370 | 157418 | |
| 157371 | | - pTriggerStep = triggerStepAllocate(pParse, TK_UPDATE, pTableName,zStart,zEnd); |
| 157419 | + pTriggerStep = triggerStepAllocate(pParse, TK_UPDATE, pTabList, zStart, zEnd); |
| 157372 | 157420 | if( pTriggerStep ){ |
| 157421 | + SrcList *pFromDup = 0; |
| 157373 | 157422 | if( IN_RENAME_OBJECT ){ |
| 157374 | 157423 | pTriggerStep->pExprList = pEList; |
| 157375 | 157424 | pTriggerStep->pWhere = pWhere; |
| 157376 | | - pTriggerStep->pFrom = pFrom; |
| 157425 | + pFromDup = pFrom; |
| 157377 | 157426 | pEList = 0; |
| 157378 | 157427 | pWhere = 0; |
| 157379 | 157428 | pFrom = 0; |
| 157380 | 157429 | }else{ |
| 157381 | 157430 | pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE); |
| 157382 | 157431 | pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); |
| 157383 | | - pTriggerStep->pFrom = sqlite3SrcListDup(db, pFrom, EXPRDUP_REDUCE); |
| 157432 | + pFromDup = sqlite3SrcListDup(db, pFrom, EXPRDUP_REDUCE); |
| 157384 | 157433 | } |
| 157385 | 157434 | pTriggerStep->orconf = orconf; |
| 157435 | + |
| 157436 | + if( pFromDup && !IN_RENAME_OBJECT){ |
| 157437 | + Select *pSub; |
| 157438 | + Token as = {0, 0}; |
| 157439 | + pSub = sqlite3SelectNew(pParse, 0, pFromDup, 0,0,0,0, SF_NestedFrom, 0); |
| 157440 | + pFromDup = sqlite3SrcListAppendFromTerm(pParse, 0, 0, 0, &as, pSub ,0); |
| 157441 | + } |
| 157442 | + if( pFromDup && pTriggerStep->pSrc ){ |
| 157443 | + pTriggerStep->pSrc = sqlite3SrcListAppendList( |
| 157444 | + pParse, pTriggerStep->pSrc, pFromDup |
| 157445 | + ); |
| 157446 | + }else{ |
| 157447 | + sqlite3SrcListDelete(db, pFromDup); |
| 157448 | + } |
| 157386 | 157449 | } |
| 157387 | 157450 | sqlite3ExprListDelete(db, pEList); |
| 157388 | 157451 | sqlite3ExprDelete(db, pWhere); |
| 157389 | 157452 | sqlite3SrcListDelete(db, pFrom); |
| 157390 | 157453 | return pTriggerStep; |
| | @@ -157395,19 +157458,19 @@ |
| 157395 | 157458 | ** a pointer to that trigger step. The parser calls this routine when it |
| 157396 | 157459 | ** sees a DELETE statement inside the body of a CREATE TRIGGER. |
| 157397 | 157460 | */ |
| 157398 | 157461 | SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep( |
| 157399 | 157462 | Parse *pParse, /* Parser */ |
| 157400 | | - Token *pTableName, /* The table from which rows are deleted */ |
| 157463 | + SrcList *pTabList, /* The table from which rows are deleted */ |
| 157401 | 157464 | Expr *pWhere, /* The WHERE clause */ |
| 157402 | 157465 | const char *zStart, /* Start of SQL text */ |
| 157403 | 157466 | const char *zEnd /* End of SQL text */ |
| 157404 | 157467 | ){ |
| 157405 | 157468 | sqlite3 *db = pParse->db; |
| 157406 | 157469 | TriggerStep *pTriggerStep; |
| 157407 | 157470 | |
| 157408 | | - pTriggerStep = triggerStepAllocate(pParse, TK_DELETE, pTableName,zStart,zEnd); |
| 157471 | + pTriggerStep = triggerStepAllocate(pParse, TK_DELETE, pTabList, zStart, zEnd); |
| 157409 | 157472 | if( pTriggerStep ){ |
| 157410 | 157473 | if( IN_RENAME_OBJECT ){ |
| 157411 | 157474 | pTriggerStep->pWhere = pWhere; |
| 157412 | 157475 | pWhere = 0; |
| 157413 | 157476 | }else{ |
| | @@ -157665,56 +157728,10 @@ |
| 157665 | 157728 | return 0; |
| 157666 | 157729 | } |
| 157667 | 157730 | return triggersReallyExist(pParse,pTab,op,pChanges,pMask); |
| 157668 | 157731 | } |
| 157669 | 157732 | |
| 157670 | | -/* |
| 157671 | | -** Convert the pStep->zTarget string into a SrcList and return a pointer |
| 157672 | | -** to that SrcList. |
| 157673 | | -** |
| 157674 | | -** This routine adds a specific database name, if needed, to the target when |
| 157675 | | -** forming the SrcList. This prevents a trigger in one database from |
| 157676 | | -** referring to a target in another database. An exception is when the |
| 157677 | | -** trigger is in TEMP in which case it can refer to any other database it |
| 157678 | | -** wants. |
| 157679 | | -*/ |
| 157680 | | -SQLITE_PRIVATE SrcList *sqlite3TriggerStepSrc( |
| 157681 | | - Parse *pParse, /* The parsing context */ |
| 157682 | | - TriggerStep *pStep /* The trigger containing the target token */ |
| 157683 | | -){ |
| 157684 | | - sqlite3 *db = pParse->db; |
| 157685 | | - SrcList *pSrc; /* SrcList to be returned */ |
| 157686 | | - char *zName = sqlite3DbStrDup(db, pStep->zTarget); |
| 157687 | | - pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); |
| 157688 | | - assert( pSrc==0 || pSrc->nSrc==1 ); |
| 157689 | | - assert( zName || pSrc==0 ); |
| 157690 | | - if( pSrc ){ |
| 157691 | | - Schema *pSchema = pStep->pTrig->pSchema; |
| 157692 | | - pSrc->a[0].zName = zName; |
| 157693 | | - if( pSchema!=db->aDb[1].pSchema ){ |
| 157694 | | - assert( pSrc->a[0].fg.fixedSchema || pSrc->a[0].u4.zDatabase==0 ); |
| 157695 | | - pSrc->a[0].u4.pSchema = pSchema; |
| 157696 | | - pSrc->a[0].fg.fixedSchema = 1; |
| 157697 | | - } |
| 157698 | | - if( pStep->pFrom ){ |
| 157699 | | - SrcList *pDup = sqlite3SrcListDup(db, pStep->pFrom, 0); |
| 157700 | | - if( pDup && pDup->nSrc>1 && !IN_RENAME_OBJECT ){ |
| 157701 | | - Select *pSubquery; |
| 157702 | | - Token as; |
| 157703 | | - pSubquery = sqlite3SelectNew(pParse,0,pDup,0,0,0,0,SF_NestedFrom,0); |
| 157704 | | - as.n = 0; |
| 157705 | | - as.z = 0; |
| 157706 | | - pDup = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&as,pSubquery,0); |
| 157707 | | - } |
| 157708 | | - pSrc = sqlite3SrcListAppendList(pParse, pSrc, pDup); |
| 157709 | | - } |
| 157710 | | - }else{ |
| 157711 | | - sqlite3DbFree(db, zName); |
| 157712 | | - } |
| 157713 | | - return pSrc; |
| 157714 | | -} |
| 157715 | | - |
| 157716 | 157733 | /* |
| 157717 | 157734 | ** Return true if the pExpr term from the RETURNING clause argument |
| 157718 | 157735 | ** list is of the form "*". Raise an error if the terms if of the |
| 157719 | 157736 | ** form "table.*". |
| 157720 | 157737 | */ |
| | @@ -157976,21 +157993,21 @@ |
| 157976 | 157993 | #endif |
| 157977 | 157994 | |
| 157978 | 157995 | switch( pStep->op ){ |
| 157979 | 157996 | case TK_UPDATE: { |
| 157980 | 157997 | sqlite3Update(pParse, |
| 157981 | | - sqlite3TriggerStepSrc(pParse, pStep), |
| 157998 | + sqlite3SrcListDup(db, pStep->pSrc, 0), |
| 157982 | 157999 | sqlite3ExprListDup(db, pStep->pExprList, 0), |
| 157983 | 158000 | sqlite3ExprDup(db, pStep->pWhere, 0), |
| 157984 | 158001 | pParse->eOrconf, 0, 0, 0 |
| 157985 | 158002 | ); |
| 157986 | 158003 | sqlite3VdbeAddOp0(v, OP_ResetCount); |
| 157987 | 158004 | break; |
| 157988 | 158005 | } |
| 157989 | 158006 | case TK_INSERT: { |
| 157990 | 158007 | sqlite3Insert(pParse, |
| 157991 | | - sqlite3TriggerStepSrc(pParse, pStep), |
| 158008 | + sqlite3SrcListDup(db, pStep->pSrc, 0), |
| 157992 | 158009 | sqlite3SelectDup(db, pStep->pSelect, 0), |
| 157993 | 158010 | sqlite3IdListDup(db, pStep->pIdList), |
| 157994 | 158011 | pParse->eOrconf, |
| 157995 | 158012 | sqlite3UpsertDup(db, pStep->pUpsert) |
| 157996 | 158013 | ); |
| | @@ -157997,11 +158014,11 @@ |
| 157997 | 158014 | sqlite3VdbeAddOp0(v, OP_ResetCount); |
| 157998 | 158015 | break; |
| 157999 | 158016 | } |
| 158000 | 158017 | case TK_DELETE: { |
| 158001 | 158018 | sqlite3DeleteFrom(pParse, |
| 158002 | | - sqlite3TriggerStepSrc(pParse, pStep), |
| 158019 | + sqlite3SrcListDup(db, pStep->pSrc, 0), |
| 158003 | 158020 | sqlite3ExprDup(db, pStep->pWhere, 0), 0, 0 |
| 158004 | 158021 | ); |
| 158005 | 158022 | sqlite3VdbeAddOp0(v, OP_ResetCount); |
| 158006 | 158023 | break; |
| 158007 | 158024 | } |
| | @@ -167114,17 +167131,15 @@ |
| 167114 | 167131 | sqlite3 *db = pParse->db; |
| 167115 | 167132 | Expr *pNew; |
| 167116 | 167133 | int iVal = 0; |
| 167117 | 167134 | |
| 167118 | 167135 | if( sqlite3ExprIsInteger(pExpr, &iVal, pParse) && iVal>=0 ){ |
| 167119 | | - Expr *pVal = sqlite3Expr(db, TK_INTEGER, 0); |
| 167136 | + Expr *pVal = sqlite3ExprInt32(db, iVal); |
| 167120 | 167137 | if( pVal==0 ) return; |
| 167121 | | - ExprSetProperty(pVal, EP_IntValue); |
| 167122 | | - pVal->u.iValue = iVal; |
| 167123 | 167138 | pNew = sqlite3PExpr(pParse, TK_MATCH, 0, pVal); |
| 167124 | 167139 | }else{ |
| 167125 | | - Expr *pVal = sqlite3Expr(db, TK_REGISTER, 0); |
| 167140 | + Expr *pVal = sqlite3ExprAlloc(db, TK_REGISTER, 0, 0); |
| 167126 | 167141 | if( pVal==0 ) return; |
| 167127 | 167142 | pVal->iTable = iReg; |
| 167128 | 167143 | pNew = sqlite3PExpr(pParse, TK_MATCH, 0, pVal); |
| 167129 | 167144 | } |
| 167130 | 167145 | if( pNew ){ |
| | @@ -174813,10 +174828,13 @@ |
| 174813 | 174828 | WhereLoop *pLoop; |
| 174814 | 174829 | SrcList *pTabList = pWInfo->pTabList; |
| 174815 | 174830 | sqlite3 *db = pParse->db; |
| 174816 | 174831 | int iEnd = sqlite3VdbeCurrentAddr(v); |
| 174817 | 174832 | int nRJ = 0; |
| 174833 | +#ifndef SQLITE_DISABLE_SKIPAHEAD_DISTINCT |
| 174834 | + int addrSeek = 0; |
| 174835 | +#endif |
| 174818 | 174836 | |
| 174819 | 174837 | /* Generate loop termination code. |
| 174820 | 174838 | */ |
| 174821 | 174839 | VdbeModuleComment((v, "End WHERE-core")); |
| 174822 | 174840 | for(i=pWInfo->nLevel-1; i>=0; i--){ |
| | @@ -174825,20 +174843,22 @@ |
| 174825 | 174843 | if( pLevel->pRJ ){ |
| 174826 | 174844 | /* Terminate the subroutine that forms the interior of the loop of |
| 174827 | 174845 | ** the RIGHT JOIN table */ |
| 174828 | 174846 | WhereRightJoin *pRJ = pLevel->pRJ; |
| 174829 | 174847 | sqlite3VdbeResolveLabel(v, pLevel->addrCont); |
| 174830 | | - pLevel->addrCont = 0; |
| 174848 | + /* Replace addrCont with a new label that will never be used, just so |
| 174849 | + ** the subsequent call to resolve pLevel->addrCont will have something |
| 174850 | + ** to resolve. */ |
| 174851 | + pLevel->addrCont = sqlite3VdbeMakeLabel(pParse); |
| 174831 | 174852 | pRJ->endSubrtn = sqlite3VdbeCurrentAddr(v); |
| 174832 | 174853 | sqlite3VdbeAddOp3(v, OP_Return, pRJ->regReturn, pRJ->addrSubrtn, 1); |
| 174833 | 174854 | VdbeCoverage(v); |
| 174834 | 174855 | nRJ++; |
| 174835 | 174856 | } |
| 174836 | 174857 | pLoop = pLevel->pWLoop; |
| 174837 | 174858 | if( pLevel->op!=OP_Noop ){ |
| 174838 | 174859 | #ifndef SQLITE_DISABLE_SKIPAHEAD_DISTINCT |
| 174839 | | - int addrSeek = 0; |
| 174840 | 174860 | Index *pIdx; |
| 174841 | 174861 | int n; |
| 174842 | 174862 | if( pWInfo->eDistinct==WHERE_DISTINCT_ORDERED |
| 174843 | 174863 | && i==pWInfo->nLevel-1 /* Ticket [ef9318757b152e3] 2017-10-21 */ |
| 174844 | 174864 | && (pLoop->wsFlags & WHERE_INDEXED)!=0 |
| | @@ -174857,29 +174877,30 @@ |
| 174857 | 174877 | VdbeCoverageIf(v, op==OP_SeekLT); |
| 174858 | 174878 | VdbeCoverageIf(v, op==OP_SeekGT); |
| 174859 | 174879 | sqlite3VdbeAddOp2(v, OP_Goto, 1, pLevel->p2); |
| 174860 | 174880 | } |
| 174861 | 174881 | #endif /* SQLITE_DISABLE_SKIPAHEAD_DISTINCT */ |
| 174862 | | - if( pTabList->a[pLevel->iFrom].fg.fromExists && i==pWInfo->nLevel-1 ){ |
| 174863 | | - /* If the EXISTS-to-JOIN optimization was applied, then the EXISTS |
| 174864 | | - ** loop(s) will be the inner-most loops of the join. There might be |
| 174865 | | - ** multiple EXISTS loops, but they will all be nested, and the join |
| 174866 | | - ** order will not have been changed by the query planner. If the |
| 174867 | | - ** inner-most EXISTS loop sees a single successful row, it should |
| 174868 | | - ** break out of *all* EXISTS loops. But only the inner-most of the |
| 174869 | | - ** nested EXISTS loops should do this breakout. */ |
| 174870 | | - int nOuter = 0; /* Nr of outer EXISTS that this one is nested within */ |
| 174871 | | - while( nOuter<i ){ |
| 174872 | | - if( !pTabList->a[pLevel[-nOuter-1].iFrom].fg.fromExists ) break; |
| 174873 | | - nOuter++; |
| 174874 | | - } |
| 174875 | | - testcase( nOuter>0 ); |
| 174876 | | - sqlite3VdbeAddOp2(v, OP_Goto, 0, pLevel[-nOuter].addrBrk); |
| 174877 | | - VdbeComment((v, "EXISTS break")); |
| 174878 | | - } |
| 174879 | | - /* The common case: Advance to the next row */ |
| 174880 | | - if( pLevel->addrCont ) sqlite3VdbeResolveLabel(v, pLevel->addrCont); |
| 174882 | + } |
| 174883 | + if( pTabList->a[pLevel->iFrom].fg.fromExists && i==pWInfo->nLevel-1 ){ |
| 174884 | + /* If the EXISTS-to-JOIN optimization was applied, then the EXISTS |
| 174885 | + ** loop(s) will be the inner-most loops of the join. There might be |
| 174886 | + ** multiple EXISTS loops, but they will all be nested, and the join |
| 174887 | + ** order will not have been changed by the query planner. If the |
| 174888 | + ** inner-most EXISTS loop sees a single successful row, it should |
| 174889 | + ** break out of *all* EXISTS loops. But only the inner-most of the |
| 174890 | + ** nested EXISTS loops should do this breakout. */ |
| 174891 | + int nOuter = 0; /* Nr of outer EXISTS that this one is nested within */ |
| 174892 | + while( nOuter<i ){ |
| 174893 | + if( !pTabList->a[pLevel[-nOuter-1].iFrom].fg.fromExists ) break; |
| 174894 | + nOuter++; |
| 174895 | + } |
| 174896 | + testcase( nOuter>0 ); |
| 174897 | + sqlite3VdbeAddOp2(v, OP_Goto, 0, pLevel[-nOuter].addrBrk); |
| 174898 | + VdbeComment((v, "EXISTS break")); |
| 174899 | + } |
| 174900 | + sqlite3VdbeResolveLabel(v, pLevel->addrCont); |
| 174901 | + if( pLevel->op!=OP_Noop ){ |
| 174881 | 174902 | sqlite3VdbeAddOp3(v, pLevel->op, pLevel->p1, pLevel->p2, pLevel->p3); |
| 174882 | 174903 | sqlite3VdbeChangeP5(v, pLevel->p5); |
| 174883 | 174904 | VdbeCoverage(v); |
| 174884 | 174905 | VdbeCoverageIf(v, pLevel->op==OP_Next); |
| 174885 | 174906 | VdbeCoverageIf(v, pLevel->op==OP_Prev); |
| | @@ -174888,14 +174909,15 @@ |
| 174888 | 174909 | sqlite3VdbeResolveLabel(v, pLevel->addrBignull); |
| 174889 | 174910 | sqlite3VdbeAddOp2(v, OP_DecrJumpZero, pLevel->regBignull, pLevel->p2-1); |
| 174890 | 174911 | VdbeCoverage(v); |
| 174891 | 174912 | } |
| 174892 | 174913 | #ifndef SQLITE_DISABLE_SKIPAHEAD_DISTINCT |
| 174893 | | - if( addrSeek ) sqlite3VdbeJumpHere(v, addrSeek); |
| 174914 | + if( addrSeek ){ |
| 174915 | + sqlite3VdbeJumpHere(v, addrSeek); |
| 174916 | + addrSeek = 0; |
| 174917 | + } |
| 174894 | 174918 | #endif |
| 174895 | | - }else if( pLevel->addrCont ){ |
| 174896 | | - sqlite3VdbeResolveLabel(v, pLevel->addrCont); |
| 174897 | 174919 | } |
| 174898 | 174920 | if( (pLoop->wsFlags & WHERE_IN_ABLE)!=0 && pLevel->u.in.nIn>0 ){ |
| 174899 | 174921 | struct InLoop *pIn; |
| 174900 | 174922 | int j; |
| 174901 | 174923 | sqlite3VdbeResolveLabel(v, pLevel->addrNxt); |
| | @@ -175888,11 +175910,11 @@ |
| 175888 | 175910 | pWin->eFrmType = aUp[i].eFrmType; |
| 175889 | 175911 | pWin->eStart = aUp[i].eStart; |
| 175890 | 175912 | pWin->eEnd = aUp[i].eEnd; |
| 175891 | 175913 | pWin->eExclude = 0; |
| 175892 | 175914 | if( pWin->eStart==TK_FOLLOWING ){ |
| 175893 | | - pWin->pStart = sqlite3Expr(db, TK_INTEGER, "1"); |
| 175915 | + pWin->pStart = sqlite3ExprInt32(db, 1); |
| 175894 | 175916 | } |
| 175895 | 175917 | break; |
| 175896 | 175918 | } |
| 175897 | 175919 | } |
| 175898 | 175920 | } |
| | @@ -176233,13 +176255,11 @@ |
| 176233 | 176255 | ** selected (e.g. "SELECT row_number() OVER () FROM t1"), it is possible |
| 176234 | 176256 | ** that pSublist is still NULL here. Add a constant expression here to |
| 176235 | 176257 | ** keep everything legal in this case. |
| 176236 | 176258 | */ |
| 176237 | 176259 | if( pSublist==0 ){ |
| 176238 | | - pSublist = sqlite3ExprListAppend(pParse, 0, |
| 176239 | | - sqlite3Expr(db, TK_INTEGER, "0") |
| 176240 | | - ); |
| 176260 | + pSublist = sqlite3ExprListAppend(pParse, 0, sqlite3ExprInt32(db, 0)); |
| 176241 | 176261 | } |
| 176242 | 176262 | |
| 176243 | 176263 | pSub = sqlite3SelectNew( |
| 176244 | 176264 | pParse, pSublist, pSrc, pWhere, pGroupBy, pHaving, pSort, 0, 0 |
| 176245 | 176265 | ); |
| | @@ -178514,19 +178534,50 @@ |
| 178514 | 178534 | } |
| 178515 | 178535 | return p; |
| 178516 | 178536 | } |
| 178517 | 178537 | |
| 178518 | 178538 | |
| 178519 | | - /* A routine to convert a binary TK_IS or TK_ISNOT expression into a |
| 178520 | | - ** unary TK_ISNULL or TK_NOTNULL expression. */ |
| 178521 | | - static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){ |
| 178522 | | - sqlite3 *db = pParse->db; |
| 178523 | | - if( pA && pY && pY->op==TK_NULL && !IN_RENAME_OBJECT ){ |
| 178524 | | - pA->op = (u8)op; |
| 178525 | | - sqlite3ExprDelete(db, pA->pRight); |
| 178526 | | - pA->pRight = 0; |
| 178527 | | - } |
| 178539 | + /* Create a TK_ISNULL or TK_NOTNULL expression, perhaps optimized to |
| 178540 | + ** to TK_TRUEFALSE, if possible */ |
| 178541 | + static Expr *sqlite3PExprIsNull( |
| 178542 | + Parse *pParse, /* Parsing context */ |
| 178543 | + int op, /* TK_ISNULL or TK_NOTNULL */ |
| 178544 | + Expr *pLeft /* Operand */ |
| 178545 | + ){ |
| 178546 | + Expr *p = pLeft; |
| 178547 | + assert( op==TK_ISNULL || op==TK_NOTNULL ); |
| 178548 | + assert( pLeft!=0 ); |
| 178549 | + while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ |
| 178550 | + p = p->pLeft; |
| 178551 | + assert( p!=0 ); |
| 178552 | + } |
| 178553 | + switch( p->op ){ |
| 178554 | + case TK_INTEGER: |
| 178555 | + case TK_STRING: |
| 178556 | + case TK_FLOAT: |
| 178557 | + case TK_BLOB: |
| 178558 | + sqlite3ExprDeferredDelete(pParse, pLeft); |
| 178559 | + return sqlite3ExprInt32(pParse->db, op==TK_NOTNULL); |
| 178560 | + default: |
| 178561 | + break; |
| 178562 | + } |
| 178563 | + return sqlite3PExpr(pParse, op, pLeft, 0); |
| 178564 | + } |
| 178565 | + |
| 178566 | + /* Create a TK_IS or TK_ISNOT operator, perhaps optimized to |
| 178567 | + ** TK_ISNULL or TK_NOTNULL or TK_TRUEFALSE. */ |
| 178568 | + static Expr *sqlite3PExprIs( |
| 178569 | + Parse *pParse, /* Parsing context */ |
| 178570 | + int op, /* TK_IS or TK_ISNOT */ |
| 178571 | + Expr *pLeft, /* Left operand */ |
| 178572 | + Expr *pRight /* Right operand */ |
| 178573 | + ){ |
| 178574 | + if( pRight && pRight->op==TK_NULL ){ |
| 178575 | + sqlite3ExprDeferredDelete(pParse, pRight); |
| 178576 | + return sqlite3PExprIsNull(pParse, op==TK_IS ? TK_ISNULL : TK_NOTNULL, pLeft); |
| 178577 | + } |
| 178578 | + return sqlite3PExpr(pParse, op, pLeft, pRight); |
| 178528 | 178579 | } |
| 178529 | 178580 | |
| 178530 | 178581 | /* Add a single new term to an ExprList that is used to store a |
| 178531 | 178582 | ** list of identifiers. Report an error if the ID list contains |
| 178532 | 178583 | ** a COLLATE clause or an ASC or DESC keyword, except ignore the |
| | @@ -178805,35 +178856,35 @@ |
| 178805 | 178856 | #ifndef INTERFACE |
| 178806 | 178857 | # define INTERFACE 1 |
| 178807 | 178858 | #endif |
| 178808 | 178859 | /************* Begin control #defines *****************************************/ |
| 178809 | 178860 | #define YYCODETYPE unsigned short int |
| 178810 | | -#define YYNOCODE 323 |
| 178861 | +#define YYNOCODE 322 |
| 178811 | 178862 | #define YYACTIONTYPE unsigned short int |
| 178812 | 178863 | #define YYWILDCARD 102 |
| 178813 | 178864 | #define sqlite3ParserTOKENTYPE Token |
| 178814 | 178865 | typedef union { |
| 178815 | 178866 | int yyinit; |
| 178816 | 178867 | sqlite3ParserTOKENTYPE yy0; |
| 178817 | | - u32 yy9; |
| 178818 | | - struct TrigEvent yy28; |
| 178819 | | - With* yy125; |
| 178820 | | - IdList* yy204; |
| 178821 | | - struct FrameBound yy205; |
| 178822 | | - TriggerStep* yy319; |
| 178823 | | - const char* yy342; |
| 178824 | | - Cte* yy361; |
| 178825 | | - ExprList* yy402; |
| 178826 | | - Upsert* yy403; |
| 178827 | | - OnOrUsing yy421; |
| 178828 | | - u8 yy444; |
| 178829 | | - struct {int value; int mask;} yy481; |
| 178830 | | - Window* yy483; |
| 178831 | | - int yy502; |
| 178832 | | - SrcList* yy563; |
| 178833 | | - Expr* yy590; |
| 178834 | | - Select* yy637; |
| 178868 | + ExprList* yy14; |
| 178869 | + With* yy59; |
| 178870 | + Cte* yy67; |
| 178871 | + Upsert* yy122; |
| 178872 | + IdList* yy132; |
| 178873 | + int yy144; |
| 178874 | + const char* yy168; |
| 178875 | + SrcList* yy203; |
| 178876 | + Window* yy211; |
| 178877 | + OnOrUsing yy269; |
| 178878 | + struct TrigEvent yy286; |
| 178879 | + struct {int value; int mask;} yy383; |
| 178880 | + u32 yy391; |
| 178881 | + TriggerStep* yy427; |
| 178882 | + Expr* yy454; |
| 178883 | + u8 yy462; |
| 178884 | + struct FrameBound yy509; |
| 178885 | + Select* yy555; |
| 178835 | 178886 | } YYMINORTYPE; |
| 178836 | 178887 | #ifndef YYSTACKDEPTH |
| 178837 | 178888 | #define YYSTACKDEPTH 50 |
| 178838 | 178889 | #endif |
| 178839 | 178890 | #define sqlite3ParserARG_SDECL |
| | @@ -178857,24 +178908,24 @@ |
| 178857 | 178908 | #define sqlite3ParserCTX_STORE yypParser->pParse=pParse; |
| 178858 | 178909 | #undef YYERRORSYMBOL |
| 178859 | 178910 | #undef YYERRSYMDT |
| 178860 | 178911 | #undef YYFALLBACK |
| 178861 | 178912 | #define YYFALLBACK 1 |
| 178862 | | -#define YYNSTATE 602 |
| 178863 | | -#define YYNRULE 414 |
| 178864 | | -#define YYNRULE_WITH_ACTION 349 |
| 178913 | +#define YYNSTATE 600 |
| 178914 | +#define YYNRULE 412 |
| 178915 | +#define YYNRULE_WITH_ACTION 348 |
| 178865 | 178916 | #define YYNTOKEN 187 |
| 178866 | | -#define YY_MAX_SHIFT 601 |
| 178867 | | -#define YY_MIN_SHIFTREDUCE 870 |
| 178868 | | -#define YY_MAX_SHIFTREDUCE 1283 |
| 178869 | | -#define YY_ERROR_ACTION 1284 |
| 178870 | | -#define YY_ACCEPT_ACTION 1285 |
| 178871 | | -#define YY_NO_ACTION 1286 |
| 178872 | | -#define YY_MIN_REDUCE 1287 |
| 178873 | | -#define YY_MAX_REDUCE 1700 |
| 178917 | +#define YY_MAX_SHIFT 599 |
| 178918 | +#define YY_MIN_SHIFTREDUCE 867 |
| 178919 | +#define YY_MAX_SHIFTREDUCE 1278 |
| 178920 | +#define YY_ERROR_ACTION 1279 |
| 178921 | +#define YY_ACCEPT_ACTION 1280 |
| 178922 | +#define YY_NO_ACTION 1281 |
| 178923 | +#define YY_MIN_REDUCE 1282 |
| 178924 | +#define YY_MAX_REDUCE 1693 |
| 178874 | 178925 | #define YY_MIN_DSTRCTR 206 |
| 178875 | | -#define YY_MAX_DSTRCTR 320 |
| 178926 | +#define YY_MAX_DSTRCTR 319 |
| 178876 | 178927 | /************* End control #defines *******************************************/ |
| 178877 | 178928 | #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) |
| 178878 | 178929 | |
| 178879 | 178930 | /* Define the yytestcase() macro to be a no-op if is not already defined |
| 178880 | 178931 | ** otherwise. |
| | @@ -178955,491 +179006,491 @@ |
| 178955 | 179006 | ** yy_default[] Default action for each state. |
| 178956 | 179007 | ** |
| 178957 | 179008 | *********** Begin parsing tables **********************************************/ |
| 178958 | 179009 | #define YY_ACTTAB_COUNT (2379) |
| 178959 | 179010 | static const YYACTIONTYPE yy_action[] = { |
| 178960 | | - /* 0 */ 134, 131, 238, 291, 291, 1358, 595, 1337, 479, 483, |
| 178961 | | - /* 10 */ 595, 436, 595, 393, 595, 1358, 592, 595, 581, 425, |
| 178962 | | - /* 20 */ 423, 1572, 134, 131, 238, 543, 479, 478, 577, 84, |
| 178963 | | - /* 30 */ 84, 1008, 304, 51, 51, 51, 51, 63, 63, 1009, |
| 178964 | | - /* 40 */ 84, 84, 1132, 141, 142, 93, 1132, 1258, 1258, 1088, |
| 178965 | | - /* 50 */ 1091, 1078, 1078, 139, 139, 140, 140, 140, 140, 425, |
| 178966 | | - /* 60 */ 297, 297, 1481, 297, 297, 569, 555, 297, 297, 134, |
| 178967 | | - /* 70 */ 131, 238, 1130, 592, 544, 581, 592, 576, 581, 512, |
| 178968 | | - /* 80 */ 592, 343, 581, 141, 142, 93, 578, 1258, 1258, 1088, |
| 178969 | | - /* 90 */ 1091, 1078, 1078, 139, 139, 140, 140, 140, 140, 6, |
| 178970 | | - /* 100 */ 479, 385, 1630, 138, 138, 138, 138, 137, 137, 136, |
| 178971 | | - /* 110 */ 136, 136, 135, 132, 464, 1363, 1363, 595, 1044, 1603, |
| 178972 | | - /* 120 */ 1285, 1, 1, 601, 2, 1289, 44, 1204, 231, 1204, |
| 178973 | | - /* 130 */ 331, 425, 158, 1617, 392, 1617, 563, 116, 500, 1371, |
| 178974 | | - /* 140 */ 84, 84, 569, 138, 138, 138, 138, 137, 137, 136, |
| 178975 | | - /* 150 */ 136, 136, 135, 132, 464, 141, 142, 93, 517, 1258, |
| 178976 | | - /* 160 */ 1258, 1088, 1091, 1078, 1078, 139, 139, 140, 140, 140, |
| 178977 | | - /* 170 */ 140, 1234, 356, 212, 297, 297, 464, 576, 490, 1234, |
| 178978 | | - /* 180 */ 570, 570, 143, 330, 586, 1320, 550, 592, 1199, 581, |
| 178979 | | - /* 190 */ 491, 358, 45, 140, 140, 140, 140, 133, 394, 566, |
| 178980 | | - /* 200 */ 1323, 1199, 253, 426, 1199, 137, 137, 136, 136, 136, |
| 178981 | | - /* 210 */ 135, 132, 464, 292, 306, 138, 138, 138, 138, 137, |
| 178982 | | - /* 220 */ 137, 136, 136, 136, 135, 132, 464, 1322, 1234, 1235, |
| 178983 | | - /* 230 */ 1234, 1605, 413, 389, 468, 425, 1234, 1235, 1234, 491, |
| 178984 | | - /* 240 */ 358, 138, 138, 138, 138, 137, 137, 136, 136, 136, |
| 178985 | | - /* 250 */ 135, 132, 464, 113, 134, 131, 238, 557, 1606, 141, |
| 178986 | | - /* 260 */ 142, 93, 595, 1258, 1258, 1088, 1091, 1078, 1078, 139, |
| 178987 | | - /* 270 */ 139, 140, 140, 140, 140, 134, 131, 238, 1612, 425, |
| 178988 | | - /* 280 */ 502, 185, 7, 334, 97, 19, 19, 994, 140, 140, |
| 178989 | | - /* 290 */ 140, 140, 136, 136, 136, 135, 132, 464, 1179, 1692, |
| 178990 | | - /* 300 */ 209, 1692, 1610, 141, 142, 93, 7, 1258, 1258, 1088, |
| 178991 | | - /* 310 */ 1091, 1078, 1078, 139, 139, 140, 140, 140, 140, 138, |
| 179011 | + /* 0 */ 134, 131, 238, 290, 290, 1353, 593, 1332, 478, 1606, |
| 179012 | + /* 10 */ 593, 1315, 593, 7, 593, 1353, 590, 593, 579, 424, |
| 179013 | + /* 20 */ 1566, 134, 131, 238, 1318, 541, 478, 477, 575, 84, |
| 179014 | + /* 30 */ 84, 1005, 303, 84, 84, 51, 51, 63, 63, 1006, |
| 179015 | + /* 40 */ 84, 84, 498, 141, 142, 93, 442, 1254, 1254, 1085, |
| 179016 | + /* 50 */ 1088, 1075, 1075, 139, 139, 140, 140, 140, 140, 424, |
| 179017 | + /* 60 */ 296, 296, 498, 296, 296, 567, 553, 296, 296, 1306, |
| 179018 | + /* 70 */ 574, 1358, 1358, 590, 542, 579, 590, 574, 579, 548, |
| 179019 | + /* 80 */ 590, 1304, 579, 141, 142, 93, 576, 1254, 1254, 1085, |
| 179020 | + /* 90 */ 1088, 1075, 1075, 139, 139, 140, 140, 140, 140, 399, |
| 179021 | + /* 100 */ 478, 395, 6, 138, 138, 138, 138, 137, 137, 136, |
| 179022 | + /* 110 */ 136, 136, 135, 132, 463, 44, 342, 593, 305, 1127, |
| 179023 | + /* 120 */ 1280, 1, 1, 599, 2, 1284, 598, 1200, 1284, 1200, |
| 179024 | + /* 130 */ 330, 424, 158, 330, 1613, 158, 390, 116, 308, 1366, |
| 179025 | + /* 140 */ 51, 51, 1366, 138, 138, 138, 138, 137, 137, 136, |
| 179026 | + /* 150 */ 136, 136, 135, 132, 463, 141, 142, 93, 515, 1254, |
| 179027 | + /* 160 */ 1254, 1085, 1088, 1075, 1075, 139, 139, 140, 140, 140, |
| 179028 | + /* 170 */ 140, 1230, 329, 584, 296, 296, 212, 296, 296, 568, |
| 179029 | + /* 180 */ 568, 488, 143, 1072, 1072, 1086, 1089, 590, 1195, 579, |
| 179030 | + /* 190 */ 590, 340, 579, 140, 140, 140, 140, 133, 392, 564, |
| 179031 | + /* 200 */ 536, 1195, 250, 425, 1195, 250, 137, 137, 136, 136, |
| 179032 | + /* 210 */ 136, 135, 132, 463, 291, 138, 138, 138, 138, 137, |
| 179033 | + /* 220 */ 137, 136, 136, 136, 135, 132, 463, 966, 1230, 1231, |
| 179034 | + /* 230 */ 1230, 412, 965, 467, 412, 424, 467, 489, 357, 1611, |
| 179035 | + /* 240 */ 391, 138, 138, 138, 138, 137, 137, 136, 136, 136, |
| 179036 | + /* 250 */ 135, 132, 463, 463, 134, 131, 238, 555, 1076, 141, |
| 179037 | + /* 260 */ 142, 93, 593, 1254, 1254, 1085, 1088, 1075, 1075, 139, |
| 179038 | + /* 270 */ 139, 140, 140, 140, 140, 1317, 134, 131, 238, 424, |
| 179039 | + /* 280 */ 549, 1597, 1531, 333, 97, 83, 83, 140, 140, 140, |
| 179040 | + /* 290 */ 140, 138, 138, 138, 138, 137, 137, 136, 136, 136, |
| 179041 | + /* 300 */ 135, 132, 463, 141, 142, 93, 1657, 1254, 1254, 1085, |
| 179042 | + /* 310 */ 1088, 1075, 1075, 139, 139, 140, 140, 140, 140, 138, |
| 178992 | 179043 | /* 320 */ 138, 138, 138, 137, 137, 136, 136, 136, 135, 132, |
| 178993 | | - /* 330 */ 464, 1663, 1234, 589, 589, 589, 138, 138, 138, 138, |
| 178994 | | - /* 340 */ 137, 137, 136, 136, 136, 135, 132, 464, 138, 138, |
| 178995 | | - /* 350 */ 138, 138, 137, 137, 136, 136, 136, 135, 132, 464, |
| 178996 | | - /* 360 */ 275, 595, 430, 138, 138, 138, 138, 137, 137, 136, |
| 178997 | | - /* 370 */ 136, 136, 135, 132, 464, 400, 1234, 396, 1177, 461, |
| 178998 | | - /* 380 */ 460, 237, 1611, 425, 51, 51, 7, 335, 1263, 1234, |
| 178999 | | - /* 390 */ 1235, 1234, 1311, 1265, 549, 145, 1254, 283, 542, 542, |
| 179000 | | - /* 400 */ 595, 1264, 597, 7, 597, 927, 994, 141, 142, 93, |
| 179001 | | - /* 410 */ 506, 1258, 1258, 1088, 1091, 1078, 1078, 139, 139, 140, |
| 179002 | | - /* 420 */ 140, 140, 140, 19, 19, 44, 1266, 425, 1266, 297, |
| 179003 | | - /* 430 */ 297, 1234, 98, 1234, 1235, 1234, 265, 534, 439, 530, |
| 179004 | | - /* 440 */ 527, 526, 592, 1633, 581, 928, 511, 272, 235, 525, |
| 179005 | | - /* 450 */ 508, 141, 142, 93, 1254, 1258, 1258, 1088, 1091, 1078, |
| 179006 | | - /* 460 */ 1078, 139, 139, 140, 140, 140, 140, 138, 138, 138, |
| 179007 | | - /* 470 */ 138, 137, 137, 136, 136, 136, 135, 132, 464, 595, |
| 179008 | | - /* 480 */ 422, 421, 330, 586, 1619, 517, 391, 517, 1234, 1235, |
| 179009 | | - /* 490 */ 1234, 1274, 127, 587, 265, 4, 1311, 530, 527, 526, |
| 179010 | | - /* 500 */ 595, 448, 84, 84, 594, 595, 572, 525, 1309, 590, |
| 179011 | | - /* 510 */ 308, 138, 138, 138, 138, 137, 137, 136, 136, 136, |
| 179012 | | - /* 520 */ 135, 132, 464, 19, 19, 161, 1234, 390, 19, 19, |
| 179013 | | - /* 530 */ 1571, 425, 1535, 465, 1637, 601, 2, 1289, 444, 576, |
| 179014 | | - /* 540 */ 330, 586, 331, 446, 158, 584, 1274, 481, 575, 595, |
| 179015 | | - /* 550 */ 240, 1371, 506, 551, 1234, 141, 142, 93, 313, 1258, |
| 179016 | | - /* 560 */ 1258, 1088, 1091, 1078, 1078, 139, 139, 140, 140, 140, |
| 179017 | | - /* 570 */ 140, 160, 83, 83, 1065, 974, 135, 132, 464, 595, |
| 179018 | | - /* 580 */ 125, 125, 973, 1234, 1235, 1234, 297, 297, 126, 517, |
| 179019 | | - /* 590 */ 465, 596, 465, 297, 297, 1053, 1234, 1369, 387, 592, |
| 179020 | | - /* 600 */ 1234, 581, 84, 84, 517, 242, 592, 1465, 581, 46, |
| 179021 | | - /* 610 */ 473, 1234, 1235, 1234, 253, 138, 138, 138, 138, 137, |
| 179022 | | - /* 620 */ 137, 136, 136, 136, 135, 132, 464, 1053, 1053, 1055, |
| 179023 | | - /* 630 */ 1056, 35, 297, 297, 1370, 399, 425, 445, 996, 576, |
| 179024 | | - /* 640 */ 372, 415, 233, 541, 413, 592, 468, 581, 452, 1366, |
| 179025 | | - /* 650 */ 112, 552, 355, 1234, 1235, 1234, 1218, 1234, 1235, 1234, |
| 179026 | | - /* 660 */ 141, 142, 93, 223, 1258, 1258, 1088, 1091, 1078, 1078, |
| 179027 | | - /* 670 */ 139, 139, 140, 140, 140, 140, 297, 297, 441, 553, |
| 179028 | | - /* 680 */ 425, 298, 298, 1375, 531, 330, 586, 1199, 115, 592, |
| 179029 | | - /* 690 */ 1465, 581, 100, 1480, 592, 592, 581, 581, 559, 1307, |
| 179030 | | - /* 700 */ 1199, 907, 545, 1199, 141, 142, 93, 498, 1258, 1258, |
| 179031 | | - /* 710 */ 1088, 1091, 1078, 1078, 139, 139, 140, 140, 140, 140, |
| 179044 | + /* 330 */ 463, 591, 1230, 958, 958, 138, 138, 138, 138, 137, |
| 179045 | + /* 340 */ 137, 136, 136, 136, 135, 132, 463, 44, 398, 547, |
| 179046 | + /* 350 */ 1306, 136, 136, 136, 135, 132, 463, 386, 593, 442, |
| 179047 | + /* 360 */ 595, 145, 595, 138, 138, 138, 138, 137, 137, 136, |
| 179048 | + /* 370 */ 136, 136, 135, 132, 463, 500, 1230, 112, 550, 460, |
| 179049 | + /* 380 */ 459, 51, 51, 424, 296, 296, 479, 334, 1259, 1230, |
| 179050 | + /* 390 */ 1231, 1230, 1599, 1261, 388, 312, 444, 590, 246, 579, |
| 179051 | + /* 400 */ 546, 1260, 271, 235, 329, 584, 551, 141, 142, 93, |
| 179052 | + /* 410 */ 429, 1254, 1254, 1085, 1088, 1075, 1075, 139, 139, 140, |
| 179053 | + /* 420 */ 140, 140, 140, 22, 22, 1230, 1262, 424, 1262, 216, |
| 179054 | + /* 430 */ 296, 296, 98, 1230, 1231, 1230, 264, 884, 45, 528, |
| 179055 | + /* 440 */ 525, 524, 1041, 590, 1269, 579, 421, 420, 393, 523, |
| 179056 | + /* 450 */ 44, 141, 142, 93, 498, 1254, 1254, 1085, 1088, 1075, |
| 179057 | + /* 460 */ 1075, 139, 139, 140, 140, 140, 140, 138, 138, 138, |
| 179058 | + /* 470 */ 138, 137, 137, 136, 136, 136, 135, 132, 463, 593, |
| 179059 | + /* 480 */ 1611, 561, 1230, 1231, 1230, 23, 264, 515, 200, 528, |
| 179060 | + /* 490 */ 525, 524, 127, 585, 509, 4, 355, 487, 506, 523, |
| 179061 | + /* 500 */ 593, 498, 84, 84, 134, 131, 238, 329, 584, 588, |
| 179062 | + /* 510 */ 1627, 138, 138, 138, 138, 137, 137, 136, 136, 136, |
| 179063 | + /* 520 */ 135, 132, 463, 19, 19, 435, 1230, 1460, 297, 297, |
| 179064 | + /* 530 */ 311, 424, 1565, 464, 1631, 599, 2, 1284, 437, 574, |
| 179065 | + /* 540 */ 1107, 590, 330, 579, 158, 582, 489, 357, 573, 593, |
| 179066 | + /* 550 */ 592, 1366, 409, 1274, 1230, 141, 142, 93, 1364, 1254, |
| 179067 | + /* 560 */ 1254, 1085, 1088, 1075, 1075, 139, 139, 140, 140, 140, |
| 179068 | + /* 570 */ 140, 389, 84, 84, 1062, 567, 1230, 313, 1523, 593, |
| 179069 | + /* 580 */ 125, 125, 970, 1230, 1231, 1230, 296, 296, 126, 46, |
| 179070 | + /* 590 */ 464, 594, 464, 296, 296, 1050, 1230, 218, 439, 590, |
| 179071 | + /* 600 */ 1604, 579, 84, 84, 7, 403, 590, 515, 579, 325, |
| 179072 | + /* 610 */ 417, 1230, 1231, 1230, 250, 138, 138, 138, 138, 137, |
| 179073 | + /* 620 */ 137, 136, 136, 136, 135, 132, 463, 1050, 1050, 1052, |
| 179074 | + /* 630 */ 1053, 35, 1275, 1230, 1231, 1230, 424, 1370, 993, 574, |
| 179075 | + /* 640 */ 371, 414, 274, 412, 1597, 467, 1302, 552, 451, 590, |
| 179076 | + /* 650 */ 543, 579, 1530, 1230, 1231, 1230, 1214, 201, 409, 1174, |
| 179077 | + /* 660 */ 141, 142, 93, 223, 1254, 1254, 1085, 1088, 1075, 1075, |
| 179078 | + /* 670 */ 139, 139, 140, 140, 140, 140, 296, 296, 1250, 593, |
| 179079 | + /* 680 */ 424, 296, 296, 236, 529, 296, 296, 515, 100, 590, |
| 179080 | + /* 690 */ 1600, 579, 48, 1605, 590, 1230, 579, 7, 590, 577, |
| 179081 | + /* 700 */ 579, 904, 84, 84, 141, 142, 93, 496, 1254, 1254, |
| 179082 | + /* 710 */ 1085, 1088, 1075, 1075, 139, 139, 140, 140, 140, 140, |
| 179032 | 179083 | /* 720 */ 138, 138, 138, 138, 137, 137, 136, 136, 136, 135, |
| 179033 | | - /* 730 */ 132, 464, 385, 1630, 297, 297, 470, 297, 297, 472, |
| 179034 | | - /* 740 */ 200, 579, 1065, 201, 44, 127, 587, 592, 4, 581, |
| 179035 | | - /* 750 */ 592, 1044, 581, 482, 40, 500, 558, 482, 907, 1054, |
| 179036 | | - /* 760 */ 1479, 442, 590, 1053, 138, 138, 138, 138, 137, 137, |
| 179037 | | - /* 770 */ 136, 136, 136, 135, 132, 464, 297, 297, 1234, 1657, |
| 179038 | | - /* 780 */ 492, 1234, 1603, 480, 425, 506, 465, 1330, 911, 592, |
| 179039 | | - /* 790 */ 918, 581, 1234, 1361, 1361, 1053, 1053, 1055, 584, 385, |
| 179040 | | - /* 800 */ 1630, 330, 586, 353, 5, 356, 486, 344, 141, 142, |
| 179041 | | - /* 810 */ 93, 185, 1258, 1258, 1088, 1091, 1078, 1078, 139, 139, |
| 179042 | | - /* 820 */ 140, 140, 140, 140, 1218, 1694, 411, 1065, 425, 1234, |
| 179043 | | - /* 830 */ 48, 309, 904, 125, 125, 1234, 1235, 1234, 1234, 1235, |
| 179044 | | - /* 840 */ 1234, 126, 1234, 465, 596, 465, 348, 517, 1053, 1234, |
| 179045 | | - /* 850 */ 1235, 1234, 141, 142, 93, 3, 1258, 1258, 1088, 1091, |
| 179046 | | - /* 860 */ 1078, 1078, 139, 139, 140, 140, 140, 140, 138, 138, |
| 179047 | | - /* 870 */ 138, 138, 137, 137, 136, 136, 136, 135, 132, 464, |
| 179048 | | - /* 880 */ 1053, 1053, 1055, 1056, 35, 315, 1234, 1235, 1234, 1234, |
| 179049 | | - /* 890 */ 1065, 1237, 363, 1234, 1604, 887, 389, 341, 500, 1234, |
| 179050 | | - /* 900 */ 1235, 1234, 595, 1075, 1075, 1089, 1092, 1054, 345, 1218, |
| 179051 | | - /* 910 */ 347, 1053, 138, 138, 138, 138, 137, 137, 136, 136, |
| 179052 | | - /* 920 */ 136, 135, 132, 464, 436, 19, 19, 370, 567, 567, |
| 179053 | | - /* 930 */ 595, 554, 425, 7, 1398, 325, 1217, 462, 462, 462, |
| 179054 | | - /* 940 */ 316, 1582, 432, 1053, 1053, 1055, 1234, 1235, 1234, 1237, |
| 179055 | | - /* 950 */ 1234, 1235, 1234, 84, 84, 489, 141, 142, 93, 595, |
| 179056 | | - /* 960 */ 1258, 1258, 1088, 1091, 1078, 1078, 139, 139, 140, 140, |
| 179057 | | - /* 970 */ 140, 140, 1218, 995, 312, 383, 425, 600, 1079, 1289, |
| 179058 | | - /* 980 */ 1066, 115, 19, 19, 331, 382, 158, 1603, 1536, 365, |
| 179059 | | - /* 990 */ 326, 368, 346, 1371, 216, 461, 460, 451, 1110, 236, |
| 179060 | | - /* 1000 */ 141, 142, 93, 1465, 1258, 1258, 1088, 1091, 1078, 1078, |
| 179084 | + /* 730 */ 132, 463, 1365, 1230, 296, 296, 1250, 115, 1275, 326, |
| 179085 | + /* 740 */ 233, 539, 1062, 40, 282, 127, 585, 590, 4, 579, |
| 179086 | + /* 750 */ 329, 584, 1230, 1231, 1230, 1598, 593, 388, 904, 1051, |
| 179087 | + /* 760 */ 1356, 1356, 588, 1050, 138, 138, 138, 138, 137, 137, |
| 179088 | + /* 770 */ 136, 136, 136, 135, 132, 463, 185, 593, 1230, 19, |
| 179089 | + /* 780 */ 19, 1230, 971, 1597, 424, 1651, 464, 129, 908, 1195, |
| 179090 | + /* 790 */ 1230, 1231, 1230, 1325, 443, 1050, 1050, 1052, 582, 1603, |
| 179091 | + /* 800 */ 149, 149, 1195, 7, 5, 1195, 1687, 410, 141, 142, |
| 179092 | + /* 810 */ 93, 1536, 1254, 1254, 1085, 1088, 1075, 1075, 139, 139, |
| 179093 | + /* 820 */ 140, 140, 140, 140, 1214, 397, 593, 1062, 424, 1536, |
| 179094 | + /* 830 */ 1538, 50, 901, 125, 125, 1230, 1231, 1230, 1230, 1231, |
| 179095 | + /* 840 */ 1230, 126, 1230, 464, 594, 464, 515, 1230, 1050, 84, |
| 179096 | + /* 850 */ 84, 3, 141, 142, 93, 924, 1254, 1254, 1085, 1088, |
| 179097 | + /* 860 */ 1075, 1075, 139, 139, 140, 140, 140, 140, 138, 138, |
| 179098 | + /* 870 */ 138, 138, 137, 137, 136, 136, 136, 135, 132, 463, |
| 179099 | + /* 880 */ 1050, 1050, 1052, 1053, 35, 442, 457, 532, 433, 1230, |
| 179100 | + /* 890 */ 1062, 1361, 540, 540, 1598, 925, 388, 7, 1129, 1230, |
| 179101 | + /* 900 */ 1231, 1230, 1129, 1536, 1230, 1231, 1230, 1051, 570, 1214, |
| 179102 | + /* 910 */ 593, 1050, 138, 138, 138, 138, 137, 137, 136, 136, |
| 179103 | + /* 920 */ 136, 135, 132, 463, 6, 185, 1195, 1230, 231, 593, |
| 179104 | + /* 930 */ 382, 992, 424, 151, 151, 510, 1213, 557, 482, 1195, |
| 179105 | + /* 940 */ 381, 160, 1195, 1050, 1050, 1052, 1230, 1231, 1230, 422, |
| 179106 | + /* 950 */ 593, 447, 84, 84, 593, 217, 141, 142, 93, 593, |
| 179107 | + /* 960 */ 1254, 1254, 1085, 1088, 1075, 1075, 139, 139, 140, 140, |
| 179108 | + /* 970 */ 140, 140, 1214, 19, 19, 593, 424, 19, 19, 442, |
| 179109 | + /* 980 */ 1063, 442, 19, 19, 1230, 1231, 1230, 515, 445, 458, |
| 179110 | + /* 990 */ 1597, 386, 315, 1175, 1685, 556, 1685, 450, 84, 84, |
| 179111 | + /* 1000 */ 141, 142, 93, 505, 1254, 1254, 1085, 1088, 1075, 1075, |
| 179061 | 179112 | /* 1010 */ 139, 139, 140, 140, 140, 140, 138, 138, 138, 138, |
| 179062 | | - /* 1020 */ 137, 137, 136, 136, 136, 135, 132, 464, 297, 297, |
| 179063 | | - /* 1030 */ 595, 500, 1008, 1199, 595, 50, 1528, 398, 218, 218, |
| 179064 | | - /* 1040 */ 1009, 592, 1266, 581, 1266, 450, 1199, 404, 522, 1199, |
| 179065 | | - /* 1050 */ 376, 424, 418, 84, 84, 595, 253, 19, 19, 548, |
| 179113 | + /* 1020 */ 137, 137, 136, 136, 136, 135, 132, 463, 442, 1147, |
| 179114 | + /* 1030 */ 454, 1597, 362, 1041, 593, 462, 1460, 1233, 47, 1393, |
| 179115 | + /* 1040 */ 324, 565, 565, 115, 1148, 449, 7, 460, 459, 307, |
| 179116 | + /* 1050 */ 375, 354, 593, 113, 593, 329, 584, 19, 19, 1149, |
| 179066 | 179117 | /* 1060 */ 138, 138, 138, 138, 137, 137, 136, 136, 136, 135, |
| 179067 | | - /* 1070 */ 132, 464, 210, 317, 443, 317, 269, 307, 19, 19, |
| 179068 | | - /* 1080 */ 425, 307, 22, 22, 1049, 294, 413, 994, 468, 593, |
| 179069 | | - /* 1090 */ 327, 961, 961, 571, 269, 1603, 1603, 595, 231, 1604, |
| 179070 | | - /* 1100 */ 425, 389, 410, 1279, 141, 142, 93, 314, 1258, 1258, |
| 179071 | | - /* 1110 */ 1088, 1091, 1078, 1078, 139, 139, 140, 140, 140, 140, |
| 179072 | | - /* 1120 */ 84, 84, 533, 387, 141, 142, 93, 434, 1258, 1258, |
| 179073 | | - /* 1130 */ 1088, 1091, 1078, 1078, 139, 139, 140, 140, 140, 140, |
| 179074 | | - /* 1140 */ 447, 1541, 1585, 47, 49, 431, 282, 300, 384, 536, |
| 179075 | | - /* 1150 */ 379, 535, 270, 595, 436, 595, 1465, 458, 375, 1541, |
| 179076 | | - /* 1160 */ 1543, 375, 455, 431, 138, 138, 138, 138, 137, 137, |
| 179077 | | - /* 1170 */ 136, 136, 136, 135, 132, 464, 84, 84, 84, 84, |
| 179078 | | - /* 1180 */ 595, 237, 1280, 1583, 138, 138, 138, 138, 137, 137, |
| 179079 | | - /* 1190 */ 136, 136, 136, 135, 132, 464, 1179, 1693, 10, 1693, |
| 179080 | | - /* 1200 */ 275, 565, 1151, 149, 149, 475, 994, 1604, 1604, 389, |
| 179081 | | - /* 1210 */ 389, 1465, 1199, 459, 425, 463, 226, 1152, 1150, 1609, |
| 179082 | | - /* 1220 */ 564, 303, 1608, 7, 217, 1199, 7, 513, 1199, 1210, |
| 179083 | | - /* 1230 */ 1312, 432, 1153, 1541, 425, 1662, 1254, 936, 141, 142, |
| 179084 | | - /* 1240 */ 93, 119, 1258, 1258, 1088, 1091, 1078, 1078, 139, 139, |
| 179085 | | - /* 1250 */ 140, 140, 140, 140, 583, 302, 538, 1396, 141, 142, |
| 179086 | | - /* 1260 */ 93, 6, 1258, 1258, 1088, 1091, 1078, 1078, 139, 139, |
| 179087 | | - /* 1270 */ 140, 140, 140, 140, 588, 432, 1177, 1135, 1135, 514, |
| 179088 | | - /* 1280 */ 1151, 1210, 456, 969, 333, 288, 433, 187, 968, 595, |
| 179089 | | - /* 1290 */ 129, 595, 547, 595, 1254, 1152, 1341, 551, 138, 138, |
| 179090 | | - /* 1300 */ 138, 138, 137, 137, 136, 136, 136, 135, 132, 464, |
| 179091 | | - /* 1310 */ 1153, 595, 151, 151, 53, 53, 54, 54, 138, 138, |
| 179092 | | - /* 1320 */ 138, 138, 137, 137, 136, 136, 136, 135, 132, 464, |
| 179093 | | - /* 1330 */ 504, 595, 947, 595, 68, 68, 595, 296, 235, 595, |
| 179094 | | - /* 1340 */ 507, 595, 948, 595, 101, 222, 595, 484, 425, 875, |
| 179095 | | - /* 1350 */ 876, 877, 215, 219, 69, 69, 21, 21, 423, 55, |
| 179096 | | - /* 1360 */ 55, 1584, 70, 70, 56, 56, 71, 71, 425, 72, |
| 179097 | | - /* 1370 */ 72, 1183, 141, 142, 93, 123, 1258, 1258, 1088, 1091, |
| 179098 | | - /* 1380 */ 1078, 1078, 139, 139, 140, 140, 140, 140, 425, 268, |
| 179099 | | - /* 1390 */ 267, 266, 141, 142, 93, 552, 1258, 1258, 1088, 1091, |
| 179100 | | - /* 1400 */ 1078, 1078, 139, 139, 140, 140, 140, 140, 23, 163, |
| 179101 | | - /* 1410 */ 496, 572, 141, 130, 93, 476, 1258, 1258, 1088, 1091, |
| 179102 | | - /* 1420 */ 1078, 1078, 139, 139, 140, 140, 140, 140, 505, 124, |
| 179103 | | - /* 1430 */ 1580, 121, 138, 138, 138, 138, 137, 137, 136, 136, |
| 179104 | | - /* 1440 */ 136, 135, 132, 464, 595, 225, 595, 899, 437, 246, |
| 179105 | | - /* 1450 */ 336, 1253, 138, 138, 138, 138, 137, 137, 136, 136, |
| 179106 | | - /* 1460 */ 136, 135, 132, 464, 595, 1340, 595, 73, 73, 74, |
| 179107 | | - /* 1470 */ 74, 337, 138, 138, 138, 138, 137, 137, 136, 136, |
| 179108 | | - /* 1480 */ 136, 135, 132, 464, 38, 595, 493, 75, 75, 57, |
| 179109 | | - /* 1490 */ 57, 595, 425, 410, 1178, 1274, 497, 423, 250, 969, |
| 179110 | | - /* 1500 */ 329, 164, 914, 16, 968, 899, 1117, 423, 58, 58, |
| 179111 | | - /* 1510 */ 595, 423, 425, 595, 59, 59, 39, 142, 93, 340, |
| 179112 | | - /* 1520 */ 1258, 1258, 1088, 1091, 1078, 1078, 139, 139, 140, 140, |
| 179113 | | - /* 1530 */ 140, 140, 595, 61, 61, 595, 62, 62, 93, 595, |
| 179114 | | - /* 1540 */ 1258, 1258, 1088, 1091, 1078, 1078, 139, 139, 140, 140, |
| 179115 | | - /* 1550 */ 140, 140, 1410, 926, 925, 76, 76, 1409, 77, 77, |
| 179116 | | - /* 1560 */ 914, 485, 78, 78, 1117, 1174, 595, 412, 595, 226, |
| 179117 | | - /* 1570 */ 595, 127, 587, 1280, 4, 1592, 138, 138, 138, 138, |
| 179118 | | - /* 1580 */ 137, 137, 136, 136, 136, 135, 132, 464, 590, 20, |
| 179119 | | - /* 1590 */ 20, 79, 79, 147, 147, 595, 138, 138, 138, 138, |
| 179120 | | - /* 1600 */ 137, 137, 136, 136, 136, 135, 132, 464, 595, 354, |
| 179121 | | - /* 1610 */ 169, 115, 465, 595, 349, 595, 252, 595, 148, 148, |
| 179122 | | - /* 1620 */ 595, 1046, 595, 274, 584, 494, 112, 499, 595, 274, |
| 179123 | | - /* 1630 */ 1560, 80, 80, 595, 44, 1559, 64, 64, 81, 81, |
| 179124 | | - /* 1640 */ 65, 65, 595, 82, 82, 66, 66, 509, 310, 595, |
| 179125 | | - /* 1650 */ 360, 173, 173, 1065, 595, 553, 174, 174, 595, 125, |
| 179126 | | - /* 1660 */ 125, 501, 595, 274, 1406, 89, 89, 126, 299, 465, |
| 179127 | | - /* 1670 */ 596, 465, 67, 67, 1053, 595, 364, 85, 85, 595, |
| 179128 | | - /* 1680 */ 1057, 150, 150, 933, 934, 86, 86, 127, 587, 367, |
| 179129 | | - /* 1690 */ 4, 330, 586, 359, 523, 115, 271, 369, 171, 171, |
| 179130 | | - /* 1700 */ 1011, 1012, 152, 152, 590, 1339, 1053, 1053, 1055, 1056, |
| 179131 | | - /* 1710 */ 35, 371, 373, 595, 115, 1354, 1338, 9, 595, 168, |
| 179132 | | - /* 1720 */ 595, 115, 595, 1113, 595, 271, 595, 378, 465, 595, |
| 179133 | | - /* 1730 */ 388, 1419, 595, 539, 595, 1218, 146, 146, 1057, 1464, |
| 179134 | | - /* 1740 */ 584, 172, 172, 165, 165, 156, 156, 155, 155, 153, |
| 179135 | | - /* 1750 */ 153, 1392, 154, 154, 561, 88, 88, 90, 90, 560, |
| 179136 | | - /* 1760 */ 127, 587, 1129, 4, 1129, 999, 208, 274, 595, 1065, |
| 179137 | | - /* 1770 */ 595, 967, 595, 129, 1404, 125, 125, 590, 964, 1128, |
| 179138 | | - /* 1780 */ 129, 1128, 897, 126, 162, 465, 596, 465, 1651, 582, |
| 179139 | | - /* 1790 */ 1053, 87, 87, 52, 52, 60, 60, 966, 1624, 129, |
| 179140 | | - /* 1800 */ 1469, 465, 1319, 243, 1310, 1298, 1297, 1299, 1644, 170, |
| 179141 | | - /* 1810 */ 518, 1389, 289, 584, 12, 322, 323, 324, 228, 409, |
| 179142 | | - /* 1820 */ 1451, 305, 1053, 1053, 1055, 1056, 35, 561, 241, 351, |
| 179143 | | - /* 1830 */ 245, 1446, 562, 127, 587, 357, 4, 1439, 352, 311, |
| 179144 | | - /* 1840 */ 1456, 503, 1065, 528, 1455, 416, 232, 1401, 125, 125, |
| 179145 | | - /* 1850 */ 590, 1218, 381, 1532, 1337, 1531, 126, 1402, 465, 596, |
| 179146 | | - /* 1860 */ 465, 1400, 1399, 1053, 585, 213, 403, 227, 214, 537, |
| 179147 | | - /* 1870 */ 1647, 1587, 1274, 1589, 465, 1588, 239, 278, 1271, 1579, |
| 179148 | | - /* 1880 */ 1577, 96, 435, 100, 224, 198, 584, 1537, 183, 99, |
| 179149 | | - /* 1890 */ 191, 487, 488, 1452, 521, 1053, 1053, 1055, 1056, 35, |
| 179150 | | - /* 1900 */ 561, 13, 193, 194, 195, 560, 196, 255, 113, 414, |
| 179151 | | - /* 1910 */ 1458, 1457, 14, 510, 495, 1065, 259, 1460, 202, 106, |
| 179152 | | - /* 1920 */ 516, 125, 125, 417, 1218, 290, 1548, 1526, 261, 126, |
| 179153 | | - /* 1930 */ 206, 465, 596, 465, 362, 519, 1053, 419, 366, 262, |
| 179154 | | - /* 1940 */ 1357, 1300, 1356, 449, 263, 1355, 1348, 108, 918, 1327, |
| 179155 | | - /* 1950 */ 1661, 420, 1660, 233, 1326, 453, 1629, 380, 546, 1347, |
| 179156 | | - /* 1960 */ 1325, 454, 277, 276, 1659, 1615, 1614, 457, 1053, 1053, |
| 179157 | | - /* 1970 */ 1055, 1056, 35, 1636, 1222, 467, 320, 321, 301, 386, |
| 179158 | | - /* 1980 */ 144, 1424, 572, 408, 408, 407, 285, 405, 11, 1423, |
| 179159 | | - /* 1990 */ 884, 397, 120, 127, 587, 220, 4, 1218, 1380, 1513, |
| 179160 | | - /* 2000 */ 395, 114, 1379, 247, 42, 339, 556, 598, 1228, 284, |
| 179161 | | - /* 2010 */ 590, 401, 402, 338, 286, 287, 328, 599, 1295, 1290, |
| 179162 | | - /* 2020 */ 1564, 175, 428, 1565, 429, 1563, 176, 871, 159, 177, |
| 179163 | | - /* 2030 */ 1562, 318, 229, 466, 465, 230, 221, 91, 332, 469, |
| 179164 | | - /* 2040 */ 1169, 471, 474, 94, 249, 189, 584, 95, 244, 1127, |
| 179165 | | - /* 2050 */ 188, 1125, 178, 342, 190, 43, 1253, 179, 251, 950, |
| 179166 | | - /* 2060 */ 254, 350, 192, 1141, 197, 180, 181, 438, 182, 440, |
| 179167 | | - /* 2070 */ 102, 103, 248, 104, 199, 1065, 1144, 256, 105, 1140, |
| 179168 | | - /* 2080 */ 257, 125, 125, 24, 166, 258, 361, 1133, 274, 126, |
| 179169 | | - /* 2090 */ 515, 465, 596, 465, 260, 15, 1053, 204, 264, 382, |
| 179170 | | - /* 2100 */ 886, 92, 587, 1268, 4, 203, 520, 427, 205, 524, |
| 179171 | | - /* 2110 */ 107, 25, 330, 586, 374, 574, 26, 916, 590, 529, |
| 179172 | | - /* 2120 */ 377, 929, 109, 319, 167, 110, 27, 184, 1053, 1053, |
| 179173 | | - /* 2130 */ 1055, 1056, 35, 540, 532, 1215, 477, 1094, 111, 1185, |
| 179174 | | - /* 2140 */ 17, 234, 465, 293, 1184, 295, 207, 997, 129, 273, |
| 179175 | | - /* 2150 */ 1205, 28, 1003, 29, 584, 30, 1201, 1218, 1208, 31, |
| 179176 | | - /* 2160 */ 1203, 1209, 32, 1190, 41, 568, 33, 34, 211, 115, |
| 179177 | | - /* 2170 */ 8, 1108, 1095, 1093, 1097, 1098, 279, 580, 122, 1149, |
| 179178 | | - /* 2180 */ 36, 117, 18, 1065, 1058, 118, 898, 128, 37, 125, |
| 179179 | | - /* 2190 */ 125, 406, 591, 186, 960, 280, 281, 126, 1652, 465, |
| 179180 | | - /* 2200 */ 596, 465, 1222, 467, 1053, 157, 301, 1224, 1223, 1286, |
| 179181 | | - /* 2210 */ 1286, 408, 408, 407, 285, 405, 1286, 1286, 884, 1286, |
| 179182 | | - /* 2220 */ 301, 1286, 1286, 573, 1286, 408, 408, 407, 285, 405, |
| 179183 | | - /* 2230 */ 1286, 247, 884, 339, 1286, 1286, 1053, 1053, 1055, 1056, |
| 179184 | | - /* 2240 */ 35, 338, 1286, 1286, 1286, 247, 1286, 339, 1286, 1286, |
| 179185 | | - /* 2250 */ 1286, 1286, 1286, 1286, 1286, 338, 1286, 1286, 1286, 1286, |
| 179186 | | - /* 2260 */ 1286, 1286, 1286, 1286, 1286, 1218, 1286, 1286, 1286, 1286, |
| 179187 | | - /* 2270 */ 1286, 1286, 249, 1286, 1286, 1286, 1286, 1286, 1286, 1286, |
| 179188 | | - /* 2280 */ 178, 1286, 1286, 43, 1286, 1286, 249, 1286, 1286, 1286, |
| 179189 | | - /* 2290 */ 1286, 1286, 1286, 1286, 178, 1286, 1286, 43, 1286, 1286, |
| 179190 | | - /* 2300 */ 248, 1286, 1286, 1286, 1286, 1286, 1286, 1286, 1286, 1286, |
| 179191 | | - /* 2310 */ 1286, 1286, 1286, 1286, 248, 1286, 1286, 1286, 1286, 1286, |
| 179192 | | - /* 2320 */ 1286, 1286, 1286, 1286, 1286, 1286, 1286, 1286, 1286, 1286, |
| 179193 | | - /* 2330 */ 1286, 1286, 1286, 1286, 1286, 427, 1286, 1286, 1286, 1286, |
| 179194 | | - /* 2340 */ 330, 586, 1286, 1286, 1286, 1286, 1286, 1286, 1286, 427, |
| 179195 | | - /* 2350 */ 1286, 1286, 1286, 1286, 330, 586, 1286, 1286, 1286, 1286, |
| 179196 | | - /* 2360 */ 1286, 1286, 1286, 1286, 477, 1286, 1286, 1286, 1286, 1286, |
| 179197 | | - /* 2370 */ 1286, 1286, 1286, 1286, 1286, 1286, 1286, 1286, 477, |
| 179118 | + /* 1070 */ 132, 463, 209, 1173, 563, 19, 19, 19, 19, 49, |
| 179119 | + /* 1080 */ 424, 944, 1175, 1686, 1046, 1686, 218, 355, 484, 343, |
| 179120 | + /* 1090 */ 210, 945, 569, 562, 1262, 1233, 1262, 490, 314, 423, |
| 179121 | + /* 1100 */ 424, 1598, 1206, 388, 141, 142, 93, 440, 1254, 1254, |
| 179122 | + /* 1110 */ 1085, 1088, 1075, 1075, 139, 139, 140, 140, 140, 140, |
| 179123 | + /* 1120 */ 352, 316, 531, 316, 141, 142, 93, 549, 1254, 1254, |
| 179124 | + /* 1130 */ 1085, 1088, 1075, 1075, 139, 139, 140, 140, 140, 140, |
| 179125 | + /* 1140 */ 446, 10, 1598, 274, 388, 915, 281, 299, 383, 534, |
| 179126 | + /* 1150 */ 378, 533, 269, 593, 1206, 587, 587, 587, 374, 293, |
| 179127 | + /* 1160 */ 1579, 991, 1173, 302, 138, 138, 138, 138, 137, 137, |
| 179128 | + /* 1170 */ 136, 136, 136, 135, 132, 463, 53, 53, 520, 1250, |
| 179129 | + /* 1180 */ 593, 1147, 1576, 431, 138, 138, 138, 138, 137, 137, |
| 179130 | + /* 1190 */ 136, 136, 136, 135, 132, 463, 1148, 301, 593, 1577, |
| 179131 | + /* 1200 */ 593, 1307, 431, 54, 54, 593, 268, 593, 461, 461, |
| 179132 | + /* 1210 */ 461, 1149, 347, 492, 424, 135, 132, 463, 1146, 1195, |
| 179133 | + /* 1220 */ 474, 68, 68, 69, 69, 550, 332, 287, 21, 21, |
| 179134 | + /* 1230 */ 55, 55, 1195, 581, 424, 1195, 309, 1250, 141, 142, |
| 179135 | + /* 1240 */ 93, 119, 1254, 1254, 1085, 1088, 1075, 1075, 139, 139, |
| 179136 | + /* 1250 */ 140, 140, 140, 140, 593, 237, 480, 1476, 141, 142, |
| 179137 | + /* 1260 */ 93, 593, 1254, 1254, 1085, 1088, 1075, 1075, 139, 139, |
| 179138 | + /* 1270 */ 140, 140, 140, 140, 344, 430, 346, 70, 70, 494, |
| 179139 | + /* 1280 */ 991, 1132, 1132, 512, 56, 56, 1269, 593, 268, 593, |
| 179140 | + /* 1290 */ 369, 374, 593, 481, 215, 384, 1624, 481, 138, 138, |
| 179141 | + /* 1300 */ 138, 138, 137, 137, 136, 136, 136, 135, 132, 463, |
| 179142 | + /* 1310 */ 71, 71, 72, 72, 225, 73, 73, 593, 138, 138, |
| 179143 | + /* 1320 */ 138, 138, 137, 137, 136, 136, 136, 135, 132, 463, |
| 179144 | + /* 1330 */ 586, 431, 593, 872, 873, 874, 593, 911, 593, 1602, |
| 179145 | + /* 1340 */ 74, 74, 593, 7, 1460, 242, 593, 306, 424, 1578, |
| 179146 | + /* 1350 */ 472, 306, 364, 219, 367, 75, 75, 430, 345, 57, |
| 179147 | + /* 1360 */ 57, 58, 58, 432, 187, 59, 59, 593, 424, 61, |
| 179148 | + /* 1370 */ 61, 1475, 141, 142, 93, 123, 1254, 1254, 1085, 1088, |
| 179149 | + /* 1380 */ 1075, 1075, 139, 139, 140, 140, 140, 140, 424, 570, |
| 179150 | + /* 1390 */ 62, 62, 141, 142, 93, 911, 1254, 1254, 1085, 1088, |
| 179151 | + /* 1400 */ 1075, 1075, 139, 139, 140, 140, 140, 140, 161, 384, |
| 179152 | + /* 1410 */ 1624, 1474, 141, 130, 93, 441, 1254, 1254, 1085, 1088, |
| 179153 | + /* 1420 */ 1075, 1075, 139, 139, 140, 140, 140, 140, 267, 266, |
| 179154 | + /* 1430 */ 265, 1460, 138, 138, 138, 138, 137, 137, 136, 136, |
| 179155 | + /* 1440 */ 136, 135, 132, 463, 593, 1336, 593, 1269, 1460, 384, |
| 179156 | + /* 1450 */ 1624, 231, 138, 138, 138, 138, 137, 137, 136, 136, |
| 179157 | + /* 1460 */ 136, 135, 132, 463, 593, 163, 593, 76, 76, 77, |
| 179158 | + /* 1470 */ 77, 593, 138, 138, 138, 138, 137, 137, 136, 136, |
| 179159 | + /* 1480 */ 136, 135, 132, 463, 475, 593, 483, 78, 78, 20, |
| 179160 | + /* 1490 */ 20, 1249, 424, 491, 79, 79, 495, 422, 295, 235, |
| 179161 | + /* 1500 */ 1574, 38, 511, 896, 422, 335, 240, 422, 147, 147, |
| 179162 | + /* 1510 */ 112, 593, 424, 593, 101, 222, 991, 142, 93, 455, |
| 179163 | + /* 1520 */ 1254, 1254, 1085, 1088, 1075, 1075, 139, 139, 140, 140, |
| 179164 | + /* 1530 */ 140, 140, 593, 39, 148, 148, 80, 80, 93, 551, |
| 179165 | + /* 1540 */ 1254, 1254, 1085, 1088, 1075, 1075, 139, 139, 140, 140, |
| 179166 | + /* 1550 */ 140, 140, 328, 923, 922, 64, 64, 502, 1656, 1005, |
| 179167 | + /* 1560 */ 933, 896, 124, 422, 121, 254, 593, 1006, 593, 226, |
| 179168 | + /* 1570 */ 593, 127, 585, 164, 4, 16, 138, 138, 138, 138, |
| 179169 | + /* 1580 */ 137, 137, 136, 136, 136, 135, 132, 463, 588, 81, |
| 179170 | + /* 1590 */ 81, 65, 65, 82, 82, 593, 138, 138, 138, 138, |
| 179171 | + /* 1600 */ 137, 137, 136, 136, 136, 135, 132, 463, 593, 226, |
| 179172 | + /* 1610 */ 237, 966, 464, 593, 298, 593, 965, 593, 66, 66, |
| 179173 | + /* 1620 */ 593, 1170, 593, 411, 582, 353, 469, 115, 593, 471, |
| 179174 | + /* 1630 */ 169, 173, 173, 593, 44, 991, 174, 174, 89, 89, |
| 179175 | + /* 1640 */ 67, 67, 593, 85, 85, 150, 150, 1114, 1043, 593, |
| 179176 | + /* 1650 */ 273, 86, 86, 1062, 593, 503, 171, 171, 593, 125, |
| 179177 | + /* 1660 */ 125, 497, 593, 273, 336, 152, 152, 126, 1335, 464, |
| 179178 | + /* 1670 */ 594, 464, 146, 146, 1050, 593, 545, 172, 172, 593, |
| 179179 | + /* 1680 */ 1054, 165, 165, 256, 339, 156, 156, 127, 585, 1586, |
| 179180 | + /* 1690 */ 4, 329, 584, 499, 358, 273, 115, 348, 155, 155, |
| 179181 | + /* 1700 */ 930, 931, 153, 153, 588, 1114, 1050, 1050, 1052, 1053, |
| 179182 | + /* 1710 */ 35, 1554, 521, 593, 270, 1008, 1009, 9, 593, 372, |
| 179183 | + /* 1720 */ 593, 115, 593, 168, 593, 115, 593, 1110, 464, 270, |
| 179184 | + /* 1730 */ 996, 964, 273, 129, 1645, 1214, 154, 154, 1054, 1404, |
| 179185 | + /* 1740 */ 582, 88, 88, 90, 90, 87, 87, 52, 52, 60, |
| 179186 | + /* 1750 */ 60, 1405, 504, 537, 559, 1179, 961, 507, 129, 558, |
| 179187 | + /* 1760 */ 127, 585, 1126, 4, 1126, 1125, 894, 1125, 162, 1062, |
| 179188 | + /* 1770 */ 963, 359, 129, 1401, 363, 125, 125, 588, 366, 368, |
| 179189 | + /* 1780 */ 370, 1349, 1334, 126, 1333, 464, 594, 464, 377, 387, |
| 179190 | + /* 1790 */ 1050, 1391, 1414, 1618, 1459, 1387, 1399, 208, 580, 1464, |
| 179191 | + /* 1800 */ 1314, 464, 243, 516, 1305, 1293, 1384, 1292, 1294, 1638, |
| 179192 | + /* 1810 */ 288, 170, 228, 582, 12, 408, 321, 322, 241, 323, |
| 179193 | + /* 1820 */ 245, 1446, 1050, 1050, 1052, 1053, 35, 559, 304, 350, |
| 179194 | + /* 1830 */ 351, 501, 560, 127, 585, 1441, 4, 1451, 1434, 310, |
| 179195 | + /* 1840 */ 1450, 526, 1062, 1332, 415, 380, 232, 1527, 125, 125, |
| 179196 | + /* 1850 */ 588, 1214, 1396, 356, 1526, 583, 126, 1397, 464, 594, |
| 179197 | + /* 1860 */ 464, 1641, 535, 1050, 1581, 1395, 1269, 1583, 1582, 213, |
| 179198 | + /* 1870 */ 402, 277, 214, 227, 464, 1573, 239, 1571, 1266, 1394, |
| 179199 | + /* 1880 */ 434, 198, 100, 224, 96, 183, 582, 191, 485, 193, |
| 179200 | + /* 1890 */ 486, 194, 195, 196, 519, 1050, 1050, 1052, 1053, 35, |
| 179201 | + /* 1900 */ 559, 113, 252, 413, 1447, 558, 493, 13, 1455, 416, |
| 179202 | + /* 1910 */ 1453, 1452, 14, 202, 1521, 1062, 1532, 508, 258, 106, |
| 179203 | + /* 1920 */ 514, 125, 125, 99, 1214, 1543, 289, 260, 206, 126, |
| 179204 | + /* 1930 */ 365, 464, 594, 464, 361, 517, 1050, 261, 448, 1295, |
| 179205 | + /* 1940 */ 262, 418, 1352, 1351, 108, 1350, 1655, 1654, 1343, 915, |
| 179206 | + /* 1950 */ 419, 1322, 233, 452, 319, 379, 1321, 453, 1623, 320, |
| 179207 | + /* 1960 */ 1320, 275, 1653, 544, 276, 1609, 1608, 1342, 1050, 1050, |
| 179208 | + /* 1970 */ 1052, 1053, 35, 1630, 1218, 466, 385, 456, 300, 1419, |
| 179209 | + /* 1980 */ 144, 1418, 570, 407, 407, 406, 284, 404, 11, 1508, |
| 179210 | + /* 1990 */ 881, 396, 120, 127, 585, 394, 4, 1214, 327, 114, |
| 179211 | + /* 2000 */ 1375, 1374, 220, 247, 400, 338, 401, 554, 42, 1224, |
| 179212 | + /* 2010 */ 588, 596, 283, 337, 285, 286, 188, 597, 1290, 1285, |
| 179213 | + /* 2020 */ 175, 1558, 176, 1559, 1557, 1556, 159, 317, 229, 177, |
| 179214 | + /* 2030 */ 868, 230, 91, 465, 464, 221, 331, 468, 1165, 470, |
| 179215 | + /* 2040 */ 473, 94, 244, 95, 249, 189, 582, 1124, 1122, 341, |
| 179216 | + /* 2050 */ 427, 190, 178, 1249, 179, 43, 192, 947, 349, 428, |
| 179217 | + /* 2060 */ 1138, 197, 251, 180, 181, 436, 102, 182, 438, 103, |
| 179218 | + /* 2070 */ 104, 199, 248, 1140, 253, 1062, 105, 255, 1137, 166, |
| 179219 | + /* 2080 */ 24, 125, 125, 257, 1264, 273, 360, 513, 259, 126, |
| 179220 | + /* 2090 */ 15, 464, 594, 464, 204, 883, 1050, 518, 263, 373, |
| 179221 | + /* 2100 */ 381, 92, 585, 1130, 4, 203, 205, 426, 107, 522, |
| 179222 | + /* 2110 */ 25, 26, 329, 584, 913, 572, 527, 376, 588, 926, |
| 179223 | + /* 2120 */ 530, 109, 184, 318, 167, 110, 27, 538, 1050, 1050, |
| 179224 | + /* 2130 */ 1052, 1053, 35, 1211, 1091, 17, 476, 111, 1181, 234, |
| 179225 | + /* 2140 */ 292, 1180, 464, 294, 207, 994, 129, 1201, 272, 1000, |
| 179226 | + /* 2150 */ 28, 1197, 29, 30, 582, 1199, 1205, 1214, 31, 1204, |
| 179227 | + /* 2160 */ 32, 1186, 41, 566, 33, 1105, 211, 8, 115, 1092, |
| 179228 | + /* 2170 */ 1090, 1094, 34, 278, 578, 1095, 117, 122, 118, 1145, |
| 179229 | + /* 2180 */ 36, 18, 128, 1062, 1055, 895, 957, 37, 589, 125, |
| 179230 | + /* 2190 */ 125, 279, 186, 280, 1646, 157, 405, 126, 1220, 464, |
| 179231 | + /* 2200 */ 594, 464, 1218, 466, 1050, 1219, 300, 1281, 1281, 1281, |
| 179232 | + /* 2210 */ 1281, 407, 407, 406, 284, 404, 1281, 1281, 881, 1281, |
| 179233 | + /* 2220 */ 300, 1281, 1281, 571, 1281, 407, 407, 406, 284, 404, |
| 179234 | + /* 2230 */ 1281, 247, 881, 338, 1281, 1281, 1050, 1050, 1052, 1053, |
| 179235 | + /* 2240 */ 35, 337, 1281, 1281, 1281, 247, 1281, 338, 1281, 1281, |
| 179236 | + /* 2250 */ 1281, 1281, 1281, 1281, 1281, 337, 1281, 1281, 1281, 1281, |
| 179237 | + /* 2260 */ 1281, 1281, 1281, 1281, 1281, 1214, 1281, 1281, 1281, 1281, |
| 179238 | + /* 2270 */ 1281, 1281, 249, 1281, 1281, 1281, 1281, 1281, 1281, 1281, |
| 179239 | + /* 2280 */ 178, 1281, 1281, 43, 1281, 1281, 249, 1281, 1281, 1281, |
| 179240 | + /* 2290 */ 1281, 1281, 1281, 1281, 178, 1281, 1281, 43, 1281, 1281, |
| 179241 | + /* 2300 */ 248, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, |
| 179242 | + /* 2310 */ 1281, 1281, 1281, 1281, 248, 1281, 1281, 1281, 1281, 1281, |
| 179243 | + /* 2320 */ 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, |
| 179244 | + /* 2330 */ 1281, 1281, 1281, 1281, 1281, 426, 1281, 1281, 1281, 1281, |
| 179245 | + /* 2340 */ 329, 584, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 426, |
| 179246 | + /* 2350 */ 1281, 1281, 1281, 1281, 329, 584, 1281, 1281, 1281, 1281, |
| 179247 | + /* 2360 */ 1281, 1281, 1281, 1281, 476, 1281, 1281, 1281, 1281, 1281, |
| 179248 | + /* 2370 */ 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 476, |
| 179198 | 179249 | }; |
| 179199 | 179250 | static const YYCODETYPE yy_lookahead[] = { |
| 179200 | | - /* 0 */ 277, 278, 279, 241, 242, 225, 195, 227, 195, 246, |
| 179201 | | - /* 10 */ 195, 195, 195, 221, 195, 235, 254, 195, 256, 19, |
| 179202 | | - /* 20 */ 257, 298, 277, 278, 279, 206, 213, 214, 206, 218, |
| 179251 | + /* 0 */ 277, 278, 279, 241, 242, 225, 195, 227, 195, 312, |
| 179252 | + /* 10 */ 195, 218, 195, 316, 195, 235, 254, 195, 256, 19, |
| 179253 | + /* 20 */ 297, 277, 278, 279, 218, 206, 213, 214, 206, 218, |
| 179203 | 179254 | /* 30 */ 219, 31, 206, 218, 219, 218, 219, 218, 219, 39, |
| 179204 | | - /* 40 */ 218, 219, 29, 43, 44, 45, 33, 47, 48, 49, |
| 179255 | + /* 40 */ 218, 219, 195, 43, 44, 45, 195, 47, 48, 49, |
| 179205 | 179256 | /* 50 */ 50, 51, 52, 53, 54, 55, 56, 57, 58, 19, |
| 179206 | | - /* 60 */ 241, 242, 276, 241, 242, 195, 255, 241, 242, 277, |
| 179207 | | - /* 70 */ 278, 279, 11, 254, 255, 256, 254, 255, 256, 66, |
| 179208 | | - /* 80 */ 254, 265, 256, 43, 44, 45, 264, 47, 48, 49, |
| 179209 | | - /* 90 */ 50, 51, 52, 53, 54, 55, 56, 57, 58, 215, |
| 179210 | | - /* 100 */ 287, 315, 316, 103, 104, 105, 106, 107, 108, 109, |
| 179211 | | - /* 110 */ 110, 111, 112, 113, 114, 237, 238, 195, 74, 195, |
| 179212 | | - /* 120 */ 187, 188, 189, 190, 191, 192, 82, 87, 25, 89, |
| 179213 | | - /* 130 */ 197, 19, 199, 318, 319, 318, 319, 25, 195, 206, |
| 179214 | | - /* 140 */ 218, 219, 195, 103, 104, 105, 106, 107, 108, 109, |
| 179257 | + /* 60 */ 241, 242, 195, 241, 242, 195, 255, 241, 242, 195, |
| 179258 | + /* 70 */ 255, 237, 238, 254, 255, 256, 254, 255, 256, 264, |
| 179259 | + /* 80 */ 254, 207, 256, 43, 44, 45, 264, 47, 48, 49, |
| 179260 | + /* 90 */ 50, 51, 52, 53, 54, 55, 56, 57, 58, 251, |
| 179261 | + /* 100 */ 287, 253, 215, 103, 104, 105, 106, 107, 108, 109, |
| 179262 | + /* 110 */ 110, 111, 112, 113, 114, 82, 265, 195, 271, 11, |
| 179263 | + /* 120 */ 187, 188, 189, 190, 191, 192, 190, 87, 192, 89, |
| 179264 | + /* 130 */ 197, 19, 199, 197, 317, 199, 319, 25, 271, 206, |
| 179265 | + /* 140 */ 218, 219, 206, 103, 104, 105, 106, 107, 108, 109, |
| 179215 | 179266 | /* 150 */ 110, 111, 112, 113, 114, 43, 44, 45, 195, 47, |
| 179216 | 179267 | /* 160 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, |
| 179217 | | - /* 170 */ 58, 60, 128, 289, 241, 242, 114, 255, 294, 60, |
| 179218 | | - /* 180 */ 310, 311, 70, 139, 140, 218, 264, 254, 77, 256, |
| 179219 | | - /* 190 */ 129, 130, 73, 55, 56, 57, 58, 59, 221, 88, |
| 179220 | | - /* 200 */ 218, 90, 269, 240, 93, 107, 108, 109, 110, 111, |
| 179221 | | - /* 210 */ 112, 113, 114, 215, 271, 103, 104, 105, 106, 107, |
| 179222 | | - /* 220 */ 108, 109, 110, 111, 112, 113, 114, 218, 117, 118, |
| 179223 | | - /* 230 */ 119, 307, 299, 309, 301, 19, 117, 118, 119, 129, |
| 179224 | | - /* 240 */ 130, 103, 104, 105, 106, 107, 108, 109, 110, 111, |
| 179225 | | - /* 250 */ 112, 113, 114, 150, 277, 278, 279, 146, 311, 43, |
| 179268 | + /* 170 */ 58, 60, 139, 140, 241, 242, 289, 241, 242, 309, |
| 179269 | + /* 180 */ 310, 294, 70, 47, 48, 49, 50, 254, 77, 256, |
| 179270 | + /* 190 */ 254, 195, 256, 55, 56, 57, 58, 59, 221, 88, |
| 179271 | + /* 200 */ 109, 90, 269, 240, 93, 269, 107, 108, 109, 110, |
| 179272 | + /* 210 */ 111, 112, 113, 114, 215, 103, 104, 105, 106, 107, |
| 179273 | + /* 220 */ 108, 109, 110, 111, 112, 113, 114, 136, 117, 118, |
| 179274 | + /* 230 */ 119, 298, 141, 300, 298, 19, 300, 129, 130, 317, |
| 179275 | + /* 240 */ 318, 103, 104, 105, 106, 107, 108, 109, 110, 111, |
| 179276 | + /* 250 */ 112, 113, 114, 114, 277, 278, 279, 146, 122, 43, |
| 179226 | 179277 | /* 260 */ 44, 45, 195, 47, 48, 49, 50, 51, 52, 53, |
| 179227 | | - /* 270 */ 54, 55, 56, 57, 58, 277, 278, 279, 313, 19, |
| 179228 | | - /* 280 */ 195, 195, 317, 23, 68, 218, 219, 25, 55, 56, |
| 179229 | | - /* 290 */ 57, 58, 109, 110, 111, 112, 113, 114, 22, 23, |
| 179230 | | - /* 300 */ 233, 25, 313, 43, 44, 45, 317, 47, 48, 49, |
| 179278 | + /* 270 */ 54, 55, 56, 57, 58, 218, 277, 278, 279, 19, |
| 179279 | + /* 280 */ 19, 195, 286, 23, 68, 218, 219, 55, 56, 57, |
| 179280 | + /* 290 */ 58, 103, 104, 105, 106, 107, 108, 109, 110, 111, |
| 179281 | + /* 300 */ 112, 113, 114, 43, 44, 45, 232, 47, 48, 49, |
| 179231 | 179282 | /* 310 */ 50, 51, 52, 53, 54, 55, 56, 57, 58, 103, |
| 179232 | 179283 | /* 320 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, |
| 179233 | | - /* 330 */ 114, 232, 60, 212, 213, 214, 103, 104, 105, 106, |
| 179234 | | - /* 340 */ 107, 108, 109, 110, 111, 112, 113, 114, 103, 104, |
| 179235 | | - /* 350 */ 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, |
| 179236 | | - /* 360 */ 24, 195, 200, 103, 104, 105, 106, 107, 108, 109, |
| 179237 | | - /* 370 */ 110, 111, 112, 113, 114, 251, 60, 253, 102, 107, |
| 179238 | | - /* 380 */ 108, 119, 313, 19, 218, 219, 317, 23, 116, 117, |
| 179239 | | - /* 390 */ 118, 119, 195, 121, 206, 22, 60, 26, 312, 313, |
| 179240 | | - /* 400 */ 195, 129, 205, 317, 207, 35, 144, 43, 44, 45, |
| 179241 | | - /* 410 */ 195, 47, 48, 49, 50, 51, 52, 53, 54, 55, |
| 179242 | | - /* 420 */ 56, 57, 58, 218, 219, 82, 154, 19, 156, 241, |
| 179243 | | - /* 430 */ 242, 60, 24, 117, 118, 119, 120, 67, 233, 123, |
| 179244 | | - /* 440 */ 124, 125, 254, 195, 256, 75, 284, 259, 260, 133, |
| 179245 | | - /* 450 */ 288, 43, 44, 45, 118, 47, 48, 49, 50, 51, |
| 179284 | + /* 330 */ 114, 135, 60, 137, 138, 103, 104, 105, 106, 107, |
| 179285 | + /* 340 */ 108, 109, 110, 111, 112, 113, 114, 82, 281, 206, |
| 179286 | + /* 350 */ 195, 109, 110, 111, 112, 113, 114, 195, 195, 195, |
| 179287 | + /* 360 */ 205, 22, 207, 103, 104, 105, 106, 107, 108, 109, |
| 179288 | + /* 370 */ 110, 111, 112, 113, 114, 195, 60, 116, 117, 107, |
| 179289 | + /* 380 */ 108, 218, 219, 19, 241, 242, 121, 23, 116, 117, |
| 179290 | + /* 390 */ 118, 119, 306, 121, 308, 206, 234, 254, 15, 256, |
| 179291 | + /* 400 */ 195, 129, 259, 260, 139, 140, 145, 43, 44, 45, |
| 179292 | + /* 410 */ 200, 47, 48, 49, 50, 51, 52, 53, 54, 55, |
| 179293 | + /* 420 */ 56, 57, 58, 218, 219, 60, 154, 19, 156, 265, |
| 179294 | + /* 430 */ 241, 242, 24, 117, 118, 119, 120, 21, 73, 123, |
| 179295 | + /* 440 */ 124, 125, 74, 254, 61, 256, 107, 108, 221, 133, |
| 179296 | + /* 450 */ 82, 43, 44, 45, 195, 47, 48, 49, 50, 51, |
| 179246 | 179297 | /* 460 */ 52, 53, 54, 55, 56, 57, 58, 103, 104, 105, |
| 179247 | 179298 | /* 470 */ 106, 107, 108, 109, 110, 111, 112, 113, 114, 195, |
| 179248 | | - /* 480 */ 107, 108, 139, 140, 318, 195, 320, 195, 117, 118, |
| 179249 | | - /* 490 */ 119, 61, 19, 20, 120, 22, 195, 123, 124, 125, |
| 179250 | | - /* 500 */ 195, 131, 218, 219, 195, 195, 146, 133, 207, 36, |
| 179251 | | - /* 510 */ 295, 103, 104, 105, 106, 107, 108, 109, 110, 111, |
| 179252 | | - /* 520 */ 112, 113, 114, 218, 219, 165, 60, 195, 218, 219, |
| 179253 | | - /* 530 */ 240, 19, 240, 60, 189, 190, 191, 192, 233, 255, |
| 179254 | | - /* 540 */ 139, 140, 197, 233, 199, 72, 61, 272, 264, 195, |
| 179255 | | - /* 550 */ 120, 206, 195, 19, 60, 43, 44, 45, 206, 47, |
| 179299 | + /* 480 */ 317, 318, 117, 118, 119, 22, 120, 195, 22, 123, |
| 179300 | + /* 490 */ 124, 125, 19, 20, 284, 22, 128, 81, 288, 133, |
| 179301 | + /* 500 */ 195, 195, 218, 219, 277, 278, 279, 139, 140, 36, |
| 179302 | + /* 510 */ 195, 103, 104, 105, 106, 107, 108, 109, 110, 111, |
| 179303 | + /* 520 */ 112, 113, 114, 218, 219, 62, 60, 195, 241, 242, |
| 179304 | + /* 530 */ 271, 19, 240, 60, 189, 190, 191, 192, 233, 255, |
| 179305 | + /* 540 */ 124, 254, 197, 256, 199, 72, 129, 130, 264, 195, |
| 179306 | + /* 550 */ 195, 206, 22, 23, 60, 43, 44, 45, 206, 47, |
| 179256 | 179307 | /* 560 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, |
| 179257 | | - /* 570 */ 58, 25, 218, 219, 101, 109, 112, 113, 114, 195, |
| 179258 | | - /* 580 */ 107, 108, 109, 117, 118, 119, 241, 242, 115, 195, |
| 179259 | | - /* 590 */ 117, 118, 119, 241, 242, 122, 60, 206, 195, 254, |
| 179260 | | - /* 600 */ 60, 256, 218, 219, 195, 120, 254, 195, 256, 73, |
| 179261 | | - /* 610 */ 125, 117, 118, 119, 269, 103, 104, 105, 106, 107, |
| 179308 | + /* 570 */ 58, 195, 218, 219, 101, 195, 60, 271, 162, 195, |
| 179309 | + /* 580 */ 107, 108, 109, 117, 118, 119, 241, 242, 115, 73, |
| 179310 | + /* 590 */ 117, 118, 119, 241, 242, 122, 60, 195, 266, 254, |
| 179311 | + /* 600 */ 312, 256, 218, 219, 316, 203, 254, 195, 256, 255, |
| 179312 | + /* 610 */ 208, 117, 118, 119, 269, 103, 104, 105, 106, 107, |
| 179262 | 179313 | /* 620 */ 108, 109, 110, 111, 112, 113, 114, 154, 155, 156, |
| 179263 | | - /* 630 */ 157, 158, 241, 242, 240, 281, 19, 234, 144, 255, |
| 179264 | | - /* 640 */ 23, 206, 166, 167, 299, 254, 301, 256, 264, 240, |
| 179265 | | - /* 650 */ 116, 117, 295, 117, 118, 119, 183, 117, 118, 119, |
| 179314 | + /* 630 */ 157, 158, 102, 117, 118, 119, 19, 242, 144, 255, |
| 179315 | + /* 640 */ 23, 206, 24, 298, 195, 300, 206, 195, 264, 254, |
| 179316 | + /* 650 */ 206, 256, 240, 117, 118, 119, 183, 22, 22, 23, |
| 179266 | 179317 | /* 660 */ 43, 44, 45, 151, 47, 48, 49, 50, 51, 52, |
| 179267 | | - /* 670 */ 53, 54, 55, 56, 57, 58, 241, 242, 266, 145, |
| 179268 | | - /* 680 */ 19, 241, 242, 242, 23, 139, 140, 77, 25, 254, |
| 179269 | | - /* 690 */ 195, 256, 152, 276, 254, 254, 256, 256, 88, 206, |
| 179270 | | - /* 700 */ 90, 60, 206, 93, 43, 44, 45, 272, 47, 48, |
| 179318 | + /* 670 */ 53, 54, 55, 56, 57, 58, 241, 242, 60, 195, |
| 179319 | + /* 680 */ 19, 241, 242, 195, 23, 241, 242, 195, 152, 254, |
| 179320 | + /* 690 */ 310, 256, 243, 312, 254, 60, 256, 316, 254, 206, |
| 179321 | + /* 700 */ 256, 60, 218, 219, 43, 44, 45, 272, 47, 48, |
| 179271 | 179322 | /* 710 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, |
| 179272 | 179323 | /* 720 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, |
| 179273 | | - /* 730 */ 113, 114, 315, 316, 241, 242, 131, 241, 242, 134, |
| 179274 | | - /* 740 */ 22, 206, 101, 22, 82, 19, 20, 254, 22, 256, |
| 179275 | | - /* 750 */ 254, 74, 256, 263, 22, 195, 146, 267, 117, 118, |
| 179276 | | - /* 760 */ 276, 266, 36, 122, 103, 104, 105, 106, 107, 108, |
| 179277 | | - /* 770 */ 109, 110, 111, 112, 113, 114, 241, 242, 60, 217, |
| 179278 | | - /* 780 */ 130, 60, 195, 121, 19, 195, 60, 225, 23, 254, |
| 179279 | | - /* 790 */ 127, 256, 60, 237, 238, 154, 155, 156, 72, 315, |
| 179280 | | - /* 800 */ 316, 139, 140, 153, 22, 128, 129, 130, 43, 44, |
| 179324 | + /* 730 */ 113, 114, 240, 60, 241, 242, 118, 25, 102, 255, |
| 179325 | + /* 740 */ 166, 167, 101, 22, 26, 19, 20, 254, 22, 256, |
| 179326 | + /* 750 */ 139, 140, 117, 118, 119, 306, 195, 308, 117, 118, |
| 179327 | + /* 760 */ 237, 238, 36, 122, 103, 104, 105, 106, 107, 108, |
| 179328 | + /* 770 */ 109, 110, 111, 112, 113, 114, 195, 195, 60, 218, |
| 179329 | + /* 780 */ 219, 60, 109, 195, 19, 217, 60, 25, 23, 77, |
| 179330 | + /* 790 */ 117, 118, 119, 225, 233, 154, 155, 156, 72, 312, |
| 179331 | + /* 800 */ 218, 219, 90, 316, 22, 93, 303, 304, 43, 44, |
| 179281 | 179332 | /* 810 */ 45, 195, 47, 48, 49, 50, 51, 52, 53, 54, |
| 179282 | | - /* 820 */ 55, 56, 57, 58, 183, 304, 305, 101, 19, 60, |
| 179283 | | - /* 830 */ 243, 271, 23, 107, 108, 117, 118, 119, 117, 118, |
| 179284 | | - /* 840 */ 119, 115, 60, 117, 118, 119, 16, 195, 122, 117, |
| 179285 | | - /* 850 */ 118, 119, 43, 44, 45, 22, 47, 48, 49, 50, |
| 179333 | + /* 820 */ 55, 56, 57, 58, 183, 195, 195, 101, 19, 213, |
| 179334 | + /* 830 */ 214, 243, 23, 107, 108, 117, 118, 119, 117, 118, |
| 179335 | + /* 840 */ 119, 115, 60, 117, 118, 119, 195, 60, 122, 218, |
| 179336 | + /* 850 */ 219, 22, 43, 44, 45, 35, 47, 48, 49, 50, |
| 179286 | 179337 | /* 860 */ 51, 52, 53, 54, 55, 56, 57, 58, 103, 104, |
| 179287 | 179338 | /* 870 */ 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, |
| 179288 | | - /* 880 */ 154, 155, 156, 157, 158, 295, 117, 118, 119, 60, |
| 179289 | | - /* 890 */ 101, 60, 240, 60, 307, 21, 309, 195, 195, 117, |
| 179290 | | - /* 900 */ 118, 119, 195, 47, 48, 49, 50, 118, 78, 183, |
| 179291 | | - /* 910 */ 80, 122, 103, 104, 105, 106, 107, 108, 109, 110, |
| 179292 | | - /* 920 */ 111, 112, 113, 114, 195, 218, 219, 16, 312, 313, |
| 179293 | | - /* 930 */ 195, 195, 19, 317, 262, 263, 23, 212, 213, 214, |
| 179294 | | - /* 940 */ 233, 210, 211, 154, 155, 156, 117, 118, 119, 118, |
| 179295 | | - /* 950 */ 117, 118, 119, 218, 219, 81, 43, 44, 45, 195, |
| 179339 | + /* 880 */ 154, 155, 156, 157, 158, 195, 255, 67, 195, 60, |
| 179340 | + /* 890 */ 101, 240, 311, 312, 306, 75, 308, 316, 29, 117, |
| 179341 | + /* 900 */ 118, 119, 33, 287, 117, 118, 119, 118, 146, 183, |
| 179342 | + /* 910 */ 195, 122, 103, 104, 105, 106, 107, 108, 109, 110, |
| 179343 | + /* 920 */ 111, 112, 113, 114, 215, 195, 77, 60, 25, 195, |
| 179344 | + /* 930 */ 122, 144, 19, 218, 219, 66, 23, 88, 246, 90, |
| 179345 | + /* 940 */ 132, 25, 93, 154, 155, 156, 117, 118, 119, 257, |
| 179346 | + /* 950 */ 195, 131, 218, 219, 195, 265, 43, 44, 45, 195, |
| 179296 | 179347 | /* 960 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, |
| 179297 | | - /* 970 */ 57, 58, 183, 144, 271, 122, 19, 190, 122, 192, |
| 179298 | | - /* 980 */ 23, 25, 218, 219, 197, 132, 199, 195, 286, 78, |
| 179299 | | - /* 990 */ 255, 80, 162, 206, 265, 107, 108, 233, 124, 195, |
| 179300 | | - /* 1000 */ 43, 44, 45, 195, 47, 48, 49, 50, 51, 52, |
| 179348 | + /* 970 */ 57, 58, 183, 218, 219, 195, 19, 218, 219, 195, |
| 179349 | + /* 980 */ 23, 195, 218, 219, 117, 118, 119, 195, 233, 255, |
| 179350 | + /* 990 */ 195, 195, 233, 22, 23, 146, 25, 233, 218, 219, |
| 179351 | + /* 1000 */ 43, 44, 45, 294, 47, 48, 49, 50, 51, 52, |
| 179301 | 179352 | /* 1010 */ 53, 54, 55, 56, 57, 58, 103, 104, 105, 106, |
| 179302 | | - /* 1020 */ 107, 108, 109, 110, 111, 112, 113, 114, 241, 242, |
| 179303 | | - /* 1030 */ 195, 195, 31, 77, 195, 243, 162, 195, 195, 195, |
| 179304 | | - /* 1040 */ 39, 254, 154, 256, 156, 19, 90, 203, 19, 93, |
| 179305 | | - /* 1050 */ 24, 208, 208, 218, 219, 195, 269, 218, 219, 195, |
| 179353 | + /* 1020 */ 107, 108, 109, 110, 111, 112, 113, 114, 195, 12, |
| 179354 | + /* 1030 */ 234, 195, 240, 74, 195, 255, 195, 60, 243, 262, |
| 179355 | + /* 1040 */ 263, 311, 312, 25, 27, 19, 316, 107, 108, 265, |
| 179356 | + /* 1050 */ 24, 265, 195, 150, 195, 139, 140, 218, 219, 42, |
| 179306 | 179357 | /* 1060 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, |
| 179307 | | - /* 1070 */ 113, 114, 233, 230, 266, 232, 47, 263, 218, 219, |
| 179308 | | - /* 1080 */ 19, 267, 218, 219, 23, 23, 299, 25, 301, 135, |
| 179309 | | - /* 1090 */ 255, 137, 138, 233, 47, 195, 195, 195, 25, 307, |
| 179310 | | - /* 1100 */ 19, 309, 22, 23, 43, 44, 45, 271, 47, 48, |
| 179358 | + /* 1070 */ 113, 114, 233, 102, 67, 218, 219, 218, 219, 243, |
| 179359 | + /* 1080 */ 19, 64, 22, 23, 23, 25, 195, 128, 129, 130, |
| 179360 | + /* 1090 */ 233, 74, 233, 86, 154, 118, 156, 130, 265, 208, |
| 179361 | + /* 1100 */ 19, 306, 95, 308, 43, 44, 45, 266, 47, 48, |
| 179311 | 179362 | /* 1110 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, |
| 179312 | | - /* 1120 */ 218, 219, 96, 195, 43, 44, 45, 195, 47, 48, |
| 179363 | + /* 1120 */ 153, 230, 96, 232, 43, 44, 45, 19, 47, 48, |
| 179313 | 179364 | /* 1130 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, |
| 179314 | | - /* 1140 */ 114, 195, 195, 243, 243, 116, 120, 121, 122, 123, |
| 179315 | | - /* 1150 */ 124, 125, 126, 195, 195, 195, 195, 255, 132, 213, |
| 179316 | | - /* 1160 */ 214, 132, 234, 116, 103, 104, 105, 106, 107, 108, |
| 179317 | | - /* 1170 */ 109, 110, 111, 112, 113, 114, 218, 219, 218, 219, |
| 179318 | | - /* 1180 */ 195, 119, 102, 195, 103, 104, 105, 106, 107, 108, |
| 179319 | | - /* 1190 */ 109, 110, 111, 112, 113, 114, 22, 23, 22, 25, |
| 179320 | | - /* 1200 */ 24, 67, 12, 218, 219, 195, 144, 307, 307, 309, |
| 179321 | | - /* 1210 */ 309, 195, 77, 255, 19, 255, 143, 27, 23, 313, |
| 179322 | | - /* 1220 */ 86, 100, 313, 317, 265, 90, 317, 266, 93, 95, |
| 179323 | | - /* 1230 */ 210, 211, 42, 287, 19, 23, 60, 25, 43, 44, |
| 179365 | + /* 1140 */ 114, 22, 306, 24, 308, 127, 120, 121, 122, 123, |
| 179366 | + /* 1150 */ 124, 125, 126, 195, 147, 212, 213, 214, 132, 23, |
| 179367 | + /* 1160 */ 195, 25, 102, 100, 103, 104, 105, 106, 107, 108, |
| 179368 | + /* 1170 */ 109, 110, 111, 112, 113, 114, 218, 219, 19, 60, |
| 179369 | + /* 1180 */ 195, 12, 210, 211, 103, 104, 105, 106, 107, 108, |
| 179370 | + /* 1190 */ 109, 110, 111, 112, 113, 114, 27, 134, 195, 195, |
| 179371 | + /* 1200 */ 195, 210, 211, 218, 219, 195, 47, 195, 212, 213, |
| 179372 | + /* 1210 */ 214, 42, 16, 130, 19, 112, 113, 114, 23, 77, |
| 179373 | + /* 1220 */ 195, 218, 219, 218, 219, 117, 163, 164, 218, 219, |
| 179374 | + /* 1230 */ 218, 219, 90, 64, 19, 93, 153, 118, 43, 44, |
| 179324 | 179375 | /* 1240 */ 45, 160, 47, 48, 49, 50, 51, 52, 53, 54, |
| 179325 | | - /* 1250 */ 55, 56, 57, 58, 64, 134, 109, 261, 43, 44, |
| 179326 | | - /* 1260 */ 45, 215, 47, 48, 49, 50, 51, 52, 53, 54, |
| 179327 | | - /* 1270 */ 55, 56, 57, 58, 210, 211, 102, 128, 129, 130, |
| 179328 | | - /* 1280 */ 12, 147, 266, 136, 163, 164, 302, 303, 141, 195, |
| 179329 | | - /* 1290 */ 25, 195, 19, 195, 118, 27, 228, 19, 103, 104, |
| 179376 | + /* 1250 */ 55, 56, 57, 58, 195, 119, 272, 276, 43, 44, |
| 179377 | + /* 1260 */ 45, 195, 47, 48, 49, 50, 51, 52, 53, 54, |
| 179378 | + /* 1270 */ 55, 56, 57, 58, 78, 116, 80, 218, 219, 116, |
| 179379 | + /* 1280 */ 144, 128, 129, 130, 218, 219, 61, 195, 47, 195, |
| 179380 | + /* 1290 */ 16, 132, 195, 263, 195, 314, 315, 267, 103, 104, |
| 179330 | 179381 | /* 1300 */ 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, |
| 179331 | | - /* 1310 */ 42, 195, 218, 219, 218, 219, 218, 219, 103, 104, |
| 179382 | + /* 1310 */ 218, 219, 218, 219, 151, 218, 219, 195, 103, 104, |
| 179332 | 179383 | /* 1320 */ 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, |
| 179333 | | - /* 1330 */ 19, 195, 64, 195, 218, 219, 195, 259, 260, 195, |
| 179334 | | - /* 1340 */ 294, 195, 74, 195, 150, 151, 195, 246, 19, 7, |
| 179335 | | - /* 1350 */ 8, 9, 195, 24, 218, 219, 218, 219, 257, 218, |
| 179336 | | - /* 1360 */ 219, 195, 218, 219, 218, 219, 218, 219, 19, 218, |
| 179337 | | - /* 1370 */ 219, 98, 43, 44, 45, 160, 47, 48, 49, 50, |
| 179338 | | - /* 1380 */ 51, 52, 53, 54, 55, 56, 57, 58, 19, 128, |
| 179339 | | - /* 1390 */ 129, 130, 43, 44, 45, 117, 47, 48, 49, 50, |
| 179340 | | - /* 1400 */ 51, 52, 53, 54, 55, 56, 57, 58, 22, 22, |
| 179341 | | - /* 1410 */ 116, 146, 43, 44, 45, 195, 47, 48, 49, 50, |
| 179342 | | - /* 1420 */ 51, 52, 53, 54, 55, 56, 57, 58, 117, 159, |
| 179343 | | - /* 1430 */ 195, 161, 103, 104, 105, 106, 107, 108, 109, 110, |
| 179344 | | - /* 1440 */ 111, 112, 113, 114, 195, 151, 195, 60, 62, 15, |
| 179345 | | - /* 1450 */ 195, 25, 103, 104, 105, 106, 107, 108, 109, 110, |
| 179346 | | - /* 1460 */ 111, 112, 113, 114, 195, 228, 195, 218, 219, 218, |
| 179384 | + /* 1330 */ 210, 211, 195, 7, 8, 9, 195, 60, 195, 312, |
| 179385 | + /* 1340 */ 218, 219, 195, 316, 195, 120, 195, 263, 19, 195, |
| 179386 | + /* 1350 */ 125, 267, 78, 24, 80, 218, 219, 116, 162, 218, |
| 179387 | + /* 1360 */ 219, 218, 219, 301, 302, 218, 219, 195, 19, 218, |
| 179388 | + /* 1370 */ 219, 276, 43, 44, 45, 160, 47, 48, 49, 50, |
| 179389 | + /* 1380 */ 51, 52, 53, 54, 55, 56, 57, 58, 19, 146, |
| 179390 | + /* 1390 */ 218, 219, 43, 44, 45, 118, 47, 48, 49, 50, |
| 179391 | + /* 1400 */ 51, 52, 53, 54, 55, 56, 57, 58, 165, 314, |
| 179392 | + /* 1410 */ 315, 276, 43, 44, 45, 266, 47, 48, 49, 50, |
| 179393 | + /* 1420 */ 51, 52, 53, 54, 55, 56, 57, 58, 128, 129, |
| 179394 | + /* 1430 */ 130, 195, 103, 104, 105, 106, 107, 108, 109, 110, |
| 179395 | + /* 1440 */ 111, 112, 113, 114, 195, 228, 195, 61, 195, 314, |
| 179396 | + /* 1450 */ 315, 25, 103, 104, 105, 106, 107, 108, 109, 110, |
| 179397 | + /* 1460 */ 111, 112, 113, 114, 195, 22, 195, 218, 219, 218, |
| 179347 | 179398 | /* 1470 */ 219, 195, 103, 104, 105, 106, 107, 108, 109, 110, |
| 179348 | | - /* 1480 */ 111, 112, 113, 114, 22, 195, 246, 218, 219, 218, |
| 179349 | | - /* 1490 */ 219, 195, 19, 22, 23, 61, 246, 257, 24, 136, |
| 179350 | | - /* 1500 */ 246, 22, 60, 24, 141, 118, 60, 257, 218, 219, |
| 179351 | | - /* 1510 */ 195, 257, 19, 195, 218, 219, 54, 44, 45, 195, |
| 179399 | + /* 1480 */ 111, 112, 113, 114, 195, 195, 246, 218, 219, 218, |
| 179400 | + /* 1490 */ 219, 25, 19, 246, 218, 219, 246, 257, 259, 260, |
| 179401 | + /* 1500 */ 195, 22, 266, 60, 257, 195, 120, 257, 218, 219, |
| 179402 | + /* 1510 */ 116, 195, 19, 195, 150, 151, 25, 44, 45, 266, |
| 179352 | 179403 | /* 1520 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, |
| 179353 | | - /* 1530 */ 57, 58, 195, 218, 219, 195, 218, 219, 45, 195, |
| 179404 | + /* 1530 */ 57, 58, 195, 54, 218, 219, 218, 219, 45, 145, |
| 179354 | 179405 | /* 1540 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, |
| 179355 | | - /* 1550 */ 57, 58, 195, 121, 122, 218, 219, 195, 218, 219, |
| 179356 | | - /* 1560 */ 118, 195, 218, 219, 118, 23, 195, 25, 195, 143, |
| 179357 | | - /* 1570 */ 195, 19, 20, 102, 22, 195, 103, 104, 105, 106, |
| 179406 | + /* 1550 */ 57, 58, 246, 121, 122, 218, 219, 19, 23, 31, |
| 179407 | + /* 1560 */ 25, 118, 159, 257, 161, 24, 195, 39, 195, 143, |
| 179408 | + /* 1570 */ 195, 19, 20, 22, 22, 24, 103, 104, 105, 106, |
| 179358 | 179409 | /* 1580 */ 107, 108, 109, 110, 111, 112, 113, 114, 36, 218, |
| 179359 | 179410 | /* 1590 */ 219, 218, 219, 218, 219, 195, 103, 104, 105, 106, |
| 179360 | | - /* 1600 */ 107, 108, 109, 110, 111, 112, 113, 114, 195, 23, |
| 179361 | | - /* 1610 */ 23, 25, 60, 195, 195, 195, 142, 195, 218, 219, |
| 179362 | | - /* 1620 */ 195, 23, 195, 25, 72, 130, 116, 23, 195, 25, |
| 179363 | | - /* 1630 */ 195, 218, 219, 195, 82, 195, 218, 219, 218, 219, |
| 179364 | | - /* 1640 */ 218, 219, 195, 218, 219, 218, 219, 195, 153, 195, |
| 179365 | | - /* 1650 */ 195, 218, 219, 101, 195, 145, 218, 219, 195, 107, |
| 179366 | | - /* 1660 */ 108, 23, 195, 25, 195, 218, 219, 115, 22, 117, |
| 179367 | | - /* 1670 */ 118, 119, 218, 219, 122, 195, 195, 218, 219, 195, |
| 179368 | | - /* 1680 */ 60, 218, 219, 7, 8, 218, 219, 19, 20, 195, |
| 179411 | + /* 1600 */ 107, 108, 109, 110, 111, 112, 113, 114, 195, 143, |
| 179412 | + /* 1610 */ 119, 136, 60, 195, 22, 195, 141, 195, 218, 219, |
| 179413 | + /* 1620 */ 195, 23, 195, 25, 72, 23, 131, 25, 195, 134, |
| 179414 | + /* 1630 */ 23, 218, 219, 195, 82, 144, 218, 219, 218, 219, |
| 179415 | + /* 1640 */ 218, 219, 195, 218, 219, 218, 219, 60, 23, 195, |
| 179416 | + /* 1650 */ 25, 218, 219, 101, 195, 117, 218, 219, 195, 107, |
| 179417 | + /* 1660 */ 108, 23, 195, 25, 195, 218, 219, 115, 228, 117, |
| 179418 | + /* 1670 */ 118, 119, 218, 219, 122, 195, 19, 218, 219, 195, |
| 179419 | + /* 1680 */ 60, 218, 219, 142, 195, 218, 219, 19, 20, 195, |
| 179369 | 179420 | /* 1690 */ 22, 139, 140, 23, 23, 25, 25, 195, 218, 219, |
| 179370 | | - /* 1700 */ 84, 85, 218, 219, 36, 228, 154, 155, 156, 157, |
| 179371 | | - /* 1710 */ 158, 195, 23, 195, 25, 195, 195, 49, 195, 23, |
| 179372 | | - /* 1720 */ 195, 25, 195, 23, 195, 25, 195, 195, 60, 195, |
| 179373 | | - /* 1730 */ 195, 195, 195, 146, 195, 183, 218, 219, 118, 195, |
| 179421 | + /* 1700 */ 7, 8, 218, 219, 36, 118, 154, 155, 156, 157, |
| 179422 | + /* 1710 */ 158, 195, 23, 195, 25, 84, 85, 49, 195, 23, |
| 179423 | + /* 1720 */ 195, 25, 195, 23, 195, 25, 195, 23, 60, 25, |
| 179424 | + /* 1730 */ 23, 23, 25, 25, 142, 183, 218, 219, 118, 195, |
| 179374 | 179425 | /* 1740 */ 72, 218, 219, 218, 219, 218, 219, 218, 219, 218, |
| 179375 | | - /* 1750 */ 219, 195, 218, 219, 86, 218, 219, 218, 219, 91, |
| 179376 | | - /* 1760 */ 19, 20, 154, 22, 156, 23, 258, 25, 195, 101, |
| 179377 | | - /* 1770 */ 195, 23, 195, 25, 195, 107, 108, 36, 23, 154, |
| 179378 | | - /* 1780 */ 25, 156, 23, 115, 25, 117, 118, 119, 142, 238, |
| 179379 | | - /* 1790 */ 122, 218, 219, 218, 219, 218, 219, 23, 322, 25, |
| 179380 | | - /* 1800 */ 195, 60, 195, 300, 195, 195, 195, 195, 195, 244, |
| 179381 | | - /* 1810 */ 291, 258, 290, 72, 245, 258, 258, 258, 216, 193, |
| 179382 | | - /* 1820 */ 274, 247, 154, 155, 156, 157, 158, 86, 300, 296, |
| 179383 | | - /* 1830 */ 300, 270, 91, 19, 20, 247, 22, 270, 248, 248, |
| 179384 | | - /* 1840 */ 274, 296, 101, 222, 274, 274, 231, 262, 107, 108, |
| 179385 | | - /* 1850 */ 36, 183, 221, 221, 227, 221, 115, 262, 117, 118, |
| 179386 | | - /* 1860 */ 119, 262, 262, 122, 283, 251, 247, 245, 251, 116, |
| 179387 | | - /* 1870 */ 198, 220, 61, 220, 60, 220, 300, 142, 38, 202, |
| 179388 | | - /* 1880 */ 202, 297, 202, 152, 151, 22, 72, 286, 43, 297, |
| 179389 | | - /* 1890 */ 236, 18, 202, 275, 18, 154, 155, 156, 157, 158, |
| 179390 | | - /* 1900 */ 86, 273, 239, 239, 239, 91, 239, 201, 150, 248, |
| 179391 | | - /* 1910 */ 275, 275, 273, 202, 248, 101, 201, 236, 236, 159, |
| 179392 | | - /* 1920 */ 63, 107, 108, 248, 183, 202, 293, 248, 201, 115, |
| 179393 | | - /* 1930 */ 22, 117, 118, 119, 292, 223, 122, 223, 202, 201, |
| 179394 | | - /* 1940 */ 220, 202, 220, 65, 201, 220, 229, 22, 127, 220, |
| 179395 | | - /* 1950 */ 226, 223, 226, 166, 222, 24, 316, 220, 308, 229, |
| 179396 | | - /* 1960 */ 220, 114, 92, 202, 220, 321, 321, 83, 154, 155, |
| 179397 | | - /* 1970 */ 156, 157, 158, 0, 1, 2, 285, 285, 5, 223, |
| 179398 | | - /* 1980 */ 149, 268, 146, 10, 11, 12, 13, 14, 22, 268, |
| 179399 | | - /* 1990 */ 17, 202, 159, 19, 20, 250, 22, 183, 252, 280, |
| 179400 | | - /* 2000 */ 251, 148, 252, 30, 25, 32, 147, 204, 13, 196, |
| 179401 | | - /* 2010 */ 36, 249, 248, 40, 196, 6, 282, 194, 194, 194, |
| 179402 | | - /* 2020 */ 215, 209, 306, 215, 306, 215, 209, 4, 224, 209, |
| 179403 | | - /* 2030 */ 215, 224, 216, 3, 60, 216, 22, 215, 122, 19, |
| 179404 | | - /* 2040 */ 122, 19, 125, 22, 71, 16, 72, 22, 15, 23, |
| 179405 | | - /* 2050 */ 303, 23, 79, 140, 152, 82, 25, 131, 24, 20, |
| 179406 | | - /* 2060 */ 145, 16, 143, 1, 143, 131, 131, 62, 131, 37, |
| 179407 | | - /* 2070 */ 54, 54, 99, 54, 152, 101, 117, 34, 54, 1, |
| 179408 | | - /* 2080 */ 142, 107, 108, 22, 5, 116, 162, 69, 25, 115, |
| 179409 | | - /* 2090 */ 41, 117, 118, 119, 142, 24, 122, 116, 126, 132, |
| 179410 | | - /* 2100 */ 20, 19, 20, 76, 22, 69, 19, 134, 22, 68, |
| 179411 | | - /* 2110 */ 22, 22, 139, 140, 23, 141, 22, 60, 36, 68, |
| 179412 | | - /* 2120 */ 24, 28, 22, 68, 23, 150, 34, 37, 154, 155, |
| 179413 | | - /* 2130 */ 156, 157, 158, 22, 97, 23, 163, 23, 25, 23, |
| 179414 | | - /* 2140 */ 22, 142, 60, 23, 98, 23, 22, 144, 25, 34, |
| 179415 | | - /* 2150 */ 76, 34, 117, 34, 72, 34, 89, 183, 94, 34, |
| 179416 | | - /* 2160 */ 87, 76, 34, 23, 22, 24, 34, 22, 25, 25, |
| 179417 | | - /* 2170 */ 44, 23, 23, 23, 23, 11, 22, 25, 25, 23, |
| 179418 | | - /* 2180 */ 22, 143, 22, 101, 23, 143, 23, 22, 22, 107, |
| 179419 | | - /* 2190 */ 108, 15, 25, 25, 136, 142, 142, 115, 142, 117, |
| 179420 | | - /* 2200 */ 118, 119, 1, 2, 122, 23, 5, 1, 1, 323, |
| 179421 | | - /* 2210 */ 323, 10, 11, 12, 13, 14, 323, 323, 17, 323, |
| 179422 | | - /* 2220 */ 5, 323, 323, 141, 323, 10, 11, 12, 13, 14, |
| 179423 | | - /* 2230 */ 323, 30, 17, 32, 323, 323, 154, 155, 156, 157, |
| 179424 | | - /* 2240 */ 158, 40, 323, 323, 323, 30, 323, 32, 323, 323, |
| 179425 | | - /* 2250 */ 323, 323, 323, 323, 323, 40, 323, 323, 323, 323, |
| 179426 | | - /* 2260 */ 323, 323, 323, 323, 323, 183, 323, 323, 323, 323, |
| 179427 | | - /* 2270 */ 323, 323, 71, 323, 323, 323, 323, 323, 323, 323, |
| 179428 | | - /* 2280 */ 79, 323, 323, 82, 323, 323, 71, 323, 323, 323, |
| 179429 | | - /* 2290 */ 323, 323, 323, 323, 79, 323, 323, 82, 323, 323, |
| 179430 | | - /* 2300 */ 99, 323, 323, 323, 323, 323, 323, 323, 323, 323, |
| 179431 | | - /* 2310 */ 323, 323, 323, 323, 99, 323, 323, 323, 323, 323, |
| 179432 | | - /* 2320 */ 323, 323, 323, 323, 323, 323, 323, 323, 323, 323, |
| 179433 | | - /* 2330 */ 323, 323, 323, 323, 323, 134, 323, 323, 323, 323, |
| 179434 | | - /* 2340 */ 139, 140, 323, 323, 323, 323, 323, 323, 323, 134, |
| 179435 | | - /* 2350 */ 323, 323, 323, 323, 139, 140, 323, 323, 323, 323, |
| 179436 | | - /* 2360 */ 323, 323, 323, 323, 163, 323, 323, 323, 323, 323, |
| 179437 | | - /* 2370 */ 323, 323, 323, 323, 323, 323, 323, 323, 163, 323, |
| 179438 | | - /* 2380 */ 323, 323, 323, 323, 323, 323, 323, 323, 323, 323, |
| 179439 | | - /* 2390 */ 323, 323, 323, 323, 323, 323, 323, 323, 323, 323, |
| 179440 | | - /* 2400 */ 323, 323, 323, 323, 323, 323, 323, 323, 187, 187, |
| 179426 | + /* 1750 */ 219, 195, 195, 146, 86, 98, 23, 195, 25, 91, |
| 179427 | + /* 1760 */ 19, 20, 154, 22, 156, 154, 23, 156, 25, 101, |
| 179428 | + /* 1770 */ 23, 195, 25, 195, 195, 107, 108, 36, 195, 195, |
| 179429 | + /* 1780 */ 195, 195, 228, 115, 195, 117, 118, 119, 195, 195, |
| 179430 | + /* 1790 */ 122, 261, 195, 321, 195, 195, 195, 258, 238, 195, |
| 179431 | + /* 1800 */ 195, 60, 299, 291, 195, 195, 258, 195, 195, 195, |
| 179432 | + /* 1810 */ 290, 244, 216, 72, 245, 193, 258, 258, 299, 258, |
| 179433 | + /* 1820 */ 299, 274, 154, 155, 156, 157, 158, 86, 247, 295, |
| 179434 | + /* 1830 */ 248, 295, 91, 19, 20, 270, 22, 274, 270, 248, |
| 179435 | + /* 1840 */ 274, 222, 101, 227, 274, 221, 231, 221, 107, 108, |
| 179436 | + /* 1850 */ 36, 183, 262, 247, 221, 283, 115, 262, 117, 118, |
| 179437 | + /* 1860 */ 119, 198, 116, 122, 220, 262, 61, 220, 220, 251, |
| 179438 | + /* 1870 */ 247, 142, 251, 245, 60, 202, 299, 202, 38, 262, |
| 179439 | + /* 1880 */ 202, 22, 152, 151, 296, 43, 72, 236, 18, 239, |
| 179440 | + /* 1890 */ 202, 239, 239, 239, 18, 154, 155, 156, 157, 158, |
| 179441 | + /* 1900 */ 86, 150, 201, 248, 275, 91, 248, 273, 236, 248, |
| 179442 | + /* 1910 */ 275, 275, 273, 236, 248, 101, 286, 202, 201, 159, |
| 179443 | + /* 1920 */ 63, 107, 108, 296, 183, 293, 202, 201, 22, 115, |
| 179444 | + /* 1930 */ 202, 117, 118, 119, 292, 223, 122, 201, 65, 202, |
| 179445 | + /* 1940 */ 201, 223, 220, 220, 22, 220, 226, 226, 229, 127, |
| 179446 | + /* 1950 */ 223, 220, 166, 24, 285, 220, 222, 114, 315, 285, |
| 179447 | + /* 1960 */ 220, 202, 220, 307, 92, 320, 320, 229, 154, 155, |
| 179448 | + /* 1970 */ 156, 157, 158, 0, 1, 2, 223, 83, 5, 268, |
| 179449 | + /* 1980 */ 149, 268, 146, 10, 11, 12, 13, 14, 22, 280, |
| 179450 | + /* 1990 */ 17, 202, 159, 19, 20, 251, 22, 183, 282, 148, |
| 179451 | + /* 2000 */ 252, 252, 250, 30, 249, 32, 248, 147, 25, 13, |
| 179452 | + /* 2010 */ 36, 204, 196, 40, 196, 6, 302, 194, 194, 194, |
| 179453 | + /* 2020 */ 209, 215, 209, 215, 215, 215, 224, 224, 216, 209, |
| 179454 | + /* 2030 */ 4, 216, 215, 3, 60, 22, 122, 19, 122, 19, |
| 179455 | + /* 2040 */ 125, 22, 15, 22, 71, 16, 72, 23, 23, 140, |
| 179456 | + /* 2050 */ 305, 152, 79, 25, 131, 82, 143, 20, 16, 305, |
| 179457 | + /* 2060 */ 1, 143, 145, 131, 131, 62, 54, 131, 37, 54, |
| 179458 | + /* 2070 */ 54, 152, 99, 117, 34, 101, 54, 24, 1, 5, |
| 179459 | + /* 2080 */ 22, 107, 108, 116, 76, 25, 162, 41, 142, 115, |
| 179460 | + /* 2090 */ 24, 117, 118, 119, 116, 20, 122, 19, 126, 23, |
| 179461 | + /* 2100 */ 132, 19, 20, 69, 22, 69, 22, 134, 22, 68, |
| 179462 | + /* 2110 */ 22, 22, 139, 140, 60, 141, 68, 24, 36, 28, |
| 179463 | + /* 2120 */ 97, 22, 37, 68, 23, 150, 34, 22, 154, 155, |
| 179464 | + /* 2130 */ 156, 157, 158, 23, 23, 22, 163, 25, 23, 142, |
| 179465 | + /* 2140 */ 23, 98, 60, 23, 22, 144, 25, 76, 34, 117, |
| 179466 | + /* 2150 */ 34, 89, 34, 34, 72, 87, 76, 183, 34, 94, |
| 179467 | + /* 2160 */ 34, 23, 22, 24, 34, 23, 25, 44, 25, 23, |
| 179468 | + /* 2170 */ 23, 23, 22, 22, 25, 11, 143, 25, 143, 23, |
| 179469 | + /* 2180 */ 22, 22, 22, 101, 23, 23, 136, 22, 25, 107, |
| 179470 | + /* 2190 */ 108, 142, 25, 142, 142, 23, 15, 115, 1, 117, |
| 179471 | + /* 2200 */ 118, 119, 1, 2, 122, 1, 5, 322, 322, 322, |
| 179472 | + /* 2210 */ 322, 10, 11, 12, 13, 14, 322, 322, 17, 322, |
| 179473 | + /* 2220 */ 5, 322, 322, 141, 322, 10, 11, 12, 13, 14, |
| 179474 | + /* 2230 */ 322, 30, 17, 32, 322, 322, 154, 155, 156, 157, |
| 179475 | + /* 2240 */ 158, 40, 322, 322, 322, 30, 322, 32, 322, 322, |
| 179476 | + /* 2250 */ 322, 322, 322, 322, 322, 40, 322, 322, 322, 322, |
| 179477 | + /* 2260 */ 322, 322, 322, 322, 322, 183, 322, 322, 322, 322, |
| 179478 | + /* 2270 */ 322, 322, 71, 322, 322, 322, 322, 322, 322, 322, |
| 179479 | + /* 2280 */ 79, 322, 322, 82, 322, 322, 71, 322, 322, 322, |
| 179480 | + /* 2290 */ 322, 322, 322, 322, 79, 322, 322, 82, 322, 322, |
| 179481 | + /* 2300 */ 99, 322, 322, 322, 322, 322, 322, 322, 322, 322, |
| 179482 | + /* 2310 */ 322, 322, 322, 322, 99, 322, 322, 322, 322, 322, |
| 179483 | + /* 2320 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, |
| 179484 | + /* 2330 */ 322, 322, 322, 322, 322, 134, 322, 322, 322, 322, |
| 179485 | + /* 2340 */ 139, 140, 322, 322, 322, 322, 322, 322, 322, 134, |
| 179486 | + /* 2350 */ 322, 322, 322, 322, 139, 140, 322, 322, 322, 322, |
| 179487 | + /* 2360 */ 322, 322, 322, 322, 163, 322, 322, 322, 322, 322, |
| 179488 | + /* 2370 */ 322, 322, 322, 322, 322, 322, 322, 322, 163, 322, |
| 179489 | + /* 2380 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, |
| 179490 | + /* 2390 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, |
| 179491 | + /* 2400 */ 322, 322, 322, 322, 322, 322, 322, 322, 187, 187, |
| 179441 | 179492 | /* 2410 */ 187, 187, 187, 187, 187, 187, 187, 187, 187, 187, |
| 179442 | 179493 | /* 2420 */ 187, 187, 187, 187, 187, 187, 187, 187, 187, 187, |
| 179443 | 179494 | /* 2430 */ 187, 187, 187, 187, 187, 187, 187, 187, 187, 187, |
| 179444 | 179495 | /* 2440 */ 187, 187, 187, 187, 187, 187, 187, 187, 187, 187, |
| 179445 | 179496 | /* 2450 */ 187, 187, 187, 187, 187, 187, 187, 187, 187, 187, |
| | @@ -179453,186 +179504,184 @@ |
| 179453 | 179504 | /* 2530 */ 187, 187, 187, 187, 187, 187, 187, 187, 187, 187, |
| 179454 | 179505 | /* 2540 */ 187, 187, 187, 187, 187, 187, 187, 187, 187, 187, |
| 179455 | 179506 | /* 2550 */ 187, 187, 187, 187, 187, 187, 187, 187, 187, 187, |
| 179456 | 179507 | /* 2560 */ 187, 187, 187, 187, 187, 187, |
| 179457 | 179508 | }; |
| 179458 | | -#define YY_SHIFT_COUNT (601) |
| 179509 | +#define YY_SHIFT_COUNT (599) |
| 179459 | 179510 | #define YY_SHIFT_MIN (0) |
| 179460 | 179511 | #define YY_SHIFT_MAX (2215) |
| 179461 | 179512 | static const unsigned short int yy_shift_ofst[] = { |
| 179462 | | - /* 0 */ 2201, 1973, 2215, 1552, 1552, 343, 44, 1668, 1741, 1814, |
| 179463 | | - /* 10 */ 726, 726, 726, 662, 343, 343, 343, 343, 343, 0, |
| 179513 | + /* 0 */ 2201, 1973, 2215, 1552, 1552, 33, 368, 1668, 1741, 1814, |
| 179514 | + /* 10 */ 726, 726, 726, 265, 33, 33, 33, 33, 33, 0, |
| 179464 | 179515 | /* 20 */ 0, 216, 1349, 726, 726, 726, 726, 726, 726, 726, |
| 179465 | 179516 | /* 30 */ 726, 726, 726, 726, 726, 726, 726, 726, 272, 272, |
| 179466 | | - /* 40 */ 111, 111, 316, 119, 536, 769, 769, 546, 546, 546, |
| 179467 | | - /* 50 */ 546, 40, 112, 260, 364, 408, 512, 617, 661, 765, |
| 179517 | + /* 40 */ 111, 111, 316, 365, 516, 867, 867, 916, 916, 916, |
| 179518 | + /* 50 */ 916, 40, 112, 260, 364, 408, 512, 617, 661, 765, |
| 179468 | 179519 | /* 60 */ 809, 913, 957, 1061, 1081, 1195, 1215, 1329, 1349, 1349, |
| 179469 | 179520 | /* 70 */ 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, |
| 179470 | 179521 | /* 80 */ 1349, 1349, 1349, 1349, 1349, 1349, 1369, 1349, 1473, 1493, |
| 179471 | 179522 | /* 90 */ 1493, 473, 1974, 2082, 726, 726, 726, 726, 726, 726, |
| 179472 | 179523 | /* 100 */ 726, 726, 726, 726, 726, 726, 726, 726, 726, 726, |
| 179473 | 179524 | /* 110 */ 726, 726, 726, 726, 726, 726, 726, 726, 726, 726, |
| 179474 | 179525 | /* 120 */ 726, 726, 726, 726, 726, 726, 726, 726, 726, 726, |
| 179475 | 179526 | /* 130 */ 726, 726, 726, 726, 726, 726, 726, 726, 726, 726, |
| 179476 | | - /* 140 */ 726, 726, 726, 726, 726, 726, 138, 233, 233, 233, |
| 179477 | | - /* 150 */ 233, 233, 233, 233, 245, 98, 183, 371, 874, 1029, |
| 179478 | | - /* 160 */ 769, 769, 888, 888, 769, 464, 110, 476, 476, 476, |
| 179479 | | - /* 170 */ 401, 62, 62, 2379, 2379, 1026, 1026, 1026, 540, 718, |
| 179480 | | - /* 180 */ 718, 718, 718, 1268, 1268, 610, 371, 276, 1174, 769, |
| 179481 | | - /* 190 */ 769, 769, 769, 769, 769, 769, 769, 769, 769, 769, |
| 179482 | | - /* 200 */ 769, 769, 769, 769, 769, 769, 769, 769, 534, 956, |
| 179483 | | - /* 210 */ 956, 769, 61, 1135, 1135, 831, 1278, 1278, 831, 831, |
| 179484 | | - /* 220 */ 360, 2379, 2379, 2379, 2379, 2379, 2379, 2379, 641, 789, |
| 179485 | | - /* 230 */ 789, 721, 374, 732, 466, 782, 494, 829, 833, 769, |
| 179486 | | - /* 240 */ 769, 769, 769, 769, 769, 769, 769, 769, 769, 769, |
| 179487 | | - /* 250 */ 769, 769, 769, 677, 769, 769, 769, 769, 769, 769, |
| 179488 | | - /* 260 */ 769, 769, 769, 769, 769, 769, 370, 370, 370, 769, |
| 179489 | | - /* 270 */ 769, 769, 1062, 769, 769, 769, 1176, 1134, 769, 1190, |
| 179490 | | - /* 280 */ 769, 769, 769, 769, 769, 769, 769, 769, 485, 1149, |
| 179491 | | - /* 290 */ 13, 954, 336, 336, 336, 336, 262, 954, 954, 1147, |
| 179492 | | - /* 300 */ 373, 1342, 430, 1434, 1294, 1194, 1073, 1194, 1311, 103, |
| 179493 | | - /* 310 */ 1294, 1294, 103, 1294, 1073, 1311, 663, 1212, 1047, 1001, |
| 179494 | | - /* 320 */ 1001, 1001, 1510, 1510, 1510, 1510, 1265, 1265, 1270, 1426, |
| 179495 | | - /* 330 */ 1363, 1479, 1753, 1811, 1753, 1753, 1735, 1735, 1840, 1840, |
| 179496 | | - /* 340 */ 1735, 1731, 1733, 1863, 1845, 1873, 1873, 1873, 1873, 1735, |
| 179497 | | - /* 350 */ 1876, 1758, 1733, 1733, 1758, 1863, 1845, 1758, 1845, 1758, |
| 179498 | | - /* 360 */ 1735, 1876, 1760, 1857, 1735, 1876, 1908, 1735, 1876, 1735, |
| 179499 | | - /* 370 */ 1876, 1908, 1753, 1753, 1753, 1878, 1925, 1925, 1908, 1753, |
| 179500 | | - /* 380 */ 1821, 1753, 1878, 1753, 1753, 1787, 1931, 1847, 1847, 1908, |
| 179501 | | - /* 390 */ 1735, 1870, 1870, 1884, 1884, 1831, 1836, 1966, 1735, 1833, |
| 179502 | | - /* 400 */ 1831, 1853, 1859, 1758, 1979, 1995, 1995, 2009, 2009, 2009, |
| 179527 | + /* 140 */ 726, 726, 726, 726, 726, 726, 138, 232, 232, 232, |
| 179528 | + /* 150 */ 232, 232, 232, 232, 188, 99, 242, 718, 416, 1159, |
| 179529 | + /* 160 */ 867, 867, 940, 940, 867, 1103, 417, 574, 574, 574, |
| 179530 | + /* 170 */ 611, 139, 139, 2379, 2379, 1026, 1026, 1026, 536, 466, |
| 179531 | + /* 180 */ 466, 466, 466, 1017, 1017, 849, 718, 971, 1060, 867, |
| 179532 | + /* 190 */ 867, 867, 867, 867, 867, 867, 867, 867, 867, 867, |
| 179533 | + /* 200 */ 867, 867, 867, 867, 867, 867, 867, 867, 261, 712, |
| 179534 | + /* 210 */ 712, 867, 108, 1142, 1142, 977, 1108, 1108, 977, 977, |
| 179535 | + /* 220 */ 1243, 2379, 2379, 2379, 2379, 2379, 2379, 2379, 641, 789, |
| 179536 | + /* 230 */ 789, 635, 366, 721, 673, 782, 494, 787, 829, 867, |
| 179537 | + /* 240 */ 867, 867, 867, 867, 867, 867, 867, 867, 867, 867, |
| 179538 | + /* 250 */ 959, 867, 867, 867, 867, 867, 867, 867, 867, 867, |
| 179539 | + /* 260 */ 867, 867, 867, 867, 867, 820, 820, 820, 867, 867, |
| 179540 | + /* 270 */ 867, 1136, 867, 867, 867, 1119, 1007, 867, 1169, 867, |
| 179541 | + /* 280 */ 867, 867, 867, 867, 867, 867, 867, 1225, 1153, 869, |
| 179542 | + /* 290 */ 196, 618, 618, 618, 618, 1491, 196, 196, 91, 339, |
| 179543 | + /* 300 */ 1326, 1386, 383, 1163, 1364, 1426, 1364, 1538, 903, 1163, |
| 179544 | + /* 310 */ 1163, 903, 1163, 1426, 1538, 1018, 1535, 1241, 1528, 1528, |
| 179545 | + /* 320 */ 1528, 1394, 1394, 1394, 1394, 762, 762, 1403, 1466, 1475, |
| 179546 | + /* 330 */ 1551, 1746, 1805, 1746, 1746, 1729, 1729, 1840, 1840, 1729, |
| 179547 | + /* 340 */ 1730, 1732, 1859, 1842, 1870, 1870, 1870, 1870, 1729, 1876, |
| 179548 | + /* 350 */ 1751, 1732, 1732, 1751, 1859, 1842, 1751, 1842, 1751, 1729, |
| 179549 | + /* 360 */ 1876, 1760, 1857, 1729, 1876, 1906, 1729, 1876, 1729, 1876, |
| 179550 | + /* 370 */ 1906, 1746, 1746, 1746, 1873, 1922, 1922, 1906, 1746, 1822, |
| 179551 | + /* 380 */ 1746, 1873, 1746, 1746, 1786, 1929, 1843, 1843, 1906, 1729, |
| 179552 | + /* 390 */ 1872, 1872, 1894, 1894, 1831, 1836, 1966, 1729, 1833, 1831, |
| 179553 | + /* 400 */ 1851, 1860, 1751, 1983, 1996, 1996, 2009, 2009, 2009, 2379, |
| 179503 | 179554 | /* 410 */ 2379, 2379, 2379, 2379, 2379, 2379, 2379, 2379, 2379, 2379, |
| 179504 | | - /* 420 */ 2379, 2379, 2379, 2379, 2379, 856, 1121, 830, 1080, 1471, |
| 179505 | | - /* 430 */ 911, 1261, 1387, 1542, 605, 1462, 1474, 650, 1495, 1586, |
| 179506 | | - /* 440 */ 1386, 1598, 1604, 1638, 1670, 1671, 1689, 1442, 1432, 1676, |
| 179507 | | - /* 450 */ 853, 1696, 1587, 1273, 1446, 1700, 1742, 1616, 1748, 1755, |
| 179508 | | - /* 460 */ 1608, 1625, 1759, 1774, 1620, 1646, 2023, 2030, 2014, 1916, |
| 179509 | | - /* 470 */ 2020, 1918, 2022, 2021, 2025, 1917, 2033, 2029, 2026, 2028, |
| 179510 | | - /* 480 */ 1913, 1902, 1926, 2031, 2031, 2034, 1919, 2039, 1915, 2045, |
| 179511 | | - /* 490 */ 2062, 1921, 1934, 2031, 1935, 2005, 2032, 2031, 1922, 2016, |
| 179512 | | - /* 500 */ 2017, 2019, 2024, 1937, 1959, 2043, 1938, 2078, 2079, 2061, |
| 179513 | | - /* 510 */ 1969, 1924, 2018, 2063, 2036, 2027, 2049, 1952, 1981, 2071, |
| 179514 | | - /* 520 */ 2080, 2087, 1967, 1972, 2086, 2041, 2088, 2089, 2091, 2094, |
| 179515 | | - /* 530 */ 2051, 2057, 2096, 2037, 2093, 2100, 2055, 2090, 2101, 2092, |
| 179516 | | - /* 540 */ 1975, 2111, 2112, 2114, 2113, 2116, 2118, 2046, 1999, 2120, |
| 179517 | | - /* 550 */ 2122, 2035, 2115, 2124, 2003, 2123, 2117, 2119, 2121, 2125, |
| 179518 | | - /* 560 */ 2067, 2074, 2073, 2126, 2085, 2064, 2128, 2140, 2142, 2141, |
| 179519 | | - /* 570 */ 2143, 2144, 2132, 2038, 2042, 2148, 2123, 2149, 2150, 2151, |
| 179520 | | - /* 580 */ 2145, 2152, 2153, 2156, 2154, 2164, 2158, 2160, 2161, 2163, |
| 179521 | | - /* 590 */ 2165, 2166, 2167, 2058, 2053, 2054, 2056, 2168, 2182, 2176, |
| 179522 | | - /* 600 */ 2206, 2207, |
| 179555 | + /* 420 */ 2379, 2379, 2379, 2379, 136, 1063, 1196, 530, 636, 1274, |
| 179556 | + /* 430 */ 1300, 1443, 1598, 1495, 1479, 967, 1083, 1602, 463, 1625, |
| 179557 | + /* 440 */ 1638, 1670, 1541, 1671, 1689, 1696, 1277, 1432, 1693, 808, |
| 179558 | + /* 450 */ 1700, 1607, 1657, 1587, 1704, 1707, 1631, 1708, 1733, 1608, |
| 179559 | + /* 460 */ 1611, 1743, 1747, 1620, 1592, 2026, 2030, 2013, 1914, 2018, |
| 179560 | + /* 470 */ 1916, 2020, 2019, 2021, 1915, 2027, 2029, 2024, 2025, 1909, |
| 179561 | + /* 480 */ 1899, 1923, 2028, 2028, 1913, 2037, 1917, 2042, 2059, 1918, |
| 179562 | + /* 490 */ 1932, 2028, 1933, 2003, 2031, 2028, 1919, 2012, 2015, 2016, |
| 179563 | + /* 500 */ 2022, 1936, 1956, 2040, 2053, 2077, 2074, 2058, 1967, 1924, |
| 179564 | + /* 510 */ 2034, 2060, 2036, 2008, 2046, 1946, 1978, 2066, 2075, 2078, |
| 179565 | + /* 520 */ 1968, 1972, 2084, 2041, 2086, 2088, 2076, 2089, 2048, 2054, |
| 179566 | + /* 530 */ 2093, 2023, 2091, 2099, 2055, 2085, 2101, 2092, 1975, 2105, |
| 179567 | + /* 540 */ 2110, 2111, 2112, 2115, 2113, 2043, 1997, 2117, 2120, 2032, |
| 179568 | + /* 550 */ 2114, 2122, 2001, 2121, 2116, 2118, 2119, 2124, 2062, 2071, |
| 179569 | + /* 560 */ 2068, 2123, 2080, 2065, 2126, 2138, 2140, 2139, 2141, 2143, |
| 179570 | + /* 570 */ 2130, 2033, 2035, 2142, 2121, 2146, 2147, 2148, 2150, 2149, |
| 179571 | + /* 580 */ 2152, 2156, 2151, 2164, 2158, 2159, 2161, 2162, 2160, 2165, |
| 179572 | + /* 590 */ 2163, 2050, 2049, 2051, 2052, 2167, 2172, 2181, 2197, 2204, |
| 179523 | 179573 | }; |
| 179524 | | -#define YY_REDUCE_COUNT (424) |
| 179525 | | -#define YY_REDUCE_MIN (-277) |
| 179574 | +#define YY_REDUCE_COUNT (423) |
| 179575 | +#define YY_REDUCE_MIN (-303) |
| 179526 | 179576 | #define YY_REDUCE_MAX (1825) |
| 179527 | 179577 | static const short yy_reduce_ofst[] = { |
| 179528 | | - /* 0 */ -67, 345, 787, -178, -181, 188, 435, -185, 166, -183, |
| 179529 | | - /* 10 */ -78, 284, 384, -174, 352, 391, 493, 496, 535, -208, |
| 179530 | | - /* 20 */ -23, -277, -2, 205, 305, 310, 707, 764, -189, 67, |
| 179531 | | - /* 30 */ 839, 735, 835, 860, 902, 354, 958, 960, -187, 946, |
| 179532 | | - /* 40 */ 86, 616, 843, 587, 792, 900, 901, -238, 440, -238, |
| 179533 | | - /* 50 */ 440, -255, -255, -255, -255, -255, -255, -255, -255, -255, |
| 179534 | | - /* 60 */ -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, |
| 179535 | | - /* 70 */ -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, |
| 179536 | | - /* 80 */ -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, |
| 179537 | | - /* 90 */ -255, 864, 985, 1094, 1096, 1098, 1116, 1136, 1138, 1141, |
| 179538 | | - /* 100 */ 1144, 1146, 1148, 1151, 1249, 1251, 1269, 1271, 1290, 1296, |
| 179539 | | - /* 110 */ 1315, 1318, 1337, 1340, 1344, 1371, 1373, 1375, 1400, 1413, |
| 179540 | | - /* 120 */ 1418, 1420, 1422, 1425, 1427, 1433, 1438, 1447, 1454, 1459, |
| 179541 | | - /* 130 */ 1463, 1467, 1480, 1484, 1518, 1523, 1525, 1527, 1529, 1531, |
| 179542 | | - /* 140 */ 1534, 1537, 1539, 1573, 1575, 1577, -255, -255, -255, -255, |
| 179543 | | - /* 150 */ -255, -255, -255, -255, -255, -255, -255, 197, 162, -220, |
| 179544 | | - /* 160 */ -76, -130, 121, 725, 844, -255, -116, -214, 417, 484, |
| 179545 | | - /* 170 */ 441, -255, -255, -255, -255, 562, 562, 562, 702, -57, |
| 179546 | | - /* 180 */ 560, 703, 836, -122, 556, -35, 301, 521, 521, -37, |
| 179547 | | - /* 190 */ -184, 729, 959, 290, 292, 394, 409, 215, 412, 357, |
| 179548 | | - /* 200 */ 495, 808, 590, 961, 652, 403, 928, 1016, 672, -11, |
| 179549 | | - /* 210 */ 69, -53, 1046, 906, 909, 731, 490, 814, 1020, 1064, |
| 179550 | | - /* 220 */ 124, 984, -237, 1101, 1240, 1250, 1078, 1254, -33, -18, |
| 179551 | | - /* 230 */ 9, 85, 99, 248, 309, 332, 736, 804, 842, 932, |
| 179552 | | - /* 240 */ 947, 988, 1010, 1157, 1166, 1220, 1235, 1255, 1276, 1324, |
| 179553 | | - /* 250 */ 1357, 1362, 1366, 275, 1380, 1419, 1435, 1440, 1452, 1455, |
| 179554 | | - /* 260 */ 1469, 1481, 1494, 1502, 1516, 1520, 1068, 1237, 1477, 1521, |
| 179555 | | - /* 270 */ 1532, 1535, 996, 1536, 1544, 1556, 1508, 1476, 1579, 1551, |
| 179556 | | - /* 280 */ 1605, 309, 1607, 1609, 1610, 1611, 1612, 1613, 1503, 1519, |
| 179557 | | - /* 290 */ 1522, 1565, 1553, 1557, 1558, 1559, 996, 1565, 1565, 1569, |
| 179558 | | - /* 300 */ 1602, 1626, 1528, 1530, 1546, 1561, 1574, 1567, 1533, 1590, |
| 179559 | | - /* 310 */ 1566, 1570, 1591, 1571, 1588, 1545, 1621, 1615, 1627, 1631, |
| 179560 | | - /* 320 */ 1632, 1634, 1585, 1595, 1599, 1600, 1614, 1617, 1581, 1619, |
| 179561 | | - /* 330 */ 1622, 1672, 1651, 1576, 1653, 1655, 1677, 1678, 1584, 1592, |
| 179562 | | - /* 340 */ 1680, 1601, 1618, 1628, 1654, 1663, 1664, 1665, 1667, 1690, |
| 179563 | | - /* 350 */ 1706, 1661, 1635, 1636, 1666, 1639, 1681, 1675, 1682, 1679, |
| 179564 | | - /* 360 */ 1711, 1715, 1633, 1642, 1723, 1727, 1712, 1736, 1738, 1739, |
| 179565 | | - /* 370 */ 1743, 1714, 1720, 1722, 1725, 1717, 1724, 1726, 1728, 1729, |
| 179566 | | - /* 380 */ 1732, 1737, 1730, 1740, 1744, 1640, 1650, 1691, 1692, 1756, |
| 179567 | | - /* 390 */ 1761, 1644, 1645, 1713, 1721, 1746, 1749, 1719, 1789, 1734, |
| 179568 | | - /* 400 */ 1750, 1745, 1762, 1764, 1803, 1813, 1818, 1823, 1824, 1825, |
| 179569 | | - /* 410 */ 1716, 1718, 1747, 1812, 1805, 1808, 1810, 1815, 1817, 1804, |
| 179570 | | - /* 420 */ 1807, 1816, 1819, 1822, 1820, |
| 179578 | + /* 0 */ -67, 345, -64, -178, -181, 143, 435, -78, -183, 163, |
| 179579 | + /* 10 */ -185, 284, 384, -174, 189, 352, 440, 444, 493, -23, |
| 179580 | + /* 20 */ 227, -277, -1, 305, 561, 755, 759, 764, -189, 839, |
| 179581 | + /* 30 */ 857, 354, 484, 859, 631, 67, 734, 780, -187, 616, |
| 179582 | + /* 40 */ 581, 730, 891, 449, 588, 795, 836, -238, 287, -238, |
| 179583 | + /* 50 */ 287, -256, -256, -256, -256, -256, -256, -256, -256, -256, |
| 179584 | + /* 60 */ -256, -256, -256, -256, -256, -256, -256, -256, -256, -256, |
| 179585 | + /* 70 */ -256, -256, -256, -256, -256, -256, -256, -256, -256, -256, |
| 179586 | + /* 80 */ -256, -256, -256, -256, -256, -256, -256, -256, -256, -256, |
| 179587 | + /* 90 */ -256, 205, 582, 715, 958, 985, 1003, 1005, 1010, 1012, |
| 179588 | + /* 100 */ 1059, 1066, 1092, 1094, 1097, 1122, 1137, 1141, 1143, 1147, |
| 179589 | + /* 110 */ 1151, 1172, 1249, 1251, 1269, 1271, 1276, 1290, 1316, 1318, |
| 179590 | + /* 120 */ 1337, 1371, 1373, 1375, 1400, 1413, 1418, 1420, 1422, 1425, |
| 179591 | + /* 130 */ 1427, 1433, 1438, 1447, 1454, 1459, 1463, 1467, 1480, 1484, |
| 179592 | + /* 140 */ 1518, 1523, 1525, 1527, 1529, 1531, -256, -256, -256, -256, |
| 179593 | + /* 150 */ -256, -256, -256, -256, -256, -256, -256, 155, 210, -220, |
| 179594 | + /* 160 */ 86, -130, 943, 996, 402, -256, -113, 981, 1095, 1135, |
| 179595 | + /* 170 */ 395, -256, -256, -256, -256, 568, 568, 568, -4, -153, |
| 179596 | + /* 180 */ -133, 259, 306, -166, 523, -303, -126, 503, 503, -37, |
| 179597 | + /* 190 */ -149, 164, 690, 292, 412, 492, 651, 784, 332, 786, |
| 179598 | + /* 200 */ 841, 1149, 833, 1236, 792, 162, 796, 1253, 777, 288, |
| 179599 | + /* 210 */ 381, 380, 709, 487, 1027, 972, 1030, 1084, 991, 1120, |
| 179600 | + /* 220 */ -152, 1062, 692, 1240, 1247, 1250, 1239, 1306, -207, -194, |
| 179601 | + /* 230 */ 57, 180, 74, 315, 355, 376, 452, 488, 630, 693, |
| 179602 | + /* 240 */ 965, 1004, 1025, 1099, 1154, 1289, 1305, 1310, 1469, 1489, |
| 179603 | + /* 250 */ 984, 1494, 1502, 1516, 1544, 1556, 1557, 1562, 1576, 1578, |
| 179604 | + /* 260 */ 1579, 1583, 1584, 1585, 1586, 1217, 1440, 1554, 1589, 1593, |
| 179605 | + /* 270 */ 1594, 1530, 1597, 1599, 1600, 1539, 1472, 1601, 1560, 1604, |
| 179606 | + /* 280 */ 355, 1605, 1609, 1610, 1612, 1613, 1614, 1503, 1512, 1520, |
| 179607 | + /* 290 */ 1567, 1548, 1558, 1559, 1561, 1530, 1567, 1567, 1569, 1596, |
| 179608 | + /* 300 */ 1622, 1519, 1521, 1547, 1565, 1581, 1568, 1534, 1582, 1563, |
| 179609 | + /* 310 */ 1566, 1591, 1570, 1606, 1536, 1619, 1615, 1616, 1624, 1626, |
| 179610 | + /* 320 */ 1633, 1590, 1595, 1603, 1617, 1618, 1621, 1572, 1623, 1628, |
| 179611 | + /* 330 */ 1663, 1644, 1577, 1647, 1648, 1673, 1675, 1588, 1627, 1678, |
| 179612 | + /* 340 */ 1630, 1629, 1634, 1651, 1650, 1652, 1653, 1654, 1688, 1701, |
| 179613 | + /* 350 */ 1655, 1635, 1636, 1658, 1639, 1672, 1661, 1677, 1666, 1715, |
| 179614 | + /* 360 */ 1717, 1632, 1642, 1724, 1726, 1712, 1728, 1736, 1737, 1739, |
| 179615 | + /* 370 */ 1718, 1722, 1723, 1725, 1719, 1720, 1721, 1727, 1731, 1734, |
| 179616 | + /* 380 */ 1735, 1738, 1740, 1742, 1643, 1656, 1669, 1674, 1753, 1759, |
| 179617 | + /* 390 */ 1645, 1646, 1711, 1713, 1748, 1744, 1709, 1789, 1716, 1749, |
| 179618 | + /* 400 */ 1752, 1755, 1758, 1807, 1816, 1818, 1823, 1824, 1825, 1745, |
| 179619 | + /* 410 */ 1754, 1714, 1811, 1806, 1808, 1809, 1810, 1813, 1802, 1803, |
| 179620 | + /* 420 */ 1812, 1815, 1817, 1820, |
| 179571 | 179621 | }; |
| 179572 | 179622 | static const YYACTIONTYPE yy_default[] = { |
| 179573 | | - /* 0 */ 1698, 1698, 1698, 1521, 1284, 1397, 1284, 1284, 1284, 1284, |
| 179574 | | - /* 10 */ 1521, 1521, 1521, 1284, 1284, 1284, 1284, 1284, 1284, 1427, |
| 179575 | | - /* 20 */ 1427, 1574, 1317, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179576 | | - /* 30 */ 1284, 1284, 1284, 1284, 1284, 1520, 1284, 1284, 1284, 1284, |
| 179577 | | - /* 40 */ 1613, 1613, 1284, 1284, 1284, 1284, 1284, 1598, 1597, 1284, |
| 179578 | | - /* 50 */ 1284, 1284, 1436, 1284, 1284, 1284, 1443, 1284, 1284, 1284, |
| 179579 | | - /* 60 */ 1284, 1284, 1522, 1523, 1284, 1284, 1284, 1284, 1573, 1575, |
| 179580 | | - /* 70 */ 1538, 1450, 1449, 1448, 1447, 1556, 1415, 1441, 1434, 1438, |
| 179581 | | - /* 80 */ 1517, 1518, 1516, 1676, 1523, 1522, 1284, 1437, 1485, 1501, |
| 179582 | | - /* 90 */ 1484, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179583 | | - /* 100 */ 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179584 | | - /* 110 */ 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179585 | | - /* 120 */ 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179586 | | - /* 130 */ 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179587 | | - /* 140 */ 1284, 1284, 1284, 1284, 1284, 1284, 1493, 1500, 1499, 1498, |
| 179588 | | - /* 150 */ 1507, 1497, 1494, 1487, 1486, 1488, 1489, 1308, 1305, 1359, |
| 179589 | | - /* 160 */ 1284, 1284, 1284, 1284, 1284, 1490, 1317, 1478, 1477, 1476, |
| 179590 | | - /* 170 */ 1284, 1504, 1491, 1503, 1502, 1581, 1650, 1649, 1539, 1284, |
| 179591 | | - /* 180 */ 1284, 1284, 1284, 1284, 1284, 1613, 1284, 1284, 1284, 1284, |
| 179592 | | - /* 190 */ 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179593 | | - /* 200 */ 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1417, 1613, |
| 179594 | | - /* 210 */ 1613, 1284, 1317, 1613, 1613, 1313, 1418, 1418, 1313, 1313, |
| 179595 | | - /* 220 */ 1421, 1593, 1388, 1388, 1388, 1388, 1397, 1388, 1284, 1284, |
| 179596 | | - /* 230 */ 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179597 | | - /* 240 */ 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1578, 1576, 1284, |
| 179598 | | - /* 250 */ 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179599 | | - /* 260 */ 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179600 | | - /* 270 */ 1284, 1284, 1284, 1284, 1284, 1284, 1393, 1284, 1284, 1284, |
| 179601 | | - /* 280 */ 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1643, 1690, 1284, |
| 179602 | | - /* 290 */ 1551, 1373, 1393, 1393, 1393, 1393, 1395, 1374, 1372, 1387, |
| 179603 | | - /* 300 */ 1318, 1291, 1690, 1690, 1453, 1442, 1394, 1442, 1687, 1440, |
| 179604 | | - /* 310 */ 1453, 1453, 1440, 1453, 1394, 1687, 1334, 1665, 1329, 1427, |
| 179605 | | - /* 320 */ 1427, 1427, 1417, 1417, 1417, 1417, 1421, 1421, 1519, 1394, |
| 179606 | | - /* 330 */ 1387, 1284, 1360, 1690, 1360, 1360, 1403, 1403, 1689, 1689, |
| 179607 | | - /* 340 */ 1403, 1539, 1673, 1462, 1362, 1368, 1368, 1368, 1368, 1403, |
| 179608 | | - /* 350 */ 1302, 1440, 1673, 1673, 1440, 1462, 1362, 1440, 1362, 1440, |
| 179609 | | - /* 360 */ 1403, 1302, 1555, 1684, 1403, 1302, 1529, 1403, 1302, 1403, |
| 179610 | | - /* 370 */ 1302, 1529, 1360, 1360, 1360, 1349, 1284, 1284, 1529, 1360, |
| 179611 | | - /* 380 */ 1334, 1360, 1349, 1360, 1360, 1631, 1284, 1533, 1533, 1529, |
| 179612 | | - /* 390 */ 1403, 1623, 1623, 1430, 1430, 1435, 1421, 1524, 1403, 1284, |
| 179613 | | - /* 400 */ 1435, 1433, 1431, 1440, 1352, 1646, 1646, 1642, 1642, 1642, |
| 179614 | | - /* 410 */ 1695, 1695, 1593, 1658, 1317, 1317, 1317, 1317, 1658, 1336, |
| 179615 | | - /* 420 */ 1336, 1318, 1318, 1317, 1658, 1284, 1284, 1284, 1284, 1284, |
| 179616 | | - /* 430 */ 1284, 1284, 1653, 1284, 1284, 1540, 1407, 1284, 1284, 1284, |
| 179617 | | - /* 440 */ 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179618 | | - /* 450 */ 1284, 1284, 1284, 1599, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179619 | | - /* 460 */ 1284, 1284, 1284, 1284, 1284, 1467, 1284, 1287, 1590, 1284, |
| 179620 | | - /* 470 */ 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179621 | | - /* 480 */ 1284, 1284, 1284, 1444, 1445, 1408, 1284, 1284, 1284, 1284, |
| 179622 | | - /* 490 */ 1284, 1284, 1284, 1459, 1284, 1284, 1284, 1454, 1284, 1284, |
| 179623 | | - /* 500 */ 1284, 1284, 1284, 1284, 1284, 1284, 1686, 1284, 1284, 1284, |
| 179624 | | - /* 510 */ 1284, 1284, 1284, 1554, 1553, 1284, 1284, 1405, 1284, 1284, |
| 179625 | | - /* 520 */ 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179626 | | - /* 530 */ 1284, 1332, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179627 | | - /* 540 */ 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179628 | | - /* 550 */ 1284, 1284, 1284, 1284, 1284, 1432, 1284, 1284, 1284, 1284, |
| 179629 | | - /* 560 */ 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179630 | | - /* 570 */ 1628, 1422, 1284, 1284, 1284, 1284, 1677, 1284, 1284, 1284, |
| 179631 | | - /* 580 */ 1284, 1382, 1284, 1284, 1284, 1284, 1284, 1284, 1284, 1284, |
| 179632 | | - /* 590 */ 1284, 1284, 1669, 1376, 1468, 1284, 1471, 1306, 1284, 1296, |
| 179633 | | - /* 600 */ 1284, 1284, |
| 179623 | + /* 0 */ 1691, 1691, 1691, 1516, 1279, 1392, 1279, 1279, 1279, 1279, |
| 179624 | + /* 10 */ 1516, 1516, 1516, 1279, 1279, 1279, 1279, 1279, 1279, 1422, |
| 179625 | + /* 20 */ 1422, 1568, 1312, 1279, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179626 | + /* 30 */ 1279, 1279, 1279, 1279, 1279, 1515, 1279, 1279, 1279, 1279, |
| 179627 | + /* 40 */ 1607, 1607, 1279, 1279, 1279, 1279, 1279, 1592, 1591, 1279, |
| 179628 | + /* 50 */ 1279, 1279, 1431, 1279, 1279, 1279, 1438, 1279, 1279, 1279, |
| 179629 | + /* 60 */ 1279, 1279, 1517, 1518, 1279, 1279, 1279, 1279, 1567, 1569, |
| 179630 | + /* 70 */ 1533, 1445, 1444, 1443, 1442, 1551, 1410, 1436, 1429, 1433, |
| 179631 | + /* 80 */ 1512, 1513, 1511, 1670, 1518, 1517, 1279, 1432, 1480, 1496, |
| 179632 | + /* 90 */ 1479, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179633 | + /* 100 */ 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179634 | + /* 110 */ 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179635 | + /* 120 */ 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179636 | + /* 130 */ 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179637 | + /* 140 */ 1279, 1279, 1279, 1279, 1279, 1279, 1488, 1495, 1494, 1493, |
| 179638 | + /* 150 */ 1502, 1492, 1489, 1482, 1481, 1483, 1484, 1303, 1300, 1354, |
| 179639 | + /* 160 */ 1279, 1279, 1279, 1279, 1279, 1485, 1312, 1473, 1472, 1471, |
| 179640 | + /* 170 */ 1279, 1499, 1486, 1498, 1497, 1575, 1644, 1643, 1534, 1279, |
| 179641 | + /* 180 */ 1279, 1279, 1279, 1279, 1279, 1607, 1279, 1279, 1279, 1279, |
| 179642 | + /* 190 */ 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179643 | + /* 200 */ 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1412, 1607, |
| 179644 | + /* 210 */ 1607, 1279, 1312, 1607, 1607, 1308, 1413, 1413, 1308, 1308, |
| 179645 | + /* 220 */ 1416, 1587, 1383, 1383, 1383, 1383, 1392, 1383, 1279, 1279, |
| 179646 | + /* 230 */ 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179647 | + /* 240 */ 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1572, 1570, 1279, |
| 179648 | + /* 250 */ 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179649 | + /* 260 */ 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179650 | + /* 270 */ 1279, 1279, 1279, 1279, 1279, 1388, 1279, 1279, 1279, 1279, |
| 179651 | + /* 280 */ 1279, 1279, 1279, 1279, 1279, 1279, 1637, 1683, 1279, 1546, |
| 179652 | + /* 290 */ 1368, 1388, 1388, 1388, 1388, 1390, 1369, 1367, 1382, 1313, |
| 179653 | + /* 300 */ 1286, 1683, 1683, 1448, 1437, 1389, 1437, 1680, 1435, 1448, |
| 179654 | + /* 310 */ 1448, 1435, 1448, 1389, 1680, 1329, 1659, 1324, 1422, 1422, |
| 179655 | + /* 320 */ 1422, 1412, 1412, 1412, 1412, 1416, 1416, 1514, 1389, 1382, |
| 179656 | + /* 330 */ 1279, 1355, 1683, 1355, 1355, 1398, 1398, 1682, 1682, 1398, |
| 179657 | + /* 340 */ 1534, 1667, 1457, 1357, 1363, 1363, 1363, 1363, 1398, 1297, |
| 179658 | + /* 350 */ 1435, 1667, 1667, 1435, 1457, 1357, 1435, 1357, 1435, 1398, |
| 179659 | + /* 360 */ 1297, 1550, 1678, 1398, 1297, 1524, 1398, 1297, 1398, 1297, |
| 179660 | + /* 370 */ 1524, 1355, 1355, 1355, 1344, 1279, 1279, 1524, 1355, 1329, |
| 179661 | + /* 380 */ 1355, 1344, 1355, 1355, 1625, 1279, 1528, 1528, 1524, 1398, |
| 179662 | + /* 390 */ 1617, 1617, 1425, 1425, 1430, 1416, 1519, 1398, 1279, 1430, |
| 179663 | + /* 400 */ 1428, 1426, 1435, 1347, 1640, 1640, 1636, 1636, 1636, 1688, |
| 179664 | + /* 410 */ 1688, 1587, 1652, 1312, 1312, 1312, 1312, 1652, 1331, 1331, |
| 179665 | + /* 420 */ 1313, 1313, 1312, 1652, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179666 | + /* 430 */ 1279, 1647, 1279, 1279, 1535, 1279, 1279, 1279, 1279, 1279, |
| 179667 | + /* 440 */ 1279, 1279, 1402, 1279, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179668 | + /* 450 */ 1279, 1279, 1593, 1279, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179669 | + /* 460 */ 1279, 1279, 1279, 1279, 1462, 1279, 1282, 1584, 1279, 1279, |
| 179670 | + /* 470 */ 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179671 | + /* 480 */ 1279, 1279, 1439, 1440, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179672 | + /* 490 */ 1279, 1454, 1279, 1279, 1279, 1449, 1279, 1279, 1279, 1279, |
| 179673 | + /* 500 */ 1279, 1279, 1279, 1279, 1403, 1279, 1279, 1279, 1279, 1279, |
| 179674 | + /* 510 */ 1279, 1549, 1548, 1279, 1279, 1400, 1279, 1279, 1279, 1279, |
| 179675 | + /* 520 */ 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1327, |
| 179676 | + /* 530 */ 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179677 | + /* 540 */ 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179678 | + /* 550 */ 1279, 1279, 1279, 1427, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179679 | + /* 560 */ 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1622, 1417, |
| 179680 | + /* 570 */ 1279, 1279, 1279, 1279, 1671, 1279, 1279, 1279, 1279, 1377, |
| 179681 | + /* 580 */ 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, |
| 179682 | + /* 590 */ 1663, 1371, 1463, 1279, 1466, 1301, 1279, 1291, 1279, 1279, |
| 179634 | 179683 | }; |
| 179635 | 179684 | /********** End of lemon-generated parsing tables *****************************/ |
| 179636 | 179685 | |
| 179637 | 179686 | /* The next table maps tokens (terminal symbols) into fallback tokens. |
| 179638 | 179687 | ** If a construct like the following: |
| | @@ -180213,38 +180262,37 @@ |
| 180213 | 180262 | /* 290 */ "trigger_time", |
| 180214 | 180263 | /* 291 */ "trigger_event", |
| 180215 | 180264 | /* 292 */ "foreach_clause", |
| 180216 | 180265 | /* 293 */ "when_clause", |
| 180217 | 180266 | /* 294 */ "trigger_cmd", |
| 180218 | | - /* 295 */ "trnm", |
| 180219 | | - /* 296 */ "tridxby", |
| 180220 | | - /* 297 */ "database_kw_opt", |
| 180221 | | - /* 298 */ "key_opt", |
| 180222 | | - /* 299 */ "alter_add", |
| 180223 | | - /* 300 */ "kwcolumn_opt", |
| 180224 | | - /* 301 */ "create_vtab", |
| 180225 | | - /* 302 */ "vtabarglist", |
| 180226 | | - /* 303 */ "vtabarg", |
| 180227 | | - /* 304 */ "vtabargtoken", |
| 180228 | | - /* 305 */ "lp", |
| 180229 | | - /* 306 */ "anylist", |
| 180230 | | - /* 307 */ "wqitem", |
| 180231 | | - /* 308 */ "wqas", |
| 180232 | | - /* 309 */ "withnm", |
| 180233 | | - /* 310 */ "windowdefn_list", |
| 180234 | | - /* 311 */ "windowdefn", |
| 180235 | | - /* 312 */ "window", |
| 180236 | | - /* 313 */ "frame_opt", |
| 180237 | | - /* 314 */ "part_opt", |
| 180238 | | - /* 315 */ "filter_clause", |
| 180239 | | - /* 316 */ "over_clause", |
| 180240 | | - /* 317 */ "range_or_rows", |
| 180241 | | - /* 318 */ "frame_bound", |
| 180242 | | - /* 319 */ "frame_bound_s", |
| 180243 | | - /* 320 */ "frame_bound_e", |
| 180244 | | - /* 321 */ "frame_exclude_opt", |
| 180245 | | - /* 322 */ "frame_exclude", |
| 180267 | + /* 295 */ "tridxby", |
| 180268 | + /* 296 */ "database_kw_opt", |
| 180269 | + /* 297 */ "key_opt", |
| 180270 | + /* 298 */ "alter_add", |
| 180271 | + /* 299 */ "kwcolumn_opt", |
| 180272 | + /* 300 */ "create_vtab", |
| 180273 | + /* 301 */ "vtabarglist", |
| 180274 | + /* 302 */ "vtabarg", |
| 180275 | + /* 303 */ "vtabargtoken", |
| 180276 | + /* 304 */ "lp", |
| 180277 | + /* 305 */ "anylist", |
| 180278 | + /* 306 */ "wqitem", |
| 180279 | + /* 307 */ "wqas", |
| 180280 | + /* 308 */ "withnm", |
| 180281 | + /* 309 */ "windowdefn_list", |
| 180282 | + /* 310 */ "windowdefn", |
| 180283 | + /* 311 */ "window", |
| 180284 | + /* 312 */ "frame_opt", |
| 180285 | + /* 313 */ "part_opt", |
| 180286 | + /* 314 */ "filter_clause", |
| 180287 | + /* 315 */ "over_clause", |
| 180288 | + /* 316 */ "range_or_rows", |
| 180289 | + /* 317 */ "frame_bound", |
| 180290 | + /* 318 */ "frame_bound_s", |
| 180291 | + /* 319 */ "frame_bound_e", |
| 180292 | + /* 320 */ "frame_exclude_opt", |
| 180293 | + /* 321 */ "frame_exclude", |
| 180246 | 180294 | }; |
| 180247 | 180295 | #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */ |
| 180248 | 180296 | |
| 180249 | 180297 | #ifndef NDEBUG |
| 180250 | 180298 | /* For tracing reduce actions, the names of all rules are required. |
| | @@ -180370,12 +180418,12 @@ |
| 180370 | 180418 | /* 117 */ "dbnm ::= DOT nm", |
| 180371 | 180419 | /* 118 */ "fullname ::= nm", |
| 180372 | 180420 | /* 119 */ "fullname ::= nm DOT nm", |
| 180373 | 180421 | /* 120 */ "xfullname ::= nm", |
| 180374 | 180422 | /* 121 */ "xfullname ::= nm DOT nm", |
| 180375 | | - /* 122 */ "xfullname ::= nm DOT nm AS nm", |
| 180376 | | - /* 123 */ "xfullname ::= nm AS nm", |
| 180423 | + /* 122 */ "xfullname ::= nm AS nm", |
| 180424 | + /* 123 */ "xfullname ::= nm DOT nm AS nm", |
| 180377 | 180425 | /* 124 */ "joinop ::= COMMA|JOIN", |
| 180378 | 180426 | /* 125 */ "joinop ::= JOIN_KW JOIN", |
| 180379 | 180427 | /* 126 */ "joinop ::= JOIN_KW nm JOIN", |
| 180380 | 180428 | /* 127 */ "joinop ::= JOIN_KW nm nm JOIN", |
| 180381 | 180429 | /* 128 */ "on_using ::= ON expr", |
| | @@ -180520,152 +180568,150 @@ |
| 180520 | 180568 | /* 267 */ "trigger_event ::= UPDATE OF idlist", |
| 180521 | 180569 | /* 268 */ "when_clause ::=", |
| 180522 | 180570 | /* 269 */ "when_clause ::= WHEN expr", |
| 180523 | 180571 | /* 270 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI", |
| 180524 | 180572 | /* 271 */ "trigger_cmd_list ::= trigger_cmd SEMI", |
| 180525 | | - /* 272 */ "trnm ::= nm DOT nm", |
| 180526 | | - /* 273 */ "tridxby ::= INDEXED BY nm", |
| 180527 | | - /* 274 */ "tridxby ::= NOT INDEXED", |
| 180528 | | - /* 275 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt", |
| 180529 | | - /* 276 */ "trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt", |
| 180530 | | - /* 277 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt", |
| 180531 | | - /* 278 */ "trigger_cmd ::= scanpt select scanpt", |
| 180532 | | - /* 279 */ "expr ::= RAISE LP IGNORE RP", |
| 180533 | | - /* 280 */ "expr ::= RAISE LP raisetype COMMA expr RP", |
| 180534 | | - /* 281 */ "raisetype ::= ROLLBACK", |
| 180535 | | - /* 282 */ "raisetype ::= ABORT", |
| 180536 | | - /* 283 */ "raisetype ::= FAIL", |
| 180537 | | - /* 284 */ "cmd ::= DROP TRIGGER ifexists fullname", |
| 180538 | | - /* 285 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt", |
| 180539 | | - /* 286 */ "cmd ::= DETACH database_kw_opt expr", |
| 180540 | | - /* 287 */ "key_opt ::=", |
| 180541 | | - /* 288 */ "key_opt ::= KEY expr", |
| 180542 | | - /* 289 */ "cmd ::= REINDEX", |
| 180543 | | - /* 290 */ "cmd ::= REINDEX nm dbnm", |
| 180544 | | - /* 291 */ "cmd ::= ANALYZE", |
| 180545 | | - /* 292 */ "cmd ::= ANALYZE nm dbnm", |
| 180546 | | - /* 293 */ "cmd ::= ALTER TABLE fullname RENAME TO nm", |
| 180547 | | - /* 294 */ "cmd ::= alter_add carglist", |
| 180548 | | - /* 295 */ "alter_add ::= ALTER TABLE fullname ADD kwcolumn_opt nm typetoken", |
| 180549 | | - /* 296 */ "cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm", |
| 180550 | | - /* 297 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm", |
| 180551 | | - /* 298 */ "cmd ::= ALTER TABLE fullname DROP CONSTRAINT nm", |
| 180552 | | - /* 299 */ "cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm DROP NOT NULL", |
| 180553 | | - /* 300 */ "cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm SET NOT NULL onconf", |
| 180554 | | - /* 301 */ "cmd ::= ALTER TABLE fullname ADD CONSTRAINT nm CHECK LP expr RP onconf", |
| 180555 | | - /* 302 */ "cmd ::= ALTER TABLE fullname ADD CHECK LP expr RP onconf", |
| 180556 | | - /* 303 */ "cmd ::= create_vtab", |
| 180557 | | - /* 304 */ "cmd ::= create_vtab LP vtabarglist RP", |
| 180558 | | - /* 305 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm", |
| 180559 | | - /* 306 */ "vtabarg ::=", |
| 180560 | | - /* 307 */ "vtabargtoken ::= ANY", |
| 180561 | | - /* 308 */ "vtabargtoken ::= lp anylist RP", |
| 180562 | | - /* 309 */ "lp ::= LP", |
| 180563 | | - /* 310 */ "with ::= WITH wqlist", |
| 180564 | | - /* 311 */ "with ::= WITH RECURSIVE wqlist", |
| 180565 | | - /* 312 */ "wqas ::= AS", |
| 180566 | | - /* 313 */ "wqas ::= AS MATERIALIZED", |
| 180567 | | - /* 314 */ "wqas ::= AS NOT MATERIALIZED", |
| 180568 | | - /* 315 */ "wqitem ::= withnm eidlist_opt wqas LP select RP", |
| 180569 | | - /* 316 */ "withnm ::= nm", |
| 180570 | | - /* 317 */ "wqlist ::= wqitem", |
| 180571 | | - /* 318 */ "wqlist ::= wqlist COMMA wqitem", |
| 180572 | | - /* 319 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn", |
| 180573 | | - /* 320 */ "windowdefn ::= nm AS LP window RP", |
| 180574 | | - /* 321 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt", |
| 180575 | | - /* 322 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt", |
| 180576 | | - /* 323 */ "window ::= ORDER BY sortlist frame_opt", |
| 180577 | | - /* 324 */ "window ::= nm ORDER BY sortlist frame_opt", |
| 180578 | | - /* 325 */ "window ::= nm frame_opt", |
| 180579 | | - /* 326 */ "frame_opt ::=", |
| 180580 | | - /* 327 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt", |
| 180581 | | - /* 328 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt", |
| 180582 | | - /* 329 */ "range_or_rows ::= RANGE|ROWS|GROUPS", |
| 180583 | | - /* 330 */ "frame_bound_s ::= frame_bound", |
| 180584 | | - /* 331 */ "frame_bound_s ::= UNBOUNDED PRECEDING", |
| 180585 | | - /* 332 */ "frame_bound_e ::= frame_bound", |
| 180586 | | - /* 333 */ "frame_bound_e ::= UNBOUNDED FOLLOWING", |
| 180587 | | - /* 334 */ "frame_bound ::= expr PRECEDING|FOLLOWING", |
| 180588 | | - /* 335 */ "frame_bound ::= CURRENT ROW", |
| 180589 | | - /* 336 */ "frame_exclude_opt ::=", |
| 180590 | | - /* 337 */ "frame_exclude_opt ::= EXCLUDE frame_exclude", |
| 180591 | | - /* 338 */ "frame_exclude ::= NO OTHERS", |
| 180592 | | - /* 339 */ "frame_exclude ::= CURRENT ROW", |
| 180593 | | - /* 340 */ "frame_exclude ::= GROUP|TIES", |
| 180594 | | - /* 341 */ "window_clause ::= WINDOW windowdefn_list", |
| 180595 | | - /* 342 */ "filter_over ::= filter_clause over_clause", |
| 180596 | | - /* 343 */ "filter_over ::= over_clause", |
| 180597 | | - /* 344 */ "filter_over ::= filter_clause", |
| 180598 | | - /* 345 */ "over_clause ::= OVER LP window RP", |
| 180599 | | - /* 346 */ "over_clause ::= OVER nm", |
| 180600 | | - /* 347 */ "filter_clause ::= FILTER LP WHERE expr RP", |
| 180601 | | - /* 348 */ "term ::= QNUMBER", |
| 180602 | | - /* 349 */ "input ::= cmdlist", |
| 180603 | | - /* 350 */ "cmdlist ::= cmdlist ecmd", |
| 180604 | | - /* 351 */ "cmdlist ::= ecmd", |
| 180605 | | - /* 352 */ "ecmd ::= SEMI", |
| 180606 | | - /* 353 */ "ecmd ::= cmdx SEMI", |
| 180607 | | - /* 354 */ "ecmd ::= explain cmdx SEMI", |
| 180608 | | - /* 355 */ "trans_opt ::=", |
| 180609 | | - /* 356 */ "trans_opt ::= TRANSACTION", |
| 180610 | | - /* 357 */ "trans_opt ::= TRANSACTION nm", |
| 180611 | | - /* 358 */ "savepoint_opt ::= SAVEPOINT", |
| 180612 | | - /* 359 */ "savepoint_opt ::=", |
| 180613 | | - /* 360 */ "cmd ::= create_table create_table_args", |
| 180614 | | - /* 361 */ "table_option_set ::= table_option", |
| 180615 | | - /* 362 */ "columnlist ::= columnlist COMMA columnname carglist", |
| 180616 | | - /* 363 */ "columnlist ::= columnname carglist", |
| 180617 | | - /* 364 */ "nm ::= ID|INDEXED|JOIN_KW", |
| 180618 | | - /* 365 */ "nm ::= STRING", |
| 180619 | | - /* 366 */ "typetoken ::= typename", |
| 180620 | | - /* 367 */ "typename ::= ID|STRING", |
| 180621 | | - /* 368 */ "signed ::= plus_num", |
| 180622 | | - /* 369 */ "signed ::= minus_num", |
| 180623 | | - /* 370 */ "carglist ::= carglist ccons", |
| 180624 | | - /* 371 */ "carglist ::=", |
| 180625 | | - /* 372 */ "ccons ::= NULL onconf", |
| 180626 | | - /* 373 */ "ccons ::= GENERATED ALWAYS AS generated", |
| 180627 | | - /* 374 */ "ccons ::= AS generated", |
| 180628 | | - /* 375 */ "conslist_opt ::= COMMA conslist", |
| 180629 | | - /* 376 */ "conslist ::= conslist tconscomma tcons", |
| 180630 | | - /* 377 */ "conslist ::= tcons", |
| 180631 | | - /* 378 */ "tconscomma ::=", |
| 180632 | | - /* 379 */ "defer_subclause_opt ::= defer_subclause", |
| 180633 | | - /* 380 */ "resolvetype ::= raisetype", |
| 180634 | | - /* 381 */ "selectnowith ::= oneselect", |
| 180635 | | - /* 382 */ "oneselect ::= values", |
| 180636 | | - /* 383 */ "sclp ::= selcollist COMMA", |
| 180637 | | - /* 384 */ "as ::= ID|STRING", |
| 180638 | | - /* 385 */ "indexed_opt ::= indexed_by", |
| 180639 | | - /* 386 */ "returning ::=", |
| 180640 | | - /* 387 */ "expr ::= term", |
| 180641 | | - /* 388 */ "likeop ::= LIKE_KW|MATCH", |
| 180642 | | - /* 389 */ "case_operand ::= expr", |
| 180643 | | - /* 390 */ "exprlist ::= nexprlist", |
| 180644 | | - /* 391 */ "nmnum ::= plus_num", |
| 180645 | | - /* 392 */ "nmnum ::= nm", |
| 180646 | | - /* 393 */ "nmnum ::= ON", |
| 180647 | | - /* 394 */ "nmnum ::= DELETE", |
| 180648 | | - /* 395 */ "nmnum ::= DEFAULT", |
| 180649 | | - /* 396 */ "plus_num ::= INTEGER|FLOAT", |
| 180650 | | - /* 397 */ "foreach_clause ::=", |
| 180651 | | - /* 398 */ "foreach_clause ::= FOR EACH ROW", |
| 180652 | | - /* 399 */ "trnm ::= nm", |
| 180653 | | - /* 400 */ "tridxby ::=", |
| 180654 | | - /* 401 */ "database_kw_opt ::= DATABASE", |
| 180655 | | - /* 402 */ "database_kw_opt ::=", |
| 180656 | | - /* 403 */ "kwcolumn_opt ::=", |
| 180657 | | - /* 404 */ "kwcolumn_opt ::= COLUMNKW", |
| 180658 | | - /* 405 */ "vtabarglist ::= vtabarg", |
| 180659 | | - /* 406 */ "vtabarglist ::= vtabarglist COMMA vtabarg", |
| 180660 | | - /* 407 */ "vtabarg ::= vtabarg vtabargtoken", |
| 180661 | | - /* 408 */ "anylist ::=", |
| 180662 | | - /* 409 */ "anylist ::= anylist LP anylist RP", |
| 180663 | | - /* 410 */ "anylist ::= anylist ANY", |
| 180664 | | - /* 411 */ "with ::=", |
| 180665 | | - /* 412 */ "windowdefn_list ::= windowdefn", |
| 180666 | | - /* 413 */ "window ::= frame_opt", |
| 180573 | + /* 272 */ "tridxby ::= INDEXED BY nm", |
| 180574 | + /* 273 */ "tridxby ::= NOT INDEXED", |
| 180575 | + /* 274 */ "trigger_cmd ::= UPDATE orconf xfullname tridxby SET setlist from where_opt scanpt", |
| 180576 | + /* 275 */ "trigger_cmd ::= scanpt insert_cmd INTO xfullname idlist_opt select upsert scanpt", |
| 180577 | + /* 276 */ "trigger_cmd ::= DELETE FROM xfullname tridxby where_opt scanpt", |
| 180578 | + /* 277 */ "trigger_cmd ::= scanpt select scanpt", |
| 180579 | + /* 278 */ "expr ::= RAISE LP IGNORE RP", |
| 180580 | + /* 279 */ "expr ::= RAISE LP raisetype COMMA expr RP", |
| 180581 | + /* 280 */ "raisetype ::= ROLLBACK", |
| 180582 | + /* 281 */ "raisetype ::= ABORT", |
| 180583 | + /* 282 */ "raisetype ::= FAIL", |
| 180584 | + /* 283 */ "cmd ::= DROP TRIGGER ifexists fullname", |
| 180585 | + /* 284 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt", |
| 180586 | + /* 285 */ "cmd ::= DETACH database_kw_opt expr", |
| 180587 | + /* 286 */ "key_opt ::=", |
| 180588 | + /* 287 */ "key_opt ::= KEY expr", |
| 180589 | + /* 288 */ "cmd ::= REINDEX", |
| 180590 | + /* 289 */ "cmd ::= REINDEX nm dbnm", |
| 180591 | + /* 290 */ "cmd ::= ANALYZE", |
| 180592 | + /* 291 */ "cmd ::= ANALYZE nm dbnm", |
| 180593 | + /* 292 */ "cmd ::= ALTER TABLE fullname RENAME TO nm", |
| 180594 | + /* 293 */ "cmd ::= alter_add carglist", |
| 180595 | + /* 294 */ "alter_add ::= ALTER TABLE fullname ADD kwcolumn_opt nm typetoken", |
| 180596 | + /* 295 */ "cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm", |
| 180597 | + /* 296 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm", |
| 180598 | + /* 297 */ "cmd ::= ALTER TABLE fullname DROP CONSTRAINT nm", |
| 180599 | + /* 298 */ "cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm DROP NOT NULL", |
| 180600 | + /* 299 */ "cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm SET NOT NULL onconf", |
| 180601 | + /* 300 */ "cmd ::= ALTER TABLE fullname ADD CONSTRAINT nm CHECK LP expr RP onconf", |
| 180602 | + /* 301 */ "cmd ::= ALTER TABLE fullname ADD CHECK LP expr RP onconf", |
| 180603 | + /* 302 */ "cmd ::= create_vtab", |
| 180604 | + /* 303 */ "cmd ::= create_vtab LP vtabarglist RP", |
| 180605 | + /* 304 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm", |
| 180606 | + /* 305 */ "vtabarg ::=", |
| 180607 | + /* 306 */ "vtabargtoken ::= ANY", |
| 180608 | + /* 307 */ "vtabargtoken ::= lp anylist RP", |
| 180609 | + /* 308 */ "lp ::= LP", |
| 180610 | + /* 309 */ "with ::= WITH wqlist", |
| 180611 | + /* 310 */ "with ::= WITH RECURSIVE wqlist", |
| 180612 | + /* 311 */ "wqas ::= AS", |
| 180613 | + /* 312 */ "wqas ::= AS MATERIALIZED", |
| 180614 | + /* 313 */ "wqas ::= AS NOT MATERIALIZED", |
| 180615 | + /* 314 */ "wqitem ::= withnm eidlist_opt wqas LP select RP", |
| 180616 | + /* 315 */ "withnm ::= nm", |
| 180617 | + /* 316 */ "wqlist ::= wqitem", |
| 180618 | + /* 317 */ "wqlist ::= wqlist COMMA wqitem", |
| 180619 | + /* 318 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn", |
| 180620 | + /* 319 */ "windowdefn ::= nm AS LP window RP", |
| 180621 | + /* 320 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt", |
| 180622 | + /* 321 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt", |
| 180623 | + /* 322 */ "window ::= ORDER BY sortlist frame_opt", |
| 180624 | + /* 323 */ "window ::= nm ORDER BY sortlist frame_opt", |
| 180625 | + /* 324 */ "window ::= nm frame_opt", |
| 180626 | + /* 325 */ "frame_opt ::=", |
| 180627 | + /* 326 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt", |
| 180628 | + /* 327 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt", |
| 180629 | + /* 328 */ "range_or_rows ::= RANGE|ROWS|GROUPS", |
| 180630 | + /* 329 */ "frame_bound_s ::= frame_bound", |
| 180631 | + /* 330 */ "frame_bound_s ::= UNBOUNDED PRECEDING", |
| 180632 | + /* 331 */ "frame_bound_e ::= frame_bound", |
| 180633 | + /* 332 */ "frame_bound_e ::= UNBOUNDED FOLLOWING", |
| 180634 | + /* 333 */ "frame_bound ::= expr PRECEDING|FOLLOWING", |
| 180635 | + /* 334 */ "frame_bound ::= CURRENT ROW", |
| 180636 | + /* 335 */ "frame_exclude_opt ::=", |
| 180637 | + /* 336 */ "frame_exclude_opt ::= EXCLUDE frame_exclude", |
| 180638 | + /* 337 */ "frame_exclude ::= NO OTHERS", |
| 180639 | + /* 338 */ "frame_exclude ::= CURRENT ROW", |
| 180640 | + /* 339 */ "frame_exclude ::= GROUP|TIES", |
| 180641 | + /* 340 */ "window_clause ::= WINDOW windowdefn_list", |
| 180642 | + /* 341 */ "filter_over ::= filter_clause over_clause", |
| 180643 | + /* 342 */ "filter_over ::= over_clause", |
| 180644 | + /* 343 */ "filter_over ::= filter_clause", |
| 180645 | + /* 344 */ "over_clause ::= OVER LP window RP", |
| 180646 | + /* 345 */ "over_clause ::= OVER nm", |
| 180647 | + /* 346 */ "filter_clause ::= FILTER LP WHERE expr RP", |
| 180648 | + /* 347 */ "term ::= QNUMBER", |
| 180649 | + /* 348 */ "input ::= cmdlist", |
| 180650 | + /* 349 */ "cmdlist ::= cmdlist ecmd", |
| 180651 | + /* 350 */ "cmdlist ::= ecmd", |
| 180652 | + /* 351 */ "ecmd ::= SEMI", |
| 180653 | + /* 352 */ "ecmd ::= cmdx SEMI", |
| 180654 | + /* 353 */ "ecmd ::= explain cmdx SEMI", |
| 180655 | + /* 354 */ "trans_opt ::=", |
| 180656 | + /* 355 */ "trans_opt ::= TRANSACTION", |
| 180657 | + /* 356 */ "trans_opt ::= TRANSACTION nm", |
| 180658 | + /* 357 */ "savepoint_opt ::= SAVEPOINT", |
| 180659 | + /* 358 */ "savepoint_opt ::=", |
| 180660 | + /* 359 */ "cmd ::= create_table create_table_args", |
| 180661 | + /* 360 */ "table_option_set ::= table_option", |
| 180662 | + /* 361 */ "columnlist ::= columnlist COMMA columnname carglist", |
| 180663 | + /* 362 */ "columnlist ::= columnname carglist", |
| 180664 | + /* 363 */ "nm ::= ID|INDEXED|JOIN_KW", |
| 180665 | + /* 364 */ "nm ::= STRING", |
| 180666 | + /* 365 */ "typetoken ::= typename", |
| 180667 | + /* 366 */ "typename ::= ID|STRING", |
| 180668 | + /* 367 */ "signed ::= plus_num", |
| 180669 | + /* 368 */ "signed ::= minus_num", |
| 180670 | + /* 369 */ "carglist ::= carglist ccons", |
| 180671 | + /* 370 */ "carglist ::=", |
| 180672 | + /* 371 */ "ccons ::= NULL onconf", |
| 180673 | + /* 372 */ "ccons ::= GENERATED ALWAYS AS generated", |
| 180674 | + /* 373 */ "ccons ::= AS generated", |
| 180675 | + /* 374 */ "conslist_opt ::= COMMA conslist", |
| 180676 | + /* 375 */ "conslist ::= conslist tconscomma tcons", |
| 180677 | + /* 376 */ "conslist ::= tcons", |
| 180678 | + /* 377 */ "tconscomma ::=", |
| 180679 | + /* 378 */ "defer_subclause_opt ::= defer_subclause", |
| 180680 | + /* 379 */ "resolvetype ::= raisetype", |
| 180681 | + /* 380 */ "selectnowith ::= oneselect", |
| 180682 | + /* 381 */ "oneselect ::= values", |
| 180683 | + /* 382 */ "sclp ::= selcollist COMMA", |
| 180684 | + /* 383 */ "as ::= ID|STRING", |
| 180685 | + /* 384 */ "indexed_opt ::= indexed_by", |
| 180686 | + /* 385 */ "returning ::=", |
| 180687 | + /* 386 */ "expr ::= term", |
| 180688 | + /* 387 */ "likeop ::= LIKE_KW|MATCH", |
| 180689 | + /* 388 */ "case_operand ::= expr", |
| 180690 | + /* 389 */ "exprlist ::= nexprlist", |
| 180691 | + /* 390 */ "nmnum ::= plus_num", |
| 180692 | + /* 391 */ "nmnum ::= nm", |
| 180693 | + /* 392 */ "nmnum ::= ON", |
| 180694 | + /* 393 */ "nmnum ::= DELETE", |
| 180695 | + /* 394 */ "nmnum ::= DEFAULT", |
| 180696 | + /* 395 */ "plus_num ::= INTEGER|FLOAT", |
| 180697 | + /* 396 */ "foreach_clause ::=", |
| 180698 | + /* 397 */ "foreach_clause ::= FOR EACH ROW", |
| 180699 | + /* 398 */ "tridxby ::=", |
| 180700 | + /* 399 */ "database_kw_opt ::= DATABASE", |
| 180701 | + /* 400 */ "database_kw_opt ::=", |
| 180702 | + /* 401 */ "kwcolumn_opt ::=", |
| 180703 | + /* 402 */ "kwcolumn_opt ::= COLUMNKW", |
| 180704 | + /* 403 */ "vtabarglist ::= vtabarg", |
| 180705 | + /* 404 */ "vtabarglist ::= vtabarglist COMMA vtabarg", |
| 180706 | + /* 405 */ "vtabarg ::= vtabarg vtabargtoken", |
| 180707 | + /* 406 */ "anylist ::=", |
| 180708 | + /* 407 */ "anylist ::= anylist LP anylist RP", |
| 180709 | + /* 408 */ "anylist ::= anylist ANY", |
| 180710 | + /* 409 */ "with ::=", |
| 180711 | + /* 410 */ "windowdefn_list ::= windowdefn", |
| 180712 | + /* 411 */ "window ::= frame_opt", |
| 180667 | 180713 | }; |
| 180668 | 180714 | #endif /* NDEBUG */ |
| 180669 | 180715 | |
| 180670 | 180716 | |
| 180671 | 180717 | #if YYGROWABLESTACK |
| | @@ -180800,11 +180846,11 @@ |
| 180800 | 180846 | case 241: /* selectnowith */ |
| 180801 | 180847 | case 242: /* oneselect */ |
| 180802 | 180848 | case 254: /* values */ |
| 180803 | 180849 | case 256: /* mvalues */ |
| 180804 | 180850 | { |
| 180805 | | -sqlite3SelectDelete(pParse->db, (yypminor->yy637)); |
| 180851 | +sqlite3SelectDelete(pParse->db, (yypminor->yy555)); |
| 180806 | 180852 | } |
| 180807 | 180853 | break; |
| 180808 | 180854 | case 218: /* term */ |
| 180809 | 180855 | case 219: /* expr */ |
| 180810 | 180856 | case 248: /* where_opt */ |
| | @@ -180812,14 +180858,14 @@ |
| 180812 | 180858 | case 270: /* where_opt_ret */ |
| 180813 | 180859 | case 281: /* case_operand */ |
| 180814 | 180860 | case 283: /* case_else */ |
| 180815 | 180861 | case 286: /* vinto */ |
| 180816 | 180862 | case 293: /* when_clause */ |
| 180817 | | - case 298: /* key_opt */ |
| 180818 | | - case 315: /* filter_clause */ |
| 180863 | + case 297: /* key_opt */ |
| 180864 | + case 314: /* filter_clause */ |
| 180819 | 180865 | { |
| 180820 | | -sqlite3ExprDelete(pParse->db, (yypminor->yy590)); |
| 180866 | +sqlite3ExprDelete(pParse->db, (yypminor->yy454)); |
| 180821 | 180867 | } |
| 180822 | 180868 | break; |
| 180823 | 180869 | case 223: /* eidlist_opt */ |
| 180824 | 180870 | case 233: /* sortlist */ |
| 180825 | 180871 | case 234: /* eidlist */ |
| | @@ -180830,66 +180876,66 @@ |
| 180830 | 180876 | case 257: /* sclp */ |
| 180831 | 180877 | case 264: /* exprlist */ |
| 180832 | 180878 | case 271: /* setlist */ |
| 180833 | 180879 | case 280: /* paren_exprlist */ |
| 180834 | 180880 | case 282: /* case_exprlist */ |
| 180835 | | - case 314: /* part_opt */ |
| 180881 | + case 313: /* part_opt */ |
| 180836 | 180882 | { |
| 180837 | | -sqlite3ExprListDelete(pParse->db, (yypminor->yy402)); |
| 180883 | +sqlite3ExprListDelete(pParse->db, (yypminor->yy14)); |
| 180838 | 180884 | } |
| 180839 | 180885 | break; |
| 180840 | 180886 | case 240: /* fullname */ |
| 180841 | 180887 | case 247: /* from */ |
| 180842 | 180888 | case 259: /* seltablist */ |
| 180843 | 180889 | case 260: /* stl_prefix */ |
| 180844 | 180890 | case 265: /* xfullname */ |
| 180845 | 180891 | { |
| 180846 | | -sqlite3SrcListDelete(pParse->db, (yypminor->yy563)); |
| 180892 | +sqlite3SrcListDelete(pParse->db, (yypminor->yy203)); |
| 180847 | 180893 | } |
| 180848 | 180894 | break; |
| 180849 | 180895 | case 243: /* wqlist */ |
| 180850 | 180896 | { |
| 180851 | | -sqlite3WithDelete(pParse->db, (yypminor->yy125)); |
| 180897 | +sqlite3WithDelete(pParse->db, (yypminor->yy59)); |
| 180852 | 180898 | } |
| 180853 | 180899 | break; |
| 180854 | 180900 | case 253: /* window_clause */ |
| 180855 | | - case 310: /* windowdefn_list */ |
| 180901 | + case 309: /* windowdefn_list */ |
| 180856 | 180902 | { |
| 180857 | | -sqlite3WindowListDelete(pParse->db, (yypminor->yy483)); |
| 180903 | +sqlite3WindowListDelete(pParse->db, (yypminor->yy211)); |
| 180858 | 180904 | } |
| 180859 | 180905 | break; |
| 180860 | 180906 | case 266: /* idlist */ |
| 180861 | 180907 | case 273: /* idlist_opt */ |
| 180862 | 180908 | { |
| 180863 | | -sqlite3IdListDelete(pParse->db, (yypminor->yy204)); |
| 180909 | +sqlite3IdListDelete(pParse->db, (yypminor->yy132)); |
| 180864 | 180910 | } |
| 180865 | 180911 | break; |
| 180866 | 180912 | case 276: /* filter_over */ |
| 180867 | | - case 311: /* windowdefn */ |
| 180868 | | - case 312: /* window */ |
| 180869 | | - case 313: /* frame_opt */ |
| 180870 | | - case 316: /* over_clause */ |
| 180913 | + case 310: /* windowdefn */ |
| 180914 | + case 311: /* window */ |
| 180915 | + case 312: /* frame_opt */ |
| 180916 | + case 315: /* over_clause */ |
| 180871 | 180917 | { |
| 180872 | | -sqlite3WindowDelete(pParse->db, (yypminor->yy483)); |
| 180918 | +sqlite3WindowDelete(pParse->db, (yypminor->yy211)); |
| 180873 | 180919 | } |
| 180874 | 180920 | break; |
| 180875 | 180921 | case 289: /* trigger_cmd_list */ |
| 180876 | 180922 | case 294: /* trigger_cmd */ |
| 180877 | 180923 | { |
| 180878 | | -sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy319)); |
| 180924 | +sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy427)); |
| 180879 | 180925 | } |
| 180880 | 180926 | break; |
| 180881 | 180927 | case 291: /* trigger_event */ |
| 180882 | 180928 | { |
| 180883 | | -sqlite3IdListDelete(pParse->db, (yypminor->yy28).b); |
| 180929 | +sqlite3IdListDelete(pParse->db, (yypminor->yy286).b); |
| 180884 | 180930 | } |
| 180885 | 180931 | break; |
| 180886 | | - case 318: /* frame_bound */ |
| 180887 | | - case 319: /* frame_bound_s */ |
| 180888 | | - case 320: /* frame_bound_e */ |
| 180932 | + case 317: /* frame_bound */ |
| 180933 | + case 318: /* frame_bound_s */ |
| 180934 | + case 319: /* frame_bound_e */ |
| 180889 | 180935 | { |
| 180890 | | -sqlite3ExprDelete(pParse->db, (yypminor->yy205).pExpr); |
| 180936 | +sqlite3ExprDelete(pParse->db, (yypminor->yy509).pExpr); |
| 180891 | 180937 | } |
| 180892 | 180938 | break; |
| 180893 | 180939 | /********* End destructor definitions *****************************************/ |
| 180894 | 180940 | default: break; /* If no destructor action specified: do nothing */ |
| 180895 | 180941 | } |
| | @@ -181311,12 +181357,12 @@ |
| 181311 | 181357 | 202, /* (117) dbnm ::= DOT nm */ |
| 181312 | 181358 | 240, /* (118) fullname ::= nm */ |
| 181313 | 181359 | 240, /* (119) fullname ::= nm DOT nm */ |
| 181314 | 181360 | 265, /* (120) xfullname ::= nm */ |
| 181315 | 181361 | 265, /* (121) xfullname ::= nm DOT nm */ |
| 181316 | | - 265, /* (122) xfullname ::= nm DOT nm AS nm */ |
| 181317 | | - 265, /* (123) xfullname ::= nm AS nm */ |
| 181362 | + 265, /* (122) xfullname ::= nm AS nm */ |
| 181363 | + 265, /* (123) xfullname ::= nm DOT nm AS nm */ |
| 181318 | 181364 | 261, /* (124) joinop ::= COMMA|JOIN */ |
| 181319 | 181365 | 261, /* (125) joinop ::= JOIN_KW JOIN */ |
| 181320 | 181366 | 261, /* (126) joinop ::= JOIN_KW nm JOIN */ |
| 181321 | 181367 | 261, /* (127) joinop ::= JOIN_KW nm nm JOIN */ |
| 181322 | 181368 | 262, /* (128) on_using ::= ON expr */ |
| | @@ -181461,152 +181507,150 @@ |
| 181461 | 181507 | 291, /* (267) trigger_event ::= UPDATE OF idlist */ |
| 181462 | 181508 | 293, /* (268) when_clause ::= */ |
| 181463 | 181509 | 293, /* (269) when_clause ::= WHEN expr */ |
| 181464 | 181510 | 289, /* (270) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ |
| 181465 | 181511 | 289, /* (271) trigger_cmd_list ::= trigger_cmd SEMI */ |
| 181466 | | - 295, /* (272) trnm ::= nm DOT nm */ |
| 181467 | | - 296, /* (273) tridxby ::= INDEXED BY nm */ |
| 181468 | | - 296, /* (274) tridxby ::= NOT INDEXED */ |
| 181469 | | - 294, /* (275) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ |
| 181470 | | - 294, /* (276) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ |
| 181471 | | - 294, /* (277) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ |
| 181472 | | - 294, /* (278) trigger_cmd ::= scanpt select scanpt */ |
| 181473 | | - 219, /* (279) expr ::= RAISE LP IGNORE RP */ |
| 181474 | | - 219, /* (280) expr ::= RAISE LP raisetype COMMA expr RP */ |
| 181475 | | - 238, /* (281) raisetype ::= ROLLBACK */ |
| 181476 | | - 238, /* (282) raisetype ::= ABORT */ |
| 181477 | | - 238, /* (283) raisetype ::= FAIL */ |
| 181478 | | - 192, /* (284) cmd ::= DROP TRIGGER ifexists fullname */ |
| 181479 | | - 192, /* (285) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ |
| 181480 | | - 192, /* (286) cmd ::= DETACH database_kw_opt expr */ |
| 181481 | | - 298, /* (287) key_opt ::= */ |
| 181482 | | - 298, /* (288) key_opt ::= KEY expr */ |
| 181483 | | - 192, /* (289) cmd ::= REINDEX */ |
| 181484 | | - 192, /* (290) cmd ::= REINDEX nm dbnm */ |
| 181485 | | - 192, /* (291) cmd ::= ANALYZE */ |
| 181486 | | - 192, /* (292) cmd ::= ANALYZE nm dbnm */ |
| 181487 | | - 192, /* (293) cmd ::= ALTER TABLE fullname RENAME TO nm */ |
| 181488 | | - 192, /* (294) cmd ::= alter_add carglist */ |
| 181489 | | - 299, /* (295) alter_add ::= ALTER TABLE fullname ADD kwcolumn_opt nm typetoken */ |
| 181490 | | - 192, /* (296) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ |
| 181491 | | - 192, /* (297) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ |
| 181492 | | - 192, /* (298) cmd ::= ALTER TABLE fullname DROP CONSTRAINT nm */ |
| 181493 | | - 192, /* (299) cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm DROP NOT NULL */ |
| 181494 | | - 192, /* (300) cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm SET NOT NULL onconf */ |
| 181495 | | - 192, /* (301) cmd ::= ALTER TABLE fullname ADD CONSTRAINT nm CHECK LP expr RP onconf */ |
| 181496 | | - 192, /* (302) cmd ::= ALTER TABLE fullname ADD CHECK LP expr RP onconf */ |
| 181497 | | - 192, /* (303) cmd ::= create_vtab */ |
| 181498 | | - 192, /* (304) cmd ::= create_vtab LP vtabarglist RP */ |
| 181499 | | - 301, /* (305) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ |
| 181500 | | - 303, /* (306) vtabarg ::= */ |
| 181501 | | - 304, /* (307) vtabargtoken ::= ANY */ |
| 181502 | | - 304, /* (308) vtabargtoken ::= lp anylist RP */ |
| 181503 | | - 305, /* (309) lp ::= LP */ |
| 181504 | | - 269, /* (310) with ::= WITH wqlist */ |
| 181505 | | - 269, /* (311) with ::= WITH RECURSIVE wqlist */ |
| 181506 | | - 308, /* (312) wqas ::= AS */ |
| 181507 | | - 308, /* (313) wqas ::= AS MATERIALIZED */ |
| 181508 | | - 308, /* (314) wqas ::= AS NOT MATERIALIZED */ |
| 181509 | | - 307, /* (315) wqitem ::= withnm eidlist_opt wqas LP select RP */ |
| 181510 | | - 309, /* (316) withnm ::= nm */ |
| 181511 | | - 243, /* (317) wqlist ::= wqitem */ |
| 181512 | | - 243, /* (318) wqlist ::= wqlist COMMA wqitem */ |
| 181513 | | - 310, /* (319) windowdefn_list ::= windowdefn_list COMMA windowdefn */ |
| 181514 | | - 311, /* (320) windowdefn ::= nm AS LP window RP */ |
| 181515 | | - 312, /* (321) window ::= PARTITION BY nexprlist orderby_opt frame_opt */ |
| 181516 | | - 312, /* (322) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ |
| 181517 | | - 312, /* (323) window ::= ORDER BY sortlist frame_opt */ |
| 181518 | | - 312, /* (324) window ::= nm ORDER BY sortlist frame_opt */ |
| 181519 | | - 312, /* (325) window ::= nm frame_opt */ |
| 181520 | | - 313, /* (326) frame_opt ::= */ |
| 181521 | | - 313, /* (327) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ |
| 181522 | | - 313, /* (328) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ |
| 181523 | | - 317, /* (329) range_or_rows ::= RANGE|ROWS|GROUPS */ |
| 181524 | | - 319, /* (330) frame_bound_s ::= frame_bound */ |
| 181525 | | - 319, /* (331) frame_bound_s ::= UNBOUNDED PRECEDING */ |
| 181526 | | - 320, /* (332) frame_bound_e ::= frame_bound */ |
| 181527 | | - 320, /* (333) frame_bound_e ::= UNBOUNDED FOLLOWING */ |
| 181528 | | - 318, /* (334) frame_bound ::= expr PRECEDING|FOLLOWING */ |
| 181529 | | - 318, /* (335) frame_bound ::= CURRENT ROW */ |
| 181530 | | - 321, /* (336) frame_exclude_opt ::= */ |
| 181531 | | - 321, /* (337) frame_exclude_opt ::= EXCLUDE frame_exclude */ |
| 181532 | | - 322, /* (338) frame_exclude ::= NO OTHERS */ |
| 181533 | | - 322, /* (339) frame_exclude ::= CURRENT ROW */ |
| 181534 | | - 322, /* (340) frame_exclude ::= GROUP|TIES */ |
| 181535 | | - 253, /* (341) window_clause ::= WINDOW windowdefn_list */ |
| 181536 | | - 276, /* (342) filter_over ::= filter_clause over_clause */ |
| 181537 | | - 276, /* (343) filter_over ::= over_clause */ |
| 181538 | | - 276, /* (344) filter_over ::= filter_clause */ |
| 181539 | | - 316, /* (345) over_clause ::= OVER LP window RP */ |
| 181540 | | - 316, /* (346) over_clause ::= OVER nm */ |
| 181541 | | - 315, /* (347) filter_clause ::= FILTER LP WHERE expr RP */ |
| 181542 | | - 218, /* (348) term ::= QNUMBER */ |
| 181543 | | - 187, /* (349) input ::= cmdlist */ |
| 181544 | | - 188, /* (350) cmdlist ::= cmdlist ecmd */ |
| 181545 | | - 188, /* (351) cmdlist ::= ecmd */ |
| 181546 | | - 189, /* (352) ecmd ::= SEMI */ |
| 181547 | | - 189, /* (353) ecmd ::= cmdx SEMI */ |
| 181548 | | - 189, /* (354) ecmd ::= explain cmdx SEMI */ |
| 181549 | | - 194, /* (355) trans_opt ::= */ |
| 181550 | | - 194, /* (356) trans_opt ::= TRANSACTION */ |
| 181551 | | - 194, /* (357) trans_opt ::= TRANSACTION nm */ |
| 181552 | | - 196, /* (358) savepoint_opt ::= SAVEPOINT */ |
| 181553 | | - 196, /* (359) savepoint_opt ::= */ |
| 181554 | | - 192, /* (360) cmd ::= create_table create_table_args */ |
| 181555 | | - 205, /* (361) table_option_set ::= table_option */ |
| 181556 | | - 203, /* (362) columnlist ::= columnlist COMMA columnname carglist */ |
| 181557 | | - 203, /* (363) columnlist ::= columnname carglist */ |
| 181558 | | - 195, /* (364) nm ::= ID|INDEXED|JOIN_KW */ |
| 181559 | | - 195, /* (365) nm ::= STRING */ |
| 181560 | | - 210, /* (366) typetoken ::= typename */ |
| 181561 | | - 211, /* (367) typename ::= ID|STRING */ |
| 181562 | | - 212, /* (368) signed ::= plus_num */ |
| 181563 | | - 212, /* (369) signed ::= minus_num */ |
| 181564 | | - 209, /* (370) carglist ::= carglist ccons */ |
| 181565 | | - 209, /* (371) carglist ::= */ |
| 181566 | | - 217, /* (372) ccons ::= NULL onconf */ |
| 181567 | | - 217, /* (373) ccons ::= GENERATED ALWAYS AS generated */ |
| 181568 | | - 217, /* (374) ccons ::= AS generated */ |
| 181569 | | - 204, /* (375) conslist_opt ::= COMMA conslist */ |
| 181570 | | - 230, /* (376) conslist ::= conslist tconscomma tcons */ |
| 181571 | | - 230, /* (377) conslist ::= tcons */ |
| 181572 | | - 231, /* (378) tconscomma ::= */ |
| 181573 | | - 235, /* (379) defer_subclause_opt ::= defer_subclause */ |
| 181574 | | - 237, /* (380) resolvetype ::= raisetype */ |
| 181575 | | - 241, /* (381) selectnowith ::= oneselect */ |
| 181576 | | - 242, /* (382) oneselect ::= values */ |
| 181577 | | - 257, /* (383) sclp ::= selcollist COMMA */ |
| 181578 | | - 258, /* (384) as ::= ID|STRING */ |
| 181579 | | - 267, /* (385) indexed_opt ::= indexed_by */ |
| 181580 | | - 275, /* (386) returning ::= */ |
| 181581 | | - 219, /* (387) expr ::= term */ |
| 181582 | | - 277, /* (388) likeop ::= LIKE_KW|MATCH */ |
| 181583 | | - 281, /* (389) case_operand ::= expr */ |
| 181584 | | - 264, /* (390) exprlist ::= nexprlist */ |
| 181585 | | - 287, /* (391) nmnum ::= plus_num */ |
| 181586 | | - 287, /* (392) nmnum ::= nm */ |
| 181587 | | - 287, /* (393) nmnum ::= ON */ |
| 181588 | | - 287, /* (394) nmnum ::= DELETE */ |
| 181589 | | - 287, /* (395) nmnum ::= DEFAULT */ |
| 181590 | | - 213, /* (396) plus_num ::= INTEGER|FLOAT */ |
| 181591 | | - 292, /* (397) foreach_clause ::= */ |
| 181592 | | - 292, /* (398) foreach_clause ::= FOR EACH ROW */ |
| 181593 | | - 295, /* (399) trnm ::= nm */ |
| 181594 | | - 296, /* (400) tridxby ::= */ |
| 181595 | | - 297, /* (401) database_kw_opt ::= DATABASE */ |
| 181596 | | - 297, /* (402) database_kw_opt ::= */ |
| 181597 | | - 300, /* (403) kwcolumn_opt ::= */ |
| 181598 | | - 300, /* (404) kwcolumn_opt ::= COLUMNKW */ |
| 181599 | | - 302, /* (405) vtabarglist ::= vtabarg */ |
| 181600 | | - 302, /* (406) vtabarglist ::= vtabarglist COMMA vtabarg */ |
| 181601 | | - 303, /* (407) vtabarg ::= vtabarg vtabargtoken */ |
| 181602 | | - 306, /* (408) anylist ::= */ |
| 181603 | | - 306, /* (409) anylist ::= anylist LP anylist RP */ |
| 181604 | | - 306, /* (410) anylist ::= anylist ANY */ |
| 181605 | | - 269, /* (411) with ::= */ |
| 181606 | | - 310, /* (412) windowdefn_list ::= windowdefn */ |
| 181607 | | - 312, /* (413) window ::= frame_opt */ |
| 181512 | + 295, /* (272) tridxby ::= INDEXED BY nm */ |
| 181513 | + 295, /* (273) tridxby ::= NOT INDEXED */ |
| 181514 | + 294, /* (274) trigger_cmd ::= UPDATE orconf xfullname tridxby SET setlist from where_opt scanpt */ |
| 181515 | + 294, /* (275) trigger_cmd ::= scanpt insert_cmd INTO xfullname idlist_opt select upsert scanpt */ |
| 181516 | + 294, /* (276) trigger_cmd ::= DELETE FROM xfullname tridxby where_opt scanpt */ |
| 181517 | + 294, /* (277) trigger_cmd ::= scanpt select scanpt */ |
| 181518 | + 219, /* (278) expr ::= RAISE LP IGNORE RP */ |
| 181519 | + 219, /* (279) expr ::= RAISE LP raisetype COMMA expr RP */ |
| 181520 | + 238, /* (280) raisetype ::= ROLLBACK */ |
| 181521 | + 238, /* (281) raisetype ::= ABORT */ |
| 181522 | + 238, /* (282) raisetype ::= FAIL */ |
| 181523 | + 192, /* (283) cmd ::= DROP TRIGGER ifexists fullname */ |
| 181524 | + 192, /* (284) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ |
| 181525 | + 192, /* (285) cmd ::= DETACH database_kw_opt expr */ |
| 181526 | + 297, /* (286) key_opt ::= */ |
| 181527 | + 297, /* (287) key_opt ::= KEY expr */ |
| 181528 | + 192, /* (288) cmd ::= REINDEX */ |
| 181529 | + 192, /* (289) cmd ::= REINDEX nm dbnm */ |
| 181530 | + 192, /* (290) cmd ::= ANALYZE */ |
| 181531 | + 192, /* (291) cmd ::= ANALYZE nm dbnm */ |
| 181532 | + 192, /* (292) cmd ::= ALTER TABLE fullname RENAME TO nm */ |
| 181533 | + 192, /* (293) cmd ::= alter_add carglist */ |
| 181534 | + 298, /* (294) alter_add ::= ALTER TABLE fullname ADD kwcolumn_opt nm typetoken */ |
| 181535 | + 192, /* (295) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ |
| 181536 | + 192, /* (296) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ |
| 181537 | + 192, /* (297) cmd ::= ALTER TABLE fullname DROP CONSTRAINT nm */ |
| 181538 | + 192, /* (298) cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm DROP NOT NULL */ |
| 181539 | + 192, /* (299) cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm SET NOT NULL onconf */ |
| 181540 | + 192, /* (300) cmd ::= ALTER TABLE fullname ADD CONSTRAINT nm CHECK LP expr RP onconf */ |
| 181541 | + 192, /* (301) cmd ::= ALTER TABLE fullname ADD CHECK LP expr RP onconf */ |
| 181542 | + 192, /* (302) cmd ::= create_vtab */ |
| 181543 | + 192, /* (303) cmd ::= create_vtab LP vtabarglist RP */ |
| 181544 | + 300, /* (304) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ |
| 181545 | + 302, /* (305) vtabarg ::= */ |
| 181546 | + 303, /* (306) vtabargtoken ::= ANY */ |
| 181547 | + 303, /* (307) vtabargtoken ::= lp anylist RP */ |
| 181548 | + 304, /* (308) lp ::= LP */ |
| 181549 | + 269, /* (309) with ::= WITH wqlist */ |
| 181550 | + 269, /* (310) with ::= WITH RECURSIVE wqlist */ |
| 181551 | + 307, /* (311) wqas ::= AS */ |
| 181552 | + 307, /* (312) wqas ::= AS MATERIALIZED */ |
| 181553 | + 307, /* (313) wqas ::= AS NOT MATERIALIZED */ |
| 181554 | + 306, /* (314) wqitem ::= withnm eidlist_opt wqas LP select RP */ |
| 181555 | + 308, /* (315) withnm ::= nm */ |
| 181556 | + 243, /* (316) wqlist ::= wqitem */ |
| 181557 | + 243, /* (317) wqlist ::= wqlist COMMA wqitem */ |
| 181558 | + 309, /* (318) windowdefn_list ::= windowdefn_list COMMA windowdefn */ |
| 181559 | + 310, /* (319) windowdefn ::= nm AS LP window RP */ |
| 181560 | + 311, /* (320) window ::= PARTITION BY nexprlist orderby_opt frame_opt */ |
| 181561 | + 311, /* (321) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ |
| 181562 | + 311, /* (322) window ::= ORDER BY sortlist frame_opt */ |
| 181563 | + 311, /* (323) window ::= nm ORDER BY sortlist frame_opt */ |
| 181564 | + 311, /* (324) window ::= nm frame_opt */ |
| 181565 | + 312, /* (325) frame_opt ::= */ |
| 181566 | + 312, /* (326) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ |
| 181567 | + 312, /* (327) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ |
| 181568 | + 316, /* (328) range_or_rows ::= RANGE|ROWS|GROUPS */ |
| 181569 | + 318, /* (329) frame_bound_s ::= frame_bound */ |
| 181570 | + 318, /* (330) frame_bound_s ::= UNBOUNDED PRECEDING */ |
| 181571 | + 319, /* (331) frame_bound_e ::= frame_bound */ |
| 181572 | + 319, /* (332) frame_bound_e ::= UNBOUNDED FOLLOWING */ |
| 181573 | + 317, /* (333) frame_bound ::= expr PRECEDING|FOLLOWING */ |
| 181574 | + 317, /* (334) frame_bound ::= CURRENT ROW */ |
| 181575 | + 320, /* (335) frame_exclude_opt ::= */ |
| 181576 | + 320, /* (336) frame_exclude_opt ::= EXCLUDE frame_exclude */ |
| 181577 | + 321, /* (337) frame_exclude ::= NO OTHERS */ |
| 181578 | + 321, /* (338) frame_exclude ::= CURRENT ROW */ |
| 181579 | + 321, /* (339) frame_exclude ::= GROUP|TIES */ |
| 181580 | + 253, /* (340) window_clause ::= WINDOW windowdefn_list */ |
| 181581 | + 276, /* (341) filter_over ::= filter_clause over_clause */ |
| 181582 | + 276, /* (342) filter_over ::= over_clause */ |
| 181583 | + 276, /* (343) filter_over ::= filter_clause */ |
| 181584 | + 315, /* (344) over_clause ::= OVER LP window RP */ |
| 181585 | + 315, /* (345) over_clause ::= OVER nm */ |
| 181586 | + 314, /* (346) filter_clause ::= FILTER LP WHERE expr RP */ |
| 181587 | + 218, /* (347) term ::= QNUMBER */ |
| 181588 | + 187, /* (348) input ::= cmdlist */ |
| 181589 | + 188, /* (349) cmdlist ::= cmdlist ecmd */ |
| 181590 | + 188, /* (350) cmdlist ::= ecmd */ |
| 181591 | + 189, /* (351) ecmd ::= SEMI */ |
| 181592 | + 189, /* (352) ecmd ::= cmdx SEMI */ |
| 181593 | + 189, /* (353) ecmd ::= explain cmdx SEMI */ |
| 181594 | + 194, /* (354) trans_opt ::= */ |
| 181595 | + 194, /* (355) trans_opt ::= TRANSACTION */ |
| 181596 | + 194, /* (356) trans_opt ::= TRANSACTION nm */ |
| 181597 | + 196, /* (357) savepoint_opt ::= SAVEPOINT */ |
| 181598 | + 196, /* (358) savepoint_opt ::= */ |
| 181599 | + 192, /* (359) cmd ::= create_table create_table_args */ |
| 181600 | + 205, /* (360) table_option_set ::= table_option */ |
| 181601 | + 203, /* (361) columnlist ::= columnlist COMMA columnname carglist */ |
| 181602 | + 203, /* (362) columnlist ::= columnname carglist */ |
| 181603 | + 195, /* (363) nm ::= ID|INDEXED|JOIN_KW */ |
| 181604 | + 195, /* (364) nm ::= STRING */ |
| 181605 | + 210, /* (365) typetoken ::= typename */ |
| 181606 | + 211, /* (366) typename ::= ID|STRING */ |
| 181607 | + 212, /* (367) signed ::= plus_num */ |
| 181608 | + 212, /* (368) signed ::= minus_num */ |
| 181609 | + 209, /* (369) carglist ::= carglist ccons */ |
| 181610 | + 209, /* (370) carglist ::= */ |
| 181611 | + 217, /* (371) ccons ::= NULL onconf */ |
| 181612 | + 217, /* (372) ccons ::= GENERATED ALWAYS AS generated */ |
| 181613 | + 217, /* (373) ccons ::= AS generated */ |
| 181614 | + 204, /* (374) conslist_opt ::= COMMA conslist */ |
| 181615 | + 230, /* (375) conslist ::= conslist tconscomma tcons */ |
| 181616 | + 230, /* (376) conslist ::= tcons */ |
| 181617 | + 231, /* (377) tconscomma ::= */ |
| 181618 | + 235, /* (378) defer_subclause_opt ::= defer_subclause */ |
| 181619 | + 237, /* (379) resolvetype ::= raisetype */ |
| 181620 | + 241, /* (380) selectnowith ::= oneselect */ |
| 181621 | + 242, /* (381) oneselect ::= values */ |
| 181622 | + 257, /* (382) sclp ::= selcollist COMMA */ |
| 181623 | + 258, /* (383) as ::= ID|STRING */ |
| 181624 | + 267, /* (384) indexed_opt ::= indexed_by */ |
| 181625 | + 275, /* (385) returning ::= */ |
| 181626 | + 219, /* (386) expr ::= term */ |
| 181627 | + 277, /* (387) likeop ::= LIKE_KW|MATCH */ |
| 181628 | + 281, /* (388) case_operand ::= expr */ |
| 181629 | + 264, /* (389) exprlist ::= nexprlist */ |
| 181630 | + 287, /* (390) nmnum ::= plus_num */ |
| 181631 | + 287, /* (391) nmnum ::= nm */ |
| 181632 | + 287, /* (392) nmnum ::= ON */ |
| 181633 | + 287, /* (393) nmnum ::= DELETE */ |
| 181634 | + 287, /* (394) nmnum ::= DEFAULT */ |
| 181635 | + 213, /* (395) plus_num ::= INTEGER|FLOAT */ |
| 181636 | + 292, /* (396) foreach_clause ::= */ |
| 181637 | + 292, /* (397) foreach_clause ::= FOR EACH ROW */ |
| 181638 | + 295, /* (398) tridxby ::= */ |
| 181639 | + 296, /* (399) database_kw_opt ::= DATABASE */ |
| 181640 | + 296, /* (400) database_kw_opt ::= */ |
| 181641 | + 299, /* (401) kwcolumn_opt ::= */ |
| 181642 | + 299, /* (402) kwcolumn_opt ::= COLUMNKW */ |
| 181643 | + 301, /* (403) vtabarglist ::= vtabarg */ |
| 181644 | + 301, /* (404) vtabarglist ::= vtabarglist COMMA vtabarg */ |
| 181645 | + 302, /* (405) vtabarg ::= vtabarg vtabargtoken */ |
| 181646 | + 305, /* (406) anylist ::= */ |
| 181647 | + 305, /* (407) anylist ::= anylist LP anylist RP */ |
| 181648 | + 305, /* (408) anylist ::= anylist ANY */ |
| 181649 | + 269, /* (409) with ::= */ |
| 181650 | + 309, /* (410) windowdefn_list ::= windowdefn */ |
| 181651 | + 311, /* (411) window ::= frame_opt */ |
| 181608 | 181652 | }; |
| 181609 | 181653 | |
| 181610 | 181654 | /* For rule J, yyRuleInfoNRhs[J] contains the negative of the number |
| 181611 | 181655 | ** of symbols on the right-hand side of that rule. */ |
| 181612 | 181656 | static const signed char yyRuleInfoNRhs[] = { |
| | @@ -181730,12 +181774,12 @@ |
| 181730 | 181774 | -2, /* (117) dbnm ::= DOT nm */ |
| 181731 | 181775 | -1, /* (118) fullname ::= nm */ |
| 181732 | 181776 | -3, /* (119) fullname ::= nm DOT nm */ |
| 181733 | 181777 | -1, /* (120) xfullname ::= nm */ |
| 181734 | 181778 | -3, /* (121) xfullname ::= nm DOT nm */ |
| 181735 | | - -5, /* (122) xfullname ::= nm DOT nm AS nm */ |
| 181736 | | - -3, /* (123) xfullname ::= nm AS nm */ |
| 181779 | + -3, /* (122) xfullname ::= nm AS nm */ |
| 181780 | + -5, /* (123) xfullname ::= nm DOT nm AS nm */ |
| 181737 | 181781 | -1, /* (124) joinop ::= COMMA|JOIN */ |
| 181738 | 181782 | -2, /* (125) joinop ::= JOIN_KW JOIN */ |
| 181739 | 181783 | -3, /* (126) joinop ::= JOIN_KW nm JOIN */ |
| 181740 | 181784 | -4, /* (127) joinop ::= JOIN_KW nm nm JOIN */ |
| 181741 | 181785 | -2, /* (128) on_using ::= ON expr */ |
| | @@ -181880,152 +181924,150 @@ |
| 181880 | 181924 | -3, /* (267) trigger_event ::= UPDATE OF idlist */ |
| 181881 | 181925 | 0, /* (268) when_clause ::= */ |
| 181882 | 181926 | -2, /* (269) when_clause ::= WHEN expr */ |
| 181883 | 181927 | -3, /* (270) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ |
| 181884 | 181928 | -2, /* (271) trigger_cmd_list ::= trigger_cmd SEMI */ |
| 181885 | | - -3, /* (272) trnm ::= nm DOT nm */ |
| 181886 | | - -3, /* (273) tridxby ::= INDEXED BY nm */ |
| 181887 | | - -2, /* (274) tridxby ::= NOT INDEXED */ |
| 181888 | | - -9, /* (275) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ |
| 181889 | | - -8, /* (276) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ |
| 181890 | | - -6, /* (277) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ |
| 181891 | | - -3, /* (278) trigger_cmd ::= scanpt select scanpt */ |
| 181892 | | - -4, /* (279) expr ::= RAISE LP IGNORE RP */ |
| 181893 | | - -6, /* (280) expr ::= RAISE LP raisetype COMMA expr RP */ |
| 181894 | | - -1, /* (281) raisetype ::= ROLLBACK */ |
| 181895 | | - -1, /* (282) raisetype ::= ABORT */ |
| 181896 | | - -1, /* (283) raisetype ::= FAIL */ |
| 181897 | | - -4, /* (284) cmd ::= DROP TRIGGER ifexists fullname */ |
| 181898 | | - -6, /* (285) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ |
| 181899 | | - -3, /* (286) cmd ::= DETACH database_kw_opt expr */ |
| 181900 | | - 0, /* (287) key_opt ::= */ |
| 181901 | | - -2, /* (288) key_opt ::= KEY expr */ |
| 181902 | | - -1, /* (289) cmd ::= REINDEX */ |
| 181903 | | - -3, /* (290) cmd ::= REINDEX nm dbnm */ |
| 181904 | | - -1, /* (291) cmd ::= ANALYZE */ |
| 181905 | | - -3, /* (292) cmd ::= ANALYZE nm dbnm */ |
| 181906 | | - -6, /* (293) cmd ::= ALTER TABLE fullname RENAME TO nm */ |
| 181907 | | - -2, /* (294) cmd ::= alter_add carglist */ |
| 181908 | | - -7, /* (295) alter_add ::= ALTER TABLE fullname ADD kwcolumn_opt nm typetoken */ |
| 181909 | | - -6, /* (296) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ |
| 181910 | | - -8, /* (297) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ |
| 181911 | | - -6, /* (298) cmd ::= ALTER TABLE fullname DROP CONSTRAINT nm */ |
| 181912 | | - -9, /* (299) cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm DROP NOT NULL */ |
| 181913 | | - -10, /* (300) cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm SET NOT NULL onconf */ |
| 181914 | | - -11, /* (301) cmd ::= ALTER TABLE fullname ADD CONSTRAINT nm CHECK LP expr RP onconf */ |
| 181915 | | - -9, /* (302) cmd ::= ALTER TABLE fullname ADD CHECK LP expr RP onconf */ |
| 181916 | | - -1, /* (303) cmd ::= create_vtab */ |
| 181917 | | - -4, /* (304) cmd ::= create_vtab LP vtabarglist RP */ |
| 181918 | | - -8, /* (305) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ |
| 181919 | | - 0, /* (306) vtabarg ::= */ |
| 181920 | | - -1, /* (307) vtabargtoken ::= ANY */ |
| 181921 | | - -3, /* (308) vtabargtoken ::= lp anylist RP */ |
| 181922 | | - -1, /* (309) lp ::= LP */ |
| 181923 | | - -2, /* (310) with ::= WITH wqlist */ |
| 181924 | | - -3, /* (311) with ::= WITH RECURSIVE wqlist */ |
| 181925 | | - -1, /* (312) wqas ::= AS */ |
| 181926 | | - -2, /* (313) wqas ::= AS MATERIALIZED */ |
| 181927 | | - -3, /* (314) wqas ::= AS NOT MATERIALIZED */ |
| 181928 | | - -6, /* (315) wqitem ::= withnm eidlist_opt wqas LP select RP */ |
| 181929 | | - -1, /* (316) withnm ::= nm */ |
| 181930 | | - -1, /* (317) wqlist ::= wqitem */ |
| 181931 | | - -3, /* (318) wqlist ::= wqlist COMMA wqitem */ |
| 181932 | | - -3, /* (319) windowdefn_list ::= windowdefn_list COMMA windowdefn */ |
| 181933 | | - -5, /* (320) windowdefn ::= nm AS LP window RP */ |
| 181934 | | - -5, /* (321) window ::= PARTITION BY nexprlist orderby_opt frame_opt */ |
| 181935 | | - -6, /* (322) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ |
| 181936 | | - -4, /* (323) window ::= ORDER BY sortlist frame_opt */ |
| 181937 | | - -5, /* (324) window ::= nm ORDER BY sortlist frame_opt */ |
| 181938 | | - -2, /* (325) window ::= nm frame_opt */ |
| 181939 | | - 0, /* (326) frame_opt ::= */ |
| 181940 | | - -3, /* (327) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ |
| 181941 | | - -6, /* (328) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ |
| 181942 | | - -1, /* (329) range_or_rows ::= RANGE|ROWS|GROUPS */ |
| 181943 | | - -1, /* (330) frame_bound_s ::= frame_bound */ |
| 181944 | | - -2, /* (331) frame_bound_s ::= UNBOUNDED PRECEDING */ |
| 181945 | | - -1, /* (332) frame_bound_e ::= frame_bound */ |
| 181946 | | - -2, /* (333) frame_bound_e ::= UNBOUNDED FOLLOWING */ |
| 181947 | | - -2, /* (334) frame_bound ::= expr PRECEDING|FOLLOWING */ |
| 181948 | | - -2, /* (335) frame_bound ::= CURRENT ROW */ |
| 181949 | | - 0, /* (336) frame_exclude_opt ::= */ |
| 181950 | | - -2, /* (337) frame_exclude_opt ::= EXCLUDE frame_exclude */ |
| 181951 | | - -2, /* (338) frame_exclude ::= NO OTHERS */ |
| 181952 | | - -2, /* (339) frame_exclude ::= CURRENT ROW */ |
| 181953 | | - -1, /* (340) frame_exclude ::= GROUP|TIES */ |
| 181954 | | - -2, /* (341) window_clause ::= WINDOW windowdefn_list */ |
| 181955 | | - -2, /* (342) filter_over ::= filter_clause over_clause */ |
| 181956 | | - -1, /* (343) filter_over ::= over_clause */ |
| 181957 | | - -1, /* (344) filter_over ::= filter_clause */ |
| 181958 | | - -4, /* (345) over_clause ::= OVER LP window RP */ |
| 181959 | | - -2, /* (346) over_clause ::= OVER nm */ |
| 181960 | | - -5, /* (347) filter_clause ::= FILTER LP WHERE expr RP */ |
| 181961 | | - -1, /* (348) term ::= QNUMBER */ |
| 181962 | | - -1, /* (349) input ::= cmdlist */ |
| 181963 | | - -2, /* (350) cmdlist ::= cmdlist ecmd */ |
| 181964 | | - -1, /* (351) cmdlist ::= ecmd */ |
| 181965 | | - -1, /* (352) ecmd ::= SEMI */ |
| 181966 | | - -2, /* (353) ecmd ::= cmdx SEMI */ |
| 181967 | | - -3, /* (354) ecmd ::= explain cmdx SEMI */ |
| 181968 | | - 0, /* (355) trans_opt ::= */ |
| 181969 | | - -1, /* (356) trans_opt ::= TRANSACTION */ |
| 181970 | | - -2, /* (357) trans_opt ::= TRANSACTION nm */ |
| 181971 | | - -1, /* (358) savepoint_opt ::= SAVEPOINT */ |
| 181972 | | - 0, /* (359) savepoint_opt ::= */ |
| 181973 | | - -2, /* (360) cmd ::= create_table create_table_args */ |
| 181974 | | - -1, /* (361) table_option_set ::= table_option */ |
| 181975 | | - -4, /* (362) columnlist ::= columnlist COMMA columnname carglist */ |
| 181976 | | - -2, /* (363) columnlist ::= columnname carglist */ |
| 181977 | | - -1, /* (364) nm ::= ID|INDEXED|JOIN_KW */ |
| 181978 | | - -1, /* (365) nm ::= STRING */ |
| 181979 | | - -1, /* (366) typetoken ::= typename */ |
| 181980 | | - -1, /* (367) typename ::= ID|STRING */ |
| 181981 | | - -1, /* (368) signed ::= plus_num */ |
| 181982 | | - -1, /* (369) signed ::= minus_num */ |
| 181983 | | - -2, /* (370) carglist ::= carglist ccons */ |
| 181984 | | - 0, /* (371) carglist ::= */ |
| 181985 | | - -2, /* (372) ccons ::= NULL onconf */ |
| 181986 | | - -4, /* (373) ccons ::= GENERATED ALWAYS AS generated */ |
| 181987 | | - -2, /* (374) ccons ::= AS generated */ |
| 181988 | | - -2, /* (375) conslist_opt ::= COMMA conslist */ |
| 181989 | | - -3, /* (376) conslist ::= conslist tconscomma tcons */ |
| 181990 | | - -1, /* (377) conslist ::= tcons */ |
| 181991 | | - 0, /* (378) tconscomma ::= */ |
| 181992 | | - -1, /* (379) defer_subclause_opt ::= defer_subclause */ |
| 181993 | | - -1, /* (380) resolvetype ::= raisetype */ |
| 181994 | | - -1, /* (381) selectnowith ::= oneselect */ |
| 181995 | | - -1, /* (382) oneselect ::= values */ |
| 181996 | | - -2, /* (383) sclp ::= selcollist COMMA */ |
| 181997 | | - -1, /* (384) as ::= ID|STRING */ |
| 181998 | | - -1, /* (385) indexed_opt ::= indexed_by */ |
| 181999 | | - 0, /* (386) returning ::= */ |
| 182000 | | - -1, /* (387) expr ::= term */ |
| 182001 | | - -1, /* (388) likeop ::= LIKE_KW|MATCH */ |
| 182002 | | - -1, /* (389) case_operand ::= expr */ |
| 182003 | | - -1, /* (390) exprlist ::= nexprlist */ |
| 182004 | | - -1, /* (391) nmnum ::= plus_num */ |
| 182005 | | - -1, /* (392) nmnum ::= nm */ |
| 182006 | | - -1, /* (393) nmnum ::= ON */ |
| 182007 | | - -1, /* (394) nmnum ::= DELETE */ |
| 182008 | | - -1, /* (395) nmnum ::= DEFAULT */ |
| 182009 | | - -1, /* (396) plus_num ::= INTEGER|FLOAT */ |
| 182010 | | - 0, /* (397) foreach_clause ::= */ |
| 182011 | | - -3, /* (398) foreach_clause ::= FOR EACH ROW */ |
| 182012 | | - -1, /* (399) trnm ::= nm */ |
| 182013 | | - 0, /* (400) tridxby ::= */ |
| 182014 | | - -1, /* (401) database_kw_opt ::= DATABASE */ |
| 182015 | | - 0, /* (402) database_kw_opt ::= */ |
| 182016 | | - 0, /* (403) kwcolumn_opt ::= */ |
| 182017 | | - -1, /* (404) kwcolumn_opt ::= COLUMNKW */ |
| 182018 | | - -1, /* (405) vtabarglist ::= vtabarg */ |
| 182019 | | - -3, /* (406) vtabarglist ::= vtabarglist COMMA vtabarg */ |
| 182020 | | - -2, /* (407) vtabarg ::= vtabarg vtabargtoken */ |
| 182021 | | - 0, /* (408) anylist ::= */ |
| 182022 | | - -4, /* (409) anylist ::= anylist LP anylist RP */ |
| 182023 | | - -2, /* (410) anylist ::= anylist ANY */ |
| 182024 | | - 0, /* (411) with ::= */ |
| 182025 | | - -1, /* (412) windowdefn_list ::= windowdefn */ |
| 182026 | | - -1, /* (413) window ::= frame_opt */ |
| 181929 | + -3, /* (272) tridxby ::= INDEXED BY nm */ |
| 181930 | + -2, /* (273) tridxby ::= NOT INDEXED */ |
| 181931 | + -9, /* (274) trigger_cmd ::= UPDATE orconf xfullname tridxby SET setlist from where_opt scanpt */ |
| 181932 | + -8, /* (275) trigger_cmd ::= scanpt insert_cmd INTO xfullname idlist_opt select upsert scanpt */ |
| 181933 | + -6, /* (276) trigger_cmd ::= DELETE FROM xfullname tridxby where_opt scanpt */ |
| 181934 | + -3, /* (277) trigger_cmd ::= scanpt select scanpt */ |
| 181935 | + -4, /* (278) expr ::= RAISE LP IGNORE RP */ |
| 181936 | + -6, /* (279) expr ::= RAISE LP raisetype COMMA expr RP */ |
| 181937 | + -1, /* (280) raisetype ::= ROLLBACK */ |
| 181938 | + -1, /* (281) raisetype ::= ABORT */ |
| 181939 | + -1, /* (282) raisetype ::= FAIL */ |
| 181940 | + -4, /* (283) cmd ::= DROP TRIGGER ifexists fullname */ |
| 181941 | + -6, /* (284) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ |
| 181942 | + -3, /* (285) cmd ::= DETACH database_kw_opt expr */ |
| 181943 | + 0, /* (286) key_opt ::= */ |
| 181944 | + -2, /* (287) key_opt ::= KEY expr */ |
| 181945 | + -1, /* (288) cmd ::= REINDEX */ |
| 181946 | + -3, /* (289) cmd ::= REINDEX nm dbnm */ |
| 181947 | + -1, /* (290) cmd ::= ANALYZE */ |
| 181948 | + -3, /* (291) cmd ::= ANALYZE nm dbnm */ |
| 181949 | + -6, /* (292) cmd ::= ALTER TABLE fullname RENAME TO nm */ |
| 181950 | + -2, /* (293) cmd ::= alter_add carglist */ |
| 181951 | + -7, /* (294) alter_add ::= ALTER TABLE fullname ADD kwcolumn_opt nm typetoken */ |
| 181952 | + -6, /* (295) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ |
| 181953 | + -8, /* (296) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ |
| 181954 | + -6, /* (297) cmd ::= ALTER TABLE fullname DROP CONSTRAINT nm */ |
| 181955 | + -9, /* (298) cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm DROP NOT NULL */ |
| 181956 | + -10, /* (299) cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm SET NOT NULL onconf */ |
| 181957 | + -11, /* (300) cmd ::= ALTER TABLE fullname ADD CONSTRAINT nm CHECK LP expr RP onconf */ |
| 181958 | + -9, /* (301) cmd ::= ALTER TABLE fullname ADD CHECK LP expr RP onconf */ |
| 181959 | + -1, /* (302) cmd ::= create_vtab */ |
| 181960 | + -4, /* (303) cmd ::= create_vtab LP vtabarglist RP */ |
| 181961 | + -8, /* (304) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ |
| 181962 | + 0, /* (305) vtabarg ::= */ |
| 181963 | + -1, /* (306) vtabargtoken ::= ANY */ |
| 181964 | + -3, /* (307) vtabargtoken ::= lp anylist RP */ |
| 181965 | + -1, /* (308) lp ::= LP */ |
| 181966 | + -2, /* (309) with ::= WITH wqlist */ |
| 181967 | + -3, /* (310) with ::= WITH RECURSIVE wqlist */ |
| 181968 | + -1, /* (311) wqas ::= AS */ |
| 181969 | + -2, /* (312) wqas ::= AS MATERIALIZED */ |
| 181970 | + -3, /* (313) wqas ::= AS NOT MATERIALIZED */ |
| 181971 | + -6, /* (314) wqitem ::= withnm eidlist_opt wqas LP select RP */ |
| 181972 | + -1, /* (315) withnm ::= nm */ |
| 181973 | + -1, /* (316) wqlist ::= wqitem */ |
| 181974 | + -3, /* (317) wqlist ::= wqlist COMMA wqitem */ |
| 181975 | + -3, /* (318) windowdefn_list ::= windowdefn_list COMMA windowdefn */ |
| 181976 | + -5, /* (319) windowdefn ::= nm AS LP window RP */ |
| 181977 | + -5, /* (320) window ::= PARTITION BY nexprlist orderby_opt frame_opt */ |
| 181978 | + -6, /* (321) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ |
| 181979 | + -4, /* (322) window ::= ORDER BY sortlist frame_opt */ |
| 181980 | + -5, /* (323) window ::= nm ORDER BY sortlist frame_opt */ |
| 181981 | + -2, /* (324) window ::= nm frame_opt */ |
| 181982 | + 0, /* (325) frame_opt ::= */ |
| 181983 | + -3, /* (326) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ |
| 181984 | + -6, /* (327) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ |
| 181985 | + -1, /* (328) range_or_rows ::= RANGE|ROWS|GROUPS */ |
| 181986 | + -1, /* (329) frame_bound_s ::= frame_bound */ |
| 181987 | + -2, /* (330) frame_bound_s ::= UNBOUNDED PRECEDING */ |
| 181988 | + -1, /* (331) frame_bound_e ::= frame_bound */ |
| 181989 | + -2, /* (332) frame_bound_e ::= UNBOUNDED FOLLOWING */ |
| 181990 | + -2, /* (333) frame_bound ::= expr PRECEDING|FOLLOWING */ |
| 181991 | + -2, /* (334) frame_bound ::= CURRENT ROW */ |
| 181992 | + 0, /* (335) frame_exclude_opt ::= */ |
| 181993 | + -2, /* (336) frame_exclude_opt ::= EXCLUDE frame_exclude */ |
| 181994 | + -2, /* (337) frame_exclude ::= NO OTHERS */ |
| 181995 | + -2, /* (338) frame_exclude ::= CURRENT ROW */ |
| 181996 | + -1, /* (339) frame_exclude ::= GROUP|TIES */ |
| 181997 | + -2, /* (340) window_clause ::= WINDOW windowdefn_list */ |
| 181998 | + -2, /* (341) filter_over ::= filter_clause over_clause */ |
| 181999 | + -1, /* (342) filter_over ::= over_clause */ |
| 182000 | + -1, /* (343) filter_over ::= filter_clause */ |
| 182001 | + -4, /* (344) over_clause ::= OVER LP window RP */ |
| 182002 | + -2, /* (345) over_clause ::= OVER nm */ |
| 182003 | + -5, /* (346) filter_clause ::= FILTER LP WHERE expr RP */ |
| 182004 | + -1, /* (347) term ::= QNUMBER */ |
| 182005 | + -1, /* (348) input ::= cmdlist */ |
| 182006 | + -2, /* (349) cmdlist ::= cmdlist ecmd */ |
| 182007 | + -1, /* (350) cmdlist ::= ecmd */ |
| 182008 | + -1, /* (351) ecmd ::= SEMI */ |
| 182009 | + -2, /* (352) ecmd ::= cmdx SEMI */ |
| 182010 | + -3, /* (353) ecmd ::= explain cmdx SEMI */ |
| 182011 | + 0, /* (354) trans_opt ::= */ |
| 182012 | + -1, /* (355) trans_opt ::= TRANSACTION */ |
| 182013 | + -2, /* (356) trans_opt ::= TRANSACTION nm */ |
| 182014 | + -1, /* (357) savepoint_opt ::= SAVEPOINT */ |
| 182015 | + 0, /* (358) savepoint_opt ::= */ |
| 182016 | + -2, /* (359) cmd ::= create_table create_table_args */ |
| 182017 | + -1, /* (360) table_option_set ::= table_option */ |
| 182018 | + -4, /* (361) columnlist ::= columnlist COMMA columnname carglist */ |
| 182019 | + -2, /* (362) columnlist ::= columnname carglist */ |
| 182020 | + -1, /* (363) nm ::= ID|INDEXED|JOIN_KW */ |
| 182021 | + -1, /* (364) nm ::= STRING */ |
| 182022 | + -1, /* (365) typetoken ::= typename */ |
| 182023 | + -1, /* (366) typename ::= ID|STRING */ |
| 182024 | + -1, /* (367) signed ::= plus_num */ |
| 182025 | + -1, /* (368) signed ::= minus_num */ |
| 182026 | + -2, /* (369) carglist ::= carglist ccons */ |
| 182027 | + 0, /* (370) carglist ::= */ |
| 182028 | + -2, /* (371) ccons ::= NULL onconf */ |
| 182029 | + -4, /* (372) ccons ::= GENERATED ALWAYS AS generated */ |
| 182030 | + -2, /* (373) ccons ::= AS generated */ |
| 182031 | + -2, /* (374) conslist_opt ::= COMMA conslist */ |
| 182032 | + -3, /* (375) conslist ::= conslist tconscomma tcons */ |
| 182033 | + -1, /* (376) conslist ::= tcons */ |
| 182034 | + 0, /* (377) tconscomma ::= */ |
| 182035 | + -1, /* (378) defer_subclause_opt ::= defer_subclause */ |
| 182036 | + -1, /* (379) resolvetype ::= raisetype */ |
| 182037 | + -1, /* (380) selectnowith ::= oneselect */ |
| 182038 | + -1, /* (381) oneselect ::= values */ |
| 182039 | + -2, /* (382) sclp ::= selcollist COMMA */ |
| 182040 | + -1, /* (383) as ::= ID|STRING */ |
| 182041 | + -1, /* (384) indexed_opt ::= indexed_by */ |
| 182042 | + 0, /* (385) returning ::= */ |
| 182043 | + -1, /* (386) expr ::= term */ |
| 182044 | + -1, /* (387) likeop ::= LIKE_KW|MATCH */ |
| 182045 | + -1, /* (388) case_operand ::= expr */ |
| 182046 | + -1, /* (389) exprlist ::= nexprlist */ |
| 182047 | + -1, /* (390) nmnum ::= plus_num */ |
| 182048 | + -1, /* (391) nmnum ::= nm */ |
| 182049 | + -1, /* (392) nmnum ::= ON */ |
| 182050 | + -1, /* (393) nmnum ::= DELETE */ |
| 182051 | + -1, /* (394) nmnum ::= DEFAULT */ |
| 182052 | + -1, /* (395) plus_num ::= INTEGER|FLOAT */ |
| 182053 | + 0, /* (396) foreach_clause ::= */ |
| 182054 | + -3, /* (397) foreach_clause ::= FOR EACH ROW */ |
| 182055 | + 0, /* (398) tridxby ::= */ |
| 182056 | + -1, /* (399) database_kw_opt ::= DATABASE */ |
| 182057 | + 0, /* (400) database_kw_opt ::= */ |
| 182058 | + 0, /* (401) kwcolumn_opt ::= */ |
| 182059 | + -1, /* (402) kwcolumn_opt ::= COLUMNKW */ |
| 182060 | + -1, /* (403) vtabarglist ::= vtabarg */ |
| 182061 | + -3, /* (404) vtabarglist ::= vtabarglist COMMA vtabarg */ |
| 182062 | + -2, /* (405) vtabarg ::= vtabarg vtabargtoken */ |
| 182063 | + 0, /* (406) anylist ::= */ |
| 182064 | + -4, /* (407) anylist ::= anylist LP anylist RP */ |
| 182065 | + -2, /* (408) anylist ::= anylist ANY */ |
| 182066 | + 0, /* (409) with ::= */ |
| 182067 | + -1, /* (410) windowdefn_list ::= windowdefn */ |
| 182068 | + -1, /* (411) window ::= frame_opt */ |
| 182027 | 182069 | }; |
| 182028 | 182070 | |
| 182029 | 182071 | static void yy_accept(yyParser*); /* Forward Declaration */ |
| 182030 | 182072 | |
| 182031 | 182073 | /* |
| | @@ -182073,20 +182115,20 @@ |
| 182073 | 182115 | break; |
| 182074 | 182116 | case 2: /* cmdx ::= cmd */ |
| 182075 | 182117 | { sqlite3FinishCoding(pParse); } |
| 182076 | 182118 | break; |
| 182077 | 182119 | case 3: /* cmd ::= BEGIN transtype trans_opt */ |
| 182078 | | -{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy502);} |
| 182120 | +{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy144);} |
| 182079 | 182121 | break; |
| 182080 | 182122 | case 4: /* transtype ::= */ |
| 182081 | | -{yymsp[1].minor.yy502 = TK_DEFERRED;} |
| 182123 | +{yymsp[1].minor.yy144 = TK_DEFERRED;} |
| 182082 | 182124 | break; |
| 182083 | 182125 | case 5: /* transtype ::= DEFERRED */ |
| 182084 | 182126 | case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6); |
| 182085 | 182127 | case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7); |
| 182086 | | - case 329: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==329); |
| 182087 | | -{yymsp[0].minor.yy502 = yymsp[0].major; /*A-overwrites-X*/} |
| 182128 | + case 328: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==328); |
| 182129 | +{yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-X*/} |
| 182088 | 182130 | break; |
| 182089 | 182131 | case 8: /* cmd ::= COMMIT|END trans_opt */ |
| 182090 | 182132 | case 9: /* cmd ::= ROLLBACK trans_opt */ yytestcase(yyruleno==9); |
| 182091 | 182133 | {sqlite3EndTransaction(pParse,yymsp[-1].major);} |
| 182092 | 182134 | break; |
| | @@ -182105,11 +182147,11 @@ |
| 182105 | 182147 | sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0); |
| 182106 | 182148 | } |
| 182107 | 182149 | break; |
| 182108 | 182150 | case 13: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */ |
| 182109 | 182151 | { |
| 182110 | | - sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy502,0,0,yymsp[-2].minor.yy502); |
| 182152 | + sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy144,0,0,yymsp[-2].minor.yy144); |
| 182111 | 182153 | } |
| 182112 | 182154 | break; |
| 182113 | 182155 | case 14: /* createkw ::= CREATE */ |
| 182114 | 182156 | { |
| 182115 | 182157 | disableLookaside(pParse); |
| | @@ -182121,56 +182163,56 @@ |
| 182121 | 182163 | case 62: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==62); |
| 182122 | 182164 | case 72: /* defer_subclause_opt ::= */ yytestcase(yyruleno==72); |
| 182123 | 182165 | case 81: /* ifexists ::= */ yytestcase(yyruleno==81); |
| 182124 | 182166 | case 100: /* distinct ::= */ yytestcase(yyruleno==100); |
| 182125 | 182167 | case 246: /* collate ::= */ yytestcase(yyruleno==246); |
| 182126 | | -{yymsp[1].minor.yy502 = 0;} |
| 182168 | +{yymsp[1].minor.yy144 = 0;} |
| 182127 | 182169 | break; |
| 182128 | 182170 | case 16: /* ifnotexists ::= IF NOT EXISTS */ |
| 182129 | | -{yymsp[-2].minor.yy502 = 1;} |
| 182171 | +{yymsp[-2].minor.yy144 = 1;} |
| 182130 | 182172 | break; |
| 182131 | 182173 | case 17: /* temp ::= TEMP */ |
| 182132 | | -{yymsp[0].minor.yy502 = pParse->db->init.busy==0;} |
| 182174 | +{yymsp[0].minor.yy144 = pParse->db->init.busy==0;} |
| 182133 | 182175 | break; |
| 182134 | 182176 | case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_option_set */ |
| 182135 | 182177 | { |
| 182136 | | - sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy9,0); |
| 182178 | + sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy391,0); |
| 182137 | 182179 | } |
| 182138 | 182180 | break; |
| 182139 | 182181 | case 20: /* create_table_args ::= AS select */ |
| 182140 | 182182 | { |
| 182141 | | - sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy637); |
| 182142 | | - sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy637); |
| 182183 | + sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy555); |
| 182184 | + sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy555); |
| 182143 | 182185 | } |
| 182144 | 182186 | break; |
| 182145 | 182187 | case 21: /* table_option_set ::= */ |
| 182146 | | -{yymsp[1].minor.yy9 = 0;} |
| 182188 | +{yymsp[1].minor.yy391 = 0;} |
| 182147 | 182189 | break; |
| 182148 | 182190 | case 22: /* table_option_set ::= table_option_set COMMA table_option */ |
| 182149 | | -{yylhsminor.yy9 = yymsp[-2].minor.yy9|yymsp[0].minor.yy9;} |
| 182150 | | - yymsp[-2].minor.yy9 = yylhsminor.yy9; |
| 182191 | +{yylhsminor.yy391 = yymsp[-2].minor.yy391|yymsp[0].minor.yy391;} |
| 182192 | + yymsp[-2].minor.yy391 = yylhsminor.yy391; |
| 182151 | 182193 | break; |
| 182152 | 182194 | case 23: /* table_option ::= WITHOUT nm */ |
| 182153 | 182195 | { |
| 182154 | 182196 | if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){ |
| 182155 | | - yymsp[-1].minor.yy9 = TF_WithoutRowid | TF_NoVisibleRowid; |
| 182197 | + yymsp[-1].minor.yy391 = TF_WithoutRowid | TF_NoVisibleRowid; |
| 182156 | 182198 | }else{ |
| 182157 | | - yymsp[-1].minor.yy9 = 0; |
| 182199 | + yymsp[-1].minor.yy391 = 0; |
| 182158 | 182200 | sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z); |
| 182159 | 182201 | } |
| 182160 | 182202 | } |
| 182161 | 182203 | break; |
| 182162 | 182204 | case 24: /* table_option ::= nm */ |
| 182163 | 182205 | { |
| 182164 | 182206 | if( yymsp[0].minor.yy0.n==6 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"strict",6)==0 ){ |
| 182165 | | - yylhsminor.yy9 = TF_Strict; |
| 182207 | + yylhsminor.yy391 = TF_Strict; |
| 182166 | 182208 | }else{ |
| 182167 | | - yylhsminor.yy9 = 0; |
| 182209 | + yylhsminor.yy391 = 0; |
| 182168 | 182210 | sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z); |
| 182169 | 182211 | } |
| 182170 | 182212 | } |
| 182171 | | - yymsp[0].minor.yy9 = yylhsminor.yy9; |
| 182213 | + yymsp[0].minor.yy391 = yylhsminor.yy391; |
| 182172 | 182214 | break; |
| 182173 | 182215 | case 25: /* columnname ::= nm typetoken */ |
| 182174 | 182216 | {sqlite3AddColumn(pParse,yymsp[-1].minor.yy0,yymsp[0].minor.yy0);} |
| 182175 | 182217 | break; |
| 182176 | 182218 | case 26: /* typetoken ::= */ |
| | @@ -182192,11 +182234,11 @@ |
| 182192 | 182234 | {yymsp[-1].minor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);} |
| 182193 | 182235 | break; |
| 182194 | 182236 | case 30: /* scanpt ::= */ |
| 182195 | 182237 | { |
| 182196 | 182238 | assert( yyLookahead!=YYNOCODE ); |
| 182197 | | - yymsp[1].minor.yy342 = yyLookaheadToken.z; |
| 182239 | + yymsp[1].minor.yy168 = yyLookaheadToken.z; |
| 182198 | 182240 | } |
| 182199 | 182241 | break; |
| 182200 | 182242 | case 31: /* scantok ::= */ |
| 182201 | 182243 | { |
| 182202 | 182244 | assert( yyLookahead!=YYNOCODE ); |
| | @@ -182206,21 +182248,21 @@ |
| 182206 | 182248 | case 32: /* ccons ::= CONSTRAINT nm */ |
| 182207 | 182249 | case 67: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==67); |
| 182208 | 182250 | {ASSERT_IS_CREATE; pParse->u1.cr.constraintName = yymsp[0].minor.yy0;} |
| 182209 | 182251 | break; |
| 182210 | 182252 | case 33: /* ccons ::= DEFAULT scantok term */ |
| 182211 | | -{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy590,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);} |
| 182253 | +{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy454,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);} |
| 182212 | 182254 | break; |
| 182213 | 182255 | case 34: /* ccons ::= DEFAULT LP expr RP */ |
| 182214 | | -{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy590,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);} |
| 182256 | +{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy454,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);} |
| 182215 | 182257 | break; |
| 182216 | 182258 | case 35: /* ccons ::= DEFAULT PLUS scantok term */ |
| 182217 | | -{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy590,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);} |
| 182259 | +{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy454,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);} |
| 182218 | 182260 | break; |
| 182219 | 182261 | case 36: /* ccons ::= DEFAULT MINUS scantok term */ |
| 182220 | 182262 | { |
| 182221 | | - Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy590, 0); |
| 182263 | + Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy454, 0); |
| 182222 | 182264 | sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]); |
| 182223 | 182265 | } |
| 182224 | 182266 | break; |
| 182225 | 182267 | case 37: /* ccons ::= DEFAULT scantok ID|INDEXED */ |
| 182226 | 182268 | { |
| | @@ -182231,262 +182273,262 @@ |
| 182231 | 182273 | } |
| 182232 | 182274 | sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n); |
| 182233 | 182275 | } |
| 182234 | 182276 | break; |
| 182235 | 182277 | case 38: /* ccons ::= NOT NULL onconf */ |
| 182236 | | -{sqlite3AddNotNull(pParse, yymsp[0].minor.yy502);} |
| 182278 | +{sqlite3AddNotNull(pParse, yymsp[0].minor.yy144);} |
| 182237 | 182279 | break; |
| 182238 | 182280 | case 39: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */ |
| 182239 | | -{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy502,yymsp[0].minor.yy502,yymsp[-2].minor.yy502);} |
| 182281 | +{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy144,yymsp[0].minor.yy144,yymsp[-2].minor.yy144);} |
| 182240 | 182282 | break; |
| 182241 | 182283 | case 40: /* ccons ::= UNIQUE onconf */ |
| 182242 | | -{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy502,0,0,0,0, |
| 182284 | +{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy144,0,0,0,0, |
| 182243 | 182285 | SQLITE_IDXTYPE_UNIQUE);} |
| 182244 | 182286 | break; |
| 182245 | 182287 | case 41: /* ccons ::= CHECK LP expr RP */ |
| 182246 | | -{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy590,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);} |
| 182288 | +{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy454,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);} |
| 182247 | 182289 | break; |
| 182248 | 182290 | case 42: /* ccons ::= REFERENCES nm eidlist_opt refargs */ |
| 182249 | | -{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy402,yymsp[0].minor.yy502);} |
| 182291 | +{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy14,yymsp[0].minor.yy144);} |
| 182250 | 182292 | break; |
| 182251 | 182293 | case 43: /* ccons ::= defer_subclause */ |
| 182252 | | -{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy502);} |
| 182294 | +{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy144);} |
| 182253 | 182295 | break; |
| 182254 | 182296 | case 44: /* ccons ::= COLLATE ID|STRING */ |
| 182255 | 182297 | {sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);} |
| 182256 | 182298 | break; |
| 182257 | 182299 | case 45: /* generated ::= LP expr RP */ |
| 182258 | | -{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy590,0);} |
| 182300 | +{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy454,0);} |
| 182259 | 182301 | break; |
| 182260 | 182302 | case 46: /* generated ::= LP expr RP ID */ |
| 182261 | | -{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy590,&yymsp[0].minor.yy0);} |
| 182303 | +{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy454,&yymsp[0].minor.yy0);} |
| 182262 | 182304 | break; |
| 182263 | 182305 | case 48: /* autoinc ::= AUTOINCR */ |
| 182264 | | -{yymsp[0].minor.yy502 = 1;} |
| 182306 | +{yymsp[0].minor.yy144 = 1;} |
| 182265 | 182307 | break; |
| 182266 | 182308 | case 49: /* refargs ::= */ |
| 182267 | | -{ yymsp[1].minor.yy502 = OE_None*0x0101; /* EV: R-19803-45884 */} |
| 182309 | +{ yymsp[1].minor.yy144 = OE_None*0x0101; /* EV: R-19803-45884 */} |
| 182268 | 182310 | break; |
| 182269 | 182311 | case 50: /* refargs ::= refargs refarg */ |
| 182270 | | -{ yymsp[-1].minor.yy502 = (yymsp[-1].minor.yy502 & ~yymsp[0].minor.yy481.mask) | yymsp[0].minor.yy481.value; } |
| 182312 | +{ yymsp[-1].minor.yy144 = (yymsp[-1].minor.yy144 & ~yymsp[0].minor.yy383.mask) | yymsp[0].minor.yy383.value; } |
| 182271 | 182313 | break; |
| 182272 | 182314 | case 51: /* refarg ::= MATCH nm */ |
| 182273 | | -{ yymsp[-1].minor.yy481.value = 0; yymsp[-1].minor.yy481.mask = 0x000000; } |
| 182315 | +{ yymsp[-1].minor.yy383.value = 0; yymsp[-1].minor.yy383.mask = 0x000000; } |
| 182274 | 182316 | break; |
| 182275 | 182317 | case 52: /* refarg ::= ON INSERT refact */ |
| 182276 | | -{ yymsp[-2].minor.yy481.value = 0; yymsp[-2].minor.yy481.mask = 0x000000; } |
| 182318 | +{ yymsp[-2].minor.yy383.value = 0; yymsp[-2].minor.yy383.mask = 0x000000; } |
| 182277 | 182319 | break; |
| 182278 | 182320 | case 53: /* refarg ::= ON DELETE refact */ |
| 182279 | | -{ yymsp[-2].minor.yy481.value = yymsp[0].minor.yy502; yymsp[-2].minor.yy481.mask = 0x0000ff; } |
| 182321 | +{ yymsp[-2].minor.yy383.value = yymsp[0].minor.yy144; yymsp[-2].minor.yy383.mask = 0x0000ff; } |
| 182280 | 182322 | break; |
| 182281 | 182323 | case 54: /* refarg ::= ON UPDATE refact */ |
| 182282 | | -{ yymsp[-2].minor.yy481.value = yymsp[0].minor.yy502<<8; yymsp[-2].minor.yy481.mask = 0x00ff00; } |
| 182324 | +{ yymsp[-2].minor.yy383.value = yymsp[0].minor.yy144<<8; yymsp[-2].minor.yy383.mask = 0x00ff00; } |
| 182283 | 182325 | break; |
| 182284 | 182326 | case 55: /* refact ::= SET NULL */ |
| 182285 | | -{ yymsp[-1].minor.yy502 = OE_SetNull; /* EV: R-33326-45252 */} |
| 182327 | +{ yymsp[-1].minor.yy144 = OE_SetNull; /* EV: R-33326-45252 */} |
| 182286 | 182328 | break; |
| 182287 | 182329 | case 56: /* refact ::= SET DEFAULT */ |
| 182288 | | -{ yymsp[-1].minor.yy502 = OE_SetDflt; /* EV: R-33326-45252 */} |
| 182330 | +{ yymsp[-1].minor.yy144 = OE_SetDflt; /* EV: R-33326-45252 */} |
| 182289 | 182331 | break; |
| 182290 | 182332 | case 57: /* refact ::= CASCADE */ |
| 182291 | | -{ yymsp[0].minor.yy502 = OE_Cascade; /* EV: R-33326-45252 */} |
| 182333 | +{ yymsp[0].minor.yy144 = OE_Cascade; /* EV: R-33326-45252 */} |
| 182292 | 182334 | break; |
| 182293 | 182335 | case 58: /* refact ::= RESTRICT */ |
| 182294 | | -{ yymsp[0].minor.yy502 = OE_Restrict; /* EV: R-33326-45252 */} |
| 182336 | +{ yymsp[0].minor.yy144 = OE_Restrict; /* EV: R-33326-45252 */} |
| 182295 | 182337 | break; |
| 182296 | 182338 | case 59: /* refact ::= NO ACTION */ |
| 182297 | | -{ yymsp[-1].minor.yy502 = OE_None; /* EV: R-33326-45252 */} |
| 182339 | +{ yymsp[-1].minor.yy144 = OE_None; /* EV: R-33326-45252 */} |
| 182298 | 182340 | break; |
| 182299 | 182341 | case 60: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ |
| 182300 | | -{yymsp[-2].minor.yy502 = 0;} |
| 182342 | +{yymsp[-2].minor.yy144 = 0;} |
| 182301 | 182343 | break; |
| 182302 | 182344 | case 61: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ |
| 182303 | 182345 | case 76: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==76); |
| 182304 | 182346 | case 173: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==173); |
| 182305 | | -{yymsp[-1].minor.yy502 = yymsp[0].minor.yy502;} |
| 182347 | +{yymsp[-1].minor.yy144 = yymsp[0].minor.yy144;} |
| 182306 | 182348 | break; |
| 182307 | 182349 | case 63: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */ |
| 182308 | 182350 | case 80: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==80); |
| 182309 | 182351 | case 219: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==219); |
| 182310 | 182352 | case 222: /* in_op ::= NOT IN */ yytestcase(yyruleno==222); |
| 182311 | 182353 | case 247: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==247); |
| 182312 | | -{yymsp[-1].minor.yy502 = 1;} |
| 182354 | +{yymsp[-1].minor.yy144 = 1;} |
| 182313 | 182355 | break; |
| 182314 | 182356 | case 64: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ |
| 182315 | | -{yymsp[-1].minor.yy502 = 0;} |
| 182357 | +{yymsp[-1].minor.yy144 = 0;} |
| 182316 | 182358 | break; |
| 182317 | 182359 | case 66: /* tconscomma ::= COMMA */ |
| 182318 | 182360 | {ASSERT_IS_CREATE; pParse->u1.cr.constraintName.n = 0;} |
| 182319 | 182361 | break; |
| 182320 | 182362 | case 68: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ |
| 182321 | | -{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy402,yymsp[0].minor.yy502,yymsp[-2].minor.yy502,0);} |
| 182363 | +{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy14,yymsp[0].minor.yy144,yymsp[-2].minor.yy144,0);} |
| 182322 | 182364 | break; |
| 182323 | 182365 | case 69: /* tcons ::= UNIQUE LP sortlist RP onconf */ |
| 182324 | | -{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy402,yymsp[0].minor.yy502,0,0,0,0, |
| 182366 | +{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy14,yymsp[0].minor.yy144,0,0,0,0, |
| 182325 | 182367 | SQLITE_IDXTYPE_UNIQUE);} |
| 182326 | 182368 | break; |
| 182327 | 182369 | case 70: /* tcons ::= CHECK LP expr RP onconf */ |
| 182328 | | -{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy590,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);} |
| 182370 | +{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy454,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);} |
| 182329 | 182371 | break; |
| 182330 | 182372 | case 71: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ |
| 182331 | 182373 | { |
| 182332 | | - sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy402, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy402, yymsp[-1].minor.yy502); |
| 182333 | | - sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy502); |
| 182374 | + sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy14, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[-1].minor.yy144); |
| 182375 | + sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy144); |
| 182334 | 182376 | } |
| 182335 | 182377 | break; |
| 182336 | 182378 | case 73: /* onconf ::= */ |
| 182337 | 182379 | case 75: /* orconf ::= */ yytestcase(yyruleno==75); |
| 182338 | | -{yymsp[1].minor.yy502 = OE_Default;} |
| 182380 | +{yymsp[1].minor.yy144 = OE_Default;} |
| 182339 | 182381 | break; |
| 182340 | 182382 | case 74: /* onconf ::= ON CONFLICT resolvetype */ |
| 182341 | | -{yymsp[-2].minor.yy502 = yymsp[0].minor.yy502;} |
| 182383 | +{yymsp[-2].minor.yy144 = yymsp[0].minor.yy144;} |
| 182342 | 182384 | break; |
| 182343 | 182385 | case 77: /* resolvetype ::= IGNORE */ |
| 182344 | | -{yymsp[0].minor.yy502 = OE_Ignore;} |
| 182386 | +{yymsp[0].minor.yy144 = OE_Ignore;} |
| 182345 | 182387 | break; |
| 182346 | 182388 | case 78: /* resolvetype ::= REPLACE */ |
| 182347 | 182389 | case 174: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==174); |
| 182348 | | -{yymsp[0].minor.yy502 = OE_Replace;} |
| 182390 | +{yymsp[0].minor.yy144 = OE_Replace;} |
| 182349 | 182391 | break; |
| 182350 | 182392 | case 79: /* cmd ::= DROP TABLE ifexists fullname */ |
| 182351 | 182393 | { |
| 182352 | | - sqlite3DropTable(pParse, yymsp[0].minor.yy563, 0, yymsp[-1].minor.yy502); |
| 182394 | + sqlite3DropTable(pParse, yymsp[0].minor.yy203, 0, yymsp[-1].minor.yy144); |
| 182353 | 182395 | } |
| 182354 | 182396 | break; |
| 182355 | 182397 | case 82: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ |
| 182356 | 182398 | { |
| 182357 | | - sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy402, yymsp[0].minor.yy637, yymsp[-7].minor.yy502, yymsp[-5].minor.yy502); |
| 182399 | + sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[0].minor.yy555, yymsp[-7].minor.yy144, yymsp[-5].minor.yy144); |
| 182358 | 182400 | } |
| 182359 | 182401 | break; |
| 182360 | 182402 | case 83: /* cmd ::= DROP VIEW ifexists fullname */ |
| 182361 | 182403 | { |
| 182362 | | - sqlite3DropTable(pParse, yymsp[0].minor.yy563, 1, yymsp[-1].minor.yy502); |
| 182404 | + sqlite3DropTable(pParse, yymsp[0].minor.yy203, 1, yymsp[-1].minor.yy144); |
| 182363 | 182405 | } |
| 182364 | 182406 | break; |
| 182365 | 182407 | case 84: /* cmd ::= select */ |
| 182366 | 182408 | { |
| 182367 | 182409 | SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0, 0}; |
| 182368 | 182410 | if( (pParse->db->mDbFlags & DBFLAG_EncodingFixed)!=0 |
| 182369 | 182411 | || sqlite3ReadSchema(pParse)==SQLITE_OK |
| 182370 | 182412 | ){ |
| 182371 | | - sqlite3Select(pParse, yymsp[0].minor.yy637, &dest); |
| 182413 | + sqlite3Select(pParse, yymsp[0].minor.yy555, &dest); |
| 182372 | 182414 | } |
| 182373 | | - sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy637); |
| 182415 | + sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy555); |
| 182374 | 182416 | } |
| 182375 | 182417 | break; |
| 182376 | 182418 | case 85: /* select ::= WITH wqlist selectnowith */ |
| 182377 | | -{yymsp[-2].minor.yy637 = attachWithToSelect(pParse,yymsp[0].minor.yy637,yymsp[-1].minor.yy125);} |
| 182419 | +{yymsp[-2].minor.yy555 = attachWithToSelect(pParse,yymsp[0].minor.yy555,yymsp[-1].minor.yy59);} |
| 182378 | 182420 | break; |
| 182379 | 182421 | case 86: /* select ::= WITH RECURSIVE wqlist selectnowith */ |
| 182380 | | -{yymsp[-3].minor.yy637 = attachWithToSelect(pParse,yymsp[0].minor.yy637,yymsp[-1].minor.yy125);} |
| 182422 | +{yymsp[-3].minor.yy555 = attachWithToSelect(pParse,yymsp[0].minor.yy555,yymsp[-1].minor.yy59);} |
| 182381 | 182423 | break; |
| 182382 | 182424 | case 87: /* select ::= selectnowith */ |
| 182383 | 182425 | { |
| 182384 | | - Select *p = yymsp[0].minor.yy637; |
| 182426 | + Select *p = yymsp[0].minor.yy555; |
| 182385 | 182427 | if( p ){ |
| 182386 | 182428 | parserDoubleLinkSelect(pParse, p); |
| 182387 | 182429 | } |
| 182388 | 182430 | } |
| 182389 | 182431 | break; |
| 182390 | 182432 | case 88: /* selectnowith ::= selectnowith multiselect_op oneselect */ |
| 182391 | 182433 | { |
| 182392 | | - Select *pRhs = yymsp[0].minor.yy637; |
| 182393 | | - Select *pLhs = yymsp[-2].minor.yy637; |
| 182434 | + Select *pRhs = yymsp[0].minor.yy555; |
| 182435 | + Select *pLhs = yymsp[-2].minor.yy555; |
| 182394 | 182436 | if( pRhs && pRhs->pPrior ){ |
| 182395 | 182437 | SrcList *pFrom; |
| 182396 | 182438 | Token x; |
| 182397 | 182439 | x.n = 0; |
| 182398 | 182440 | parserDoubleLinkSelect(pParse, pRhs); |
| 182399 | 182441 | pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0); |
| 182400 | 182442 | pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0); |
| 182401 | 182443 | } |
| 182402 | 182444 | if( pRhs ){ |
| 182403 | | - pRhs->op = (u8)yymsp[-1].minor.yy502; |
| 182445 | + pRhs->op = (u8)yymsp[-1].minor.yy144; |
| 182404 | 182446 | pRhs->pPrior = pLhs; |
| 182405 | 182447 | if( ALWAYS(pLhs) ) pLhs->selFlags &= ~(u32)SF_MultiValue; |
| 182406 | 182448 | pRhs->selFlags &= ~(u32)SF_MultiValue; |
| 182407 | | - if( yymsp[-1].minor.yy502!=TK_ALL ) pParse->hasCompound = 1; |
| 182449 | + if( yymsp[-1].minor.yy144!=TK_ALL ) pParse->hasCompound = 1; |
| 182408 | 182450 | }else{ |
| 182409 | 182451 | sqlite3SelectDelete(pParse->db, pLhs); |
| 182410 | 182452 | } |
| 182411 | | - yymsp[-2].minor.yy637 = pRhs; |
| 182453 | + yymsp[-2].minor.yy555 = pRhs; |
| 182412 | 182454 | } |
| 182413 | 182455 | break; |
| 182414 | 182456 | case 89: /* multiselect_op ::= UNION */ |
| 182415 | 182457 | case 91: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==91); |
| 182416 | | -{yymsp[0].minor.yy502 = yymsp[0].major; /*A-overwrites-OP*/} |
| 182458 | +{yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-OP*/} |
| 182417 | 182459 | break; |
| 182418 | 182460 | case 90: /* multiselect_op ::= UNION ALL */ |
| 182419 | | -{yymsp[-1].minor.yy502 = TK_ALL;} |
| 182461 | +{yymsp[-1].minor.yy144 = TK_ALL;} |
| 182420 | 182462 | break; |
| 182421 | 182463 | case 92: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ |
| 182422 | 182464 | { |
| 182423 | | - yymsp[-8].minor.yy637 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy402,yymsp[-5].minor.yy563,yymsp[-4].minor.yy590,yymsp[-3].minor.yy402,yymsp[-2].minor.yy590,yymsp[-1].minor.yy402,yymsp[-7].minor.yy502,yymsp[0].minor.yy590); |
| 182465 | + yymsp[-8].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy14,yymsp[-5].minor.yy203,yymsp[-4].minor.yy454,yymsp[-3].minor.yy14,yymsp[-2].minor.yy454,yymsp[-1].minor.yy14,yymsp[-7].minor.yy144,yymsp[0].minor.yy454); |
| 182424 | 182466 | } |
| 182425 | 182467 | break; |
| 182426 | 182468 | case 93: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */ |
| 182427 | 182469 | { |
| 182428 | | - yymsp[-9].minor.yy637 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy402,yymsp[-6].minor.yy563,yymsp[-5].minor.yy590,yymsp[-4].minor.yy402,yymsp[-3].minor.yy590,yymsp[-1].minor.yy402,yymsp[-8].minor.yy502,yymsp[0].minor.yy590); |
| 182429 | | - if( yymsp[-9].minor.yy637 ){ |
| 182430 | | - yymsp[-9].minor.yy637->pWinDefn = yymsp[-2].minor.yy483; |
| 182470 | + yymsp[-9].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy14,yymsp[-6].minor.yy203,yymsp[-5].minor.yy454,yymsp[-4].minor.yy14,yymsp[-3].minor.yy454,yymsp[-1].minor.yy14,yymsp[-8].minor.yy144,yymsp[0].minor.yy454); |
| 182471 | + if( yymsp[-9].minor.yy555 ){ |
| 182472 | + yymsp[-9].minor.yy555->pWinDefn = yymsp[-2].minor.yy211; |
| 182431 | 182473 | }else{ |
| 182432 | | - sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy483); |
| 182474 | + sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy211); |
| 182433 | 182475 | } |
| 182434 | 182476 | } |
| 182435 | 182477 | break; |
| 182436 | 182478 | case 94: /* values ::= VALUES LP nexprlist RP */ |
| 182437 | 182479 | { |
| 182438 | | - yymsp[-3].minor.yy637 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy402,0,0,0,0,0,SF_Values,0); |
| 182480 | + yymsp[-3].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy14,0,0,0,0,0,SF_Values,0); |
| 182439 | 182481 | } |
| 182440 | 182482 | break; |
| 182441 | 182483 | case 95: /* oneselect ::= mvalues */ |
| 182442 | 182484 | { |
| 182443 | | - sqlite3MultiValuesEnd(pParse, yymsp[0].minor.yy637); |
| 182485 | + sqlite3MultiValuesEnd(pParse, yymsp[0].minor.yy555); |
| 182444 | 182486 | } |
| 182445 | 182487 | break; |
| 182446 | 182488 | case 96: /* mvalues ::= values COMMA LP nexprlist RP */ |
| 182447 | 182489 | case 97: /* mvalues ::= mvalues COMMA LP nexprlist RP */ yytestcase(yyruleno==97); |
| 182448 | 182490 | { |
| 182449 | | - yymsp[-4].minor.yy637 = sqlite3MultiValues(pParse, yymsp[-4].minor.yy637, yymsp[-1].minor.yy402); |
| 182491 | + yymsp[-4].minor.yy555 = sqlite3MultiValues(pParse, yymsp[-4].minor.yy555, yymsp[-1].minor.yy14); |
| 182450 | 182492 | } |
| 182451 | 182493 | break; |
| 182452 | 182494 | case 98: /* distinct ::= DISTINCT */ |
| 182453 | | -{yymsp[0].minor.yy502 = SF_Distinct;} |
| 182495 | +{yymsp[0].minor.yy144 = SF_Distinct;} |
| 182454 | 182496 | break; |
| 182455 | 182497 | case 99: /* distinct ::= ALL */ |
| 182456 | | -{yymsp[0].minor.yy502 = SF_All;} |
| 182498 | +{yymsp[0].minor.yy144 = SF_All;} |
| 182457 | 182499 | break; |
| 182458 | 182500 | case 101: /* sclp ::= */ |
| 182459 | 182501 | case 134: /* orderby_opt ::= */ yytestcase(yyruleno==134); |
| 182460 | 182502 | case 144: /* groupby_opt ::= */ yytestcase(yyruleno==144); |
| 182461 | 182503 | case 234: /* exprlist ::= */ yytestcase(yyruleno==234); |
| 182462 | 182504 | case 237: /* paren_exprlist ::= */ yytestcase(yyruleno==237); |
| 182463 | 182505 | case 242: /* eidlist_opt ::= */ yytestcase(yyruleno==242); |
| 182464 | | -{yymsp[1].minor.yy402 = 0;} |
| 182506 | +{yymsp[1].minor.yy14 = 0;} |
| 182465 | 182507 | break; |
| 182466 | 182508 | case 102: /* selcollist ::= sclp scanpt expr scanpt as */ |
| 182467 | 182509 | { |
| 182468 | | - yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy402, yymsp[-2].minor.yy590); |
| 182469 | | - if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy402, &yymsp[0].minor.yy0, 1); |
| 182470 | | - sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy402,yymsp[-3].minor.yy342,yymsp[-1].minor.yy342); |
| 182510 | + yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[-2].minor.yy454); |
| 182511 | + if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy14, &yymsp[0].minor.yy0, 1); |
| 182512 | + sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy14,yymsp[-3].minor.yy168,yymsp[-1].minor.yy168); |
| 182471 | 182513 | } |
| 182472 | 182514 | break; |
| 182473 | 182515 | case 103: /* selcollist ::= sclp scanpt STAR */ |
| 182474 | 182516 | { |
| 182475 | 182517 | Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0); |
| 182476 | 182518 | sqlite3ExprSetErrorOffset(p, (int)(yymsp[0].minor.yy0.z - pParse->zTail)); |
| 182477 | | - yymsp[-2].minor.yy402 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy402, p); |
| 182519 | + yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy14, p); |
| 182478 | 182520 | } |
| 182479 | 182521 | break; |
| 182480 | 182522 | case 104: /* selcollist ::= sclp scanpt nm DOT STAR */ |
| 182481 | 182523 | { |
| 182482 | 182524 | Expr *pRight, *pLeft, *pDot; |
| 182483 | 182525 | pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0); |
| 182484 | 182526 | sqlite3ExprSetErrorOffset(pRight, (int)(yymsp[0].minor.yy0.z - pParse->zTail)); |
| 182485 | 182527 | pLeft = tokenExpr(pParse, TK_ID, yymsp[-2].minor.yy0); |
| 182486 | 182528 | pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight); |
| 182487 | | - yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy402, pDot); |
| 182529 | + yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, pDot); |
| 182488 | 182530 | } |
| 182489 | 182531 | break; |
| 182490 | 182532 | case 105: /* as ::= AS nm */ |
| 182491 | 182533 | case 117: /* dbnm ::= DOT nm */ yytestcase(yyruleno==117); |
| 182492 | 182534 | case 258: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==258); |
| | @@ -182493,54 +182535,54 @@ |
| 182493 | 182535 | case 259: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==259); |
| 182494 | 182536 | {yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;} |
| 182495 | 182537 | break; |
| 182496 | 182538 | case 107: /* from ::= */ |
| 182497 | 182539 | case 110: /* stl_prefix ::= */ yytestcase(yyruleno==110); |
| 182498 | | -{yymsp[1].minor.yy563 = 0;} |
| 182540 | +{yymsp[1].minor.yy203 = 0;} |
| 182499 | 182541 | break; |
| 182500 | 182542 | case 108: /* from ::= FROM seltablist */ |
| 182501 | 182543 | { |
| 182502 | | - yymsp[-1].minor.yy563 = yymsp[0].minor.yy563; |
| 182503 | | - sqlite3SrcListShiftJoinType(pParse,yymsp[-1].minor.yy563); |
| 182544 | + yymsp[-1].minor.yy203 = yymsp[0].minor.yy203; |
| 182545 | + sqlite3SrcListShiftJoinType(pParse,yymsp[-1].minor.yy203); |
| 182504 | 182546 | } |
| 182505 | 182547 | break; |
| 182506 | 182548 | case 109: /* stl_prefix ::= seltablist joinop */ |
| 182507 | 182549 | { |
| 182508 | | - if( ALWAYS(yymsp[-1].minor.yy563 && yymsp[-1].minor.yy563->nSrc>0) ) yymsp[-1].minor.yy563->a[yymsp[-1].minor.yy563->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy502; |
| 182550 | + if( ALWAYS(yymsp[-1].minor.yy203 && yymsp[-1].minor.yy203->nSrc>0) ) yymsp[-1].minor.yy203->a[yymsp[-1].minor.yy203->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy144; |
| 182509 | 182551 | } |
| 182510 | 182552 | break; |
| 182511 | 182553 | case 111: /* seltablist ::= stl_prefix nm dbnm as on_using */ |
| 182512 | 182554 | { |
| 182513 | | - yymsp[-4].minor.yy563 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-4].minor.yy563,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy421); |
| 182555 | + yymsp[-4].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-4].minor.yy203,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269); |
| 182514 | 182556 | } |
| 182515 | 182557 | break; |
| 182516 | 182558 | case 112: /* seltablist ::= stl_prefix nm dbnm as indexed_by on_using */ |
| 182517 | 182559 | { |
| 182518 | | - yymsp[-5].minor.yy563 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy563,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,0,&yymsp[0].minor.yy421); |
| 182519 | | - sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy563, &yymsp[-1].minor.yy0); |
| 182560 | + yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,0,&yymsp[0].minor.yy269); |
| 182561 | + sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy203, &yymsp[-1].minor.yy0); |
| 182520 | 182562 | } |
| 182521 | 182563 | break; |
| 182522 | 182564 | case 113: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */ |
| 182523 | 182565 | { |
| 182524 | | - yymsp[-7].minor.yy563 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-7].minor.yy563,&yymsp[-6].minor.yy0,&yymsp[-5].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy421); |
| 182525 | | - sqlite3SrcListFuncArgs(pParse, yymsp[-7].minor.yy563, yymsp[-3].minor.yy402); |
| 182566 | + yymsp[-7].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-7].minor.yy203,&yymsp[-6].minor.yy0,&yymsp[-5].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269); |
| 182567 | + sqlite3SrcListFuncArgs(pParse, yymsp[-7].minor.yy203, yymsp[-3].minor.yy14); |
| 182526 | 182568 | } |
| 182527 | 182569 | break; |
| 182528 | 182570 | case 114: /* seltablist ::= stl_prefix LP select RP as on_using */ |
| 182529 | 182571 | { |
| 182530 | | - yymsp[-5].minor.yy563 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy563,0,0,&yymsp[-1].minor.yy0,yymsp[-3].minor.yy637,&yymsp[0].minor.yy421); |
| 182572 | + yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,yymsp[-3].minor.yy555,&yymsp[0].minor.yy269); |
| 182531 | 182573 | } |
| 182532 | 182574 | break; |
| 182533 | 182575 | case 115: /* seltablist ::= stl_prefix LP seltablist RP as on_using */ |
| 182534 | 182576 | { |
| 182535 | | - if( yymsp[-5].minor.yy563==0 && yymsp[-1].minor.yy0.n==0 && yymsp[0].minor.yy421.pOn==0 && yymsp[0].minor.yy421.pUsing==0 ){ |
| 182536 | | - yymsp[-5].minor.yy563 = yymsp[-3].minor.yy563; |
| 182537 | | - }else if( ALWAYS(yymsp[-3].minor.yy563!=0) && yymsp[-3].minor.yy563->nSrc==1 ){ |
| 182538 | | - yymsp[-5].minor.yy563 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy563,0,0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy421); |
| 182539 | | - if( yymsp[-5].minor.yy563 ){ |
| 182540 | | - SrcItem *pNew = &yymsp[-5].minor.yy563->a[yymsp[-5].minor.yy563->nSrc-1]; |
| 182541 | | - SrcItem *pOld = yymsp[-3].minor.yy563->a; |
| 182577 | + if( yymsp[-5].minor.yy203==0 && yymsp[-1].minor.yy0.n==0 && yymsp[0].minor.yy269.pOn==0 && yymsp[0].minor.yy269.pUsing==0 ){ |
| 182578 | + yymsp[-5].minor.yy203 = yymsp[-3].minor.yy203; |
| 182579 | + }else if( ALWAYS(yymsp[-3].minor.yy203!=0) && yymsp[-3].minor.yy203->nSrc==1 ){ |
| 182580 | + yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269); |
| 182581 | + if( yymsp[-5].minor.yy203 ){ |
| 182582 | + SrcItem *pNew = &yymsp[-5].minor.yy203->a[yymsp[-5].minor.yy203->nSrc-1]; |
| 182583 | + SrcItem *pOld = yymsp[-3].minor.yy203->a; |
| 182542 | 182584 | assert( pOld->fg.fixedSchema==0 ); |
| 182543 | 182585 | pNew->zName = pOld->zName; |
| 182544 | 182586 | assert( pOld->fg.fixedSchema==0 ); |
| 182545 | 182587 | if( pOld->fg.isSubquery ){ |
| 182546 | 182588 | pNew->fg.isSubquery = 1; |
| | @@ -182561,249 +182603,259 @@ |
| 182561 | 182603 | pOld->fg.isTabFunc = 0; |
| 182562 | 182604 | pNew->fg.isTabFunc = 1; |
| 182563 | 182605 | } |
| 182564 | 182606 | pOld->zName = 0; |
| 182565 | 182607 | } |
| 182566 | | - sqlite3SrcListDelete(pParse->db, yymsp[-3].minor.yy563); |
| 182608 | + sqlite3SrcListDelete(pParse->db, yymsp[-3].minor.yy203); |
| 182567 | 182609 | }else{ |
| 182568 | 182610 | Select *pSubquery; |
| 182569 | | - sqlite3SrcListShiftJoinType(pParse,yymsp[-3].minor.yy563); |
| 182570 | | - pSubquery = sqlite3SelectNew(pParse,0,yymsp[-3].minor.yy563,0,0,0,0,SF_NestedFrom,0); |
| 182571 | | - yymsp[-5].minor.yy563 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy563,0,0,&yymsp[-1].minor.yy0,pSubquery,&yymsp[0].minor.yy421); |
| 182611 | + sqlite3SrcListShiftJoinType(pParse,yymsp[-3].minor.yy203); |
| 182612 | + pSubquery = sqlite3SelectNew(pParse,0,yymsp[-3].minor.yy203,0,0,0,0,SF_NestedFrom,0); |
| 182613 | + yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,pSubquery,&yymsp[0].minor.yy269); |
| 182572 | 182614 | } |
| 182573 | 182615 | } |
| 182574 | 182616 | break; |
| 182575 | 182617 | case 116: /* dbnm ::= */ |
| 182576 | 182618 | case 131: /* indexed_opt ::= */ yytestcase(yyruleno==131); |
| 182577 | 182619 | {yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;} |
| 182578 | 182620 | break; |
| 182579 | 182621 | case 118: /* fullname ::= nm */ |
| 182622 | + case 120: /* xfullname ::= nm */ yytestcase(yyruleno==120); |
| 182580 | 182623 | { |
| 182581 | | - yylhsminor.yy563 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); |
| 182582 | | - if( IN_RENAME_OBJECT && yylhsminor.yy563 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy563->a[0].zName, &yymsp[0].minor.yy0); |
| 182624 | + yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); |
| 182625 | + if( IN_RENAME_OBJECT && yylhsminor.yy203 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[0].minor.yy0); |
| 182583 | 182626 | } |
| 182584 | | - yymsp[0].minor.yy563 = yylhsminor.yy563; |
| 182627 | + yymsp[0].minor.yy203 = yylhsminor.yy203; |
| 182585 | 182628 | break; |
| 182586 | 182629 | case 119: /* fullname ::= nm DOT nm */ |
| 182587 | | -{ |
| 182588 | | - yylhsminor.yy563 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); |
| 182589 | | - if( IN_RENAME_OBJECT && yylhsminor.yy563 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy563->a[0].zName, &yymsp[0].minor.yy0); |
| 182590 | | -} |
| 182591 | | - yymsp[-2].minor.yy563 = yylhsminor.yy563; |
| 182592 | | - break; |
| 182593 | | - case 120: /* xfullname ::= nm */ |
| 182594 | | -{yymsp[0].minor.yy563 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/} |
| 182595 | | - break; |
| 182596 | | - case 121: /* xfullname ::= nm DOT nm */ |
| 182597 | | -{yymsp[-2].minor.yy563 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/} |
| 182598 | | - break; |
| 182599 | | - case 122: /* xfullname ::= nm DOT nm AS nm */ |
| 182600 | | -{ |
| 182601 | | - yymsp[-4].minor.yy563 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/ |
| 182602 | | - if( yymsp[-4].minor.yy563 ) yymsp[-4].minor.yy563->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0); |
| 182603 | | -} |
| 182604 | | - break; |
| 182605 | | - case 123: /* xfullname ::= nm AS nm */ |
| 182606 | | -{ |
| 182607 | | - yymsp[-2].minor.yy563 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/ |
| 182608 | | - if( yymsp[-2].minor.yy563 ) yymsp[-2].minor.yy563->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0); |
| 182609 | | -} |
| 182630 | + case 121: /* xfullname ::= nm DOT nm */ yytestcase(yyruleno==121); |
| 182631 | +{ |
| 182632 | + yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); |
| 182633 | + if( IN_RENAME_OBJECT && yylhsminor.yy203 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[0].minor.yy0); |
| 182634 | +} |
| 182635 | + yymsp[-2].minor.yy203 = yylhsminor.yy203; |
| 182636 | + break; |
| 182637 | + case 122: /* xfullname ::= nm AS nm */ |
| 182638 | +{ |
| 182639 | + yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); |
| 182640 | + if( yylhsminor.yy203 ){ |
| 182641 | + if( IN_RENAME_OBJECT ){ |
| 182642 | + sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[-2].minor.yy0); |
| 182643 | + }else{ |
| 182644 | + yylhsminor.yy203->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0); |
| 182645 | + } |
| 182646 | + } |
| 182647 | +} |
| 182648 | + yymsp[-2].minor.yy203 = yylhsminor.yy203; |
| 182649 | + break; |
| 182650 | + case 123: /* xfullname ::= nm DOT nm AS nm */ |
| 182651 | +{ |
| 182652 | + yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); |
| 182653 | + if( yylhsminor.yy203 ){ |
| 182654 | + if( IN_RENAME_OBJECT ){ |
| 182655 | + sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[-2].minor.yy0); |
| 182656 | + }else{ |
| 182657 | + yylhsminor.yy203->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0); |
| 182658 | + } |
| 182659 | + } |
| 182660 | +} |
| 182661 | + yymsp[-4].minor.yy203 = yylhsminor.yy203; |
| 182610 | 182662 | break; |
| 182611 | 182663 | case 124: /* joinop ::= COMMA|JOIN */ |
| 182612 | | -{ yymsp[0].minor.yy502 = JT_INNER; } |
| 182664 | +{ yymsp[0].minor.yy144 = JT_INNER; } |
| 182613 | 182665 | break; |
| 182614 | 182666 | case 125: /* joinop ::= JOIN_KW JOIN */ |
| 182615 | | -{yymsp[-1].minor.yy502 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /*X-overwrites-A*/} |
| 182667 | +{yymsp[-1].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /*X-overwrites-A*/} |
| 182616 | 182668 | break; |
| 182617 | 182669 | case 126: /* joinop ::= JOIN_KW nm JOIN */ |
| 182618 | | -{yymsp[-2].minor.yy502 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/} |
| 182670 | +{yymsp[-2].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/} |
| 182619 | 182671 | break; |
| 182620 | 182672 | case 127: /* joinop ::= JOIN_KW nm nm JOIN */ |
| 182621 | | -{yymsp[-3].minor.yy502 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/} |
| 182673 | +{yymsp[-3].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/} |
| 182622 | 182674 | break; |
| 182623 | 182675 | case 128: /* on_using ::= ON expr */ |
| 182624 | | -{yymsp[-1].minor.yy421.pOn = yymsp[0].minor.yy590; yymsp[-1].minor.yy421.pUsing = 0;} |
| 182676 | +{yymsp[-1].minor.yy269.pOn = yymsp[0].minor.yy454; yymsp[-1].minor.yy269.pUsing = 0;} |
| 182625 | 182677 | break; |
| 182626 | 182678 | case 129: /* on_using ::= USING LP idlist RP */ |
| 182627 | | -{yymsp[-3].minor.yy421.pOn = 0; yymsp[-3].minor.yy421.pUsing = yymsp[-1].minor.yy204;} |
| 182679 | +{yymsp[-3].minor.yy269.pOn = 0; yymsp[-3].minor.yy269.pUsing = yymsp[-1].minor.yy132;} |
| 182628 | 182680 | break; |
| 182629 | 182681 | case 130: /* on_using ::= */ |
| 182630 | | -{yymsp[1].minor.yy421.pOn = 0; yymsp[1].minor.yy421.pUsing = 0;} |
| 182682 | +{yymsp[1].minor.yy269.pOn = 0; yymsp[1].minor.yy269.pUsing = 0;} |
| 182631 | 182683 | break; |
| 182632 | 182684 | case 132: /* indexed_by ::= INDEXED BY nm */ |
| 182633 | 182685 | {yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;} |
| 182634 | 182686 | break; |
| 182635 | 182687 | case 133: /* indexed_by ::= NOT INDEXED */ |
| 182636 | 182688 | {yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;} |
| 182637 | 182689 | break; |
| 182638 | 182690 | case 135: /* orderby_opt ::= ORDER BY sortlist */ |
| 182639 | 182691 | case 145: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==145); |
| 182640 | | -{yymsp[-2].minor.yy402 = yymsp[0].minor.yy402;} |
| 182692 | +{yymsp[-2].minor.yy14 = yymsp[0].minor.yy14;} |
| 182641 | 182693 | break; |
| 182642 | 182694 | case 136: /* sortlist ::= sortlist COMMA expr sortorder nulls */ |
| 182643 | 182695 | { |
| 182644 | | - yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy402,yymsp[-2].minor.yy590); |
| 182645 | | - sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy402,yymsp[-1].minor.yy502,yymsp[0].minor.yy502); |
| 182696 | + yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14,yymsp[-2].minor.yy454); |
| 182697 | + sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy14,yymsp[-1].minor.yy144,yymsp[0].minor.yy144); |
| 182646 | 182698 | } |
| 182647 | 182699 | break; |
| 182648 | 182700 | case 137: /* sortlist ::= expr sortorder nulls */ |
| 182649 | 182701 | { |
| 182650 | | - yymsp[-2].minor.yy402 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy590); /*A-overwrites-Y*/ |
| 182651 | | - sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy402,yymsp[-1].minor.yy502,yymsp[0].minor.yy502); |
| 182702 | + yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy454); /*A-overwrites-Y*/ |
| 182703 | + sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy14,yymsp[-1].minor.yy144,yymsp[0].minor.yy144); |
| 182652 | 182704 | } |
| 182653 | 182705 | break; |
| 182654 | 182706 | case 138: /* sortorder ::= ASC */ |
| 182655 | | -{yymsp[0].minor.yy502 = SQLITE_SO_ASC;} |
| 182707 | +{yymsp[0].minor.yy144 = SQLITE_SO_ASC;} |
| 182656 | 182708 | break; |
| 182657 | 182709 | case 139: /* sortorder ::= DESC */ |
| 182658 | | -{yymsp[0].minor.yy502 = SQLITE_SO_DESC;} |
| 182710 | +{yymsp[0].minor.yy144 = SQLITE_SO_DESC;} |
| 182659 | 182711 | break; |
| 182660 | 182712 | case 140: /* sortorder ::= */ |
| 182661 | 182713 | case 143: /* nulls ::= */ yytestcase(yyruleno==143); |
| 182662 | | -{yymsp[1].minor.yy502 = SQLITE_SO_UNDEFINED;} |
| 182714 | +{yymsp[1].minor.yy144 = SQLITE_SO_UNDEFINED;} |
| 182663 | 182715 | break; |
| 182664 | 182716 | case 141: /* nulls ::= NULLS FIRST */ |
| 182665 | | -{yymsp[-1].minor.yy502 = SQLITE_SO_ASC;} |
| 182717 | +{yymsp[-1].minor.yy144 = SQLITE_SO_ASC;} |
| 182666 | 182718 | break; |
| 182667 | 182719 | case 142: /* nulls ::= NULLS LAST */ |
| 182668 | | -{yymsp[-1].minor.yy502 = SQLITE_SO_DESC;} |
| 182720 | +{yymsp[-1].minor.yy144 = SQLITE_SO_DESC;} |
| 182669 | 182721 | break; |
| 182670 | 182722 | case 146: /* having_opt ::= */ |
| 182671 | 182723 | case 148: /* limit_opt ::= */ yytestcase(yyruleno==148); |
| 182672 | 182724 | case 153: /* where_opt ::= */ yytestcase(yyruleno==153); |
| 182673 | 182725 | case 155: /* where_opt_ret ::= */ yytestcase(yyruleno==155); |
| 182674 | 182726 | case 232: /* case_else ::= */ yytestcase(yyruleno==232); |
| 182675 | 182727 | case 233: /* case_operand ::= */ yytestcase(yyruleno==233); |
| 182676 | 182728 | case 252: /* vinto ::= */ yytestcase(yyruleno==252); |
| 182677 | | -{yymsp[1].minor.yy590 = 0;} |
| 182729 | +{yymsp[1].minor.yy454 = 0;} |
| 182678 | 182730 | break; |
| 182679 | 182731 | case 147: /* having_opt ::= HAVING expr */ |
| 182680 | 182732 | case 154: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==154); |
| 182681 | 182733 | case 156: /* where_opt_ret ::= WHERE expr */ yytestcase(yyruleno==156); |
| 182682 | 182734 | case 231: /* case_else ::= ELSE expr */ yytestcase(yyruleno==231); |
| 182683 | 182735 | case 251: /* vinto ::= INTO expr */ yytestcase(yyruleno==251); |
| 182684 | | -{yymsp[-1].minor.yy590 = yymsp[0].minor.yy590;} |
| 182736 | +{yymsp[-1].minor.yy454 = yymsp[0].minor.yy454;} |
| 182685 | 182737 | break; |
| 182686 | 182738 | case 149: /* limit_opt ::= LIMIT expr */ |
| 182687 | | -{yymsp[-1].minor.yy590 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy590,0);} |
| 182739 | +{yymsp[-1].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy454,0);} |
| 182688 | 182740 | break; |
| 182689 | 182741 | case 150: /* limit_opt ::= LIMIT expr OFFSET expr */ |
| 182690 | | -{yymsp[-3].minor.yy590 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy590,yymsp[0].minor.yy590);} |
| 182742 | +{yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);} |
| 182691 | 182743 | break; |
| 182692 | 182744 | case 151: /* limit_opt ::= LIMIT expr COMMA expr */ |
| 182693 | | -{yymsp[-3].minor.yy590 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy590,yymsp[-2].minor.yy590);} |
| 182745 | +{yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy454,yymsp[-2].minor.yy454);} |
| 182694 | 182746 | break; |
| 182695 | 182747 | case 152: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */ |
| 182696 | 182748 | { |
| 182697 | | - sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy563, &yymsp[-1].minor.yy0); |
| 182698 | | - sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy563,yymsp[0].minor.yy590,0,0); |
| 182749 | + sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy203, &yymsp[-1].minor.yy0); |
| 182750 | + sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy203,yymsp[0].minor.yy454,0,0); |
| 182699 | 182751 | } |
| 182700 | 182752 | break; |
| 182701 | 182753 | case 157: /* where_opt_ret ::= RETURNING selcollist */ |
| 182702 | | -{sqlite3AddReturning(pParse,yymsp[0].minor.yy402); yymsp[-1].minor.yy590 = 0;} |
| 182754 | +{sqlite3AddReturning(pParse,yymsp[0].minor.yy14); yymsp[-1].minor.yy454 = 0;} |
| 182703 | 182755 | break; |
| 182704 | 182756 | case 158: /* where_opt_ret ::= WHERE expr RETURNING selcollist */ |
| 182705 | | -{sqlite3AddReturning(pParse,yymsp[0].minor.yy402); yymsp[-3].minor.yy590 = yymsp[-2].minor.yy590;} |
| 182757 | +{sqlite3AddReturning(pParse,yymsp[0].minor.yy14); yymsp[-3].minor.yy454 = yymsp[-2].minor.yy454;} |
| 182706 | 182758 | break; |
| 182707 | 182759 | case 159: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */ |
| 182708 | 182760 | { |
| 182709 | | - sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy563, &yymsp[-4].minor.yy0); |
| 182710 | | - sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy402,"set list"); |
| 182711 | | - if( yymsp[-1].minor.yy563 ){ |
| 182712 | | - SrcList *pFromClause = yymsp[-1].minor.yy563; |
| 182761 | + sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy203, &yymsp[-4].minor.yy0); |
| 182762 | + sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy14,"set list"); |
| 182763 | + if( yymsp[-1].minor.yy203 ){ |
| 182764 | + SrcList *pFromClause = yymsp[-1].minor.yy203; |
| 182713 | 182765 | if( pFromClause->nSrc>1 ){ |
| 182714 | 182766 | Select *pSubquery; |
| 182715 | 182767 | Token as; |
| 182716 | 182768 | pSubquery = sqlite3SelectNew(pParse,0,pFromClause,0,0,0,0,SF_NestedFrom,0); |
| 182717 | 182769 | as.n = 0; |
| 182718 | 182770 | as.z = 0; |
| 182719 | 182771 | pFromClause = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&as,pSubquery,0); |
| 182720 | 182772 | } |
| 182721 | | - yymsp[-5].minor.yy563 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy563, pFromClause); |
| 182773 | + yymsp[-5].minor.yy203 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy203, pFromClause); |
| 182722 | 182774 | } |
| 182723 | | - sqlite3Update(pParse,yymsp[-5].minor.yy563,yymsp[-2].minor.yy402,yymsp[0].minor.yy590,yymsp[-6].minor.yy502,0,0,0); |
| 182775 | + sqlite3Update(pParse,yymsp[-5].minor.yy203,yymsp[-2].minor.yy14,yymsp[0].minor.yy454,yymsp[-6].minor.yy144,0,0,0); |
| 182724 | 182776 | } |
| 182725 | 182777 | break; |
| 182726 | 182778 | case 160: /* setlist ::= setlist COMMA nm EQ expr */ |
| 182727 | 182779 | { |
| 182728 | | - yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy402, yymsp[0].minor.yy590); |
| 182729 | | - sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy402, &yymsp[-2].minor.yy0, 1); |
| 182780 | + yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[0].minor.yy454); |
| 182781 | + sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy14, &yymsp[-2].minor.yy0, 1); |
| 182730 | 182782 | } |
| 182731 | 182783 | break; |
| 182732 | 182784 | case 161: /* setlist ::= setlist COMMA LP idlist RP EQ expr */ |
| 182733 | 182785 | { |
| 182734 | | - yymsp[-6].minor.yy402 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy402, yymsp[-3].minor.yy204, yymsp[0].minor.yy590); |
| 182786 | + yymsp[-6].minor.yy14 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy14, yymsp[-3].minor.yy132, yymsp[0].minor.yy454); |
| 182735 | 182787 | } |
| 182736 | 182788 | break; |
| 182737 | 182789 | case 162: /* setlist ::= nm EQ expr */ |
| 182738 | 182790 | { |
| 182739 | | - yylhsminor.yy402 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy590); |
| 182740 | | - sqlite3ExprListSetName(pParse, yylhsminor.yy402, &yymsp[-2].minor.yy0, 1); |
| 182791 | + yylhsminor.yy14 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy454); |
| 182792 | + sqlite3ExprListSetName(pParse, yylhsminor.yy14, &yymsp[-2].minor.yy0, 1); |
| 182741 | 182793 | } |
| 182742 | | - yymsp[-2].minor.yy402 = yylhsminor.yy402; |
| 182794 | + yymsp[-2].minor.yy14 = yylhsminor.yy14; |
| 182743 | 182795 | break; |
| 182744 | 182796 | case 163: /* setlist ::= LP idlist RP EQ expr */ |
| 182745 | 182797 | { |
| 182746 | | - yymsp[-4].minor.yy402 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy204, yymsp[0].minor.yy590); |
| 182798 | + yymsp[-4].minor.yy14 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy132, yymsp[0].minor.yy454); |
| 182747 | 182799 | } |
| 182748 | 182800 | break; |
| 182749 | 182801 | case 164: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */ |
| 182750 | 182802 | { |
| 182751 | | - sqlite3Insert(pParse, yymsp[-3].minor.yy563, yymsp[-1].minor.yy637, yymsp[-2].minor.yy204, yymsp[-5].minor.yy502, yymsp[0].minor.yy403); |
| 182803 | + sqlite3Insert(pParse, yymsp[-3].minor.yy203, yymsp[-1].minor.yy555, yymsp[-2].minor.yy132, yymsp[-5].minor.yy144, yymsp[0].minor.yy122); |
| 182752 | 182804 | } |
| 182753 | 182805 | break; |
| 182754 | 182806 | case 165: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */ |
| 182755 | 182807 | { |
| 182756 | | - sqlite3Insert(pParse, yymsp[-4].minor.yy563, 0, yymsp[-3].minor.yy204, yymsp[-6].minor.yy502, 0); |
| 182808 | + sqlite3Insert(pParse, yymsp[-4].minor.yy203, 0, yymsp[-3].minor.yy132, yymsp[-6].minor.yy144, 0); |
| 182757 | 182809 | } |
| 182758 | 182810 | break; |
| 182759 | 182811 | case 166: /* upsert ::= */ |
| 182760 | | -{ yymsp[1].minor.yy403 = 0; } |
| 182812 | +{ yymsp[1].minor.yy122 = 0; } |
| 182761 | 182813 | break; |
| 182762 | 182814 | case 167: /* upsert ::= RETURNING selcollist */ |
| 182763 | | -{ yymsp[-1].minor.yy403 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy402); } |
| 182815 | +{ yymsp[-1].minor.yy122 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy14); } |
| 182764 | 182816 | break; |
| 182765 | 182817 | case 168: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */ |
| 182766 | | -{ yymsp[-11].minor.yy403 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy402,yymsp[-6].minor.yy590,yymsp[-2].minor.yy402,yymsp[-1].minor.yy590,yymsp[0].minor.yy403);} |
| 182818 | +{ yymsp[-11].minor.yy122 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy14,yymsp[-6].minor.yy454,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454,yymsp[0].minor.yy122);} |
| 182767 | 182819 | break; |
| 182768 | 182820 | case 169: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */ |
| 182769 | | -{ yymsp[-8].minor.yy403 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy402,yymsp[-3].minor.yy590,0,0,yymsp[0].minor.yy403); } |
| 182821 | +{ yymsp[-8].minor.yy122 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy14,yymsp[-3].minor.yy454,0,0,yymsp[0].minor.yy122); } |
| 182770 | 182822 | break; |
| 182771 | 182823 | case 170: /* upsert ::= ON CONFLICT DO NOTHING returning */ |
| 182772 | | -{ yymsp[-4].minor.yy403 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); } |
| 182824 | +{ yymsp[-4].minor.yy122 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); } |
| 182773 | 182825 | break; |
| 182774 | 182826 | case 171: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */ |
| 182775 | | -{ yymsp[-7].minor.yy403 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy402,yymsp[-1].minor.yy590,0);} |
| 182827 | +{ yymsp[-7].minor.yy122 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454,0);} |
| 182776 | 182828 | break; |
| 182777 | 182829 | case 172: /* returning ::= RETURNING selcollist */ |
| 182778 | | -{sqlite3AddReturning(pParse,yymsp[0].minor.yy402);} |
| 182830 | +{sqlite3AddReturning(pParse,yymsp[0].minor.yy14);} |
| 182779 | 182831 | break; |
| 182780 | 182832 | case 175: /* idlist_opt ::= */ |
| 182781 | | -{yymsp[1].minor.yy204 = 0;} |
| 182833 | +{yymsp[1].minor.yy132 = 0;} |
| 182782 | 182834 | break; |
| 182783 | 182835 | case 176: /* idlist_opt ::= LP idlist RP */ |
| 182784 | | -{yymsp[-2].minor.yy204 = yymsp[-1].minor.yy204;} |
| 182836 | +{yymsp[-2].minor.yy132 = yymsp[-1].minor.yy132;} |
| 182785 | 182837 | break; |
| 182786 | 182838 | case 177: /* idlist ::= idlist COMMA nm */ |
| 182787 | | -{yymsp[-2].minor.yy204 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy204,&yymsp[0].minor.yy0);} |
| 182839 | +{yymsp[-2].minor.yy132 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy132,&yymsp[0].minor.yy0);} |
| 182788 | 182840 | break; |
| 182789 | 182841 | case 178: /* idlist ::= nm */ |
| 182790 | | -{yymsp[0].minor.yy204 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/} |
| 182842 | +{yymsp[0].minor.yy132 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/} |
| 182791 | 182843 | break; |
| 182792 | 182844 | case 179: /* expr ::= LP expr RP */ |
| 182793 | | -{yymsp[-2].minor.yy590 = yymsp[-1].minor.yy590;} |
| 182845 | +{yymsp[-2].minor.yy454 = yymsp[-1].minor.yy454;} |
| 182794 | 182846 | break; |
| 182795 | 182847 | case 180: /* expr ::= ID|INDEXED|JOIN_KW */ |
| 182796 | | -{yymsp[0].minor.yy590=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/} |
| 182848 | +{yymsp[0].minor.yy454=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/} |
| 182797 | 182849 | break; |
| 182798 | 182850 | case 181: /* expr ::= nm DOT nm */ |
| 182799 | 182851 | { |
| 182800 | 182852 | Expr *temp1 = tokenExpr(pParse,TK_ID,yymsp[-2].minor.yy0); |
| 182801 | 182853 | Expr *temp2 = tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); |
| 182802 | | - yylhsminor.yy590 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2); |
| 182854 | + yylhsminor.yy454 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2); |
| 182803 | 182855 | } |
| 182804 | | - yymsp[-2].minor.yy590 = yylhsminor.yy590; |
| 182856 | + yymsp[-2].minor.yy454 = yylhsminor.yy454; |
| 182805 | 182857 | break; |
| 182806 | 182858 | case 182: /* expr ::= nm DOT nm DOT nm */ |
| 182807 | 182859 | { |
| 182808 | 182860 | Expr *temp1 = tokenExpr(pParse,TK_ID,yymsp[-4].minor.yy0); |
| 182809 | 182861 | Expr *temp2 = tokenExpr(pParse,TK_ID,yymsp[-2].minor.yy0); |
| | @@ -182810,236 +182862,237 @@ |
| 182810 | 182862 | Expr *temp3 = tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); |
| 182811 | 182863 | Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3); |
| 182812 | 182864 | if( IN_RENAME_OBJECT ){ |
| 182813 | 182865 | sqlite3RenameTokenRemap(pParse, 0, temp1); |
| 182814 | 182866 | } |
| 182815 | | - yylhsminor.yy590 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4); |
| 182867 | + yylhsminor.yy454 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4); |
| 182816 | 182868 | } |
| 182817 | | - yymsp[-4].minor.yy590 = yylhsminor.yy590; |
| 182869 | + yymsp[-4].minor.yy454 = yylhsminor.yy454; |
| 182818 | 182870 | break; |
| 182819 | 182871 | case 183: /* term ::= NULL|FLOAT|BLOB */ |
| 182820 | 182872 | case 184: /* term ::= STRING */ yytestcase(yyruleno==184); |
| 182821 | | -{yymsp[0].minor.yy590=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/} |
| 182873 | +{yymsp[0].minor.yy454=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/} |
| 182822 | 182874 | break; |
| 182823 | 182875 | case 185: /* term ::= INTEGER */ |
| 182824 | 182876 | { |
| 182825 | | - yylhsminor.yy590 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1); |
| 182826 | | - if( yylhsminor.yy590 ) yylhsminor.yy590->w.iOfst = (int)(yymsp[0].minor.yy0.z - pParse->zTail); |
| 182877 | + int iValue; |
| 182878 | + if( sqlite3GetInt32(yymsp[0].minor.yy0.z, &iValue)==0 ){ |
| 182879 | + yylhsminor.yy454 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 0); |
| 182880 | + }else{ |
| 182881 | + yylhsminor.yy454 = sqlite3ExprInt32(pParse->db, iValue); |
| 182882 | + } |
| 182883 | + if( yylhsminor.yy454 ) yylhsminor.yy454->w.iOfst = (int)(yymsp[0].minor.yy0.z - pParse->zTail); |
| 182827 | 182884 | } |
| 182828 | | - yymsp[0].minor.yy590 = yylhsminor.yy590; |
| 182885 | + yymsp[0].minor.yy454 = yylhsminor.yy454; |
| 182829 | 182886 | break; |
| 182830 | 182887 | case 186: /* expr ::= VARIABLE */ |
| 182831 | 182888 | { |
| 182832 | 182889 | if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){ |
| 182833 | 182890 | u32 n = yymsp[0].minor.yy0.n; |
| 182834 | | - yymsp[0].minor.yy590 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0); |
| 182835 | | - sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy590, n); |
| 182891 | + yymsp[0].minor.yy454 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0); |
| 182892 | + sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy454, n); |
| 182836 | 182893 | }else{ |
| 182837 | 182894 | /* When doing a nested parse, one can include terms in an expression |
| 182838 | 182895 | ** that look like this: #1 #2 ... These terms refer to registers |
| 182839 | 182896 | ** in the virtual machine. #N is the N-th register. */ |
| 182840 | 182897 | Token t = yymsp[0].minor.yy0; /*A-overwrites-X*/ |
| 182841 | 182898 | assert( t.n>=2 ); |
| 182842 | 182899 | if( pParse->nested==0 ){ |
| 182843 | 182900 | parserSyntaxError(pParse, &t); |
| 182844 | | - yymsp[0].minor.yy590 = 0; |
| 182901 | + yymsp[0].minor.yy454 = 0; |
| 182845 | 182902 | }else{ |
| 182846 | | - yymsp[0].minor.yy590 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0); |
| 182847 | | - if( yymsp[0].minor.yy590 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy590->iTable); |
| 182903 | + yymsp[0].minor.yy454 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0); |
| 182904 | + if( yymsp[0].minor.yy454 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy454->iTable); |
| 182848 | 182905 | } |
| 182849 | 182906 | } |
| 182850 | 182907 | } |
| 182851 | 182908 | break; |
| 182852 | 182909 | case 187: /* expr ::= expr COLLATE ID|STRING */ |
| 182853 | 182910 | { |
| 182854 | | - yymsp[-2].minor.yy590 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy590, &yymsp[0].minor.yy0, 1); |
| 182911 | + yymsp[-2].minor.yy454 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy454, &yymsp[0].minor.yy0, 1); |
| 182855 | 182912 | } |
| 182856 | 182913 | break; |
| 182857 | 182914 | case 188: /* expr ::= CAST LP expr AS typetoken RP */ |
| 182858 | 182915 | { |
| 182859 | | - yymsp[-5].minor.yy590 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1); |
| 182860 | | - sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy590, yymsp[-3].minor.yy590, 0); |
| 182916 | + yymsp[-5].minor.yy454 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1); |
| 182917 | + sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy454, yymsp[-3].minor.yy454, 0); |
| 182861 | 182918 | } |
| 182862 | 182919 | break; |
| 182863 | 182920 | case 189: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */ |
| 182864 | 182921 | { |
| 182865 | | - yylhsminor.yy590 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy402, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy502); |
| 182922 | + yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy144); |
| 182866 | 182923 | } |
| 182867 | | - yymsp[-4].minor.yy590 = yylhsminor.yy590; |
| 182924 | + yymsp[-4].minor.yy454 = yylhsminor.yy454; |
| 182868 | 182925 | break; |
| 182869 | 182926 | case 190: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */ |
| 182870 | 182927 | { |
| 182871 | | - yylhsminor.yy590 = sqlite3ExprFunction(pParse, yymsp[-4].minor.yy402, &yymsp[-7].minor.yy0, yymsp[-5].minor.yy502); |
| 182872 | | - sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy590, yymsp[-1].minor.yy402); |
| 182928 | + yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-4].minor.yy14, &yymsp[-7].minor.yy0, yymsp[-5].minor.yy144); |
| 182929 | + sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy454, yymsp[-1].minor.yy14); |
| 182873 | 182930 | } |
| 182874 | | - yymsp[-7].minor.yy590 = yylhsminor.yy590; |
| 182931 | + yymsp[-7].minor.yy454 = yylhsminor.yy454; |
| 182875 | 182932 | break; |
| 182876 | 182933 | case 191: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP */ |
| 182877 | 182934 | { |
| 182878 | | - yylhsminor.yy590 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0); |
| 182935 | + yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0); |
| 182879 | 182936 | } |
| 182880 | | - yymsp[-3].minor.yy590 = yylhsminor.yy590; |
| 182937 | + yymsp[-3].minor.yy454 = yylhsminor.yy454; |
| 182881 | 182938 | break; |
| 182882 | 182939 | case 192: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */ |
| 182883 | 182940 | { |
| 182884 | | - yylhsminor.yy590 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy402, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy502); |
| 182885 | | - sqlite3WindowAttach(pParse, yylhsminor.yy590, yymsp[0].minor.yy483); |
| 182941 | + yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy14, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy144); |
| 182942 | + sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211); |
| 182886 | 182943 | } |
| 182887 | | - yymsp[-5].minor.yy590 = yylhsminor.yy590; |
| 182944 | + yymsp[-5].minor.yy454 = yylhsminor.yy454; |
| 182888 | 182945 | break; |
| 182889 | 182946 | case 193: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */ |
| 182890 | 182947 | { |
| 182891 | | - yylhsminor.yy590 = sqlite3ExprFunction(pParse, yymsp[-5].minor.yy402, &yymsp[-8].minor.yy0, yymsp[-6].minor.yy502); |
| 182892 | | - sqlite3WindowAttach(pParse, yylhsminor.yy590, yymsp[0].minor.yy483); |
| 182893 | | - sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy590, yymsp[-2].minor.yy402); |
| 182948 | + yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-5].minor.yy14, &yymsp[-8].minor.yy0, yymsp[-6].minor.yy144); |
| 182949 | + sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211); |
| 182950 | + sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy454, yymsp[-2].minor.yy14); |
| 182894 | 182951 | } |
| 182895 | | - yymsp[-8].minor.yy590 = yylhsminor.yy590; |
| 182952 | + yymsp[-8].minor.yy454 = yylhsminor.yy454; |
| 182896 | 182953 | break; |
| 182897 | 182954 | case 194: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */ |
| 182898 | 182955 | { |
| 182899 | | - yylhsminor.yy590 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0); |
| 182900 | | - sqlite3WindowAttach(pParse, yylhsminor.yy590, yymsp[0].minor.yy483); |
| 182956 | + yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0); |
| 182957 | + sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211); |
| 182901 | 182958 | } |
| 182902 | | - yymsp[-4].minor.yy590 = yylhsminor.yy590; |
| 182959 | + yymsp[-4].minor.yy454 = yylhsminor.yy454; |
| 182903 | 182960 | break; |
| 182904 | 182961 | case 195: /* term ::= CTIME_KW */ |
| 182905 | 182962 | { |
| 182906 | | - yylhsminor.yy590 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0); |
| 182963 | + yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0); |
| 182907 | 182964 | } |
| 182908 | | - yymsp[0].minor.yy590 = yylhsminor.yy590; |
| 182965 | + yymsp[0].minor.yy454 = yylhsminor.yy454; |
| 182909 | 182966 | break; |
| 182910 | 182967 | case 196: /* expr ::= LP nexprlist COMMA expr RP */ |
| 182911 | 182968 | { |
| 182912 | | - ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy402, yymsp[-1].minor.yy590); |
| 182913 | | - yymsp[-4].minor.yy590 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0); |
| 182914 | | - if( yymsp[-4].minor.yy590 ){ |
| 182915 | | - yymsp[-4].minor.yy590->x.pList = pList; |
| 182969 | + ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy14, yymsp[-1].minor.yy454); |
| 182970 | + yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0); |
| 182971 | + if( yymsp[-4].minor.yy454 ){ |
| 182972 | + yymsp[-4].minor.yy454->x.pList = pList; |
| 182916 | 182973 | if( ALWAYS(pList->nExpr) ){ |
| 182917 | | - yymsp[-4].minor.yy590->flags |= pList->a[0].pExpr->flags & EP_Propagate; |
| 182974 | + yymsp[-4].minor.yy454->flags |= pList->a[0].pExpr->flags & EP_Propagate; |
| 182918 | 182975 | } |
| 182919 | 182976 | }else{ |
| 182920 | 182977 | sqlite3ExprListDelete(pParse->db, pList); |
| 182921 | 182978 | } |
| 182922 | 182979 | } |
| 182923 | 182980 | break; |
| 182924 | 182981 | case 197: /* expr ::= expr AND expr */ |
| 182925 | | -{yymsp[-2].minor.yy590=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy590,yymsp[0].minor.yy590);} |
| 182982 | +{yymsp[-2].minor.yy454=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);} |
| 182926 | 182983 | break; |
| 182927 | 182984 | case 198: /* expr ::= expr OR expr */ |
| 182928 | 182985 | case 199: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==199); |
| 182929 | 182986 | case 200: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==200); |
| 182930 | 182987 | case 201: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==201); |
| 182931 | 182988 | case 202: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==202); |
| 182932 | 182989 | case 203: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==203); |
| 182933 | 182990 | case 204: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==204); |
| 182934 | | -{yymsp[-2].minor.yy590=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy590,yymsp[0].minor.yy590);} |
| 182991 | +{yymsp[-2].minor.yy454=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);} |
| 182935 | 182992 | break; |
| 182936 | 182993 | case 205: /* likeop ::= NOT LIKE_KW|MATCH */ |
| 182937 | 182994 | {yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n|=0x80000000; /*yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0*/} |
| 182938 | 182995 | break; |
| 182939 | 182996 | case 206: /* expr ::= expr likeop expr */ |
| 182940 | 182997 | { |
| 182941 | 182998 | ExprList *pList; |
| 182942 | 182999 | int bNot = yymsp[-1].minor.yy0.n & 0x80000000; |
| 182943 | 183000 | yymsp[-1].minor.yy0.n &= 0x7fffffff; |
| 182944 | | - pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy590); |
| 182945 | | - pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy590); |
| 182946 | | - yymsp[-2].minor.yy590 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0); |
| 182947 | | - if( bNot ) yymsp[-2].minor.yy590 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy590, 0); |
| 182948 | | - if( yymsp[-2].minor.yy590 ) yymsp[-2].minor.yy590->flags |= EP_InfixFunc; |
| 183001 | + pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy454); |
| 183002 | + pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy454); |
| 183003 | + yymsp[-2].minor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0); |
| 183004 | + if( bNot ) yymsp[-2].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy454, 0); |
| 183005 | + if( yymsp[-2].minor.yy454 ) yymsp[-2].minor.yy454->flags |= EP_InfixFunc; |
| 182949 | 183006 | } |
| 182950 | 183007 | break; |
| 182951 | 183008 | case 207: /* expr ::= expr likeop expr ESCAPE expr */ |
| 182952 | 183009 | { |
| 182953 | 183010 | ExprList *pList; |
| 182954 | 183011 | int bNot = yymsp[-3].minor.yy0.n & 0x80000000; |
| 182955 | 183012 | yymsp[-3].minor.yy0.n &= 0x7fffffff; |
| 182956 | | - pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy590); |
| 182957 | | - pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy590); |
| 182958 | | - pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy590); |
| 182959 | | - yymsp[-4].minor.yy590 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0); |
| 182960 | | - if( bNot ) yymsp[-4].minor.yy590 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy590, 0); |
| 182961 | | - if( yymsp[-4].minor.yy590 ) yymsp[-4].minor.yy590->flags |= EP_InfixFunc; |
| 183013 | + pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454); |
| 183014 | + pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy454); |
| 183015 | + pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy454); |
| 183016 | + yymsp[-4].minor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0); |
| 183017 | + if( bNot ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0); |
| 183018 | + if( yymsp[-4].minor.yy454 ) yymsp[-4].minor.yy454->flags |= EP_InfixFunc; |
| 182962 | 183019 | } |
| 182963 | 183020 | break; |
| 182964 | 183021 | case 208: /* expr ::= expr ISNULL|NOTNULL */ |
| 182965 | | -{yymsp[-1].minor.yy590 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy590,0);} |
| 183022 | +{yymsp[-1].minor.yy454 = sqlite3PExprIsNull(pParse,yymsp[0].major,yymsp[-1].minor.yy454);} |
| 182966 | 183023 | break; |
| 182967 | 183024 | case 209: /* expr ::= expr NOT NULL */ |
| 182968 | | -{yymsp[-2].minor.yy590 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy590,0);} |
| 183025 | +{yymsp[-2].minor.yy454 = sqlite3PExprIsNull(pParse,TK_NOTNULL,yymsp[-2].minor.yy454);} |
| 182969 | 183026 | break; |
| 182970 | 183027 | case 210: /* expr ::= expr IS expr */ |
| 182971 | 183028 | { |
| 182972 | | - yymsp[-2].minor.yy590 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy590,yymsp[0].minor.yy590); |
| 182973 | | - binaryToUnaryIfNull(pParse, yymsp[0].minor.yy590, yymsp[-2].minor.yy590, TK_ISNULL); |
| 183029 | + yymsp[-2].minor.yy454 = sqlite3PExprIs(pParse, TK_IS, yymsp[-2].minor.yy454, yymsp[0].minor.yy454); |
| 182974 | 183030 | } |
| 182975 | 183031 | break; |
| 182976 | 183032 | case 211: /* expr ::= expr IS NOT expr */ |
| 182977 | 183033 | { |
| 182978 | | - yymsp[-3].minor.yy590 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy590,yymsp[0].minor.yy590); |
| 182979 | | - binaryToUnaryIfNull(pParse, yymsp[0].minor.yy590, yymsp[-3].minor.yy590, TK_NOTNULL); |
| 183034 | + yymsp[-3].minor.yy454 = sqlite3PExprIs(pParse, TK_ISNOT, yymsp[-3].minor.yy454, yymsp[0].minor.yy454); |
| 182980 | 183035 | } |
| 182981 | 183036 | break; |
| 182982 | 183037 | case 212: /* expr ::= expr IS NOT DISTINCT FROM expr */ |
| 182983 | 183038 | { |
| 182984 | | - yymsp[-5].minor.yy590 = sqlite3PExpr(pParse,TK_IS,yymsp[-5].minor.yy590,yymsp[0].minor.yy590); |
| 182985 | | - binaryToUnaryIfNull(pParse, yymsp[0].minor.yy590, yymsp[-5].minor.yy590, TK_ISNULL); |
| 183039 | + yymsp[-5].minor.yy454 = sqlite3PExprIs(pParse, TK_IS, yymsp[-5].minor.yy454, yymsp[0].minor.yy454); |
| 182986 | 183040 | } |
| 182987 | 183041 | break; |
| 182988 | 183042 | case 213: /* expr ::= expr IS DISTINCT FROM expr */ |
| 182989 | 183043 | { |
| 182990 | | - yymsp[-4].minor.yy590 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-4].minor.yy590,yymsp[0].minor.yy590); |
| 182991 | | - binaryToUnaryIfNull(pParse, yymsp[0].minor.yy590, yymsp[-4].minor.yy590, TK_NOTNULL); |
| 183044 | + yymsp[-4].minor.yy454 = sqlite3PExprIs(pParse, TK_ISNOT, yymsp[-4].minor.yy454, yymsp[0].minor.yy454); |
| 182992 | 183045 | } |
| 182993 | 183046 | break; |
| 182994 | 183047 | case 214: /* expr ::= NOT expr */ |
| 182995 | 183048 | case 215: /* expr ::= BITNOT expr */ yytestcase(yyruleno==215); |
| 182996 | | -{yymsp[-1].minor.yy590 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy590, 0);/*A-overwrites-B*/} |
| 183049 | +{yymsp[-1].minor.yy454 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy454, 0);/*A-overwrites-B*/} |
| 182997 | 183050 | break; |
| 182998 | 183051 | case 216: /* expr ::= PLUS|MINUS expr */ |
| 182999 | 183052 | { |
| 183000 | | - Expr *p = yymsp[0].minor.yy590; |
| 183053 | + Expr *p = yymsp[0].minor.yy454; |
| 183001 | 183054 | u8 op = yymsp[-1].major + (TK_UPLUS-TK_PLUS); |
| 183002 | 183055 | assert( TK_UPLUS>TK_PLUS ); |
| 183003 | 183056 | assert( TK_UMINUS == TK_MINUS + (TK_UPLUS - TK_PLUS) ); |
| 183004 | 183057 | if( p && p->op==TK_UPLUS ){ |
| 183005 | 183058 | p->op = op; |
| 183006 | | - yymsp[-1].minor.yy590 = p; |
| 183059 | + yymsp[-1].minor.yy454 = p; |
| 183007 | 183060 | }else{ |
| 183008 | | - yymsp[-1].minor.yy590 = sqlite3PExpr(pParse, op, p, 0); |
| 183061 | + yymsp[-1].minor.yy454 = sqlite3PExpr(pParse, op, p, 0); |
| 183009 | 183062 | /*A-overwrites-B*/ |
| 183010 | 183063 | } |
| 183011 | 183064 | } |
| 183012 | 183065 | break; |
| 183013 | 183066 | case 217: /* expr ::= expr PTR expr */ |
| 183014 | 183067 | { |
| 183015 | | - ExprList *pList = sqlite3ExprListAppend(pParse, 0, yymsp[-2].minor.yy590); |
| 183016 | | - pList = sqlite3ExprListAppend(pParse, pList, yymsp[0].minor.yy590); |
| 183017 | | - yylhsminor.yy590 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0); |
| 183068 | + ExprList *pList = sqlite3ExprListAppend(pParse, 0, yymsp[-2].minor.yy454); |
| 183069 | + pList = sqlite3ExprListAppend(pParse, pList, yymsp[0].minor.yy454); |
| 183070 | + yylhsminor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0); |
| 183018 | 183071 | } |
| 183019 | | - yymsp[-2].minor.yy590 = yylhsminor.yy590; |
| 183072 | + yymsp[-2].minor.yy454 = yylhsminor.yy454; |
| 183020 | 183073 | break; |
| 183021 | 183074 | case 218: /* between_op ::= BETWEEN */ |
| 183022 | 183075 | case 221: /* in_op ::= IN */ yytestcase(yyruleno==221); |
| 183023 | | -{yymsp[0].minor.yy502 = 0;} |
| 183076 | +{yymsp[0].minor.yy144 = 0;} |
| 183024 | 183077 | break; |
| 183025 | 183078 | case 220: /* expr ::= expr between_op expr AND expr */ |
| 183026 | 183079 | { |
| 183027 | | - ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy590); |
| 183028 | | - pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy590); |
| 183029 | | - yymsp[-4].minor.yy590 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy590, 0); |
| 183030 | | - if( yymsp[-4].minor.yy590 ){ |
| 183031 | | - yymsp[-4].minor.yy590->x.pList = pList; |
| 183080 | + ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454); |
| 183081 | + pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy454); |
| 183082 | + yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy454, 0); |
| 183083 | + if( yymsp[-4].minor.yy454 ){ |
| 183084 | + yymsp[-4].minor.yy454->x.pList = pList; |
| 183032 | 183085 | }else{ |
| 183033 | 183086 | sqlite3ExprListDelete(pParse->db, pList); |
| 183034 | 183087 | } |
| 183035 | | - if( yymsp[-3].minor.yy502 ) yymsp[-4].minor.yy590 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy590, 0); |
| 183088 | + if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0); |
| 183036 | 183089 | } |
| 183037 | 183090 | break; |
| 183038 | 183091 | case 223: /* expr ::= expr in_op LP exprlist RP */ |
| 183039 | 183092 | { |
| 183040 | | - if( yymsp[-1].minor.yy402==0 ){ |
| 183093 | + if( yymsp[-1].minor.yy14==0 ){ |
| 183041 | 183094 | /* Expressions of the form |
| 183042 | 183095 | ** |
| 183043 | 183096 | ** expr1 IN () |
| 183044 | 183097 | ** expr1 NOT IN () |
| 183045 | 183098 | ** |
| | @@ -183048,149 +183101,149 @@ |
| 183048 | 183101 | ** Except, do not apply this optimization if expr1 contains a function |
| 183049 | 183102 | ** because that function might be an aggregate (we don't know yet whether |
| 183050 | 183103 | ** it is or not) and if it is an aggregate, that could change the meaning |
| 183051 | 183104 | ** of the whole query. |
| 183052 | 183105 | */ |
| 183053 | | - Expr *pB = sqlite3Expr(pParse->db, TK_STRING, yymsp[-3].minor.yy502 ? "true" : "false"); |
| 183106 | + Expr *pB = sqlite3Expr(pParse->db, TK_STRING, yymsp[-3].minor.yy144 ? "true" : "false"); |
| 183054 | 183107 | if( pB ) sqlite3ExprIdToTrueFalse(pB); |
| 183055 | | - if( !ExprHasProperty(yymsp[-4].minor.yy590, EP_HasFunc) ){ |
| 183056 | | - sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy590); |
| 183057 | | - yymsp[-4].minor.yy590 = pB; |
| 183108 | + if( !ExprHasProperty(yymsp[-4].minor.yy454, EP_HasFunc) ){ |
| 183109 | + sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy454); |
| 183110 | + yymsp[-4].minor.yy454 = pB; |
| 183058 | 183111 | }else{ |
| 183059 | | - yymsp[-4].minor.yy590 = sqlite3PExpr(pParse, yymsp[-3].minor.yy502 ? TK_OR : TK_AND, pB, yymsp[-4].minor.yy590); |
| 183112 | + yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, yymsp[-3].minor.yy144 ? TK_OR : TK_AND, pB, yymsp[-4].minor.yy454); |
| 183060 | 183113 | } |
| 183061 | 183114 | }else{ |
| 183062 | | - Expr *pRHS = yymsp[-1].minor.yy402->a[0].pExpr; |
| 183063 | | - if( yymsp[-1].minor.yy402->nExpr==1 && sqlite3ExprIsConstant(pParse,pRHS) && yymsp[-4].minor.yy590->op!=TK_VECTOR ){ |
| 183064 | | - yymsp[-1].minor.yy402->a[0].pExpr = 0; |
| 183065 | | - sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy402); |
| 183115 | + Expr *pRHS = yymsp[-1].minor.yy14->a[0].pExpr; |
| 183116 | + if( yymsp[-1].minor.yy14->nExpr==1 && sqlite3ExprIsConstant(pParse,pRHS) && yymsp[-4].minor.yy454->op!=TK_VECTOR ){ |
| 183117 | + yymsp[-1].minor.yy14->a[0].pExpr = 0; |
| 183118 | + sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14); |
| 183066 | 183119 | pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0); |
| 183067 | | - yymsp[-4].minor.yy590 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy590, pRHS); |
| 183068 | | - }else if( yymsp[-1].minor.yy402->nExpr==1 && pRHS->op==TK_SELECT ){ |
| 183069 | | - yymsp[-4].minor.yy590 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy590, 0); |
| 183070 | | - sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy590, pRHS->x.pSelect); |
| 183120 | + yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy454, pRHS); |
| 183121 | + }else if( yymsp[-1].minor.yy14->nExpr==1 && pRHS->op==TK_SELECT ){ |
| 183122 | + yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0); |
| 183123 | + sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pRHS->x.pSelect); |
| 183071 | 183124 | pRHS->x.pSelect = 0; |
| 183072 | | - sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy402); |
| 183125 | + sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14); |
| 183073 | 183126 | }else{ |
| 183074 | | - yymsp[-4].minor.yy590 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy590, 0); |
| 183075 | | - if( yymsp[-4].minor.yy590==0 ){ |
| 183076 | | - sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy402); |
| 183077 | | - }else if( yymsp[-4].minor.yy590->pLeft->op==TK_VECTOR ){ |
| 183078 | | - int nExpr = yymsp[-4].minor.yy590->pLeft->x.pList->nExpr; |
| 183079 | | - Select *pSelectRHS = sqlite3ExprListToValues(pParse, nExpr, yymsp[-1].minor.yy402); |
| 183127 | + yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0); |
| 183128 | + if( yymsp[-4].minor.yy454==0 ){ |
| 183129 | + sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14); |
| 183130 | + }else if( yymsp[-4].minor.yy454->pLeft->op==TK_VECTOR ){ |
| 183131 | + int nExpr = yymsp[-4].minor.yy454->pLeft->x.pList->nExpr; |
| 183132 | + Select *pSelectRHS = sqlite3ExprListToValues(pParse, nExpr, yymsp[-1].minor.yy14); |
| 183080 | 183133 | if( pSelectRHS ){ |
| 183081 | 183134 | parserDoubleLinkSelect(pParse, pSelectRHS); |
| 183082 | | - sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy590, pSelectRHS); |
| 183135 | + sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pSelectRHS); |
| 183083 | 183136 | } |
| 183084 | 183137 | }else{ |
| 183085 | | - yymsp[-4].minor.yy590->x.pList = yymsp[-1].minor.yy402; |
| 183086 | | - sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy590); |
| 183138 | + yymsp[-4].minor.yy454->x.pList = yymsp[-1].minor.yy14; |
| 183139 | + sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454); |
| 183087 | 183140 | } |
| 183088 | 183141 | } |
| 183089 | | - if( yymsp[-3].minor.yy502 ) yymsp[-4].minor.yy590 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy590, 0); |
| 183142 | + if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0); |
| 183090 | 183143 | } |
| 183091 | 183144 | } |
| 183092 | 183145 | break; |
| 183093 | 183146 | case 224: /* expr ::= LP select RP */ |
| 183094 | 183147 | { |
| 183095 | | - yymsp[-2].minor.yy590 = sqlite3PExpr(pParse, TK_SELECT, 0, 0); |
| 183096 | | - sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy590, yymsp[-1].minor.yy637); |
| 183148 | + yymsp[-2].minor.yy454 = sqlite3PExpr(pParse, TK_SELECT, 0, 0); |
| 183149 | + sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy454, yymsp[-1].minor.yy555); |
| 183097 | 183150 | } |
| 183098 | 183151 | break; |
| 183099 | 183152 | case 225: /* expr ::= expr in_op LP select RP */ |
| 183100 | 183153 | { |
| 183101 | | - yymsp[-4].minor.yy590 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy590, 0); |
| 183102 | | - sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy590, yymsp[-1].minor.yy637); |
| 183103 | | - if( yymsp[-3].minor.yy502 ) yymsp[-4].minor.yy590 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy590, 0); |
| 183154 | + yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0); |
| 183155 | + sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, yymsp[-1].minor.yy555); |
| 183156 | + if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0); |
| 183104 | 183157 | } |
| 183105 | 183158 | break; |
| 183106 | 183159 | case 226: /* expr ::= expr in_op nm dbnm paren_exprlist */ |
| 183107 | 183160 | { |
| 183108 | 183161 | SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); |
| 183109 | 183162 | Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0); |
| 183110 | | - if( yymsp[0].minor.yy402 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy402); |
| 183111 | | - yymsp[-4].minor.yy590 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy590, 0); |
| 183112 | | - sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy590, pSelect); |
| 183113 | | - if( yymsp[-3].minor.yy502 ) yymsp[-4].minor.yy590 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy590, 0); |
| 183163 | + if( yymsp[0].minor.yy14 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy14); |
| 183164 | + yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0); |
| 183165 | + sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pSelect); |
| 183166 | + if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0); |
| 183114 | 183167 | } |
| 183115 | 183168 | break; |
| 183116 | 183169 | case 227: /* expr ::= EXISTS LP select RP */ |
| 183117 | 183170 | { |
| 183118 | 183171 | Expr *p; |
| 183119 | | - p = yymsp[-3].minor.yy590 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0); |
| 183120 | | - sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy637); |
| 183172 | + p = yymsp[-3].minor.yy454 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0); |
| 183173 | + sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy555); |
| 183121 | 183174 | } |
| 183122 | 183175 | break; |
| 183123 | 183176 | case 228: /* expr ::= CASE case_operand case_exprlist case_else END */ |
| 183124 | 183177 | { |
| 183125 | | - yymsp[-4].minor.yy590 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy590, 0); |
| 183126 | | - if( yymsp[-4].minor.yy590 ){ |
| 183127 | | - yymsp[-4].minor.yy590->x.pList = yymsp[-1].minor.yy590 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy402,yymsp[-1].minor.yy590) : yymsp[-2].minor.yy402; |
| 183128 | | - sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy590); |
| 183178 | + yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy454, 0); |
| 183179 | + if( yymsp[-4].minor.yy454 ){ |
| 183180 | + yymsp[-4].minor.yy454->x.pList = yymsp[-1].minor.yy454 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454) : yymsp[-2].minor.yy14; |
| 183181 | + sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454); |
| 183129 | 183182 | }else{ |
| 183130 | | - sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy402); |
| 183131 | | - sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy590); |
| 183183 | + sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy14); |
| 183184 | + sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy454); |
| 183132 | 183185 | } |
| 183133 | 183186 | } |
| 183134 | 183187 | break; |
| 183135 | 183188 | case 229: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */ |
| 183136 | 183189 | { |
| 183137 | | - yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy402, yymsp[-2].minor.yy590); |
| 183138 | | - yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy402, yymsp[0].minor.yy590); |
| 183190 | + yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[-2].minor.yy454); |
| 183191 | + yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[0].minor.yy454); |
| 183139 | 183192 | } |
| 183140 | 183193 | break; |
| 183141 | 183194 | case 230: /* case_exprlist ::= WHEN expr THEN expr */ |
| 183142 | 183195 | { |
| 183143 | | - yymsp[-3].minor.yy402 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy590); |
| 183144 | | - yymsp[-3].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy402, yymsp[0].minor.yy590); |
| 183196 | + yymsp[-3].minor.yy14 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454); |
| 183197 | + yymsp[-3].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14, yymsp[0].minor.yy454); |
| 183145 | 183198 | } |
| 183146 | 183199 | break; |
| 183147 | 183200 | case 235: /* nexprlist ::= nexprlist COMMA expr */ |
| 183148 | | -{yymsp[-2].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy402,yymsp[0].minor.yy590);} |
| 183201 | +{yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[0].minor.yy454);} |
| 183149 | 183202 | break; |
| 183150 | 183203 | case 236: /* nexprlist ::= expr */ |
| 183151 | | -{yymsp[0].minor.yy402 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy590); /*A-overwrites-Y*/} |
| 183204 | +{yymsp[0].minor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy454); /*A-overwrites-Y*/} |
| 183152 | 183205 | break; |
| 183153 | 183206 | case 238: /* paren_exprlist ::= LP exprlist RP */ |
| 183154 | 183207 | case 243: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==243); |
| 183155 | | -{yymsp[-2].minor.yy402 = yymsp[-1].minor.yy402;} |
| 183208 | +{yymsp[-2].minor.yy14 = yymsp[-1].minor.yy14;} |
| 183156 | 183209 | break; |
| 183157 | 183210 | case 239: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ |
| 183158 | 183211 | { |
| 183159 | 183212 | sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, |
| 183160 | | - sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy402, yymsp[-10].minor.yy502, |
| 183161 | | - &yymsp[-11].minor.yy0, yymsp[0].minor.yy590, SQLITE_SO_ASC, yymsp[-8].minor.yy502, SQLITE_IDXTYPE_APPDEF); |
| 183213 | + sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy14, yymsp[-10].minor.yy144, |
| 183214 | + &yymsp[-11].minor.yy0, yymsp[0].minor.yy454, SQLITE_SO_ASC, yymsp[-8].minor.yy144, SQLITE_IDXTYPE_APPDEF); |
| 183162 | 183215 | if( IN_RENAME_OBJECT && pParse->pNewIndex ){ |
| 183163 | 183216 | sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0); |
| 183164 | 183217 | } |
| 183165 | 183218 | } |
| 183166 | 183219 | break; |
| 183167 | 183220 | case 240: /* uniqueflag ::= UNIQUE */ |
| 183168 | | - case 282: /* raisetype ::= ABORT */ yytestcase(yyruleno==282); |
| 183169 | | -{yymsp[0].minor.yy502 = OE_Abort;} |
| 183221 | + case 281: /* raisetype ::= ABORT */ yytestcase(yyruleno==281); |
| 183222 | +{yymsp[0].minor.yy144 = OE_Abort;} |
| 183170 | 183223 | break; |
| 183171 | 183224 | case 241: /* uniqueflag ::= */ |
| 183172 | | -{yymsp[1].minor.yy502 = OE_None;} |
| 183225 | +{yymsp[1].minor.yy144 = OE_None;} |
| 183173 | 183226 | break; |
| 183174 | 183227 | case 244: /* eidlist ::= eidlist COMMA nm collate sortorder */ |
| 183175 | 183228 | { |
| 183176 | | - yymsp[-4].minor.yy402 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy402, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy502, yymsp[0].minor.yy502); |
| 183229 | + yymsp[-4].minor.yy14 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy14, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy144, yymsp[0].minor.yy144); |
| 183177 | 183230 | } |
| 183178 | 183231 | break; |
| 183179 | 183232 | case 245: /* eidlist ::= nm collate sortorder */ |
| 183180 | 183233 | { |
| 183181 | | - yymsp[-2].minor.yy402 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy502, yymsp[0].minor.yy502); /*A-overwrites-Y*/ |
| 183234 | + yymsp[-2].minor.yy14 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy144, yymsp[0].minor.yy144); /*A-overwrites-Y*/ |
| 183182 | 183235 | } |
| 183183 | 183236 | break; |
| 183184 | 183237 | case 248: /* cmd ::= DROP INDEX ifexists fullname */ |
| 183185 | | -{sqlite3DropIndex(pParse, yymsp[0].minor.yy563, yymsp[-1].minor.yy502);} |
| 183238 | +{sqlite3DropIndex(pParse, yymsp[0].minor.yy203, yymsp[-1].minor.yy144);} |
| 183186 | 183239 | break; |
| 183187 | 183240 | case 249: /* cmd ::= VACUUM vinto */ |
| 183188 | | -{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy590);} |
| 183241 | +{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy454);} |
| 183189 | 183242 | break; |
| 183190 | 183243 | case 250: /* cmd ::= VACUUM nm vinto */ |
| 183191 | | -{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy590);} |
| 183244 | +{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy454);} |
| 183192 | 183245 | break; |
| 183193 | 183246 | case 253: /* cmd ::= PRAGMA nm dbnm */ |
| 183194 | 183247 | {sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);} |
| 183195 | 183248 | break; |
| 183196 | 183249 | case 254: /* cmd ::= PRAGMA nm dbnm EQ nmnum */ |
| | @@ -183208,468 +183261,457 @@ |
| 183208 | 183261 | case 260: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ |
| 183209 | 183262 | { |
| 183210 | 183263 | Token all; |
| 183211 | 183264 | all.z = yymsp[-3].minor.yy0.z; |
| 183212 | 183265 | all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n; |
| 183213 | | - sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy319, &all); |
| 183266 | + sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy427, &all); |
| 183214 | 183267 | } |
| 183215 | 183268 | break; |
| 183216 | 183269 | case 261: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ |
| 183217 | 183270 | { |
| 183218 | | - sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy502, yymsp[-4].minor.yy28.a, yymsp[-4].minor.yy28.b, yymsp[-2].minor.yy563, yymsp[0].minor.yy590, yymsp[-10].minor.yy502, yymsp[-8].minor.yy502); |
| 183271 | + sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy144, yymsp[-4].minor.yy286.a, yymsp[-4].minor.yy286.b, yymsp[-2].minor.yy203, yymsp[0].minor.yy454, yymsp[-10].minor.yy144, yymsp[-8].minor.yy144); |
| 183219 | 183272 | yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /*A-overwrites-T*/ |
| 183220 | 183273 | #ifdef SQLITE_DEBUG |
| 183221 | 183274 | assert( pParse->isCreate ); /* Set by createkw reduce action */ |
| 183222 | 183275 | pParse->isCreate = 0; /* But, should not be set for CREATE TRIGGER */ |
| 183223 | 183276 | #endif |
| 183224 | 183277 | } |
| 183225 | 183278 | break; |
| 183226 | 183279 | case 262: /* trigger_time ::= BEFORE|AFTER */ |
| 183227 | | -{ yymsp[0].minor.yy502 = yymsp[0].major; /*A-overwrites-X*/ } |
| 183280 | +{ yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-X*/ } |
| 183228 | 183281 | break; |
| 183229 | 183282 | case 263: /* trigger_time ::= INSTEAD OF */ |
| 183230 | | -{ yymsp[-1].minor.yy502 = TK_INSTEAD;} |
| 183283 | +{ yymsp[-1].minor.yy144 = TK_INSTEAD;} |
| 183231 | 183284 | break; |
| 183232 | 183285 | case 264: /* trigger_time ::= */ |
| 183233 | | -{ yymsp[1].minor.yy502 = TK_BEFORE; } |
| 183286 | +{ yymsp[1].minor.yy144 = TK_BEFORE; } |
| 183234 | 183287 | break; |
| 183235 | 183288 | case 265: /* trigger_event ::= DELETE|INSERT */ |
| 183236 | 183289 | case 266: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==266); |
| 183237 | | -{yymsp[0].minor.yy28.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy28.b = 0;} |
| 183290 | +{yymsp[0].minor.yy286.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy286.b = 0;} |
| 183238 | 183291 | break; |
| 183239 | 183292 | case 267: /* trigger_event ::= UPDATE OF idlist */ |
| 183240 | | -{yymsp[-2].minor.yy28.a = TK_UPDATE; yymsp[-2].minor.yy28.b = yymsp[0].minor.yy204;} |
| 183293 | +{yymsp[-2].minor.yy286.a = TK_UPDATE; yymsp[-2].minor.yy286.b = yymsp[0].minor.yy132;} |
| 183241 | 183294 | break; |
| 183242 | 183295 | case 268: /* when_clause ::= */ |
| 183243 | | - case 287: /* key_opt ::= */ yytestcase(yyruleno==287); |
| 183244 | | -{ yymsp[1].minor.yy590 = 0; } |
| 183296 | + case 286: /* key_opt ::= */ yytestcase(yyruleno==286); |
| 183297 | +{ yymsp[1].minor.yy454 = 0; } |
| 183245 | 183298 | break; |
| 183246 | 183299 | case 269: /* when_clause ::= WHEN expr */ |
| 183247 | | - case 288: /* key_opt ::= KEY expr */ yytestcase(yyruleno==288); |
| 183248 | | -{ yymsp[-1].minor.yy590 = yymsp[0].minor.yy590; } |
| 183300 | + case 287: /* key_opt ::= KEY expr */ yytestcase(yyruleno==287); |
| 183301 | +{ yymsp[-1].minor.yy454 = yymsp[0].minor.yy454; } |
| 183249 | 183302 | break; |
| 183250 | 183303 | case 270: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ |
| 183251 | 183304 | { |
| 183252 | | - assert( yymsp[-2].minor.yy319!=0 ); |
| 183253 | | - yymsp[-2].minor.yy319->pLast->pNext = yymsp[-1].minor.yy319; |
| 183254 | | - yymsp[-2].minor.yy319->pLast = yymsp[-1].minor.yy319; |
| 183305 | + yymsp[-2].minor.yy427->pLast->pNext = yymsp[-1].minor.yy427; |
| 183306 | + yymsp[-2].minor.yy427->pLast = yymsp[-1].minor.yy427; |
| 183255 | 183307 | } |
| 183256 | 183308 | break; |
| 183257 | 183309 | case 271: /* trigger_cmd_list ::= trigger_cmd SEMI */ |
| 183258 | 183310 | { |
| 183259 | | - assert( yymsp[-1].minor.yy319!=0 ); |
| 183260 | | - yymsp[-1].minor.yy319->pLast = yymsp[-1].minor.yy319; |
| 183311 | + yymsp[-1].minor.yy427->pLast = yymsp[-1].minor.yy427; |
| 183261 | 183312 | } |
| 183262 | 183313 | break; |
| 183263 | | - case 272: /* trnm ::= nm DOT nm */ |
| 183264 | | -{ |
| 183265 | | - yymsp[-2].minor.yy0 = yymsp[0].minor.yy0; |
| 183266 | | - sqlite3ErrorMsg(pParse, |
| 183267 | | - "qualified table names are not allowed on INSERT, UPDATE, and DELETE " |
| 183268 | | - "statements within triggers"); |
| 183269 | | -} |
| 183270 | | - break; |
| 183271 | | - case 273: /* tridxby ::= INDEXED BY nm */ |
| 183314 | + case 272: /* tridxby ::= INDEXED BY nm */ |
| 183272 | 183315 | { |
| 183273 | 183316 | sqlite3ErrorMsg(pParse, |
| 183274 | 183317 | "the INDEXED BY clause is not allowed on UPDATE or DELETE statements " |
| 183275 | 183318 | "within triggers"); |
| 183276 | 183319 | } |
| 183277 | 183320 | break; |
| 183278 | | - case 274: /* tridxby ::= NOT INDEXED */ |
| 183321 | + case 273: /* tridxby ::= NOT INDEXED */ |
| 183279 | 183322 | { |
| 183280 | 183323 | sqlite3ErrorMsg(pParse, |
| 183281 | 183324 | "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements " |
| 183282 | 183325 | "within triggers"); |
| 183283 | 183326 | } |
| 183284 | 183327 | break; |
| 183285 | | - case 275: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ |
| 183286 | | -{yylhsminor.yy319 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy563, yymsp[-3].minor.yy402, yymsp[-1].minor.yy590, yymsp[-7].minor.yy502, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy342);} |
| 183287 | | - yymsp[-8].minor.yy319 = yylhsminor.yy319; |
| 183288 | | - break; |
| 183289 | | - case 276: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ |
| 183290 | | -{ |
| 183291 | | - yylhsminor.yy319 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy204,yymsp[-2].minor.yy637,yymsp[-6].minor.yy502,yymsp[-1].minor.yy403,yymsp[-7].minor.yy342,yymsp[0].minor.yy342);/*yylhsminor.yy319-overwrites-yymsp[-6].minor.yy502*/ |
| 183292 | | -} |
| 183293 | | - yymsp[-7].minor.yy319 = yylhsminor.yy319; |
| 183294 | | - break; |
| 183295 | | - case 277: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ |
| 183296 | | -{yylhsminor.yy319 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy590, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy342);} |
| 183297 | | - yymsp[-5].minor.yy319 = yylhsminor.yy319; |
| 183298 | | - break; |
| 183299 | | - case 278: /* trigger_cmd ::= scanpt select scanpt */ |
| 183300 | | -{yylhsminor.yy319 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy637, yymsp[-2].minor.yy342, yymsp[0].minor.yy342); /*yylhsminor.yy319-overwrites-yymsp[-1].minor.yy637*/} |
| 183301 | | - yymsp[-2].minor.yy319 = yylhsminor.yy319; |
| 183302 | | - break; |
| 183303 | | - case 279: /* expr ::= RAISE LP IGNORE RP */ |
| 183304 | | -{ |
| 183305 | | - yymsp[-3].minor.yy590 = sqlite3PExpr(pParse, TK_RAISE, 0, 0); |
| 183306 | | - if( yymsp[-3].minor.yy590 ){ |
| 183307 | | - yymsp[-3].minor.yy590->affExpr = OE_Ignore; |
| 183308 | | - } |
| 183309 | | -} |
| 183310 | | - break; |
| 183311 | | - case 280: /* expr ::= RAISE LP raisetype COMMA expr RP */ |
| 183312 | | -{ |
| 183313 | | - yymsp[-5].minor.yy590 = sqlite3PExpr(pParse, TK_RAISE, yymsp[-1].minor.yy590, 0); |
| 183314 | | - if( yymsp[-5].minor.yy590 ) { |
| 183315 | | - yymsp[-5].minor.yy590->affExpr = (char)yymsp[-3].minor.yy502; |
| 183316 | | - } |
| 183317 | | -} |
| 183318 | | - break; |
| 183319 | | - case 281: /* raisetype ::= ROLLBACK */ |
| 183320 | | -{yymsp[0].minor.yy502 = OE_Rollback;} |
| 183321 | | - break; |
| 183322 | | - case 283: /* raisetype ::= FAIL */ |
| 183323 | | -{yymsp[0].minor.yy502 = OE_Fail;} |
| 183324 | | - break; |
| 183325 | | - case 284: /* cmd ::= DROP TRIGGER ifexists fullname */ |
| 183326 | | -{ |
| 183327 | | - sqlite3DropTrigger(pParse,yymsp[0].minor.yy563,yymsp[-1].minor.yy502); |
| 183328 | | -} |
| 183329 | | - break; |
| 183330 | | - case 285: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ |
| 183331 | | -{ |
| 183332 | | - sqlite3Attach(pParse, yymsp[-3].minor.yy590, yymsp[-1].minor.yy590, yymsp[0].minor.yy590); |
| 183333 | | -} |
| 183334 | | - break; |
| 183335 | | - case 286: /* cmd ::= DETACH database_kw_opt expr */ |
| 183336 | | -{ |
| 183337 | | - sqlite3Detach(pParse, yymsp[0].minor.yy590); |
| 183338 | | -} |
| 183339 | | - break; |
| 183340 | | - case 289: /* cmd ::= REINDEX */ |
| 183328 | + case 274: /* trigger_cmd ::= UPDATE orconf xfullname tridxby SET setlist from where_opt scanpt */ |
| 183329 | +{yylhsminor.yy427 = sqlite3TriggerUpdateStep(pParse, yymsp[-6].minor.yy203, yymsp[-2].minor.yy203, yymsp[-3].minor.yy14, yymsp[-1].minor.yy454, yymsp[-7].minor.yy144, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy168);} |
| 183330 | + yymsp[-8].minor.yy427 = yylhsminor.yy427; |
| 183331 | + break; |
| 183332 | + case 275: /* trigger_cmd ::= scanpt insert_cmd INTO xfullname idlist_opt select upsert scanpt */ |
| 183333 | +{ |
| 183334 | + yylhsminor.yy427 = sqlite3TriggerInsertStep(pParse,yymsp[-4].minor.yy203,yymsp[-3].minor.yy132,yymsp[-2].minor.yy555,yymsp[-6].minor.yy144,yymsp[-1].minor.yy122,yymsp[-7].minor.yy168,yymsp[0].minor.yy168);/*yylhsminor.yy427-overwrites-yymsp[-6].minor.yy144*/ |
| 183335 | +} |
| 183336 | + yymsp[-7].minor.yy427 = yylhsminor.yy427; |
| 183337 | + break; |
| 183338 | + case 276: /* trigger_cmd ::= DELETE FROM xfullname tridxby where_opt scanpt */ |
| 183339 | +{yylhsminor.yy427 = sqlite3TriggerDeleteStep(pParse, yymsp[-3].minor.yy203, yymsp[-1].minor.yy454, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy168);} |
| 183340 | + yymsp[-5].minor.yy427 = yylhsminor.yy427; |
| 183341 | + break; |
| 183342 | + case 277: /* trigger_cmd ::= scanpt select scanpt */ |
| 183343 | +{yylhsminor.yy427 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy555, yymsp[-2].minor.yy168, yymsp[0].minor.yy168); /*yylhsminor.yy427-overwrites-yymsp[-1].minor.yy555*/} |
| 183344 | + yymsp[-2].minor.yy427 = yylhsminor.yy427; |
| 183345 | + break; |
| 183346 | + case 278: /* expr ::= RAISE LP IGNORE RP */ |
| 183347 | +{ |
| 183348 | + yymsp[-3].minor.yy454 = sqlite3PExpr(pParse, TK_RAISE, 0, 0); |
| 183349 | + if( yymsp[-3].minor.yy454 ){ |
| 183350 | + yymsp[-3].minor.yy454->affExpr = OE_Ignore; |
| 183351 | + } |
| 183352 | +} |
| 183353 | + break; |
| 183354 | + case 279: /* expr ::= RAISE LP raisetype COMMA expr RP */ |
| 183355 | +{ |
| 183356 | + yymsp[-5].minor.yy454 = sqlite3PExpr(pParse, TK_RAISE, yymsp[-1].minor.yy454, 0); |
| 183357 | + if( yymsp[-5].minor.yy454 ) { |
| 183358 | + yymsp[-5].minor.yy454->affExpr = (char)yymsp[-3].minor.yy144; |
| 183359 | + } |
| 183360 | +} |
| 183361 | + break; |
| 183362 | + case 280: /* raisetype ::= ROLLBACK */ |
| 183363 | +{yymsp[0].minor.yy144 = OE_Rollback;} |
| 183364 | + break; |
| 183365 | + case 282: /* raisetype ::= FAIL */ |
| 183366 | +{yymsp[0].minor.yy144 = OE_Fail;} |
| 183367 | + break; |
| 183368 | + case 283: /* cmd ::= DROP TRIGGER ifexists fullname */ |
| 183369 | +{ |
| 183370 | + sqlite3DropTrigger(pParse,yymsp[0].minor.yy203,yymsp[-1].minor.yy144); |
| 183371 | +} |
| 183372 | + break; |
| 183373 | + case 284: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ |
| 183374 | +{ |
| 183375 | + sqlite3Attach(pParse, yymsp[-3].minor.yy454, yymsp[-1].minor.yy454, yymsp[0].minor.yy454); |
| 183376 | +} |
| 183377 | + break; |
| 183378 | + case 285: /* cmd ::= DETACH database_kw_opt expr */ |
| 183379 | +{ |
| 183380 | + sqlite3Detach(pParse, yymsp[0].minor.yy454); |
| 183381 | +} |
| 183382 | + break; |
| 183383 | + case 288: /* cmd ::= REINDEX */ |
| 183341 | 183384 | {sqlite3Reindex(pParse, 0, 0);} |
| 183342 | 183385 | break; |
| 183343 | | - case 290: /* cmd ::= REINDEX nm dbnm */ |
| 183386 | + case 289: /* cmd ::= REINDEX nm dbnm */ |
| 183344 | 183387 | {sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);} |
| 183345 | 183388 | break; |
| 183346 | | - case 291: /* cmd ::= ANALYZE */ |
| 183389 | + case 290: /* cmd ::= ANALYZE */ |
| 183347 | 183390 | {sqlite3Analyze(pParse, 0, 0);} |
| 183348 | 183391 | break; |
| 183349 | | - case 292: /* cmd ::= ANALYZE nm dbnm */ |
| 183392 | + case 291: /* cmd ::= ANALYZE nm dbnm */ |
| 183350 | 183393 | {sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);} |
| 183351 | 183394 | break; |
| 183352 | | - case 293: /* cmd ::= ALTER TABLE fullname RENAME TO nm */ |
| 183395 | + case 292: /* cmd ::= ALTER TABLE fullname RENAME TO nm */ |
| 183353 | 183396 | { |
| 183354 | | - sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy563,&yymsp[0].minor.yy0); |
| 183397 | + sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy203,&yymsp[0].minor.yy0); |
| 183355 | 183398 | } |
| 183356 | 183399 | break; |
| 183357 | | - case 294: /* cmd ::= alter_add carglist */ |
| 183400 | + case 293: /* cmd ::= alter_add carglist */ |
| 183358 | 183401 | { |
| 183359 | 183402 | yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n; |
| 183360 | 183403 | sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0); |
| 183361 | 183404 | } |
| 183362 | 183405 | break; |
| 183363 | | - case 295: /* alter_add ::= ALTER TABLE fullname ADD kwcolumn_opt nm typetoken */ |
| 183406 | + case 294: /* alter_add ::= ALTER TABLE fullname ADD kwcolumn_opt nm typetoken */ |
| 183364 | 183407 | { |
| 183365 | 183408 | disableLookaside(pParse); |
| 183366 | | - sqlite3AlterBeginAddColumn(pParse, yymsp[-4].minor.yy563); |
| 183409 | + sqlite3AlterBeginAddColumn(pParse, yymsp[-4].minor.yy203); |
| 183367 | 183410 | sqlite3AddColumn(pParse, yymsp[-1].minor.yy0, yymsp[0].minor.yy0); |
| 183368 | 183411 | yymsp[-6].minor.yy0 = yymsp[-1].minor.yy0; |
| 183369 | 183412 | } |
| 183370 | 183413 | break; |
| 183371 | | - case 296: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ |
| 183372 | | -{ |
| 183373 | | - sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy563, &yymsp[0].minor.yy0); |
| 183374 | | -} |
| 183375 | | - break; |
| 183376 | | - case 297: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ |
| 183377 | | -{ |
| 183378 | | - sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy563, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); |
| 183379 | | -} |
| 183380 | | - break; |
| 183381 | | - case 298: /* cmd ::= ALTER TABLE fullname DROP CONSTRAINT nm */ |
| 183382 | | -{ |
| 183383 | | - sqlite3AlterDropConstraint(pParse, yymsp[-3].minor.yy563, &yymsp[0].minor.yy0, 0); |
| 183384 | | -} |
| 183385 | | - break; |
| 183386 | | - case 299: /* cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm DROP NOT NULL */ |
| 183387 | | -{ |
| 183388 | | - sqlite3AlterDropConstraint(pParse, yymsp[-6].minor.yy563, 0, &yymsp[-3].minor.yy0); |
| 183389 | | -} |
| 183390 | | - break; |
| 183391 | | - case 300: /* cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm SET NOT NULL onconf */ |
| 183392 | | -{ |
| 183393 | | - sqlite3AlterSetNotNull(pParse, yymsp[-7].minor.yy563, &yymsp[-4].minor.yy0, &yymsp[-2].minor.yy0); |
| 183394 | | -} |
| 183395 | | - break; |
| 183396 | | - case 301: /* cmd ::= ALTER TABLE fullname ADD CONSTRAINT nm CHECK LP expr RP onconf */ |
| 183397 | | -{ |
| 183398 | | - sqlite3AlterAddConstraint(pParse, yymsp[-8].minor.yy563, &yymsp[-6].minor.yy0, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy0.z+1, (yymsp[-1].minor.yy0.z-yymsp[-3].minor.yy0.z-1)); |
| 183399 | | -} |
| 183400 | | - yy_destructor(yypParser,219,&yymsp[-2].minor); |
| 183401 | | - break; |
| 183402 | | - case 302: /* cmd ::= ALTER TABLE fullname ADD CHECK LP expr RP onconf */ |
| 183403 | | -{ |
| 183404 | | - sqlite3AlterAddConstraint(pParse, yymsp[-6].minor.yy563, &yymsp[-4].minor.yy0, 0, yymsp[-3].minor.yy0.z+1, (yymsp[-1].minor.yy0.z-yymsp[-3].minor.yy0.z-1)); |
| 183405 | | -} |
| 183406 | | - yy_destructor(yypParser,219,&yymsp[-2].minor); |
| 183407 | | - break; |
| 183408 | | - case 303: /* cmd ::= create_vtab */ |
| 183409 | | -{sqlite3VtabFinishParse(pParse,0);} |
| 183410 | | - break; |
| 183411 | | - case 304: /* cmd ::= create_vtab LP vtabarglist RP */ |
| 183412 | | -{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);} |
| 183413 | | - break; |
| 183414 | | - case 305: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ |
| 183415 | | -{ |
| 183416 | | - sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy502); |
| 183417 | | -} |
| 183418 | | - break; |
| 183419 | | - case 306: /* vtabarg ::= */ |
| 183420 | | -{sqlite3VtabArgInit(pParse);} |
| 183421 | | - break; |
| 183422 | | - case 307: /* vtabargtoken ::= ANY */ |
| 183423 | | - case 308: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==308); |
| 183424 | | - case 309: /* lp ::= LP */ yytestcase(yyruleno==309); |
| 183425 | | -{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);} |
| 183426 | | - break; |
| 183427 | | - case 310: /* with ::= WITH wqlist */ |
| 183428 | | - case 311: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==311); |
| 183429 | | -{ sqlite3WithPush(pParse, yymsp[0].minor.yy125, 1); } |
| 183430 | | - break; |
| 183431 | | - case 312: /* wqas ::= AS */ |
| 183432 | | -{yymsp[0].minor.yy444 = M10d_Any;} |
| 183433 | | - break; |
| 183434 | | - case 313: /* wqas ::= AS MATERIALIZED */ |
| 183435 | | -{yymsp[-1].minor.yy444 = M10d_Yes;} |
| 183436 | | - break; |
| 183437 | | - case 314: /* wqas ::= AS NOT MATERIALIZED */ |
| 183438 | | -{yymsp[-2].minor.yy444 = M10d_No;} |
| 183439 | | - break; |
| 183440 | | - case 315: /* wqitem ::= withnm eidlist_opt wqas LP select RP */ |
| 183441 | | -{ |
| 183442 | | - yymsp[-5].minor.yy361 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy402, yymsp[-1].minor.yy637, yymsp[-3].minor.yy444); /*A-overwrites-X*/ |
| 183443 | | -} |
| 183444 | | - break; |
| 183445 | | - case 316: /* withnm ::= nm */ |
| 183446 | | -{pParse->bHasWith = 1;} |
| 183447 | | - break; |
| 183448 | | - case 317: /* wqlist ::= wqitem */ |
| 183449 | | -{ |
| 183450 | | - yymsp[0].minor.yy125 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy361); /*A-overwrites-X*/ |
| 183451 | | -} |
| 183452 | | - break; |
| 183453 | | - case 318: /* wqlist ::= wqlist COMMA wqitem */ |
| 183454 | | -{ |
| 183455 | | - yymsp[-2].minor.yy125 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy125, yymsp[0].minor.yy361); |
| 183456 | | -} |
| 183457 | | - break; |
| 183458 | | - case 319: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */ |
| 183459 | | -{ |
| 183460 | | - assert( yymsp[0].minor.yy483!=0 ); |
| 183461 | | - sqlite3WindowChain(pParse, yymsp[0].minor.yy483, yymsp[-2].minor.yy483); |
| 183462 | | - yymsp[0].minor.yy483->pNextWin = yymsp[-2].minor.yy483; |
| 183463 | | - yylhsminor.yy483 = yymsp[0].minor.yy483; |
| 183464 | | -} |
| 183465 | | - yymsp[-2].minor.yy483 = yylhsminor.yy483; |
| 183466 | | - break; |
| 183467 | | - case 320: /* windowdefn ::= nm AS LP window RP */ |
| 183468 | | -{ |
| 183469 | | - if( ALWAYS(yymsp[-1].minor.yy483) ){ |
| 183470 | | - yymsp[-1].minor.yy483->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n); |
| 183471 | | - } |
| 183472 | | - yylhsminor.yy483 = yymsp[-1].minor.yy483; |
| 183473 | | -} |
| 183474 | | - yymsp[-4].minor.yy483 = yylhsminor.yy483; |
| 183475 | | - break; |
| 183476 | | - case 321: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */ |
| 183477 | | -{ |
| 183478 | | - yymsp[-4].minor.yy483 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy483, yymsp[-2].minor.yy402, yymsp[-1].minor.yy402, 0); |
| 183479 | | -} |
| 183480 | | - break; |
| 183481 | | - case 322: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ |
| 183482 | | -{ |
| 183483 | | - yylhsminor.yy483 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy483, yymsp[-2].minor.yy402, yymsp[-1].minor.yy402, &yymsp[-5].minor.yy0); |
| 183484 | | -} |
| 183485 | | - yymsp[-5].minor.yy483 = yylhsminor.yy483; |
| 183486 | | - break; |
| 183487 | | - case 323: /* window ::= ORDER BY sortlist frame_opt */ |
| 183488 | | -{ |
| 183489 | | - yymsp[-3].minor.yy483 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy483, 0, yymsp[-1].minor.yy402, 0); |
| 183490 | | -} |
| 183491 | | - break; |
| 183492 | | - case 324: /* window ::= nm ORDER BY sortlist frame_opt */ |
| 183493 | | -{ |
| 183494 | | - yylhsminor.yy483 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy483, 0, yymsp[-1].minor.yy402, &yymsp[-4].minor.yy0); |
| 183495 | | -} |
| 183496 | | - yymsp[-4].minor.yy483 = yylhsminor.yy483; |
| 183497 | | - break; |
| 183498 | | - case 325: /* window ::= nm frame_opt */ |
| 183499 | | -{ |
| 183500 | | - yylhsminor.yy483 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy483, 0, 0, &yymsp[-1].minor.yy0); |
| 183501 | | -} |
| 183502 | | - yymsp[-1].minor.yy483 = yylhsminor.yy483; |
| 183503 | | - break; |
| 183504 | | - case 326: /* frame_opt ::= */ |
| 183505 | | -{ |
| 183506 | | - yymsp[1].minor.yy483 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0); |
| 183507 | | -} |
| 183508 | | - break; |
| 183509 | | - case 327: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ |
| 183510 | | -{ |
| 183511 | | - yylhsminor.yy483 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy502, yymsp[-1].minor.yy205.eType, yymsp[-1].minor.yy205.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy444); |
| 183512 | | -} |
| 183513 | | - yymsp[-2].minor.yy483 = yylhsminor.yy483; |
| 183514 | | - break; |
| 183515 | | - case 328: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ |
| 183516 | | -{ |
| 183517 | | - yylhsminor.yy483 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy502, yymsp[-3].minor.yy205.eType, yymsp[-3].minor.yy205.pExpr, yymsp[-1].minor.yy205.eType, yymsp[-1].minor.yy205.pExpr, yymsp[0].minor.yy444); |
| 183518 | | -} |
| 183519 | | - yymsp[-5].minor.yy483 = yylhsminor.yy483; |
| 183520 | | - break; |
| 183521 | | - case 330: /* frame_bound_s ::= frame_bound */ |
| 183522 | | - case 332: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==332); |
| 183523 | | -{yylhsminor.yy205 = yymsp[0].minor.yy205;} |
| 183524 | | - yymsp[0].minor.yy205 = yylhsminor.yy205; |
| 183525 | | - break; |
| 183526 | | - case 331: /* frame_bound_s ::= UNBOUNDED PRECEDING */ |
| 183527 | | - case 333: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==333); |
| 183528 | | - case 335: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==335); |
| 183529 | | -{yylhsminor.yy205.eType = yymsp[-1].major; yylhsminor.yy205.pExpr = 0;} |
| 183530 | | - yymsp[-1].minor.yy205 = yylhsminor.yy205; |
| 183531 | | - break; |
| 183532 | | - case 334: /* frame_bound ::= expr PRECEDING|FOLLOWING */ |
| 183533 | | -{yylhsminor.yy205.eType = yymsp[0].major; yylhsminor.yy205.pExpr = yymsp[-1].minor.yy590;} |
| 183534 | | - yymsp[-1].minor.yy205 = yylhsminor.yy205; |
| 183535 | | - break; |
| 183536 | | - case 336: /* frame_exclude_opt ::= */ |
| 183537 | | -{yymsp[1].minor.yy444 = 0;} |
| 183538 | | - break; |
| 183539 | | - case 337: /* frame_exclude_opt ::= EXCLUDE frame_exclude */ |
| 183540 | | -{yymsp[-1].minor.yy444 = yymsp[0].minor.yy444;} |
| 183541 | | - break; |
| 183542 | | - case 338: /* frame_exclude ::= NO OTHERS */ |
| 183543 | | - case 339: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==339); |
| 183544 | | -{yymsp[-1].minor.yy444 = yymsp[-1].major; /*A-overwrites-X*/} |
| 183545 | | - break; |
| 183546 | | - case 340: /* frame_exclude ::= GROUP|TIES */ |
| 183547 | | -{yymsp[0].minor.yy444 = yymsp[0].major; /*A-overwrites-X*/} |
| 183548 | | - break; |
| 183549 | | - case 341: /* window_clause ::= WINDOW windowdefn_list */ |
| 183550 | | -{ yymsp[-1].minor.yy483 = yymsp[0].minor.yy483; } |
| 183551 | | - break; |
| 183552 | | - case 342: /* filter_over ::= filter_clause over_clause */ |
| 183553 | | -{ |
| 183554 | | - if( yymsp[0].minor.yy483 ){ |
| 183555 | | - yymsp[0].minor.yy483->pFilter = yymsp[-1].minor.yy590; |
| 183556 | | - }else{ |
| 183557 | | - sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy590); |
| 183558 | | - } |
| 183559 | | - yylhsminor.yy483 = yymsp[0].minor.yy483; |
| 183560 | | -} |
| 183561 | | - yymsp[-1].minor.yy483 = yylhsminor.yy483; |
| 183562 | | - break; |
| 183563 | | - case 343: /* filter_over ::= over_clause */ |
| 183564 | | -{ |
| 183565 | | - yylhsminor.yy483 = yymsp[0].minor.yy483; |
| 183566 | | -} |
| 183567 | | - yymsp[0].minor.yy483 = yylhsminor.yy483; |
| 183568 | | - break; |
| 183569 | | - case 344: /* filter_over ::= filter_clause */ |
| 183570 | | -{ |
| 183571 | | - yylhsminor.yy483 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); |
| 183572 | | - if( yylhsminor.yy483 ){ |
| 183573 | | - yylhsminor.yy483->eFrmType = TK_FILTER; |
| 183574 | | - yylhsminor.yy483->pFilter = yymsp[0].minor.yy590; |
| 183575 | | - }else{ |
| 183576 | | - sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy590); |
| 183577 | | - } |
| 183578 | | -} |
| 183579 | | - yymsp[0].minor.yy483 = yylhsminor.yy483; |
| 183580 | | - break; |
| 183581 | | - case 345: /* over_clause ::= OVER LP window RP */ |
| 183582 | | -{ |
| 183583 | | - yymsp[-3].minor.yy483 = yymsp[-1].minor.yy483; |
| 183584 | | - assert( yymsp[-3].minor.yy483!=0 ); |
| 183585 | | -} |
| 183586 | | - break; |
| 183587 | | - case 346: /* over_clause ::= OVER nm */ |
| 183588 | | -{ |
| 183589 | | - yymsp[-1].minor.yy483 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); |
| 183590 | | - if( yymsp[-1].minor.yy483 ){ |
| 183591 | | - yymsp[-1].minor.yy483->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n); |
| 183592 | | - } |
| 183593 | | -} |
| 183594 | | - break; |
| 183595 | | - case 347: /* filter_clause ::= FILTER LP WHERE expr RP */ |
| 183596 | | -{ yymsp[-4].minor.yy590 = yymsp[-1].minor.yy590; } |
| 183597 | | - break; |
| 183598 | | - case 348: /* term ::= QNUMBER */ |
| 183599 | | -{ |
| 183600 | | - yylhsminor.yy590=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); |
| 183601 | | - sqlite3DequoteNumber(pParse, yylhsminor.yy590); |
| 183602 | | -} |
| 183603 | | - yymsp[0].minor.yy590 = yylhsminor.yy590; |
| 183604 | | - break; |
| 183605 | | - default: |
| 183606 | | - /* (349) input ::= cmdlist */ yytestcase(yyruleno==349); |
| 183607 | | - /* (350) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==350); |
| 183608 | | - /* (351) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=351); |
| 183609 | | - /* (352) ecmd ::= SEMI */ yytestcase(yyruleno==352); |
| 183610 | | - /* (353) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==353); |
| 183611 | | - /* (354) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=354); |
| 183612 | | - /* (355) trans_opt ::= */ yytestcase(yyruleno==355); |
| 183613 | | - /* (356) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==356); |
| 183614 | | - /* (357) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==357); |
| 183615 | | - /* (358) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==358); |
| 183616 | | - /* (359) savepoint_opt ::= */ yytestcase(yyruleno==359); |
| 183617 | | - /* (360) cmd ::= create_table create_table_args */ yytestcase(yyruleno==360); |
| 183618 | | - /* (361) table_option_set ::= table_option (OPTIMIZED OUT) */ assert(yyruleno!=361); |
| 183619 | | - /* (362) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==362); |
| 183620 | | - /* (363) columnlist ::= columnname carglist */ yytestcase(yyruleno==363); |
| 183621 | | - /* (364) nm ::= ID|INDEXED|JOIN_KW */ yytestcase(yyruleno==364); |
| 183622 | | - /* (365) nm ::= STRING */ yytestcase(yyruleno==365); |
| 183623 | | - /* (366) typetoken ::= typename */ yytestcase(yyruleno==366); |
| 183624 | | - /* (367) typename ::= ID|STRING */ yytestcase(yyruleno==367); |
| 183625 | | - /* (368) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=368); |
| 183626 | | - /* (369) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=369); |
| 183627 | | - /* (370) carglist ::= carglist ccons */ yytestcase(yyruleno==370); |
| 183628 | | - /* (371) carglist ::= */ yytestcase(yyruleno==371); |
| 183629 | | - /* (372) ccons ::= NULL onconf */ yytestcase(yyruleno==372); |
| 183630 | | - /* (373) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==373); |
| 183631 | | - /* (374) ccons ::= AS generated */ yytestcase(yyruleno==374); |
| 183632 | | - /* (375) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==375); |
| 183633 | | - /* (376) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==376); |
| 183634 | | - /* (377) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=377); |
| 183635 | | - /* (378) tconscomma ::= */ yytestcase(yyruleno==378); |
| 183636 | | - /* (379) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=379); |
| 183637 | | - /* (380) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=380); |
| 183638 | | - /* (381) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=381); |
| 183639 | | - /* (382) oneselect ::= values */ yytestcase(yyruleno==382); |
| 183640 | | - /* (383) sclp ::= selcollist COMMA */ yytestcase(yyruleno==383); |
| 183641 | | - /* (384) as ::= ID|STRING */ yytestcase(yyruleno==384); |
| 183642 | | - /* (385) indexed_opt ::= indexed_by (OPTIMIZED OUT) */ assert(yyruleno!=385); |
| 183643 | | - /* (386) returning ::= */ yytestcase(yyruleno==386); |
| 183644 | | - /* (387) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=387); |
| 183645 | | - /* (388) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==388); |
| 183646 | | - /* (389) case_operand ::= expr */ yytestcase(yyruleno==389); |
| 183647 | | - /* (390) exprlist ::= nexprlist */ yytestcase(yyruleno==390); |
| 183648 | | - /* (391) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=391); |
| 183649 | | - /* (392) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=392); |
| 183650 | | - /* (393) nmnum ::= ON */ yytestcase(yyruleno==393); |
| 183651 | | - /* (394) nmnum ::= DELETE */ yytestcase(yyruleno==394); |
| 183652 | | - /* (395) nmnum ::= DEFAULT */ yytestcase(yyruleno==395); |
| 183653 | | - /* (396) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==396); |
| 183654 | | - /* (397) foreach_clause ::= */ yytestcase(yyruleno==397); |
| 183655 | | - /* (398) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==398); |
| 183656 | | - /* (399) trnm ::= nm */ yytestcase(yyruleno==399); |
| 183657 | | - /* (400) tridxby ::= */ yytestcase(yyruleno==400); |
| 183658 | | - /* (401) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==401); |
| 183659 | | - /* (402) database_kw_opt ::= */ yytestcase(yyruleno==402); |
| 183660 | | - /* (403) kwcolumn_opt ::= */ yytestcase(yyruleno==403); |
| 183661 | | - /* (404) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==404); |
| 183662 | | - /* (405) vtabarglist ::= vtabarg */ yytestcase(yyruleno==405); |
| 183663 | | - /* (406) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==406); |
| 183664 | | - /* (407) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==407); |
| 183665 | | - /* (408) anylist ::= */ yytestcase(yyruleno==408); |
| 183666 | | - /* (409) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==409); |
| 183667 | | - /* (410) anylist ::= anylist ANY */ yytestcase(yyruleno==410); |
| 183668 | | - /* (411) with ::= */ yytestcase(yyruleno==411); |
| 183669 | | - /* (412) windowdefn_list ::= windowdefn (OPTIMIZED OUT) */ assert(yyruleno!=412); |
| 183670 | | - /* (413) window ::= frame_opt (OPTIMIZED OUT) */ assert(yyruleno!=413); |
| 183414 | + case 295: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ |
| 183415 | +{ |
| 183416 | + sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy203, &yymsp[0].minor.yy0); |
| 183417 | +} |
| 183418 | + break; |
| 183419 | + case 296: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ |
| 183420 | +{ |
| 183421 | + sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy203, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); |
| 183422 | +} |
| 183423 | + break; |
| 183424 | + case 297: /* cmd ::= ALTER TABLE fullname DROP CONSTRAINT nm */ |
| 183425 | +{ |
| 183426 | + sqlite3AlterDropConstraint(pParse, yymsp[-3].minor.yy203, &yymsp[0].minor.yy0, 0); |
| 183427 | +} |
| 183428 | + break; |
| 183429 | + case 298: /* cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm DROP NOT NULL */ |
| 183430 | +{ |
| 183431 | + sqlite3AlterDropConstraint(pParse, yymsp[-6].minor.yy203, 0, &yymsp[-3].minor.yy0); |
| 183432 | +} |
| 183433 | + break; |
| 183434 | + case 299: /* cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm SET NOT NULL onconf */ |
| 183435 | +{ |
| 183436 | + sqlite3AlterSetNotNull(pParse, yymsp[-7].minor.yy203, &yymsp[-4].minor.yy0, &yymsp[-2].minor.yy0); |
| 183437 | +} |
| 183438 | + break; |
| 183439 | + case 300: /* cmd ::= ALTER TABLE fullname ADD CONSTRAINT nm CHECK LP expr RP onconf */ |
| 183440 | +{ |
| 183441 | + sqlite3AlterAddConstraint(pParse, yymsp[-8].minor.yy203, &yymsp[-6].minor.yy0, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy0.z+1, (yymsp[-1].minor.yy0.z-yymsp[-3].minor.yy0.z-1)); |
| 183442 | +} |
| 183443 | + yy_destructor(yypParser,219,&yymsp[-2].minor); |
| 183444 | + break; |
| 183445 | + case 301: /* cmd ::= ALTER TABLE fullname ADD CHECK LP expr RP onconf */ |
| 183446 | +{ |
| 183447 | + sqlite3AlterAddConstraint(pParse, yymsp[-6].minor.yy203, &yymsp[-4].minor.yy0, 0, yymsp[-3].minor.yy0.z+1, (yymsp[-1].minor.yy0.z-yymsp[-3].minor.yy0.z-1)); |
| 183448 | +} |
| 183449 | + yy_destructor(yypParser,219,&yymsp[-2].minor); |
| 183450 | + break; |
| 183451 | + case 302: /* cmd ::= create_vtab */ |
| 183452 | +{sqlite3VtabFinishParse(pParse,0);} |
| 183453 | + break; |
| 183454 | + case 303: /* cmd ::= create_vtab LP vtabarglist RP */ |
| 183455 | +{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);} |
| 183456 | + break; |
| 183457 | + case 304: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ |
| 183458 | +{ |
| 183459 | + sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy144); |
| 183460 | +} |
| 183461 | + break; |
| 183462 | + case 305: /* vtabarg ::= */ |
| 183463 | +{sqlite3VtabArgInit(pParse);} |
| 183464 | + break; |
| 183465 | + case 306: /* vtabargtoken ::= ANY */ |
| 183466 | + case 307: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==307); |
| 183467 | + case 308: /* lp ::= LP */ yytestcase(yyruleno==308); |
| 183468 | +{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);} |
| 183469 | + break; |
| 183470 | + case 309: /* with ::= WITH wqlist */ |
| 183471 | + case 310: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==310); |
| 183472 | +{ sqlite3WithPush(pParse, yymsp[0].minor.yy59, 1); } |
| 183473 | + break; |
| 183474 | + case 311: /* wqas ::= AS */ |
| 183475 | +{yymsp[0].minor.yy462 = M10d_Any;} |
| 183476 | + break; |
| 183477 | + case 312: /* wqas ::= AS MATERIALIZED */ |
| 183478 | +{yymsp[-1].minor.yy462 = M10d_Yes;} |
| 183479 | + break; |
| 183480 | + case 313: /* wqas ::= AS NOT MATERIALIZED */ |
| 183481 | +{yymsp[-2].minor.yy462 = M10d_No;} |
| 183482 | + break; |
| 183483 | + case 314: /* wqitem ::= withnm eidlist_opt wqas LP select RP */ |
| 183484 | +{ |
| 183485 | + yymsp[-5].minor.yy67 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy14, yymsp[-1].minor.yy555, yymsp[-3].minor.yy462); /*A-overwrites-X*/ |
| 183486 | +} |
| 183487 | + break; |
| 183488 | + case 315: /* withnm ::= nm */ |
| 183489 | +{pParse->bHasWith = 1;} |
| 183490 | + break; |
| 183491 | + case 316: /* wqlist ::= wqitem */ |
| 183492 | +{ |
| 183493 | + yymsp[0].minor.yy59 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy67); /*A-overwrites-X*/ |
| 183494 | +} |
| 183495 | + break; |
| 183496 | + case 317: /* wqlist ::= wqlist COMMA wqitem */ |
| 183497 | +{ |
| 183498 | + yymsp[-2].minor.yy59 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy59, yymsp[0].minor.yy67); |
| 183499 | +} |
| 183500 | + break; |
| 183501 | + case 318: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */ |
| 183502 | +{ |
| 183503 | + assert( yymsp[0].minor.yy211!=0 ); |
| 183504 | + sqlite3WindowChain(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy211); |
| 183505 | + yymsp[0].minor.yy211->pNextWin = yymsp[-2].minor.yy211; |
| 183506 | + yylhsminor.yy211 = yymsp[0].minor.yy211; |
| 183507 | +} |
| 183508 | + yymsp[-2].minor.yy211 = yylhsminor.yy211; |
| 183509 | + break; |
| 183510 | + case 319: /* windowdefn ::= nm AS LP window RP */ |
| 183511 | +{ |
| 183512 | + if( ALWAYS(yymsp[-1].minor.yy211) ){ |
| 183513 | + yymsp[-1].minor.yy211->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n); |
| 183514 | + } |
| 183515 | + yylhsminor.yy211 = yymsp[-1].minor.yy211; |
| 183516 | +} |
| 183517 | + yymsp[-4].minor.yy211 = yylhsminor.yy211; |
| 183518 | + break; |
| 183519 | + case 320: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */ |
| 183520 | +{ |
| 183521 | + yymsp[-4].minor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy14, yymsp[-1].minor.yy14, 0); |
| 183522 | +} |
| 183523 | + break; |
| 183524 | + case 321: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ |
| 183525 | +{ |
| 183526 | + yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy14, yymsp[-1].minor.yy14, &yymsp[-5].minor.yy0); |
| 183527 | +} |
| 183528 | + yymsp[-5].minor.yy211 = yylhsminor.yy211; |
| 183529 | + break; |
| 183530 | + case 322: /* window ::= ORDER BY sortlist frame_opt */ |
| 183531 | +{ |
| 183532 | + yymsp[-3].minor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, yymsp[-1].minor.yy14, 0); |
| 183533 | +} |
| 183534 | + break; |
| 183535 | + case 323: /* window ::= nm ORDER BY sortlist frame_opt */ |
| 183536 | +{ |
| 183537 | + yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0); |
| 183538 | +} |
| 183539 | + yymsp[-4].minor.yy211 = yylhsminor.yy211; |
| 183540 | + break; |
| 183541 | + case 324: /* window ::= nm frame_opt */ |
| 183542 | +{ |
| 183543 | + yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, 0, &yymsp[-1].minor.yy0); |
| 183544 | +} |
| 183545 | + yymsp[-1].minor.yy211 = yylhsminor.yy211; |
| 183546 | + break; |
| 183547 | + case 325: /* frame_opt ::= */ |
| 183548 | +{ |
| 183549 | + yymsp[1].minor.yy211 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0); |
| 183550 | +} |
| 183551 | + break; |
| 183552 | + case 326: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ |
| 183553 | +{ |
| 183554 | + yylhsminor.yy211 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy144, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy462); |
| 183555 | +} |
| 183556 | + yymsp[-2].minor.yy211 = yylhsminor.yy211; |
| 183557 | + break; |
| 183558 | + case 327: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ |
| 183559 | +{ |
| 183560 | + yylhsminor.yy211 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy144, yymsp[-3].minor.yy509.eType, yymsp[-3].minor.yy509.pExpr, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, yymsp[0].minor.yy462); |
| 183561 | +} |
| 183562 | + yymsp[-5].minor.yy211 = yylhsminor.yy211; |
| 183563 | + break; |
| 183564 | + case 329: /* frame_bound_s ::= frame_bound */ |
| 183565 | + case 331: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==331); |
| 183566 | +{yylhsminor.yy509 = yymsp[0].minor.yy509;} |
| 183567 | + yymsp[0].minor.yy509 = yylhsminor.yy509; |
| 183568 | + break; |
| 183569 | + case 330: /* frame_bound_s ::= UNBOUNDED PRECEDING */ |
| 183570 | + case 332: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==332); |
| 183571 | + case 334: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==334); |
| 183572 | +{yylhsminor.yy509.eType = yymsp[-1].major; yylhsminor.yy509.pExpr = 0;} |
| 183573 | + yymsp[-1].minor.yy509 = yylhsminor.yy509; |
| 183574 | + break; |
| 183575 | + case 333: /* frame_bound ::= expr PRECEDING|FOLLOWING */ |
| 183576 | +{yylhsminor.yy509.eType = yymsp[0].major; yylhsminor.yy509.pExpr = yymsp[-1].minor.yy454;} |
| 183577 | + yymsp[-1].minor.yy509 = yylhsminor.yy509; |
| 183578 | + break; |
| 183579 | + case 335: /* frame_exclude_opt ::= */ |
| 183580 | +{yymsp[1].minor.yy462 = 0;} |
| 183581 | + break; |
| 183582 | + case 336: /* frame_exclude_opt ::= EXCLUDE frame_exclude */ |
| 183583 | +{yymsp[-1].minor.yy462 = yymsp[0].minor.yy462;} |
| 183584 | + break; |
| 183585 | + case 337: /* frame_exclude ::= NO OTHERS */ |
| 183586 | + case 338: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==338); |
| 183587 | +{yymsp[-1].minor.yy462 = yymsp[-1].major; /*A-overwrites-X*/} |
| 183588 | + break; |
| 183589 | + case 339: /* frame_exclude ::= GROUP|TIES */ |
| 183590 | +{yymsp[0].minor.yy462 = yymsp[0].major; /*A-overwrites-X*/} |
| 183591 | + break; |
| 183592 | + case 340: /* window_clause ::= WINDOW windowdefn_list */ |
| 183593 | +{ yymsp[-1].minor.yy211 = yymsp[0].minor.yy211; } |
| 183594 | + break; |
| 183595 | + case 341: /* filter_over ::= filter_clause over_clause */ |
| 183596 | +{ |
| 183597 | + if( yymsp[0].minor.yy211 ){ |
| 183598 | + yymsp[0].minor.yy211->pFilter = yymsp[-1].minor.yy454; |
| 183599 | + }else{ |
| 183600 | + sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy454); |
| 183601 | + } |
| 183602 | + yylhsminor.yy211 = yymsp[0].minor.yy211; |
| 183603 | +} |
| 183604 | + yymsp[-1].minor.yy211 = yylhsminor.yy211; |
| 183605 | + break; |
| 183606 | + case 342: /* filter_over ::= over_clause */ |
| 183607 | +{ |
| 183608 | + yylhsminor.yy211 = yymsp[0].minor.yy211; |
| 183609 | +} |
| 183610 | + yymsp[0].minor.yy211 = yylhsminor.yy211; |
| 183611 | + break; |
| 183612 | + case 343: /* filter_over ::= filter_clause */ |
| 183613 | +{ |
| 183614 | + yylhsminor.yy211 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); |
| 183615 | + if( yylhsminor.yy211 ){ |
| 183616 | + yylhsminor.yy211->eFrmType = TK_FILTER; |
| 183617 | + yylhsminor.yy211->pFilter = yymsp[0].minor.yy454; |
| 183618 | + }else{ |
| 183619 | + sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy454); |
| 183620 | + } |
| 183621 | +} |
| 183622 | + yymsp[0].minor.yy211 = yylhsminor.yy211; |
| 183623 | + break; |
| 183624 | + case 344: /* over_clause ::= OVER LP window RP */ |
| 183625 | +{ |
| 183626 | + yymsp[-3].minor.yy211 = yymsp[-1].minor.yy211; |
| 183627 | + assert( yymsp[-3].minor.yy211!=0 ); |
| 183628 | +} |
| 183629 | + break; |
| 183630 | + case 345: /* over_clause ::= OVER nm */ |
| 183631 | +{ |
| 183632 | + yymsp[-1].minor.yy211 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); |
| 183633 | + if( yymsp[-1].minor.yy211 ){ |
| 183634 | + yymsp[-1].minor.yy211->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n); |
| 183635 | + } |
| 183636 | +} |
| 183637 | + break; |
| 183638 | + case 346: /* filter_clause ::= FILTER LP WHERE expr RP */ |
| 183639 | +{ yymsp[-4].minor.yy454 = yymsp[-1].minor.yy454; } |
| 183640 | + break; |
| 183641 | + case 347: /* term ::= QNUMBER */ |
| 183642 | +{ |
| 183643 | + yylhsminor.yy454=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); |
| 183644 | + sqlite3DequoteNumber(pParse, yylhsminor.yy454); |
| 183645 | +} |
| 183646 | + yymsp[0].minor.yy454 = yylhsminor.yy454; |
| 183647 | + break; |
| 183648 | + default: |
| 183649 | + /* (348) input ::= cmdlist */ yytestcase(yyruleno==348); |
| 183650 | + /* (349) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==349); |
| 183651 | + /* (350) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=350); |
| 183652 | + /* (351) ecmd ::= SEMI */ yytestcase(yyruleno==351); |
| 183653 | + /* (352) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==352); |
| 183654 | + /* (353) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=353); |
| 183655 | + /* (354) trans_opt ::= */ yytestcase(yyruleno==354); |
| 183656 | + /* (355) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==355); |
| 183657 | + /* (356) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==356); |
| 183658 | + /* (357) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==357); |
| 183659 | + /* (358) savepoint_opt ::= */ yytestcase(yyruleno==358); |
| 183660 | + /* (359) cmd ::= create_table create_table_args */ yytestcase(yyruleno==359); |
| 183661 | + /* (360) table_option_set ::= table_option (OPTIMIZED OUT) */ assert(yyruleno!=360); |
| 183662 | + /* (361) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==361); |
| 183663 | + /* (362) columnlist ::= columnname carglist */ yytestcase(yyruleno==362); |
| 183664 | + /* (363) nm ::= ID|INDEXED|JOIN_KW */ yytestcase(yyruleno==363); |
| 183665 | + /* (364) nm ::= STRING */ yytestcase(yyruleno==364); |
| 183666 | + /* (365) typetoken ::= typename */ yytestcase(yyruleno==365); |
| 183667 | + /* (366) typename ::= ID|STRING */ yytestcase(yyruleno==366); |
| 183668 | + /* (367) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=367); |
| 183669 | + /* (368) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=368); |
| 183670 | + /* (369) carglist ::= carglist ccons */ yytestcase(yyruleno==369); |
| 183671 | + /* (370) carglist ::= */ yytestcase(yyruleno==370); |
| 183672 | + /* (371) ccons ::= NULL onconf */ yytestcase(yyruleno==371); |
| 183673 | + /* (372) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==372); |
| 183674 | + /* (373) ccons ::= AS generated */ yytestcase(yyruleno==373); |
| 183675 | + /* (374) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==374); |
| 183676 | + /* (375) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==375); |
| 183677 | + /* (376) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=376); |
| 183678 | + /* (377) tconscomma ::= */ yytestcase(yyruleno==377); |
| 183679 | + /* (378) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=378); |
| 183680 | + /* (379) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=379); |
| 183681 | + /* (380) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=380); |
| 183682 | + /* (381) oneselect ::= values */ yytestcase(yyruleno==381); |
| 183683 | + /* (382) sclp ::= selcollist COMMA */ yytestcase(yyruleno==382); |
| 183684 | + /* (383) as ::= ID|STRING */ yytestcase(yyruleno==383); |
| 183685 | + /* (384) indexed_opt ::= indexed_by (OPTIMIZED OUT) */ assert(yyruleno!=384); |
| 183686 | + /* (385) returning ::= */ yytestcase(yyruleno==385); |
| 183687 | + /* (386) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=386); |
| 183688 | + /* (387) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==387); |
| 183689 | + /* (388) case_operand ::= expr */ yytestcase(yyruleno==388); |
| 183690 | + /* (389) exprlist ::= nexprlist */ yytestcase(yyruleno==389); |
| 183691 | + /* (390) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=390); |
| 183692 | + /* (391) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=391); |
| 183693 | + /* (392) nmnum ::= ON */ yytestcase(yyruleno==392); |
| 183694 | + /* (393) nmnum ::= DELETE */ yytestcase(yyruleno==393); |
| 183695 | + /* (394) nmnum ::= DEFAULT */ yytestcase(yyruleno==394); |
| 183696 | + /* (395) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==395); |
| 183697 | + /* (396) foreach_clause ::= */ yytestcase(yyruleno==396); |
| 183698 | + /* (397) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==397); |
| 183699 | + /* (398) tridxby ::= */ yytestcase(yyruleno==398); |
| 183700 | + /* (399) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==399); |
| 183701 | + /* (400) database_kw_opt ::= */ yytestcase(yyruleno==400); |
| 183702 | + /* (401) kwcolumn_opt ::= */ yytestcase(yyruleno==401); |
| 183703 | + /* (402) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==402); |
| 183704 | + /* (403) vtabarglist ::= vtabarg */ yytestcase(yyruleno==403); |
| 183705 | + /* (404) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==404); |
| 183706 | + /* (405) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==405); |
| 183707 | + /* (406) anylist ::= */ yytestcase(yyruleno==406); |
| 183708 | + /* (407) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==407); |
| 183709 | + /* (408) anylist ::= anylist ANY */ yytestcase(yyruleno==408); |
| 183710 | + /* (409) with ::= */ yytestcase(yyruleno==409); |
| 183711 | + /* (410) windowdefn_list ::= windowdefn (OPTIMIZED OUT) */ assert(yyruleno!=410); |
| 183712 | + /* (411) window ::= frame_opt (OPTIMIZED OUT) */ assert(yyruleno!=411); |
| 183671 | 183713 | break; |
| 183672 | 183714 | /********** End reduce actions ************************************************/ |
| 183673 | 183715 | }; |
| 183674 | 183716 | assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) ); |
| 183675 | 183717 | yygoto = yyRuleInfoLhs[yyruleno]; |
| | @@ -184444,12 +184486,12 @@ |
| 184444 | 184486 | ** 126: UPDATE UNIQUE |
| 184445 | 184487 | */ |
| 184446 | 184488 | /* Check to see if z[0..n-1] is a keyword. If it is, write the |
| 184447 | 184489 | ** parser symbol code for that keyword into *pType. Always |
| 184448 | 184490 | ** return the integer n (the length of the token). */ |
| 184449 | | -static int keywordCode(const char *z, int n, int *pType){ |
| 184450 | | - int i, j; |
| 184491 | +static i64 keywordCode(const char *z, i64 n, int *pType){ |
| 184492 | + i64 i, j; |
| 184451 | 184493 | const char *zKW; |
| 184452 | 184494 | assert( n>=2 ); |
| 184453 | 184495 | i = ((charMap(z[0])*4) ^ (charMap(z[n-1])*3) ^ n*1) % 127; |
| 184454 | 184496 | for(i=(int)aKWHash[i]; i>0; i=aKWNext[i]){ |
| 184455 | 184497 | if( aKWLen[i]!=n ) continue; |
| | @@ -185095,11 +185137,11 @@ |
| 185095 | 185137 | void *pEngine; /* The LEMON-generated LALR(1) parser */ |
| 185096 | 185138 | i64 n = 0; /* Length of the next token token */ |
| 185097 | 185139 | int tokenType; /* type of the next token */ |
| 185098 | 185140 | int lastTokenParsed = -1; /* type of the previous token */ |
| 185099 | 185141 | sqlite3 *db = pParse->db; /* The database connection */ |
| 185100 | | - int mxSqlLen; /* Max length of an SQL string */ |
| 185142 | + i64 mxSqlLen; /* Max length of an SQL string */ |
| 185101 | 185143 | Parse *pParentParse = 0; /* Outer parse context, if any */ |
| 185102 | 185144 | #ifdef sqlite3Parser_ENGINEALWAYSONSTACK |
| 185103 | 185145 | yyParser sEngine; /* Space to hold the Lemon-generated Parser object */ |
| 185104 | 185146 | #endif |
| 185105 | 185147 | VVA_ONLY( u8 startedWithOom = db->mallocFailed ); |
| | @@ -188724,10 +188766,13 @@ |
| 188724 | 188766 | #if SQLITE_MAX_SQL_LENGTH<100 |
| 188725 | 188767 | # error SQLITE_MAX_SQL_LENGTH must be at least 100 |
| 188726 | 188768 | #endif |
| 188727 | 188769 | #if SQLITE_MAX_SQL_LENGTH>SQLITE_MAX_LENGTH |
| 188728 | 188770 | # error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH |
| 188771 | +#endif |
| 188772 | +#if SQLITE_MAX_SQL_LENGTH>2147482624 /* 1024 less than 2^31 */ |
| 188773 | +# error SQLITE_MAX_SQL_LENGTH must not be greater than 2147482624 |
| 188729 | 188774 | #endif |
| 188730 | 188775 | #if SQLITE_MAX_COMPOUND_SELECT<2 |
| 188731 | 188776 | # error SQLITE_MAX_COMPOUND_SELECT must be at least 2 |
| 188732 | 188777 | #endif |
| 188733 | 188778 | #if SQLITE_MAX_VDBE_OP<40 |
| | @@ -261267,11 +261312,11 @@ |
| 261267 | 261312 | int nArg, /* Number of args */ |
| 261268 | 261313 | sqlite3_value **apUnused /* Function arguments */ |
| 261269 | 261314 | ){ |
| 261270 | 261315 | assert( nArg==0 ); |
| 261271 | 261316 | UNUSED_PARAM2(nArg, apUnused); |
| 261272 | | - sqlite3_result_text(pCtx, "fts5: 2025-11-28 17:56:22 4384c9a108b58a0b8c38c51678aad871f088358b9bff3922299cc7ddb3d247ce", -1, SQLITE_TRANSIENT); |
| 261317 | + sqlite3_result_text(pCtx, "fts5: 2025-12-05 12:22:23 aa0a28776bbeafb71b2db20ac8c16377ba07b7d3d58e46cfd11f60c694759a90", -1, SQLITE_TRANSIENT); |
| 261273 | 261318 | } |
| 261274 | 261319 | |
| 261275 | 261320 | /* |
| 261276 | 261321 | ** Implementation of fts5_locale(LOCALE, TEXT) function. |
| 261277 | 261322 | ** |
| 261278 | 261323 | |