自学教程：C++ sqlite3StrICmp函数代码示例

/*** Interpret the given string as a locking mode value.*/static int getLockingMode(const char *z){  if( z ){    if( 0==sqlite3StrICmp(z, "exclusive") ) return PAGER_LOCKINGMODE_EXCLUSIVE;    if( 0==sqlite3StrICmp(z, "normal") ) return PAGER_LOCKINGMODE_NORMAL;  }  return PAGER_LOCKINGMODE_QUERY;}

int sqlcipher_cipher_profile(sqlite3 *db, const char *destination){  FILE *f;  if(sqlite3StrICmp(destination, "stdout") == 0){    f = stdout;  }else if(sqlite3StrICmp(destination, "stderr") == 0){    f = stderr;  }else if(sqlite3StrICmp(destination, "off") == 0){    f = 0;  }else{#if defined(_WIN32) && (__STDC_VERSION__ > 199901L) || defined(SQLITE_OS_WINRT)    if(fopen_s(&f, destination, "a") != 0){#else    f = fopen(destination, "a");    if(f == 0){#endif        return SQLITE_ERROR;  }	  }  sqlite3_profile(db, sqlcipher_profile_callback, f);  return SQLITE_OK;}static void sqlcipher_profile_callback(void *file, const char *sql, sqlite3_uint64 run_time){  FILE *f = (FILE*)file;  double elapsed = run_time/1000000.0;  if(f) fprintf(f, "Elapsed time:%.3f ms - %s/n", elapsed, sql);}

/*** Interpret the given string as an auto-vacuum mode value.**** The following strings, "none", "full" and "incremental" are ** acceptable, as are their numeric equivalents: 0, 1 and 2 respectively.*/static int getAutoVacuum(const char *z){  int i;  if( 0==sqlite3StrICmp(z, "none") ) return BTREE_AUTOVACUUM_NONE;  if( 0==sqlite3StrICmp(z, "full") ) return BTREE_AUTOVACUUM_FULL;  if( 0==sqlite3StrICmp(z, "incremental") ) return BTREE_AUTOVACUUM_INCR;  i = atoi(z);  return ((i>=0&&i<=2)?i:0);}

/*** Interpret the given string as a temp db location. Return 1 for file** backed temporary databases, 2 for the Red-Black tree in memory database** and 0 to use the compile-time default.*/static int getTempStore(const char *z){  if( z[0]>='0' && z[0]<='2' ){    return z[0] - '0';  }else if( sqlite3StrICmp(z, "file")==0 ){    return 1;  }else if( sqlite3StrICmp(z, "memory")==0 ){    return 2;  }else{    return 0;  }}

__declspec(dllexport) int WINAPI sqlite3_index_column_info_interop(sqlite3 *db, const char *zDb, const char *zIndexName, const char *zColumnName, int *sortOrder, int *onError, char **pzColl, int *plen){  Index *pIdx;  Table *pTab;  char *zErrMsg = 0;  int n;  pIdx = sqlite3FindIndex(db, zIndexName, zDb);  if (!pIdx) return SQLITE_ERROR;  pTab = pIdx->pTable;  for (n = 0; n < pIdx->nColumn; n++)  {    int cnum = pIdx->aiColumn[n];    if (sqlite3StrICmp(pTab->aCol[cnum].zName, zColumnName) == 0)    {      *sortOrder = pIdx->aSortOrder[n];      *pzColl = pIdx->azColl[n];      *plen = strlen(*pzColl);      *onError = pIdx->onError;      return SQLITE_OK;    }  }  return SQLITE_ERROR;}

/*** The following set of routines walk through the parse tree and assign** a specific database to all table references where the database name** was left unspecified in the original SQL statement.  The pFix structure** must have been initialized by a prior call to sqlite3FixInit().**** These routines are used to make sure that an index, trigger, or** view in one database does not refer to objects in a different database.** (Exception: indices, triggers, and views in the TEMP database are** allowed to refer to anything.)  If a reference is explicitly made** to an object in a different database, an error message is added to** pParse->zErrMsg and these routines return non-zero.  If everything** checks out, these routines return 0.*/int sqlite3FixSrcList(  DbFixer *pFix,       /* Context of the fixation */  SrcList *pList       /* The Source list to check and modify */){  int i;  const char *zDb;  struct SrcList_item *pItem;  if( NEVER(pList==0) ) return 0;  zDb = pFix->zDb;  for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){    if( pItem->zDatabase==0 ){      pItem->zDatabase = sqlite3DbStrDup(pFix->pParse->db, zDb);    }else if( sqlite3StrICmp(pItem->zDatabase,zDb)!=0 ){      sqlite3ErrorMsg(pFix->pParse,         "%s %T cannot reference objects in database %s",         pFix->zType, pFix->pName, pItem->zDatabase);      return 1;    }#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)    if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;    if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;#endif  }  return 0;}

/*** This function is called to drop a trigger from the database schema. **** This may be called directly from the parser and therefore identifies** the trigger by name.  The sqlite3DropTriggerPtr() routine does the** same job as this routine except it takes a pointer to the trigger** instead of the trigger name.**/void sqlite3DropTrigger(Parse *pParse, SrcList *pName){  Trigger *pTrigger = 0;  int i;  const char *zDb;  const char *zName;  int nName;  sqlite *db = pParse->db;  if( sqlite3_malloc_failed ) goto drop_trigger_cleanup;  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){    goto drop_trigger_cleanup;  }  assert( pName->nSrc==1 );  zDb = pName->a[0].zDatabase;  zName = pName->a[0].zName;  nName = strlen(zName);  for(i=0; i<db->nDb; i++){    int j = (i<2) ? i^1 : i;  /* Search TEMP before MAIN */    if( zDb && sqlite3StrICmp(db->aDb[j].zName, zDb) ) continue;    pTrigger = sqlite3HashFind(&(db->aDb[j].trigHash), zName, nName+1);    if( pTrigger ) break;  }  if( !pTrigger ){    sqlite3ErrorMsg(pParse, "no such trigger: %S", pName, 0);    goto drop_trigger_cleanup;  }  sqlite3DropTriggerPtr(pParse, pTrigger, 0);drop_trigger_cleanup:  sqlite3SrcListDelete(pName);}

/*** The following set of routines walk through the parse tree and assign** a specific database to all table references where the database name** was left unspecified in the original SQL statement.  The pFix structure** must have been initialized by a prior call to sqlite3FixInit().**** These routines are used to make sure that an index, trigger, or** view in one database does not refer to objects in a different database.** (Exception: indices, triggers, and views in the TEMP database are** allowed to refer to anything.)  If a reference is explicitly made** to an object in a different database, an error message is added to** pParse->zErrMsg and these routines return non-zero.  If everything** checks out, these routines return 0.*/int sqlite3FixSrcList(  DbFixer *pFix,       /* Context of the fixation */  SrcList *pList       /* The Source list to check and modify */){  int i;  const char *zDb;  struct SrcList_item *pItem;  if( NEVER(pList==0) ) return 0;  zDb = pFix->zDb;  for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){    if( pFix->bVarOnly==0 ){      if( pItem->zDatabase && sqlite3StrICmp(pItem->zDatabase, zDb) ){        sqlite3ErrorMsg(pFix->pParse,            "%s %T cannot reference objects in database %s",            pFix->zType, pFix->pName, pItem->zDatabase);        return 1;      }      sqlite3DbFree(pFix->pParse->db, pItem->zDatabase);      pItem->zDatabase = 0;      pItem->pSchema = pFix->pSchema;    }#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)    if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;    if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;#endif    if( pItem->fg.isTabFunc && sqlite3FixExprList(pFix, pItem->u1.pFuncArg) ){      return 1;    }  }  return 0;}

/* This function (for internal use only) locates an element in an** hash table that matches the given key.  The hash for this key is** also computed and returned in the *pH parameter.*/static HashElem *findElementWithHash(    const Hash *pH,     /* The pH to be searched */    const char *pKey,   /* The key we are searching for */    unsigned int *pHash /* Write the hash value here */) {    HashElem *elem;                /* Used to loop thru the element list */    int count;                     /* Number of elements left to test */    unsigned int h;                /* The computed hash */    if( pH->ht ) {  /*OPTIMIZATION-IF-TRUE*/        struct _ht *pEntry;        h = strHash(pKey) % pH->htsize;        pEntry = &pH->ht[h];        elem = pEntry->chain;        count = pEntry->count;    } else {        h = 0;        elem = pH->first;        count = pH->count;    }    *pHash = h;    while( count-- ) {        assert( elem!=0 );        if( sqlite3StrICmp(elem->pKey,pKey)==0 ) {            return elem;        }        elem = elem->next;    }    return 0;}

/*** Return TRUE if the name zCol occurs anywhere in the USING clause.**** Return FALSE if the USING clause is NULL or if it does not contain** zCol.*/static int nameInUsingClause(IdList *pUsing, const char *zCol){  if( pUsing ){    int k;    for(k=0; k<pUsing->nId; k++){      if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ) return 1;    }  }  return 0;}

/*** Check to see if zRight and zLeft refer to a pragma that queries** or changes one of the flags in db->flags.  Return 1 if so and 0 if not.** Also, implement the pragma.*/static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){  static const struct sPragmaType {    const char *zName;  /* Name of the pragma */    int mask;           /* Mask for the db->flags value */  } aPragma[] = {    { "full_column_names",        SQLITE_FullColNames  },    { "short_column_names",       SQLITE_ShortColNames },    { "count_changes",            SQLITE_CountRows     },    { "empty_result_callbacks",   SQLITE_NullCallback  },    { "legacy_file_format",       SQLITE_LegacyFileFmt },    { "fullfsync",                SQLITE_FullFSync     },#ifdef SQLITE_DEBUG    { "sql_trace",                SQLITE_SqlTrace      },    { "vdbe_listing",             SQLITE_VdbeListing   },    { "vdbe_trace",               SQLITE_VdbeTrace     },#endif#ifndef SQLITE_OMIT_CHECK    { "ignore_check_constraints", SQLITE_IgnoreChecks  },#endif    /* The following is VERY experimental */    { "writable_schema",          SQLITE_WriteSchema|SQLITE_RecoveryMode },    { "omit_readlock",            SQLITE_NoReadlock    },    /* TODO: Maybe it shouldn't be possible to change the ReadUncommitted    ** flag if there are any active statements. */    { "read_uncommitted",         SQLITE_ReadUncommitted },  };  int i;  const struct sPragmaType *p;  for(i=0, p=aPragma; i<sizeof(aPragma)/sizeof(aPragma[0]); i++, p++){    if( sqlite3StrICmp(zLeft, p->zName)==0 ){      sqlite3 *db = pParse->db;      Vdbe *v;      v = sqlite3GetVdbe(pParse);      if( v ){        if( zRight==0 ){          returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );        }else{          if( getBoolean(zRight) ){            db->flags |= p->mask;          }else{            db->flags &= ~p->mask;          }          /* Many of the flag-pragmas modify the code generated by the SQL           ** compiler (eg. count_changes). So add an opcode to expire all          ** compiled SQL statements after modifying a pragma value.          */          sqlite3VdbeAddOp2(v, OP_Expire, 0, 0);        }      }      return 1;    }  }  return 0;}

/*** Search a FuncDefHash for a function with the given name.  Return** a pointer to the matching FuncDef if found, or 0 if there is no match.*/static FuncDef *functionSearch(  int h,               /* Hash of the name */  const char *zFunc    /* Name of function */){  FuncDef *p;  for(p=sqlite3BuiltinFunctions.a[h]; p; p=p->u.pHash){    if( sqlite3StrICmp(p->zName, zFunc)==0 ){      return p;    }  }  return 0;}

/*** We already know that pExpr is a binary operator where both operands are** column references.  This routine checks to see if pExpr is an equivalence** relation:**   1.  The SQLITE_Transitive optimization must be enabled**   2.  Must be either an == or an IS operator**   3.  Not originating in the ON clause of an OUTER JOIN**   4.  The affinities of A and B must be compatible**   5a. Both operands use the same collating sequence OR**   5b. The overall collating sequence is BINARY** If this routine returns TRUE, that means that the RHS can be substituted** for the LHS anyplace else in the WHERE clause where the LHS column occurs.** This is an optimization.  No harm comes from returning 0.  But if 1 is** returned when it should not be, then incorrect answers might result.*/static int termIsEquivalence(Parse *pParse, Expr *pExpr){  char aff1, aff2;  CollSeq *pColl;  const char *zColl1, *zColl2;  if( !OptimizationEnabled(pParse->db, SQLITE_Transitive) ) return 0;  if( pExpr->op!=TK_EQ && pExpr->op!=TK_IS ) return 0;  if( ExprHasProperty(pExpr, EP_FromJoin) ) return 0;  aff1 = sqlite3ExprAffinity(pExpr->pLeft);  aff2 = sqlite3ExprAffinity(pExpr->pRight);  if( aff1!=aff2   && (!sqlite3IsNumericAffinity(aff1) || !sqlite3IsNumericAffinity(aff2))  ){    return 0;  }  pColl = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft, pExpr->pRight);  if( pColl==0 || sqlite3StrICmp(pColl->zName, "BINARY")==0 ) return 1;  pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);  /* Since pLeft and pRight are both a column references, their collating  ** sequence should always be defined. */  zColl1 = ALWAYS(pColl) ? pColl->zName : 0;  pColl = sqlite3ExprCollSeq(pParse, pExpr->pRight);  zColl2 = ALWAYS(pColl) ? pColl->zName : 0;  return sqlite3StrICmp(zColl1, zColl2)==0;}

static void renameParentFunc(  sqlite3_context *context,  int NotUsed,  sqlite3_value **argv){  sqlite3 *db = sqlite3_context_db_handle(context);  char *zOutput = 0;  char *zResult;  unsigned char const *zInput = sqlite3_value_text(argv[0]);  unsigned char const *zOld = sqlite3_value_text(argv[1]);  unsigned char const *zNew = sqlite3_value_text(argv[2]);  unsigned const char *z;         /* Pointer to token */  int n;                          /* Length of token z */  int token;                      /* Type of token */  UNUSED_PARAMETER(NotUsed);  if( zInput==0 || zOld==0 ) return;  for(z=zInput; *z; z=z+n){    n = sqlite3GetToken(z, &token);    if( token==TK_REFERENCES ){      char *zParent;      do {        z += n;        n = sqlite3GetToken(z, &token);      }while( token==TK_SPACE );      if( token==TK_ILLEGAL ) break;      zParent = sqlite3DbStrNDup(db, (const char *)z, n);      if( zParent==0 ) break;      sqlite3Dequote(zParent);      if( 0==sqlite3StrICmp((const char *)zOld, zParent) ){        char *zOut = sqlite3MPrintf(db, "%s%.*s/"%w/"",            (zOutput?zOutput:""), (int)(z-zInput), zInput, (const char *)zNew        );        sqlite3DbFree(db, zOutput);        zOutput = zOut;        zInput = &z[n];      }      sqlite3DbFree(db, zParent);    }  }  zResult = sqlite3MPrintf(db, "%s%s", (zOutput?zOutput:""), zInput),  sqlite3_result_text(context, zResult, -1, SQLITE_DYNAMIC);  sqlite3DbFree(db, zOutput);}

/*** An SQL user-function registered to do the work of an DETACH statement. The** three arguments to the function come directly from a detach statement:****     DETACH DATABASE x****     SELECT sqlite_detach(x)*/static void detachFunc(  sqlite3_context *context,  int NotUsed,  sqlite3_value **argv){  const char *zName = (const char *)sqlite3_value_text(argv[0]);  sqlite3 *db = sqlite3_context_db_handle(context);  int i;  Db *pDb = 0;  char zErr[128];  UNUSED_PARAMETER(NotUsed);  if( zName==0 ) zName = "";  for(i=0; i<db->nDb; i++){    pDb = &db->aDb[i];    if( pDb->pBt==0 ) continue;    if( sqlite3StrICmp(pDb->zName, zName)==0 ) break;  }  if( i>=db->nDb ){    sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);    goto detach_error;  }  if( i<2 ){    sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);    goto detach_error;  }  if( !db->autoCommit ){    sqlite3_snprintf(sizeof(zErr), zErr,                     "cannot DETACH database within transaction");    goto detach_error;  }  if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){    sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);    goto detach_error;  }  sqlite3BtreeClose(pDb->pBt);  pDb->pBt = 0;  pDb->pSchema = 0;  sqlite3ResetInternalSchema(db, 0);  return;detach_error:  sqlite3_result_error(context, zErr, -1);}

