SQLite

** The zFilename argument is the filename pointer passed into the xOpen()
** method of a VFS implementation.  The zParam argument is the name of the
** query parameter we seek.  This routine returns the value of the zParam
** parameter if it exists.  If the parameter does not exist, this routine
** returns a NULL pointer.
*/
const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam){
  const Pager *pPager;
  const char *z;
  if( zFilename==0 || zParam==0 ) return 0;
  pPager = sqlite3PagerFromFilename(zFilename);
  assert( pPager!=0 );
  z = sqlite3PagerQueryParameters(pPager);
  while( z[0] ){
    int x = strcmp(z, zParam);
    z += sqlite3Strlen30(z) + 1;
    if( x==0 ) return z;
    z += sqlite3Strlen30(z) + 1;
  }
  return 0;
}

/*
** Return a boolean value for a query parameter.
*/

  const char *z = sqlite3_uri_parameter(zFilename, zParam);
  sqlite3_int64 v;
  if( z && sqlite3DecOrHexToI64(z, &v)==0 ){
    bDflt = v;
  }
  return bDflt;
}

/*
** Translate a filename that was handed to a VFS routine into the corresponding
** database, journal, or WAL file.
**
** It is an error to pass this routine a filename string that was not
** passed into the VFS from the SQLite core.  Doing so is similar to
** passing free() a pointer that was not obtained from malloc() - it is
** an error that we cannot easily detect but that will likely cause memory
** corruption.
*/
const char *sqlite3_filename_database(const char *zFilename){
  const Pager *pPager = sqlite3PagerFromFilename(zFilename);
  assert( pPager!=0 );
  return sqlite3PagerFilename(pPager, 0);
}
const char *sqlite3_filename_journal(const char *zFilename){
  const Pager *pPager = sqlite3PagerFromFilename(zFilename);
  assert( pPager!=0 );
  return sqlite3PagerJournalFilename(pPager);
}
const char *sqlite3_filename_wal(const char *zFilename){
  const Pager *pPager = sqlite3PagerFromFilename(zFilename);
  assert( pPager!=0 );
  return sqlite3PagerWalFilename(pPager);
}

/*
** Return the Btree pointer identified by zDbName.  Return NULL if not found.
*/
Btree *sqlite3DbNameToBtree(sqlite3 *db, const char *zDbName){
  int iDb = zDbName ? sqlite3FindDbName(db, zDbName) : 0;
  return iDb<0 ? 0 : db->aDb[iDb].pBt;

  i16 nReserve;               /* Number of unused bytes at end of each page */
  u32 vfsFlags;               /* Flags for sqlite3_vfs.xOpen() */
  u32 sectorSize;             /* Assumed sector size during rollback */
  int pageSize;               /* Number of bytes in a page */
  Pgno mxPgno;                /* Maximum allowed size of the database */
  i64 journalSizeLimit;       /* Size limit for persistent journal files */
  char *zFilename;            /* Name of the database file */
  char *zQueryParam;          /* URI query parameters on the filename */
  char *zJournal;             /* Name of the journal file */
  int (*xBusyHandler)(void*); /* Function to call when busy */
  void *pBusyHandlerArg;      /* Context argument for xBusyHandler */
  int aStat[4];               /* Total cache hits, misses, writes, spills */
#ifdef SQLITE_TEST
  int nRead;                  /* Database pages read */
#endif

  ** file name. The layout in memory is as follows:
  **
  **     Pager object                    (sizeof(Pager) bytes)
  **     PCache object                   (sqlite3PcacheSize() bytes)
  **     Database file handle            (pVfs->szOsFile bytes)
  **     Sub-journal file handle         (journalFileSize bytes)
  **     Main journal file handle        (journalFileSize bytes)
  **     Pointer back to self            (sizeof(*Pager) bytes)
  **     Database file name              (nPathname+1 bytes)
  **     URI query parameters            (nUriByte bytes)
  **     padding for 8-byte alignment
  **     Pointer back to self            (sizeof(*Pager) bytes)
  **     WAL filename                    (nPathname+4+1 bytes)
  **     padding for 8-byte alignment
  **     Pointer back to self            (sizeof(*Pager) bytes)
  **     Journal file name               (nPathname+8+1 bytes)
  */
  pPtr = (u8 *)sqlite3MallocZero(
    ROUND8(sizeof(*pPager)) +            /* Pager structure */
    ROUND8(pcacheSize) +                 /* PCache object */
    ROUND8(pVfs->szOsFile) +             /* The main db file */
    journalFileSize * 2 +                /* The two journal files */
    sizeof(Pager*) +                     /* Self-pointer for database */
    ROUND8(nPathname + 1 + nUriByte) +   /* database filename + query params */
    sizeof(Pager*) +                     /* Self-pointer for journal */
    ROUND8(nPathname + 8 + 2) +          /* zJournal */
#ifndef SQLITE_OMIT_WAL
    sizeof(Pager*) +                     /* Self-pointer for zWal */
    ROUND8(nPathname + 4 + 2) +          /* zWal */
#endif
    0
  );
  assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize)) );
  if( !pPtr ){
    sqlite3DbFree(0, zPathname);
    return SQLITE_NOMEM_BKPT;
  }

  pPager = (Pager*)pPtr;                  pPtr += ROUND8(sizeof(*pPager));
  pPager->pPCache = (PCache*)pPtr;        pPtr += ROUND8(pcacheSize);
  pPager->fd = (sqlite3_file*)pPtr;       pPtr += ROUND8(pVfs->szOsFile);
  pPager->sjfd = (sqlite3_file*)pPtr;     pPtr += journalFileSize;
  pPager->jfd =  (sqlite3_file*)pPtr;     pPtr += journalFileSize;

  assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );

  /* Fill in the Pager.zFilename and pPager.zQueryParam fields */
  assert( EIGHT_BYTE_ALIGNMENT(pPtr) );
  memcpy(pPtr, &pPager, sizeof(pPager));  pPtr += sizeof(pPager);
  pPager->zFilename = (char*)pPtr;
  if( nPathname==0 ) zPathname = "";
  memcpy(pPtr, zPathname, nPathname);
  pPager->zQueryParam = pPager->zFilename + nPathname + 1;
  if( zUri ) memcpy(pPager->zQueryParam, zUri, nUriByte);
  assert( nUriByte>=1 );
  assert( nUriByte >= nUri*3 + 1 );
  pPtr += ROUND8(nPathname + 1 + nUriByte);



