injectable_functions/expr_injectable_functions.json

[
  {
    "function_name": "sqlite3ExprAffinity",
    "function_signature": "char sqlite3ExprAffinity(const Expr *pExpr)",
    "test_filename": "tests_expr_sqlite3ExprAffinity.c"
  },
  {
    "function_name": "sqlite3ExprDataType",
    "function_signature": "int sqlite3ExprDataType(const Expr *pExpr)",
    "test_filename": "tests_expr_sqlite3ExprDataType.c"
  },
  {
    "function_name": "sqlite3CompareAffinity",
    "function_signature": "char sqlite3CompareAffinity(const Expr *pExpr, char aff2)",
    "test_filename": "tests_expr_sqlite3CompareAffinity.c"
  },
  {
    "function_name": "comparisonAffinity",
    "function_signature": "static char comparisonAffinity(const Expr *pExpr)",
    "test_filename": "tests_expr_comparisonAffinity.c"
  },
  {
    "function_name": "sqlite3IndexAffinityOk",
    "function_signature": "int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity)",
    "test_filename": "tests_expr_sqlite3IndexAffinityOk.c"
  },
  {
    "function_name": "codeCompare",
    "function_signature": "static int codeCompare(\n  Parse *pParse,    /* The parsing (and code generating) context */\n  Expr *pLeft,      /* The left operand */\n  Expr *pRight,     /* The right operand */\n  int opcode,       /* The comparison opcode */\n  int in1, int in2, /* Register holding operands */\n  int dest,         /* Jump here if true.  */\n  int jumpIfNull,   /* If true, jump if either operand is NULL */\n  int isCommuted    /* The comparison has been commuted */\n)",
    "test_filename": "tests_expr_codeCompare.c"
  },
  {
    "function_name": "sqlite3ExprVectorSize",
    "function_signature": "int sqlite3ExprVectorSize(const Expr *pExpr)",
    "test_filename": "tests_expr_sqlite3ExprVectorSize.c"
  },
  {
    "function_name": "exprVectorRegister",
    "function_signature": "static int exprVectorRegister(\n  Parse *pParse,                  /* Parse context */\n  Expr *pVector,                  /* Vector to extract element from */\n  int iField,                     /* Field to extract from pVector */\n  int regSelect,                  /* First in array of registers */\n  Expr **ppExpr,                  /* OUT: Expression element */\n  int *pRegFree                   /* OUT: Temp register to free */\n)",
    "test_filename": "tests_expr_exprVectorRegister.c"
  },
  {
    "function_name": "codeVectorCompare",
    "function_signature": "static void codeVectorCompare(\n  Parse *pParse,        /* Code generator context */\n  Expr *pExpr,          /* The comparison operation */\n  int dest,             /* Write results into this register */\n  u8 op,                /* Comparison operator */\n  u8 p5                 /* SQLITE_NULLEQ or zero */\n)",
    "test_filename": "tests_expr_codeVectorCompare.c"
  },
  {
    "function_name": "sqlite3ExprCheckHeight",
    "function_signature": "int sqlite3ExprCheckHeight(Parse *pParse, int nHeight)",
    "test_filename": "tests_expr_sqlite3ExprCheckHeight.c"
  },
  {
    "function_name": "heightOfSelect",
    "function_signature": "static void heightOfSelect(const Select *pSelect, int *pnHeight)",
    "test_filename": "tests_expr_heightOfSelect.c"
  },
  {
    "function_name": "exprSetHeight",
    "function_signature": "static void exprSetHeight(Expr *p)",
    "test_filename": "tests_expr_exprSetHeight.c"
  },
  {
    "function_name": "sqlite3ExprAttachSubtrees",
    "function_signature": "void sqlite3ExprAttachSubtrees(\n  sqlite3 *db,\n  Expr *pRoot,\n  Expr *pLeft,\n  Expr *pRight\n)",
    "test_filename": "tests_expr_sqlite3ExprAttachSubtrees.c"
  },
  {
    "function_name": "sqlite3PExprAddSelect",
    "function_signature": "void sqlite3PExprAddSelect(Parse *pParse, Expr *pExpr, Select *pSelect)",
    "test_filename": "tests_expr_sqlite3PExprAddSelect.c"
  },
  {
    "function_name": "sqlite3ExprAddFunctionOrderBy",
    "function_signature": "void sqlite3ExprAddFunctionOrderBy(\n  Parse *pParse,        /* Parsing context */\n  Expr *pExpr,          /* The function call to which ORDER BY is to be added */\n  ExprList *pOrderBy    /* The ORDER BY clause to add */\n)",
    "test_filename": "tests_expr_sqlite3ExprAddFunctionOrderBy.c"
  },
  {
    "function_name": "sqlite3ExprFunctionUsable",
    "function_signature": "void sqlite3ExprFunctionUsable(\n  Parse *pParse,         /* Parsing and code generating context */\n  const Expr *pExpr,     /* The function invocation */\n  const FuncDef *pDef    /* The function being invoked */\n)",
    "test_filename": "tests_expr_sqlite3ExprFunctionUsable.c"
  },
  {
    "function_name": "sqlite3ExprAssignVarNumber",
    "function_signature": "void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n)",
    "test_filename": "tests_expr_sqlite3ExprAssignVarNumber.c"
  },
  {
    "function_name": "sqlite3ExprDeleteNN",
    "function_signature": "static SQLITE_NOINLINE void sqlite3ExprDeleteNN(sqlite3 *db, Expr *p)",
    "test_filename": "tests_expr_sqlite3ExprDeleteNN.c"
  },
  {
    "function_name": "dupedExprStructSize",
    "function_signature": "static int dupedExprStructSize(const Expr *p, int flags)",
    "test_filename": "tests_expr_dupedExprStructSize.c"
  },
  {
    "function_name": "gatherSelectWindowsCallback",
    "function_signature": "static int gatherSelectWindowsCallback(Walker *pWalker, Expr *pExpr)",
    "test_filename": "tests_expr_gatherSelectWindowsCallback.c"
  },
  {
    "function_name": "sqlite3ExprListSetSortOrder",
    "function_signature": "void sqlite3ExprListSetSortOrder(ExprList *p, int iSortOrder, int eNulls)",
    "test_filename": "tests_expr_sqlite3ExprListSetSortOrder.c"
  },
  {
    "function_name": "sqlite3ExprListSetName",
    "function_signature": "void sqlite3ExprListSetName(\n  Parse *pParse,          /* Parsing context */\n  ExprList *pList,        /* List to which to add the span. */\n  const Token *pName,     /* Name to be added */\n  int dequote             /* True to cause the name to be dequoted */\n)",
    "test_filename": "tests_expr_sqlite3ExprListSetName.c"
  },
  {
    "function_name": "sqlite3ExprListSetSpan",
    "function_signature": "void sqlite3ExprListSetSpan(\n  Parse *pParse,          /* Parsing context */\n  ExprList *pList,        /* List to which to add the span. */\n  const char *zStart,     /* Start of the span */\n  const char *zEnd        /* End of the span */\n)",
    "test_filename": "tests_expr_sqlite3ExprListSetSpan.c"
  },
  {
    "function_name": "sqlite3ExprListCheckLength",
    "function_signature": "void sqlite3ExprListCheckLength(\n  Parse *pParse,\n  ExprList *pEList,\n  const char *zObject\n)",
    "test_filename": "tests_expr_sqlite3ExprListCheckLength.c"
  },
  {
    "function_name": "exprListDeleteNN",
    "function_signature": "static SQLITE_NOINLINE void exprListDeleteNN(sqlite3 *db, ExprList *pList)",
    "test_filename": "tests_expr_exprListDeleteNN.c"
  },
  {
    "function_name": "sqlite3ExprListFlags",
    "function_signature": "u32 sqlite3ExprListFlags(const ExprList *pList)",
    "test_filename": "tests_expr_sqlite3ExprListFlags.c"
  },
  {
    "function_name": "sqlite3ExprIdToTrueFalse",
    "function_signature": "int sqlite3ExprIdToTrueFalse(Expr *pExpr)",
    "test_filename": "tests_expr_sqlite3ExprIdToTrueFalse.c"
  },
  {
    "function_name": "exprComputeOperands",
    "function_signature": "static int exprComputeOperands(\n  Parse *pParse,     /* Parsing context */\n  Expr *pExpr,       /* The comparison expression */\n  int *pR1,          /* OUT: Register holding the left operand */\n  int *pR2,          /* OUT: Register holding the right operand */\n  int *pFree1,       /* OUT: Temp register to free if not zero */\n  int *pFree2        /* OUT: Another temp register to free if not zero */\n)",
    "test_filename": "tests_expr_exprComputeOperands.c"
  },
  {
    "function_name": "exprNodeIsConstantFunction",
    "function_signature": "static SQLITE_NOINLINE int exprNodeIsConstantFunction(\n  Walker *pWalker,\n  Expr *pExpr\n)",
    "test_filename": "tests_expr_exprNodeIsConstantFunction.c"
  },
  {
    "function_name": "exprNodeIsConstant",
    "function_signature": "static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr)",
    "test_filename": "tests_expr_exprNodeIsConstant.c"
  },
  {
    "function_name": "exprIsConst",
    "function_signature": "static int exprIsConst(Parse *pParse, Expr *p, int initFlag)",
    "test_filename": "tests_expr_exprIsConst.c"
  },
  {
    "function_name": "sqlite3ExprIsTableConstant",
    "function_signature": "static int sqlite3ExprIsTableConstant(Expr *p, int iCur, int bAllowSubq)",
    "test_filename": "tests_expr_sqlite3ExprIsTableConstant.c"
  },
  {
    "function_name": "sqlite3ExprIsSingleTableConstraint",
    "function_signature": "int sqlite3ExprIsSingleTableConstraint(\n  Expr *pExpr,                 /* The constraint */\n  const SrcList *pSrcList,     /* Complete FROM clause */\n  int iSrc,                    /* Which element of pSrcList to use */\n  int bAllowSubq               /* Allow non-correlated subqueries */\n)",
    "test_filename": "tests_expr_sqlite3ExprIsSingleTableConstraint.c"
  },
  {
    "function_name": "exprNodeIsConstantOrGroupBy",
    "function_signature": "static int exprNodeIsConstantOrGroupBy(Walker *pWalker, Expr *pExpr)",
    "test_filename": "tests_expr_exprNodeIsConstantOrGroupBy.c"
  },
  {
    "function_name": "sqlite3ExprIsConstantOrGroupBy",
    "function_signature": "int sqlite3ExprIsConstantOrGroupBy(Parse *pParse, Expr *p, ExprList *pGroupBy)",
    "test_filename": "tests_expr_sqlite3ExprIsConstantOrGroupBy.c"
  },
  {
    "function_name": "sqlite3ExprContainsSubquery",
    "function_signature": "int sqlite3ExprContainsSubquery(Expr *p)",
    "test_filename": "tests_expr_sqlite3ExprContainsSubquery.c"
  },
  {
    "function_name": "sqlite3ExprIsInteger",
    "function_signature": "int sqlite3ExprIsInteger(const Expr *p, int *pValue, Parse *pParse)",
    "test_filename": "tests_expr_sqlite3ExprIsInteger.c"
  },
  {
    "function_name": "sqlite3ExprCanBeNull",
    "function_signature": "int sqlite3ExprCanBeNull(const Expr *p)",
    "test_filename": "tests_expr_sqlite3ExprCanBeNull.c"
  },
  {
    "function_name": "sqlite3ExprNeedsNoAffinityChange",
    "function_signature": "int sqlite3ExprNeedsNoAffinityChange(const Expr *p, char aff)",
    "test_filename": "tests_expr_sqlite3ExprNeedsNoAffinityChange.c"
  },
  {
    "function_name": "sqlite3InRhsIsConstant",
    "function_signature": "static int sqlite3InRhsIsConstant(Parse *pParse, Expr *pIn)",
    "test_filename": "tests_expr_sqlite3InRhsIsConstant.c"
  },
  {
    "function_name": "sqlite3FindInIndex",
    "function_signature": "int sqlite3FindInIndex(\n  Parse *pParse,             /* Parsing context */\n  Expr *pX,                  /* The IN expression */\n  u32 inFlags,               /* IN_INDEX_LOOP, _MEMBERSHIP, and/or _NOOP_OK */\n  int *prRhsHasNull,         /* Register holding NULL status.  See notes */\n  int *aiMap,                /* Mapping from Index fields to RHS fields */\n  int *piTab                 /* OUT: index to use */\n)",
    "test_filename": "tests_expr_sqlite3FindInIndex.c"
  },
  {
    "function_name": "sqlite3VectorErrorMsg",
    "function_signature": "void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr)",
    "test_filename": "tests_expr_sqlite3VectorErrorMsg.c"
  },
  {
    "function_name": "findCompatibleInRhsSubrtn",
    "function_signature": "static int findCompatibleInRhsSubrtn(\n  Parse *pParse,          /* Parsing context */\n  Expr *pExpr,            /* IN operator with RHS that we want to reuse */\n  SubrtnSig *pNewSig      /* Signature for the IN operator */\n)",
    "test_filename": "tests_expr_findCompatibleInRhsSubrtn.c"
  },
  {
    "function_name": "sqlite3CodeRhsOfIN",
    "function_signature": "void sqlite3CodeRhsOfIN(\n  Parse *pParse,          /* Parsing context */\n  Expr *pExpr,            /* The IN operator */\n  int iTab                /* Use this cursor number */\n)",
    "test_filename": "tests_expr_sqlite3CodeRhsOfIN.c"
  },
  {
    "function_name": "sqlite3CodeSubselect",
    "function_signature": "int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr)",
    "test_filename": "tests_expr_sqlite3CodeSubselect.c"
  },
  {
    "function_name": "sqlite3ExprCheckIN",
    "function_signature": "int sqlite3ExprCheckIN(Parse *pParse, Expr *pIn)",
    "test_filename": "tests_expr_sqlite3ExprCheckIN.c"
  },
  {
    "function_name": "sqlite3ExprCodeIN",
    "function_signature": "static void sqlite3ExprCodeIN(\n  Parse *pParse,        /* Parsing and code generating context */\n  Expr *pExpr,          /* The IN expression */\n  int destIfFalse,      /* Jump here if LHS is not contained in the RHS */\n  int destIfNull        /* Jump here if the results are unknown due to NULLs */\n)",
    "test_filename": "tests_expr_sqlite3ExprCodeIN.c"
  },
  {
    "function_name": "codeInteger",
    "function_signature": "static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem)",
    "test_filename": "tests_expr_codeInteger.c"
  },
  {
    "function_name": "sqlite3ExprCodeLoadIndexColumn",
    "function_signature": "void sqlite3ExprCodeLoadIndexColumn(\n  Parse *pParse,  /* The parsing context */\n  Index *pIdx,    /* The index whose column is to be loaded */\n  int iTabCur,    /* Cursor pointing to a table row */\n  int iIdxCol,    /* The column of the index to be loaded */\n  int regOut      /* Store the index column value in this register */\n)",
    "test_filename": "tests_expr_sqlite3ExprCodeLoadIndexColumn.c"
  },
  {
    "function_name": "sqlite3ExprCodeGeneratedColumn",
    "function_signature": "void sqlite3ExprCodeGeneratedColumn(\n  Parse *pParse,     /* Parsing context */\n  Table *pTab,       /* Table containing the generated column */\n  Column *pCol,      /* The generated column */\n  int regOut         /* Put the result in this register */\n)",
    "test_filename": "tests_expr_sqlite3ExprCodeGeneratedColumn.c"
  },
  {
    "function_name": "sqlite3ExprCodeGetColumnOfTable",
    "function_signature": "void sqlite3ExprCodeGetColumnOfTable(\n  Vdbe *v,        /* Parsing context */\n  Table *pTab,    /* The table containing the value */\n  int iTabCur,    /* The table cursor.  Or the PK cursor for WITHOUT ROWID */\n  int iCol,       /* Index of the column to extract */\n  int regOut      /* Extract the value into this register */\n)",
    "test_filename": "tests_expr_sqlite3ExprCodeGetColumnOfTable.c"
  },
  {
    "function_name": "sqlite3ExprCodeGetColumn",
    "function_signature": "int sqlite3ExprCodeGetColumn(\n  Parse *pParse,   /* Parsing and code generating context */\n  Table *pTab,     /* Description of the table we are reading from */\n  int iColumn,     /* Index of the table column */\n  int iTable,      /* The cursor pointing to the table */\n  int iReg,        /* Store results here */\n  u8 p5            /* P5 value for OP_Column + FLAGS */\n)",
    "test_filename": "tests_expr_sqlite3ExprCodeGetColumn.c"
  },
  {
    "function_name": "sqlite3ExprToRegister",
    "function_signature": "void sqlite3ExprToRegister(Expr *pExpr, int iReg)",
    "test_filename": "tests_expr_sqlite3ExprToRegister.c"
  },
  {
    "function_name": "exprCodeVector",
    "function_signature": "static int exprCodeVector(Parse *pParse, Expr *p, int *piFreeable)",
    "test_filename": "tests_expr_exprCodeVector.c"
  },
  {
    "function_name": "exprCodeInlineFunction",
    "function_signature": "static int exprCodeInlineFunction(\n  Parse *pParse,        /* Parsing context */\n  ExprList *pFarg,      /* List of function arguments */\n  int iFuncId,          /* Function ID.  One of the INTFUNC_... values */\n  int target            /* Store function result in this register */\n)",
    "test_filename": "tests_expr_exprCodeInlineFunction.c"
  },
  {
    "function_name": "exprNodeCanReturnSubtype",
    "function_signature": "static int exprNodeCanReturnSubtype(Walker *pWalker, Expr *pExpr)",
    "test_filename": "tests_expr_exprNodeCanReturnSubtype.c"
  },
  {
    "function_name": "sqlite3IndexedExprLookup",
    "function_signature": "static SQLITE_NOINLINE int sqlite3IndexedExprLookup(\n  Parse *pParse,   /* The parsing context */\n  Expr *pExpr,     /* The expression to potentially bypass */\n  int target       /* Where to store the result of the expression */\n)",
    "test_filename": "tests_expr_sqlite3IndexedExprLookup.c"
  },
  {
    "function_name": "exprPartidxExprLookup",
    "function_signature": "static int exprPartidxExprLookup(Parse *pParse, Expr *pExpr, int iTarget)",
    "test_filename": "tests_expr_exprPartidxExprLookup.c"
  },
  {
    "function_name": "exprCodeTargetAndOr",
    "function_signature": "static SQLITE_NOINLINE int exprCodeTargetAndOr(\n  Parse *pParse,     /* Parsing context */\n  Expr *pExpr,       /* AND or OR expression to be coded */\n  int target,        /* Put result in this register, guaranteed */\n  int *pTmpReg       /* Write a temporary register here */\n)",
    "test_filename": "tests_expr_exprCodeTargetAndOr.c"
  },
  {
    "function_name": "sqlite3ExprCodeTarget",
    "function_signature": "int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)",
    "test_filename": "tests_expr_sqlite3ExprCodeTarget.c"
  },
  {
    "function_name": "sqlite3ExprCodeRunJustOnce",
    "function_signature": "int sqlite3ExprCodeRunJustOnce(\n  Parse *pParse,    /* Parsing context */\n  Expr *pExpr,      /* The expression to code when the VDBE initializes */\n  int regDest       /* Store the value in this register */\n)",
    "test_filename": "tests_expr_sqlite3ExprCodeRunJustOnce.c"
  },
  {
    "function_name": "sqlite3ExprNullRegisterRange",
    "function_signature": "SQLITE_NOINLINE void sqlite3ExprNullRegisterRange(\n  Parse *pParse,   /* Parsing context */\n  int iReg,        /* First register to set to NULL */\n  int nReg         /* Number of sequential registers to NULL out */\n)",
    "test_filename": "tests_expr_sqlite3ExprNullRegisterRange.c"
  },
  {
    "function_name": "sqlite3ExprCodeTemp",
    "function_signature": "int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg)",
    "test_filename": "tests_expr_sqlite3ExprCodeTemp.c"
  },
  {
    "function_name": "sqlite3ExprCode",
    "function_signature": "void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target)",
    "test_filename": "tests_expr_sqlite3ExprCode.c"
  },
  {
    "function_name": "sqlite3ExprCodeExprList",
    "function_signature": "int sqlite3ExprCodeExprList(\n  Parse *pParse,     /* Parsing context */\n  ExprList *pList,   /* The expression list to be coded */\n  int target,        /* Where to write results */\n  int srcReg,        /* Source registers if SQLITE_ECEL_REF */\n  u8 flags           /* SQLITE_ECEL_* flags */\n)",
    "test_filename": "tests_expr_sqlite3ExprCodeExprList.c"
  },
  {
    "function_name": "exprCodeBetween",
    "function_signature": "static void exprCodeBetween(\n  Parse *pParse,    /* Parsing and code generating context */\n  Expr *pExpr,      /* The BETWEEN expression */\n  int dest,         /* Jump destination or storage location */\n  void (*xJump)(Parse*,Expr*,int,int), /* Action to take */\n  int jumpIfNull    /* Take the jump if the BETWEEN is NULL */\n)",
    "test_filename": "tests_expr_exprCodeBetween.c"
  },
  {
    "function_name": "sqlite3ExprIfTrue",
    "function_signature": "void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull)",
    "test_filename": "tests_expr_sqlite3ExprIfTrue.c"
  },
  {
    "function_name": "sqlite3ExprIfFalse",
    "function_signature": "void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull)",
    "test_filename": "tests_expr_sqlite3ExprIfFalse.c"
  },
  {
    "function_name": "exprCompareVariable",
    "function_signature": "static SQLITE_NOINLINE int exprCompareVariable(\n  const Parse *pParse,\n  const Expr *pVar,\n  const Expr *pExpr\n)",
    "test_filename": "tests_expr_exprCompareVariable.c"
  },
  {
    "function_name": "sqlite3ExprCompare",
    "function_signature": "int sqlite3ExprCompare(\n  const Parse *pParse,\n  const Expr *pA,\n  const Expr *pB,\n  int iTab\n)",
    "test_filename": "tests_expr_sqlite3ExprCompare.c"
  },
  {
    "function_name": "sqlite3ExprListCompare",
    "function_signature": "int sqlite3ExprListCompare(const ExprList *pA, const ExprList *pB, int iTab)",
    "test_filename": "tests_expr_sqlite3ExprListCompare.c"
  },
  {
    "function_name": "exprImpliesNotNull",
    "function_signature": "static int exprImpliesNotNull(\n  const Parse *pParse,/* Parsing context */\n  const Expr *p,      /* The expression to be checked */\n  const Expr *pNN,    /* The expression that is NOT NULL */\n  int iTab,           /* Table being evaluated */\n  int seenNot         /* Return true only if p can be any non-NULL value */\n)",
    "test_filename": "tests_expr_exprImpliesNotNull.c"
  },
  {
    "function_name": "sqlite3ExprIsIIF",
    "function_signature": "static int sqlite3ExprIsIIF(sqlite3 *db, const Expr *pExpr)",
    "test_filename": "tests_expr_sqlite3ExprIsIIF.c"
  },
  {
    "function_name": "sqlite3ExprImpliesExpr",
    "function_signature": "int sqlite3ExprImpliesExpr(\n  const Parse *pParse,\n  const Expr *pE1,\n  const Expr *pE2,\n  int iTab\n)",
    "test_filename": "tests_expr_sqlite3ExprImpliesExpr.c"
  },
  {
    "function_name": "impliesNotNullRow",
    "function_signature": "static int impliesNotNullRow(Walker *pWalker, Expr *pExpr)",
    "test_filename": "tests_expr_impliesNotNullRow.c"
  },
  {
    "function_name": "sqlite3ExprImpliesNonNullRow",
    "function_signature": "int sqlite3ExprImpliesNonNullRow(Expr *p, int iTab, int isRJ)",
    "test_filename": "tests_expr_sqlite3ExprImpliesNonNullRow.c"
  },
  {
    "function_name": "exprIdxCover",
    "function_signature": "static int exprIdxCover(Walker *pWalker, Expr *pExpr)",
    "test_filename": "tests_expr_exprIdxCover.c"
  },
  {
    "function_name": "sqlite3ExprCoveredByIndex",
    "function_signature": "int sqlite3ExprCoveredByIndex(\n  Expr *pExpr,        /* The index to be tested */\n  int iCur,           /* The cursor number for the corresponding table */\n  Index *pIdx         /* The index that might be used for coverage */\n)",
    "test_filename": "tests_expr_sqlite3ExprCoveredByIndex.c"
  },
  {
    "function_name": "selectRefEnter",
    "function_signature": "static int selectRefEnter(Walker *pWalker, Select *pSelect)",
    "test_filename": "tests_expr_selectRefEnter.c"
  },
  {
    "function_name": "exprRefToSrcList",
    "function_signature": "static int exprRefToSrcList(Walker *pWalker, Expr *pExpr)",
    "test_filename": "tests_expr_exprRefToSrcList.c"
  },
  {
    "function_name": "sqlite3ReferencesSrcList",
    "function_signature": "int sqlite3ReferencesSrcList(Parse *pParse, Expr *pExpr, SrcList *pSrcList)",
    "test_filename": "tests_expr_sqlite3ReferencesSrcList.c"
  },
  {
    "function_name": "agginfoPersistExprCb",
    "function_signature": "static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr)",
    "test_filename": "tests_expr_agginfoPersistExprCb.c"
  },
  {
    "function_name": "addAggInfoColumn",
    "function_signature": "static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo)",
    "test_filename": "tests_expr_addAggInfoColumn.c"
  },
  {
    "function_name": "addAggInfoFunc",
    "function_signature": "static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo)",
    "test_filename": "tests_expr_addAggInfoFunc.c"
  },
  {
    "function_name": "findOrCreateAggInfoColumn",
    "function_signature": "static void findOrCreateAggInfoColumn(\n  Parse *pParse,       /* Parsing context */\n  AggInfo *pAggInfo,   /* The AggInfo object to search and/or modify */\n  Expr *pExpr          /* Expr describing the column to find or insert */\n)",
    "test_filename": "tests_expr_findOrCreateAggInfoColumn.c"
  },
  {
    "function_name": "analyzeAggregate",
    "function_signature": "static int analyzeAggregate(Walker *pWalker, Expr *pExpr)",
    "test_filename": "tests_expr_analyzeAggregate.c"
  },
  {
    "function_name": "sqlite3ExprAnalyzeAggregates",
    "function_signature": "void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr)",
    "test_filename": "tests_expr_sqlite3ExprAnalyzeAggregates.c"
  },
  {
    "function_name": "sqlite3GetTempRange",
    "function_signature": "int sqlite3GetTempRange(Parse *pParse, int nReg)",
    "test_filename": "tests_expr_sqlite3GetTempRange.c"
  },
  {
    "function_name": "sqlite3ReleaseTempRange",
    "function_signature": "void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg)",
    "test_filename": "tests_expr_sqlite3ReleaseTempRange.c"
  },
  {
    "function_name": "sqlite3FirstAvailableRegister",
    "function_signature": "int sqlite3FirstAvailableRegister(Parse *pParse, int iMin)",
    "test_filename": "tests_expr_sqlite3FirstAvailableRegister.c"
  },
  {
    "function_name": "sqlite3NoTempsInRange",
    "function_signature": "int sqlite3NoTempsInRange(Parse *pParse, int iFirst, int iLast)",
    "test_filename": "tests_expr_sqlite3NoTempsInRange.c"
  }
]