/*** This function is called before generating code to update or delete a ** row contained in table pTab. If the operation is a DELETE, then** parameter aChange is passed a NULL value. For an UPDATE, aChange points** to an array of size N, where N is the number of columns in table pTab.** If the i'th column is not modified by the UPDATE, then the corresponding ** entry in the aChange[] array is set to -1. If the column is modified,** the value is 0 or greater. Parameter chngRowid is set to true if the** UPDATE statement modifies the rowid fields of the table.**** If any foreign key processing will be required, this function returns** true. If there is no foreign key related processing, this function ** returns false.*/int sqlite3FkRequired(  Parse *pParse,                  /* Parse context */  Table *pTab,                    /* Table being modified */  int *aChange,                   /* Non-NULL for UPDATE operations */  int chngRowid                   /* True for UPDATE that affects rowid */){  if( pParse->db->flags&SQLITE_ForeignKeys ){    if( !aChange ){      /* A DELETE operation. Foreign key processing is required if the       ** table in question is either the child or parent table for any       ** foreign key constraint.  */      return (sqlite3FkReferences(pTab) || pTab->pFKey);    }else{      /* This is an UPDATE. Foreign key processing is only required if the      ** operation modifies one or more child or parent key columns. */      int i;      FKey *p;      /* Check if any child key columns are being modified. */      for(p=pTab->pFKey; p; p=p->pNextFrom){        for(i=0; i<p->nCol; i++){          int iChildKey = p->aCol[i].iFrom;          if( aChange[iChildKey]>=0 ) return 1;          if( iChildKey==pTab->iPKey && chngRowid ) return 1;        }      }      /* Check if any parent key columns are being modified. */      for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){        for(i=0; i<p->nCol; i++){          char *zKey = p->aCol[i].zCol;          int iKey;          for(iKey=0; iKey<pTab->nCol; iKey++){            Column *pCol = &pTab->aCol[iKey];            if( (zKey ? !sqlite3StrICmp(pCol->zName, zKey) : pCol->isPrimKey) ){              if( aChange[iKey]>=0 ) return 1;              if( iKey==pTab->iPKey && chngRowid ) return 1;            }          }        }      }    }  }  return 0;}