#ifndef SQLITE_OMIT_WAL
  /* Fill in Pager.zWal */
  assert( EIGHT_BYTE_ALIGNMENT(pPtr) );
  memcpy(pPtr, &pPager, sizeof(pPager));  pPtr += sizeof(pPager);
  pPager->zWal = (char*)pPtr;
  memcpy(pPtr, zPathname, nPathname);
  memcpy(pPtr+nPathname, "-wal", 4);      pPtr += ROUND8(nPathname + 4 + 2);


#endif

  /* Fill in Pager.zJournal */
  assert( EIGHT_BYTE_ALIGNMENT(pPtr) );
  memcpy(pPtr, &pPager, sizeof(pPager));  pPtr += sizeof(pPager);
  pPager->zJournal = (char*)pPtr;
  memcpy(pPtr, zPathname, nPathname);
  memcpy(pPtr+nPathname, "-journal",8); /*pPtr += ROUND8(nPathname + 8 + 2);*/

  if( nPathname ) sqlite3DbFree(0, zPathname);
  pPager->pVfs = pVfs;
  pPager->vfsFlags = vfsFlags;

  /* Open the pager file.
  */
  if( zFilename && zFilename[0] ){
    int fout = 0;                    /* VFS flags returned by xOpen() */

            if( iDc&(SQLITE_IOCAP_ATOMIC|(ii>>8)) ){
              szPageDflt = ii;
            }
          }
        }
#endif
      }
      pPager->noLock = sqlite3_uri_boolean(pPager->zFilename, "nolock", 0);
      if( (iDc & SQLITE_IOCAP_IMMUTABLE)!=0
       || sqlite3_uri_boolean(pPager->zFilename, "immutable", 0) ){
          vfsFlags |= SQLITE_OPEN_READONLY;
          goto act_like_temp_file;
      }
    }
  }else{
    /* If a temporary file is requested, it is not opened immediately.
    ** In this case we accept the default page size and delay actually

** Except, if the pager is in-memory only, then return an empty string if
** nullIfMemDb is true.  This routine is called with nullIfMemDb==1 when
** used to report the filename to the user, for compatibility with legacy
** behavior.  But when the Btree needs to know the filename for matching to
** shared cache, it uses nullIfMemDb==0 so that in-memory databases can
** participate in shared-cache.
*/
const char *sqlite3PagerFilename(const Pager *pPager, int nullIfMemDb){
  return (nullIfMemDb && pPager->memDb) ? "" : pPager->zFilename;
}

/*
** Return the name of the Journal file or WAL file of the given pager.
*/
const char *sqlite3PagerJournalFilename(const Pager *pPager){
  assert( pPager!=0 );
  return pPager->zJournal;
}
#ifndef SQLITE_OMIT_WAL
const char *sqlite3PagerWalFilename(const Pager *pPager){
  assert( pPager!=0 );
  return pPager->zWal;
}
#endif /* SQLITE_OMIT_WAL */

/* Return a pointer to the URI query parameters associated with the
** pager.
**
** The query parameters are a sequence of strings pairs.  The first
** string of each pair is the key and the second string is the value.
** All strings are terminated by a single 0x00 byte.  The list is
** terminated by the first empty-string key.
*/
const char *sqlite3PagerQueryParameters(const Pager *pPager){
  assert( pPager!=0 );
  return pPager->zQueryParam;
}

/* If zFilename is a filename passed to the xOpen method of the VFS - 
** either the main database file, the WAL file, or the journal file - 
** then this routine returns a pointer to the Pager object associated
** with that file.
*/
const Pager *sqlite3PagerFromFilename(const char *zFilename){
  const Pager **pp = (const Pager**)zFilename;
  pp--;
  assert( (*pp)->zFilename==zFilename
       || (*pp)->zJournal==zFilename
       || (*pp)->zWal==zFilename );
  return *pp;
}

/*
** Return the VFS structure for the pager.
*/
sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){
  return pPager->pVfs;
}

      pPager->pWal = 0;
      pagerFixMaplimit(pPager);
      if( rc && !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
    }
  }
  return rc;
}



