analyze.c
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:14k
源码类别:

数据库系统

开发平台:

C/C++

  1. /*
  2. ** 2005 July 8
  3. **
  4. ** The author disclaims copyright to this source code.  In place of
  5. ** a legal notice, here is a blessing:
  6. **
  7. **    May you do good and not evil.
  8. **    May you find forgiveness for yourself and forgive others.
  9. **    May you share freely, never taking more than you give.
  10. **
  11. *************************************************************************
  12. ** This file contains code associated with the ANALYZE command.
  13. **
  14. ** @(#) $Id: analyze.c,v 1.42 2008/03/25 09:47:35 danielk1977 Exp $
  15. */
  16. #ifndef SQLITE_OMIT_ANALYZE
  17. #include "sqliteInt.h"
  18. /*
  19. ** This routine generates code that opens the sqlite_stat1 table on cursor
  20. ** iStatCur.
  21. **
  22. ** If the sqlite_stat1 tables does not previously exist, it is created.
  23. ** If it does previously exist, all entires associated with table zWhere
  24. ** are removed.  If zWhere==0 then all entries are removed.
  25. */
  26. static void openStatTable(
  27.   Parse *pParse,          /* Parsing context */
  28.   int iDb,                /* The database we are looking in */
  29.   int iStatCur,           /* Open the sqlite_stat1 table on this cursor */
  30.   const char *zWhere      /* Delete entries associated with this table */
  31. ){
  32.   sqlite3 *db = pParse->db;
  33.   Db *pDb;
  34.   int iRootPage;
  35.   int createStat1 = 0;
  36.   Table *pStat;
  37.   Vdbe *v = sqlite3GetVdbe(pParse);
  38.   if( v==0 ) return;
  39.   assert( sqlite3BtreeHoldsAllMutexes(db) );
  40.   assert( sqlite3VdbeDb(v)==db );
  41.   pDb = &db->aDb[iDb];
  42.   if( (pStat = sqlite3FindTable(db, "sqlite_stat1", pDb->zName))==0 ){
  43.     /* The sqlite_stat1 tables does not exist.  Create it.  
  44.     ** Note that a side-effect of the CREATE TABLE statement is to leave
  45.     ** the rootpage of the new table in register pParse->regRoot.  This is
  46.     ** important because the OpenWrite opcode below will be needing it. */
  47.     sqlite3NestedParse(pParse,
  48.       "CREATE TABLE %Q.sqlite_stat1(tbl,idx,stat)",
  49.       pDb->zName
  50.     );
  51.     iRootPage = pParse->regRoot;
  52.     createStat1 = 1;  /* Cause rootpage to be taken from top of stack */
  53.   }else if( zWhere ){
  54.     /* The sqlite_stat1 table exists.  Delete all entries associated with
  55.     ** the table zWhere. */
  56.     sqlite3NestedParse(pParse,
  57.        "DELETE FROM %Q.sqlite_stat1 WHERE tbl=%Q",
  58.        pDb->zName, zWhere
  59.     );
  60.     iRootPage = pStat->tnum;
  61.   }else{
  62.     /* The sqlite_stat1 table already exists.  Delete all rows. */
  63.     iRootPage = pStat->tnum;
  64.     sqlite3VdbeAddOp2(v, OP_Clear, pStat->tnum, iDb);
  65.   }
  66.   /* Open the sqlite_stat1 table for writing. Unless it was created
  67.   ** by this vdbe program, lock it for writing at the shared-cache level. 
  68.   ** If this vdbe did create the sqlite_stat1 table, then it must have 
  69.   ** already obtained a schema-lock, making the write-lock redundant.
  70.   */
  71.   if( !createStat1 ){
  72.     sqlite3TableLock(pParse, iDb, iRootPage, 1, "sqlite_stat1");
  73.   }
  74.   sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, 3);
  75.   sqlite3VdbeAddOp3(v, OP_OpenWrite, iStatCur, iRootPage, iDb);
  76.   sqlite3VdbeChangeP5(v, createStat1);
  77. }
  78. /*
  79. ** Generate code to do an analysis of all indices associated with
  80. ** a single table.
  81. */
  82. static void analyzeOneTable(
  83.   Parse *pParse,   /* Parser context */
  84.   Table *pTab,     /* Table whose indices are to be analyzed */
  85.   int iStatCur,    /* Cursor that writes to the sqlite_stat1 table */
  86.   int iMem         /* Available memory locations begin here */
  87. ){
  88.   Index *pIdx;     /* An index to being analyzed */
  89.   int iIdxCur;     /* Cursor number for index being analyzed */
  90.   int nCol;        /* Number of columns in the index */
  91.   Vdbe *v;         /* The virtual machine being built up */
  92.   int i;           /* Loop counter */
  93.   int topOfLoop;   /* The top of the loop */
  94.   int endOfLoop;   /* The end of the loop */
  95.   int addr;        /* The address of an instruction */
  96.   int iDb;         /* Index of database containing pTab */
  97.   v = sqlite3GetVdbe(pParse);
  98.   if( v==0 || pTab==0 || pTab->pIndex==0 ){
  99.     /* Do no analysis for tables that have no indices */
  100.     return;
  101.   }
  102.   assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
  103.   iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
  104.   assert( iDb>=0 );
  105. #ifndef SQLITE_OMIT_AUTHORIZATION
  106.   if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
  107.       pParse->db->aDb[iDb].zName ) ){
  108.     return;
  109.   }
  110. #endif
  111.   /* Establish a read-lock on the table at the shared-cache level. */
  112.   sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
  113.   iIdxCur = pParse->nTab;
  114.   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
  115.     KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
  116.     int regFields;    /* Register block for building records */
  117.     int regRec;       /* Register holding completed record */
  118.     int regTemp;      /* Temporary use register */
  119.     int regCol;       /* Content of a column from the table being analyzed */
  120.     int regRowid;     /* Rowid for the inserted record */
  121.     int regF2;
  122.     /* Open a cursor to the index to be analyzed
  123.     */
  124.     assert( iDb==sqlite3SchemaToIndex(pParse->db, pIdx->pSchema) );
  125.     nCol = pIdx->nColumn;
  126.     sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, nCol+1);
  127.     sqlite3VdbeAddOp4(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb,
  128.         (char *)pKey, P4_KEYINFO_HANDOFF);
  129.     VdbeComment((v, "%s", pIdx->zName));
  130.     regFields = iMem+nCol*2;
  131.     regTemp = regRowid = regCol = regFields+3;
  132.     regRec = regCol+1;
  133.     if( regRec>pParse->nMem ){
  134.       pParse->nMem = regRec;
  135.     }
  136.     /* Memory cells are used as follows:
  137.     **
  138.     **    mem[iMem]:             The total number of rows in the table.
  139.     **    mem[iMem+1]:           Number of distinct values in column 1
  140.     **    ...
  141.     **    mem[iMem+nCol]:        Number of distinct values in column N
  142.     **    mem[iMem+nCol+1]       Last observed value of column 1
  143.     **    ...
  144.     **    mem[iMem+nCol+nCol]:   Last observed value of column N
  145.     **
  146.     ** Cells iMem through iMem+nCol are initialized to 0.  The others
  147.     ** are initialized to NULL.
  148.     */
  149.     for(i=0; i<=nCol; i++){
  150.       sqlite3VdbeAddOp2(v, OP_Integer, 0, iMem+i);
  151.     }
  152.     for(i=0; i<nCol; i++){
  153.       sqlite3VdbeAddOp2(v, OP_Null, 0, iMem+nCol+i+1);
  154.     }
  155.     /* Do the analysis.
  156.     */
  157.     endOfLoop = sqlite3VdbeMakeLabel(v);
  158.     sqlite3VdbeAddOp2(v, OP_Rewind, iIdxCur, endOfLoop);
  159.     topOfLoop = sqlite3VdbeCurrentAddr(v);
  160.     sqlite3VdbeAddOp2(v, OP_AddImm, iMem, 1);
  161.     for(i=0; i<nCol; i++){
  162.       sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, regCol);
  163.       sqlite3VdbeAddOp3(v, OP_Ne, regCol, 0, iMem+nCol+i+1);
  164.       /**** TODO:  add collating sequence *****/
  165.       sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);
  166.     }
  167.     sqlite3VdbeAddOp2(v, OP_Goto, 0, endOfLoop);
  168.     for(i=0; i<nCol; i++){
  169.       sqlite3VdbeJumpHere(v, topOfLoop + 2*(i + 1));
  170.       sqlite3VdbeAddOp2(v, OP_AddImm, iMem+i+1, 1);
  171.       sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, iMem+nCol+i+1);
  172.     }
  173.     sqlite3VdbeResolveLabel(v, endOfLoop);
  174.     sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, topOfLoop);
  175.     sqlite3VdbeAddOp1(v, OP_Close, iIdxCur);
  176.     /* Store the results.  
  177.     **
  178.     ** The result is a single row of the sqlite_stat1 table.  The first
  179.     ** two columns are the names of the table and index.  The third column
  180.     ** is a string composed of a list of integer statistics about the
  181.     ** index.  The first integer in the list is the total number of entires
  182.     ** in the index.  There is one additional integer in the list for each
  183.     ** column of the table.  This additional integer is a guess of how many
  184.     ** rows of the table the index will select.  If D is the count of distinct
  185.     ** values and K is the total number of rows, then the integer is computed
  186.     ** as:
  187.     **
  188.     **        I = (K+D-1)/D
  189.     **
  190.     ** If K==0 then no entry is made into the sqlite_stat1 table.  
  191.     ** If K>0 then it is always the case the D>0 so division by zero
  192.     ** is never possible.
  193.     */
  194.     addr = sqlite3VdbeAddOp1(v, OP_IfNot, iMem);
  195.     sqlite3VdbeAddOp4(v, OP_String8, 0, regFields, 0, pTab->zName, 0);
  196.     sqlite3VdbeAddOp4(v, OP_String8, 0, regFields+1, 0, pIdx->zName, 0);
  197.     regF2 = regFields+2;
  198.     sqlite3VdbeAddOp2(v, OP_SCopy, iMem, regF2);
  199.     for(i=0; i<nCol; i++){
  200.       sqlite3VdbeAddOp4(v, OP_String8, 0, regTemp, 0, " ", 0);
  201.       sqlite3VdbeAddOp3(v, OP_Concat, regTemp, regF2, regF2);
  202.       sqlite3VdbeAddOp3(v, OP_Add, iMem, iMem+i+1, regTemp);
  203.       sqlite3VdbeAddOp2(v, OP_AddImm, regTemp, -1);
  204.       sqlite3VdbeAddOp3(v, OP_Divide, iMem+i+1, regTemp, regTemp);
  205.       sqlite3VdbeAddOp1(v, OP_ToInt, regTemp);
  206.       sqlite3VdbeAddOp3(v, OP_Concat, regTemp, regF2, regF2);
  207.     }
  208.     sqlite3VdbeAddOp4(v, OP_MakeRecord, regFields, 3, regRec, "aaa", 0);
  209.     sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regRowid);
  210.     sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regRec, regRowid);
  211.     sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
  212.     sqlite3VdbeJumpHere(v, addr);
  213.   }
  214. }
  215. /*
  216. ** Generate code that will cause the most recent index analysis to
  217. ** be laoded into internal hash tables where is can be used.
  218. */
  219. static void loadAnalysis(Parse *pParse, int iDb){
  220.   Vdbe *v = sqlite3GetVdbe(pParse);
  221.   if( v ){
  222.     sqlite3VdbeAddOp1(v, OP_LoadAnalysis, iDb);
  223.   }
  224. }
  225. /*
  226. ** Generate code that will do an analysis of an entire database
  227. */
  228. static void analyzeDatabase(Parse *pParse, int iDb){
  229.   sqlite3 *db = pParse->db;
  230.   Schema *pSchema = db->aDb[iDb].pSchema;    /* Schema of database iDb */
  231.   HashElem *k;
  232.   int iStatCur;
  233.   int iMem;
  234.   sqlite3BeginWriteOperation(pParse, 0, iDb);
  235.   iStatCur = pParse->nTab++;
  236.   openStatTable(pParse, iDb, iStatCur, 0);
  237.   iMem = pParse->nMem+1;
  238.   for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){
  239.     Table *pTab = (Table*)sqliteHashData(k);
  240.     analyzeOneTable(pParse, pTab, iStatCur, iMem);
  241.   }
  242.   loadAnalysis(pParse, iDb);
  243. }
  244. /*
  245. ** Generate code that will do an analysis of a single table in
  246. ** a database.
  247. */
  248. static void analyzeTable(Parse *pParse, Table *pTab){
  249.   int iDb;
  250.   int iStatCur;
  251.   assert( pTab!=0 );
  252.   assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
  253.   iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
  254.   sqlite3BeginWriteOperation(pParse, 0, iDb);
  255.   iStatCur = pParse->nTab++;
  256.   openStatTable(pParse, iDb, iStatCur, pTab->zName);
  257.   analyzeOneTable(pParse, pTab, iStatCur, pParse->nMem+1);
  258.   loadAnalysis(pParse, iDb);
  259. }
  260. /*
  261. ** Generate code for the ANALYZE command.  The parser calls this routine
  262. ** when it recognizes an ANALYZE command.
  263. **
  264. **        ANALYZE                            -- 1
  265. **        ANALYZE  <database>                -- 2
  266. **        ANALYZE  ?<database>.?<tablename>  -- 3
  267. **
  268. ** Form 1 causes all indices in all attached databases to be analyzed.
  269. ** Form 2 analyzes all indices the single database named.
  270. ** Form 3 analyzes all indices associated with the named table.
  271. */
  272. void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){
  273.   sqlite3 *db = pParse->db;
  274.   int iDb;
  275.   int i;
  276.   char *z, *zDb;
  277.   Table *pTab;
  278.   Token *pTableName;
  279.   /* Read the database schema. If an error occurs, leave an error message
  280.   ** and code in pParse and return NULL. */
  281.   assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
  282.   if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
  283.     return;
  284.   }
  285.   if( pName1==0 ){
  286.     /* Form 1:  Analyze everything */
  287.     for(i=0; i<db->nDb; i++){
  288.       if( i==1 ) continue;  /* Do not analyze the TEMP database */
  289.       analyzeDatabase(pParse, i);
  290.     }
  291.   }else if( pName2==0 || pName2->n==0 ){
  292.     /* Form 2:  Analyze the database or table named */
  293.     iDb = sqlite3FindDb(db, pName1);
  294.     if( iDb>=0 ){
  295.       analyzeDatabase(pParse, iDb);
  296.     }else{
  297.       z = sqlite3NameFromToken(db, pName1);
  298.       if( z ){
  299.         pTab = sqlite3LocateTable(pParse, 0, z, 0);
  300.         sqlite3_free(z);
  301.         if( pTab ){
  302.           analyzeTable(pParse, pTab);
  303.         }
  304.       }
  305.     }
  306.   }else{
  307.     /* Form 3: Analyze the fully qualified table name */
  308.     iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
  309.     if( iDb>=0 ){
  310.       zDb = db->aDb[iDb].zName;
  311.       z = sqlite3NameFromToken(db, pTableName);
  312.       if( z ){
  313.         pTab = sqlite3LocateTable(pParse, 0, z, zDb);
  314.         sqlite3_free(z);
  315.         if( pTab ){
  316.           analyzeTable(pParse, pTab);
  317.         }
  318.       }
  319.     }   
  320.   }
  321. }
  322. /*
  323. ** Used to pass information from the analyzer reader through to the
  324. ** callback routine.
  325. */
  326. typedef struct analysisInfo analysisInfo;
  327. struct analysisInfo {
  328.   sqlite3 *db;
  329.   const char *zDatabase;
  330. };
  331. /*
  332. ** This callback is invoked once for each index when reading the
  333. ** sqlite_stat1 table.  
  334. **
  335. **     argv[0] = name of the index
  336. **     argv[1] = results of analysis - on integer for each column
  337. */
  338. static int analysisLoader(void *pData, int argc, char **argv, char **azNotUsed){
  339.   analysisInfo *pInfo = (analysisInfo*)pData;
  340.   Index *pIndex;
  341.   int i, c;
  342.   unsigned int v;
  343.   const char *z;
  344.   assert( argc==2 );
  345.   if( argv==0 || argv[0]==0 || argv[1]==0 ){
  346.     return 0;
  347.   }
  348.   pIndex = sqlite3FindIndex(pInfo->db, argv[0], pInfo->zDatabase);
  349.   if( pIndex==0 ){
  350.     return 0;
  351.   }
  352.   z = argv[1];
  353.   for(i=0; *z && i<=pIndex->nColumn; i++){
  354.     v = 0;
  355.     while( (c=z[0])>='0' && c<='9' ){
  356.       v = v*10 + c - '0';
  357.       z++;
  358.     }
  359.     pIndex->aiRowEst[i] = v;
  360.     if( *z==' ' ) z++;
  361.   }
  362.   return 0;
  363. }
  364. /*
  365. ** Load the content of the sqlite_stat1 table into the index hash tables.
  366. */
  367. int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
  368.   analysisInfo sInfo;
  369.   HashElem *i;
  370.   char *zSql;
  371.   int rc;
  372.   assert( iDb>=0 && iDb<db->nDb );
  373.   assert( db->aDb[iDb].pBt!=0 );
  374.   assert( sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
  375.   /* Clear any prior statistics */
  376.   for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
  377.     Index *pIdx = sqliteHashData(i);
  378.     sqlite3DefaultRowEst(pIdx);
  379.   }
  380.   /* Check to make sure the sqlite_stat1 table existss */
  381.   sInfo.db = db;
  382.   sInfo.zDatabase = db->aDb[iDb].zName;
  383.   if( sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)==0 ){
  384.      return SQLITE_ERROR;
  385.   }
  386.   /* Load new statistics out of the sqlite_stat1 table */
  387.   zSql = sqlite3MPrintf(db, "SELECT idx, stat FROM %Q.sqlite_stat1",
  388.                         sInfo.zDatabase);
  389.   (void)sqlite3SafetyOff(db);
  390.   rc = sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0);
  391.   (void)sqlite3SafetyOn(db);
  392.   sqlite3_free(zSql);
  393.   return rc;
  394. }
  395. #endif /* SQLITE_OMIT_ANALYZE */