/*** Given table pTab, return a list of all the triggers attached to ** the table. The list is connected by Trigger.pNext pointers.**** All of the triggers on pTab that are in the same database as pTab** are already attached to pTab->pTrigger.  But there might be additional** triggers on pTab in the TEMP schema.  This routine prepends all** TEMP triggers on pTab to the beginning of the pTab->pTrigger list** and returns the combined list.**** To state it another way:  This routine returns a list of all triggers** that fire off of pTab.  The list will include any TEMP triggers on** pTab as well as the triggers lised in pTab->pTrigger.*/Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){  Schema * const pTmpSchema = pParse->db->aDb[1].pSchema;  Trigger *pList = 0;                  /* List of triggers to return */  if( pTmpSchema!=pTab->pSchema ){    HashElem *p;    for(p=sqliteHashFirst(&pTmpSchema->trigHash); p; p=sqliteHashNext(p)){      Trigger *pTrig = (Trigger *)sqliteHashData(p);      if( pTrig->pTabSchema==pTab->pSchema       && 0==sqlite3StrICmp(pTrig->table, pTab->zName)       ){        pTrig->pNext = (pList ? pList : pTab->pTrigger);        pList = pTrig;      }    }  }  return (pList ? pList : pTab->pTrigger);}

/*** Check to see if zRight and zLeft refer to a pragma that queries** or changes one of the flags in db->flags.  Return 1 if so and 0 if not.** Also, implement the pragma.*/static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){  static const struct sPragmaType {    const char *zName;  /* Name of the pragma */    int mask;           /* Mask for the db->flags value */  } aPragma[] = {    { "vdbe_trace",               SQLITE_VdbeTrace     },    { "sql_trace",                SQLITE_SqlTrace      },    { "vdbe_listing",             SQLITE_VdbeListing   },    { "full_column_names",        SQLITE_FullColNames  },    { "short_column_names",       SQLITE_ShortColNames },    { "count_changes",            SQLITE_CountRows     },    { "empty_result_callbacks",   SQLITE_NullCallback  },    /* The following is VERY experimental */    { "writable_schema",          SQLITE_WriteSchema   },    { "omit_readlock",            SQLITE_NoReadlock    },  };  int i;  const struct sPragmaType *p;  for(i=0, p=aPragma; i<sizeof(aPragma)/sizeof(aPragma[0]); i++, p++){    if( sqlite3StrICmp(zLeft, p->zName)==0 ){      sqlite3 *db = pParse->db;      Vdbe *v;      v = sqlite3GetVdbe(pParse);      if( v ){        if( zRight==0 ){          returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );        }else{          if( getBoolean(zRight) ){            db->flags |= p->mask;          }else{            db->flags &= ~p->mask;          }        }        /* If one of these pragmas is executed, any prepared statements        ** need to be recompiled.        */        sqlite3VdbeAddOp(v, OP_Expire, 0, 0);      }      return 1;    }  }  return 0;}

