bump(version): 1.0.53

packages/client-app/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Nylas Mail Changelog
 
+### 1.0.53 (3/31/2017)
+
+  + [client-app] add  which doesn't use Transactions
+  + [client-app] rename DatabaseTransaction -> DatabaseWriter
+  + [client-app] use debug library for DB
+  + [cloud-api] Add awaits in thread metadata reconciliation test
+  + [client-sync] Add provider to syncbackTask perf metric
+  + [client-sync] Report metrics about SyncbackTask runs
+  + [client-app] Add script that benchmarks new commits
+  + [client-app] Add search support for has:attachment
+  + [client-sync] Convert syncback tasks to interruptible generators
+  + [client-sync] Interrupt long-running syncback tasks
+  + [client-app] Add silent flag to DB persists for thread indexing
+  + [client-app] Add better DB logging with ENABLE_SEQUELIZE_DEBUG_LOGGING
+
 ### 1.0.52 (3/29/2017)
 
 - Fixes:

packages/client-app/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nylas-mail",
   "productName": "Nylas Mail",
-  "version": "1.0.52",
+  "version": "1.0.53",
   "description": "The best email app for people and teams at work",
   "license": "GPL-3.0",
   "main": "./src/browser/main.js",

scripts-tmp/benchmark-initial-sync.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+
+set -e
+
+function print_help {
+  OUTPUT=$(cat <<- EOM
+
+    A script to benchmark the initial sync performance of Nylas Mail. To use,
+    simply run the script after authing whatever accounts you wish to measure
+    in your development version of Nylas Mail. The benchmarking script will
+    clear all of the data except for your accounts and open and close Nylas
+    Mail several times, printing out the number of messages synced after each
+    iteration.
+  )
+  echo "$OUTPUT"
+}
+
+if [[ $1 == '-h' || $1 == '--help' ]]
+then
+  print_help
+  exit 0
+fi
+
+# Run sudo to prime root privileges
+sudo ls > /dev/null
+
+CWD="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+NYLAS_DIR="$HOME/.nylas-dev"
+EDGEHILL_DB="$NYLAS_DIR/edgehill.db"
+TIME_LIMIT=120
+ITERS=5
+
+for i in `seq 1 $ITERS`
+do
+  bash $CWD/drop-data-except-accounts.sh > /dev/null
+
+  (npm start &> /dev/null &)
+
+  sleep $TIME_LIMIT
+
+  ELECTRON_PID=`ps aux | grep "Electron packages/client-app" | grep -v grep | awk '{print $2}'`
+  sudo kill -9 $ELECTRON_PID
+
+  MESSAGE_COUNT=`sqlite3 $EDGEHILL_DB 'SELECT COUNT(*) FROM Message'`
+  echo "Synced Messages: $MESSAGE_COUNT"
+
+  # Sometimes it takes a while to shutdown
+  while [[ $ELECTRON_PID != '' ]]
+  do
+    sleep 1
+    ELECTRON_PID=`ps aux | grep "Electron packages/client-app" | grep -v grep | awk '{print $2}'`
+  done
+done

scripts-tmp/benchmark-new-commits.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+set -e
+
+function get_next_commit() {
+  local LAST_COMMIT=$1
+  local NEXT_COMMIT=$(git log master ^$LAST_COMMIT --ancestry-path --pretty=oneline | cut -d" " -f1 | tail -n 1)
+  echo "$NEXT_COMMIT"
+}
+
+BENCHMARK_RESULTS_DIR="$HOME/.benchmark_results"
+mkdir -p $BENCHMARK_RESULTS_DIR
+
+CWD="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+LAST_COMMIT=$(cat $BENCHMARK_RESULTS_DIR/last_commit)
+NEXT_COMMIT=$(get_next_commit $LAST_COMMIT)
+
+git checkout -q master
+git pull -q --rebase
+
+while [[ $NEXT_COMMIT != '' ]]
+do
+  echo $NEXT_COMMIT
+  git checkout -q $NEXT_COMMIT
+  bash $CWD/benchmark-initial-sync.sh > "$BENCHMARK_RESULTS_DIR/$NEXT_COMMIT-results.txt"
+  echo "$NEXT_COMMIT" > "$BENCHMARK_RESULTS_DIR/last_commit"
+  NEXT_COMMIT=$(get_next_commit $NEXT_COMMIT)
+done

