Fossil

    }
  }else

  if( (c=='o'
        && (strncmp(azArg[0], "output", n)==0||strncmp(azArg[0], "once", n)==0))
   || (c=='e' && n==5 && strcmp(azArg[0],"excel")==0)
  ){
    char *zFile = 0;
    int bTxtMode = 0;
    int i;
    int eMode = 0;
    int bBOM = 0;
    int bOnce = 0;  /* 0: .output, 1: .once, 2: .excel */

    if( c=='e' ){

        }else{
          utf8_printf(p->out, "ERROR: unknown option: \"%s\".  Usage:\n",
                      azArg[i]);
          showHelp(p->out, azArg[0]);
          rc = 1;
          goto meta_command_exit;
        }
      }else if( zFile==0 && eMode!='e' && eMode!='x' ){
        zFile = sqlite3_mprintf("%s", z);
        if( zFile[0]=='|' ){
          while( i+1<nArg ) zFile = sqlite3_mprintf("%z %s", zFile, azArg[++i]);
          break;
        }
      }else{
        utf8_printf(p->out,"ERROR: extra parameter: \"%s\".  Usage:\n",
                    azArg[i]);
        showHelp(p->out, azArg[0]);
        rc = 1;
        sqlite3_free(zFile);
        goto meta_command_exit;
      }
    }
    if( zFile==0 ) zFile = sqlite3_mprintf("stdout");
    if( bOnce ){
      p->outCount = 2;
    }else{
      p->outCount = 0;
    }
    output_reset(p);
#ifndef SQLITE_NOHAVE_SYSTEM

        sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
        sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
      }else{
        /* text editor mode */
        newTempFile(p, "txt");
        bTxtMode = 1;
      }
      sqlite3_free(zFile);
      zFile = sqlite3_mprintf("%s", p->zTempFile);
    }
#endif /* SQLITE_NOHAVE_SYSTEM */
    if( zFile[0]=='|' ){
#ifdef SQLITE_OMIT_POPEN
      raw_printf(stderr, "Error: pipes are not supported in this OS\n");
      rc = 1;
      p->out = stdout;

        p->out = stdout;
        rc = 1;
      } else {
        if( bBOM ) fprintf(p->out,"\357\273\277");
        sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
      }
    }
    sqlite3_free(zFile);
  }else

  if( c=='p' && n>=3 && strncmp(azArg[0], "parameter", n)==0 ){
    open_db(p,0);
    if( nArg<=1 ) goto parameter_syntax_error;

    /* .parameter clear

** The SQLITE_VERSION_NUMBER for any given release of SQLite will also
** be larger than the release from which it is derived.  Either Y will
** be held constant and Z will be incremented or else Y will be incremented
** and Z will be reset to zero.
**
** Since [version 3.6.18] ([dateof:3.6.18]),
** SQLite source code has been stored in the
** <a href="http://www.fossil-scm.org/">Fossil configuration management
** system</a>.  ^The SQLITE_SOURCE_ID macro evaluates to
** a string which identifies a particular check-in of SQLite
** within its configuration management system.  ^The SQLITE_SOURCE_ID
** string contains the date and time of the check-in (UTC) and a SHA1
** or SHA3-256 hash of the entire source tree.  If the source code has
** been edited in any way since it was last checked in, then the last
** four hexadecimal digits of the hash may be modified.
**
** See also: [sqlite3_libversion()],
** [sqlite3_libversion_number()], [sqlite3_sourceid()],
** [sqlite_version()] and [sqlite_source_id()].
*/
#define SQLITE_VERSION        "3.35.0"
#define SQLITE_VERSION_NUMBER 3035000
#define SQLITE_SOURCE_ID      "2021-02-19 14:32:58 c844a331e78949850fde8ed95058cb34f863566944bc9e92e3ae042768f130e1"

/*
** CAPI3REF: Run-Time Library Version Numbers
** KEYWORDS: sqlite3_version sqlite3_sourceid
**
** These interfaces provide the same information as the [SQLITE_VERSION],
** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros

# define sqlite3ExplainBreakpoint(A,B) /*no-op*/
#endif
#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_EXPLAIN)
SQLITE_PRIVATE   void sqlite3ExplainBreakpoint(const char*,const char*);
#else
# define sqlite3ExplainBreakpoint(A,B) /*no-op*/
#endif
SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe*, int, char*, u16);
SQLITE_PRIVATE void sqlite3VdbeChangeOpcode(Vdbe*, int addr, u8);
SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, int addr, int P1);
SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, int addr, int P2);
SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, int addr, int P3);
SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe*, u16 P5);
SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe*, int addr);
SQLITE_PRIVATE void sqlite3VdbeJumpHereOrPopInst(Vdbe*, int addr);

  u8 notNull;      /* An OE_ code for handling a NOT NULL constraint */
  char affinity;   /* One of the SQLITE_AFF_... values */
  u8 szEst;        /* Estimated size of value in this column. sizeof(INT)==1 */
  u8 hName;        /* Column name hash for faster lookup */
  u16 colFlags;    /* Boolean properties.  See COLFLAG_ defines below */
};

/* Allowed values for Column.colFlags.
**
** Constraints:
**         TF_HasVirtual == COLFLAG_VIRTUAL
**         TF_HasStored  == COLFLAG_STORED
**         TF_HasHidden  == COLFLAG_HIDDEN
*/
#define COLFLAG_PRIMKEY   0x0001   /* Column is part of the primary key */
#define COLFLAG_HIDDEN    0x0002   /* A hidden column in a virtual table */
#define COLFLAG_HASTYPE   0x0004   /* Type name follows column name */
#define COLFLAG_UNIQUE    0x0008   /* Column def contains "UNIQUE" or "PK" */
#define COLFLAG_SORTERREF 0x0010   /* Use sorter-refs with this column */
#define COLFLAG_VIRTUAL   0x0020   /* GENERATED ALWAYS AS ... VIRTUAL */

** followed by non-hidden columns.  Example:  "CREATE VIRTUAL TABLE x USING
** vtab1(a HIDDEN, b);".  Since "b" is a non-hidden column but "a" is hidden,
** the TF_OOOHidden attribute would apply in this case.  Such tables require
** special handling during INSERT processing. The "OOO" means "Out Of Order".
**
** Constraints:
**
**         TF_HasVirtual == COLFLAG_VIRTUAL
**         TF_HasStored  == COLFLAG_STORED
**         TF_HasHidden  == COLFLAG_HIDDEN
*/
#define TF_Readonly        0x0001    /* Read-only system table */
#define TF_HasHidden       0x0002    /* Has one or more hidden columns */
#define TF_HasPrimaryKey   0x0004    /* Table has a primary key */
#define TF_Autoincrement   0x0008    /* Integer primary key is autoincrement */
#define TF_HasStat1        0x0010    /* nRowLogEst set from sqlite_stat1 */
#define TF_HasVirtual      0x0020    /* Has one or more VIRTUAL columns */
#define TF_HasStored       0x0040    /* Has one or more STORED columns */
#define TF_HasGenerated    0x0060    /* Combo: HasVirtual + HasStored */
#define TF_WithoutRowid    0x0080    /* No rowid.  PRIMARY KEY is the key */
#define TF_StatsUsed       0x0100    /* Query planner decisions affected by
                                     ** Index.aiRowLogEst[] values */
#define TF_NoVisibleRowid  0x0200    /* No user-visible "rowid" column */
#define TF_OOOHidden       0x0400    /* Out-of-Order hidden columns */
#define TF_HasNotNull      0x0800    /* Contains NOT NULL constraints */
#define TF_Shadow          0x1000    /* True for a shadow table */
#define TF_HasStat4        0x2000    /* STAT4 info available for this table */
#define TF_Ephemeral       0x4000    /* An ephemeral table */

/*
** Test to see whether or not a table is a virtual table.  This is
** done as a macro so that it will be optimized out when virtual
** table support is omitted from the build.
*/
#ifndef SQLITE_OMIT_VIRTUALTABLE

    Expr *pFExpr;            /* Expression encoding the function */
    FuncDef *pFunc;          /* The aggregate function implementation */
    int iMem;                /* Memory location that acts as accumulator */
    int iDistinct;           /* Ephemeral table used to enforce DISTINCT */
  } *aFunc;
  int nFunc;              /* Number of entries in aFunc[] */
  u32 selId;              /* Select to which this AggInfo belongs */

};

/*
** The datatype ynVar is a signed integer, either 16-bit or 32-bit.
** Usually it is 16-bits.  But if SQLITE_MAX_VARIABLE_NUMBER is greater
** than 32767 we have to make it 32-bit.  16-bit is preferred because
** it uses less memory in the Expr object, which is a big memory user

#define SF_IncludeHidden 0x0020000 /* Include hidden columns in output */
#define SF_ComplexResult 0x0040000 /* Result contains subquery or function */
#define SF_WhereBegin    0x0080000 /* Really a WhereBegin() call.  Debug Only */
#define SF_WinRewrite    0x0100000 /* Window function rewrite accomplished */
#define SF_View          0x0200000 /* SELECT statement is a view */
#define SF_NoopOrderBy   0x0400000 /* ORDER BY is ignored for this query */
#define SF_UpdateFrom    0x0800000 /* Statement is an UPDATE...FROM */
#define SF_PushDown      0x1000000 /* SELECT has be modified by push-down opt */

/*
** The results of a SELECT can be distributed in several ways, as defined
** by one of the following macros.  The "SRT" prefix means "SELECT Result
** Type".
**
**     SRT_Union       Store results as a key in a temporary index

  int nTableLock;        /* Number of locks in aTableLock */
  TableLock *aTableLock; /* Required table locks for shared-cache mode */
#endif
  AutoincInfo *pAinc;  /* Information about AUTOINCREMENT counters */
  Parse *pToplevel;    /* Parse structure for main program (or NULL) */
  Table *pTriggerTab;  /* Table triggers are being coded for */
  Parse *pParentParse; /* Parent parser if this parser is nested */

  union {
    int addrCrTab;         /* Address of OP_CreateBtree on CREATE TABLE */
    Returning *pReturning; /* The RETURNING clause */
  } u1;
  u32 nQueryLoop;      /* Est number of iterations of a query (10*log2(N)) */
  u32 oldmask;         /* Mask of old.* columns referenced */
  u32 newmask;         /* Mask of new.* columns referenced */

  u32 nInitRow;       /* Number of rows processed */
  Pgno mxPage;        /* Maximum page number.  0 for no limit. */
} InitData;

/*
** Allowed values for mInitFlags
*/
#define INITFLAG_AlterRename   0x0001  /* Reparse after a RENAME */
#define INITFLAG_AlterDrop     0x0002  /* Reparse after a DROP COLUMN */

/*
** Structure containing global configuration data for the SQLite library.
**
** This structure also contains some state information.
*/
struct Sqlite3Config {

# define sqlite3ParseToplevel(p) p
# define sqlite3IsToplevel(p) 1
# define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0
# define sqlite3TriggerStepSrc(A,B) 0
#endif

SQLITE_PRIVATE int sqlite3JoinType(Parse*, Token*, Token*, Token*);
SQLITE_PRIVATE int sqlite3ColumnIndex(Table *pTab, const char *zCol);
SQLITE_PRIVATE void sqlite3SetJoinExpr(Expr*,int);
SQLITE_PRIVATE void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int);
SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse*, int);
#ifndef SQLITE_OMIT_AUTHORIZATION
SQLITE_PRIVATE   void sqlite3AuthRead(Parse*,Expr*,Schema*,SrcList*);
SQLITE_PRIVATE   int sqlite3AuthCheck(Parse*,int, const char*, const char*, const char*);
SQLITE_PRIVATE   void sqlite3AuthContextPush(Parse*, AuthContext*, const char*);

SQLITE_PRIVATE int sqlite3ResolveExprListNames(NameContext*, ExprList*);
SQLITE_PRIVATE void sqlite3ResolveSelectNames(Parse*, Select*, NameContext*);
SQLITE_PRIVATE int sqlite3ResolveSelfReference(Parse*,Table*,int,Expr*,ExprList*);
SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy(Parse*, Select*, ExprList*, const char*);
SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *, Table *, int, int);
SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *, Token *);
SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *, SrcList *);
SQLITE_PRIVATE void sqlite3AlterDropColumn(Parse*, SrcList*, Token*);
SQLITE_PRIVATE void *sqlite3RenameTokenMap(Parse*, void*, Token*);
SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse*, void *pTo, void *pFrom);
SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse*, Expr*);
SQLITE_PRIVATE void sqlite3RenameExprlistUnmap(Parse*, ExprList*);
SQLITE_PRIVATE CollSeq *sqlite3GetCollSeq(Parse*, u8, CollSeq *, const char*);
SQLITE_PRIVATE char sqlite3AffinityType(const char*, Column*);
SQLITE_PRIVATE void sqlite3Analyze(Parse*, Token*, Token*);

** Add an OP_ParseSchema opcode.  This routine is broken out from
** sqlite3VdbeAddOp4() since it needs to also needs to mark all btrees
** as having been used.
**
** The zWhere string must have been obtained from sqlite3_malloc().
** This routine will take ownership of the allocated memory.
*/
SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere, u16 p5){
  int j;
  sqlite3VdbeAddOp4(p, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC);
  sqlite3VdbeChangeP5(p, p5);
  for(j=0; j<p->db->nDb; j++) sqlite3VdbeUsesBtree(p, j);
  sqlite3MayAbort(p->pParse);
}

/*
** Add an opcode that includes the p4 value as an integer.
*/

  assert( iDb>=0 && iDb<db->nDb );
  assert( DbHasProperty(db, iDb, DB_SchemaLoaded) );

#ifndef SQLITE_OMIT_ALTERTABLE
  if( pOp->p4.z==0 ){
    sqlite3SchemaClear(db->aDb[iDb].pSchema);
    db->mDbFlags &= ~DBFLAG_SchemaKnownOk;
    rc = sqlite3InitOne(db, iDb, &p->zErrMsg, pOp->p5);
    db->mDbFlags |= DBFLAG_SchemaChange;
    p->expired = 0;
  }else
#endif
  {
    zSchema = DFLT_SCHEMA_TABLE;
    initData.db = db;

** structures must be increased by the nSubquery amount.
*/
static void resolveAlias(
  Parse *pParse,         /* Parsing context */
  ExprList *pEList,      /* A result set */
  int iCol,              /* A column in the result set.  0..pEList->nExpr-1 */
  Expr *pExpr,           /* Transform this into an alias to the result set */

  int nSubquery          /* Number of subqueries that the label is moving */
){
  Expr *pOrig;           /* The iCol-th column of the result set */
  Expr *pDup;            /* Copy of pOrig */
  sqlite3 *db;           /* The database connection */

  assert( iCol>=0 && iCol<pEList->nExpr );
  pOrig = pEList->a[iCol].pExpr;
  assert( pOrig!=0 );
  db = pParse->db;
  pDup = sqlite3ExprDup(db, pOrig, 0);
  if( pDup!=0 ){
    incrAggFunctionDepth(pDup, nSubquery);
    if( pExpr->op==TK_COLLATE ){
      pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
    }

    /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This
    ** prevents ExprDelete() from deleting the Expr structure itself,
    ** allowing it to be repopulated by the memcpy() on the following line.

        pSchema = pExpr->y.pTab->pSchema;
      }
    } /* if( pSrcList ) */

#if !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT)
    /* If we have not already resolved the name, then maybe
    ** it is a new.* or old.* trigger argument reference.  Or
    ** maybe it is an excluded.* from an upsert.  Or maybe it is
    ** a reference in the RETURNING clause to a table being modified.
    */
    if( cnt==0 && zDb==0 ){
      pTab = 0;
#ifndef SQLITE_OMIT_TRIGGER
      if( pParse->pTriggerTab!=0 ){
        int op = pParse->eTriggerOp;
        assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT );
        if( op!=TK_DELETE && zTab && sqlite3StrICmp("new",zTab) == 0 ){
          pExpr->iTable = 1;
          pTab = pParse->pTriggerTab;
        }else if( op!=TK_INSERT && zTab && sqlite3StrICmp("old",zTab)==0 ){
          pExpr->iTable = 0;
          pTab = pParse->pTriggerTab;
        }else if( pParse->bReturning && (pNC->ncFlags & NC_UBaseReg)!=0 ){
          pExpr->iTable = op!=TK_DELETE;
          pTab = pParse->pTriggerTab;
        }
      }
#endif /* SQLITE_OMIT_TRIGGER */
#ifndef SQLITE_OMIT_UPSERT
      if( (pNC->ncFlags & NC_UUpsert)!=0 && zTab!=0 ){
        Upsert *pUpsert = pNC->uNC.pUpsert;
        if( pUpsert && sqlite3StrICmp("excluded",zTab)==0 ){
          pTab = pUpsert->pUpsertSrc->a[0].pTab;
          pExpr->iTable = EXCLUDED_TABLE_NUMBER;
        }
      }
#endif /* SQLITE_OMIT_UPSERT */

          }else
#endif /* SQLITE_OMIT_UPSERT */
          {
            pExpr->y.pTab = pTab;
            if( pParse->bReturning ){
              eNewExprOp = TK_REGISTER;
              pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable
                                + iCol + 1;
            }else{
              pExpr->iColumn = (i16)iCol;
              eNewExprOp = TK_TRIGGER;
#ifndef SQLITE_OMIT_TRIGGER
              if( iCol<0 ){
                pExpr->affExpr = SQLITE_AFF_INTEGER;
              }else if( pExpr->iTable==0 ){

            sqlite3ErrorMsg(pParse, "misuse of aliased window function %s",zAs);
            return WRC_Abort;
          }
          if( sqlite3ExprVectorSize(pOrig)!=1 ){
            sqlite3ErrorMsg(pParse, "row value misused");
            return WRC_Abort;
          }
          resolveAlias(pParse, pEList, j, pExpr, nSubquery);
          cnt = 1;
          pMatch = 0;
          assert( zTab==0 && zDb==0 );
          if( IN_RENAME_OBJECT ){
            sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr);
          }
          goto lookupname_end;

  */
  if( pExpr->iColumn>=0 && pMatch!=0 ){
    pMatch->colUsed |= sqlite3ExprColUsed(pExpr);
  }

  /* Clean up and return
  */
  if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
    sqlite3ExprDelete(db, pExpr->pLeft);
    pExpr->pLeft = 0;
    sqlite3ExprDelete(db, pExpr->pRight);
    pExpr->pRight = 0;
  }
  pExpr->op = eNewExprOp;
  ExprSetProperty(pExpr, EP_Leaf);