/*** This routine is called by the parser to process a DETACH statement:****    DETACH DATABASE dbname**** The pDbname argument is the name of the database in the DETACH statement.*/void sqlite3Detach(Parse *pParse, Token *pDbname){  int i;  sqlite3 *db;  Vdbe *v;  Db *pDb = 0;  char *zName;  v = sqlite3GetVdbe(pParse);  if( !v ) return;  sqlite3VdbeAddOp(v, OP_Expire, 0, 0);  sqlite3VdbeAddOp(v, OP_Halt, 0, 0);  if( pParse->explain ) return;  db = pParse->db;  zName = sqlite3NameFromToken(pDbname);  if( zName==0 ) return;  for(i=0; i<db->nDb; i++){    pDb = &db->aDb[i];    if( pDb->pBt==0 ) continue;    if( sqlite3StrICmp(pDb->zName, zName)==0 ) break;  }  if( i>=db->nDb ){    sqlite3ErrorMsg(pParse, "no such database: %z", zName);    return;  }  if( i<2 ){    sqlite3ErrorMsg(pParse, "cannot detach database %z", zName);    return;  }  sqliteFree(zName);  if( !db->autoCommit ){    sqlite3ErrorMsg(pParse, "cannot DETACH database within transaction");    pParse->rc = SQLITE_ERROR;    return;  }#ifndef SQLITE_OMIT_AUTHORIZATION  if( sqlite3AuthCheck(pParse,SQLITE_DETACH,db->aDb[i].zName,0,0)!=SQLITE_OK ){    return;  }#endif /* SQLITE_OMIT_AUTHORIZATION */  sqlite3BtreeClose(pDb->pBt);  pDb->pBt = 0;  sqlite3ResetInternalSchema(db, 0);}

/*** Attempt to parse the given string into a julian day number.  Return** the number of errors.**** The following are acceptable forms for the input string:****      YYYY-MM-DD HH:MM:SS.FFF  +/-HH:MM**      DDDD.DD **      now**** In the first form, the +/-HH:MM is always optional.  The fractional** seconds extension (the ".FFF") is optional.  The seconds portion** (":SS.FFF") is option.  The year and date can be omitted as long** as there is a time string.  The time string can be omitted as long** as there is a year and date.*/static int parseDateOrTime(  sqlite3_context *context,   const char *zDate,   DateTime *p){  double r;  if( parseYyyyMmDd(zDate,p)==0 ){    return 0;  }else if( parseHhMmSs(zDate, p)==0 ){    return 0;  }else if( sqlite3StrICmp(zDate,"now")==0){    return setDateTimeToCurrent(context, p);  }else if( sqlite3AtoF(zDate, &r, sqlite3Strlen30(zDate), SQLITE_UTF8) ){    p->iJD = (sqlite3_int64)(r*86400000.0 + 0.5);    p->validJD = 1;    return 0;  }  return 1;}

/*** pEList is a list of expressions which are really the result set of the** a SELECT statement.  pE is a term in an ORDER BY or GROUP BY clause.** This routine checks to see if pE is a simple identifier which corresponds** to the AS-name of one of the terms of the expression list.  If it is,** this routine return an integer between 1 and N where N is the number of** elements in pEList, corresponding to the matching entry.  If there is** no match, or if pE is not a simple identifier, then this routine** return 0.**** pEList has been resolved.  pE has not.*/static int resolveAsName(  Parse *pParse,     /* Parsing context for error messages */  ExprList *pEList,  /* List of expressions to scan */  Expr *pE           /* Expression we are trying to match */){  int i;             /* Loop counter */  UNUSED_PARAMETER(pParse);  if( pE->op==TK_ID ){    char *zCol = pE->u.zToken;    for(i=0; i<pEList->nExpr; i++){      char *zAs = pEList->a[i].zName;      if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){        return i+1;      }    }  }  return 0;}