#ifdef SQLITE_ENABLE_SNAPSHOT
/*
** If this is a WAL database, obtain a snapshot handle for the snapshot
** currently open. Otherwise, return an error.
*/
int sqlite3PagerSnapshotGet(Pager *pPager, sqlite3_snapshot **ppSnapshot){

/* Functions used to query pager state and configuration. */
u8 sqlite3PagerIsreadonly(Pager*);
u32 sqlite3PagerDataVersion(Pager*);
#ifdef SQLITE_DEBUG
  int sqlite3PagerRefcount(Pager*);
#endif
int sqlite3PagerMemUsed(Pager*);
const char *sqlite3PagerFilename(const Pager*, int);
const char *sqlite3PagerWalFilename(const Pager*);
const char *sqlite3PagerJournalFilename(const Pager*);
const char *sqlite3PagerQueryParameters(const Pager*);
const Pager *sqlite3PagerFromFilename(const char*);
sqlite3_vfs *sqlite3PagerVfs(Pager*);
sqlite3_file *sqlite3PagerFile(Pager*);
sqlite3_file *sqlite3PagerJrnlFile(Pager*);
const char *sqlite3PagerJournalname(Pager*);
void *sqlite3PagerTempSpace(Pager*);
int sqlite3PagerIsMemdb(Pager*);
void sqlite3PagerCacheStat(Pager *, int, int, int *);

**
** See the [URI filename] documentation for additional information.
*/
const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam);
int sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault);
sqlite3_int64 sqlite3_uri_int64(const char*, const char*, sqlite3_int64);

/*
** CAPI3REF:  Translate filenames
**
** These routines are available to VFS implementations for translating
** filenames between the main database file, the journal file, and the
** WAL file.
**
** If F is the name of an sqlite database file, journal file, or WAL file
** then sqlite3_filename_database(F) returns the name of the corresponding
** database file.
**
** If F is the name of an sqlite database file, journal file, or WAL file
** then sqlite3_filename_journal(F) returns the name of the corresponding
** rollback journal file.
**
** If F is the name of an sqlite database file, journal file, or WAL file
** then sqlite3_filename_wal(F) returns the name of the corresponding
** WAL file.
**
** In all of the above, if F is not the name of a database, journal or WAL
** filename passed into the VFS from the SQLite core, then the result is
** undefined and is likely a memory access violation.
*/
const char *sqlite3_filename_database(const char*);
const char *sqlite3_filename_journal(const char*);
const char *sqlite3_filename_wal(const char*);


/*
** CAPI3REF: Error Codes And Messages
** METHOD: sqlite3
**
** ^If the most recent sqlite3_* API call associated with 
** [database connection] D failed, then the sqlite3_errcode(D) interface

void sqlite3AddNotNull(Parse*, int);
void sqlite3AddPrimaryKey(Parse*, ExprList*, int, int, int);
void sqlite3AddCheckConstraint(Parse*, Expr*);
void sqlite3AddDefaultValue(Parse*,Expr*,const char*,const char*);
void sqlite3AddCollateType(Parse*, Token*);
void sqlite3AddGenerated(Parse*,Expr*,Token*);
void sqlite3EndTable(Parse*,Token*,Token*,u8,Select*);



int sqlite3ParseUri(const char*,const char*,unsigned int*,
                    sqlite3_vfs**,char**,char **);
#ifdef SQLITE_HAS_CODEC
  int sqlite3CodecQueryParameters(sqlite3*,const char*,const char*);
#else
# define sqlite3CodecQueryParameters(A,B,C) 0
#endif