lookupname_end:
  if( cnt==1 ){
    assert( pNC!=0 );
    if( pParse->db->xAuth
     && (pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER)

  assert( pEList!=0 );  /* sqlite3SelectNew() guarantees this */
  for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
    if( pItem->u.x.iOrderByCol ){
      if( pItem->u.x.iOrderByCol>pEList->nExpr ){
        resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr);
        return 1;
      }
      resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,0);

    }
  }
  return 0;
}

#ifndef SQLITE_OMIT_WINDOWFUNC
/*

    ** other expressions in the SELECT statement. This is so that
    ** expressions in the WHERE clause (etc.) can refer to expressions by
    ** aliases in the result set.
    **
    ** Minor point: If this is the case, then the expression will be
    ** re-evaluated for each reference to it.
    */
    assert( (sNC.ncFlags & (NC_UAggInfo|NC_UUpsert|NC_UBaseReg))==0 );
    sNC.uNC.pEList = p->pEList;
    sNC.ncFlags |= NC_UEList;
    if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort;
    if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort;

    /* Resolve names in table-valued-function arguments */
    for(i=0; i<p->pSrc->nSrc; i++){

/*
** Generate code to verify that the schemas of database zDb and, if
** bTemp is not true, database "temp", can still be parsed. This is
** called at the end of the generation of an ALTER TABLE ... RENAME ...
** statement to ensure that the operation has not rendered any schema
** objects unusable.
*/
static void renameTestSchema(
  Parse *pParse,                  /* Parse context */
  const char *zDb,                /* Name of db to verify schema of */
  int bTemp,                      /* True if this is the temp db */
  const char *zWhen               /* "when" part of error message */
){
  pParse->colNamesSet = 1;
  sqlite3NestedParse(pParse,
      "SELECT 1 "
      "FROM \"%w\"." DFLT_SCHEMA_TABLE " "
      "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
      " AND sql NOT LIKE 'create virtual%%'"
      " AND sqlite_rename_test(%Q, sql, type, name, %d, %Q)=NULL ",
      zDb,
      zDb, bTemp, zWhen
  );

  if( bTemp==0 ){
    sqlite3NestedParse(pParse,
        "SELECT 1 "
        "FROM temp." DFLT_SCHEMA_TABLE " "
        "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
        " AND sql NOT LIKE 'create virtual%%'"
        " AND sqlite_rename_test(%Q, sql, type, name, 1, %Q)=NULL ",
        zDb, zWhen
    );
  }
}

/*
** Generate code to reload the schema for database iDb. And, if iDb!=1, for
** the temp database as well.
*/
static void renameReloadSchema(Parse *pParse, int iDb, u16 p5){
  Vdbe *v = pParse->pVdbe;
  if( v ){
    sqlite3ChangeCookie(pParse, iDb);
    sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0, p5);
    if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0, p5);
  }
}

/*
** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy"
** command.
*/

  ** as required.  */
  if( iDb!=1 ){
    sqlite3NestedParse(pParse,
        "UPDATE sqlite_temp_schema SET "
            "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, 1), "
            "tbl_name = "
              "CASE WHEN tbl_name=%Q COLLATE nocase AND "
              "    sqlite_rename_test(%Q, sql, type, name, 1, 'after rename') "
              "THEN %Q ELSE tbl_name END "
            "WHERE type IN ('view', 'trigger')"
        , zDb, zTabName, zName, zTabName, zDb, zName);
  }

  /* If this is a virtual table, invoke the xRename() function if
  ** one is defined. The xRename() callback will modify the names
  ** of any resources used by the v-table implementation (including other
  ** SQLite tables) that are identified by the name of the virtual table.
  */
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( pVTab ){
    int i = ++pParse->nMem;
    sqlite3VdbeLoadString(v, i, zName);
    sqlite3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pVTab, P4_VTAB);
  }
#endif

  renameReloadSchema(pParse, iDb, INITFLAG_AlterRename);
  renameTestSchema(pParse, zDb, iDb==1, "after rename");

exit_rename_table:
  sqlite3SrcListDelete(db, pSrc);
  sqlite3DbFree(db, zName);
  db->mDbFlags = savedDbFlags;
}

    sqlite3VdbeAddOp2(v, OP_IfPos, r1, sqlite3VdbeCurrentAddr(v)+2);
    VdbeCoverage(v);
    sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3);
    sqlite3ReleaseTempReg(pParse, r1);
  }

  /* Reload the table definition */
  renameReloadSchema(pParse, iDb, INITFLAG_AlterRename);
}

/*
** This function is called by the parser after the table-name in
** an "ALTER TABLE <table-name> ADD" statement is parsed. Argument
** pSrc is the full-name of the table being altered.
**

** command. This function checks if the table is a view or virtual
** table (columns of views or virtual tables may not be renamed). If so,
** it loads an error message into pParse and returns non-zero.
**
** Or, if pTab is not a view or virtual table, zero is returned.
*/
#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
static int isRealTable(Parse *pParse, Table *pTab, int bDrop){
  const char *zType = 0;
#ifndef SQLITE_OMIT_VIEW
  if( pTab->pSelect ){
    zType = "view";
  }
#endif
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( IsVirtual(pTab) ){
    zType = "virtual table";
  }
#endif
  if( zType ){
    sqlite3ErrorMsg(pParse, "cannot %s %s \"%s\"",
        (bDrop ? "drop column from" : "rename columns of"),
        zType, pTab->zName
    );
    return 1;
  }
  return 0;
}
#else /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */
# define isRealTable(x,y,z) (0)
#endif

/*
** Handles the following parser reduction:
**
**  cmd ::= ALTER TABLE pSrc RENAME COLUMN pOld TO pNew
*/

  /* Locate the table to be altered */
  pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
  if( !pTab ) goto exit_rename_column;

  /* Cannot alter a system table */
  if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_rename_column;
  if( SQLITE_OK!=isRealTable(pParse, pTab, 0) ) goto exit_rename_column;

  /* Which schema holds the table to be altered */
  iSchema = sqlite3SchemaToIndex(db, pTab->pSchema);
  assert( iSchema>=0 );
  zDb = db->aDb[iSchema].zDbSName;

#ifndef SQLITE_OMIT_AUTHORIZATION

      "UPDATE temp." DFLT_SCHEMA_TABLE " SET "
      "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, 1) "
      "WHERE type IN ('trigger', 'view')",
      zDb, pTab->zName, iCol, zNew, bQuote
  );

  /* Drop and reload the database schema. */
  renameReloadSchema(pParse, iSchema, INITFLAG_AlterRename);
  renameTestSchema(pParse, zDb, iSchema==1, "after rename");

 exit_rename_column:
  sqlite3SrcListDelete(db, pSrc);
  sqlite3DbFree(db, zOld);
  sqlite3DbFree(db, zNew);
  return;
}

    pNext = p->pNext;
    sqlite3DbFree(db, p);
  }
}

/*
** Search the Parse object passed as the first argument for a RenameToken
** object associated with parse tree element pPtr. If found, return a pointer
** to it. Otherwise, return NULL.
**
** If the second argument passed to this function is not NULL and a matching
** RenameToken object is found, remove it from the Parse object and add it to
** the list maintained by the RenameCtx object.
*/
static RenameToken *renameTokenFind(
  Parse *pParse,
  struct RenameCtx *pCtx,
  void *pPtr
){
  RenameToken **pp;
  assert( pPtr!=0 );
  for(pp=&pParse->pRename; (*pp); pp=&(*pp)->pNext){
    if( (*pp)->p==pPtr ){
      RenameToken *pToken = *pp;
      if( pCtx ){
        *pp = pToken->pNext;
        pToken->pNext = pCtx->pList;
        pCtx->pList = pToken;
        pCtx->nList++;
      }
      return pToken;
    }
  }
  return 0;
}

/*
** This is a Walker select callback. It does nothing. It is only required
** because without a dummy callback, sqlite3WalkExpr() and similar do not
** descend into sub-select statements.
*/

** object (either pParse->pNewTable, pNewIndex or pNewTrigger) as part of an
** ALTER TABLE RENAME COLUMN program. The error message emitted by the
** sub-routine is currently stored in pParse->zErrMsg. This function
** adds context to the error message and then stores it in pCtx.
*/
static void renameColumnParseError(
  sqlite3_context *pCtx,
  const char *zWhen,
  sqlite3_value *pType,
  sqlite3_value *pObject,
  Parse *pParse
){
  const char *zT = (const char*)sqlite3_value_text(pType);
  const char *zN = (const char*)sqlite3_value_text(pObject);
  char *zErr;

  zErr = sqlite3_mprintf("error in %s %s%s%s: %s",
      zT, zN, (zWhen[0] ? " " : ""), zWhen,
      pParse->zErrMsg
  );
  sqlite3_result_error(pCtx, zErr, -1);
  sqlite3_free(zErr);
}

/*

  /* Parse the SQL statement passed as the first argument. If no error
  ** occurs and the parse does not result in a new table, index or
  ** trigger object, the database must be corrupt. */
  memset(p, 0, sizeof(Parse));
  p->eParseMode = PARSE_MODE_RENAME;
  p->db = db;
  p->nQueryLoop = 1;
  rc = zSql ? sqlite3RunParser(p, zSql, &zErr) : SQLITE_NOMEM;
  assert( p->zErrMsg==0 );
  assert( rc!=SQLITE_OK || zErr==0 );
  p->zErrMsg = zErr;
  if( db->mallocFailed ) rc = SQLITE_NOMEM;
  if( rc==SQLITE_OK
   && p->pNewTable==0 && p->pNewIndex==0 && p->pNewTrigger==0
  ){

  assert( rc==SQLITE_OK );
  rc = renameEditSql(context, &sCtx, zSql, zNew, bQuote);

renameColumnFunc_done:
  if( rc!=SQLITE_OK ){
    if( sParse.zErrMsg ){
      renameColumnParseError(context, "", argv[1], argv[2], &sParse);
    }else{
      sqlite3_result_error_code(context, rc);
    }
  }

  renameParseCleanup(&sParse);
  renameTokenFree(db, sCtx.pList);

    }

    if( rc==SQLITE_OK ){
      rc = renameEditSql(context, &sCtx, zInput, zNew, bQuote);
    }
    if( rc!=SQLITE_OK ){
      if( sParse.zErrMsg ){
        renameColumnParseError(context, "", argv[1], argv[2], &sParse);
      }else{
        sqlite3_result_error_code(context, rc);
      }
    }

    renameParseCleanup(&sParse);
    renameTokenFree(db, sCtx.pList);

** to ensure that it is still usable.
**
**   0: Database name ("main", "temp" etc.).
**   1: SQL statement.
**   2: Object type ("view", "table", "trigger" or "index").
**   3: Object name.
**   4: True if object is from temp schema.
**   5: "when" part of error message.
**
** Unless it finds an error, this function normally returns NULL. However, it
** returns integer value 1 if:
**
**   * the SQL argument creates a trigger, and
**   * the table that the trigger is attached to is in database zDb.
*/
static void renameTableTest(
  sqlite3_context *context,
  int NotUsed,
  sqlite3_value **argv
){
  sqlite3 *db = sqlite3_context_db_handle(context);
  char const *zDb = (const char*)sqlite3_value_text(argv[0]);
  char const *zInput = (const char*)sqlite3_value_text(argv[1]);
  int bTemp = sqlite3_value_int(argv[4]);
  int isLegacy = (db->flags & SQLITE_LegacyAlter);
  char const *zWhen = (const char*)sqlite3_value_text(argv[5]);

#ifndef SQLITE_OMIT_AUTHORIZATION
  sqlite3_xauth xAuth = db->xAuth;
  db->xAuth = 0;
#endif

  UNUSED_PARAMETER(NotUsed);

          int i1 = sqlite3SchemaToIndex(db, sParse.pNewTrigger->pTabSchema);
          int i2 = sqlite3FindDbName(db, zDb);
          if( i1==i2 ) sqlite3_result_int(context, 1);
        }
      }
    }

    if( rc!=SQLITE_OK && zWhen ){
      renameColumnParseError(context, zWhen, argv[2], argv[3],&sParse);
    }
    renameParseCleanup(&sParse);
  }

#ifndef SQLITE_OMIT_AUTHORIZATION
  db->xAuth = xAuth;
#endif
}

/*
** The implementation of internal UDF sqlite_drop_column().
**
** Arguments:
**
**  argv[0]: An integer - the index of the schema containing the table
**  argv[1]: CREATE TABLE statement to modify.
**  argv[2]: An integer - the index of the column to remove.
**  argv[3]: Byte offset of first byte after last column definition in argv[1]
**
** The value returned is a string containing the CREATE TABLE statement
** with column argv[2] removed.
*/
static void dropColumnFunc(
  sqlite3_context *context,
  int NotUsed,
  sqlite3_value **argv
){
  sqlite3 *db = sqlite3_context_db_handle(context);
  int iSchema = sqlite3_value_int(argv[0]);
  const char *zSql = (const char*)sqlite3_value_text(argv[1]);
  int iCol = sqlite3_value_int(argv[2]);
  int iAddColOffset = sqlite3_value_int(argv[3]);
  const char *zDb = db->aDb[iSchema].zDbSName;
  int rc;
  Parse sParse;
  RenameToken *pCol;
  Table *pTab;
  const char *zEnd;
  char *zNew = 0;

#ifndef SQLITE_OMIT_AUTHORIZATION
  sqlite3_xauth xAuth = db->xAuth;
  db->xAuth = 0;
#endif

  rc = renameParseSql(&sParse, zDb, db, zSql, iSchema==1);
  if( rc!=SQLITE_OK ) goto drop_column_done;
  pTab = sParse.pNewTable;
  if( iCol>=pTab->nCol ){
    /* This can happen if the sqlite_schema table is corrupt */
    rc = SQLITE_CORRUPT_BKPT;
    goto drop_column_done;
  }

  pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol].zName);
  if( iCol<pTab->nCol-1 ){
    RenameToken *pEnd;
    pEnd = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol+1].zName);
    zEnd = (const char*)pEnd->t.z;
  }else{
    zEnd = (const char*)&zSql[iAddColOffset];
    while( ALWAYS(pCol->t.z[0]!=0) && pCol->t.z[0]!=',' ) pCol->t.z--;
  }

  zNew = sqlite3MPrintf(db, "%.*s%s", pCol->t.z-zSql, zSql, zEnd);
  sqlite3_result_text(context, zNew, -1, SQLITE_TRANSIENT);
  sqlite3_free(zNew);

drop_column_done:
  renameParseCleanup(&sParse);
#ifndef SQLITE_OMIT_AUTHORIZATION
  db->xAuth = xAuth;
#endif
  if( rc!=SQLITE_OK ){
    sqlite3_result_error_code(context, rc);
  }
}

/*
** This function is called by the parser upon parsing an
**
**     ALTER TABLE pSrc DROP COLUMN pName
**
** statement. Argument pSrc contains the possibly qualified name of the
** table being edited, and token pName the name of the column to drop.
*/
SQLITE_PRIVATE void sqlite3AlterDropColumn(Parse *pParse, SrcList *pSrc, Token *pName){
  sqlite3 *db = pParse->db;       /* Database handle */
  Table *pTab;                    /* Table to modify */
  int iDb;                        /* Index of db containing pTab in aDb[] */
  const char *zDb;                /* Database containing pTab ("main" etc.) */
  char *zCol = 0;                 /* Name of column to drop */
  int iCol;                       /* Index of column zCol in pTab->aCol[] */

  /* Look up the table being altered. */
  assert( pParse->pNewTable==0 );
  assert( sqlite3BtreeHoldsAllMutexes(db) );
  if( NEVER(db->mallocFailed) ) goto exit_drop_column;
  pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
  if( !pTab ) goto exit_drop_column;

  /* Make sure this is not an attempt to ALTER a view, virtual table or
  ** system table. */
  if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_drop_column;
  if( SQLITE_OK!=isRealTable(pParse, pTab, 1) ) goto exit_drop_column;

  /* Find the index of the column being dropped. */
  zCol = sqlite3NameFromToken(db, pName);
  if( zCol==0 ){
    assert( db->mallocFailed );
    goto exit_drop_column;
  }
  iCol = sqlite3ColumnIndex(pTab, zCol);
  if( iCol<0 ){
    sqlite3ErrorMsg(pParse, "no such column: \"%s\"", zCol);
    goto exit_drop_column;
  }

  /* Do not allow the user to drop a PRIMARY KEY column or a column
  ** constrained by a UNIQUE constraint.  */
  if( pTab->aCol[iCol].colFlags & (COLFLAG_PRIMKEY|COLFLAG_UNIQUE) ){
    sqlite3ErrorMsg(pParse, "cannot drop %s column: \"%s\"",
        (pTab->aCol[iCol].colFlags&COLFLAG_PRIMKEY) ? "PRIMARY KEY" : "UNIQUE",
        zCol
    );
    goto exit_drop_column;
  }

  /* Do not allow the number of columns to go to zero */
  if( pTab->nCol<=1 ){
    sqlite3ErrorMsg(pParse, "cannot drop column \"%s\": no other columns exist",zCol);
    goto exit_drop_column;
  }

  /* Edit the sqlite_schema table */
  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
  assert( iDb>=0 );
  zDb = db->aDb[iDb].zDbSName;
  renameTestSchema(pParse, zDb, iDb==1, "");
  sqlite3NestedParse(pParse,
      "UPDATE \"%w\"." DFLT_SCHEMA_TABLE " SET "
      "sql = sqlite_drop_column(%d, sql, %d, %d) "
      "WHERE (type=='table' AND tbl_name=%Q COLLATE nocase)"
      , zDb, iDb, iCol, pTab->addColOffset, pTab->zName
  );

  /* Drop and reload the database schema. */
  renameReloadSchema(pParse, iDb, INITFLAG_AlterDrop);
  renameTestSchema(pParse, zDb, iDb==1, "after drop column");

  /* Edit rows of table on disk */
  if( pParse->nErr==0 && (pTab->aCol[iCol].colFlags & COLFLAG_VIRTUAL)==0 ){
    int i;
    int addr;
    int reg;
    int regRec;
    Index *pPk = 0;
    int nField = 0;               /* Number of non-virtual columns after drop */
    int iCur;
    Vdbe *v = sqlite3GetVdbe(pParse);
    iCur = pParse->nTab++;
    sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
    addr = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v);
    reg = ++pParse->nMem;
    pParse->nMem += pTab->nCol;
    if( HasRowid(pTab) ){
      sqlite3VdbeAddOp2(v, OP_Rowid, iCur, reg);
    }else{
      pPk = sqlite3PrimaryKeyIndex(pTab);
    }
    for(i=0; i<pTab->nCol; i++){
      if( i!=iCol && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
        int regOut;
        if( pPk ){
          int iPos = sqlite3TableColumnToIndex(pPk, i);
          int iColPos = sqlite3TableColumnToIndex(pPk, iCol);
          regOut = reg+1+iPos-(iPos>iColPos);
        }else{
          regOut = reg+1+nField;
        }
        sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOut);
        nField++;
      }
    }
    regRec = reg + pTab->nCol;
    sqlite3VdbeAddOp3(v, OP_MakeRecord, reg+1, nField, regRec);
    if( pPk ){
      sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iCur, regRec, reg+1, pPk->nKeyCol);
    }else{
      sqlite3VdbeAddOp3(v, OP_Insert, iCur, regRec, reg);
    }

    sqlite3VdbeAddOp2(v, OP_Next, iCur, addr+1); VdbeCoverage(v);
    sqlite3VdbeJumpHere(v, addr);
  }