scripts-tmp/daily.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env babel-node
+const childProcess = require('child_process')
+const path = require('path')
+const mkdirp = require('mkdirp')
+const semver = require('semver')
+const program = require('commander')
+const pkg = require('../packages/client-app/package.json')
+
+const TMP_DIR = path.join(__dirname, '..', 'tmp')
+
+async function spawn(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const env = Object.assign({}, process.env, opts.env || {})
+    delete opts.env
+    const options = Object.assign({stdio: 'inherit', env}, opts);
+    const proc = childProcess.spawn(cmd, args, options)
+    proc.on("error", reject)
+    proc.on("exit", resolve)
+  })
+}
+
+function exec(cmd, opts = {}) {
+  return new Promise((resolve, reject) => {
+    childProcess.exec(cmd, opts, (err, stdout) => {
+      if (err) {
+        return reject(err)
+      }
+      return resolve(stdout)
+    })
+  })
+}
+
+function git(subCmd, opts = {}) {
+  const optsString = Object.keys(opts).reduce((prev, key) => {
+    const optVal = opts[key]
+    if (optVal == null) {
+      return key.length > 1 ? `${prev} --${key}` : `${prev} -${key}`
+    }
+    return key.length > 1 ? `${prev} --${key}=${optVal}` : `${prev} -${key} ${optVal}`
+  }, '')
+  return exec(`git ${subCmd} ${optsString}`, {cwd: './'})
+}
+
+async function prependToFile(filepath, string) {
+  await exec(`echo "${string}" > ${TMP_DIR}/tmpfile`)
+  await exec(`cat ${filepath} >> ${TMP_DIR}/tmpfile`)
+  await exec(`mv ${TMP_DIR}/tmpfile ${filepath}`)
+}
+
+async function sliceFileLines(filepath, idx) {
+  await exec(`tail -n +${1 + idx} ${filepath} > ${TMP_DIR}/tmpfile`)
+  await exec(`mv ${TMP_DIR}/tmpfile ${filepath}`)
+}
+
+async function updateChangelogFile(changelogString) {
+  mkdirp.sync(TMP_DIR)
+  await sliceFileLines('./packages/client-app/CHANGELOG.md', 2)
+  await prependToFile('./packages/client-app/CHANGELOG.md', changelogString)
+}
+
+function getFormattedLogs(mainLog) {
+  const formattedMainLog = (
+    mainLog
+    .filter(line => line.length > 0)
+    .filter(line => !/^bump/i.test(line) && !/changelog/i.test(line))
+    .map(line => `  + ${line.replace('*', '\\*')}`)
+    .join('\n')
+  )
+  return `${formattedMainLog}\n`
+}
+
+function getChangelogHeader(nextVersion) {
+  const date = new Date().toLocaleDateString()
+  return (
+    `# Nylas Mail Changelog
+
+### ${nextVersion} (${date})
+
+`
+  )
+}
+
+function validateArgs(args) {
+  if (args.editChangelog && !process.env.EDITOR) {
+    throw new Error(`You can't edit the changelog without a default EDITOR in your env`)
+  }
+}
+
+// TODO add progress indicators with ora
+// TODO add options
+// --update-daily-channel
+// --notify
+// --quiet
+async function main(args) {
+  const currentVersion = pkg.version
+  const nextVersion = semver.inc(currentVersion, 'patch')
+
+  validateArgs(args)
+
+  // Pull latest changes
+  try {
+    await git(`checkout master`)
+    await git(`pull --rebase`)
+  } catch (err) {
+    console.error(err)
+    process.exit(1)
+  }
+
+  // Make sure working directory is clean
+  try {
+    await exec('git diff --exit-code && git diff --cached --exit-code')
+  } catch (err) {
+    console.error('Git working directory is not clean!')
+    process.exit(1)
+  }
+
+  // Make sure there is a diff to build
+  let mainLog = '';
+  try {
+    mainLog = (await git(`log ${currentVersion}..master --format='%s'`)).split('\n')
+    if (mainLog.length <= 1) {
+      console.error(`There are no changes to build since ${currentVersion}`)
+      process.exit(1)
+    }
+  } catch (err) {
+    console.error(err)
+    process.exit(1)
+  }
+
+  // Update CHANGELOG
+  try {
+    const commitLogSinceLatestVersion = await getFormattedLogs(mainLog)
+    const changelogHeader = getChangelogHeader(nextVersion)
+    const changelogString = `${changelogHeader}${commitLogSinceLatestVersion}`
+    await updateChangelogFile(changelogString)
+    console.log(changelogString)
+  } catch (err) {
+    console.error('Could not update changelog file')
+    console.error(err)
+    process.exit(1)
+  }
+
+  // Allow editing
+  if (args.editChangelog) {
+    try {
+      await spawn(process.env.EDITOR, ['./packages/client-app/CHANGELOG.md'], {stdio: 'inherit'})
+    } catch (err) {
+      console.error('Error editing CHANGELOG.md')
+      console.error(err)
+      process.exit(1)
+    }
+  }
+
+  // Bump patch version in package.json
+  try {
+    await exec('npm --no-git-tag-version version patch', {cwd: 'packages/client-app'})
+  } catch (err) {
+    console.error('Could not bump version in package.json')
+    console.error(err)
+    process.exit(1)
+  }
+
+  if (args.noCommit) {
+    return
+  }
+
+  // Commit changes
+  try {
+    await git('add .')
+    await git(`commit -m 'bump(version): ${nextVersion}'`)
+  } catch (err) {
+    console.error('Could not commit changes')
+    console.error(err)
+    process.exit(1)
+  }
+
+  if (args.noTag) {
+    return
+  }
+
+  // Tag commit
+  try {
+    await git(`tag ${nextVersion}`)
+  } catch (err) {
+    console.error('Could not tag commit')
+    console.error(err)
+    process.exit(1)
+  }
+
+  if (args.noPush) {
+    return
+  }
+
+  // Push changes
+  try {
+    await git(`push origin master --tags`)
+  } catch (err) {
+    console.error('Could not tag commit')
+    console.error(err)
+    process.exit(1)
+  }
+
+  // Build locally. This should only be used when building from our in-office
+  // coffee machine mac mini
+  if (args.build) {
+    try {
+      await spawn('git', ['clean', '-xdf'])
+      await spawn('cp', ['-r', '../n1-keys-and-certificates', 'packages/client-app/build/resources/certs'])
+      await spawn('npm', ['install'], {env: {INSTALL_TARGET: 'client'}})
+      await spawn('npm', ['run', 'build-client'], {env: {SIGN_BUILD: true}})
+      await spawn('codesign', ['--verify', '--deep', '--verbose=2', '"packages/client-app/dist/Nylas Mail-darwin-x64/Nylas Mail.app"'])
+      await spawn('npm', ['run', 'upload-client'])
+    } catch (err) {
+      console.error('Errored while running build')
+      console.error(err)
+      process.exit(1)
+    }
+
+    // TODO Update `daily` channel
+
+    // TODO send out notification email
+  }
+
+  console.log('Done!')
+}
+
+program
+.version('0.0.1')
+.usage('[options]')
+.description('This script will bump the version in package.json, edit the changelog with the latest\n  git log (for easier editing), commit and tag the changes, and push to Github to trigger\n  a build')
+.option('--edit-changelog', 'Open your $EDITOR to edit CHANGELOG before commiting version bump.')
+.option('--no-commit', 'Wether to commit changes to CHANGELOG.md and package.json')
+.option('--no-tag', 'Wether to tag the version bump commit (no-op if --no-commit is used)')
+.option('--no-push', 'Wether to push changes to the Github remote')
+.option('--build', 'Wether to build the app locally. This should only be used when building from our in-office Mac Mini by the coffee machine')
+.parse(process.argv)
+
+main(program)

scripts-tmp/drop-data-except-accounts.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+
+set -e
+
+CWD="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+NYLAS_DIR="$HOME/.nylas-dev"
+TRUNCATE_TABLES="
+Account 
+AccountPluginMetadata 
+Calendar 
+Category 
+Contact 
+ContactSearch 
+Event 
+EventSearch 
+File 
+Message 
+MessageBody 
+MessagePluginMetadata 
+ProviderSyncbackRequest
+Thread 
+ThreadCategory 
+ThreadContact 
+ThreadCounts 
+ThreadPluginMetadata 
+ThreadSearch"
+SQLITE_DIR=$CWD/sqlite
+SQLITE_BIN=$SQLITE_DIR/sqlite3
+SQLITE_SRC_DIR="$SQLITE_DIR/sqlite-amalgamation-3170000"
+
+# Build the sqlite3 amalgamation if necessary because we need FTS5 support.
+if [[ ! -e "$SQLITE_BIN" ]]
+then
+  mkdir -p $SQLITE_DIR
+  curl -s "https://www.sqlite.org/2017/sqlite-amalgamation-3170000.zip" > "$SQLITE_DIR/sqlite-amalgamation.zip"
+  unzip -o -d $SQLITE_DIR "$SQLITE_DIR/sqlite-amalgamation.zip"
+  clang -DSQLITE_ENABLE_FTS5 "$SQLITE_SRC_DIR/sqlite3.c" "$SQLITE_SRC_DIR/shell.c" -o $SQLITE_BIN
+fi
+
+rm -f $NYLAS_DIR/a-*.sqlite
+
+EDGEHILL_DB=$NYLAS_DIR/edgehill.db
+
+for TABLE in $TRUNCATE_TABLES
+do
+  COMMAND="DELETE FROM $TABLE"
+  $SQLITE_BIN $EDGEHILL_DB "DELETE FROM $TABLE"
+done
+
+$SQLITE_BIN $EDGEHILL_DB 'DELETE FROM JSONBlob WHERE client_id != "NylasID"'