/*** Check to see if the given expression is of the form****         column MATCH expr**** If it is then return TRUE.  If not, return FALSE.*/static int isMatchOfColumn(  Expr *pExpr      /* Test this expression */){  ExprList *pList;  if( pExpr->op!=TK_FUNCTION ){    return 0;  }  if( sqlite3StrICmp(pExpr->u.zToken,"match")!=0 ){    return 0;  }  pList = pExpr->x.pList;  if( pList->nExpr!=2 ){    return 0;  }  if( pList->a[1].pExpr->op != TK_COLUMN ){    return 0;  }  return 1;}

/*** This function is called to drop a trigger from the database schema.**** This may be called directly from the parser and therefore identifies** the trigger by name.  The sqlite3DropTriggerPtr() routine does the** same job as this routine except it takes a pointer to the trigger** instead of the trigger name.**/void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr){    Trigger *pTrigger = 0;    int i;    const char *zDb;    const char *zName;    int nName;    sqlite3 *db = pParse->db;    if (db->mallocFailed) goto drop_trigger_cleanup;    if (SQLITE_OK != sqlite3ReadSchema(pParse)){        goto drop_trigger_cleanup;    }    assert(pName->nSrc == 1);    zDb = pName->a[0].zDatabase;    zName = pName->a[0].zName;    nName = sqlite3Strlen30(zName);    assert(zDb != 0 || sqlite3BtreeHoldsAllMutexes(db));    for (i = OMIT_TEMPDB; i < db->nDb; i++){        int j = (i < 2) ? i ^ 1 : i;  /* Search TEMP before MAIN */        if (zDb && sqlite3StrICmp(db->aDb[j].zName, zDb)) continue;        assert(sqlite3SchemaMutexHeld(db, j, 0));        pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName, nName);        if (pTrigger) break;    }    if (!pTrigger){        if (!noErr){            sqlite3ErrorMsg(pParse, "no such trigger: %S", pName, 0);        }        else{            sqlite3CodeVerifyNamedSchema(pParse, zDb);        }        pParse->checkSchema = 1;        goto drop_trigger_cleanup;    }    sqlite3DropTriggerPtr(pParse, pTrigger);drop_trigger_cleanup:    sqlite3SrcListDelete(db, pName);}