exit_drop_column:
  sqlite3DbFree(db, zCol);
  sqlite3SrcListDelete(db, pSrc);
}

/*
** Register built-in functions used to help implement ALTER TABLE
*/
SQLITE_PRIVATE void sqlite3AlterFunctions(void){
  static FuncDef aAlterTableFuncs[] = {
    INTERNAL_FUNCTION(sqlite_rename_column,  9, renameColumnFunc),
    INTERNAL_FUNCTION(sqlite_rename_table,   7, renameTableFunc),
    INTERNAL_FUNCTION(sqlite_rename_test,    6, renameTableTest),
    INTERNAL_FUNCTION(sqlite_drop_column,    4, dropColumnFunc),
  };
  sqlite3InsertBuiltinFuncs(aAlterTableFuncs, ArraySize(aAlterTableFuncs));
}
#endif  /* SQLITE_ALTER_TABLE */

/************** End of alter.c ***********************************************/
/************** Begin file analyze.c *****************************************/

      Returning *pReturning = pParse->u1.pReturning;
      int addrRewind;
      int i;
      int reg;

      addrRewind =
         sqlite3VdbeAddOp1(v, OP_Rewind, pReturning->iRetCur);
      VdbeCoverage(v);
      reg = pReturning->iRetReg;
      for(i=0; i<pReturning->nRetCol; i++){
        sqlite3VdbeAddOp3(v, OP_Column, pReturning->iRetCur, i, reg+i);
      }
      sqlite3VdbeAddOp2(v, OP_ResultRow, reg, i);
      sqlite3VdbeAddOp2(v, OP_Next, pReturning->iRetCur, addrRewind+1);
      VdbeCoverage(v);
      sqlite3VdbeJumpHere(v, addrRewind);
    }
    sqlite3VdbeAddOp0(v, OP_Halt);

#if SQLITE_USER_AUTHENTICATION
    if( pParse->nTableLock>0 && db->init.busy==0 ){
      sqlite3UserAuthInit(db);

/* Set properties of a table column based on the (magical)
** name of the column.
*/
#if SQLITE_ENABLE_HIDDEN_COLUMNS
SQLITE_PRIVATE void sqlite3ColumnPropertiesFromName(Table *pTab, Column *pCol){
  if( sqlite3_strnicmp(pCol->zName, "__hidden__", 10)==0 ){
    pCol->colFlags |= COLFLAG_HIDDEN;
    if( pTab ) pTab->tabFlags |= TF_HasHidden;
  }else if( pTab && pCol!=pTab->aCol && (pCol[-1].colFlags & COLFLAG_HIDDEN) ){
    pTab->tabFlags |= TF_OOOHidden;
  }
}
#endif

/*

** RETURNING trigger instead.  It will then be converted into the appropriate
** type on the first call to sqlite3TriggersExist().
*/
SQLITE_PRIVATE void sqlite3AddReturning(Parse *pParse, ExprList *pList){
  Returning *pRet;
  Hash *pHash;
  sqlite3 *db = pParse->db;
  if( pParse->pNewTrigger ){
    sqlite3ErrorMsg(pParse, "cannot use RETURNING in a trigger");
  }else{
    assert( pParse->bReturning==0 );
  }
  pParse->bReturning = 1;
  pRet = sqlite3DbMallocZero(db, sizeof(*pRet));
  if( pRet==0 ){
    sqlite3ExprListDelete(db, pList);
    return;
  }
  pParse->u1.pReturning = pRet;

  pRet->retTrig.bReturning = 1;
  pRet->retTrig.pSchema = db->aDb[1].pSchema;
  pRet->retTrig.step_list = &pRet->retTStep;
  pRet->retTStep.op = TK_RETURNING;
  pRet->retTStep.pTrig = &pRet->retTrig;
  pRet->retTStep.pExprList = pList;
  pHash = &(db->aDb[1].pSchema->trigHash);
  assert( sqlite3HashFind(pHash, RETURNING_TRIGGER_NAME)==0 || pParse->nErr );
  if( sqlite3HashInsert(pHash, RETURNING_TRIGGER_NAME, &pRet->retTrig)
          ==&pRet->retTrig ){
    sqlite3OomFault(db);
  }
}

/*

        );
      }
    }
#endif

    /* Reparse everything to update our internal data structures */
    sqlite3VdbeAddParseSchemaOp(v, iDb,
           sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName),0);
  }

  /* Add the table to the in-memory representation of the database.
  */
  if( db->init.busy ){
    Table *pOld;
    Schema *pSchema = p->pSchema;

      /* Fill the index with data and reparse the schema. Code an OP_Expire
      ** to invalidate all pre-compiled statements.
      */
      if( pTblName ){
        sqlite3RefillIndex(pParse, pIndex, iMem);
        sqlite3ChangeCookie(pParse, iDb);
        sqlite3VdbeAddParseSchemaOp(v, iDb,
            sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName), 0);
        sqlite3VdbeAddOp2(v, OP_Expire, 0, 1);
      }

      sqlite3VdbeJumpHere(v, (int)pIndex->tnum);
    }
  }
  if( db->init.busy || pTblName==0 ){

  const u8 *zEscaped = 0;          /* One past the last escaped input char */

  while( (c = Utf8Read(zPattern))!=0 ){
    if( c==matchAll ){  /* Match "*" */
      /* Skip over multiple "*" characters in the pattern.  If there
      ** are also "?" characters, skip those as well, but consume a
      ** single character of the input string for each "?" skipped */
      while( (c=Utf8Read(zPattern)) == matchAll
             || (c == matchOne && matchOne!=0) ){
        if( c==matchOne && sqlite3Utf8Read(&zString)==0 ){
          return SQLITE_NOWILDCARDMATCH;
        }
      }
      if( c==0 ){
        return SQLITE_MATCH;   /* "*" at the end of the pattern matches */
      }else if( c==matchOther ){

          testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL );
          testcase( pTab->aCol[i].colFlags & COLFLAG_STORED );
          ipkColumn--;
        }
      }
    }
#endif


    /* Make sure the number of columns in the source data matches the number
    ** of columns to be inserted into the table.
    */
    assert( TF_HasHidden==COLFLAG_HIDDEN );
    assert( TF_HasGenerated==COLFLAG_GENERATED );
    assert( COLFLAG_NOINSERT==(COLFLAG_GENERATED|COLFLAG_HIDDEN) );
    if( (pTab->tabFlags & (TF_HasGenerated|TF_HasHidden))!=0 ){
      for(i=0; i<pTab->nCol; i++){
        if( pTab->aCol[i].colFlags & COLFLAG_NOINSERT ) nHidden++;
      }
    }
    if( nColumn!=(pTab->nCol-nHidden) ){
      sqlite3ErrorMsg(pParse,
         "table %S has %d columns but %d values were supplied",
         pTabList, 0, pTab->nCol-nHidden, nColumn);
     goto insert_cleanup;
    }
  }
  if( pColumn!=0 && nColumn!=pColumn->nId ){
    sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
    goto insert_cleanup;
  }

  /* Initialize the count of rows to be inserted

    if( pTab->aCol[i].pDflt!=0 ) break;
    if( pTab->aCol[i].colFlags & COLFLAG_PRIMKEY ) break;
  }
  sqlite3VdbeChangeP5(v, i+1);
}
#endif

/*
** Table pTab is a WITHOUT ROWID table that is being written to. The cursor
** number is iCur, and register regData contains the new record for the
** PK index. This function adds code to invoke the pre-update hook,
** if one is registered.
*/
#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
static void codeWithoutRowidPreupdate(
  Parse *pParse,                  /* Parse context */
  Table *pTab,                    /* Table being updated */
  int iCur,                       /* Cursor number for table */
  int regData                     /* Data containing new record */
){
  Vdbe *v = pParse->pVdbe;
  int r = sqlite3GetTempReg(pParse);
  assert( !HasRowid(pTab) );
  assert( 0==(pParse->db->mDbFlags & DBFLAG_Vacuum) );
  sqlite3VdbeAddOp2(v, OP_Integer, 0, r);
  sqlite3VdbeAddOp4(v, OP_Insert, iCur, regData, r, (char*)pTab, P4_TABLE);
  sqlite3VdbeChangeP5(v, OPFLAG_ISNOOP);
  sqlite3ReleaseTempReg(pParse, r);
}
#else
# define codeWithoutRowidPreupdate(a,b,c,d)
#endif

/*
** This routine generates code to finish the INSERT or UPDATE operation
** that was started by a prior call to sqlite3GenerateConstraintChecks.
** A consecutive range of registers starting at regNewData contains the
** rowid and the content to be inserted.
**
** The arguments to this routine should be the same as the first six

      VdbeCoverage(v);
    }
    pik_flags = (useSeekResult ? OPFLAG_USESEEKRESULT : 0);
    if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
      assert( pParse->nested==0 );
      pik_flags |= OPFLAG_NCHANGE;
      pik_flags |= (update_flags & OPFLAG_SAVEPOSITION);

      if( update_flags==0 ){



        codeWithoutRowidPreupdate(pParse, pTab, iIdxCur+i, aRegIdx[i]);



      }

    }
    sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iIdxCur+i, aRegIdx[i],
                         aRegIdx[i]+1,
                         pIdx->uniqNotNull ? pIdx->nKeyCol: pIdx->nColumn);
    sqlite3VdbeChangeP5(v, pik_flags);
  }
  if( !HasRowid(pTab) ) return;

    if( db->mDbFlags & DBFLAG_Vacuum ){
      sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest);
      insFlags = OPFLAG_APPEND|OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT;
    }else{
      insFlags = OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND|OPFLAG_PREFORMAT;
    }
#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
    if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){
      sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
      insFlags &= ~OPFLAG_PREFORMAT;
    }else
#endif
    {
      sqlite3VdbeAddOp3(v, OP_RowCell, iDest, iSrc, regRowid);
    }
    sqlite3VdbeAddOp3(v, OP_Insert, iDest, regData, regRowid);
    if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){
      sqlite3VdbeChangeP4(v, -1, (char*)pDest, P4_TABLE);
    }
    sqlite3VdbeChangeP5(v, insFlags);

    sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1); VdbeCoverage(v);
    sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
    sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
  }else{
    sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);

        sqlite3VdbeAddOp2(v, OP_RowCell, iDest, iSrc);
      }
    }else if( !HasRowid(pSrc) && pDestIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){
      idxInsFlags |= OPFLAG_NCHANGE;
    }
    if( idxInsFlags!=(OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT) ){
      sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
      if( (db->mDbFlags & DBFLAG_Vacuum)==0
       && !HasRowid(pDest)
       && IsPrimaryKeyIndex(pDestIdx)
      ){
        codeWithoutRowidPreupdate(pParse, pDest, iDest, regData);
      }
    }
    sqlite3VdbeAddOp2(v, OP_IdxInsert, iDest, regData);
    sqlite3VdbeChangeP5(v, idxInsFlags|OPFLAG_APPEND);
    sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1); VdbeCoverage(v);
    sqlite3VdbeJumpHere(v, addr1);
    sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
    sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);

/*
** Fill the InitData structure with an error message that indicates
** that the database is corrupt.
*/
static void corruptSchema(
  InitData *pData,     /* Initialization context */
  char **azObj,        /* Type and name of object being parsed */
  const char *zExtra   /* Error information */
){
  sqlite3 *db = pData->db;
  if( db->mallocFailed ){
    pData->rc = SQLITE_NOMEM_BKPT;
  }else if( pData->pzErrMsg[0]!=0 ){
    /* A error message has already been generated.  Do not overwrite it */
  }else if( pData->mInitFlags & (INITFLAG_AlterRename|INITFLAG_AlterDrop) ){
    *pData->pzErrMsg = sqlite3MPrintf(db,
        "error in %s %s after %s: %s", azObj[0], azObj[1],
        (pData->mInitFlags & INITFLAG_AlterRename) ? "rename" : "drop column",
        zExtra
    );
    pData->rc = SQLITE_ERROR;
  }else if( db->flags & SQLITE_WriteSchema ){
    pData->rc = SQLITE_CORRUPT_BKPT;
  }else{
    char *z;
    const char *zObj = azObj[1] ? azObj[1] : "?";
    z = sqlite3MPrintf(db, "malformed database schema (%s)", zObj);
    if( zExtra && zExtra[0] ) z = sqlite3MPrintf(db, "%z - %s", z, zExtra);
    *pData->pzErrMsg = z;
    pData->rc = SQLITE_CORRUPT_BKPT;
  }
}

  assert( argc==5 );
  UNUSED_PARAMETER2(NotUsed, argc);
  assert( sqlite3_mutex_held(db->mutex) );
  db->mDbFlags |= DBFLAG_EncodingFixed;
  pData->nInitRow++;
  if( db->mallocFailed ){
    corruptSchema(pData, argv, 0);
    return 1;
  }

  assert( iDb>=0 && iDb<db->nDb );
  if( argv==0 ) return 0;   /* Might happen if EMPTY_RESULT_CALLBACKS are on */
  if( argv[3]==0 ){
    corruptSchema(pData, argv, 0);
  }else if( argv[4]
         && 'c'==sqlite3UpperToLower[(unsigned char)argv[4][0]]
         && 'r'==sqlite3UpperToLower[(unsigned char)argv[4][1]] ){
    /* Call the parser to process a CREATE TABLE, INDEX or VIEW.
    ** But because db->init.busy is set to 1, no VDBE code is generated
    ** or executed.  All the parser does is build the internal data
    ** structures that describe the table, index, or view.

    assert( db->init.busy );
    db->init.iDb = iDb;
    if( sqlite3GetUInt32(argv[3], &db->init.newTnum)==0
     || (db->init.newTnum>pData->mxPage && pData->mxPage>0)
    ){
      if( sqlite3Config.bExtraSchemaChecks ){
        corruptSchema(pData, argv, "invalid rootpage");
      }
    }
    db->init.orphanTrigger = 0;
    db->init.azInit = argv;
    pStmt = 0;
    TESTONLY(rcp = ) sqlite3Prepare(db, argv[4], -1, 0, 0, &pStmt, 0);
    rc = db->errCode;
    assert( (rc&0xFF)==(rcp&0xFF) );
    db->init.iDb = saved_iDb;
    /* assert( saved_iDb==0 || (db->mDbFlags & DBFLAG_Vacuum)!=0 ); */
    if( SQLITE_OK!=rc ){
      if( db->init.orphanTrigger ){
        assert( iDb==1 );
      }else{
        if( rc > pData->rc ) pData->rc = rc;
        if( rc==SQLITE_NOMEM ){
          sqlite3OomFault(db);
        }else if( rc!=SQLITE_INTERRUPT && (rc&0xFF)!=SQLITE_LOCKED ){
          corruptSchema(pData, argv, sqlite3_errmsg(db));
        }
      }
    }
    sqlite3_finalize(pStmt);
  }else if( argv[1]==0 || (argv[4]!=0 && argv[4][0]!=0) ){
    corruptSchema(pData, argv, 0);
  }else{
    /* If the SQL column is blank it means this is an index that
    ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
    ** constraint for a CREATE TABLE.  The index should have already
    ** been created when we processed the CREATE TABLE.  All we have
    ** to do here is record the root page number for that index.
    */
    Index *pIndex;
    pIndex = sqlite3FindIndex(db, argv[1], db->aDb[iDb].zDbSName);
    if( pIndex==0 ){
      corruptSchema(pData, argv, "orphan index");
    }else
    if( sqlite3GetUInt32(argv[3],&pIndex->tnum)==0
     || pIndex->tnum<2
     || pIndex->tnum>pData->mxPage
     || sqlite3IndexHasDuplicateRootPage(pIndex)
    ){
      if( sqlite3Config.bExtraSchemaChecks ){
        corruptSchema(pData, argv, "invalid rootpage");
      }
    }
  }
  return 0;
}

