SQLite

*/
static void analyzeOneTable(
  Parse *pParse,   /* Parser context */
  Table *pTab,     /* Table whose indices are to be analyzed */
  Index *pOnlyIdx, /* If not NULL, only analyze this one index */
  int iStatCur,    /* Index of VdbeCursor that writes the sqlite_stat1 table */
  int iMem,        /* Available memory locations begin here */
  int iTab,        /* Next available cursor */
  LogEst szOld     /* Run the analysis if table row count is larger than this */
){
  sqlite3 *db = pParse->db;    /* Database handle */
  Index *pIdx;                 /* An index to being analyzed */
  int addrSizeCk = 0;          /* Address of the IfSmaller */
  int iIdxCur;                 /* Cursor open on index being analyzed */
  int iTabCur;                 /* Table cursor */
  Vdbe *v;                     /* The virtual machine being built up */
  int i;                       /* Loop counter */
  int jZeroRows = -1;          /* Jump from here if number of rows is zero */
  int iDb;                     /* Index of database containing pTab */
  u8 needTableCnt = 1;         /* True to count the table */
  int regWorkDone = iMem++;    /* Set to 1 if any work is done */
  int regNewRowid = iMem++;    /* Rowid for the inserted record */
  int regStat4 = iMem++;       /* Register to hold Stat4Accum object */
  int regChng = iMem++;        /* Index of changed index field */
#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
  int regRowid = iMem++;       /* Rowid argument passed to stat_push() */
#endif
  int regTemp = iMem++;        /* Temporary use register */

  ** to use for scanning indexes (iIdxCur). No index cursor is opened at
  ** this time though.  */
  sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
  iTabCur = iTab++;
  iIdxCur = iTab++;
  pParse->nTab = MAX(pParse->nTab, iTab);
  sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
  if( szOld>0 ){
    addrSizeCk = sqlite3VdbeAddOp3(v, OP_IfSmaller, iTabCur, 0, szOld);
    VdbeCoverage(v);
  }
  sqlite3VdbeLoadString(v, regTabname, pTab->zName);

  for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
    int nCol;                     /* Number of columns in pIdx. "N" */
    int addrRewind;               /* Address of "OP_Rewind iIdxCur" */
    int addrNextRow;              /* Address of "next_row:" */
    const char *zIdxName;         /* Name of the index */

    assert( "BBB"[0]==SQLITE_AFF_TEXT );
    sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regTemp, "BBB", 0);
    sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid);
    sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regTemp, regNewRowid);
    sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
    sqlite3VdbeJumpHere(v, jZeroRows);
  }
  sqlite3VdbeAddOp2(v, OP_Integer, 1, regWorkDone);
  VdbeComment((v, "work was done"));
  sqlite3VdbeJumpHere(v, addrSizeCk);
}


/*
** Return true if table pTab might need to being reanalyzed.  Return
** false if we know that pTab should not be reanalyzed.
**
** If returning true, also set *pThreshold to a size threshold that
** will determine at run-time whether or not the reanalysis occurs.
** The reanalysis will only occur if the size of the table is greater
** than the threshold. Not that the threshold is a logarithmic LogEst
** value.


*/
static int analyzeNeeded(Table *pTab, LogEst *pThreshold){
  Index *pIdx;
  if( (pTab->tabFlags & TF_StatsUsed)==0 ) return 0;

  /* If TF_StatsUsed is true, then we might need to reanalyze.
  ** TUNING: Only reanalyze if the table size has grown by a factor
  ** of 25 or more. */
  *pThreshold = pTab->nRowLogEst + 46;  assert( sqlite3LogEst(25)==46 );

  /* Except, if any of the indexes of the table do not have valid
  ** sqlite_stat1 entries, then set the size threshold to zero to
  ** ensure the analysis will always occur. */
  for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
    if( !pIdx->hasStat1 ){
      *pThreshold = 0;
      break;
    }
  }
  return 1;
}

/*
** Generate code that will do an analysis of an entire database, or
** all databases in the connection if iDbReq is negative.
**
** If onlyIfNeeded is true, then only run the analysis if SQLite thinks
** it is actually needed.
*/
void sqlite3AnalyzeDatabase(
  Parse *pParse,       /* The parsing context */
  int iDbReq,          /* Which schema to analyze. -1 for all (except TEMP) */
  int onlyIfNeeded     /* Only do the analysis if needed, when true */
){
  sqlite3 *db = pParse->db;
  Schema *pSchema;
  HashElem *k;
  int iStatCur = 0;
  int iMem = 0;
  int iTab = 0;
  int iDb;                /* Database currently being analyzed */
  int iDbFirst, iDbLast;  /* Range of databases to be analyzed */
  int bStatTabs = 0;
  Vdbe *v = sqlite3GetVdbe(pParse);
  int nHit = 0;
  unsigned char aHit[SQLITE_MAX_ATTACHED+2];

  if( v==0 ) return;
  if( iDbReq>=0 ){
    iDbFirst = iDbLast = iDbReq;
  }else{
    iDbFirst = 0;
    iDbLast = db->nDb-1;
  }
  for(iDb=iDbFirst; iDb<=iDbLast; iDb++, bStatTabs=0){
    if( iDb==1 ) continue;  /* Do not analyze the TEMP database */
    pSchema = db->aDb[iDb].pSchema;
    assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
    for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){
      Table *pTab = (Table*)sqliteHashData(k);
      LogEst szThreshold = 0;
      if( !onlyIfNeeded || analyzeNeeded(pTab, &szThreshold) ){
        if( iMem==0 ){
          iStatCur = pParse->nTab;
          pParse->nTab += 3;

          iMem = pParse->nMem+1;
          iTab = pParse->nTab;
          sqlite3VdbeAddOp2(v, OP_Integer, 0, iMem);
        }
        if( !bStatTabs ){
          aHit[nHit++] = iDb;
          sqlite3BeginWriteOperation(pParse, 0, iDb);
          openStatTable(pParse, iDb, iStatCur, 0, 0);
          bStatTabs = 1;
        }
        analyzeOneTable(pParse, pTab, 0, iStatCur, iMem, iTab, szThreshold);
      }
    }
  }
  if( iMem ){
    int addrTop = sqlite3VdbeAddOp1(v, OP_IfNot, iMem); VdbeCoverage(v);
    for(iDb=0; iDb<nHit; iDb++){
      sqlite3VdbeAddOp1(v, OP_LoadAnalysis, aHit[iDb]);
    }
    sqlite3VdbeAddOp0(v, OP_Expire);
    sqlite3VdbeJumpHere(v, addrTop);
  }
}

