injectable_functions/build_injectable_functions.json

[
  {
    "function_name": "lockTable",
    "function_signature": "static SQLITE_NOINLINE void lockTable(\n  Parse *pParse,     /* Parsing context */\n  int iDb,           /* Index of the database containing the table to lock */\n  Pgno iTab,         /* Root page number of the table to be locked */\n  u8 isWriteLock,    /* True for a write lock */\n  const char *zName  /* Name of the table to be locked */\n)",
    "test_filename": "tests_build_lockTable.c"
  },
  {
    "function_name": "sqlite3TableLock",
    "function_signature": "void sqlite3TableLock(\n  Parse *pParse,     /* Parsing context */\n  int iDb,           /* Index of the database containing the table to lock */\n  Pgno iTab,         /* Root page number of the table to be locked */\n  u8 isWriteLock,    /* True for a write lock */\n  const char *zName  /* Name of the table to be locked */\n)",
    "test_filename": "tests_build_sqlite3TableLock.c"
  },
  {
    "function_name": "codeTableLocks",
    "function_signature": "static void codeTableLocks(Parse *pParse)",
    "test_filename": "tests_build_codeTableLocks.c"
  },
  {
    "function_name": "sqlite3FinishCoding",
    "function_signature": "void sqlite3FinishCoding(Parse *pParse)",
    "test_filename": "tests_build_sqlite3FinishCoding.c"
  },
  {
    "function_name": "sqlite3NestedParse",
    "function_signature": "void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...)",
    "test_filename": "tests_build_sqlite3NestedParse.c"
  },
  {
    "function_name": "sqlite3FreeIndex",
    "function_signature": "void sqlite3FreeIndex(sqlite3 *db, Index *p)",
    "test_filename": "tests_build_sqlite3FreeIndex.c"
  },
  {
    "function_name": "sqlite3UnlinkAndDeleteIndex",
    "function_signature": "void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName)",
    "test_filename": "tests_build_sqlite3UnlinkAndDeleteIndex.c"
  },
  {
    "function_name": "sqlite3CollapseDatabaseArray",
    "function_signature": "void sqlite3CollapseDatabaseArray(sqlite3 *db)",
    "test_filename": "tests_build_sqlite3CollapseDatabaseArray.c"
  },
  {
    "function_name": "sqlite3ResetOneSchema",
    "function_signature": "void sqlite3ResetOneSchema(sqlite3 *db, int iDb)",
    "test_filename": "tests_build_sqlite3ResetOneSchema.c"
  },
  {
    "function_name": "sqlite3ResetAllSchemasOfConnection",
    "function_signature": "void sqlite3ResetAllSchemasOfConnection(sqlite3 *db)",
    "test_filename": "tests_build_sqlite3ResetAllSchemasOfConnection.c"
  },
  {
    "function_name": "sqlite3ColumnSetExpr",
    "function_signature": "void sqlite3ColumnSetExpr(\n  Parse *pParse,    /* Parsing context */\n  Table *pTab,      /* The table containing the column */\n  Column *pCol,     /* The column to receive the new DEFAULT expression */\n  Expr *pExpr       /* The new default expression */\n)",
    "test_filename": "tests_build_sqlite3ColumnSetExpr.c"
  },
  {
    "function_name": "sqlite3ColumnSetColl",
    "function_signature": "void sqlite3ColumnSetColl(\n  sqlite3 *db,\n  Column *pCol,\n  const char *zColl\n)",
    "test_filename": "tests_build_sqlite3ColumnSetColl.c"
  },
  {
    "function_name": "sqlite3DeleteColumnNames",
    "function_signature": "void sqlite3DeleteColumnNames(sqlite3 *db, Table *pTable)",
    "test_filename": "tests_build_sqlite3DeleteColumnNames.c"
  },
  {
    "function_name": "deleteTable",
    "function_signature": "static void SQLITE_NOINLINE deleteTable(sqlite3 *db, Table *pTable)",
    "test_filename": "tests_build_deleteTable.c"
  },
  {
    "function_name": "sqlite3UnlinkAndDeleteTable",
    "function_signature": "void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName)",
    "test_filename": "tests_build_sqlite3UnlinkAndDeleteTable.c"
  },
  {
    "function_name": "sqlite3FindDbName",
    "function_signature": "int sqlite3FindDbName(sqlite3 *db, const char *zName)",
    "test_filename": "tests_build_sqlite3FindDbName.c"
  },
  {
    "function_name": "sqlite3TwoPartName",
    "function_signature": "int sqlite3TwoPartName(\n  Parse *pParse,      /* Parsing and code generating context */\n  Token *pName1,      /* The \"xxx\" in the name \"xxx.yyy\" or \"xxx\" */\n  Token *pName2,      /* The \"yyy\" in the name \"xxx.yyy\" */\n  Token **pUnqual     /* Write the unqualified object name here */\n)",
    "test_filename": "tests_build_sqlite3TwoPartName.c"
  },
  {
    "function_name": "sqlite3WritableSchema",
    "function_signature": "int sqlite3WritableSchema(sqlite3 *db)",
    "test_filename": "tests_build_sqlite3WritableSchema.c"
  },
  {
    "function_name": "sqlite3CheckObjectName",
    "function_signature": "int sqlite3CheckObjectName(\n  Parse *pParse,            /* Parsing context */\n  const char *zName,        /* Name of the object to check */\n  const char *zType,        /* Type of this object */\n  const char *zTblName      /* Parent table name for triggers and indexes */\n)",
    "test_filename": "tests_build_sqlite3CheckObjectName.c"
  },
  {
    "function_name": "sqlite3TableColumnToIndex",
    "function_signature": "int sqlite3TableColumnToIndex(Index *pIdx, int iCol)",
    "test_filename": "tests_build_sqlite3TableColumnToIndex.c"
  },
  {
    "function_name": "sqlite3TableColumnToStorage",
    "function_signature": "i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol)",
    "test_filename": "tests_build_sqlite3TableColumnToStorage.c"
  },
  {
    "function_name": "sqlite3StartTable",
    "function_signature": "void sqlite3StartTable(\n  Parse *pParse,   /* Parser context */\n  Token *pName1,   /* First part of the name of the table or view */\n  Token *pName2,   /* Second part of the name of the table or view */\n  int isTemp,      /* True if this is a TEMP table */\n  int isView,      /* True if this is a VIEW */\n  int isVirtual,   /* True if this is a VIRTUAL table */\n  int noErr        /* Do nothing if table already exists */\n)",
    "test_filename": "tests_build_sqlite3StartTable.c"
  },
  {
    "function_name": "sqlite3AddReturning",
    "function_signature": "void sqlite3AddReturning(Parse *pParse, ExprList *pList)",
    "test_filename": "tests_build_sqlite3AddReturning.c"
  },
  {
    "function_name": "sqlite3AddColumn",
    "function_signature": "void sqlite3AddColumn(Parse *pParse, Token sName, Token sType)",
    "test_filename": "tests_build_sqlite3AddColumn.c"
  },
  {
    "function_name": "sqlite3AddNotNull",
    "function_signature": "void sqlite3AddNotNull(Parse *pParse, int onError)",
    "test_filename": "tests_build_sqlite3AddNotNull.c"
  },
  {
    "function_name": "sqlite3AffinityType",
    "function_signature": "char sqlite3AffinityType(const char *zIn, Column *pCol)",
    "test_filename": "tests_build_sqlite3AffinityType.c"
  },
  {
    "function_name": "sqlite3AddDefaultValue",
    "function_signature": "void sqlite3AddDefaultValue(\n  Parse *pParse,           /* Parsing context */\n  Expr *pExpr,             /* The parsed expression of the default value */\n  const char *zStart,      /* Start of the default value text */\n  const char *zEnd         /* First character past end of default value text */\n)",
    "test_filename": "tests_build_sqlite3AddDefaultValue.c"
  },
  {
    "function_name": "makeColumnPartOfPrimaryKey",
    "function_signature": "static void makeColumnPartOfPrimaryKey(Parse *pParse, Column *pCol)",
    "test_filename": "tests_build_makeColumnPartOfPrimaryKey.c"
  },
  {
    "function_name": "sqlite3AddPrimaryKey",
    "function_signature": "void sqlite3AddPrimaryKey(\n  Parse *pParse,    /* Parsing context */\n  ExprList *pList,  /* List of field names to be indexed */\n  int onError,      /* What to do with a uniqueness conflict */\n  int autoInc,      /* True if the AUTOINCREMENT keyword is present */\n  int sortOrder     /* SQLITE_SO_ASC or SQLITE_SO_DESC */\n)",
    "test_filename": "tests_build_sqlite3AddPrimaryKey.c"
  },
  {
    "function_name": "sqlite3AddCheckConstraint",
    "function_signature": "void sqlite3AddCheckConstraint(\n  Parse *pParse,      /* Parsing context */\n  Expr *pCheckExpr,   /* The check expression */\n  const char *zStart, /* Opening \"(\" */\n  const char *zEnd    /* Closing \")\" */\n)",
    "test_filename": "tests_build_sqlite3AddCheckConstraint.c"
  },
  {
    "function_name": "sqlite3AddCollateType",
    "function_signature": "void sqlite3AddCollateType(Parse *pParse, Token *pToken)",
    "test_filename": "tests_build_sqlite3AddCollateType.c"
  },
  {
    "function_name": "sqlite3AddGenerated",
    "function_signature": "void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType)",
    "test_filename": "tests_build_sqlite3AddGenerated.c"
  },
  {
    "function_name": "identPut",
    "function_signature": "static void identPut(char *z, int *pIdx, char *zSignedIdent)",
    "test_filename": "tests_build_identPut.c"
  },
  {
    "function_name": "resizeIndexObject",
    "function_signature": "static int resizeIndexObject(Parse *pParse, Index *pIdx, int N)",
    "test_filename": "tests_build_resizeIndexObject.c"
  },
  {
    "function_name": "estimateTableWidth",
    "function_signature": "static void estimateTableWidth(Table *pTab)",
    "test_filename": "tests_build_estimateTableWidth.c"
  },
  {
    "function_name": "estimateIndexWidth",
    "function_signature": "static void estimateIndexWidth(Index *pIdx)",
    "test_filename": "tests_build_estimateIndexWidth.c"
  },
  {
    "function_name": "isDupColumn",
    "function_signature": "static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol)",
    "test_filename": "tests_build_isDupColumn.c"
  },
  {
    "function_name": "recomputeColumnsNotIndexed",
    "function_signature": "static void recomputeColumnsNotIndexed(Index *pIdx)",
    "test_filename": "tests_build_recomputeColumnsNotIndexed.c"
  },
  {
    "function_name": "convertToWithoutRowidTable",
    "function_signature": "static void convertToWithoutRowidTable(Parse *pParse, Table *pTab)",
    "test_filename": "tests_build_convertToWithoutRowidTable.c"
  },
  {
    "function_name": "sqlite3IsShadowTableOf",
    "function_signature": "int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char *zName)",
    "test_filename": "tests_build_sqlite3IsShadowTableOf.c"
  },
  {
    "function_name": "sqlite3MarkAllShadowTablesOf",
    "function_signature": "void sqlite3MarkAllShadowTablesOf(sqlite3 *db, Table *pTab)",
    "test_filename": "tests_build_sqlite3MarkAllShadowTablesOf.c"
  },
  {
    "function_name": "sqlite3ShadowTableName",
    "function_signature": "int sqlite3ShadowTableName(sqlite3 *db, const char *zName)",
    "test_filename": "tests_build_sqlite3ShadowTableName.c"
  },
  {
    "function_name": "markExprListImmutable",
    "function_signature": "static void markExprListImmutable(ExprList *pList)",
    "test_filename": "tests_build_markExprListImmutable.c"
  },
  {
    "function_name": "sqlite3EndTable",
    "function_signature": "void sqlite3EndTable(\n  Parse *pParse,          /* Parse context */\n  Token *pCons,           /* The ',' token after the last column defn. */\n  Token *pEnd,            /* The ')' before options in the CREATE TABLE */\n  u32 tabOpts,            /* Extra table options. Usually 0. */\n  Select *pSelect         /* Select from a \"CREATE ... AS SELECT\" */\n)",
    "test_filename": "tests_build_sqlite3EndTable.c"
  },
  {
    "function_name": "sqlite3CreateView",
    "function_signature": "void sqlite3CreateView(\n  Parse *pParse,     /* The parsing context */\n  Token *pBegin,     /* The CREATE token that begins the statement */\n  Token *pName1,     /* The token that holds the name of the view */\n  Token *pName2,     /* The token that holds the name of the view */\n  ExprList *pCNames, /* Optional list of view column names */\n  Select *pSelect,   /* A SELECT statement that will become the new view */\n  int isTemp,        /* TRUE for a TEMPORARY view */\n  int noErr          /* Suppress error messages if VIEW already exists */\n)",
    "test_filename": "tests_build_sqlite3CreateView.c"
  },
  {
    "function_name": "viewGetColumnNames",
    "function_signature": "static SQLITE_NOINLINE int viewGetColumnNames(Parse *pParse, Table *pTable)",
    "test_filename": "tests_build_viewGetColumnNames.c"
  },
  {
    "function_name": "sqliteViewResetAll",
    "function_signature": "static void sqliteViewResetAll(sqlite3 *db, int idx)",
    "test_filename": "tests_build_sqliteViewResetAll.c"
  },
  {
    "function_name": "sqlite3RootPageMoved",
    "function_signature": "void sqlite3RootPageMoved(sqlite3 *db, int iDb, Pgno iFrom, Pgno iTo)",
    "test_filename": "tests_build_sqlite3RootPageMoved.c"
  },
  {
    "function_name": "destroyRootPage",
    "function_signature": "static void destroyRootPage(Parse *pParse, int iTable, int iDb)",
    "test_filename": "tests_build_destroyRootPage.c"
  },
  {
    "function_name": "destroyTable",
    "function_signature": "static void destroyTable(Parse *pParse, Table *pTab)",
    "test_filename": "tests_build_destroyTable.c"
  },
  {
    "function_name": "sqlite3ClearStatTables",
    "function_signature": "static void sqlite3ClearStatTables(\n  Parse *pParse,         /* The parsing context */\n  int iDb,               /* The database number */\n  const char *zType,     /* \"idx\" or \"tbl\" */\n  const char *zName      /* Name of index or table */\n)",
    "test_filename": "tests_build_sqlite3ClearStatTables.c"
  },
  {
    "function_name": "sqlite3CodeDropTable",
    "function_signature": "void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView)",
    "test_filename": "tests_build_sqlite3CodeDropTable.c"
  },
  {
    "function_name": "sqlite3ReadOnlyShadowTables",
    "function_signature": "int sqlite3ReadOnlyShadowTables(sqlite3 *db)",
    "test_filename": "tests_build_sqlite3ReadOnlyShadowTables.c"
  },
  {
    "function_name": "tableMayNotBeDropped",
    "function_signature": "static int tableMayNotBeDropped(sqlite3 *db, Table *pTab)",
    "test_filename": "tests_build_tableMayNotBeDropped.c"
  },
  {
    "function_name": "sqlite3DropTable",
    "function_signature": "void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr)",
    "test_filename": "tests_build_sqlite3DropTable.c"
  },
  {
    "function_name": "sqlite3CreateForeignKey",
    "function_signature": "void sqlite3CreateForeignKey(\n  Parse *pParse,       /* Parsing context */\n  ExprList *pFromCol,  /* Columns in this table that point to other table */\n  Token *pTo,          /* Name of the other table */\n  ExprList *pToCol,    /* Columns in the other table */\n  int flags            /* Conflict resolution algorithms. */\n)",
    "test_filename": "tests_build_sqlite3CreateForeignKey.c"
  },
  {
    "function_name": "sqlite3DeferForeignKey",
    "function_signature": "void sqlite3DeferForeignKey(Parse *pParse, int isDeferred)",
    "test_filename": "tests_build_sqlite3DeferForeignKey.c"
  },
  {
    "function_name": "sqlite3RefillIndex",
    "function_signature": "static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage)",
    "test_filename": "tests_build_sqlite3RefillIndex.c"
  },
  {
    "function_name": "sqlite3HasExplicitNulls",
    "function_signature": "int sqlite3HasExplicitNulls(Parse *pParse, ExprList *pList)",
    "test_filename": "tests_build_sqlite3HasExplicitNulls.c"
  },
  {
    "function_name": "sqlite3CreateIndex",
    "function_signature": "void sqlite3CreateIndex(\n  Parse *pParse,     /* All information about this parse */\n  Token *pName1,     /* First part of index name. May be NULL */\n  Token *pName2,     /* Second part of index name. May be NULL */\n  SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */\n  ExprList *pList,   /* A list of columns to be indexed */\n  int onError,       /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */\n  Token *pStart,     /* The CREATE token that begins this statement */\n  Expr *pPIWhere,    /* WHERE clause for partial indices */\n  int sortOrder,     /* Sort order of primary key when pList==NULL */\n  int ifNotExist,    /* Omit error if index already exists */\n  u8 idxType         /* The index type */\n)",
    "test_filename": "tests_build_sqlite3CreateIndex.c"
  },
  {
    "function_name": "sqlite3DefaultRowEst",
    "function_signature": "void sqlite3DefaultRowEst(Index *pIdx)",
    "test_filename": "tests_build_sqlite3DefaultRowEst.c"
  },
  {
    "function_name": "sqlite3DropIndex",
    "function_signature": "void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists)",
    "test_filename": "tests_build_sqlite3DropIndex.c"
  },
  {
    "function_name": "sqlite3SrcListAssignCursors",
    "function_signature": "void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList)",
    "test_filename": "tests_build_sqlite3SrcListAssignCursors.c"
  },
  {
    "function_name": "sqlite3SrcListDelete",
    "function_signature": "void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList)",
    "test_filename": "tests_build_sqlite3SrcListDelete.c"
  },
  {
    "function_name": "sqlite3SrcItemAttachSubquery",
    "function_signature": "int sqlite3SrcItemAttachSubquery(\n  Parse *pParse,     /* Parsing context */\n  SrcItem *pItem,    /* Item to which the subquery is to be attached */\n  Select *pSelect,   /* The subquery SELECT.  Must be non-NULL */\n  int dupSelect      /* If true, attach a copy of pSelect, not pSelect itself.*/\n)",
    "test_filename": "tests_build_sqlite3SrcItemAttachSubquery.c"
  },
  {
    "function_name": "sqlite3SrcListIndexedBy",
    "function_signature": "void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy)",
    "test_filename": "tests_build_sqlite3SrcListIndexedBy.c"
  },
  {
    "function_name": "sqlite3SrcListFuncArgs",
    "function_signature": "void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList)",
    "test_filename": "tests_build_sqlite3SrcListFuncArgs.c"
  },
  {
    "function_name": "sqlite3SrcListShiftJoinType",
    "function_signature": "void sqlite3SrcListShiftJoinType(Parse *pParse, SrcList *p)",
    "test_filename": "tests_build_sqlite3SrcListShiftJoinType.c"
  },
  {
    "function_name": "sqlite3BeginTransaction",
    "function_signature": "void sqlite3BeginTransaction(Parse *pParse, int type)",
    "test_filename": "tests_build_sqlite3BeginTransaction.c"
  },
  {
    "function_name": "sqlite3EndTransaction",
    "function_signature": "void sqlite3EndTransaction(Parse *pParse, int eType)",
    "test_filename": "tests_build_sqlite3EndTransaction.c"
  },
  {
    "function_name": "sqlite3Savepoint",
    "function_signature": "void sqlite3Savepoint(Parse *pParse, int op, Token *pName)",
    "test_filename": "tests_build_sqlite3Savepoint.c"
  },
  {
    "function_name": "sqlite3OpenTempDatabase",
    "function_signature": "int sqlite3OpenTempDatabase(Parse *pParse)",
    "test_filename": "tests_build_sqlite3OpenTempDatabase.c"
  },
  {
    "function_name": "sqlite3CodeVerifySchemaAtToplevel",
    "function_signature": "static void sqlite3CodeVerifySchemaAtToplevel(Parse *pToplevel, int iDb)",
    "test_filename": "tests_build_sqlite3CodeVerifySchemaAtToplevel.c"
  },
  {
    "function_name": "sqlite3CodeVerifyNamedSchema",
    "function_signature": "void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb)",
    "test_filename": "tests_build_sqlite3CodeVerifyNamedSchema.c"
  },
  {
    "function_name": "sqlite3HaltConstraint",
    "function_signature": "void sqlite3HaltConstraint(\n  Parse *pParse,    /* Parsing context */\n  int errCode,      /* extended error code */\n  int onError,      /* Constraint type */\n  char *p4,         /* Error message */\n  i8 p4type,        /* P4_STATIC or P4_TRANSIENT */\n  u8 p5Errmsg       /* P5_ErrMsg type */\n)",
    "test_filename": "tests_build_sqlite3HaltConstraint.c"
  },
  {
    "function_name": "sqlite3UniqueConstraint",
    "function_signature": "void sqlite3UniqueConstraint(\n  Parse *pParse,    /* Parsing context */\n  int onError,      /* Constraint type */\n  Index *pIdx       /* The index that triggers the constraint */\n)",
    "test_filename": "tests_build_sqlite3UniqueConstraint.c"
  },
  {
    "function_name": "sqlite3RowidConstraint",
    "function_signature": "void sqlite3RowidConstraint(\n  Parse *pParse,    /* Parsing context */\n  int onError,      /* Conflict resolution algorithm */\n  Table *pTab       /* The table with the non-unique rowid */\n)",
    "test_filename": "tests_build_sqlite3RowidConstraint.c"
  },
  {
    "function_name": "collationMatch",
    "function_signature": "static int collationMatch(const char *zColl, Index *pIndex)",
    "test_filename": "tests_build_collationMatch.c"
  },
  {
    "function_name": "reindexTable",
    "function_signature": "static void reindexTable(Parse *pParse, Table *pTab, char const *zColl)",
    "test_filename": "tests_build_reindexTable.c"
  },
  {
    "function_name": "reindexDatabases",
    "function_signature": "static void reindexDatabases(Parse *pParse, char const *zColl)",
    "test_filename": "tests_build_reindexDatabases.c"
  },
  {
    "function_name": "sqlite3Reindex",
    "function_signature": "void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2)",
    "test_filename": "tests_build_sqlite3Reindex.c"
  }
]