/*

      }
    }
    assert( i>=0 && i<db->nDb );
  }
  return i;
}










/*
** Free all memory allocations in the pParse object
*/
SQLITE_PRIVATE void sqlite3ParserReset(Parse *pParse){
  sqlite3 *db = pParse->db;






  while( pParse->pCleanup ){
    ParseCleanup *pCleanup = pParse->pCleanup;
    pParse->pCleanup = pCleanup->pNext;
    pCleanup->xCleanup(db, pCleanup->pPtr);
    sqlite3DbFreeNN(db, pCleanup);
  }
  sqlite3DbFree(db, pParse->aLabel);
  if( pParse->pConstExpr ){
    sqlite3ExprListDelete(db, pParse->pConstExpr);
  }
  if( db ){
    assert( db->lookaside.bDisable >= pParse->disableLookaside );

  return jointype;
}

/*
** Return the index of a column in a table.  Return -1 if the column
** is not contained in the table.
*/
SQLITE_PRIVATE int sqlite3ColumnIndex(Table *pTab, const char *zCol){
  int i;
  u8 h = sqlite3StrIHash(zCol);
  Column *pCol;
  for(pCol=pTab->aCol, i=0; i<pTab->nCol; pCol++, i++){
    if( pCol->hName==h && sqlite3StrICmp(pCol->zName, zCol)==0 ) return i;
  }
  return -1;

  int bIgnoreHidden    /* True to ignore hidden columns */
){
  int i;               /* For looping over tables in pSrc */
  int iCol;            /* Index of column matching zCol */

  assert( (piTab==0)==(piCol==0) );  /* Both or neither are NULL */
  for(i=0; i<N; i++){
    iCol = sqlite3ColumnIndex(pSrc->a[i].pTab, zCol);
    if( iCol>=0
     && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0)
    ){
      if( piTab ){
        *piTab = i;
        *piCol = iCol;
      }

      for(j=0; j<pList->nId; j++){
        char *zName;     /* Name of the term in the USING clause */
        int iLeft;       /* Table on the left with matching column name */
        int iLeftCol;    /* Column number of matching column on the left */
        int iRightCol;   /* Column number of matching column on the right */

        zName = pList->a[j].zName;
        iRightCol = sqlite3ColumnIndex(pRightTab, zName);
        if( iRightCol<0
         || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 0)
        ){
          sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
            "not present in both tables", zName);
          return 1;
        }

  if( db->mallocFailed ) return;
  memset(&sNC, 0, sizeof(sNC));
  sNC.pSrcList = pSelect->pSrc;
  a = pSelect->pEList->a;
  for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
    const char *zType;
    int n, m;
    pTab->tabFlags |= (pCol->colFlags & COLFLAG_NOINSERT);
    p = a[i].pExpr;
    zType = columnType(&sNC, p, 0, 0, 0);
    /* pCol->szEst = ... // Column size est for SELECT tables never used */
    pCol->affinity = sqlite3ExprAffinity(p);
    if( zType ){
      m = sqlite3Strlen30(zType);
      n = sqlite3Strlen30(pCol->zName);

/*
** Expression walker callback used by renumberCursors() to update
** Expr objects to match newly assigned cursor numbers.
*/
static int renumberCursorsCb(Walker *pWalker, Expr *pExpr){
  int *aCsrMap = pWalker->u.aiCol;
  int op = pExpr->op;
  if( (op==TK_COLUMN || op==TK_IF_NULL_ROW) && aCsrMap[pExpr->iTable] ){
    pExpr->iTable = aCsrMap[pExpr->iTable];
  }
  if( ExprHasProperty(pExpr, EP_FromJoin) && aCsrMap[pExpr->iRightJoinTable] ){
    pExpr->iRightJoinTable = aCsrMap[pExpr->iRightJoinTable];
  }
  return WRC_Continue;
}

    return 0; /* restriction (4) */
  }
  if( ExprHasProperty(pWhere,EP_FromJoin) && pWhere->iRightJoinTable!=iCursor ){
    return 0; /* restriction (5) */
  }
  if( sqlite3ExprIsTableConstant(pWhere, iCursor) ){
    nChng++;
    pSubq->selFlags |= SF_PushDown;
    while( pSubq ){
      SubstContext x;
      pNew = sqlite3ExprDup(pParse->db, pWhere, 0);
      unsetJoinExpr(pNew, -1);
      x.pParse = pParse;
      x.iTable = iCursor;
      x.iNewTable = iCursor;

** then return 0.
*/
static struct SrcList_item *isSelfJoinView(
  SrcList *pTabList,           /* Search for self-joins in this FROM clause */
  struct SrcList_item *pThis   /* Search for prior reference to this subquery */
){
  struct SrcList_item *pItem;
  assert( pThis->pSelect!=0 );
  if( pThis->pSelect->selFlags & SF_PushDown ) return 0;
  for(pItem = pTabList->a; pItem<pThis; pItem++){
    Select *pS1;
    if( pItem->pSelect==0 ) continue;
    if( pItem->fg.viaCoroutine ) continue;
    if( pItem->zName==0 ) continue;
    assert( pItem->pTab!=0 );
    assert( pThis->pTab!=0 );
    if( pItem->pTab->pSchema!=pThis->pTab->pSchema ) continue;
    if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue;
    pS1 = pItem->pSelect;
    if( pItem->pTab->pSchema==0 && pThis->pSelect->selId!=pS1->selId ){
      /* The query flattener left two different CTE tables with identical
      ** names in the same FROM clause. */
      continue;
    }
    if( pItem->pSelect->selFlags & SF_PushDown ){


      /* The view was modified by some other optimization such as
      ** pushDownWhereTerms() */
      continue;
    }
    return pItem;
  }
  return 0;
}

/*
** Deallocate a single AggInfo object
*/
static void agginfoFree(sqlite3 *db, AggInfo *p){
  sqlite3DbFree(db, p->aCol);
  sqlite3DbFree(db, p->aFunc);
  sqlite3DbFreeNN(db, p);
}

#ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION
/*
** Attempt to transform a query of the form
**
**    SELECT count(*) FROM (SELECT x FROM t1 UNION ALL SELECT y FROM t2)
**

#if SELECTTRACE_ENABLED
      if( sqlite3SelectTrace & 0x100 ){
        SELECTTRACE(0x100,pParse,p,
            ("After WHERE-clause push-down into subquery %d:\n", pSub->selId));
        sqlite3TreeViewSelect(0, p, 0);
      }
#endif
      assert( pItem->pSelect && (pItem->pSelect->selFlags & SF_PushDown)!=0 );
    }else{
      SELECTTRACE(0x100,pParse,p,("Push-down not possible\n"));
    }

    zSavedAuthContext = pParse->zAuthContext;
    pParse->zAuthContext = pItem->zName;

    if( sSort.pOrderBy ){
      sSort.nOBSat = sqlite3WhereIsOrdered(pWInfo);
      sSort.labelOBLopt = sqlite3WhereOrderByLimitOptLabel(pWInfo);
      if( sSort.nOBSat==sSort.pOrderBy->nExpr ){
        sSort.pOrderBy = 0;
      }
    }
    SELECTTRACE(1,pParse,p,("WhereBegin returns\n"));

    /* If sorting index that was created by a prior OP_OpenEphemeral
    ** instruction ended up not being needed, then change the OP_OpenEphemeral
    ** into an OP_Noop.
    */
    if( sSort.addrSortIndex>=0 && sSort.pOrderBy==0 ){
      sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex);

      /* Use the standard inner loop. */
      selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest,
          sqlite3WhereContinueLabel(pWInfo),
          sqlite3WhereBreakLabel(pWInfo));

      /* End the database scan loop.
      */
      SELECTTRACE(1,pParse,p,("WhereEnd\n"));
      sqlite3WhereEnd(pWInfo);
    }
  }else{
    /* This case when there exist aggregate functions or a GROUP BY clause
    ** or both */
    NameContext sNC;    /* Name context for processing aggregate information */
    int iAMem;          /* First Mem address for storing current GROUP BY */

    addrEnd = sqlite3VdbeMakeLabel(pParse);

    /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
    ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
    ** SELECT statement.
    */
    pAggInfo = sqlite3DbMallocZero(db, sizeof(*pAggInfo) );
    if( pAggInfo ){
      sqlite3ParserAddCleanup(pParse,
          (void(*)(sqlite3*,void*))agginfoFree, pAggInfo);
    }
    if( db->mallocFailed ){
      goto select_end;
    }


    pAggInfo->selId = p->selId;
    memset(&sNC, 0, sizeof(sNC));
    sNC.pParse = pParse;
    sNC.pSrcList = pTabList;
    sNC.uNC.pAggInfo = pAggInfo;
    VVA_ONLY( sNC.ncFlags = NC_UAggInfo; )
    pAggInfo->mnReg = pParse->nMem+1;

      */
      sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
      SELECTTRACE(1,pParse,p,("WhereBegin\n"));
      pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, 0,
          WHERE_GROUPBY | (orderByGrp ? WHERE_SORTBYGROUP : 0), 0
      );
      if( pWInfo==0 ) goto select_end;
      SELECTTRACE(1,pParse,p,("WhereBegin returns\n"));
      if( sqlite3WhereIsOrdered(pWInfo)==pGroupBy->nExpr ){
        /* The optimizer is able to deliver rows in group by order so
        ** we do not have to sort.  The OP_OpenEphemeral table will be
        ** cancelled later because we still need to use the pKeyInfo
        */
        groupBySort = 0;
      }else{

          }
        }
        regRecord = sqlite3GetTempReg(pParse);
        sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
        sqlite3VdbeAddOp2(v, OP_SorterInsert, pAggInfo->sortingIdx, regRecord);
        sqlite3ReleaseTempReg(pParse, regRecord);
        sqlite3ReleaseTempRange(pParse, regBase, nCol);
        SELECTTRACE(1,pParse,p,("WhereEnd\n"));
        sqlite3WhereEnd(pWInfo);
        pAggInfo->sortingIdxPTab = sortPTab = pParse->nTab++;
        sortOut = sqlite3GetTempReg(pParse);
        sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
        sqlite3VdbeAddOp2(v, OP_SorterSort, pAggInfo->sortingIdx, addrEnd);
        VdbeComment((v, "GROUP BY sort")); VdbeCoverage(v);
        pAggInfo->useSortingIdx = 1;

      /* End of the loop
      */
      if( groupBySort ){
        sqlite3VdbeAddOp2(v, OP_SorterNext, pAggInfo->sortingIdx,addrTopOfLoop);
        VdbeCoverage(v);
      }else{
        SELECTTRACE(1,pParse,p,("WhereEnd\n"));
        sqlite3WhereEnd(pWInfo);
        sqlite3VdbeChangeToNoop(v, addrSortingIdx);
      }

      /* Output the final row of result
      */
      sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);

        SELECTTRACE(1,pParse,p,("WhereBegin\n"));
        pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMaxOrderBy,
                                   0, minMaxFlag, 0);
        if( pWInfo==0 ){
          goto select_end;
        }
        SELECTTRACE(1,pParse,p,("WhereBegin returns\n"));
        updateAccumulator(pParse, regAcc, pAggInfo);
        if( regAcc ) sqlite3VdbeAddOp2(v, OP_Integer, 1, regAcc);
        if( minMaxFlag ){
          sqlite3WhereMinMaxOptEarlyOut(v, pWInfo);
        }
        SELECTTRACE(1,pParse,p,("WhereEnd\n"));
        sqlite3WhereEnd(pWInfo);
        finalizeAggFunctions(pParse, pAggInfo);
      }

      sSort.pOrderBy = 0;
      sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL);
      selectInnerLoop(pParse, p, -1, 0, 0,

       "INSERT INTO %Q." DFLT_SCHEMA_TABLE
       " VALUES('trigger',%Q,%Q,0,'CREATE TRIGGER %q')",
       db->aDb[iDb].zDbSName, zName,
       pTrig->table, z);
    sqlite3DbFree(db, z);
    sqlite3ChangeCookie(pParse, iDb);
    sqlite3VdbeAddParseSchemaOp(v, iDb,
        sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName), 0);
  }

  if( db->init.busy ){
    Trigger *pLink = pTrig;
    Hash *pHash = &db->aDb[iDb].pSchema->trigHash;
    assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
    assert( pLink!=0 );

      pParse->regRowid
    );
    v = sqlite3GetVdbe(pParse);
    sqlite3ChangeCookie(pParse, iDb);

    sqlite3VdbeAddOp0(v, OP_Expire);
    zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt);
    sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere, 0);
    sqlite3DbFree(db, zStmt);

    iReg = ++pParse->nMem;
    sqlite3VdbeLoadString(v, iReg, pTab->zName);
    sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg);
  }

            zType[j] = zType[j+nDel];
          }
          if( zType[i]=='\0' && i>0 ){
            assert(zType[i-1]==' ');
            zType[i-1] = '\0';
          }
          pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;
          pTab->tabFlags |= TF_HasHidden;
          oooHidden = TF_OOOHidden;
        }else{
          pTab->tabFlags |= oooHidden;
        }
      }
    }
  }

#define sqlite3ParserARG_STORE
#define sqlite3ParserCTX_SDECL Parse *pParse;
#define sqlite3ParserCTX_PDECL ,Parse *pParse
#define sqlite3ParserCTX_PARAM ,pParse
#define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse;
#define sqlite3ParserCTX_STORE yypParser->pParse=pParse;
#define YYFALLBACK 1
#define YYNSTATE             573
#define YYNRULE              394
#define YYNRULE_WITH_ACTION  333
#define YYNTOKEN             182
#define YY_MAX_SHIFT         572
#define YY_MIN_SHIFTREDUCE   825
#define YY_MAX_SHIFTREDUCE   1218
#define YY_ERROR_ACTION      1219
#define YY_ACCEPT_ACTION     1220
#define YY_NO_ACTION         1221
#define YY_MIN_REDUCE        1222
#define YY_MAX_REDUCE        1615
/************* End control #defines *******************************************/
#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))