/*** An SQL user-function registered to do the work of an DETACH statement. The** three arguments to the function come directly from a detach statement:****     DETACH DATABASE x****     SELECT sqlite_detach(x)*/static void detachFunc(  sqlite3_context *context,  int argc,  sqlite3_value **argv){  const char *zName = (const char *)sqlite3_value_text(argv[0]);  sqlite3 *db = sqlite3_user_data(context);  int i;  Db *pDb = 0;  char zErr[128];  assert(zName);  for(i=0; i<db->nDb; i++){    pDb = &db->aDb[i];    if( pDb->pBt==0 ) continue;    if( sqlite3StrICmp(pDb->zName, zName)==0 ) break;  }  if( i>=db->nDb ){    sqlite3_snprintf(sizeof(zErr), zErr, "no such database: %s", zName);    goto detach_error;  }  if( i<2 ){    sqlite3_snprintf(sizeof(zErr), zErr, "cannot detach database %s", zName);    goto detach_error;  }  if( !db->autoCommit ){    strcpy(zErr, "cannot DETACH database within transaction");    goto detach_error;  }  sqlite3BtreeClose(pDb->pBt);  pDb->pBt = 0;  pDb->pSchema = 0;  sqlite3ResetInternalSchema(db, 0);  return;detach_error:  sqlite3_result_error(context, zErr, -1);}