/*
** Generate code that will do an analysis of a single table in
** a database.  If pOnlyIdx is not NULL then it is a single index
** in pTab that should be analyzed.
*/
static void analyzeTable(Parse *pParse, Table *pTab, Index *pOnlyIdx){
  int iDb;
  int iStatCur;
  Vdbe *v;

  assert( pTab!=0 );
  assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
  iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
  sqlite3BeginWriteOperation(pParse, 0, iDb);
  iStatCur = pParse->nTab;
  pParse->nTab += 3;
  if( pOnlyIdx ){
    openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
  }else{
    openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
  }
  analyzeOneTable(pParse, pTab, pOnlyIdx, iStatCur, pParse->nMem+1,
                  pParse->nTab, 0);
  v = sqlite3GetVdbe(pParse);
  if( v ){
    sqlite3VdbeAddOp1(v, OP_LoadAnalysis, iDb);
    sqlite3VdbeAddOp0(v, OP_Expire);
  }
}

/*
** Generate code for the ANALYZE command.  The parser calls this routine
** when it recognizes an ANALYZE command.
**
**        ANALYZE                            -- 1
**        ANALYZE  <database>                -- 2
**        ANALYZE  ?<database>.?<tablename>  -- 3
**
** Form 1 causes all indices in all attached databases to be analyzed.
** Form 2 analyzes all indices the single database named.
** Form 3 analyzes all indices associated with the named table.
**
** If pName1 and pName2 are both NULL and if the ifNeeded flag is true,
** this routine computes an conditional ANALYZE on only those tables
** are believed to be in need of analysis.  The conditional analysis
** might well be a no-op.
*/
void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){
  sqlite3 *db = pParse->db;
  int iDb;

  char *z, *zDb;
  Table *pTab;
  Index *pIdx;
  Token *pTableName;


  /* Read the database schema. If an error occurs, leave an error message
  ** and code in pParse and return NULL. */
  assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
    return;
  }

  assert( pName2!=0 || pName1==0 );
  if( pName1==0 ){
    /* Form 1:  Analyze everything */


    sqlite3AnalyzeDatabase(pParse, -1, 0);

  }else if( pName2->n==0 ){
    /* Form 2:  Analyze the database or table named */
    iDb = sqlite3FindDb(db, pName1);
    if( iDb>=0 ){
      sqlite3AnalyzeDatabase(pParse, iDb, 0);
    }else{
      z = sqlite3NameFromToken(db, pName1);
      if( z ){
        if( (pIdx = sqlite3FindIndex(db, z, 0))!=0 ){
          analyzeTable(pParse, pIdx->pTable, pIdx);
        }else if( (pTab = sqlite3LocateTable(pParse, 0, z, 0))!=0 ){
          analyzeTable(pParse, pTab, 0);

        }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
          analyzeTable(pParse, pTab, 0);
        }
        sqlite3DbFree(db, z);
      }
    }   
  }


}

/*
** Used to pass information from the analyzer reader through to the
** callback routine.
*/
typedef struct analysisInfo analysisInfo;

    break;
  }

  /*
  **  PRAGMA analyze_as_needed
  */
  case PragTyp_ANALYZE_AS_NEEDED: {








    sqlite3AnalyzeDatabase(pParse, zDb ? iDb : -1, 1);


























    break;
  }

  /*
  **   PRAGMA busy_timeout
  **   PRAGMA busy_timeout = N
  **

int sqlite3ResolveOrderGroupBy(Parse*, Select*, ExprList*, const char*);
void sqlite3ColumnDefault(Vdbe *, Table *, int, int);
void sqlite3AlterFinishAddColumn(Parse *, Token *);
void sqlite3AlterBeginAddColumn(Parse *, SrcList *);
CollSeq *sqlite3GetCollSeq(Parse*, u8, CollSeq *, const char*);
char sqlite3AffinityType(const char*, u8*);
void sqlite3Analyze(Parse*, Token*, Token*);
void sqlite3AnalyzeDatabase(Parse*,int,int);
int sqlite3InvokeBusyHandler(BusyHandler*);
int sqlite3FindDb(sqlite3*, Token*);
int sqlite3FindDbName(sqlite3 *, const char *);
int sqlite3AnalysisLoad(sqlite3*,int iDB);
void sqlite3DeleteIndexSamples(sqlite3*,Index*);
void sqlite3DefaultRowEst(Index*);
void sqlite3RegisterLikeFunctions(sqlite3*, int);

    flags = BTREE_BLOBKEY;
  }
  rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, flags);
  if( rc ) goto abort_due_to_error;
  pOut->u.i = pgno;
  break;
}











/* Opcode: ParseSchema P1 * * P4 *
**
** Read and parse all entries from the SQLITE_MASTER table of database P1
** that match the WHERE clause P4. 
**
** This opcode invokes the parser to create a new virtual machine,