/* Define the yytestcase() macro to be a no-op if is not already defined
** otherwise.
**
** Applications can choose to define yytestcase() in the %include section

**  yy_reduce_ofst[]   For each state, the offset into yy_action for
**                     shifting non-terminals after a reduce.
**  yy_default[]       Default action for each state.
**
*********** Begin parsing tables **********************************************/
#define YY_ACTTAB_COUNT (2017)
static const YYACTIONTYPE yy_action[] = {
 /*     0 */   566, 1253,  566,  197, 1576,  566, 1256,  566,  116,  113,
 /*    10 */   218,  566, 1263,  566,  488,  395,  116,  113,  218,  407,
 /*    20 */   359,  359,   42,   42,   42,   42,  471,   42,   42,   72,
 /*    30 */    72,  959, 1255,   72,   72,   72,   72, 1500, 1581,  960,
 /*    40 */     9,  889,  252,  123,  124,  114, 1196, 1196, 1035, 1038,
 /*    50 */  1028, 1028,  121,  121,  122,  122,  122,  122,  415,  407,
 /*    60 */   473, 1556,  572,    2, 1224, 1582,  548,  145,  147,  306,
 /*    70 */   548,  138,  548, 1296, 1296,  524,  566, 1193, 1304,  547,
 /*    80 */   523,  513,  167,  123,  124,  114, 1196, 1196, 1035, 1038,
 /*    90 */  1028, 1028,  121,  121,  122,  122,  122,  122,   72,   72,
 /*   100 */   282,  120,  120,  120,  120,  119,  119,  118,  118,  118,
 /*   110 */   117,  441,  274,  274,  274,  274,  446, 1172, 1537,  373,
 /*   120 */  1539, 1172,  372, 1537,  537,  563, 1144,  563, 1144,  407,
 /*   130 */  1078,  249,  215, 1193,  174,  529,  100,  305,  557,  229,
 /*   140 */   441,  120,  120,  120,  120,  119,  119,  118,  118,  118,
 /*   150 */   117,  441,  450,  123,  124,  114, 1196, 1196, 1035, 1038,
 /*   160 */  1028, 1028,  121,  121,  122,  122,  122,  122,  543,  450,
 /*   170 */   449,  445, 1172, 1173, 1174,  397, 1172, 1173, 1174,  125,
 /*   180 */   120,  120,  120,  120,  119,  119,  118,  118,  118,  117,
 /*   190 */   441,  119,  119,  118,  118,  118,  117,  441,  269,  407,
 /*   200 */  1553,  122,  122,  122,  122,  115,  381,   84,  377,  274,
 /*   210 */   274,  120,  120,  120,  120,  119,  119,  118,  118,  118,
 /*   220 */   117,  441,  563,  123,  124,  114, 1196, 1196, 1035, 1038,
 /*   230 */  1028, 1028,  121,  121,  122,  122,  122,  122,  407,  469,
 /*   240 */  1122, 1609,  450,   82, 1609,  462,  331,   81,  120,  120,
 /*   250 */   120,  120,  119,  119,  118,  118,  118,  117,  441,  116,
 /*   260 */   113,  218,  123,  124,  114, 1196, 1196, 1035, 1038, 1028,
 /*   270 */  1028,  121,  121,  122,  122,  122,  122,  566,  544, 1524,
 /*   280 */   880,  120,  120,  120,  120,  119,  119,  118,  118,  118,
 /*   290 */   117,  441,  118,  118,  118,  117,  441,   12,  197,   71,
 /*   300 */    71, 1139,  122,  122,  122,  122,  386,  407,  431, 1172,
 /*   310 */   400,  505,  533,  349, 1139,  166,  314, 1139, 1120,  881,
 /*   320 */   120,  120,  120,  120,  119,  119,  118,  118,  118,  117,
 /*   330 */   441,  123,  124,  114, 1196, 1196, 1035, 1038, 1028, 1028,
 /*   340 */   121,  121,  122,  122,  122,  122, 1172,  268,  268,  120,
 /*   350 */   120,  120,  120,  119,  119,  118,  118,  118,  117,  441,
 /*   360 */   563,  380, 1015, 1139, 1172, 1173, 1174,  241,  532,  565,
 /*   370 */   501,  498,  497,  429,  540,  478, 1139, 1532, 1006, 1139,
 /*   380 */   496,    6, 1005, 1396,  504, 1025, 1025, 1036, 1039,  120,
 /*   390 */   120,  120,  120,  119,  119,  118,  118,  118,  117,  441,
 /*   400 */   428, 1172, 1173, 1174, 1099, 1464,  260,  277,  357,  507,
 /*   410 */   352,  506,  246,  407, 1005, 1005, 1007,  345,  348, 1100,
 /*   420 */   241,  462,  331,  501,  498,  497,  371,  512, 1531,  359,
 /*   430 */   531,  360,    6,  496, 1101,  452,  203,  123,  124,  114,
 /*   440 */  1196, 1196, 1035, 1038, 1028, 1028,  121,  121,  122,  122,
 /*   450 */   122,  122,  522,  422, 1172,  900,  407,  571, 1029, 1224,
 /*   460 */   502,  321, 1274,  995,  306,  901,  138,  188, 1291,  426,
 /*   470 */  1270,  167,  488, 1304,   16,   16,  144,  860, 1291, 1273,
 /*   480 */   123,  124,  114, 1196, 1196, 1035, 1038, 1028, 1028,  121,
 /*   490 */   121,  122,  122,  122,  122,  120,  120,  120,  120,  119,
 /*   500 */   119,  118,  118,  118,  117,  441,  528,  274,  274, 1172,
 /*   510 */  1173, 1174, 1396,  566,  166,  329, 1499, 1015,  417,  374,
 /*   520 */   563,  488,  318, 1172,  320,  407,  305,  557,  375,  864,
 /*   530 */   182,  216,  860, 1006,  229,   72,   72, 1005,  120,  120,
 /*   540 */   120,  120,  119,  119,  118,  118,  118,  117,  441,  123,
 /*   550 */   124,  114, 1196, 1196, 1035, 1038, 1028, 1028,  121,  121,
 /*   560 */   122,  122,  122,  122,  407, 1463,  445, 1172,  857, 1005,
 /*   570 */  1005, 1007,  301, 1529,  116,  113,  218,    6, 1172, 1173,
 /*   580 */  1174,  183,  423,  116,  113,  218, 1172,  316,  123,  124,
 /*   590 */   114, 1196, 1196, 1035, 1038, 1028, 1028,  121,  121,  122,
 /*   600 */   122,  122,  122, 1469,  319,  946,  471,  120,  120,  120,
 /*   610 */   120,  119,  119,  118,  118,  118,  117,  441, 1172,  211,
 /*   620 */  1469, 1471, 1172, 1173, 1174,  920,  541, 1531,  477, 1172,
 /*   630 */   919,    6, 1172,  407,  925,  438,  437, 1157,  213,  511,
 /*   640 */    32, 1172, 1173, 1174,  280,    5,  120,  120,  120,  120,
 /*   650 */   119,  119,  118,  118,  118,  117,  441,  123,  124,  114,
 /*   660 */  1196, 1196, 1035, 1038, 1028, 1028,  121,  121,  122,  122,
 /*   670 */   122,  122,  407, 1172, 1173, 1174, 1016, 1172,  274,  274,
 /*   680 */   287, 1203, 1172, 1203, 1172, 1173, 1174, 1172, 1173, 1174,
 /*   690 */   566,  563,  167, 1469,  117,  441,  123,  124,  114, 1196,
 /*   700 */  1196, 1035, 1038, 1028, 1028,  121,  121,  122,  122,  122,
 /*   710 */   122,  945,   13,   13,  127,  120,  120,  120,  120,  119,
 /*   720 */   119,  118,  118,  118,  117,  441,  286,  420,  566,  451,
 /*   730 */   566, 1396, 1172, 1173, 1174, 1294, 1294, 1172, 1173, 1174,
 /*   740 */    97,  407,  995, 1611,  393, 1000,  488,  305,  557,   17,
 /*   750 */    72,   72,   72,   72,  120,  120,  120,  120,  119,  119,
 /*   760 */   118,  118,  118,  117,  441,  123,  124,  114, 1196, 1196,
 /*   770 */  1035, 1038, 1028, 1028,  121,  121,  122,  122,  122,  122,
 /*   780 */   407, 1220,    1,    1,  572,    2, 1224,  302,  418,  436,
 /*   790 */  1303,  306,  842,  138,  329,  457,  317,  404,  403,  566,
 /*   800 */  1304,  424,    3,  291,  123,  124,  114, 1196, 1196, 1035,
 /*   810 */  1038, 1028, 1028,  121,  121,  122,  122,  122,  122,  379,
 /*   820 */   566,   13,   13,  120,  120,  120,  120,  119,  119,  118,
 /*   830 */   118,  118,  117,  441,  274,  274,  425,  274,  274, 1172,
 /*   840 */  1308,  359,   13,   13, 1122, 1610,   12,  563, 1610,  407,
 /*   850 */   563,  460,  563, 1172,  560,  560,  560,  427,  439,  439,
 /*   860 */   439,  229,  120,  120,  120,  120,  119,  119,  118,  118,
 /*   870 */   118,  117,  441,  123,  124,  114, 1196, 1196, 1035, 1038,
 /*   880 */  1028, 1028,  121,  121,  122,  122,  122,  122,  146,  197,
 /*   890 */   417,  566, 1058,  445, 1172, 1173, 1174,  417,  471,  438,
 /*   900 */   437,  406,  564,  248,  914,  914,  566, 1200, 1172, 1173,
 /*   910 */  1174,  488, 1202,   72,   72,  493, 1510,  549,  102,  194,
 /*   920 */  1201,  566, 1120,  295,  461,  295, 1302,  252,   72,   72,
 /*   930 */  1456,  120,  120,  120,  120,  119,  119,  118,  118,  118,
 /*   940 */   117,  441,  245,   56,   56, 1203,  566, 1203,  566, 1242,
 /*   950 */   440,  274,  274,  566,  516, 1299,  566,  514,  566,  283,
 /*   960 */   274,  274, 1193,  519,  563,  548,  285,  343,   52,   52,
 /*   970 */    13,   13,  290,  563,  550,   13,   13,  566,   13,   13,
 /*   980 */    13,   13,  551,  274,  274,  294, 1411,  105,  274,  274,
 /*   990 */   191,  274,  274,  192, 1512,  545,  563,  274,  274,   57,
 /*  1000 */    57,  563,  275,  275,  563,  515,  447,  407,  271,  412,
 /*  1010 */   563,  944,  198,  305,  557,  563,  274,  274, 1193,  106,
 /*  1020 */   411,  104,  358, 1550, 1508,  348,  566,  407,  338,  563,
 /*  1030 */   341,  123,  124,  114, 1196, 1196, 1035, 1038, 1028, 1028,
 /*  1040 */   121,  121,  122,  122,  122,  122,  471,  407,   15,   15,
 /*  1050 */   477,  123,  124,  114, 1196, 1196, 1035, 1038, 1028, 1028,
 /*  1060 */   121,  121,  122,  122,  122,  122, 1083, 1083,  485,  360,
 /*  1070 */   477,  123,  112,  114, 1196, 1196, 1035, 1038, 1028, 1028,
 /*  1080 */   121,  121,  122,  122,  122,  122,  392, 1216,  309,  120,
 /*  1090 */   120,  120,  120,  119,  119,  118,  118,  118,  117,  441,
 /*  1100 */    99,  217,  482, 1176, 1410,  566,  479,  433,  543,  120,
 /*  1110 */   120,  120,  120,  119,  119,  118,  118,  118,  117,  441,
 /*  1120 */   292, 1080,  566, 1396,  566, 1080,  944,   44,   44,  120,
 /*  1130 */   120,  120,  120,  119,  119,  118,  118,  118,  117,  441,
 /*  1140 */   358, 1550,  539, 1099,   58,   58,   45,   45,  328,  407,
 /*  1150 */  1139,  830,  831,  832,  244,  243,  242,  483, 1100, 1176,
 /*  1160 */  1396,  538,  310, 1139, 1217,  488, 1139,  566,  293,  407,
 /*  1170 */  1150, 1245,  413, 1101,  124,  114, 1196, 1196, 1035, 1038,
 /*  1180 */  1028, 1028,  121,  121,  122,  122,  122,  122,  566,   59,
 /*  1190 */    59,  566,  509,  484,  554,  114, 1196, 1196, 1035, 1038,
 /*  1200 */  1028, 1028,  121,  121,  122,  122,  122,  122, 1530,  336,
 /*  1210 */    60,   60,    6,   61,   61,  392, 1121, 1528,  920, 1525,
 /*  1220 */  1150,    6,  566,  919,  566,  109,  558,  566,    4,  944,
 /*  1230 */   434,  120,  120,  120,  120,  119,  119,  118,  118,  118,
 /*  1240 */   117,  441,  561,  867,   62,   62,   63,   63,  566,   46,
 /*  1250 */    46,  120,  120,  120,  120,  119,  119,  118,  118,  118,
 /*  1260 */   117,  441,  566, 1139, 1527,  442, 1327,  566,    6,  566,
 /*  1270 */    47,   47,  566,  559,  413, 1272, 1139,  555,  142, 1139,
 /*  1280 */   566,  467,  305,  557,   48,   48,  566,  167,  546,   50,
 /*  1290 */    50,   51,   51, 1217,   64,   64,  959,  109,  558,  867,
 /*  1300 */     4,  566,   65,   65,  960, 1015,  566,  140,   66,   66,
 /*  1310 */   566,  107,  107,  566,  561,  852,  205,  566,  108,  217,
 /*  1320 */   442,  568,  567,   14,   14, 1005,    8,  525,   67,   67,
 /*  1330 */   566,  454,  129,  129,  222,   68,   68,  442,  455,   53,
 /*  1340 */    53,  405,  305,  557,  944,  414,  168,  211,  405,  555,
 /*  1350 */   111, 1192,   69,   69,   99,  464,  245, 1005, 1005, 1007,
 /*  1360 */  1008,   27,  468,  535,  566,  405,  566,  313,  534,  273,
 /*  1370 */   215,  852,  405,  566,   85,  202,  566, 1015,  566, 1211,
 /*  1380 */   566,  304,  566,  107,  107,  566,   70,   70,   54,   54,
 /*  1390 */   108,  405,  442,  568,  567,  153,  153, 1005,  154,  154,
 /*  1400 */    77,   77,   55,   55,   73,   73, 1117,  130,  130,  394,
 /*  1410 */   109,  558,  143,    4,   38,  566,  475,  300,  566,  463,
 /*  1420 */   279, 1340,  526,  412,   30,  226, 1077,  561, 1077, 1005,
 /*  1430 */  1005, 1007, 1008,   27, 1555, 1161,  444,   74,   74,  278,
 /*  1440 */   131,  131,  326, 1339,  390,  390,  389,  263,  387,  566,
 /*  1450 */   442,  839,  871,  308,  465,   31,  566,  879,  878,  356,
 /*  1460 */   327,  206,  555,   99,  223,  206,  312,  546, 1544,  355,
 /*  1470 */   997,  132,  132,  251,  311,  456,  535,  288,  128,  128,
 /*  1480 */  1065,  536,  109,  558,  470,    4,  566,  251, 1515,  472,
 /*  1490 */  1015,  566,  251,  276,  566,  332,  107,  107,   99,  561,
 /*  1500 */  1076,  566, 1076,  108,  225,  442,  568,  567,  152,  152,
 /*  1510 */  1005,  476,  158,  151,  151,  160,  136,  136,  494,  886,
 /*  1520 */   887,  247,  442,  135,  135,  346,  322,  566,   99, 1061,
 /*  1530 */   489,  224,  247,  566,  555, 1488, 1065, 1487,  953, 1009,
 /*  1540 */   228,  251, 1005, 1005, 1007, 1008,   27,  480,  535,  133,
 /*  1550 */   133,  566,  333,  534, 1336,  134,  134,  962,  963,  337,
 /*  1560 */   917,  340, 1015,  111,  850,  408,  342,  141,  107,  107,
 /*  1570 */   305,  557,  344,   76,   76,  108,  566,  442,  568,  567,
 /*  1580 */  1161,  444, 1005,  566,  278,  109,  558,  553,    4,  390,
 /*  1590 */   390,  389,  263,  387,  448, 1009,  839,  918,   78,   78,
 /*  1600 */   111,  566,  561, 1287,  566,   75,   75, 1271, 1334,  223,
 /*  1610 */  1569,  312,  351,  361, 1005, 1005, 1007, 1008,   27,  311,
 /*  1620 */   362, 1348, 1395,   43,   43,  442,   49,   49, 1323,  552,
 /*  1630 */  1401, 1252, 1244, 1233, 1232, 1234, 1563,  555,  200,  266,
 /*  1640 */  1320,  391,   11,  364,  221,  366,  368, 1382, 1377,  225,
 /*  1650 */   281,  453,  324,  330,  284, 1387,  474,  158,  208,  370,
 /*  1660 */   160, 1370,  325,  556,  195, 1015,  289,  499,  384,  354,
 /*  1670 */  1270,  107,  107,  924, 1386,  398,  224,  212,  108, 1460,
 /*  1680 */   442,  568,  567, 1459, 1566, 1005, 1211,  255, 1208, 1507,
 /*  1690 */  1505,  109,  558,  416,    4,  196,  207,  204,  170,  219,
 /*  1700 */    80,   84,  180, 1383, 1465,   83,  164,  172,  561,  458,
 /*  1710 */   408,  175,  176,  459,  177,  305,  557, 1005, 1005, 1007,
 /*  1720 */  1008,   27,   35,  178,  492,  231,  396,   97, 1389,  466,
 /*  1730 */  1388,  442,  481,   36, 1391,  184,  399,   90,  235,  448,
 /*  1740 */  1454, 1476,  267,  555,  487,  189,  237,  490,  339,  238,
 /*  1750 */   335, 1235,  239,  401,  508, 1281,  430, 1290, 1289,  101,
 /*  1760 */   558, 1288,    4,   92,  871,  213, 1580,  432, 1331,  527,
 /*  1770 */    96, 1015, 1260,  353,  402, 1579,  561,  107,  107, 1259,
 /*  1780 */   363, 1258, 1578, 1280,  108,  298,  442,  568,  567, 1549,
 /*  1790 */   518, 1005,  299,  521,  253, 1332,  365, 1535,  254,  442,
 /*  1800 */  1534,  435,  546,   10,  126,  378, 1440,  103,  530,  303,
 /*  1810 */    98,  555,  261, 1241,   34,  569,  199, 1313, 1330, 1329,
 /*  1820 */   367,  369,  376, 1005, 1005, 1007, 1008,   27, 1312,  382,
 /*  1830 */  1355, 1354,  383, 1167,  262,  264,  265,  570, 1230, 1015,
 /*  1840 */   155, 1225, 1492, 1493, 1491,  107,  107, 1490,  156,  139,
 /*  1850 */   296,   79,  108,  826,  442,  568,  567,  209,  157, 1005,
 /*  1860 */   443,  278,  201,  210,  307,  220,  390,  390,  389,  263,
 /*  1870 */   387,  137,  315,  839,  409, 1075, 1073,  410,  171,  169,
 /*  1880 */   159,  903,  173,  227, 1192,  230,  223,  323,  312, 1089,
 /*  1890 */   179, 1005, 1005, 1007, 1008,   27,  311,  161,  162,  419,
 /*  1900 */   421,   86,  181,  163,   87, 1092,  232,   88, 1088,  148,
 /*  1910 */   233,   18,  234,   89,  334, 1081,  251, 1205,  486,  236,
 /*  1920 */   186,   37,  841,  355,  491,  240,  225,  869,  187,  503,
 /*  1930 */   185,  495,   91,   19,  158,  347,   20,  160,   93,  350,
 /*  1940 */   500,  882,  297,  149,   94,  165,  510,   95, 1155,  150,
 /*  1950 */  1041, 1125,   39,  224,   40,  517, 1126,  214,  520,  270,
 /*  1960 */   272,  190,  947,  250,  111, 1143, 1141, 1145, 1149,   21,
 /*  1970 */  1129,   33,  542, 1148,   22,   23,   24,   25,  193,  952,
 /*  1980 */    99, 1056, 1042, 1040,   26, 1044, 1098,  408,    7, 1097,
 /*  1990 */   256,  257,  305,  557, 1045,   28,   41,  562, 1010,  851,
 /*  2000 */   110,   29,  913,  385,  388,  258,  259, 1163, 1162, 1571,
 /*  2010 */  1221, 1221, 1221, 1570, 1221, 1221,  448,
};
static const YYCODETYPE yy_lookahead[] = {
 /*     0 */   190,  212,  190,  190,  211,  190,  212,  190,  270,  271,
 /*    10 */   272,  190,  219,  190,  190,  202,  270,  271,  272,   19,
 /*    20 */   190,  190,  212,  213,  212,  213,  190,  212,  213,  212,
 /*    30 */   213,   31,  212,  212,  213,  212,  213,  291,   23,   39,
 /*    40 */    22,   26,   24,   43,   44,   45,   46,   47,   48,   49,

 /*  1350 */    26,   26,  212,  213,   26,  240,   46,  151,  152,  153,
 /*  1360 */   154,  155,  240,   85,  190,  250,  190,  190,   90,  252,
 /*  1370 */   253,  115,  250,  190,  147,  148,  190,   99,  190,   60,
 /*  1380 */   190,  240,  190,  105,  106,  190,  212,  213,  212,  213,
 /*  1390 */   112,  250,  114,  115,  116,  212,  213,  119,  212,  213,
 /*  1400 */   212,  213,  212,  213,  212,  213,   23,  212,  213,   26,
 /*  1410 */    19,   20,   22,   22,   24,  190,   19,  251,  190,  127,
 /*  1420 */    98,  190,  114,  113,   22,   24,  151,   36,  153,  151,
 /*  1430 */   152,  153,  154,  155,    0,    1,    2,  212,  213,    5,
 /*  1440 */   212,  213,  150,  190,   10,   11,   12,   13,   14,  190,
 /*  1450 */    59,   17,  124,  131,  127,   53,  190,  118,  119,  119,
 /*  1460 */    23,  140,   71,   26,   30,  140,   32,  143,  312,  129,
 /*  1470 */    23,  212,  213,   26,   40,  190,   85,  150,  212,  213,
 /*  1480 */    59,   90,   19,   20,   23,   22,  190,   26,  190,   23,
 /*  1490 */    99,  190,   26,   22,  190,   23,  105,  106,   26,   36,
 /*  1500 */   151,  190,  153,  112,   70,  114,  115,  116,  212,  213,
 /*  1510 */   119,  114,   78,  212,  213,   81,  212,  213,   23,    7,
 /*  1520 */     8,   26,   59,  212,  213,   23,  190,  190,   26,   23,
 /*  1530 */   284,   97,   26,  190,   71,  190,  115,  190,   23,   59,
 /*  1540 */   139,   26,  151,  152,  153,  154,  155,  190,   85,  212,
 /*  1550 */   213,  190,  190,   90,  190,  212,  213,   83,   84,  190,
 /*  1560 */    23,  190,   99,   26,   23,  131,  190,   26,  105,  106,
 /*  1570 */   136,  137,  190,  212,  213,  112,  190,  114,  115,  116,
 /*  1580 */     1,    2,  119,  190,    5,   19,   20,  232,   22,   10,
 /*  1590 */    11,   12,   13,   14,  160,  115,   17,   23,  212,  213,
 /*  1600 */    26,  190,   36,  190,  190,  212,  213,  190,  190,   30,
 /*  1610 */   139,   32,  190,  190,  151,  152,  153,  154,  155,   40,
 /*  1620 */   190,  190,  190,  212,  213,   59,  212,  213,  190,  190,
 /*  1630 */   190,  190,  190,  190,  190,  190,  190,   71,  238,  283,
 /*  1640 */   251,  188,  239,  251,  293,  251,  251,  267,  263,   70,
 /*  1650 */   241,  255,  289,  241,  255,  267,  289,   78,  210,  255,
 /*  1660 */    81,  263,  242,  276,  245,   99,  242,  216,  241,  215,
 /*  1670 */   221,  105,  106,  107,  267,  267,   97,  225,  112,  215,
 /*  1680 */   114,  115,  116,  215,  193,  119,   60,  139,   38,  197,
 /*  1690 */   197,   19,   20,  197,   22,  245,  239,  148,  293,  293,
 /*  1700 */   290,  149,   22,  268,  279,  290,   43,  230,   36,   18,
 /*  1710 */   131,  233,  233,  197,  233,  136,  137,  151,  152,  153,
 /*  1720 */   154,  155,  266,  233,   18,  196,  242,  147,  268,  242,
 /*  1730 */   268,   59,  197,  266,  230,  230,  242,  156,  196,  160,
 /*  1740 */   242,  286,  197,   71,   62,   22,  196,  217,  197,  196,
 /*  1750 */   285,  197,  196,  217,  113,  223,   64,  214,  214,   19,
 /*  1760 */    20,  214,   22,   22,  124,  163,  220,  111,  257,  142,
 /*  1770 */   113,   99,  214,  214,  217,  220,   36,  105,  106,  216,
 /*  1780 */   256,  214,  214,  223,  112,  278,  114,  115,  116,  306,
 /*  1790 */   217,  119,  278,  217,  197,  257,  256,  311,   91,   59,
 /*  1800 */   311,   82,  143,   22,  146,  197,  273,  156,  144,  275,
 /*  1810 */   145,   71,   25,  200,   26,  199,  244,  246,  257,  257,







 /*  1820 */   256,  256,  245,  151,  152,  153,  154,  155,  246,  243,
 /*  1830 */   261,  261,  242,   13,  191,  191,    6,  189,  189,   99,
 /*  1840 */   203,  189,  209,  209,  209,  105,  106,  209,  203,  218,
 /*  1850 */   218,  209,  112,    4,  114,  115,  116,  210,  203,  119,
 /*  1860 */     3,    5,   22,  210,  161,   15,   10,   11,   12,   13,
 /*  1870 */    14,   16,  137,   17,  299,   23,   23,  299,  149,  296,
 /*  1880 */   128,   20,  140,   24,   26,  142,   30,   16,   32,    1,
 /*  1890 */   140,  151,  152,  153,  154,  155,   40,  128,  128,   61,
 /*  1900 */    37,   53,  149,  128,   53,  114,   34,   53,    1,    5,
 /*  1910 */   139,   22,  113,   53,  159,   68,   26,   75,   41,  139,
 /*  1920 */   113,   24,   20,  129,   19,  123,   70,   59,   22,   96,
 /*  1930 */    68,   67,   22,   22,   78,   23,   22,   81,   22,   24,
 /*  1940 */    67,   28,   67,   23,  147,   37,   22,   26,   23,   23,
 /*  1950 */    23,   23,   22,   97,   22,   24,   23,  139,   24,   23,
 /*  1960 */    23,   22,  141,   34,   26,   86,   88,   75,   75,   34,
 /*  1970 */    23,   22,   24,   93,   34,   34,   34,   34,   26,  114,
 /*  1980 */    26,   23,   23,   23,   34,   23,   23,  131,   44,   23,
 /*  1990 */    26,   22,  136,  137,   11,   22,   22,   26,   23,   23,
 /*  2000 */    22,   22,  133,   23,   15,  139,  139,    1,    1,  139,
 /*  2010 */   313,  313,  313,  139,  313,  313,  160,  313,  313,  313,
 /*  2020 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2030 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2040 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2050 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2060 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2070 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2080 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2090 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2100 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2110 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2120 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2130 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2140 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2150 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2160 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2170 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2180 */   313,  313,  313,  313,  313,  313,  313,  313,  313,  313,
 /*  2190 */   313,  313,  313,  313,  313,  313,  182,  182,  182,
};
#define YY_SHIFT_COUNT    (572)
#define YY_SHIFT_MIN      (0)
#define YY_SHIFT_MAX      (2007)
static const unsigned short int yy_shift_ofst[] = {
 /*     0 */  1579, 1434, 1856, 1206, 1206,    1, 1278, 1391, 1463, 1672,
 /*    10 */  1672, 1672,  390,    0,    0,  180, 1008, 1672, 1672, 1672,
 /*    20 */  1672, 1672, 1672, 1672, 1672, 1672, 1672, 1672, 1672, 1672,
 /*    30 */   794,  794,  287,  287,  250,  611,    1,    1,    1,    1,
 /*    40 */     1,    1,   40,  110,  219,  288,  394,  437,  506,  545,
 /*    50 */   614,  653,  722,  761,  830,  988, 1008, 1008, 1008, 1008,

 /*   150 */   475,  584,   29, 2017, 2017,  289,  289,  289,   58,  508,
 /*   160 */    62,  508,  508,  508,  392,  392,  225,  395,  218,  822,
 /*   170 */   573,  573,  573,  573,  573,  573,  573,  573,  573,  573,
 /*   180 */   573,  573,  573,  573,  573,  573,  573,  573,  573,  573,
 /*   190 */   573, 1074, 1074,  573,  119, 1187, 1187, 1044, 1044, 1145,
 /*   200 */  1146, 2017, 2017, 2017, 2017, 2017, 2017, 2017,  418,  263,
 /*   210 */   263,  559,  303,  618,  527,  623,  464,  570,  780,  573,
 /*   220 */   573,  573,  573,  573,  573,  573,  573,  573,  573,  669,
 /*   230 */   573,  573,  573,  573,  573,  573,  573,  573,  573,  573,
 /*   240 */   573,  573,  245,  245,  245,  573,  573,  573,  573,  985,
 /*   250 */   573,  573,  573,   18, 1076,  573,  573, 1131,  573,  573,
 /*   260 */   573,  573,  573,  573,  573,  573,  941, 1092,  770,  903,
 /*   270 */   903,  903,  903, 1203,  770,  770, 1085,  692, 1144, 1319,
 /*   280 */  1168, 1227, 1321, 1308, 1227, 1308, 1397,  593, 1168, 1168,
 /*   290 */   593, 1168, 1321, 1397, 1328,   15, 1310, 1265, 1265, 1265,
 /*   300 */  1308, 1324, 1324,  863, 1325,  492, 1390, 1626, 1626, 1548,
 /*   310 */  1548, 1650, 1650, 1548, 1552, 1549, 1680, 1663, 1691, 1691,
 /*   320 */  1691, 1691, 1548, 1706, 1580, 1549, 1549, 1580, 1680, 1663,
 /*   330 */  1580, 1663, 1580, 1548, 1706, 1581, 1682, 1548, 1706, 1723,
 /*   340 */  1548, 1706, 1548, 1706, 1723, 1641, 1641, 1641, 1692, 1741,
 /*   350 */  1741, 1723, 1641, 1640, 1641, 1692, 1641, 1641, 1602, 1723,
 /*   360 */  1656, 1656, 1723, 1627, 1657, 1627, 1657, 1627, 1657, 1627,
 /*   370 */  1657, 1548, 1707, 1707, 1719, 1719, 1658, 1659, 1781, 1548,
 /*   380 */  1651, 1658, 1665, 1664, 1580, 1787, 1788, 1820, 1820, 1830,
 /*   390 */  1830, 1830, 2017, 2017, 2017, 2017, 2017, 2017, 2017, 2017,
 /*   400 */  2017, 2017, 2017, 2017, 2017, 2017, 2017,  339,  445, 1064,
 /*   410 */  1193,  951, 1029, 1256, 1383, 1322, 1402, 1401, 1292, 1327,
 /*   420 */  1437,  727, 1447, 1461, 1466, 1472, 1495, 1502, 1184, 1339,
 /*   430 */  1512, 1340, 1421, 1506, 1515, 1474, 1537, 1275, 1349, 1541,
 /*   440 */  1574, 1480, 1471, 1849, 1857, 1840, 1703, 1850, 1855, 1852,
 /*   450 */  1853, 1735, 1729, 1752, 1858, 1858, 1859, 1742, 1861, 1743,
 /*   460 */  1871, 1888, 1750, 1769, 1858, 1770, 1838, 1863, 1858, 1753,
 /*   470 */  1848, 1851, 1854, 1860, 1775, 1791, 1872, 1771, 1907, 1904,
 /*   480 */  1889, 1799, 1755, 1847, 1890, 1862, 1842, 1877, 1780, 1807,
 /*   490 */  1897, 1902, 1905, 1794, 1802, 1906, 1864, 1910, 1911, 1912,
 /*   500 */  1914, 1873, 1868, 1915, 1833, 1913, 1916, 1875, 1908, 1920,
 /*   510 */  1797, 1924, 1925, 1926, 1927, 1921, 1928, 1930, 1931, 1933,
 /*   520 */  1932, 1934, 1818, 1936, 1937, 1865, 1929, 1939, 1821, 1938,
 /*   530 */  1935, 1940, 1941, 1942, 1878, 1892, 1879, 1944, 1893, 1880,
 /*   540 */  1943, 1947, 1949, 1948, 1952, 1954, 1950, 1958, 1938, 1959,
 /*   550 */  1960, 1962, 1963, 1964, 1966, 1969, 1983, 1973, 1974, 1975,
 /*   560 */  1976, 1978, 1979, 1971, 1869, 1866, 1867, 1870, 1874, 1980,
 /*   570 */  1989, 2006, 2007,
};
#define YY_REDUCE_COUNT (406)
#define YY_REDUCE_MIN   (-262)
#define YY_REDUCE_MAX   (1655)
static const short yy_reduce_ofst[] = {
 /*     0 */   599, -123,  272,  716,  756, -121, -190, -188, -185, -183,
 /*    10 */  -179, -177,  -26,  304,  313, -254,  -11,  500,  609,  630,
 /*    20 */   758, -114,  763,  766,  323,  538,  768,   87,  540,  701,
 /*    30 */   -38,  413,  125,  324,  699,  443,  602,  725,  748,  753,

 /*   150 */   835, -262, -262, -262, -262, -207, -207, -207,  126, -164,
 /*   160 */  -170,  416,  708,  856, -158,  504,   74, -169,  446,  446,
 /*   170 */  -187,  328,  700,  707,  239,  282,  331,  556,  721,  438,
 /*   180 */   193,  860,  322,  541,  880,  933,  975,  241,  651,  879,
 /*   190 */   970,  270,  905,  918,   88,  914,  961,  967, 1069,  -39,
 /*   200 */   604, 1050, 1091, 1098, 1115, 1122, 1117, 1141, -211, -206,
 /*   210 */  -180, -130, -161,   10,  179,  236,  316,  341,  629,  726,
 /*   220 */   804,  816,  834,  898,  972, 1177, 1231, 1253, 1285,  170,
 /*   230 */  1298, 1336, 1345, 1347, 1357, 1362, 1364, 1369, 1371, 1376,
 /*   240 */  1382, 1413,  240,  257, 1053, 1417, 1422, 1423, 1430, 1012,
 /*   250 */  1431, 1432, 1438, 1166, 1156, 1418, 1439, 1355, 1440,  179,
 /*   260 */  1441, 1442, 1443, 1444, 1445, 1446, 1246, 1356, 1400, 1389,
 /*   270 */  1392, 1394, 1395, 1012, 1400, 1400, 1403, 1448, 1453, 1351,
 /*   280 */  1380, 1385, 1409, 1396, 1398, 1399, 1363, 1420, 1388, 1407,
 /*   290 */  1424, 1408, 1412, 1367, 1451, 1452, 1449, 1454, 1464, 1468,
 /*   300 */  1404, 1419, 1450, 1387, 1427, 1457, 1491, 1405, 1406, 1492,
 /*   310 */  1493, 1410, 1415, 1496, 1425, 1435, 1456, 1477, 1478, 1479,
 /*   320 */  1481, 1490, 1516, 1529, 1484, 1460, 1462, 1487, 1467, 1504,
 /*   330 */  1494, 1505, 1498, 1535, 1542, 1455, 1465, 1545, 1550, 1530,
 /*   340 */  1551, 1553, 1554, 1556, 1536, 1543, 1544, 1547, 1532, 1546,
 /*   350 */  1555, 1557, 1558, 1563, 1559, 1560, 1567, 1568, 1483, 1573,
 /*   360 */  1507, 1514, 1576, 1511, 1524, 1538, 1540, 1561, 1564, 1562,
 /*   370 */  1565, 1597, 1486, 1489, 1569, 1570, 1571, 1577, 1533, 1608,
 /*   380 */  1534, 1582, 1572, 1586, 1590, 1613, 1616, 1643, 1644, 1648,
 /*   390 */  1649, 1652, 1575, 1578, 1583, 1637, 1633, 1634, 1635, 1638,
 /*   400 */  1645, 1631, 1632, 1647, 1653, 1642, 1655,
};
static const YYACTIONTYPE yy_default[] = {
 /*     0 */  1615, 1615, 1615, 1449, 1219, 1328, 1219, 1219, 1219, 1449,
 /*    10 */  1449, 1449, 1219, 1358, 1358, 1502, 1250, 1219, 1219, 1219,
 /*    20 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1448, 1219, 1219,
 /*    30 */  1219, 1219, 1533, 1533, 1219, 1219, 1219, 1219, 1219, 1219,
 /*    40 */  1219, 1219, 1219, 1367, 1219, 1374, 1219, 1219, 1219, 1219,
 /*    50 */  1219, 1450, 1451, 1219, 1219, 1219, 1501, 1503, 1466, 1381,
 /*    60 */  1380, 1379, 1378, 1484, 1345, 1372, 1365, 1369, 1444, 1445,
 /*    70 */  1443, 1447, 1451, 1450, 1219, 1368, 1415, 1429, 1414, 1219,
 /*    80 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 /*    90 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 /*   100 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 /*   110 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 /*   120 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1423, 1428,
 /*   130 */  1434, 1427, 1424, 1417, 1416, 1418, 1419, 1219, 1240, 1292,
 /*   140 */  1219, 1219, 1219, 1219, 1521, 1520, 1219, 1219, 1250, 1409,
 /*   150 */  1408, 1420, 1421, 1431, 1430, 1509, 1568, 1567, 1467, 1219,
 /*   160 */  1219, 1219, 1219, 1219, 1219, 1219, 1533, 1219, 1219, 1219,
 /*   170 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 /*   180 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 /*   190 */  1219, 1533, 1533, 1219, 1250, 1533, 1533, 1246, 1246, 1352,
 /*   200 */  1219, 1516, 1319, 1319, 1319, 1319, 1328, 1319, 1219, 1219,
 /*   210 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 /*   220 */  1219, 1219, 1219, 1506, 1504, 1219, 1219, 1219, 1219, 1219,
 /*   230 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 /*   240 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 /*   250 */  1219, 1219, 1219, 1324, 1219, 1219, 1219, 1219, 1219, 1219,
 /*   260 */  1219, 1219, 1219, 1219, 1219, 1562, 1219, 1479, 1306, 1324,
 /*   270 */  1324, 1324, 1324, 1326, 1307, 1305, 1318, 1251, 1226, 1607,
 /*   280 */  1384, 1373, 1325, 1347, 1373, 1347, 1604, 1371, 1384, 1384,
 /*   290 */  1371, 1384, 1325, 1604, 1267, 1584, 1262, 1358, 1358, 1358,
 /*   300 */  1347, 1352, 1352, 1446, 1325, 1318, 1219, 1607, 1607, 1333,
 /*   310 */  1333, 1606, 1606, 1333, 1467, 1591, 1393, 1295, 1301, 1301,
 /*   320 */  1301, 1301, 1333, 1237, 1371, 1591, 1591, 1371, 1393, 1295,
 /*   330 */  1371, 1295, 1371, 1333, 1237, 1483, 1601, 1333, 1237, 1457,
 /*   340 */  1333, 1237, 1333, 1237, 1457, 1293, 1293, 1293, 1282, 1219,
 /*   350 */  1219, 1457, 1293, 1267, 1293, 1282, 1293, 1293, 1551, 1457,
 /*   360 */  1461, 1461, 1457, 1351, 1346, 1351, 1346, 1351, 1346, 1351,
 /*   370 */  1346, 1333, 1543, 1543, 1361, 1361, 1366, 1352, 1452, 1333,
 /*   380 */  1219, 1366, 1364, 1362, 1371, 1243, 1285, 1565, 1565, 1561,
 /*   390 */  1561, 1561, 1612, 1612, 1516, 1577, 1250, 1250, 1250, 1250,
 /*   400 */  1577, 1269, 1269, 1251, 1251, 1250, 1577, 1219, 1219, 1219,
 /*   410 */  1219, 1219, 1219, 1572, 1219, 1511, 1468, 1337, 1219, 1219,
 /*   420 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 /*   430 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 /*   440 */  1219, 1219, 1398, 1219, 1222, 1513, 1219, 1219, 1219, 1219,
 /*   450 */  1219, 1219, 1219, 1219, 1375, 1376, 1338, 1219, 1219, 1219,
 /*   460 */  1219, 1219, 1219, 1219, 1390, 1219, 1219, 1219, 1385, 1219,
 /*   470 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1603, 1219, 1219,
 /*   480 */  1219, 1219, 1219, 1219, 1482, 1481, 1219, 1219, 1335, 1219,
 /*   490 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 /*   500 */  1219, 1219, 1265, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 /*   510 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 /*   520 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1363,
 /*   530 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 /*   540 */  1219, 1219, 1219, 1219, 1548, 1353, 1219, 1219, 1594, 1219,
 /*   550 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 /*   560 */  1219, 1219, 1219, 1588, 1309, 1400, 1219, 1399, 1403, 1219,
 /*   570 */  1231, 1219, 1219,
};
/********** End of lemon-generated parsing tables *****************************/