scripts-tmp/postinstall.es6

@@ -0,0 +1,187 @@
+import fs from 'fs-plus'
+import path from 'path'
+import childProcess from 'child_process'
+
+const TARGET_ALL = 'all'
+const TARGET_CLOUD = 'cloud'
+const TARGET_CLIENT = 'client'
+
+async function spawn(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const options = Object.assign({stdio: 'inherit'}, opts);
+    const proc = childProcess.spawn(cmd, args, options)
+    proc.on("error", reject)
+    proc.on("exit", resolve)
+  })
+}
+
+function unlinkIfExistsSync(p) {
+  try {
+    if (fs.lstatSync(p)) {
+      fs.removeSync(p);
+    }
+  } catch (err) {
+    return
+  }
+}
+
+function copyErrorLoggerExtensions(privateDir) {
+  const from = path.join(privateDir, 'src')
+  const to = path.resolve(path.join('packages', 'client-app', 'src'))
+  unlinkIfExistsSync(path.join(to, 'error-logger-extensions'));
+  fs.copySync(from, to);
+}
+
+async function installPrivateResources() {
+  console.log("\n---> Linking private plugins")
+  const privateDir = path.resolve(path.join('packages', 'client-private-plugins'))
+  if (!fs.existsSync(privateDir)) {
+    console.log("\n---> No client app to link. Moving on")
+    return;
+  }
+
+  copyErrorLoggerExtensions(privateDir)
+
+  // link private plugins
+  for (const plugin of fs.readdirSync(path.join(privateDir, 'packages'))) {
+    const from = path.resolve(path.join(privateDir, 'packages', plugin));
+    const to = path.resolve(path.join('packages', 'client-app', 'internal_packages', plugin));
+    unlinkIfExistsSync(to);
+    fs.symlinkSync(from, to, 'dir');
+  }
+
+  // link client-sync
+  const clientSyncDir = path.resolve(path.join('packages', 'client-sync'));
+  const destination = path.resolve(path.join('packages', 'client-app', 'internal_packages', 'client-sync'));
+  unlinkIfExistsSync(destination);
+  fs.symlinkSync(clientSyncDir, destination, 'dir');
+}
+
+async function lernaBootstrap(installTarget) {
+  console.log("\n---> Installing packages");
+  const lernaCmd = process.platform === 'win32' ? 'lerna.cmd' : 'lerna';
+  const args = ["bootstrap"]
+  switch (installTarget) {
+    case TARGET_CLIENT:
+      args.push(`--ignore='cloud-*'`)
+      break
+    case TARGET_CLOUD:
+      args.push(`--ignore='client-*'`)
+      break
+    default:
+      break
+  }
+  await spawn(path.join('node_modules', '.bin', lernaCmd), args)
+}
+
+const npmEnvs = {
+  system: process.env,
+  apm: Object.assign({}, process.env, {
+    NPM_CONFIG_TARGET: '0.10.40',
+  }),
+  electron: Object.assign({}, process.env, {
+    NPM_CONFIG_TARGET: '1.4.15',
+    NPM_CONFIG_ARCH: process.arch,
+    NPM_CONFIG_TARGET_ARCH: process.arch,
+    NPM_CONFIG_DISTURL: 'https://atom.io/download/electron',
+    NPM_CONFIG_RUNTIME: 'electron',
+    NPM_CONFIG_BUILD_FROM_SOURCE: true,
+  }),
+};
+
+async function npm(cmd, options) {
+  const {cwd, env} = Object.assign({cwd: '.', env: 'system'}, options);
+  const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm'
+  await spawn(npmCmd, [cmd], {
+    cwd: path.resolve(__dirname, '..', cwd),
+    env: npmEnvs[env],
+  })
+}
+
+async function electronRebuild() {
+  if (!fs.existsSync(path.join("packages", "client-app", "apm"))) {
+    console.log("\n---> No client app to rebuild. Moving on")
+    return;
+  }
+  await npm('install', {
+    cwd: path.join('packages', 'client-app', 'apm'),
+    env: 'apm',
+  })
+  await npm('rebuild', {
+    cwd: path.join('packages', 'client-app'),
+    env: 'electron',
+  })
+}
+
+const getJasmineDir = (packageName) => path.resolve(
+  path.join('packages', packageName, 'spec', 'jasmine')
+)
+const getJasmineConfigPath = (packageName) => path.resolve(
+  path.join(getJasmineDir(packageName), 'config.json')
+)
+
+function linkJasmineConfigs() {
+  console.log("\n---> Linking Jasmine configs");
+  const linkToPackages = ['cloud-api', 'cloud-core', 'cloud-workers']
+  const from = getJasmineConfigPath('isomorphic-core')
+
+  for (const packageName of linkToPackages) {
+    const dir = getJasmineDir(packageName)
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir)
+    }
+    const to = getJasmineConfigPath(packageName)
+    unlinkIfExistsSync(to)
+    fs.symlinkSync(from, to, 'file')
+  }
+}
+
+function linkIsomorphicCoreSpecs() {
+  console.log("\n---> Linking isomorphic-core specs to client-app specs")
+  const from = path.resolve(path.join('packages', 'isomorphic-core', 'spec'))
+  const to = path.resolve(path.join('packages', 'client-app', 'spec', 'isomorphic-core'))
+  unlinkIfExistsSync(to)
+  fs.symlinkSync(from, to, 'dir')
+}
+
+function getInstallTarget() {
+  const {INSTALL_TARGET} = process.env
+  if (!INSTALL_TARGET) {
+    return TARGET_ALL
+  }
+  if (![TARGET_ALL, TARGET_CLIENT, TARGET_CLOUD].includes(INSTALL_TARGET)) {
+    throw new Error(`postinstall: INSTALL_TARGET must be one of client, cloud, or all. It was set to ${INSTALL_TARGET}`)
+  }
+  return INSTALL_TARGET
+}
+
+async function main() {
+  try {
+    const installTarget = getInstallTarget()
+    console.log(`\n---> Installing for target ${installTarget}`);
+
+    if ([TARGET_ALL, TARGET_CLIENT].includes(installTarget)) {
+      await installPrivateResources()
+    }
+
+    await lernaBootstrap(installTarget);
+
+    if ([TARGET_ALL, TARGET_CLIENT].includes(installTarget)) {
+      if (process.platform === "darwin") {
+        // Given that `lerna bootstrap` does not install optional dependencies, we
+        // need to manually run `npm install` inside `client-app` so
+        // `node-mac-notifier` get's correctly installed and included in the build
+        // See https://github.com/lerna/lerna/issues/121
+        console.log("\n---> Reinstalling client-app dependencies to include optional dependencies");
+        await npm('install', {cwd: 'packages/client-app'})
+      }
+      await electronRebuild();
+      linkJasmineConfigs();
+      linkIsomorphicCoreSpecs();
+    }
+  } catch (err) {
+    console.error(err);
+    process.exit(1);
+  }
+}
+main()