/*** Subqueries stores the original database, table and column names for their** result sets in ExprList.a[].zSpan, in the form "DATABASE.TABLE.COLUMN".** Check to see if the zSpan given to this routine matches the zDb, zTab,** and zCol.  If any of zDb, zTab, and zCol are NULL then those fields will** match anything.*/int sqlite3MatchSpanName(  const char *zSpan,  const char *zCol,  const char *zTab,  const char *zDb){  int n;  for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}  if( zDb && (sqlite3StrNICmp(zSpan, zDb, n)!=0 || zDb[n]!=0) ){    return 0;  }  zSpan += n+1;  for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}  if( zTab && (sqlite3StrNICmp(zSpan, zTab, n)!=0 || zTab[n]!=0) ){    return 0;  }  zSpan += n+1;  if( zCol && sqlite3StrICmp(zSpan, zCol)!=0 ){    return 0;  }  return 1;}

int sqlite3_key_v2(    sqlite3 *db, const char *zDbName, const void *key, int nkey) {	int backend;	const char *dbname;	// NULL is an alias of the "main" database.	if (zDbName == NULL)		dbname = "main";	else		dbname = zDbName;	for(backend = 0; backend < db->nDb; backend++) {		if (db->aDb[backend].zName == NULL)			continue;		if (sqlite3StrICmp(db->aDb[backend].zName, dbname) == 0)			break;	}	if (backend == db->nDb)		return SQLITE_NOTFOUND;	return sqlite3CodecAttach(db, backend, key, nkey);}

/*** pEList is a list of expressions which are really the result set of the** a SELECT statement.  pE is a term in an ORDER BY or GROUP BY clause.** This routine checks to see if pE is a simple identifier which corresponds** to the AS-name of one of the terms of the expression list.  If it is,** this routine return an integer between 1 and N where N is the number of** elements in pEList, corresponding to the matching entry.  If there is** no match, or if pE is not a simple identifier, then this routine** return 0.**** pEList has been resolved.  pE has not.*/static int resolveAsName(  Parse *pParse,     /* Parsing context for error messages */  ExprList *pEList,  /* List of expressions to scan */  Expr *pE           /* Expression we are trying to match */){  int i;             /* Loop counter */  if( pE->op==TK_ID || (pE->op==TK_STRING && pE->token.z[0]!='/'') ){    sqlite3 *db = pParse->db;    char *zCol = sqlite3NameFromToken(db, &pE->token);    if( zCol==0 ){      return -1;    }    for(i=0; i<pEList->nExpr; i++){      char *zAs = pEList->a[i].zName;      if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){        sqlite3DbFree(db, zCol);        return i+1;      }    }    sqlite3DbFree(db, zCol);  }  return 0;}