/* The next table maps tokens (terminal symbols) into fallback tokens.
** If a construct like the following:
**
**      %fallback ID X Y Z.

 /* 281 */ "key_opt ::= KEY expr",
 /* 282 */ "cmd ::= REINDEX",
 /* 283 */ "cmd ::= REINDEX nm dbnm",
 /* 284 */ "cmd ::= ANALYZE",
 /* 285 */ "cmd ::= ANALYZE nm dbnm",
 /* 286 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
 /* 287 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist",
 /* 288 */ "cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm",
 /* 289 */ "add_column_fullname ::= fullname",
 /* 290 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm",
 /* 291 */ "cmd ::= create_vtab",
 /* 292 */ "cmd ::= create_vtab LP vtabarglist RP",
 /* 293 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
 /* 294 */ "vtabarg ::=",
 /* 295 */ "vtabargtoken ::= ANY",
 /* 296 */ "vtabargtoken ::= lp anylist RP",
 /* 297 */ "lp ::= LP",
 /* 298 */ "with ::= WITH wqlist",
 /* 299 */ "with ::= WITH RECURSIVE wqlist",
 /* 300 */ "wqlist ::= nm eidlist_opt AS LP select RP",
 /* 301 */ "wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP",
 /* 302 */ "windowdefn_list ::= windowdefn",
 /* 303 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn",
 /* 304 */ "windowdefn ::= nm AS LP window RP",
 /* 305 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt",
 /* 306 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt",
 /* 307 */ "window ::= ORDER BY sortlist frame_opt",
 /* 308 */ "window ::= nm ORDER BY sortlist frame_opt",
 /* 309 */ "window ::= frame_opt",
 /* 310 */ "window ::= nm frame_opt",
 /* 311 */ "frame_opt ::=",
 /* 312 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt",
 /* 313 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt",
 /* 314 */ "range_or_rows ::= RANGE|ROWS|GROUPS",
 /* 315 */ "frame_bound_s ::= frame_bound",
 /* 316 */ "frame_bound_s ::= UNBOUNDED PRECEDING",
 /* 317 */ "frame_bound_e ::= frame_bound",
 /* 318 */ "frame_bound_e ::= UNBOUNDED FOLLOWING",
 /* 319 */ "frame_bound ::= expr PRECEDING|FOLLOWING",
 /* 320 */ "frame_bound ::= CURRENT ROW",
 /* 321 */ "frame_exclude_opt ::=",
 /* 322 */ "frame_exclude_opt ::= EXCLUDE frame_exclude",
 /* 323 */ "frame_exclude ::= NO OTHERS",
 /* 324 */ "frame_exclude ::= CURRENT ROW",
 /* 325 */ "frame_exclude ::= GROUP|TIES",
 /* 326 */ "window_clause ::= WINDOW windowdefn_list",
 /* 327 */ "filter_over ::= filter_clause over_clause",
 /* 328 */ "filter_over ::= over_clause",
 /* 329 */ "filter_over ::= filter_clause",
 /* 330 */ "over_clause ::= OVER LP window RP",
 /* 331 */ "over_clause ::= OVER nm",
 /* 332 */ "filter_clause ::= FILTER LP WHERE expr RP",
 /* 333 */ "input ::= cmdlist",
 /* 334 */ "cmdlist ::= cmdlist ecmd",
 /* 335 */ "cmdlist ::= ecmd",
 /* 336 */ "ecmd ::= SEMI",
 /* 337 */ "ecmd ::= cmdx SEMI",
 /* 338 */ "ecmd ::= explain cmdx SEMI",
 /* 339 */ "trans_opt ::=",
 /* 340 */ "trans_opt ::= TRANSACTION",
 /* 341 */ "trans_opt ::= TRANSACTION nm",
 /* 342 */ "savepoint_opt ::= SAVEPOINT",
 /* 343 */ "savepoint_opt ::=",
 /* 344 */ "cmd ::= create_table create_table_args",
 /* 345 */ "columnlist ::= columnlist COMMA columnname carglist",
 /* 346 */ "columnlist ::= columnname carglist",
 /* 347 */ "nm ::= ID|INDEXED",
 /* 348 */ "nm ::= STRING",
 /* 349 */ "nm ::= JOIN_KW",
 /* 350 */ "typetoken ::= typename",
 /* 351 */ "typename ::= ID|STRING",
 /* 352 */ "signed ::= plus_num",
 /* 353 */ "signed ::= minus_num",
 /* 354 */ "carglist ::= carglist ccons",
 /* 355 */ "carglist ::=",
 /* 356 */ "ccons ::= NULL onconf",
 /* 357 */ "ccons ::= GENERATED ALWAYS AS generated",
 /* 358 */ "ccons ::= AS generated",
 /* 359 */ "conslist_opt ::= COMMA conslist",
 /* 360 */ "conslist ::= conslist tconscomma tcons",
 /* 361 */ "conslist ::= tcons",
 /* 362 */ "tconscomma ::=",
 /* 363 */ "defer_subclause_opt ::= defer_subclause",
 /* 364 */ "resolvetype ::= raisetype",
 /* 365 */ "selectnowith ::= oneselect",
 /* 366 */ "oneselect ::= values",
 /* 367 */ "sclp ::= selcollist COMMA",
 /* 368 */ "as ::= ID|STRING",
 /* 369 */ "returning ::=",
 /* 370 */ "expr ::= term",
 /* 371 */ "likeop ::= LIKE_KW|MATCH",
 /* 372 */ "exprlist ::= nexprlist",

 /* 373 */ "nmnum ::= plus_num",
 /* 374 */ "nmnum ::= nm",
 /* 375 */ "nmnum ::= ON",
 /* 376 */ "nmnum ::= DELETE",
 /* 377 */ "nmnum ::= DEFAULT",
 /* 378 */ "plus_num ::= INTEGER|FLOAT",
 /* 379 */ "foreach_clause ::=",
 /* 380 */ "foreach_clause ::= FOR EACH ROW",
 /* 381 */ "trnm ::= nm",
 /* 382 */ "tridxby ::=",
 /* 383 */ "database_kw_opt ::= DATABASE",
 /* 384 */ "database_kw_opt ::=",
 /* 385 */ "kwcolumn_opt ::=",
 /* 386 */ "kwcolumn_opt ::= COLUMNKW",
 /* 387 */ "vtabarglist ::= vtabarg",
 /* 388 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
 /* 389 */ "vtabarg ::= vtabarg vtabargtoken",
 /* 390 */ "anylist ::=",
 /* 391 */ "anylist ::= anylist LP anylist RP",
 /* 392 */ "anylist ::= anylist ANY",
 /* 393 */ "with ::=",
};
#endif /* NDEBUG */


