| /* |
| ** 2005 July 8 |
| ** |
| ** The author disclaims copyright to this source code. In place of |
| ** a legal notice, here is a blessing: |
| ** |
| ** May you do good and not evil. |
| ** May you find forgiveness for yourself and forgive others. |
| ** May you share freely, never taking more than you give. |
| ** |
| ************************************************************************* |
| ** This file contains code associated with the ANALYZE command. |
| */ |
| #ifndef SQLITE_OMIT_ANALYZE |
| #include "sqliteInt.h" |
| |
| /* |
| ** This routine generates code that opens the sqlite_stat1 table for |
| ** writing with cursor iStatCur. If the library was built with the |
| ** SQLITE_ENABLE_STAT2 macro defined, then the sqlite_stat2 table is |
| ** opened for writing using cursor (iStatCur+1) |
| ** |
| ** If the sqlite_stat1 tables does not previously exist, it is created. |
| ** Similarly, if the sqlite_stat2 table does not exist and the library |
| ** is compiled with SQLITE_ENABLE_STAT2 defined, it is created. |
| ** |
| ** Argument zWhere may be a pointer to a buffer containing a table name, |
| ** or it may be a NULL pointer. If it is not NULL, then all entries in |
| ** the sqlite_stat1 and (if applicable) sqlite_stat2 tables associated |
| ** with the named table are deleted. If zWhere==0, then code is generated |
| ** to delete all stat table entries. |
| */ |
| static void openStatTable( |
| Parse *pParse, /* Parsing context */ |
| int iDb, /* The database we are looking in */ |
| int iStatCur, /* Open the sqlite_stat1 table on this cursor */ |
| const char *zWhere, /* Delete entries for this table or index */ |
| const char *zWhereType /* Either "tbl" or "idx" */ |
| ){ |
| static const struct { |
| const char *zName; |
| const char *zCols; |
| } aTable[] = { |
| { "sqlite_stat1", "tbl,idx,stat" }, |
| #ifdef SQLITE_ENABLE_STAT2 |
| { "sqlite_stat2", "tbl,idx,sampleno,sample" }, |
| #endif |
| }; |
| |
| int aRoot[] = {0, 0}; |
| u8 aCreateTbl[] = {0, 0}; |
| |
| int i; |
| sqlite3 *db = pParse->db; |
| Db *pDb; |
| Vdbe *v = sqlite3GetVdbe(pParse); |
| if( v==0 ) return; |
| assert( sqlite3BtreeHoldsAllMutexes(db) ); |
| assert( sqlite3VdbeDb(v)==db ); |
| pDb = &db->aDb[iDb]; |
| |
| for(i=0; i<ArraySize(aTable); i++){ |
| const char *zTab = aTable[i].zName; |
| Table *pStat; |
| if( (pStat = sqlite3FindTable(db, zTab, pDb->zName))==0 ){ |
| /* The sqlite_stat[12] table does not exist. Create it. Note that a |
| ** side-effect of the CREATE TABLE statement is to leave the rootpage |
| ** of the new table in register pParse->regRoot. This is important |
| ** because the OpenWrite opcode below will be needing it. */ |
| sqlite3NestedParse(pParse, |
| "CREATE TABLE %Q.%s(%s)", pDb->zName, zTab, aTable[i].zCols |
| ); |
| aRoot[i] = pParse->regRoot; |
| aCreateTbl[i] = 1; |
| }else{ |
| /* The table already exists. If zWhere is not NULL, delete all entries |
| ** associated with the table zWhere. If zWhere is NULL, delete the |
| ** entire contents of the table. */ |
| aRoot[i] = pStat->tnum; |
| sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab); |
| if( zWhere ){ |
| sqlite3NestedParse(pParse, |
| "DELETE FROM %Q.%s WHERE %s=%Q", pDb->zName, zTab, zWhereType, zWhere |
| ); |
| }else{ |
| /* The sqlite_stat[12] table already exists. Delete all rows. */ |
| sqlite3VdbeAddOp2(v, OP_Clear, aRoot[i], iDb); |
| } |
| } |
| } |
| |
| /* Open the sqlite_stat[12] tables for writing. */ |
| for(i=0; i<ArraySize(aTable); i++){ |
| sqlite3VdbeAddOp3(v, OP_OpenWrite, iStatCur+i, aRoot[i], iDb); |
| sqlite3VdbeChangeP4(v, -1, (char *)3, P4_INT32); |
| sqlite3VdbeChangeP5(v, aCreateTbl[i]); |
| } |
| } |
| |
| /* |
| ** Generate code to do an analysis of all indices associated with |
| ** a single table. |
| */ |
| 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 */ |
| ){ |
| sqlite3 *db = pParse->db; /* Database handle */ |
| Index *pIdx; /* An index to being analyzed */ |
| int iIdxCur; /* Cursor open on index being analyzed */ |
| Vdbe *v; /* The virtual machine being built up */ |
| int i; /* Loop counter */ |
| int topOfLoop; /* The top of the loop */ |
| int endOfLoop; /* The end of the loop */ |
| int jZeroRows = -1; /* Jump from here if number of rows is zero */ |
| int iDb; /* Index of database containing pTab */ |
| int regTabname = iMem++; /* Register containing table name */ |
| int regIdxname = iMem++; /* Register containing index name */ |
| int regSampleno = iMem++; /* Register containing next sample number */ |
| int regCol = iMem++; /* Content of a column analyzed table */ |
| int regRec = iMem++; /* Register holding completed record */ |
| int regTemp = iMem++; /* Temporary use register */ |
| int regRowid = iMem++; /* Rowid for the inserted record */ |
| |
| #ifdef SQLITE_ENABLE_STAT2 |
| int addr = 0; /* Instruction address */ |
| int regTemp2 = iMem++; /* Temporary use register */ |
| int regSamplerecno = iMem++; /* Index of next sample to record */ |
| int regRecno = iMem++; /* Current sample index */ |
| int regLast = iMem++; /* Index of last sample to record */ |
| int regFirst = iMem++; /* Index of first sample to record */ |
| #endif |
| |
| v = sqlite3GetVdbe(pParse); |
| if( v==0 || NEVER(pTab==0) ){ |
| return; |
| } |
| if( pTab->tnum==0 ){ |
| /* Do not gather statistics on views or virtual tables */ |
| return; |
| } |
| if( memcmp(pTab->zName, "sqlite_", 7)==0 ){ |
| /* Do not gather statistics on system tables */ |
| return; |
| } |
| assert( sqlite3BtreeHoldsAllMutexes(db) ); |
| iDb = sqlite3SchemaToIndex(db, pTab->pSchema); |
| assert( iDb>=0 ); |
| assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); |
| #ifndef SQLITE_OMIT_AUTHORIZATION |
| if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0, |
| db->aDb[iDb].zName ) ){ |
| return; |
| } |
| #endif |
| |
| /* Establish a read-lock on the table at the shared-cache level. */ |
| sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); |
| |
| iIdxCur = pParse->nTab++; |
| sqlite3VdbeAddOp4(v, OP_String8, 0, regTabname, 0, pTab->zName, 0); |
| for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ |
| int nCol; |
| KeyInfo *pKey; |
| |
| if( pOnlyIdx && pOnlyIdx!=pIdx ) continue; |
| nCol = pIdx->nColumn; |
| pKey = sqlite3IndexKeyinfo(pParse, pIdx); |
| if( iMem+1+(nCol*2)>pParse->nMem ){ |
| pParse->nMem = iMem+1+(nCol*2); |
| } |
| |
| /* Open a cursor to the index to be analyzed. */ |
| assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) ); |
| sqlite3VdbeAddOp4(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb, |
| (char *)pKey, P4_KEYINFO_HANDOFF); |
| VdbeComment((v, "%s", pIdx->zName)); |
| |
| /* Populate the register containing the index name. */ |
| sqlite3VdbeAddOp4(v, OP_String8, 0, regIdxname, 0, pIdx->zName, 0); |
| |
| #ifdef SQLITE_ENABLE_STAT2 |
| |
| /* If this iteration of the loop is generating code to analyze the |
| ** first index in the pTab->pIndex list, then register regLast has |
| ** not been populated. In this case populate it now. */ |
| if( pTab->pIndex==pIdx ){ |
| sqlite3VdbeAddOp2(v, OP_Integer, SQLITE_INDEX_SAMPLES, regSamplerecno); |
| sqlite3VdbeAddOp2(v, OP_Integer, SQLITE_INDEX_SAMPLES*2-1, regTemp); |
| sqlite3VdbeAddOp2(v, OP_Integer, SQLITE_INDEX_SAMPLES*2, regTemp2); |
| |
| sqlite3VdbeAddOp2(v, OP_Count, iIdxCur, regLast); |
| sqlite3VdbeAddOp2(v, OP_Null, 0, regFirst); |
| addr = sqlite3VdbeAddOp3(v, OP_Lt, regSamplerecno, 0, regLast); |
| sqlite3VdbeAddOp3(v, OP_Divide, regTemp2, regLast, regFirst); |
| sqlite3VdbeAddOp3(v, OP_Multiply, regLast, regTemp, regLast); |
| sqlite3VdbeAddOp2(v, OP_AddImm, regLast, SQLITE_INDEX_SAMPLES*2-2); |
| sqlite3VdbeAddOp3(v, OP_Divide, regTemp2, regLast, regLast); |
| sqlite3VdbeJumpHere(v, addr); |
| } |
| |
| /* Zero the regSampleno and regRecno registers. */ |
| sqlite3VdbeAddOp2(v, OP_Integer, 0, regSampleno); |
| sqlite3VdbeAddOp2(v, OP_Integer, 0, regRecno); |
| sqlite3VdbeAddOp2(v, OP_Copy, regFirst, regSamplerecno); |
| #endif |
| |
| /* The block of memory cells initialized here is used as follows. |
| ** |
| ** iMem: |
| ** The total number of rows in the table. |
| ** |
| ** iMem+1 .. iMem+nCol: |
| ** Number of distinct entries in index considering the |
| ** left-most N columns only, where N is between 1 and nCol, |
| ** inclusive. |
| ** |
| ** iMem+nCol+1 .. Mem+2*nCol: |
| ** Previous value of indexed columns, from left to right. |
| ** |
| ** Cells iMem through iMem+nCol are initialized to 0. The others are |
| ** initialized to contain an SQL NULL. |
| */ |
| for(i=0; i<=nCol; i++){ |
| sqlite3VdbeAddOp2(v, OP_Integer, 0, iMem+i); |
| } |
| for(i=0; i<nCol; i++){ |
| sqlite3VdbeAddOp2(v, OP_Null, 0, iMem+nCol+i+1); |
| } |
| |
| /* Start the analysis loop. This loop runs through all the entries in |
| ** the index b-tree. */ |
| endOfLoop = sqlite3VdbeMakeLabel(v); |
| sqlite3VdbeAddOp2(v, OP_Rewind, iIdxCur, endOfLoop); |
| topOfLoop = sqlite3VdbeCurrentAddr(v); |
| sqlite3VdbeAddOp2(v, OP_AddImm, iMem, 1); |
| |
| for(i=0; i<nCol; i++){ |
| CollSeq *pColl; |
| sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, regCol); |
| if( i==0 ){ |
| #ifdef SQLITE_ENABLE_STAT2 |
| /* Check if the record that cursor iIdxCur points to contains a |
| ** value that should be stored in the sqlite_stat2 table. If so, |
| ** store it. */ |
| int ne = sqlite3VdbeAddOp3(v, OP_Ne, regRecno, 0, regSamplerecno); |
| assert( regTabname+1==regIdxname |
| && regTabname+2==regSampleno |
| && regTabname+3==regCol |
| ); |
| sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL); |
| sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 4, regRec, "aaab", 0); |
| sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur+1, regRowid); |
| sqlite3VdbeAddOp3(v, OP_Insert, iStatCur+1, regRec, regRowid); |
| |
| /* Calculate new values for regSamplerecno and regSampleno. |
| ** |
| ** sampleno = sampleno + 1 |
| ** samplerecno = samplerecno+(remaining records)/(remaining samples) |
| */ |
| sqlite3VdbeAddOp2(v, OP_AddImm, regSampleno, 1); |
| sqlite3VdbeAddOp3(v, OP_Subtract, regRecno, regLast, regTemp); |
| sqlite3VdbeAddOp2(v, OP_AddImm, regTemp, -1); |
| sqlite3VdbeAddOp2(v, OP_Integer, SQLITE_INDEX_SAMPLES, regTemp2); |
| sqlite3VdbeAddOp3(v, OP_Subtract, regSampleno, regTemp2, regTemp2); |
| sqlite3VdbeAddOp3(v, OP_Divide, regTemp2, regTemp, regTemp); |
| sqlite3VdbeAddOp3(v, OP_Add, regSamplerecno, regTemp, regSamplerecno); |
| |
| sqlite3VdbeJumpHere(v, ne); |
| sqlite3VdbeAddOp2(v, OP_AddImm, regRecno, 1); |
| #endif |
| |
| /* Always record the very first row */ |
| sqlite3VdbeAddOp1(v, OP_IfNot, iMem+1); |
| } |
| assert( pIdx->azColl!=0 ); |
| assert( pIdx->azColl[i]!=0 ); |
| pColl = sqlite3LocateCollSeq(pParse, pIdx->azColl[i]); |
| sqlite3VdbeAddOp4(v, OP_Ne, regCol, 0, iMem+nCol+i+1, |
| (char*)pColl, P4_COLLSEQ); |
| sqlite3VdbeChangeP5(v, SQLITE_NULLEQ); |
| } |
| if( db->mallocFailed ){ |
| /* If a malloc failure has occurred, then the result of the expression |
| ** passed as the second argument to the call to sqlite3VdbeJumpHere() |
| ** below may be negative. Which causes an assert() to fail (or an |
| ** out-of-bounds write if SQLITE_DEBUG is not defined). */ |
| return; |
| } |
| sqlite3VdbeAddOp2(v, OP_Goto, 0, endOfLoop); |
| for(i=0; i<nCol; i++){ |
| int addr2 = sqlite3VdbeCurrentAddr(v) - (nCol*2); |
| if( i==0 ){ |
| sqlite3VdbeJumpHere(v, addr2-1); /* Set jump dest for the OP_IfNot */ |
| } |
| sqlite3VdbeJumpHere(v, addr2); /* Set jump dest for the OP_Ne */ |
| sqlite3VdbeAddOp2(v, OP_AddImm, iMem+i+1, 1); |
| sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, iMem+nCol+i+1); |
| } |
| |
| /* End of the analysis loop. */ |
| sqlite3VdbeResolveLabel(v, endOfLoop); |
| sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, topOfLoop); |
| sqlite3VdbeAddOp1(v, OP_Close, iIdxCur); |
| |
| /* Store the results in sqlite_stat1. |
| ** |
| ** The result is a single row of the sqlite_stat1 table. The first |
| ** two columns are the names of the table and index. The third column |
| ** is a string composed of a list of integer statistics about the |
| ** index. The first integer in the list is the total number of entries |
| ** in the index. There is one additional integer in the list for each |
| ** column of the table. This additional integer is a guess of how many |
| ** rows of the table the index will select. If D is the count of distinct |
| ** values and K is the total number of rows, then the integer is computed |
| ** as: |
| ** |
| ** I = (K+D-1)/D |
| ** |
| ** If K==0 then no entry is made into the sqlite_stat1 table. |
| ** If K>0 then it is always the case the D>0 so division by zero |
| ** is never possible. |
| */ |
| sqlite3VdbeAddOp2(v, OP_SCopy, iMem, regSampleno); |
| if( jZeroRows<0 ){ |
| jZeroRows = sqlite3VdbeAddOp1(v, OP_IfNot, iMem); |
| } |
| for(i=0; i<nCol; i++){ |
| sqlite3VdbeAddOp4(v, OP_String8, 0, regTemp, 0, " ", 0); |
| sqlite3VdbeAddOp3(v, OP_Concat, regTemp, regSampleno, regSampleno); |
| sqlite3VdbeAddOp3(v, OP_Add, iMem, iMem+i+1, regTemp); |
| sqlite3VdbeAddOp2(v, OP_AddImm, regTemp, -1); |
| sqlite3VdbeAddOp3(v, OP_Divide, iMem+i+1, regTemp, regTemp); |
| sqlite3VdbeAddOp1(v, OP_ToInt, regTemp); |
| sqlite3VdbeAddOp3(v, OP_Concat, regTemp, regSampleno, regSampleno); |
| } |
| sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regRec, "aaa", 0); |
| sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regRowid); |
| sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regRec, regRowid); |
| sqlite3VdbeChangeP5(v, OPFLAG_APPEND); |
| } |
| |
| /* If the table has no indices, create a single sqlite_stat1 entry |
| ** containing NULL as the index name and the row count as the content. |
| */ |
| if( pTab->pIndex==0 ){ |
| sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pTab->tnum, iDb); |
| VdbeComment((v, "%s", pTab->zName)); |
| sqlite3VdbeAddOp2(v, OP_Count, iIdxCur, regSampleno); |
| sqlite3VdbeAddOp1(v, OP_Close, iIdxCur); |
| jZeroRows = sqlite3VdbeAddOp1(v, OP_IfNot, regSampleno); |
| }else{ |
| sqlite3VdbeJumpHere(v, jZeroRows); |
| jZeroRows = sqlite3VdbeAddOp0(v, OP_Goto); |
| } |
| sqlite3VdbeAddOp2(v, OP_Null, 0, regIdxname); |
| sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regRec, "aaa", 0); |
| sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regRowid); |
| sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regRec, regRowid); |
| sqlite3VdbeChangeP5(v, OPFLAG_APPEND); |
| if( pParse->nMem<regRec ) pParse->nMem = regRec; |
| sqlite3VdbeJumpHere(v, jZeroRows); |
| } |
| |
| /* |
| ** Generate code that will cause the most recent index analysis to |
| ** be loaded into internal hash tables where is can be used. |
| */ |
| static void loadAnalysis(Parse *pParse, int iDb){ |
| Vdbe *v = sqlite3GetVdbe(pParse); |
| if( v ){ |
| sqlite3VdbeAddOp1(v, OP_LoadAnalysis, iDb); |
| } |
| } |
| |
| /* |
| ** Generate code that will do an analysis of an entire database |
| */ |
| static void analyzeDatabase(Parse *pParse, int iDb){ |
| sqlite3 *db = pParse->db; |
| Schema *pSchema = db->aDb[iDb].pSchema; /* Schema of database iDb */ |
| HashElem *k; |
| int iStatCur; |
| int iMem; |
| |
| sqlite3BeginWriteOperation(pParse, 0, iDb); |
| iStatCur = pParse->nTab; |
| pParse->nTab += 2; |
| openStatTable(pParse, iDb, iStatCur, 0, 0); |
| iMem = pParse->nMem+1; |
| assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); |
| for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){ |
| Table *pTab = (Table*)sqliteHashData(k); |
| analyzeOneTable(pParse, pTab, 0, iStatCur, iMem); |
| } |
| loadAnalysis(pParse, iDb); |
| } |
| |
| /* |
| ** 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; |
| |
| assert( pTab!=0 ); |
| assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); |
| iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); |
| sqlite3BeginWriteOperation(pParse, 0, iDb); |
| iStatCur = pParse->nTab; |
| pParse->nTab += 2; |
| 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); |
| loadAnalysis(pParse, iDb); |
| } |
| |
| /* |
| ** 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. |
| */ |
| void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){ |
| sqlite3 *db = pParse->db; |
| int iDb; |
| int i; |
| 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 */ |
| for(i=0; i<db->nDb; i++){ |
| if( i==1 ) continue; /* Do not analyze the TEMP database */ |
| analyzeDatabase(pParse, i); |
| } |
| }else if( pName2->n==0 ){ |
| /* Form 2: Analyze the database or table named */ |
| iDb = sqlite3FindDb(db, pName1); |
| if( iDb>=0 ){ |
| analyzeDatabase(pParse, iDb); |
| }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); |
| } |
| sqlite3DbFree(db, z); |
| } |
| } |
| }else{ |
| /* Form 3: Analyze the fully qualified table name */ |
| iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName); |
| if( iDb>=0 ){ |
| zDb = db->aDb[iDb].zName; |
| z = sqlite3NameFromToken(db, pTableName); |
| if( z ){ |
| if( (pIdx = sqlite3FindIndex(db, z, zDb))!=0 ){ |
| analyzeTable(pParse, pIdx->pTable, pIdx); |
| }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; |
| struct analysisInfo { |
| sqlite3 *db; |
| const char *zDatabase; |
| }; |
| |
| /* |
| ** This callback is invoked once for each index when reading the |
| ** sqlite_stat1 table. |
| ** |
| ** argv[0] = name of the table |
| ** argv[1] = name of the index (might be NULL) |
| ** argv[2] = results of analysis - on integer for each column |
| ** |
| ** Entries for which argv[1]==NULL simply record the number of rows in |
| ** the table. |
| */ |
| static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){ |
| analysisInfo *pInfo = (analysisInfo*)pData; |
| Index *pIndex; |
| Table *pTable; |
| int i, c, n; |
| unsigned int v; |
| const char *z; |
| |
| assert( argc==3 ); |
| UNUSED_PARAMETER2(NotUsed, argc); |
| |
| if( argv==0 || argv[0]==0 || argv[2]==0 ){ |
| return 0; |
| } |
| pTable = sqlite3FindTable(pInfo->db, argv[0], pInfo->zDatabase); |
| if( pTable==0 ){ |
| return 0; |
| } |
| if( argv[1] ){ |
| pIndex = sqlite3FindIndex(pInfo->db, argv[1], pInfo->zDatabase); |
| }else{ |
| pIndex = 0; |
| } |
| n = pIndex ? pIndex->nColumn : 0; |
| z = argv[2]; |
| for(i=0; *z && i<=n; i++){ |
| v = 0; |
| while( (c=z[0])>='0' && c<='9' ){ |
| v = v*10 + c - '0'; |
| z++; |
| } |
| if( i==0 ) pTable->nRowEst = v; |
| if( pIndex==0 ) break; |
| pIndex->aiRowEst[i] = v; |
| if( *z==' ' ) z++; |
| if( memcmp(z, "unordered", 10)==0 ){ |
| pIndex->bUnordered = 1; |
| break; |
| } |
| } |
| return 0; |
| } |
| |
| /* |
| ** If the Index.aSample variable is not NULL, delete the aSample[] array |
| ** and its contents. |
| */ |
| void sqlite3DeleteIndexSamples(sqlite3 *db, Index *pIdx){ |
| #ifdef SQLITE_ENABLE_STAT2 |
| if( pIdx->aSample ){ |
| int j; |
| for(j=0; j<SQLITE_INDEX_SAMPLES; j++){ |
| IndexSample *p = &pIdx->aSample[j]; |
| if( p->eType==SQLITE_TEXT || p->eType==SQLITE_BLOB ){ |
| sqlite3DbFree(db, p->u.z); |
| } |
| } |
| sqlite3DbFree(db, pIdx->aSample); |
| } |
| #else |
| UNUSED_PARAMETER(db); |
| UNUSED_PARAMETER(pIdx); |
| #endif |
| } |
| |
| /* |
| ** Load the content of the sqlite_stat1 and sqlite_stat2 tables. The |
| ** contents of sqlite_stat1 are used to populate the Index.aiRowEst[] |
| ** arrays. The contents of sqlite_stat2 are used to populate the |
| ** Index.aSample[] arrays. |
| ** |
| ** If the sqlite_stat1 table is not present in the database, SQLITE_ERROR |
| ** is returned. In this case, even if SQLITE_ENABLE_STAT2 was defined |
| ** during compilation and the sqlite_stat2 table is present, no data is |
| ** read from it. |
| ** |
| ** If SQLITE_ENABLE_STAT2 was defined during compilation and the |
| ** sqlite_stat2 table is not present in the database, SQLITE_ERROR is |
| ** returned. However, in this case, data is read from the sqlite_stat1 |
| ** table (if it is present) before returning. |
| ** |
| ** If an OOM error occurs, this function always sets db->mallocFailed. |
| ** This means if the caller does not care about other errors, the return |
| ** code may be ignored. |
| */ |
| int sqlite3AnalysisLoad(sqlite3 *db, int iDb){ |
| analysisInfo sInfo; |
| HashElem *i; |
| char *zSql; |
| int rc; |
| |
| assert( iDb>=0 && iDb<db->nDb ); |
| assert( db->aDb[iDb].pBt!=0 ); |
| |
| /* Clear any prior statistics */ |
| assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); |
| for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){ |
| Index *pIdx = sqliteHashData(i); |
| sqlite3DefaultRowEst(pIdx); |
| sqlite3DeleteIndexSamples(db, pIdx); |
| pIdx->aSample = 0; |
| } |
| |
| /* Check to make sure the sqlite_stat1 table exists */ |
| sInfo.db = db; |
| sInfo.zDatabase = db->aDb[iDb].zName; |
| if( sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)==0 ){ |
| return SQLITE_ERROR; |
| } |
| |
| /* Load new statistics out of the sqlite_stat1 table */ |
| zSql = sqlite3MPrintf(db, |
| "SELECT tbl, idx, stat FROM %Q.sqlite_stat1", sInfo.zDatabase); |
| if( zSql==0 ){ |
| rc = SQLITE_NOMEM; |
| }else{ |
| rc = sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0); |
| sqlite3DbFree(db, zSql); |
| } |
| |
| |
| /* Load the statistics from the sqlite_stat2 table. */ |
| #ifdef SQLITE_ENABLE_STAT2 |
| if( rc==SQLITE_OK && !sqlite3FindTable(db, "sqlite_stat2", sInfo.zDatabase) ){ |
| rc = SQLITE_ERROR; |
| } |
| if( rc==SQLITE_OK ){ |
| sqlite3_stmt *pStmt = 0; |
| |
| zSql = sqlite3MPrintf(db, |
| "SELECT idx,sampleno,sample FROM %Q.sqlite_stat2", sInfo.zDatabase); |
| if( !zSql ){ |
| rc = SQLITE_NOMEM; |
| }else{ |
| rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0); |
| sqlite3DbFree(db, zSql); |
| } |
| |
| if( rc==SQLITE_OK ){ |
| while( sqlite3_step(pStmt)==SQLITE_ROW ){ |
| char *zIndex; /* Index name */ |
| Index *pIdx; /* Pointer to the index object */ |
| |
| zIndex = (char *)sqlite3_column_text(pStmt, 0); |
| pIdx = zIndex ? sqlite3FindIndex(db, zIndex, sInfo.zDatabase) : 0; |
| if( pIdx ){ |
| int iSample = sqlite3_column_int(pStmt, 1); |
| if( iSample<SQLITE_INDEX_SAMPLES && iSample>=0 ){ |
| int eType = sqlite3_column_type(pStmt, 2); |
| |
| if( pIdx->aSample==0 ){ |
| static const int sz = sizeof(IndexSample)*SQLITE_INDEX_SAMPLES; |
| pIdx->aSample = (IndexSample *)sqlite3DbMallocRaw(0, sz); |
| if( pIdx->aSample==0 ){ |
| db->mallocFailed = 1; |
| break; |
| } |
| memset(pIdx->aSample, 0, sz); |
| } |
| |
| assert( pIdx->aSample ); |
| { |
| IndexSample *pSample = &pIdx->aSample[iSample]; |
| pSample->eType = (u8)eType; |
| if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){ |
| pSample->u.r = sqlite3_column_double(pStmt, 2); |
| }else if( eType==SQLITE_TEXT || eType==SQLITE_BLOB ){ |
| const char *z = (const char *)( |
| (eType==SQLITE_BLOB) ? |
| sqlite3_column_blob(pStmt, 2): |
| sqlite3_column_text(pStmt, 2) |
| ); |
| int n = sqlite3_column_bytes(pStmt, 2); |
| if( n>24 ){ |
| n = 24; |
| } |
| pSample->nByte = (u8)n; |
| if( n < 1){ |
| pSample->u.z = 0; |
| }else{ |
| pSample->u.z = sqlite3DbStrNDup(0, z, n); |
| if( pSample->u.z==0 ){ |
| db->mallocFailed = 1; |
| break; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| rc = sqlite3_finalize(pStmt); |
| } |
| } |
| #endif |
| |
| if( rc==SQLITE_NOMEM ){ |
| db->mallocFailed = 1; |
| } |
| return rc; |
| } |
| |
| |
| #endif /* SQLITE_OMIT_ANALYZE */ |