/* Begin generating the code that will insert the table record into  ** the SQLITE_MASTER table.  Note in particular that we must go ahead  ** and allocate the record number for the table entry now.  Before any  ** PRIMARY KEY or UNIQUE keywords are parsed.  Those keywords will cause  ** indices to be created and the table record must come before the   ** indices.  Hence, the record number for the table must be allocated  ** now.  */  if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){    int lbl;    int fileFormat;    sqlite3BeginWriteOperation(pParse, 0, iDb);    /* If the file format and encoding in the database have not been set,     ** set them now.    */    sqlite3VdbeAddOp(v, OP_ReadCookie, iDb, 1);   /* file_format */    lbl = sqlite3VdbeMakeLabel(v);    sqlite3VdbeAddOp(v, OP_If, 0, lbl);    fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?                  1 : SQLITE_DEFAULT_FILE_FORMAT;    sqlite3VdbeAddOp(v, OP_Integer, fileFormat, 0);    sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 1);    sqlite3VdbeAddOp(v, OP_Integer, ENC(db), 0);    sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 4);    sqlite3VdbeResolveLabel(v, lbl);    /* This just creates a place-holder record in the sqlite_master table.    ** The record created does not contain anything yet.  It will be replaced    ** by the real entry in code generated at sqlite3EndTable().    **    ** The rowid for the new entry is left on the top of the stack.    ** The rowid value is needed by the code that sqlite3EndTable will    ** generate.    */#ifndef SQLITE_OMIT_VIEW    if( isView ){      sqlite3VdbeAddOp(v, OP_Integer, 0, 0);    }else#endif    {      sqlite3VdbeAddOp(v, OP_CreateTable, iDb, 0);    }    sqlite3OpenMasterTable(pParse, iDb);    sqlite3VdbeAddOp(v, OP_NewRowid, 0, 0);    sqlite3VdbeAddOp(v, OP_Dup, 0, 0);    sqlite3VdbeAddOp(v, OP_Null, 0, 0);    sqlite3VdbeAddOp(v, OP_Insert, 0, 0);    sqlite3VdbeAddOp(v, OP_Close, 0, 0);    sqlite3VdbeAddOp(v, OP_Pull, 1, 0);  }  /* Normal (non-error) return. */  return;  /* If an error occurs, we jump here */begin_table_error:  sqliteFree(zName);  return;}/*** This macro is used to compare two strings in a case-insensitive manner.** It is slightly faster than calling sqlite3StrICmp() directly, but** produces larger code.**** WARNING: This macro is not compatible with the strcmp() family. It** returns true if the two strings are equal, otherwise false.*/#define STRICMP(x, y) (\sqlite3UpperToLower[*(unsigned char *)(x)]==   \sqlite3UpperToLower[*(unsigned char *)(y)]     \&& sqlite3StrICmp((x)+1,(y)+1)==0 )/*** Add a new column to the table currently being constructed.**** The parser calls this routine once for each column declaration** in a CREATE TABLE statement.  sqlite3StartTable() gets called** first to get things going.  Then this routine is called for each** column.*/void sqlite3AddColumn(Parse *pParse, Token *pName){  Table *p;  int i;  char *z;  Column *pCol;  if( (p = pParse->pNewTable)==0 ) return;  z = sqlite3NameFromToken(pName);  if( z==0 ) return;  for(i=0; i<p->nCol; i++){    if( STRICMP(z, p->aCol[i].zName) ){      sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);      sqliteFree(z);      return;    }  }  if( (p->nCol & 0x7)==0 ){    Column *aNew;    aNew = sqliteRealloc( p->aCol, (p->nCol+8)*sizeof(p->aCol[0]));    if( aNew==0 ){      sqliteFree(z);      return;    }    p->aCol = aNew;  }  pCol = &p->aCol[p->nCol];  memset(pCol, 0, sizeof(p->aCol[0]));  pCol->zName = z;   /* If there is no type specified, columns have the default affinity  ** 'NONE'. If there is a type specified, then sqlite3AddColumnType() will  ** be called next to set pCol->affinity correctly.  */  pCol->affinity = SQLITE_AFF_NONE;  p->nCol++;}/*** This routine is called by the parser while in the middle of** parsing a CREATE TABLE statement.  A "NOT NULL" constraint has** been seen on a column.  This routine sets the notNull flag on** the column currently under construction.*/void sqlite3AddNotNull(Parse *pParse, int onError){  Table *p;  int i;  if( (p = pParse->pNewTable)==0 ) return;  i = p->nCol-1;  if( i>=0 ) p->aCol[i].notNull = onError;}/*** Scan the column type name zType (length nType) and return the** associated affinity type.**** This routine does a case-independent search of zType for the ** substrings in the following table. If one of the substrings is** found, the corresponding affinity is returned. If zType contains** more than one of the substrings, entries toward the top of ** the table take priority. For example, if zType is 'BLOBINT', ** SQLITE_AFF_INTEGER is returned.**** Substring     | Affinity** --------------------------------** 'INT'         | SQLITE_AFF_INTEGER** 'CHAR'        | SQLITE_AFF_TEXT** 'CLOB'        | SQLITE_AFF_TEXT** 'TEXT'        | SQLITE_AFF_TEXT** 'BLOB'        | SQLITE_AFF_NONE** 'REAL'        | SQLITE_AFF_REAL** 'FLOA'        | SQLITE_AFF_REAL** 'DOUB'        | SQLITE_AFF_REAL**** If none of the substrings in the above table are found,** SQLITE_AFF_NUMERIC is returned.*/char sqlite3AffinityType(const Token *pType){  u32 h = 0;  char aff = SQLITE_AFF_NUMERIC;  const unsigned char *zIn = pType->z;  const unsigned char *zEnd = &pType->z[pType->n];  while( zIn!=zEnd ){    h = (h<<8) + sqlite3UpperToLower[*zIn];    zIn++;    if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){             /* CHAR */      aff = SQLITE_AFF_TEXT;     }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){       /* CLOB */      aff = SQLITE_AFF_TEXT;    }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){       /* TEXT */      aff = SQLITE_AFF_TEXT;    }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b')          /* BLOB */        && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){      aff = SQLITE_AFF_NONE;#ifndef SQLITE_OMIT_FLOATING_POINT    }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l')          /* REAL */        && aff==SQLITE_AFF_NUMERIC ){      aff = SQLITE_AFF_REAL;    }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a')          /* FLOA */        && aff==SQLITE_AFF_NUMERIC ){      aff = SQLITE_AFF_REAL;    }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b')          /* DOUB */        && aff==SQLITE_AFF_NUMERIC ){      aff = SQLITE_AFF_REAL;#endif    }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){    /* INT */      aff = SQLITE_AFF_INTEGER;      break;    }  }  return aff;}/*** This routine is called by the parser while in the middle of** parsing a CREATE TABLE statement.  The pFirst token is the first** token in the sequence of tokens that describe the type of the** column currently under construction.   pLast is the last token** in the sequence.  Use this information to construct a string** that contains the typename of the column and store that string** in zType.*/ void sqlite3AddColumnType(Parse *pParse, Token *pType){  Table *p;  int i;  Column *pCol;  if( (p = pParse->pNewTable)==0 ) return;  i = p->nCol-1;  if( i<0 ) return;  pCol = &p->aCol[i];  sqliteFree(pCol->zType);  pCol->zType = sqlite3NameFromToken(pType);  pCol->affinity = sqlite3AffinityType(pType);}/*** The expression is the default value for the most recently added column** of the table currently under construction.**** Default value expressions must be constant.  Raise an exception if this** is not the case.**** This routine is called by the parser while in the middle of** parsing a CREATE TABLE statement.*/void sqlite3AddDefaultValue(Parse *pParse, Expr *pExpr){  Table *p;  Column *pCol;  if( (p = pParse->pNewTable)!=0 ){    pCol = &(p->aCol[p->nCol-1]);    if( !sqlite3ExprIsConstantOrFunction(pExpr) ){      sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",          pCol->zName);    }else{      sqlite3ExprDelete(pCol->pDflt);      pCol->pDflt = sqlite3ExprDup(pExpr);    }  }  sqlite3ExprDelete(pExpr);}/*** Designate the PRIMARY KEY for the table.  pList is a list of names ** of columns that form the primary key.  If pList is NULL, then the** most recently added column of the table is the primary key.**** A table can have at most one primary key.  If the table already has** a primary key (and this is the second primary key) then create an** error.**** If the PRIMARY KEY is on a single column whose datatype is INTEGER,** then we will try to use that column as the rowid.  Set the Table.iPKey** field of the table under construction to be the index of the** INTEGER PRIMARY KEY column.  Table.iPKey is set to -1 if there is** no INTEGER PRIMARY KEY.**** If the key is not an INTEGER PRIMARY KEY, then create a unique** index for the key.  No index is created for INTEGER PRIMARY KEYs.*/void sqlite3AddPrimaryKey(  Parse *pParse,    /* Parsing context */  ExprList *pList,  /* List of field names to be indexed */  int onError,      /* What to do with a uniqueness conflict */  int autoInc,      /* True if the AUTOINCREMENT keyword is present */  int sortOrder     /* SQLITE_SO_ASC or SQLITE_SO_DESC */){  Table *pTab = pParse->pNewTable;  char *zType = 0;  int iCol = -1, i;  if( pTab==0 ) goto primary_key_exit;  if( pTab->hasPrimKey ){    sqlite3ErrorMsg(pParse,       "table \"%s\" has more than one primary key", pTab->zName);    goto primary_key_exit;  }  pTab->hasPrimKey = 1;  if( pList==0 ){    iCol = pTab->nCol - 1;    pTab->aCol[iCol].isPrimKey = 1;  }else{    for(i=0; i<pList->nExpr; i++){      for(iCol=0; iCol<pTab->nCol; iCol++){        if( sqlite3StrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ){          break;        }      }      if( iCol<pTab->nCol ){        pTab->aCol[iCol].isPrimKey = 1;      }    }    if( pList->nExpr>1 ) iCol = -1;  }  if( iCol>=0 && iCol<pTab->nCol ){    zType = pTab->aCol[iCol].zType;  }  if( zType && sqlite3StrICmp(zType, "INTEGER")==0        && sortOrder==SQLITE_SO_ASC ){    pTab->iPKey = iCol;    pTab->keyConf = onError;    pTab->autoInc = autoInc;  }else if( autoInc ){#ifndef SQLITE_OMIT_AUTOINCREMENT    sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "       "INTEGER PRIMARY KEY");#endif  }else{    sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0, 0, sortOrder, 0);    pList = 0;  }primary_key_exit:  sqlite3ExprListDelete(pList);  return;}/*** Add a new CHECK constraint to the table currently under construction.*/void sqlite3AddCheckConstraint(  Parse *pParse,    /* Parsing context */  Expr *pCheckExpr  /* The check expression */){#ifndef SQLITE_OMIT_CHECK  Table *pTab = pParse->pNewTable;  if( pTab ){    /* The CHECK expression must be duplicated so that tokens refer    ** to malloced space and not the (ephemeral) text of the CREATE TABLE    ** statement */    pTab->pCheck = sqlite3ExprAnd(pTab->pCheck, sqlite3ExprDup(pCheckExpr));  }#endif  sqlite3ExprDelete(pCheckExpr);}/*** Set the collation function of the most recently parsed table column** to the CollSeq given.*/void sqlite3AddCollateType(Parse *pParse, const char *zType, int nType){  Table *p;  int i;  if( (p = pParse->pNewTable)==0 ) return;  i = p->nCol-1;  if( sqlite3LocateCollSeq(pParse, zType, nType) ){    Index *pIdx;    p->aCol[i].zColl = sqliteStrNDup(zType, nType);      /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",    ** then an index may have been created on this column before the    ** collation type was added. Correct this if it is the case.    */    for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){      assert( pIdx->nColumn==1 );      if( pIdx->aiColumn[0]==i ){        pIdx->azColl[0] = p->aCol[i].zColl;      }    }  }}/*** This function returns the collation sequence for database native text** encoding identified by the string zName, length nName.**** If the requested collation sequence is not available, or not available** in the database native encoding, the collation factory is invoked to** request it. If the collation factory does not supply such a sequence,** and the sequence is available in another text encoding, then that is** returned instead.**** If no versions of the requested collations sequence are available, or** another error occurs, NULL is returned and an error message written into** pParse.*/CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName, int nName){  sqlite3 *db = pParse->db;  u8 enc = ENC(db);  u8 initbusy = db->init.busy;  CollSeq *pColl;  pColl = sqlite3FindCollSeq(db, enc, zName, nName, initbusy);  if( !initbusy && (!pColl || !pColl->xCmp) ){    pColl = sqlite3GetCollSeq(db, pColl, zName, nName);    if( !pColl ){      if( nName<0 ){        nName = strlen(zName);      }      sqlite3ErrorMsg(pParse, "no such collation sequence: %.*s", nName, zName);      pColl = 0;    }  }  return pColl;}/*** Generate code that will increment the schema cookie.**** The schema cookie is used to determine when the schema for the** database changes.  After each schema change, the cookie value** changes.  When a process first reads the schema it records the** cookie.  Thereafter, whenever it goes to access the database,** it checks the cookie to make sure the schema has not changed** since it was last read.**