#if YYSTACKDEPTH<=0
/*
** Try to increase the size of the parser stack.  Return the number

   291,  /* (281) key_opt ::= KEY expr */
   187,  /* (282) cmd ::= REINDEX */
   187,  /* (283) cmd ::= REINDEX nm dbnm */
   187,  /* (284) cmd ::= ANALYZE */
   187,  /* (285) cmd ::= ANALYZE nm dbnm */
   187,  /* (286) cmd ::= ALTER TABLE fullname RENAME TO nm */
   187,  /* (287) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
   187,  /* (288) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
   292,  /* (289) add_column_fullname ::= fullname */
   187,  /* (290) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
   187,  /* (291) cmd ::= create_vtab */
   187,  /* (292) cmd ::= create_vtab LP vtabarglist RP */
   294,  /* (293) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
   296,  /* (294) vtabarg ::= */
   297,  /* (295) vtabargtoken ::= ANY */
   297,  /* (296) vtabargtoken ::= lp anylist RP */
   298,  /* (297) lp ::= LP */
   262,  /* (298) with ::= WITH wqlist */
   262,  /* (299) with ::= WITH RECURSIVE wqlist */
   237,  /* (300) wqlist ::= nm eidlist_opt AS LP select RP */
   237,  /* (301) wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */
   300,  /* (302) windowdefn_list ::= windowdefn */
   300,  /* (303) windowdefn_list ::= windowdefn_list COMMA windowdefn */
   301,  /* (304) windowdefn ::= nm AS LP window RP */
   302,  /* (305) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
   302,  /* (306) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
   302,  /* (307) window ::= ORDER BY sortlist frame_opt */
   302,  /* (308) window ::= nm ORDER BY sortlist frame_opt */
   302,  /* (309) window ::= frame_opt */
   302,  /* (310) window ::= nm frame_opt */
   303,  /* (311) frame_opt ::= */
   303,  /* (312) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
   303,  /* (313) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
   307,  /* (314) range_or_rows ::= RANGE|ROWS|GROUPS */
   309,  /* (315) frame_bound_s ::= frame_bound */
   309,  /* (316) frame_bound_s ::= UNBOUNDED PRECEDING */
   310,  /* (317) frame_bound_e ::= frame_bound */
   310,  /* (318) frame_bound_e ::= UNBOUNDED FOLLOWING */
   308,  /* (319) frame_bound ::= expr PRECEDING|FOLLOWING */
   308,  /* (320) frame_bound ::= CURRENT ROW */
   311,  /* (321) frame_exclude_opt ::= */
   311,  /* (322) frame_exclude_opt ::= EXCLUDE frame_exclude */
   312,  /* (323) frame_exclude ::= NO OTHERS */
   312,  /* (324) frame_exclude ::= CURRENT ROW */
   312,  /* (325) frame_exclude ::= GROUP|TIES */
   247,  /* (326) window_clause ::= WINDOW windowdefn_list */
   269,  /* (327) filter_over ::= filter_clause over_clause */
   269,  /* (328) filter_over ::= over_clause */
   269,  /* (329) filter_over ::= filter_clause */
   306,  /* (330) over_clause ::= OVER LP window RP */
   306,  /* (331) over_clause ::= OVER nm */
   305,  /* (332) filter_clause ::= FILTER LP WHERE expr RP */
   182,  /* (333) input ::= cmdlist */
   183,  /* (334) cmdlist ::= cmdlist ecmd */
   183,  /* (335) cmdlist ::= ecmd */
   184,  /* (336) ecmd ::= SEMI */
   184,  /* (337) ecmd ::= cmdx SEMI */
   184,  /* (338) ecmd ::= explain cmdx SEMI */
   189,  /* (339) trans_opt ::= */
   189,  /* (340) trans_opt ::= TRANSACTION */
   189,  /* (341) trans_opt ::= TRANSACTION nm */
   191,  /* (342) savepoint_opt ::= SAVEPOINT */
   191,  /* (343) savepoint_opt ::= */
   187,  /* (344) cmd ::= create_table create_table_args */
   198,  /* (345) columnlist ::= columnlist COMMA columnname carglist */
   198,  /* (346) columnlist ::= columnname carglist */

   190,  /* (347) nm ::= ID|INDEXED */
   190,  /* (348) nm ::= STRING */
   190,  /* (349) nm ::= JOIN_KW */
   204,  /* (350) typetoken ::= typename */
   205,  /* (351) typename ::= ID|STRING */
   206,  /* (352) signed ::= plus_num */
   206,  /* (353) signed ::= minus_num */
   203,  /* (354) carglist ::= carglist ccons */
   203,  /* (355) carglist ::= */
   211,  /* (356) ccons ::= NULL onconf */
   211,  /* (357) ccons ::= GENERATED ALWAYS AS generated */
   211,  /* (358) ccons ::= AS generated */
   199,  /* (359) conslist_opt ::= COMMA conslist */
   224,  /* (360) conslist ::= conslist tconscomma tcons */
   224,  /* (361) conslist ::= tcons */
   225,  /* (362) tconscomma ::= */
   229,  /* (363) defer_subclause_opt ::= defer_subclause */
   231,  /* (364) resolvetype ::= raisetype */
   235,  /* (365) selectnowith ::= oneselect */
   236,  /* (366) oneselect ::= values */
   250,  /* (367) sclp ::= selcollist COMMA */
   251,  /* (368) as ::= ID|STRING */
   268,  /* (369) returning ::= */
   213,  /* (370) expr ::= term */
   270,  /* (371) likeop ::= LIKE_KW|MATCH */
   258,  /* (372) exprlist ::= nexprlist */

   280,  /* (373) nmnum ::= plus_num */
   280,  /* (374) nmnum ::= nm */
   280,  /* (375) nmnum ::= ON */
   280,  /* (376) nmnum ::= DELETE */
   280,  /* (377) nmnum ::= DEFAULT */
   207,  /* (378) plus_num ::= INTEGER|FLOAT */
   285,  /* (379) foreach_clause ::= */
   285,  /* (380) foreach_clause ::= FOR EACH ROW */
   288,  /* (381) trnm ::= nm */
   289,  /* (382) tridxby ::= */
   290,  /* (383) database_kw_opt ::= DATABASE */
   290,  /* (384) database_kw_opt ::= */
   293,  /* (385) kwcolumn_opt ::= */
   293,  /* (386) kwcolumn_opt ::= COLUMNKW */
   295,  /* (387) vtabarglist ::= vtabarg */
   295,  /* (388) vtabarglist ::= vtabarglist COMMA vtabarg */
   296,  /* (389) vtabarg ::= vtabarg vtabargtoken */
   299,  /* (390) anylist ::= */
   299,  /* (391) anylist ::= anylist LP anylist RP */
   299,  /* (392) anylist ::= anylist ANY */
   262,  /* (393) with ::= */
};

/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
** of symbols on the right-hand side of that rule. */
static const signed char yyRuleInfoNRhs[] = {
   -1,  /* (0) explain ::= EXPLAIN */
   -3,  /* (1) explain ::= EXPLAIN QUERY PLAN */

   -2,  /* (281) key_opt ::= KEY expr */
   -1,  /* (282) cmd ::= REINDEX */
   -3,  /* (283) cmd ::= REINDEX nm dbnm */
   -1,  /* (284) cmd ::= ANALYZE */
   -3,  /* (285) cmd ::= ANALYZE nm dbnm */
   -6,  /* (286) cmd ::= ALTER TABLE fullname RENAME TO nm */
   -7,  /* (287) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
   -6,  /* (288) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
   -1,  /* (289) add_column_fullname ::= fullname */
   -8,  /* (290) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
   -1,  /* (291) cmd ::= create_vtab */
   -4,  /* (292) cmd ::= create_vtab LP vtabarglist RP */
   -8,  /* (293) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
    0,  /* (294) vtabarg ::= */
   -1,  /* (295) vtabargtoken ::= ANY */
   -3,  /* (296) vtabargtoken ::= lp anylist RP */
   -1,  /* (297) lp ::= LP */
   -2,  /* (298) with ::= WITH wqlist */
   -3,  /* (299) with ::= WITH RECURSIVE wqlist */
   -6,  /* (300) wqlist ::= nm eidlist_opt AS LP select RP */
   -8,  /* (301) wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */
   -1,  /* (302) windowdefn_list ::= windowdefn */
   -3,  /* (303) windowdefn_list ::= windowdefn_list COMMA windowdefn */
   -5,  /* (304) windowdefn ::= nm AS LP window RP */
   -5,  /* (305) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
   -6,  /* (306) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
   -4,  /* (307) window ::= ORDER BY sortlist frame_opt */
   -5,  /* (308) window ::= nm ORDER BY sortlist frame_opt */
   -1,  /* (309) window ::= frame_opt */
   -2,  /* (310) window ::= nm frame_opt */
    0,  /* (311) frame_opt ::= */
   -3,  /* (312) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
   -6,  /* (313) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
   -1,  /* (314) range_or_rows ::= RANGE|ROWS|GROUPS */
   -1,  /* (315) frame_bound_s ::= frame_bound */
   -2,  /* (316) frame_bound_s ::= UNBOUNDED PRECEDING */
   -1,  /* (317) frame_bound_e ::= frame_bound */
   -2,  /* (318) frame_bound_e ::= UNBOUNDED FOLLOWING */
   -2,  /* (319) frame_bound ::= expr PRECEDING|FOLLOWING */
   -2,  /* (320) frame_bound ::= CURRENT ROW */
    0,  /* (321) frame_exclude_opt ::= */
   -2,  /* (322) frame_exclude_opt ::= EXCLUDE frame_exclude */
   -2,  /* (323) frame_exclude ::= NO OTHERS */
   -2,  /* (324) frame_exclude ::= CURRENT ROW */
   -1,  /* (325) frame_exclude ::= GROUP|TIES */
   -2,  /* (326) window_clause ::= WINDOW windowdefn_list */
   -2,  /* (327) filter_over ::= filter_clause over_clause */
   -1,  /* (328) filter_over ::= over_clause */
   -1,  /* (329) filter_over ::= filter_clause */
   -4,  /* (330) over_clause ::= OVER LP window RP */
   -2,  /* (331) over_clause ::= OVER nm */
   -5,  /* (332) filter_clause ::= FILTER LP WHERE expr RP */
   -1,  /* (333) input ::= cmdlist */
   -2,  /* (334) cmdlist ::= cmdlist ecmd */
   -1,  /* (335) cmdlist ::= ecmd */
   -1,  /* (336) ecmd ::= SEMI */
   -2,  /* (337) ecmd ::= cmdx SEMI */
   -3,  /* (338) ecmd ::= explain cmdx SEMI */
    0,  /* (339) trans_opt ::= */
   -1,  /* (340) trans_opt ::= TRANSACTION */
   -2,  /* (341) trans_opt ::= TRANSACTION nm */
   -1,  /* (342) savepoint_opt ::= SAVEPOINT */
    0,  /* (343) savepoint_opt ::= */
   -2,  /* (344) cmd ::= create_table create_table_args */
   -4,  /* (345) columnlist ::= columnlist COMMA columnname carglist */
   -2,  /* (346) columnlist ::= columnname carglist */

   -1,  /* (347) nm ::= ID|INDEXED */
   -1,  /* (348) nm ::= STRING */
   -1,  /* (349) nm ::= JOIN_KW */
   -1,  /* (350) typetoken ::= typename */
   -1,  /* (351) typename ::= ID|STRING */
   -1,  /* (352) signed ::= plus_num */
   -1,  /* (353) signed ::= minus_num */
   -2,  /* (354) carglist ::= carglist ccons */
    0,  /* (355) carglist ::= */
   -2,  /* (356) ccons ::= NULL onconf */
   -4,  /* (357) ccons ::= GENERATED ALWAYS AS generated */
   -2,  /* (358) ccons ::= AS generated */
   -2,  /* (359) conslist_opt ::= COMMA conslist */
   -3,  /* (360) conslist ::= conslist tconscomma tcons */
   -1,  /* (361) conslist ::= tcons */
    0,  /* (362) tconscomma ::= */
   -1,  /* (363) defer_subclause_opt ::= defer_subclause */
   -1,  /* (364) resolvetype ::= raisetype */
   -1,  /* (365) selectnowith ::= oneselect */
   -1,  /* (366) oneselect ::= values */
   -2,  /* (367) sclp ::= selcollist COMMA */
   -1,  /* (368) as ::= ID|STRING */
    0,  /* (369) returning ::= */
   -1,  /* (370) expr ::= term */
   -1,  /* (371) likeop ::= LIKE_KW|MATCH */
   -1,  /* (372) exprlist ::= nexprlist */

   -1,  /* (373) nmnum ::= plus_num */
   -1,  /* (374) nmnum ::= nm */
   -1,  /* (375) nmnum ::= ON */
   -1,  /* (376) nmnum ::= DELETE */
   -1,  /* (377) nmnum ::= DEFAULT */
   -1,  /* (378) plus_num ::= INTEGER|FLOAT */
    0,  /* (379) foreach_clause ::= */
   -3,  /* (380) foreach_clause ::= FOR EACH ROW */
   -1,  /* (381) trnm ::= nm */
    0,  /* (382) tridxby ::= */
   -1,  /* (383) database_kw_opt ::= DATABASE */
    0,  /* (384) database_kw_opt ::= */
    0,  /* (385) kwcolumn_opt ::= */
   -1,  /* (386) kwcolumn_opt ::= COLUMNKW */
   -1,  /* (387) vtabarglist ::= vtabarg */
   -3,  /* (388) vtabarglist ::= vtabarglist COMMA vtabarg */
   -2,  /* (389) vtabarg ::= vtabarg vtabargtoken */
    0,  /* (390) anylist ::= */
   -4,  /* (391) anylist ::= anylist LP anylist RP */
   -2,  /* (392) anylist ::= anylist ANY */
    0,  /* (393) with ::= */
};