scripts-tmp/sqlite/sqlite-amalgamation-3170000/sqlite3ext.h

@@ -0,0 +1,560 @@
+/*
+** 2006 June 7
+**
+** 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 header file defines the SQLite interface for use by
+** shared libraries that want to be imported as extensions into
+** an SQLite instance.  Shared libraries that intend to be loaded
+** as extensions by SQLite should #include this file instead of 
+** sqlite3.h.
+*/
+#ifndef SQLITE3EXT_H
+#define SQLITE3EXT_H
+#include "sqlite3.h"
+
+/*
+** The following structure holds pointers to all of the SQLite API
+** routines.
+**
+** WARNING:  In order to maintain backwards compatibility, add new
+** interfaces to the end of this structure only.  If you insert new
+** interfaces in the middle of this structure, then older different
+** versions of SQLite will not be able to load each other's shared
+** libraries!
+*/
+struct sqlite3_api_routines {
+  void * (*aggregate_context)(sqlite3_context*,int nBytes);
+  int  (*aggregate_count)(sqlite3_context*);
+  int  (*bind_blob)(sqlite3_stmt*,int,const void*,int n,void(*)(void*));
+  int  (*bind_double)(sqlite3_stmt*,int,double);
+  int  (*bind_int)(sqlite3_stmt*,int,int);
+  int  (*bind_int64)(sqlite3_stmt*,int,sqlite_int64);
+  int  (*bind_null)(sqlite3_stmt*,int);
+  int  (*bind_parameter_count)(sqlite3_stmt*);
+  int  (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
+  const char * (*bind_parameter_name)(sqlite3_stmt*,int);
+  int  (*bind_text)(sqlite3_stmt*,int,const char*,int n,void(*)(void*));
+  int  (*bind_text16)(sqlite3_stmt*,int,const void*,int,void(*)(void*));
+  int  (*bind_value)(sqlite3_stmt*,int,const sqlite3_value*);
+  int  (*busy_handler)(sqlite3*,int(*)(void*,int),void*);
+  int  (*busy_timeout)(sqlite3*,int ms);
+  int  (*changes)(sqlite3*);
+  int  (*close)(sqlite3*);
+  int  (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*,
+                           int eTextRep,const char*));
+  int  (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*,
+                             int eTextRep,const void*));
+  const void * (*column_blob)(sqlite3_stmt*,int iCol);
+  int  (*column_bytes)(sqlite3_stmt*,int iCol);
+  int  (*column_bytes16)(sqlite3_stmt*,int iCol);
+  int  (*column_count)(sqlite3_stmt*pStmt);
+  const char * (*column_database_name)(sqlite3_stmt*,int);
+  const void * (*column_database_name16)(sqlite3_stmt*,int);
+  const char * (*column_decltype)(sqlite3_stmt*,int i);
+  const void * (*column_decltype16)(sqlite3_stmt*,int);
+  double  (*column_double)(sqlite3_stmt*,int iCol);
+  int  (*column_int)(sqlite3_stmt*,int iCol);
+  sqlite_int64  (*column_int64)(sqlite3_stmt*,int iCol);
+  const char * (*column_name)(sqlite3_stmt*,int);
+  const void * (*column_name16)(sqlite3_stmt*,int);
+  const char * (*column_origin_name)(sqlite3_stmt*,int);
+  const void * (*column_origin_name16)(sqlite3_stmt*,int);
+  const char * (*column_table_name)(sqlite3_stmt*,int);
+  const void * (*column_table_name16)(sqlite3_stmt*,int);
+  const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
+  const void * (*column_text16)(sqlite3_stmt*,int iCol);
+  int  (*column_type)(sqlite3_stmt*,int iCol);
+  sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
+  void * (*commit_hook)(sqlite3*,int(*)(void*),void*);
+  int  (*complete)(const char*sql);
+  int  (*complete16)(const void*sql);
+  int  (*create_collation)(sqlite3*,const char*,int,void*,
+                           int(*)(void*,int,const void*,int,const void*));
+  int  (*create_collation16)(sqlite3*,const void*,int,void*,
+                             int(*)(void*,int,const void*,int,const void*));
+  int  (*create_function)(sqlite3*,const char*,int,int,void*,
+                          void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+                          void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+                          void (*xFinal)(sqlite3_context*));
+  int  (*create_function16)(sqlite3*,const void*,int,int,void*,
+                            void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+                            void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+                            void (*xFinal)(sqlite3_context*));
+  int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*);
+  int  (*data_count)(sqlite3_stmt*pStmt);
+  sqlite3 * (*db_handle)(sqlite3_stmt*);
+  int (*declare_vtab)(sqlite3*,const char*);
+  int  (*enable_shared_cache)(int);
+  int  (*errcode)(sqlite3*db);
+  const char * (*errmsg)(sqlite3*);
+  const void * (*errmsg16)(sqlite3*);
+  int  (*exec)(sqlite3*,const char*,sqlite3_callback,void*,char**);
+  int  (*expired)(sqlite3_stmt*);
+  int  (*finalize)(sqlite3_stmt*pStmt);
+  void  (*free)(void*);
+  void  (*free_table)(char**result);
+  int  (*get_autocommit)(sqlite3*);
+  void * (*get_auxdata)(sqlite3_context*,int);
+  int  (*get_table)(sqlite3*,const char*,char***,int*,int*,char**);
+  int  (*global_recover)(void);
+  void  (*interruptx)(sqlite3*);
+  sqlite_int64  (*last_insert_rowid)(sqlite3*);
+  const char * (*libversion)(void);
+  int  (*libversion_number)(void);
+  void *(*malloc)(int);
+  char * (*mprintf)(const char*,...);
+  int  (*open)(const char*,sqlite3**);
+  int  (*open16)(const void*,sqlite3**);
+  int  (*prepare)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
+  int  (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
+  void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*);
+  void  (*progress_handler)(sqlite3*,int,int(*)(void*),void*);
+  void *(*realloc)(void*,int);
+  int  (*reset)(sqlite3_stmt*pStmt);
+  void  (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*));
+  void  (*result_double)(sqlite3_context*,double);
+  void  (*result_error)(sqlite3_context*,const char*,int);
+  void  (*result_error16)(sqlite3_context*,const void*,int);
+  void  (*result_int)(sqlite3_context*,int);
+  void  (*result_int64)(sqlite3_context*,sqlite_int64);
+  void  (*result_null)(sqlite3_context*);
+  void  (*result_text)(sqlite3_context*,const char*,int,void(*)(void*));
+  void  (*result_text16)(sqlite3_context*,const void*,int,void(*)(void*));
+  void  (*result_text16be)(sqlite3_context*,const void*,int,void(*)(void*));
+  void  (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*));
+  void  (*result_value)(sqlite3_context*,sqlite3_value*);
+  void * (*rollback_hook)(sqlite3*,void(*)(void*),void*);
+  int  (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*,
+                         const char*,const char*),void*);
+  void  (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*));
+  char * (*snprintf)(int,char*,const char*,...);
+  int  (*step)(sqlite3_stmt*);
+  int  (*table_column_metadata)(sqlite3*,const char*,const char*,const char*,
+                                char const**,char const**,int*,int*,int*);
+  void  (*thread_cleanup)(void);
+  int  (*total_changes)(sqlite3*);
+  void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*);
+  int  (*transfer_bindings)(sqlite3_stmt*,sqlite3_stmt*);
+  void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*,
+                                         sqlite_int64),void*);
+  void * (*user_data)(sqlite3_context*);
+  const void * (*value_blob)(sqlite3_value*);
+  int  (*value_bytes)(sqlite3_value*);
+  int  (*value_bytes16)(sqlite3_value*);
+  double  (*value_double)(sqlite3_value*);
+  int  (*value_int)(sqlite3_value*);
+  sqlite_int64  (*value_int64)(sqlite3_value*);
+  int  (*value_numeric_type)(sqlite3_value*);
+  const unsigned char * (*value_text)(sqlite3_value*);
+  const void * (*value_text16)(sqlite3_value*);
+  const void * (*value_text16be)(sqlite3_value*);
+  const void * (*value_text16le)(sqlite3_value*);
+  int  (*value_type)(sqlite3_value*);
+  char *(*vmprintf)(const char*,va_list);
+  /* Added ??? */
+  int (*overload_function)(sqlite3*, const char *zFuncName, int nArg);
+  /* Added by 3.3.13 */
+  int (*prepare_v2)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
+  int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
+  int (*clear_bindings)(sqlite3_stmt*);
+  /* Added by 3.4.1 */
+  int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*,
+                          void (*xDestroy)(void *));
+  /* Added by 3.5.0 */
+  int (*bind_zeroblob)(sqlite3_stmt*,int,int);
+  int (*blob_bytes)(sqlite3_blob*);
+  int (*blob_close)(sqlite3_blob*);
+  int (*blob_open)(sqlite3*,const char*,const char*,const char*,sqlite3_int64,
+                   int,sqlite3_blob**);
+  int (*blob_read)(sqlite3_blob*,void*,int,int);
+  int (*blob_write)(sqlite3_blob*,const void*,int,int);
+  int (*create_collation_v2)(sqlite3*,const char*,int,void*,
+                             int(*)(void*,int,const void*,int,const void*),
+                             void(*)(void*));
+  int (*file_control)(sqlite3*,const char*,int,void*);
+  sqlite3_int64 (*memory_highwater)(int);
+  sqlite3_int64 (*memory_used)(void);
+  sqlite3_mutex *(*mutex_alloc)(int);
+  void (*mutex_enter)(sqlite3_mutex*);
+  void (*mutex_free)(sqlite3_mutex*);
+  void (*mutex_leave)(sqlite3_mutex*);
+  int (*mutex_try)(sqlite3_mutex*);
+  int (*open_v2)(const char*,sqlite3**,int,const char*);
+  int (*release_memory)(int);
+  void (*result_error_nomem)(sqlite3_context*);
+  void (*result_error_toobig)(sqlite3_context*);
+  int (*sleep)(int);
+  void (*soft_heap_limit)(int);
+  sqlite3_vfs *(*vfs_find)(const char*);
+  int (*vfs_register)(sqlite3_vfs*,int);
+  int (*vfs_unregister)(sqlite3_vfs*);
+  int (*xthreadsafe)(void);
+  void (*result_zeroblob)(sqlite3_context*,int);
+  void (*result_error_code)(sqlite3_context*,int);
+  int (*test_control)(int, ...);
+  void (*randomness)(int,void*);
+  sqlite3 *(*context_db_handle)(sqlite3_context*);
+  int (*extended_result_codes)(sqlite3*,int);
+  int (*limit)(sqlite3*,int,int);
+  sqlite3_stmt *(*next_stmt)(sqlite3*,sqlite3_stmt*);
+  const char *(*sql)(sqlite3_stmt*);
+  int (*status)(int,int*,int*,int);
+  int (*backup_finish)(sqlite3_backup*);
+  sqlite3_backup *(*backup_init)(sqlite3*,const char*,sqlite3*,const char*);
+  int (*backup_pagecount)(sqlite3_backup*);
+  int (*backup_remaining)(sqlite3_backup*);
+  int (*backup_step)(sqlite3_backup*,int);
+  const char *(*compileoption_get)(int);
+  int (*compileoption_used)(const char*);
+  int (*create_function_v2)(sqlite3*,const char*,int,int,void*,
+                            void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+                            void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+                            void (*xFinal)(sqlite3_context*),
+                            void(*xDestroy)(void*));
+  int (*db_config)(sqlite3*,int,...);
+  sqlite3_mutex *(*db_mutex)(sqlite3*);
+  int (*db_status)(sqlite3*,int,int*,int*,int);
+  int (*extended_errcode)(sqlite3*);
+  void (*log)(int,const char*,...);
+  sqlite3_int64 (*soft_heap_limit64)(sqlite3_int64);
+  const char *(*sourceid)(void);
+  int (*stmt_status)(sqlite3_stmt*,int,int);
+  int (*strnicmp)(const char*,const char*,int);
+  int (*unlock_notify)(sqlite3*,void(*)(void**,int),void*);
+  int (*wal_autocheckpoint)(sqlite3*,int);
+  int (*wal_checkpoint)(sqlite3*,const char*);
+  void *(*wal_hook)(sqlite3*,int(*)(void*,sqlite3*,const char*,int),void*);
+  int (*blob_reopen)(sqlite3_blob*,sqlite3_int64);
+  int (*vtab_config)(sqlite3*,int op,...);
+  int (*vtab_on_conflict)(sqlite3*);
+  /* Version 3.7.16 and later */
+  int (*close_v2)(sqlite3*);
+  const char *(*db_filename)(sqlite3*,const char*);
+  int (*db_readonly)(sqlite3*,const char*);
+  int (*db_release_memory)(sqlite3*);
+  const char *(*errstr)(int);
+  int (*stmt_busy)(sqlite3_stmt*);
+  int (*stmt_readonly)(sqlite3_stmt*);
+  int (*stricmp)(const char*,const char*);
+  int (*uri_boolean)(const char*,const char*,int);
+  sqlite3_int64 (*uri_int64)(const char*,const char*,sqlite3_int64);
+  const char *(*uri_parameter)(const char*,const char*);
+  char *(*vsnprintf)(int,char*,const char*,va_list);
+  int (*wal_checkpoint_v2)(sqlite3*,const char*,int,int*,int*);
+  /* Version 3.8.7 and later */
+  int (*auto_extension)(void(*)(void));
+  int (*bind_blob64)(sqlite3_stmt*,int,const void*,sqlite3_uint64,
+                     void(*)(void*));
+  int (*bind_text64)(sqlite3_stmt*,int,const char*,sqlite3_uint64,
+                      void(*)(void*),unsigned char);
+  int (*cancel_auto_extension)(void(*)(void));
+  int (*load_extension)(sqlite3*,const char*,const char*,char**);
+  void *(*malloc64)(sqlite3_uint64);
+  sqlite3_uint64 (*msize)(void*);
+  void *(*realloc64)(void*,sqlite3_uint64);
+  void (*reset_auto_extension)(void);
+  void (*result_blob64)(sqlite3_context*,const void*,sqlite3_uint64,
+                        void(*)(void*));
+  void (*result_text64)(sqlite3_context*,const char*,sqlite3_uint64,
+                         void(*)(void*), unsigned char);
+  int (*strglob)(const char*,const char*);
+  /* Version 3.8.11 and later */
+  sqlite3_value *(*value_dup)(const sqlite3_value*);
+  void (*value_free)(sqlite3_value*);
+  int (*result_zeroblob64)(sqlite3_context*,sqlite3_uint64);
+  int (*bind_zeroblob64)(sqlite3_stmt*, int, sqlite3_uint64);
+  /* Version 3.9.0 and later */
+  unsigned int (*value_subtype)(sqlite3_value*);
+  void (*result_subtype)(sqlite3_context*,unsigned int);
+  /* Version 3.10.0 and later */
+  int (*status64)(int,sqlite3_int64*,sqlite3_int64*,int);
+  int (*strlike)(const char*,const char*,unsigned int);
+  int (*db_cacheflush)(sqlite3*);
+  /* Version 3.12.0 and later */
+  int (*system_errno)(sqlite3*);
+  /* Version 3.14.0 and later */
+  int (*trace_v2)(sqlite3*,unsigned,int(*)(unsigned,void*,void*,void*),void*);
+  char *(*expanded_sql)(sqlite3_stmt*);
+};
+
+/*
+** This is the function signature used for all extension entry points.  It
+** is also defined in the file "loadext.c".
+*/
+typedef int (*sqlite3_loadext_entry)(
+  sqlite3 *db,                       /* Handle to the database. */
+  char **pzErrMsg,                   /* Used to set error string on failure. */
+  const sqlite3_api_routines *pThunk /* Extension API function pointers. */
+);
+
+/*
+** The following macros redefine the API routines so that they are
+** redirected through the global sqlite3_api structure.
+**
+** This header file is also used by the loadext.c source file
+** (part of the main SQLite library - not an extension) so that
+** it can get access to the sqlite3_api_routines structure
+** definition.  But the main library does not want to redefine
+** the API.  So the redefinition macros are only valid if the
+** SQLITE_CORE macros is undefined.
+*/
+#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
+#define sqlite3_aggregate_context      sqlite3_api->aggregate_context
+#ifndef SQLITE_OMIT_DEPRECATED
+#define sqlite3_aggregate_count        sqlite3_api->aggregate_count
+#endif
+#define sqlite3_bind_blob              sqlite3_api->bind_blob
+#define sqlite3_bind_double            sqlite3_api->bind_double
+#define sqlite3_bind_int               sqlite3_api->bind_int
+#define sqlite3_bind_int64             sqlite3_api->bind_int64
+#define sqlite3_bind_null              sqlite3_api->bind_null
+#define sqlite3_bind_parameter_count   sqlite3_api->bind_parameter_count
+#define sqlite3_bind_parameter_index   sqlite3_api->bind_parameter_index
+#define sqlite3_bind_parameter_name    sqlite3_api->bind_parameter_name
+#define sqlite3_bind_text              sqlite3_api->bind_text
+#define sqlite3_bind_text16            sqlite3_api->bind_text16
+#define sqlite3_bind_value             sqlite3_api->bind_value
+#define sqlite3_busy_handler           sqlite3_api->busy_handler
+#define sqlite3_busy_timeout           sqlite3_api->busy_timeout
+#define sqlite3_changes                sqlite3_api->changes
+#define sqlite3_close                  sqlite3_api->close
+#define sqlite3_collation_needed       sqlite3_api->collation_needed
+#define sqlite3_collation_needed16     sqlite3_api->collation_needed16
+#define sqlite3_column_blob            sqlite3_api->column_blob
+#define sqlite3_column_bytes           sqlite3_api->column_bytes
+#define sqlite3_column_bytes16         sqlite3_api->column_bytes16
+#define sqlite3_column_count           sqlite3_api->column_count
+#define sqlite3_column_database_name   sqlite3_api->column_database_name
+#define sqlite3_column_database_name16 sqlite3_api->column_database_name16
+#define sqlite3_column_decltype        sqlite3_api->column_decltype
+#define sqlite3_column_decltype16      sqlite3_api->column_decltype16
+#define sqlite3_column_double          sqlite3_api->column_double
+#define sqlite3_column_int             sqlite3_api->column_int
+#define sqlite3_column_int64           sqlite3_api->column_int64
+#define sqlite3_column_name            sqlite3_api->column_name
+#define sqlite3_column_name16          sqlite3_api->column_name16
+#define sqlite3_column_origin_name     sqlite3_api->column_origin_name
+#define sqlite3_column_origin_name16   sqlite3_api->column_origin_name16
+#define sqlite3_column_table_name      sqlite3_api->column_table_name
+#define sqlite3_column_table_name16    sqlite3_api->column_table_name16
+#define sqlite3_column_text            sqlite3_api->column_text
+#define sqlite3_column_text16          sqlite3_api->column_text16
+#define sqlite3_column_type            sqlite3_api->column_type
+#define sqlite3_column_value           sqlite3_api->column_value
+#define sqlite3_commit_hook            sqlite3_api->commit_hook
+#define sqlite3_complete               sqlite3_api->complete
+#define sqlite3_complete16             sqlite3_api->complete16
+#define sqlite3_create_collation       sqlite3_api->create_collation
+#define sqlite3_create_collation16     sqlite3_api->create_collation16
+#define sqlite3_create_function        sqlite3_api->create_function
+#define sqlite3_create_function16      sqlite3_api->create_function16
+#define sqlite3_create_module          sqlite3_api->create_module
+#define sqlite3_create_module_v2       sqlite3_api->create_module_v2
+#define sqlite3_data_count             sqlite3_api->data_count
+#define sqlite3_db_handle              sqlite3_api->db_handle
+#define sqlite3_declare_vtab           sqlite3_api->declare_vtab
+#define sqlite3_enable_shared_cache    sqlite3_api->enable_shared_cache
+#define sqlite3_errcode                sqlite3_api->errcode
+#define sqlite3_errmsg                 sqlite3_api->errmsg
+#define sqlite3_errmsg16               sqlite3_api->errmsg16
+#define sqlite3_exec                   sqlite3_api->exec
+#ifndef SQLITE_OMIT_DEPRECATED
+#define sqlite3_expired                sqlite3_api->expired
+#endif
+#define sqlite3_finalize               sqlite3_api->finalize
+#define sqlite3_free                   sqlite3_api->free
+#define sqlite3_free_table             sqlite3_api->free_table
+#define sqlite3_get_autocommit         sqlite3_api->get_autocommit
+#define sqlite3_get_auxdata            sqlite3_api->get_auxdata
+#define sqlite3_get_table              sqlite3_api->get_table
+#ifndef SQLITE_OMIT_DEPRECATED
+#define sqlite3_global_recover         sqlite3_api->global_recover
+#endif
+#define sqlite3_interrupt              sqlite3_api->interruptx
+#define sqlite3_last_insert_rowid      sqlite3_api->last_insert_rowid
+#define sqlite3_libversion             sqlite3_api->libversion
+#define sqlite3_libversion_number      sqlite3_api->libversion_number
+#define sqlite3_malloc                 sqlite3_api->malloc
+#define sqlite3_mprintf                sqlite3_api->mprintf
+#define sqlite3_open                   sqlite3_api->open
+#define sqlite3_open16                 sqlite3_api->open16
+#define sqlite3_prepare                sqlite3_api->prepare
+#define sqlite3_prepare16              sqlite3_api->prepare16
+#define sqlite3_prepare_v2             sqlite3_api->prepare_v2
+#define sqlite3_prepare16_v2           sqlite3_api->prepare16_v2
+#define sqlite3_profile                sqlite3_api->profile
+#define sqlite3_progress_handler       sqlite3_api->progress_handler
+#define sqlite3_realloc                sqlite3_api->realloc
+#define sqlite3_reset                  sqlite3_api->reset
+#define sqlite3_result_blob            sqlite3_api->result_blob
+#define sqlite3_result_double          sqlite3_api->result_double
+#define sqlite3_result_error           sqlite3_api->result_error
+#define sqlite3_result_error16         sqlite3_api->result_error16
+#define sqlite3_result_int             sqlite3_api->result_int
+#define sqlite3_result_int64           sqlite3_api->result_int64
+#define sqlite3_result_null            sqlite3_api->result_null
+#define sqlite3_result_text            sqlite3_api->result_text
+#define sqlite3_result_text16          sqlite3_api->result_text16
+#define sqlite3_result_text16be        sqlite3_api->result_text16be
+#define sqlite3_result_text16le        sqlite3_api->result_text16le
+#define sqlite3_result_value           sqlite3_api->result_value
+#define sqlite3_rollback_hook          sqlite3_api->rollback_hook
+#define sqlite3_set_authorizer         sqlite3_api->set_authorizer
+#define sqlite3_set_auxdata            sqlite3_api->set_auxdata
+#define sqlite3_snprintf               sqlite3_api->snprintf
+#define sqlite3_step                   sqlite3_api->step
+#define sqlite3_table_column_metadata  sqlite3_api->table_column_metadata
+#define sqlite3_thread_cleanup         sqlite3_api->thread_cleanup
+#define sqlite3_total_changes          sqlite3_api->total_changes
+#define sqlite3_trace                  sqlite3_api->trace
+#ifndef SQLITE_OMIT_DEPRECATED
+#define sqlite3_transfer_bindings      sqlite3_api->transfer_bindings
+#endif
+#define sqlite3_update_hook            sqlite3_api->update_hook
+#define sqlite3_user_data              sqlite3_api->user_data
+#define sqlite3_value_blob             sqlite3_api->value_blob
+#define sqlite3_value_bytes            sqlite3_api->value_bytes
+#define sqlite3_value_bytes16          sqlite3_api->value_bytes16
+#define sqlite3_value_double           sqlite3_api->value_double
+#define sqlite3_value_int              sqlite3_api->value_int
+#define sqlite3_value_int64            sqlite3_api->value_int64
+#define sqlite3_value_numeric_type     sqlite3_api->value_numeric_type
+#define sqlite3_value_text             sqlite3_api->value_text
+#define sqlite3_value_text16           sqlite3_api->value_text16
+#define sqlite3_value_text16be         sqlite3_api->value_text16be
+#define sqlite3_value_text16le         sqlite3_api->value_text16le
+#define sqlite3_value_type             sqlite3_api->value_type
+#define sqlite3_vmprintf               sqlite3_api->vmprintf
+#define sqlite3_vsnprintf              sqlite3_api->vsnprintf
+#define sqlite3_overload_function      sqlite3_api->overload_function
+#define sqlite3_prepare_v2             sqlite3_api->prepare_v2
+#define sqlite3_prepare16_v2           sqlite3_api->prepare16_v2
+#define sqlite3_clear_bindings         sqlite3_api->clear_bindings
+#define sqlite3_bind_zeroblob          sqlite3_api->bind_zeroblob
+#define sqlite3_blob_bytes             sqlite3_api->blob_bytes
+#define sqlite3_blob_close             sqlite3_api->blob_close
+#define sqlite3_blob_open              sqlite3_api->blob_open
+#define sqlite3_blob_read              sqlite3_api->blob_read
+#define sqlite3_blob_write             sqlite3_api->blob_write
+#define sqlite3_create_collation_v2    sqlite3_api->create_collation_v2
+#define sqlite3_file_control           sqlite3_api->file_control
+#define sqlite3_memory_highwater       sqlite3_api->memory_highwater
+#define sqlite3_memory_used            sqlite3_api->memory_used
+#define sqlite3_mutex_alloc            sqlite3_api->mutex_alloc
+#define sqlite3_mutex_enter            sqlite3_api->mutex_enter
+#define sqlite3_mutex_free             sqlite3_api->mutex_free
+#define sqlite3_mutex_leave            sqlite3_api->mutex_leave
+#define sqlite3_mutex_try              sqlite3_api->mutex_try
+#define sqlite3_open_v2                sqlite3_api->open_v2
+#define sqlite3_release_memory         sqlite3_api->release_memory
+#define sqlite3_result_error_nomem     sqlite3_api->result_error_nomem
+#define sqlite3_result_error_toobig    sqlite3_api->result_error_toobig
+#define sqlite3_sleep                  sqlite3_api->sleep
+#define sqlite3_soft_heap_limit        sqlite3_api->soft_heap_limit
+#define sqlite3_vfs_find               sqlite3_api->vfs_find
+#define sqlite3_vfs_register           sqlite3_api->vfs_register
+#define sqlite3_vfs_unregister         sqlite3_api->vfs_unregister
+#define sqlite3_threadsafe             sqlite3_api->xthreadsafe
+#define sqlite3_result_zeroblob        sqlite3_api->result_zeroblob
+#define sqlite3_result_error_code      sqlite3_api->result_error_code
+#define sqlite3_test_control           sqlite3_api->test_control
+#define sqlite3_randomness             sqlite3_api->randomness
+#define sqlite3_context_db_handle      sqlite3_api->context_db_handle
+#define sqlite3_extended_result_codes  sqlite3_api->extended_result_codes
+#define sqlite3_limit                  sqlite3_api->limit
+#define sqlite3_next_stmt              sqlite3_api->next_stmt
+#define sqlite3_sql                    sqlite3_api->sql
+#define sqlite3_status                 sqlite3_api->status
+#define sqlite3_backup_finish          sqlite3_api->backup_finish
+#define sqlite3_backup_init            sqlite3_api->backup_init
+#define sqlite3_backup_pagecount       sqlite3_api->backup_pagecount
+#define sqlite3_backup_remaining       sqlite3_api->backup_remaining
+#define sqlite3_backup_step            sqlite3_api->backup_step
+#define sqlite3_compileoption_get      sqlite3_api->compileoption_get
+#define sqlite3_compileoption_used     sqlite3_api->compileoption_used
+#define sqlite3_create_function_v2     sqlite3_api->create_function_v2
+#define sqlite3_db_config              sqlite3_api->db_config
+#define sqlite3_db_mutex               sqlite3_api->db_mutex
+#define sqlite3_db_status              sqlite3_api->db_status
+#define sqlite3_extended_errcode       sqlite3_api->extended_errcode
+#define sqlite3_log                    sqlite3_api->log
+#define sqlite3_soft_heap_limit64      sqlite3_api->soft_heap_limit64
+#define sqlite3_sourceid               sqlite3_api->sourceid
+#define sqlite3_stmt_status            sqlite3_api->stmt_status
+#define sqlite3_strnicmp               sqlite3_api->strnicmp
+#define sqlite3_unlock_notify          sqlite3_api->unlock_notify
+#define sqlite3_wal_autocheckpoint     sqlite3_api->wal_autocheckpoint
+#define sqlite3_wal_checkpoint         sqlite3_api->wal_checkpoint
+#define sqlite3_wal_hook               sqlite3_api->wal_hook
+#define sqlite3_blob_reopen            sqlite3_api->blob_reopen
+#define sqlite3_vtab_config            sqlite3_api->vtab_config
+#define sqlite3_vtab_on_conflict       sqlite3_api->vtab_on_conflict
+/* Version 3.7.16 and later */
+#define sqlite3_close_v2               sqlite3_api->close_v2
+#define sqlite3_db_filename            sqlite3_api->db_filename
+#define sqlite3_db_readonly            sqlite3_api->db_readonly
+#define sqlite3_db_release_memory      sqlite3_api->db_release_memory
+#define sqlite3_errstr                 sqlite3_api->errstr
+#define sqlite3_stmt_busy              sqlite3_api->stmt_busy
+#define sqlite3_stmt_readonly          sqlite3_api->stmt_readonly
+#define sqlite3_stricmp                sqlite3_api->stricmp
+#define sqlite3_uri_boolean            sqlite3_api->uri_boolean
+#define sqlite3_uri_int64              sqlite3_api->uri_int64
+#define sqlite3_uri_parameter          sqlite3_api->uri_parameter
+#define sqlite3_uri_vsnprintf          sqlite3_api->vsnprintf
+#define sqlite3_wal_checkpoint_v2      sqlite3_api->wal_checkpoint_v2
+/* Version 3.8.7 and later */
+#define sqlite3_auto_extension         sqlite3_api->auto_extension
+#define sqlite3_bind_blob64            sqlite3_api->bind_blob64
+#define sqlite3_bind_text64            sqlite3_api->bind_text64
+#define sqlite3_cancel_auto_extension  sqlite3_api->cancel_auto_extension
+#define sqlite3_load_extension         sqlite3_api->load_extension
+#define sqlite3_malloc64               sqlite3_api->malloc64
+#define sqlite3_msize                  sqlite3_api->msize
+#define sqlite3_realloc64              sqlite3_api->realloc64
+#define sqlite3_reset_auto_extension   sqlite3_api->reset_auto_extension
+#define sqlite3_result_blob64          sqlite3_api->result_blob64
+#define sqlite3_result_text64          sqlite3_api->result_text64
+#define sqlite3_strglob                sqlite3_api->strglob
+/* Version 3.8.11 and later */
+#define sqlite3_value_dup              sqlite3_api->value_dup
+#define sqlite3_value_free             sqlite3_api->value_free
+#define sqlite3_result_zeroblob64      sqlite3_api->result_zeroblob64
+#define sqlite3_bind_zeroblob64        sqlite3_api->bind_zeroblob64
+/* Version 3.9.0 and later */
+#define sqlite3_value_subtype          sqlite3_api->value_subtype
+#define sqlite3_result_subtype         sqlite3_api->result_subtype
+/* Version 3.10.0 and later */
+#define sqlite3_status64               sqlite3_api->status64
+#define sqlite3_strlike                sqlite3_api->strlike
+#define sqlite3_db_cacheflush          sqlite3_api->db_cacheflush
+/* Version 3.12.0 and later */
+#define sqlite3_system_errno           sqlite3_api->system_errno
+/* Version 3.14.0 and later */
+#define sqlite3_trace_v2               sqlite3_api->trace_v2
+#define sqlite3_expanded_sql           sqlite3_api->expanded_sql
+#endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */
+
+#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
+  /* This case when the file really is being compiled as a loadable 
+  ** extension */
+# define SQLITE_EXTENSION_INIT1     const sqlite3_api_routines *sqlite3_api=0;
+# define SQLITE_EXTENSION_INIT2(v)  sqlite3_api=v;
+# define SQLITE_EXTENSION_INIT3     \
+    extern const sqlite3_api_routines *sqlite3_api;
+#else
+  /* This case when the file is being statically linked into the 
+  ** application */
+# define SQLITE_EXTENSION_INIT1     /*no-op*/
+# define SQLITE_EXTENSION_INIT2(v)  (void)v; /* unused parameter */
+# define SQLITE_EXTENSION_INIT3     /*no-op*/
+#endif
+
+#endif /* SQLITE3EXT_H */