injectable_functions/select_injectable_functions.json

[
  {
    "function_name": "clearSelect",
    "function_signature": "static void clearSelect(sqlite3 *db, Select *p, int bFree)",
    "test_filename": "tests_select_clearSelect.c"
  },
  {
    "function_name": "sqlite3JoinType",
    "function_signature": "int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC)",
    "test_filename": "tests_select_sqlite3JoinType.c"
  },
  {
    "function_name": "sqlite3ColumnIndex",
    "function_signature": "int sqlite3ColumnIndex(Table *pTab, const char *zCol)",
    "test_filename": "tests_select_sqlite3ColumnIndex.c"
  },
  {
    "function_name": "sqlite3SrcItemColumnUsed",
    "function_signature": "void sqlite3SrcItemColumnUsed(SrcItem *pItem, int iCol)",
    "test_filename": "tests_select_sqlite3SrcItemColumnUsed.c"
  },
  {
    "function_name": "tableAndColumnIndex",
    "function_signature": "static int tableAndColumnIndex(\n  SrcList *pSrc,       /* Array of tables to search */\n  int iStart,          /* First member of pSrc->a[] to check */\n  int iEnd,            /* Last member of pSrc->a[] to check */\n  const char *zCol,    /* Name of the column we are looking for */\n  int *piTab,          /* Write index of pSrc->a[] here */\n  int *piCol,          /* Write index of pSrc->a[*piTab].pSTab->aCol[] here */\n  int bIgnoreHidden    /* Ignore hidden columns */\n)",
    "test_filename": "tests_select_tableAndColumnIndex.c"
  },
  {
    "function_name": "sqlite3SetJoinExpr",
    "function_signature": "void sqlite3SetJoinExpr(Expr *p, int iTable, u32 joinFlag)",
    "test_filename": "tests_select_sqlite3SetJoinExpr.c"
  },
  {
    "function_name": "unsetJoinExpr",
    "function_signature": "static void unsetJoinExpr(Expr *p, int iTable, int nullable)",
    "test_filename": "tests_select_unsetJoinExpr.c"
  },
  {
    "function_name": "sqlite3ProcessJoin",
    "function_signature": "static int sqlite3ProcessJoin(Parse *pParse, Select *p)",
    "test_filename": "tests_select_sqlite3ProcessJoin.c"
  },
  {
    "function_name": "innerLoopLoadRow",
    "function_signature": "static void innerLoopLoadRow(\n  Parse *pParse,             /* Statement under construction */\n  Select *pSelect,           /* The query being coded */\n  RowLoadInfo *pInfo         /* Info needed to complete the row load */\n)",
    "test_filename": "tests_select_innerLoopLoadRow.c"
  },
  {
    "function_name": "makeSorterRecord",
    "function_signature": "static int makeSorterRecord(\n  Parse *pParse,\n  SortCtx *pSort,\n  Select *pSelect,\n  int regBase,\n  int nBase\n)",
    "test_filename": "tests_select_makeSorterRecord.c"
  },
  {
    "function_name": "pushOntoSorter",
    "function_signature": "static void pushOntoSorter(\n  Parse *pParse,         /* Parser context */\n  SortCtx *pSort,        /* Information about the ORDER BY clause */\n  Select *pSelect,       /* The whole SELECT statement */\n  int regData,           /* First register holding data to be sorted */\n  int regOrigData,       /* First register holding data before packing */\n  int nData,             /* Number of elements in the regData data array */\n  int nPrefixReg         /* No. of reg prior to regData available for use */\n)",
    "test_filename": "tests_select_pushOntoSorter.c"
  },
  {
    "function_name": "codeOffset",
    "function_signature": "static void codeOffset(\n  Vdbe *v,          /* Generate code into this VM */\n  int iOffset,      /* Register holding the offset counter */\n  int iContinue     /* Jump here to skip the current record */\n)",
    "test_filename": "tests_select_codeOffset.c"
  },
  {
    "function_name": "codeDistinct",
    "function_signature": "static int codeDistinct(\n  Parse *pParse,     /* Parsing and code generating context */\n  int eTnctType,     /* WHERE_DISTINCT_* value */\n  int iTab,          /* A sorting index used to test for distinctness */\n  int addrRepeat,    /* Jump to here if not distinct */\n  ExprList *pEList,  /* Expression for each element */\n  int regElem        /* First element */\n)",
    "test_filename": "tests_select_codeDistinct.c"
  },
  {
    "function_name": "fixDistinctOpenEph",
    "function_signature": "static void fixDistinctOpenEph(\n  Parse *pParse,     /* Parsing and code generating context */\n  int eTnctType,     /* WHERE_DISTINCT_* value */\n  int iVal,          /* Value returned by codeDistinct() */\n  int iOpenEphAddr   /* Address of OP_OpenEphemeral instruction for iTab */\n)",
    "test_filename": "tests_select_fixDistinctOpenEph.c"
  },
  {
    "function_name": "selectExprDefer",
    "function_signature": "static void selectExprDefer(\n  Parse *pParse,                  /* Leave any error here */\n  SortCtx *pSort,                 /* Sorter context */\n  ExprList *pEList,               /* Expressions destined for sorter */\n  ExprList **ppExtra              /* Expressions to append to sorter record */\n)",
    "test_filename": "tests_select_selectExprDefer.c"
  },
  {
    "function_name": "selectInnerLoop",
    "function_signature": "static void selectInnerLoop(\n  Parse *pParse,          /* The parser context */\n  Select *p,              /* The complete select statement being coded */\n  int srcTab,             /* Pull data from this table if non-negative */\n  SortCtx *pSort,         /* If not NULL, info on how to process ORDER BY */\n  DistinctCtx *pDistinct, /* If not NULL, info on how to process DISTINCT */\n  SelectDest *pDest,      /* How to dispose of the results */\n  int iContinue,          /* Jump here to continue with next row */\n  int iBreak              /* Jump here to break out of the inner loop */\n)",
    "test_filename": "tests_select_selectInnerLoop.c"
  },
  {
    "function_name": "generateSortTail",
    "function_signature": "static void generateSortTail(\n  Parse *pParse,    /* Parsing context */\n  Select *p,        /* The SELECT statement */\n  SortCtx *pSort,   /* Information on the ORDER BY clause */\n  int nColumn,      /* Number of columns of data */\n  SelectDest *pDest /* Write the sorted results here */\n)",
    "test_filename": "tests_select_generateSortTail.c"
  },
  {
    "function_name": "generateColumnTypes",
    "function_signature": "static void generateColumnTypes(\n  Parse *pParse,      /* Parser context */\n  SrcList *pTabList,  /* List of tables */\n  ExprList *pEList    /* Expressions defining the result set */\n)",
    "test_filename": "tests_select_generateColumnTypes.c"
  },
  {
    "function_name": "sqlite3GenerateColumnNames",
    "function_signature": "void sqlite3GenerateColumnNames(\n  Parse *pParse,      /* Parser context */\n  Select *pSelect     /* Generate column names for this SELECT statement */\n)",
    "test_filename": "tests_select_sqlite3GenerateColumnNames.c"
  },
  {
    "function_name": "sqlite3ColumnsFromExprList",
    "function_signature": "int sqlite3ColumnsFromExprList(\n  Parse *pParse,          /* Parsing context */\n  ExprList *pEList,       /* Expr list from which to derive column names */\n  i16 *pnCol,             /* Write the number of columns here */\n  Column **paCol          /* Write the new column list here */\n)",
    "test_filename": "tests_select_sqlite3ColumnsFromExprList.c"
  },
  {
    "function_name": "sqlite3SubqueryColumnTypes",
    "function_signature": "void sqlite3SubqueryColumnTypes(\n  Parse *pParse,      /* Parsing contexts */\n  Table *pTab,        /* Add column type information to this table */\n  Select *pSelect,    /* SELECT used to determine types and collations */\n  char aff            /* Default affinity. */\n)",
    "test_filename": "tests_select_sqlite3SubqueryColumnTypes.c"
  },
  {
    "function_name": "computeLimitRegisters",
    "function_signature": "static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak)",
    "test_filename": "tests_select_computeLimitRegisters.c"
  },
  {
    "function_name": "generateWithRecursiveQuery",
    "function_signature": "static void generateWithRecursiveQuery(\n  Parse *pParse,        /* Parsing context */\n  Select *p,            /* The recursive SELECT to be coded */\n  SelectDest *pDest     /* What to do with query results */\n)",
    "test_filename": "tests_select_generateWithRecursiveQuery.c"
  },
  {
    "function_name": "multiSelectValues",
    "function_signature": "static int multiSelectValues(\n  Parse *pParse,        /* Parsing context */\n  Select *p,            /* The right-most of SELECTs to be coded */\n  SelectDest *pDest     /* What to do with query results */\n)",
    "test_filename": "tests_select_multiSelectValues.c"
  },
  {
    "function_name": "multiSelect",
    "function_signature": "static int multiSelect(\n  Parse *pParse,        /* Parsing context */\n  Select *p,            /* The right-most of SELECTs to be coded */\n  SelectDest *pDest     /* What to do with query results */\n)",
    "test_filename": "tests_select_multiSelect.c"
  },
  {
    "function_name": "generateOutputSubroutine",
    "function_signature": "static int generateOutputSubroutine(\n  Parse *pParse,          /* Parsing context */\n  Select *p,              /* The SELECT statement */\n  SelectDest *pIn,        /* Coroutine supplying data */\n  SelectDest *pDest,      /* Where to send the data */\n  int regReturn,          /* The return address register */\n  int regPrev,            /* Previous result register.  No uniqueness if 0 */\n  KeyInfo *pKeyInfo,      /* For comparing with previous entry */\n  int iBreak              /* Jump here if we hit the LIMIT */\n)",
    "test_filename": "tests_select_generateOutputSubroutine.c"
  },
  {
    "function_name": "multiSelectOrderBy",
    "function_signature": "static int multiSelectOrderBy(\n  Parse *pParse,        /* Parsing context */\n  Select *p,            /* The right-most of SELECTs to be coded */\n  SelectDest *pDest     /* What to do with query results */\n)",
    "test_filename": "tests_select_multiSelectOrderBy.c"
  },
  {
    "function_name": "substExprList",
    "function_signature": "static void substExprList(\n  SubstContext *pSubst, /* Description of the substitution */\n  ExprList *pList       /* List to scan and in which to make substitutes */\n)",
    "test_filename": "tests_select_substExprList.c"
  },
  {
    "function_name": "substSelect",
    "function_signature": "static void substSelect(\n  SubstContext *pSubst, /* Description of the substitution */\n  Select *p,            /* SELECT statement in which to make substitutions */\n  int doPrior           /* Do substitutes on p->pPrior too */\n)",
    "test_filename": "tests_select_substSelect.c"
  },
  {
    "function_name": "recomputeColumnsUsed",
    "function_signature": "static void recomputeColumnsUsed(\n  Select *pSelect,                 /* The complete SELECT statement */\n  SrcItem *pSrcItem                /* Which FROM clause item to recompute */\n)",
    "test_filename": "tests_select_recomputeColumnsUsed.c"
  },
  {
    "function_name": "srclistRenumberCursors",
    "function_signature": "static void srclistRenumberCursors(\n  Parse *pParse,                  /* Parse context */\n  int *aCsrMap,                   /* Array to store cursor mappings in */\n  SrcList *pSrc,                  /* FROM clause to renumber */\n  int iExcept                     /* FROM clause item to skip */\n)",
    "test_filename": "tests_select_srclistRenumberCursors.c"
  },
  {
    "function_name": "renumberCursorsCb",
    "function_signature": "static int renumberCursorsCb(Walker *pWalker, Expr *pExpr)",
    "test_filename": "tests_select_renumberCursorsCb.c"
  },
  {
    "function_name": "renumberCursors",
    "function_signature": "static void renumberCursors(\n  Parse *pParse,                  /* Parse context */\n  Select *p,                      /* Select to renumber cursors within */\n  int iExcept,                    /* FROM clause item to skip */\n  int *aCsrMap                    /* Working space */\n)",
    "test_filename": "tests_select_renumberCursors.c"
  },
  {
    "function_name": "compoundHasDifferentAffinities",
    "function_signature": "static int compoundHasDifferentAffinities(Select *p)",
    "test_filename": "tests_select_compoundHasDifferentAffinities.c"
  },
  {
    "function_name": "flattenSubquery",
    "function_signature": "static int flattenSubquery(\n  Parse *pParse,       /* Parsing context */\n  Select *p,           /* The parent or outer SELECT statement */\n  int iFrom,           /* Index in p->pSrc->a[] of the inner subquery */\n  int isAgg            /* True if outer SELECT uses aggregate functions */\n)",
    "test_filename": "tests_select_flattenSubquery.c"
  },
  {
    "function_name": "constInsert",
    "function_signature": "static void constInsert(\n  WhereConst *pConst,  /* The WhereConst into which we are inserting */\n  Expr *pColumn,       /* The COLUMN part of the constraint */\n  Expr *pValue,        /* The VALUE part of the constraint */\n  Expr *pExpr          /* Overall expression: COLUMN=VALUE or VALUE=COLUMN */\n)",
    "test_filename": "tests_select_constInsert.c"
  },
  {
    "function_name": "findConstInWhere",
    "function_signature": "static void findConstInWhere(WhereConst *pConst, Expr *pExpr)",
    "test_filename": "tests_select_findConstInWhere.c"
  },
  {
    "function_name": "propagateConstantExprRewriteOne",
    "function_signature": "static int propagateConstantExprRewriteOne(\n  WhereConst *pConst,\n  Expr *pExpr,\n  int bIgnoreAffBlob\n)",
    "test_filename": "tests_select_propagateConstantExprRewriteOne.c"
  },
  {
    "function_name": "propagateConstantExprRewrite",
    "function_signature": "static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr)",
    "test_filename": "tests_select_propagateConstantExprRewrite.c"
  },
  {
    "function_name": "propagateConstants",
    "function_signature": "static int propagateConstants(\n  Parse *pParse,   /* The parsing context */\n  Select *p        /* The query in which to propagate constants */\n)",
    "test_filename": "tests_select_propagateConstants.c"
  },
  {
    "function_name": "pushDownWhereTerms",
    "function_signature": "static int pushDownWhereTerms(\n  Parse *pParse,        /* Parse context (for malloc() and error reporting) */\n  Select *pSubq,        /* The subquery whose WHERE clause is to be augmented */\n  Expr *pWhere,         /* The WHERE clause of the outer query */\n  SrcList *pSrcList,    /* The complete from clause of the outer query */\n  int iSrc              /* Which FROM clause term to try to push into  */\n)",
    "test_filename": "tests_select_pushDownWhereTerms.c"
  },
  {
    "function_name": "disableUnusedSubqueryResultColumns",
    "function_signature": "static int disableUnusedSubqueryResultColumns(SrcItem *pItem)",
    "test_filename": "tests_select_disableUnusedSubqueryResultColumns.c"
  },
  {
    "function_name": "minMaxQuery",
    "function_signature": "static u8 minMaxQuery(sqlite3 *db, Expr *pFunc, ExprList **ppMinMax)",
    "test_filename": "tests_select_minMaxQuery.c"
  },
  {
    "function_name": "sqlite3IndexedByLookup",
    "function_signature": "int sqlite3IndexedByLookup(Parse *pParse, SrcItem *pFrom)",
    "test_filename": "tests_select_sqlite3IndexedByLookup.c"
  },
  {
    "function_name": "convertCompoundSelectToSubquery",
    "function_signature": "static int convertCompoundSelectToSubquery(Walker *pWalker, Select *p)",
    "test_filename": "tests_select_convertCompoundSelectToSubquery.c"
  },
  {
    "function_name": "resolveFromTermToCte",
    "function_signature": "static int resolveFromTermToCte(\n  Parse *pParse,                  /* The parsing context */\n  Walker *pWalker,                /* Current tree walker */\n  SrcItem *pFrom                  /* The FROM clause term to check */\n)",
    "test_filename": "tests_select_resolveFromTermToCte.c"
  },
  {
    "function_name": "sqlite3SelectPopWith",
    "function_signature": "void sqlite3SelectPopWith(Walker *pWalker, Select *p)",
    "test_filename": "tests_select_sqlite3SelectPopWith.c"
  },
  {
    "function_name": "sqlite3ExpandSubquery",
    "function_signature": "int sqlite3ExpandSubquery(Parse *pParse, SrcItem *pFrom)",
    "test_filename": "tests_select_sqlite3ExpandSubquery.c"
  },
  {
    "function_name": "inAnyUsingClause",
    "function_signature": "static int inAnyUsingClause(\n  const char *zName, /* Name we are looking for */\n  SrcItem *pBase,    /* The base SrcItem.  Looking at pBase[1] and following */\n  int N              /* How many SrcItems to check */\n)",
    "test_filename": "tests_select_inAnyUsingClause.c"
  },
  {
    "function_name": "selectExpander",
    "function_signature": "static int selectExpander(Walker *pWalker, Select *p)",
    "test_filename": "tests_select_selectExpander.c"
  },
  {
    "function_name": "sqlite3SelectExpand",
    "function_signature": "static void sqlite3SelectExpand(Parse *pParse, Select *pSelect)",
    "test_filename": "tests_select_sqlite3SelectExpand.c"
  },
  {
    "function_name": "selectAddSubqueryTypeInfo",
    "function_signature": "static void selectAddSubqueryTypeInfo(Walker *pWalker, Select *p)",
    "test_filename": "tests_select_selectAddSubqueryTypeInfo.c"
  },
  {
    "function_name": "sqlite3SelectAddTypeInfo",
    "function_signature": "static void sqlite3SelectAddTypeInfo(Parse *pParse, Select *pSelect)",
    "test_filename": "tests_select_sqlite3SelectAddTypeInfo.c"
  },
  {
    "function_name": "sqlite3SelectPrep",
    "function_signature": "void sqlite3SelectPrep(\n  Parse *pParse,         /* The parser context */\n  Select *p,             /* The SELECT statement being coded. */\n  NameContext *pOuterNC  /* Name context for container */\n)",
    "test_filename": "tests_select_sqlite3SelectPrep.c"
  },
  {
    "function_name": "printAggInfo",
    "function_signature": "static void printAggInfo(AggInfo *pAggInfo)",
    "test_filename": "tests_select_printAggInfo.c"
  },
  {
    "function_name": "analyzeAggFuncArgs",
    "function_signature": "static void analyzeAggFuncArgs(\n  AggInfo *pAggInfo,\n  NameContext *pNC\n)",
    "test_filename": "tests_select_analyzeAggFuncArgs.c"
  },
  {
    "function_name": "optimizeAggregateUseOfIndexedExpr",
    "function_signature": "static void optimizeAggregateUseOfIndexedExpr(\n  Parse *pParse,          /* Parsing context */\n  Select *pSelect,        /* The SELECT statement being processed */\n  AggInfo *pAggInfo,      /* The aggregate info */\n  NameContext *pNC        /* Name context used to resolve agg-func args */\n)",
    "test_filename": "tests_select_optimizeAggregateUseOfIndexedExpr.c"
  },
  {
    "function_name": "aggregateIdxEprRefToColCallback",
    "function_signature": "static int aggregateIdxEprRefToColCallback(Walker *pWalker, Expr *pExpr)",
    "test_filename": "tests_select_aggregateIdxEprRefToColCallback.c"
  },
  {
    "function_name": "resetAccumulator",
    "function_signature": "static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo)",
    "test_filename": "tests_select_resetAccumulator.c"
  },
  {
    "function_name": "finalizeAggFunctions",
    "function_signature": "static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo)",
    "test_filename": "tests_select_finalizeAggFunctions.c"
  },
  {
    "function_name": "updateAccumulator",
    "function_signature": "static void updateAccumulator(\n  Parse *pParse,\n  int regAcc,\n  AggInfo *pAggInfo,\n  int eDistinctType\n)",
    "test_filename": "tests_select_updateAccumulator.c"
  },
  {
    "function_name": "explainSimpleCount",
    "function_signature": "static void explainSimpleCount(\n  Parse *pParse,                  /* Parse context */\n  Table *pTab,                    /* Table being queried */\n  Index *pIdx                     /* Index used to optimize scan, or NULL */\n)",
    "test_filename": "tests_select_explainSimpleCount.c"
  },
  {
    "function_name": "havingToWhereExprCb",
    "function_signature": "static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr)",
    "test_filename": "tests_select_havingToWhereExprCb.c"
  },
  {
    "function_name": "havingToWhere",
    "function_signature": "static void havingToWhere(Parse *pParse, Select *p)",
    "test_filename": "tests_select_havingToWhere.c"
  },
  {
    "function_name": "countOfViewOptimization",
    "function_signature": "static int countOfViewOptimization(Parse *pParse, Select *p)",
    "test_filename": "tests_select_countOfViewOptimization.c"
  },
  {
    "function_name": "sameSrcAlias",
    "function_signature": "static int sameSrcAlias(SrcItem *p0, SrcList *pSrc)",
    "test_filename": "tests_select_sameSrcAlias.c"
  },
  {
    "function_name": "fromClauseTermCanBeCoroutine",
    "function_signature": "static int fromClauseTermCanBeCoroutine(\n  Parse *pParse,          /* Parsing context */\n  SrcList *pTabList,      /* FROM clause */\n  int i,                  /* Which term of the FROM clause holds the subquery */\n  int selFlags            /* Flags on the SELECT statement */\n)",
    "test_filename": "tests_select_fromClauseTermCanBeCoroutine.c"
  },
  {
    "function_name": "existsToJoin",
    "function_signature": "static SQLITE_NOINLINE void existsToJoin(\n  Parse *pParse,  /* Parsing context */\n  Select *p,      /* The SELECT statement being optimized */\n  Expr *pWhere    /* part of the WHERE clause currently being examined */\n)",
    "test_filename": "tests_select_existsToJoin.c"
  },
  {
    "function_name": "selectCheckOnClausesExpr",
    "function_signature": "static int selectCheckOnClausesExpr(Walker *pWalker, Expr *pExpr)",
    "test_filename": "tests_select_selectCheckOnClausesExpr.c"
  },
  {
    "function_name": "selectCheckOnClausesSelect",
    "function_signature": "static int selectCheckOnClausesSelect(Walker *pWalker, Select *pSelect)",
    "test_filename": "tests_select_selectCheckOnClausesSelect.c"
  },
  {
    "function_name": "selectCheckOnClauses",
    "function_signature": "static void selectCheckOnClauses(Parse *pParse, Select *pSelect)",
    "test_filename": "tests_select_selectCheckOnClauses.c"
  },
  {
    "function_name": "sqlite3Select",
    "function_signature": "int sqlite3Select(\n  Parse *pParse,         /* The parser context */\n  Select *p,             /* The SELECT statement being coded. */\n  SelectDest *pDest      /* What to do with the query results */\n)",
    "test_filename": "tests_select_sqlite3Select.c"
  }
]