static void yy_accept(yyParser*);  /* Forward Declaration */

/*
** Perform a reduce action and the shift that must immediately
** follow the reduce.

        break;
      case 4: /* transtype ::= */
{yymsp[1].minor.yy412 = TK_DEFERRED;}
        break;
      case 5: /* transtype ::= DEFERRED */
      case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6);
      case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7);
      case 314: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==314);
{yymsp[0].minor.yy412 = yymsp[0].major; /*A-overwrites-X*/}
        break;
      case 8: /* cmd ::= COMMIT|END trans_opt */
      case 9: /* cmd ::= ROLLBACK trans_opt */ yytestcase(yyruleno==9);
{sqlite3EndTransaction(pParse,yymsp[-1].major);}
        break;
      case 10: /* cmd ::= SAVEPOINT nm */

        break;
      case 287: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
{
  yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n;
  sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0);
}
        break;
      case 288: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
{
  sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy457, &yymsp[0].minor.yy0);
}
        break;
      case 289: /* add_column_fullname ::= fullname */
{
  disableLookaside(pParse);
  sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy457);
}
        break;
      case 290: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
{
  sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy457, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
}
        break;
      case 291: /* cmd ::= create_vtab */
{sqlite3VtabFinishParse(pParse,0);}
        break;
      case 292: /* cmd ::= create_vtab LP vtabarglist RP */
{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
        break;
      case 293: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
{
    sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy412);
}
        break;
      case 294: /* vtabarg ::= */
{sqlite3VtabArgInit(pParse);}
        break;
      case 295: /* vtabargtoken ::= ANY */
      case 296: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==296);
      case 297: /* lp ::= LP */ yytestcase(yyruleno==297);
{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
        break;
      case 298: /* with ::= WITH wqlist */
      case 299: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==299);
{ sqlite3WithPush(pParse, yymsp[0].minor.yy105, 1); }
        break;
      case 300: /* wqlist ::= nm eidlist_opt AS LP select RP */
{
  yymsp[-5].minor.yy105 = sqlite3WithAdd(pParse, 0, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy350, yymsp[-1].minor.yy293); /*A-overwrites-X*/
}
        break;
      case 301: /* wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */
{
  yymsp[-7].minor.yy105 = sqlite3WithAdd(pParse, yymsp[-7].minor.yy105, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy350, yymsp[-1].minor.yy293);
}
        break;
      case 302: /* windowdefn_list ::= windowdefn */
{ yylhsminor.yy503 = yymsp[0].minor.yy503; }
  yymsp[0].minor.yy503 = yylhsminor.yy503;
        break;
      case 303: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */
{
  assert( yymsp[0].minor.yy503!=0 );
  sqlite3WindowChain(pParse, yymsp[0].minor.yy503, yymsp[-2].minor.yy503);
  yymsp[0].minor.yy503->pNextWin = yymsp[-2].minor.yy503;
  yylhsminor.yy503 = yymsp[0].minor.yy503;
}
  yymsp[-2].minor.yy503 = yylhsminor.yy503;
        break;
      case 304: /* windowdefn ::= nm AS LP window RP */
{
  if( ALWAYS(yymsp[-1].minor.yy503) ){
    yymsp[-1].minor.yy503->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
  }
  yylhsminor.yy503 = yymsp[-1].minor.yy503;
}
  yymsp[-4].minor.yy503 = yylhsminor.yy503;
        break;
      case 305: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */
{
  yymsp[-4].minor.yy503 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy503, yymsp[-2].minor.yy350, yymsp[-1].minor.yy350, 0);
}
        break;
      case 306: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
{
  yylhsminor.yy503 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy503, yymsp[-2].minor.yy350, yymsp[-1].minor.yy350, &yymsp[-5].minor.yy0);
}
  yymsp[-5].minor.yy503 = yylhsminor.yy503;
        break;
      case 307: /* window ::= ORDER BY sortlist frame_opt */
{
  yymsp[-3].minor.yy503 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy503, 0, yymsp[-1].minor.yy350, 0);
}
        break;
      case 308: /* window ::= nm ORDER BY sortlist frame_opt */
{
  yylhsminor.yy503 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy503, 0, yymsp[-1].minor.yy350, &yymsp[-4].minor.yy0);
}
  yymsp[-4].minor.yy503 = yylhsminor.yy503;
        break;
      case 309: /* window ::= frame_opt */
      case 328: /* filter_over ::= over_clause */ yytestcase(yyruleno==328);
{
  yylhsminor.yy503 = yymsp[0].minor.yy503;
}
  yymsp[0].minor.yy503 = yylhsminor.yy503;
        break;
      case 310: /* window ::= nm frame_opt */
{
  yylhsminor.yy503 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy503, 0, 0, &yymsp[-1].minor.yy0);
}
  yymsp[-1].minor.yy503 = yylhsminor.yy503;
        break;
      case 311: /* frame_opt ::= */
{
  yymsp[1].minor.yy503 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
}
        break;
      case 312: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
{
  yylhsminor.yy503 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy412, yymsp[-1].minor.yy341.eType, yymsp[-1].minor.yy341.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy624);
}
  yymsp[-2].minor.yy503 = yylhsminor.yy503;
        break;
      case 313: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
{
  yylhsminor.yy503 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy412, yymsp[-3].minor.yy341.eType, yymsp[-3].minor.yy341.pExpr, yymsp[-1].minor.yy341.eType, yymsp[-1].minor.yy341.pExpr, yymsp[0].minor.yy624);
}
  yymsp[-5].minor.yy503 = yylhsminor.yy503;
        break;
      case 315: /* frame_bound_s ::= frame_bound */
      case 317: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==317);
{yylhsminor.yy341 = yymsp[0].minor.yy341;}
  yymsp[0].minor.yy341 = yylhsminor.yy341;
        break;
      case 316: /* frame_bound_s ::= UNBOUNDED PRECEDING */
      case 318: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==318);
      case 320: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==320);
{yylhsminor.yy341.eType = yymsp[-1].major; yylhsminor.yy341.pExpr = 0;}
  yymsp[-1].minor.yy341 = yylhsminor.yy341;
        break;
      case 319: /* frame_bound ::= expr PRECEDING|FOLLOWING */
{yylhsminor.yy341.eType = yymsp[0].major; yylhsminor.yy341.pExpr = yymsp[-1].minor.yy354;}
  yymsp[-1].minor.yy341 = yylhsminor.yy341;
        break;
      case 321: /* frame_exclude_opt ::= */
{yymsp[1].minor.yy624 = 0;}
        break;
      case 322: /* frame_exclude_opt ::= EXCLUDE frame_exclude */
{yymsp[-1].minor.yy624 = yymsp[0].minor.yy624;}
        break;
      case 323: /* frame_exclude ::= NO OTHERS */
      case 324: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==324);
{yymsp[-1].minor.yy624 = yymsp[-1].major; /*A-overwrites-X*/}
        break;
      case 325: /* frame_exclude ::= GROUP|TIES */
{yymsp[0].minor.yy624 = yymsp[0].major; /*A-overwrites-X*/}
        break;
      case 326: /* window_clause ::= WINDOW windowdefn_list */
{ yymsp[-1].minor.yy503 = yymsp[0].minor.yy503; }
        break;
      case 327: /* filter_over ::= filter_clause over_clause */
{
  yymsp[0].minor.yy503->pFilter = yymsp[-1].minor.yy354;
  yylhsminor.yy503 = yymsp[0].minor.yy503;
}
  yymsp[-1].minor.yy503 = yylhsminor.yy503;
        break;
      case 329: /* filter_over ::= filter_clause */
{
  yylhsminor.yy503 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
  if( yylhsminor.yy503 ){
    yylhsminor.yy503->eFrmType = TK_FILTER;
    yylhsminor.yy503->pFilter = yymsp[0].minor.yy354;
  }else{
    sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy354);
  }
}
  yymsp[0].minor.yy503 = yylhsminor.yy503;
        break;
      case 330: /* over_clause ::= OVER LP window RP */
{
  yymsp[-3].minor.yy503 = yymsp[-1].minor.yy503;
  assert( yymsp[-3].minor.yy503!=0 );
}
        break;
      case 331: /* over_clause ::= OVER nm */
{
  yymsp[-1].minor.yy503 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
  if( yymsp[-1].minor.yy503 ){
    yymsp[-1].minor.yy503->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
  }
}
        break;
      case 332: /* filter_clause ::= FILTER LP WHERE expr RP */
{ yymsp[-4].minor.yy354 = yymsp[-1].minor.yy354; }
        break;
      default:
      /* (333) input ::= cmdlist */ yytestcase(yyruleno==333);
      /* (334) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==334);
      /* (335) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=335);
      /* (336) ecmd ::= SEMI */ yytestcase(yyruleno==336);
      /* (337) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==337);
      /* (338) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=338);
      /* (339) trans_opt ::= */ yytestcase(yyruleno==339);
      /* (340) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==340);
      /* (341) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==341);
      /* (342) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==342);
      /* (343) savepoint_opt ::= */ yytestcase(yyruleno==343);
      /* (344) cmd ::= create_table create_table_args */ yytestcase(yyruleno==344);
      /* (345) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==345);
      /* (346) columnlist ::= columnname carglist */ yytestcase(yyruleno==346);
      /* (347) nm ::= ID|INDEXED */ yytestcase(yyruleno==347);
      /* (348) nm ::= STRING */ yytestcase(yyruleno==348);
      /* (349) nm ::= JOIN_KW */ yytestcase(yyruleno==349);
      /* (350) typetoken ::= typename */ yytestcase(yyruleno==350);
      /* (351) typename ::= ID|STRING */ yytestcase(yyruleno==351);
      /* (352) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=352);
      /* (353) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=353);
      /* (354) carglist ::= carglist ccons */ yytestcase(yyruleno==354);
      /* (355) carglist ::= */ yytestcase(yyruleno==355);
      /* (356) ccons ::= NULL onconf */ yytestcase(yyruleno==356);
      /* (357) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==357);
      /* (358) ccons ::= AS generated */ yytestcase(yyruleno==358);
      /* (359) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==359);
      /* (360) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==360);
      /* (361) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=361);
      /* (362) tconscomma ::= */ yytestcase(yyruleno==362);
      /* (363) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=363);
      /* (364) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=364);
      /* (365) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=365);
      /* (366) oneselect ::= values */ yytestcase(yyruleno==366);
      /* (367) sclp ::= selcollist COMMA */ yytestcase(yyruleno==367);
      /* (368) as ::= ID|STRING */ yytestcase(yyruleno==368);
      /* (369) returning ::= */ yytestcase(yyruleno==369);
      /* (370) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=370);
      /* (371) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==371);
      /* (372) exprlist ::= nexprlist */ yytestcase(yyruleno==372);
      /* (373) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=373);
      /* (374) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=374);
      /* (375) nmnum ::= ON */ yytestcase(yyruleno==375);
      /* (376) nmnum ::= DELETE */ yytestcase(yyruleno==376);
      /* (377) nmnum ::= DEFAULT */ yytestcase(yyruleno==377);
      /* (378) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==378);
      /* (379) foreach_clause ::= */ yytestcase(yyruleno==379);
      /* (380) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==380);
      /* (381) trnm ::= nm */ yytestcase(yyruleno==381);
      /* (382) tridxby ::= */ yytestcase(yyruleno==382);
      /* (383) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==383);
      /* (384) database_kw_opt ::= */ yytestcase(yyruleno==384);
      /* (385) kwcolumn_opt ::= */ yytestcase(yyruleno==385);
      /* (386) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==386);
      /* (387) vtabarglist ::= vtabarg */ yytestcase(yyruleno==387);
      /* (388) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==388);
      /* (389) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==389);
      /* (390) anylist ::= */ yytestcase(yyruleno==390);
      /* (391) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==391);
      /* (392) anylist ::= anylist ANY */ yytestcase(yyruleno==392);
      /* (393) with ::= */ yytestcase(yyruleno==393);
        break;
/********** End reduce actions ************************************************/
  };
  assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
  yygoto = yyRuleInfoLhs[yyruleno];
  yysize = yyRuleInfoNRhs[yyruleno];
  yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPE)yygoto);

  int rc = SQLITE_OK;

#ifdef SQLITE_AMALGAMATION
    assert( WAL_CKPT_LOCK==1 );
#endif

  assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
  if( pRbu && (
       pRbu->eStage==RBU_STAGE_OAL
    || pRbu->eStage==RBU_STAGE_MOVE
    || pRbu->eStage==RBU_STAGE_DONE
  )){
    /* Prevent SQLite from taking a shm-lock on the target file when it



    ** is supplying heap memory to the upper layer in place of *-shm
    ** segments. */
    if( ofst==WAL_LOCK_CKPT && n==1 ) rc = SQLITE_BUSY;
  }else{
    int bCapture = 0;
    if( pRbu && pRbu->eStage==RBU_STAGE_CAPTURE ){
      bCapture = 1;
    }

    if( bCapture==0 || 0==(flags & SQLITE_SHM_UNLOCK) ){
      rc = p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags);
      if( bCapture && rc==SQLITE_OK ){
        pRbu->mLock |= ((1<<n) - 1) << ofst;
      }
    }
  }

  return rc;
}

static void fts5SourceIdFunc(
  sqlite3_context *pCtx,          /* Function call context */
  int nArg,                       /* Number of args */
  sqlite3_value **apUnused        /* Function arguments */
){
  assert( nArg==0 );
  UNUSED_PARAM2(nArg, apUnused);
  sqlite3_result_text(pCtx, "fts5: 2021-02-17 13:19:22 c46a94a624c2cc6c49ac916a206a913081e1628c24805987cabc75c9057ea36b", -1, SQLITE_TRANSIENT);
}

/*
** Return true if zName is the extension on one of the shadow tables used
** by this module.
*/
static int fts5ShadowName(const char *zName){

#endif
  return rc;
}
#endif /* SQLITE_CORE */
#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_STMTVTAB) */

/************** End of stmt.c ************************************************/
#if __LINE__!=233699
#undef SQLITE_SOURCE_ID
#define SQLITE_SOURCE_ID      "2021-02-19 14:32:58 c844a331e78949850fde8ed95058cb34f863566944bc9e92e3ae042768f1alt2"
#endif
/* Return the source-id for this library */
SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
/************************** End of sqlite3.c ******************************/

** The SQLITE_VERSION_NUMBER for any given release of SQLite will also
** be larger than the release from which it is derived.  Either Y will
** be held constant and Z will be incremented or else Y will be incremented
** and Z will be reset to zero.
**
** Since [version 3.6.18] ([dateof:3.6.18]),
** SQLite source code has been stored in the
** <a href="http://www.fossil-scm.org/">Fossil configuration management
** system</a>.  ^The SQLITE_SOURCE_ID macro evaluates to
** a string which identifies a particular check-in of SQLite
** within its configuration management system.  ^The SQLITE_SOURCE_ID
** string contains the date and time of the check-in (UTC) and a SHA1
** or SHA3-256 hash of the entire source tree.  If the source code has
** been edited in any way since it was last checked in, then the last
** four hexadecimal digits of the hash may be modified.
**
** See also: [sqlite3_libversion()],
** [sqlite3_libversion_number()], [sqlite3_sourceid()],
** [sqlite_version()] and [sqlite_source_id()].
*/
#define SQLITE_VERSION        "3.35.0"
#define SQLITE_VERSION_NUMBER 3035000
#define SQLITE_SOURCE_ID      "2021-02-19 14:32:58 c844a331e78949850fde8ed95058cb34f863566944bc9e92e3ae042768f130e1"

/*
** CAPI3REF: Run-Time Library Version Numbers
** KEYWORDS: sqlite3_version sqlite3_sourceid
**
** These interfaces provide the same information as the [SQLITE_VERSION],
** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros