SQLite: dbdata.c at [4eef562a00] (original) (raw)

`/* ** 2019-04-17 ** ** 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 an implementation of two eponymous virtual tables, ** "sqlite_dbdata" and "sqlite_dbptr". Both modules require that the ** "sqlite_dbpage" eponymous virtual table be available. ** ** SQLITE_DBDATA: ** sqlite_dbdata is used to extract data directly from a database b-tree ** page and its associated overflow pages, bypassing the b-tree layer. ** The table schema is equivalent to: ** ** CREATE TABLE sqlite_dbdata( ** pgno INTEGER, ** cell INTEGER, ** field INTEGER, ** value ANY, ** schema TEXT HIDDEN ** ); ** ** IMPORTANT: THE VIRTUAL TABLE SCHEMA ABOVE IS SUBJECT TO CHANGE. IN THE ** FUTURE NEW NON-HIDDEN COLUMNS MAY BE ADDED BETWEEN "value" AND ** "schema". ** ** Each page of the database is inspected. If it cannot be interpreted as ** a b-tree page, or if it is a b-tree page containing 0 entries, the ** sqlite_dbdata table contains no rows for that page. Otherwise, the ** table contains one row for each field in the record associated with ** each cell on the page. For intkey b-trees, the key value is stored in ** field -1. ** ** For example, for the database: ** ** CREATE TABLE t1(a, b); -- root page is page 2 ** INSERT INTO t1(rowid, a, b) VALUES(5, 'v', 'five'); ** INSERT INTO t1(rowid, a, b) VALUES(10, 'x', 'ten'); ** ** the sqlite_dbdata table contains, as well as from entries related to ** page 1, content equivalent to: ** ** INSERT INTO sqlite_dbdata(pgno, cell, field, value) VALUES ** (2, 0, -1, 5 ), ** (2, 0, 0, 'v' ), ** (2, 0, 1, 'five'), ** (2, 1, -1, 10 ), ** (2, 1, 0, 'x' ), ** (2, 1, 1, 'ten' ); ** ** If database corruption is encountered, this module does not report an ** error. Instead, it attempts to extract as much data as possible and ** ignores the corruption. ** ** SQLITE_DBPTR: ** The sqlite_dbptr table has the following schema: ** ** CREATE TABLE sqlite_dbptr( ** pgno INTEGER, ** child INTEGER, ** schema TEXT HIDDEN ** ); ** ** It contains one entry for each b-tree pointer between a parent and ** child page in the database. */ #if !defined(SQLITEINT_H) #include "sqlite3ext.h"

typedef unsigned char u8;

#endif SQLITE_EXTENSION_INIT1 #include <string.h> #include <assert.h>

#define DBDATA_PADDING_BYTES 100

typedef struct DbdataTable DbdataTable; typedef struct DbdataCursor DbdataCursor;

/* Cursor object / struct DbdataCursor { sqlite3_vtab_cursor base; / Base class. Must be first */ sqlite3_stmt pStmt; / For fetching database pages */

int iPgno; /* Current page number */ u8 aPage; / Buffer containing page / int nPage; / Size of aPage[] in bytes / int nCell; / Number of cells on aPage[] / int iCell; / Current cell number / int bOnePage; / True to stop after one page */ int szDb; sqlite3_int64 iRowid;

/* Only for the sqlite_dbdata table */ u8 pRec; / Buffer containing current record / int nRec; / Size of pRec[] in bytes / int nHdr; / Size of header in bytes / int iField; / Current field number */ u8 *pHdrPtr; u8 *pPtr;

sqlite3_int64 iIntkey; /* Integer key value */ };

/* Table object / struct DbdataTable { sqlite3_vtab base; / Base class. Must be first */ sqlite3 db; / The database connection */ sqlite3_stmt pStmt; / For fetching database pages / int bPtr; / True for sqlite3_dbptr table */ };

/* Column and schema definitions for sqlite_dbdata */ #define DBDATA_COLUMN_PGNO 0 #define DBDATA_COLUMN_CELL 1 #define DBDATA_COLUMN_FIELD 2 #define DBDATA_COLUMN_VALUE 3 #define DBDATA_COLUMN_SCHEMA 4 #define DBDATA_SCHEMA
"CREATE TABLE x("
" pgno INTEGER,"
" cell INTEGER,"
" field INTEGER,"
" value ANY,"
" schema TEXT HIDDEN"
")"

/* Column and schema definitions for sqlite_dbptr */ #define DBPTR_COLUMN_PGNO 0 #define DBPTR_COLUMN_CHILD 1 #define DBPTR_COLUMN_SCHEMA 2 #define DBPTR_SCHEMA
"CREATE TABLE x("
" pgno INTEGER,"
" child INTEGER,"
" schema TEXT HIDDEN"
")"

/* ** Connect to an sqlite_dbdata (pAux==0) or sqlite_dbptr (pAux!=0) virtual ** table. */ static int dbdataConnect( sqlite3 *db, void *pAux, int argc, const char constargv, sqlite3_vtab **ppVtab, char **pzErr ){ DbdataTable *pTab = 0; int rc = sqlite3_declare_vtab(db, pAux ? DBPTR_SCHEMA : DBDATA_SCHEMA);

if( rc==SQLITE_OK ){ pTab = (DbdataTable*)sqlite3_malloc64(sizeof(DbdataTable)); if( pTab==0 ){ rc = SQLITE_NOMEM; }else{ memset(pTab, 0, sizeof(DbdataTable)); pTab->db = db; pTab->bPtr = (pAux!=0); } }

ppVtab = (sqlite3_vtab)pTab; return rc; }

/* ** Disconnect from or destroy a sqlite_dbdata or sqlite_dbptr virtual table. */ static int dbdataDisconnect(sqlite3_vtab *pVtab){ DbdataTable pTab = (DbdataTable)pVtab; if( pTab ){ sqlite3_finalize(pTab->pStmt); sqlite3_free(pVtab); } return SQLITE_OK; }

/* ** This function interprets two types of constraints: ** ** schema=? ** pgno=? ** ** If neither are present, idxNum is set to 0. If schema=? is present, ** the 0x01 bit in idxNum is set. If pgno=? is present, the 0x02 bit ** in idxNum is set. ** ** If both parameters are present, schema is in position 0 and pgno in ** position 1. */ static int dbdataBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdx){ DbdataTable pTab = (DbdataTable)tab; int i; int iSchema = -1; int iPgno = -1; int colSchema = (pTab->bPtr ? DBPTR_COLUMN_SCHEMA : DBDATA_COLUMN_SCHEMA);

for(i=0; inConstraint; i++){ struct sqlite3_index_constraint *p = &pIdx->aConstraint[i]; if( p->op==SQLITE_INDEX_CONSTRAINT_EQ ){ if( p->iColumn==colSchema ){ if( p->usable==0 ) return SQLITE_CONSTRAINT; iSchema = i; } if( p->iColumn==DBDATA_COLUMN_PGNO && p->usable ){ iPgno = i; } } }

if( iSchema>=0 ){ pIdx->aConstraintUsage[iSchema].argvIndex = 1; pIdx->aConstraintUsage[iSchema].omit = 1; } if( iPgno>=0 ){ pIdx->aConstraintUsage[iPgno].argvIndex = 1 + (iSchema>=0); pIdx->aConstraintUsage[iPgno].omit = 1; pIdx->estimatedCost = 100; pIdx->estimatedRows = 50;

if( pTab->bPtr==0 && pIdx->nOrderBy && pIdx->aOrderBy[0].desc==0 ){
  int iCol = pIdx->aOrderBy[0].iColumn;
  if( pIdx->nOrderBy==1 ){
    pIdx->orderByConsumed = (iCol==0 || iCol==1);
  }else if( pIdx->nOrderBy==2 && pIdx->aOrderBy[1].desc==0 && iCol==0 ){
    pIdx->orderByConsumed = (pIdx->aOrderBy[1].iColumn==1);
  }
}

}else{ pIdx->estimatedCost = 100000000; pIdx->estimatedRows = 1000000000; } pIdx->idxNum = (iSchema>=0 ? 0x01 : 0x00) | (iPgno>=0 ? 0x02 : 0x00); return SQLITE_OK; }

/* ** Open a new sqlite_dbdata or sqlite_dbptr cursor. */ static int dbdataOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){ DbdataCursor *pCsr;

pCsr = (DbdataCursor*)sqlite3_malloc64(sizeof(DbdataCursor)); if( pCsr==0 ){ return SQLITE_NOMEM; }else{ memset(pCsr, 0, sizeof(DbdataCursor)); pCsr->base.pVtab = pVTab; }

*ppCursor = (sqlite3_vtab_cursor *)pCsr; return SQLITE_OK; }

/* ** Restore a cursor object to the state it was in when first allocated ** by dbdataOpen(). */ static void dbdataResetCursor(DbdataCursor *pCsr){ DbdataTable pTab = (DbdataTable)(pCsr->base.pVtab); if( pTab->pStmt==0 ){ pTab->pStmt = pCsr->pStmt; }else{ sqlite3_finalize(pCsr->pStmt); } pCsr->pStmt = 0; pCsr->iPgno = 1; pCsr->iCell = 0; pCsr->iField = 0; pCsr->bOnePage = 0; sqlite3_free(pCsr->aPage); sqlite3_free(pCsr->pRec); pCsr->pRec = 0; pCsr->aPage = 0; }

/* ** Close an sqlite_dbdata or sqlite_dbptr cursor. */ static int dbdataClose(sqlite3_vtab_cursor *pCursor){ DbdataCursor pCsr = (DbdataCursor)pCursor; dbdataResetCursor(pCsr); sqlite3_free(pCsr); return SQLITE_OK; }

/* ** Utility methods to decode 16 and 32-bit big-endian unsigned integers. */ static unsigned int get_uint16(unsigned char *a){ return (a[0]<<8)|a[1]; } static unsigned int get_uint32(unsigned char *a){ return ((unsigned int)a[0]<<24) | ((unsigned int)a[1]<<16) | ((unsigned int)a[2]<<8) | ((unsigned int)a[3]); }

/* ** Load page pgno from the database via the sqlite_dbpage virtual table. ** If successful, set (*ppPage) to point to a buffer containing the page ** data, (*pnPage) to the size of that buffer in bytes and return ** SQLITE_OK. In this case it is the responsibility of the caller to ** eventually free the buffer using sqlite3_free(). ** ** Or, if an error occurs, set both (*ppPage) and (*pnPage) to 0 and ** return an SQLite error code. */ static int dbdataLoadPage( DbdataCursor pCsr, / Cursor object / unsigned int pgno, / Page number of page to load */ u8 *ppPage, / OUT: pointer to page buffer */ int pnPage / OUT: Size of (*ppPage) in bytes */ ){ int rc2; int rc = SQLITE_OK; sqlite3_stmt *pStmt = pCsr->pStmt;

*ppPage = 0; *pnPage = 0; sqlite3_bind_int64(pStmt, 2, pgno); if( SQLITE_ROW==sqlite3_step(pStmt) ){ int nCopy = sqlite3_column_bytes(pStmt, 0); if( nCopy>0 ){ u8 pPage; pPage = (u8)sqlite3_malloc64(nCopy + DBDATA_PADDING_BYTES); if( pPage==0 ){ rc = SQLITE_NOMEM; }else{ const u8 *pCopy = sqlite3_column_blob(pStmt, 0); memcpy(pPage, pCopy, nCopy); memset(&pPage[nCopy], 0, DBDATA_PADDING_BYTES); } *ppPage = pPage; *pnPage = nCopy; } } rc2 = sqlite3_reset(pStmt); if( rc==SQLITE_OK ) rc = rc2;

return rc; }

/* ** Read a varint. Put the value in *pVal and return the number of bytes. */ static int dbdataGetVarint(const u8 *z, sqlite3_int64 *pVal){ sqlite3_uint64 u = 0; int i; for(i=0; i<8; i++){ u = (u<<7) + (z[i]&0x7f); if( (z[i]&0x80)==0 ){ *pVal = (sqlite3_int64)u; return i+1; } } u = (u<<8) + (z[i]&0xff); *pVal = (sqlite3_int64)u; return 9; }

/* ** Like dbdataGetVarint(), but set the output to 0 if it is less than 0 ** or greater than 0xFFFFFFFF. This can be used for all varints in an ** SQLite database except for key values in intkey tables. */ static int dbdataGetVarintU32(const u8 *z, sqlite3_int64 *pVal){ sqlite3_int64 val; int nRet = dbdataGetVarint(z, &val); if( val<0 || val>0xFFFFFFFF ) val = 0; *pVal = val; return nRet; }

/* ** Return the number of bytes of space used by an SQLite value of type ** eType. */ static int dbdataValueBytes(int eType){ switch( eType ){ case 0: case 8: case 9: case 10: case 11: return 0; case 1: return 1; case 2: return 2; case 3: return 3; case 4: return 4; case 5: return 6; case 6: case 7: return 8; default: if( eType>0 ){ return ((eType-12) / 2); } return 0; } }

/* ** Load a value of type eType from buffer pData and use it to set the ** result of context object pCtx. */ static void dbdataValue( sqlite3_context *pCtx, int eType, u8 *pData, int nData ){ if( eType>=0 && dbdataValueBytes(eType)<=nData ){ switch( eType ){ case 0: case 10: case 11: sqlite3_result_null(pCtx); break;

  case 8: 
    sqlite3_result_int(pCtx, 0);
    break;
  case 9:
    sqlite3_result_int(pCtx, 1);
    break;

  case 1: case 2: case 3: case 4: case 5: case 6: case 7: {
    sqlite3_uint64 v = (signed char)pData[0];
    pData++;
    switch( eType ){
      case 7:
      case 6:  v = (v<<16) + (pData[0]<<8) + pData[1];  pData += 2;
      case 5:  v = (v<<16) + (pData[0]<<8) + pData[1];  pData += 2;
      case 4:  v = (v<<8) + pData[0];  pData++;
      case 3:  v = (v<<8) + pData[0];  pData++;
      case 2:  v = (v<<8) + pData[0];  pData++;
    }

    if( eType==7 ){
      double r;
      memcpy(&r, &v, sizeof(r));
      sqlite3_result_double(pCtx, r);
    }else{
      sqlite3_result_int64(pCtx, (sqlite3_int64)v);
    }
    break;
  }

  default: {
    int n = ((eType-12) / 2);
    if( eType % 2 ){
      sqlite3_result_text(pCtx, (const char*)pData, n, SQLITE_TRANSIENT);
    }else{
      sqlite3_result_blob(pCtx, pData, n, SQLITE_TRANSIENT);
    }
  }
}

} }

/* ** Move an sqlite_dbdata or sqlite_dbptr cursor to the next entry. */ static int dbdataNext(sqlite3_vtab_cursor *pCursor){ DbdataCursor pCsr = (DbdataCursor)pCursor; DbdataTable pTab = (DbdataTable)pCursor->pVtab;

pCsr->iRowid++; while( 1 ){ int rc; int iOff = (pCsr->iPgno==1 ? 100 : 0); int bNextPage = 0;

if( pCsr->aPage==0 ){
  while( 1 ){
    if( pCsr->bOnePage==0 && pCsr->iPgno>pCsr->szDb ) return SQLITE_OK;
    rc = dbdataLoadPage(pCsr, pCsr->iPgno, &pCsr->aPage, &pCsr->nPage);
    if( rc!=SQLITE_OK ) return rc;
    if( pCsr->aPage ) break;
    pCsr->iPgno++;
  }
  pCsr->iCell = pTab->bPtr ? -2 : 0;
  pCsr->nCell = get_uint16(&pCsr->aPage[iOff+3]);
}

if( pTab->bPtr ){
  if( pCsr->aPage[iOff]!=0x02 && pCsr->aPage[iOff]!=0x05 ){
    pCsr->iCell = pCsr->nCell;
  }
  pCsr->iCell++;
  if( pCsr->iCell>=pCsr->nCell ){
    sqlite3_free(pCsr->aPage);
    pCsr->aPage = 0;
    if( pCsr->bOnePage ) return SQLITE_OK;
    pCsr->iPgno++;
  }else{
    return SQLITE_OK;
  }
}else{
  /* If there is no record loaded, load it now. */
  if( pCsr->pRec==0 ){
    int bHasRowid = 0;
    int nPointer = 0;
    sqlite3_int64 nPayload = 0;
    sqlite3_int64 nHdr = 0;
    int iHdr;
    int U, X;
    int nLocal;

    switch( pCsr->aPage[iOff] ){
      case 0x02:
        nPointer = 4;
        break;
      case 0x0a:
        break;
      case 0x0d:
        bHasRowid = 1;
        break;
      default:
        /* This is not a b-tree page with records on it. Continue. */
        pCsr->iCell = pCsr->nCell;
        break;
    }

    if( pCsr->iCell>=pCsr->nCell ){
      bNextPage = 1;
    }else{

      iOff += 8 + nPointer + pCsr->iCell*2;
      if( iOff>pCsr->nPage ){
        bNextPage = 1;
      }else{
        iOff = get_uint16(&pCsr->aPage[iOff]);
      }

      /* For an interior node cell, skip past the child-page number */
      iOff += nPointer;

      /* Load the "byte of payload including overflow" field */
      if( bNextPage || iOff>pCsr->nPage ){
        bNextPage = 1;
      }else{
        iOff += dbdataGetVarintU32(&pCsr->aPage[iOff], &nPayload);
      }

      /* If this is a leaf intkey cell, load the rowid */
      if( bHasRowid && !bNextPage && iOff<pCsr->nPage ){
        iOff += dbdataGetVarint(&pCsr->aPage[iOff], &pCsr->iIntkey);
      }

      /* Figure out how much data to read from the local page */
      U = pCsr->nPage;
      if( bHasRowid ){
        X = U-35;
      }else{
        X = ((U-12)*64/255)-23;
      }
      if( nPayload<=X ){
        nLocal = nPayload;
      }else{
        int M, K;
        M = ((U-12)*32/255)-23;
        K = M+((nPayload-M)%(U-4));
        if( K<=X ){
          nLocal = K;
        }else{
          nLocal = M;
        }
      }

      if( bNextPage || nLocal+iOff>pCsr->nPage ){
        bNextPage = 1;
      }else{

        /* Allocate space for payload. And a bit more to catch small buffer
        ** overruns caused by attempting to read a varint or similar from 
        ** near the end of a corrupt record.  */
        pCsr->pRec = (u8*)sqlite3_malloc64(nPayload+DBDATA_PADDING_BYTES);
        if( pCsr->pRec==0 ) return SQLITE_NOMEM;
        memset(pCsr->pRec, 0, nPayload+DBDATA_PADDING_BYTES);
        pCsr->nRec = nPayload;

        /* Load the nLocal bytes of payload */
        memcpy(pCsr->pRec, &pCsr->aPage[iOff], nLocal);
        iOff += nLocal;

        /* Load content from overflow pages */
        if( nPayload>nLocal ){
          sqlite3_int64 nRem = nPayload - nLocal;
          unsigned int pgnoOvfl = get_uint32(&pCsr->aPage[iOff]);
          while( nRem>0 ){
            u8 *aOvfl = 0;
            int nOvfl = 0;
            int nCopy;
            rc = dbdataLoadPage(pCsr, pgnoOvfl, &aOvfl, &nOvfl);
            assert( rc!=SQLITE_OK || aOvfl==0 || nOvfl==pCsr->nPage );
            if( rc!=SQLITE_OK ) return rc;
            if( aOvfl==0 ) break;

            nCopy = U-4;
            if( nCopy>nRem ) nCopy = nRem;
            memcpy(&pCsr->pRec[nPayload-nRem], &aOvfl[4], nCopy);
            nRem -= nCopy;

            pgnoOvfl = get_uint32(aOvfl);
            sqlite3_free(aOvfl);
          }
        }

        iHdr = dbdataGetVarintU32(pCsr->pRec, &nHdr);
        pCsr->nHdr = nHdr;
        pCsr->pHdrPtr = &pCsr->pRec[iHdr];
        pCsr->pPtr = &pCsr->pRec[pCsr->nHdr];
        pCsr->iField = (bHasRowid ? -1 : 0);
      }
    }
  }else{
    pCsr->iField++;
    if( pCsr->iField>0 ){
      sqlite3_int64 iType;
      if( pCsr->pHdrPtr>&pCsr->pRec[pCsr->nRec] ){
        bNextPage = 1;
      }else{
        pCsr->pHdrPtr += dbdataGetVarintU32(pCsr->pHdrPtr, &iType);
        pCsr->pPtr += dbdataValueBytes(iType);
      }
    }
  }

  if( bNextPage ){
    sqlite3_free(pCsr->aPage);
    sqlite3_free(pCsr->pRec);
    pCsr->aPage = 0;
    pCsr->pRec = 0;
    if( pCsr->bOnePage ) return SQLITE_OK;
    pCsr->iPgno++;
  }else{
    if( pCsr->iField<0 || pCsr->pHdrPtr<&pCsr->pRec[pCsr->nHdr] ){
      return SQLITE_OK;
    }

    /* Advance to the next cell. The next iteration of the loop will load
    ** the record and so on. */
    sqlite3_free(pCsr->pRec);
    pCsr->pRec = 0;
    pCsr->iCell++;
  }
}

}

assert( !"can't get here" ); return SQLITE_OK; }

/* ** Return true if the cursor is at EOF. */ static int dbdataEof(sqlite3_vtab_cursor *pCursor){ DbdataCursor pCsr = (DbdataCursor)pCursor; return pCsr->aPage==0; }

/* ** Determine the size in pages of database zSchema (where zSchema is ** "main", "temp" or the name of an attached database) and set ** pCsr->szDb accordingly. If successful, return SQLITE_OK. Otherwise, ** an SQLite error code. */ static int dbdataDbsize(DbdataCursor *pCsr, const char *zSchema){ DbdataTable pTab = (DbdataTable)pCsr->base.pVtab; char *zSql = 0; int rc, rc2; sqlite3_stmt *pStmt = 0;

zSql = sqlite3_mprintf("PRAGMA %Q.page_count", zSchema); if( zSql==0 ) return SQLITE_NOMEM; rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pStmt, 0); sqlite3_free(zSql); if( rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){ pCsr->szDb = sqlite3_column_int(pStmt, 0); } rc2 = sqlite3_finalize(pStmt); if( rc==SQLITE_OK ) rc = rc2; return rc; }

/* ** xFilter method for sqlite_dbdata and sqlite_dbptr. */ static int dbdataFilter( sqlite3_vtab_cursor *pCursor, int idxNum, const char *idxStr, int argc, sqlite3_value **argv ){ DbdataCursor pCsr = (DbdataCursor)pCursor; DbdataTable pTab = (DbdataTable)pCursor->pVtab; int rc = SQLITE_OK; const char *zSchema = "main";

dbdataResetCursor(pCsr); assert( pCsr->iPgno==1 ); if( idxNum & 0x01 ){ zSchema = (const char*)sqlite3_value_text(argv[0]); } if( idxNum & 0x02 ){ pCsr->iPgno = sqlite3_value_int(argv[(idxNum & 0x01)]); pCsr->bOnePage = 1; }else{ pCsr->nPage = dbdataDbsize(pCsr, zSchema); rc = dbdataDbsize(pCsr, zSchema); }

if( rc==SQLITE_OK ){ if( pTab->pStmt ){ pCsr->pStmt = pTab->pStmt; pTab->pStmt = 0; }else{ rc = sqlite3_prepare_v2(pTab->db, "SELECT data FROM sqlite_dbpage(?) WHERE pgno=?", -1, &pCsr->pStmt, 0 ); } } if( rc==SQLITE_OK ){ rc = sqlite3_bind_text(pCsr->pStmt, 1, zSchema, -1, SQLITE_TRANSIENT); }else{ pTab->base.zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pTab->db)); } if( rc==SQLITE_OK ){ rc = dbdataNext(pCursor); } return rc; }

/* ** Return a column for the sqlite_dbdata or sqlite_dbptr table. */ static int dbdataColumn( sqlite3_vtab_cursor *pCursor, sqlite3_context ctx, int i ){ DbdataCursor pCsr = (DbdataCursor)pCursor; DbdataTable pTab = (DbdataTable)pCursor->pVtab; if( pTab->bPtr ){ switch( i ){ case DBPTR_COLUMN_PGNO: sqlite3_result_int64(ctx, pCsr->iPgno); break; case DBPTR_COLUMN_CHILD: { int iOff = pCsr->iPgno==1 ? 100 : 0; if( pCsr->iCell<0 ){ iOff += 8; }else{ iOff += 12 + pCsr->iCell2; if( iOff>pCsr->nPage ) return SQLITE_OK; iOff = get_uint16(&pCsr->aPage[iOff]); } if( iOff<=pCsr->nPage ){ sqlite3_result_int64(ctx, get_uint32(&pCsr->aPage[iOff])); } break; } } }else{ switch( i ){ case DBDATA_COLUMN_PGNO: sqlite3_result_int64(ctx, pCsr->iPgno); break; case DBDATA_COLUMN_CELL: sqlite3_result_int(ctx, pCsr->iCell); break; case DBDATA_COLUMN_FIELD: sqlite3_result_int(ctx, pCsr->iField); break; case DBDATA_COLUMN_VALUE: { if( pCsr->iField<0 ){ sqlite3_result_int64(ctx, pCsr->iIntkey); }else{ sqlite3_int64 iType; dbdataGetVarintU32(pCsr->pHdrPtr, &iType); dbdataValue( ctx, iType, pCsr->pPtr, &pCsr->pRec[pCsr->nRec] - pCsr->pPtr ); } break; } } } return SQLITE_OK; }

/* ** Return the rowid for an sqlite_dbdata or sqlite_dptr table. */ static int dbdataRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){ DbdataCursor pCsr = (DbdataCursor)pCursor; *pRowid = pCsr->iRowid; return SQLITE_OK; }

/* ** Invoke this routine to register the "sqlite_dbdata" virtual table module */ static int sqlite3DbdataRegister(sqlite3 db){ static sqlite3_module dbdata_module = { 0, / iVersion / 0, / xCreate / dbdataConnect, / xConnect / dbdataBestIndex, / xBestIndex / dbdataDisconnect, / xDisconnect / 0, / xDestroy / dbdataOpen, / xOpen - open a cursor / dbdataClose, / xClose - close a cursor / dbdataFilter, / xFilter - configure scan constraints / dbdataNext, / xNext - advance a cursor / dbdataEof, / xEof - check for end of scan / dbdataColumn, / xColumn - read data / dbdataRowid, / xRowid - read data / 0, / xUpdate / 0, / xBegin / 0, / xSync / 0, / xCommit / 0, / xRollback / 0, / xFindMethod / 0, / xRename / 0, / xSavepoint / 0, / xRelease / 0, / xRollbackTo / 0 / xShadowName */ };

int rc = sqlite3_create_module(db, "sqlite_dbdata", &dbdata_module, 0); if( rc==SQLITE_OK ){ rc = sqlite3_create_module(db, "sqlite_dbptr", &dbdata_module, (void*)1); } return rc; }

#ifdef _WIN32 __declspec(dllexport) #endif int sqlite3_dbdata_init( sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi ){ SQLITE_EXTENSION_INIT2(pApi); return sqlite3DbdataRegister(db); } `