Lines Matching refs:column
1442 ** [sqlite3_column_text()], one for each column. ^If an element of a
1446 ** entry represents the name of corresponding result column as obtained
3073 ** of a table column that its values are likely to be very large - larger
3075 ** is stored in each sorted record and the required column values loaded
3442 ** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
3444 ** the table has a column of type [INTEGER PRIMARY KEY] then that column
4058 ** a NULL value in place of the table column that would have
4062 ** ^When a table is referenced by a [SELECT] but no column values are
4065 ** is invoked once for that table with a column name that is an empty string.
5114 ** or [GLOB] operator or if the parameter is compared to an indexed column
5586 ** ^These routines return the name assigned to a particular column
5592 ** column number. ^The leftmost column is number 0.
5598 ** sqlite3_column_name() or sqlite3_column_name16() on the same column.
5604 ** ^The name of a result column is the value of the "AS" clause for
5605 ** that column, if there is an AS clause. If there is no AS clause
5606 ** then the name of the column is unspecified and may change from
5617 ** table column that is the origin of a particular result column in
5619 ** ^The name of the database or table or column can be returned as
5622 ** the origin_ routines return the column name.
5630 ** database, table, and column.
5633 ** ^These functions return information about the Nth result column returned by
5635 ** ^The left-most column is column 0 for these routines.
5637 ** ^If the Nth column returned by the statement is an expression or
5638 ** subquery and is not a column value, then all of these functions return
5641 ** or column that query result column was extracted from.
5650 ** [sqlite3_column_database_name | column metadata interfaces]
5651 ** for the same [prepared statement] and result column
5666 ** If this statement is a [SELECT] statement and the Nth column of the
5667 ** returned result set of that [SELECT] is a table column (not an
5669 ** column is returned.)^ ^If the Nth column of the result set is an
5682 ** column (i==1), and a NULL pointer for the first result column (i==0).)^
5684 ** ^SQLite uses dynamic run-time typing. ^So just because a column
5686 ** data stored in that column is of the declared type. SQLite is
5731 ** caller. The values may be accessed using the [column access functions].
5833 ** KEYWORDS: {column access functions}
5858 ** ^These routines return information about a single column of the current
5862 ** and the second argument is the index of the column for which information
5863 ** should be returned. ^The leftmost column of the result set has the index 0.
5868 ** column index is out of range, the result is undefined.
5880 ** each return the value of a result column in a specific data format. If
5881 ** the result column is not initially in the requested format (for example,
5887 ** of the result column. ^The returned value is one of [SQLITE_INTEGER],
5890 ** of the first six interface should be used to extract the column value.
6034 ** routines is the same as if the column had contained an SQL NULL value.
6164 ** within VIEWs, TRIGGERs, CHECK constraints, generated column expressions,
6405 ** <td>→ <td>True if the column is unchanged in an UPDATE
6422 ** ^These routines work just like the corresponding [column access functions]
6424 ** pointer instead of a [sqlite3_stmt*] pointer and an integer column number.
6459 ** the column corresponding to X is unchanged by the UPDATE operation
6462 ** the value for that column returned without setting a result (probably
6463 ** because it queried [sqlite3_vtab_nochange()] and found that the column
6472 ** interfaces. ^If X comes from an SQL literal value, or a table column,
6500 ** routines is the same as if the column had contained an SQL NULL value.
7593 ** information about column C of table T in database D
7597 ** column exists. ^The sqlite3_table_column_metadata() interface returns
7598 ** SQLITE_ERROR if the specified column does not exist.
7599 ** ^If the column-name parameter to sqlite3_table_column_metadata() is a
7606 ** ^The column is identified by the second, third and fourth parameters to
7613 ** ^The third and fourth parameters to this function are the table and column
7614 ** name of the desired column, respectively.
7626 ** <tr><td> 7th <td> int <td> True if column has a NOT NULL constraint
7627 ** <tr><td> 8th <td> int <td> True if column is part of the PRIMARY KEY
7628 ** <tr><td> 9th <td> int <td> True if column is [AUTOINCREMENT]
7638 ** ^If the specified column is "rowid", "oid" or "_rowid_" and the table
7640 ** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output
7641 ** parameters are set for the explicitly declared column. ^(If there is no
7642 ** [INTEGER PRIMARY KEY] column, then the outputs
7665 int *pPrimaryKey, /* OUTPUT: True if column part of PK */
7666 int *pAutoinc /* OUTPUT: True if column is auto-increment */
7889 ** <blockquote>column OP expr</blockquote>
7894 ** ^(The index of the column is stored in
7899 ** ^The optimizer automatically inverts terms of the form "expr OP column"
7906 ** ^Each term of aOrderBy records a column of the ORDER BY clause.
7912 ** the corresponding bit is set within the colUsed mask if the column may be
7913 ** required by SQLite. If the table has at least 64 columns and any column
7915 ** set. In other words, column iCol may be required if the expression
8212 ** in row iRow, column zColumn, table zTable in database zDb;
8242 ** <li> ^(The specified column of row iRow contains a value that is not
8247 ** column zColumn is part of a [child key] definition and the blob is
8259 ** interface. However, the column, table, or database of a [BLOB handle]
8265 ** This is true if any column of the row is changed, even a column
8306 ** changed. ^The database, table and column on which the blob handle is open
8312 ** the nominated column.)^ ^If the new row is not present in the table, or if
10326 ** column is being fetched as part of an UPDATE operation during which the
10327 ** column value will not change. The virtual table implementation can use
10333 ** the column is not changed by the UPDATE statement, then the xColumn
10337 ** same column in the [xUpdate] method.
10423 ** The select-id is the same value as is output in the first column
10574 ** a [protected sqlite3_value] that contains the value of the Nth column of
10583 ** a [protected sqlite3_value] that contains the value of the Nth column of
11225 ** KEY may consist of a single column, or may be a composite key.
11307 ** column. It is not possible for an UPDATE change to represent a change that
11342 ** It also records the original primary key and other column values of any
11673 ** 0x01 if the corresponding column is part of the tables primary key, or
11741 ** a new value for the requested column, *ppValue is set to NULL and
11997 ** If one or more of the column values in the row inserted by the
12815 ** the total number of tokens in column iCol, considering all rows in
12830 ** *pnToken to the number of tokens in column iCol of the current row.
12841 ** This function attempts to retrieve the text of column iCol of the
12861 ** "detail=none" or "detail=column" option. If the FTS5 table is created
12862 ** with either "detail=none" or "detail=column" and "content=" option
12872 ** to the column in which it occurs and *piOff the token offset of the
12877 ** "detail=none" or "detail=column" option.
12892 ** current query is executed. Any column filter that applies to
12967 ** // An instance of phrase iPhrase at offset iOff of column iCol
12976 ** "detail=none" or "detail=column" option. If the FTS5 table is created
12977 ** with either "detail=none" or "detail=column" and "content=" option
13010 ** "detail=column" tables.
15295 ** column of the b-tree of the cursor. The Expr tree will not contain
16802 ** DB_UnresetViews means that one or more views have column names that
16803 ** have been filled out. If the schema changes, these column names might
16807 #define DB_UnresetViews 0x0002 /* Some views have defined column names */
17013 /* name of the column being dropped */
17131 #define SQLITE_FullColNames 0x00000004 /* Show full column names on SELECT */
17476 ** Information about each column of an SQL table is held in an instance
17481 ** "table column index" This is the index of the column in the
17483 ** the column in the original CREATE TABLE stmt.
17485 ** "storage column index" This is the index of the column in the
17487 ** opcode. The storage column index is less than
17488 ** or equal to the table column index. It is
17493 char *zName; /* Name of this column, \000, then the type */
17498 u8 szEst; /* Estimated size of value in this column. sizeof(INT)==1 */
17511 #define COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */
17512 #define COLFLAG_HASTYPE 0x0004 /* Type name follows column name */
17514 #define COLFLAG_SORTERREF 0x0010 /* Use sorter-refs with this column */
17517 #define COLFLAG_NOTAVAIL 0x0080 /* STORED column not yet calculated */
17655 Column *aCol; /* Information about each column */
17659 char *zColAff; /* String defining the affinity of each column */
17661 /* ... also used as column name list in a VIEW */
17675 int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */
17691 ** vtab1(a HIDDEN, b);". Since "b" is a non-hidden column but "a" is hidden,
17712 #define TF_NoVisibleRowid 0x0200 /* No user-visible "rowid" column */
17734 ** Macros to determine if a column is hidden. IsOrdinaryHiddenColumn()
17795 int iFrom; /* Index of column in pFrom */
17796 char *zCol; /* Name of column in zTo. If NULL use PRIMARY KEY */
17860 u8 *aSortFlags; /* Sort order for each column. */
17932 ** first column to be indexed (c3) has an index of 2 in Ex1.aCol[].
17933 ** The second column to be indexed (c1) has an index of 0 in
17954 LogEst *aiRowLogEst; /* From ANALYZE: Est. rows selected by each column */
17956 char *zColAff; /* String defining the affinity of each column */
17959 u8 *aSortOrder; /* for each column: True==DESC, False==ASC */
18006 #define XN_ROWID (-1) /* Indexed column is the rowid */
18007 #define XN_EXPR (-2) /* Indexed column is an expression */
18066 struct AggInfo_col { /* For each column used in source tables */
18130 ** An expression of the form ID or ID.ID refers to a column in a table.
18133 ** Expr.iColumn is the column number for the specific column. If the
18135 ** value is also stored in the Expr.iAgg column in the aggregate so that
18203 int iTable; /* TK_COLUMN: cursor number of table holding column
18210 ynVar iColumn; /* TK_COLUMN: column index. -1 for rowid.
18212 ** TK_SELECT_COLUMN: column of the result vector */
18217 Table *pTab; /* TK_COLUMN: Table containing column. Can be NULL
18218 ** for a column of an index on an expression */
18344 ** ENAME_NAME (1) the AS of result set column
18366 u16 iOrderByCol; /* For ORDER BY, column number in result set */
18390 ** column names after a table name in an INSERT statement. In the statement
18394 ** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.
18399 int idx; /* Index in some Table.aCol[] of a column named zName */
18432 Bitmask colUsed; /* Bit N (1<<N) set if column N of pTab is used */
18460 ** contains more than 63 columns and the 64-th or later column is used.
18514 ** A NameContext defines a context in which to resolve table and column
18588 ** pUpsertSet is the list of column=expr terms of the UPDATE statement.
18711 ** SRT_Mem Only valid if the result is a single column.
18712 ** Store the first column of the first result row
18716 ** SRT_Set The result must be a single column. Store each
18755 ** column returned by the SELECT is used as the integer
19092 IdList *pColumns; /* If this is an UPDATE OF <column-list> trigger,
19093 the <column-list> is stored here */
19130 * pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ...
19131 * statement, then this stores the column-names to be
19317 struct SrcCount *pSrcCount; /* Counting column references */
19319 int *aiCol; /* array of column indexes */
19321 struct IdxExprTrans *pIdxTrans; /* Convert idxed expr to column */
19327 struct Table *pTab; /* Table of generated column */
19377 ExprList *pCols; /* List of explicit column names, or NULL */
19429 u8 bLine[100]; /* Draw vertical in column i if bLine[i] is true */
21079 u32 *aAltMap; /* Mapping from table to index column numbers */
23179 ** are included instead. This is to support column declarations that
30311 ** emulate collation associated with a table column. These show
30412 ** to a column in the new.* or old.* pseudo-tables available to
30415 ** is set to the column of the pseudo-table to read, or to -1 to
31570 ** Return the declared type of a column. Or return zDflt if the column
31573 ** The column type is an extra string stored after the zero-terminator on
31574 ** the column name if and only if the COLFLAG_HASTYPE flag is set.
64820 ** a statement since we will be comparing table and column names
73134 ** and WITHOUT ROWID tables with exactly one column which is the
77972 ** on a table column definition, and hence only when pCtx==0. This
78194 ** corresponding column within index pIdx is applied to it. Before
78262 ** Extract the iCol-th column from the nRec-byte record in pRec. Write
78263 ** the column value into *ppVal. If *ppVal is initially NULL then a new
78276 u32 t = 0; /* a column type code */
78727 ** while computing a generated column value. 0 is the usual case.
79936 ** that can be displayed in the P4 column of EXPLAIN output.
80972 ** Set the name of the idx'th column to be returned by the SQL statement.
80983 int idx, /* Index of column zName applies to */
83507 zContext = "a generated column";
83947 /* Return true if a parameter to xUpdate represents an unchanged column */
84448 ** UPDATE operation and the value of the column will not be modified
84457 ** value, as a signal to the xUpdate routine that the column is unchanged.
84677 ** Check to see if column iCol of the given statement is valid. If
84678 ** it is, return a pointer to the Mem for the value of that column.
84701 ** column value (i.e. a value returned by evaluating an SQL expression in the
84803 ** There are up to 5 names for each column. useType determines which
84806 ** 0 The column name as it should be displayed for output
84807 ** 1 The datatype name for the column
84808 ** 2 The name of the database that the column derives from
84809 ** 3 The name of the table that the column derives from
84810 ** 4 The name of the table column that the result column derives from
84812 ** If the result is not a simple column reference (if it is an expression
84817 int N, /* Which column to get the name for */
84861 ** Return the name of the Nth column of the result set returned by SQL
84884 ** Return the column declaration type (if applicable) of the 'i'th column
84899 ** Return the name of the database from which a result column derives.
84900 ** NULL is returned if the result column is an expression or constant or
84901 ** anything else which is not an unambiguous reference to a database column.
84913 ** Return the name of the table from which a result column derives.
84914 ** NULL is returned if the result column is an expression or constant or
84915 ** anything else which is not an unambiguous reference to a database column.
84927 ** Return the name of the table column from which a result column derives.
84928 ** NULL is returned if the result column is an expression or constant or
84929 ** anything else which is not an unambiguous reference to a database column.
84948 ** the same as binding a NULL value to the column. If the "i" parameter is
86276 ** Try to convert the type of a function argument or a result column
87829 ** This opcode is used when extracting information from a column that
87830 ** has REAL affinity. Such column values may still be stored as
88509 ** P2 is the column number for the argument to the sqlite_offset() function.
88536 ** information about the format of the data.) Extract the P2-th column
88552 u32 p2; /* column number to retrieve */
88555 u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */
88556 int len; /* The length of the serialized data for the column */
88739 /* Extract the content for the p2+1-th column. Control can only
88757 /* If the column value is a string, we need a persistent value, not
88825 ** string indicates the column affinity that should be used for the N-th
88874 ** string indicates the column affinity that should be used for the N-th
88964 ** index of the right-most column with a non-NULL default value */
89006 ** computing an unchanging column value in an UPDATE statement.
89147 ** additional varints, one per column. */
89149 /* EVIDENCE-OF: R-64536-51728 The values for each column in the record
90068 ** by the cursor. The high-order bit is set if any column after
90376 ** This opcode helps to optimize IN operators on a multi-column index
90601 ** This opcode is used in IN clause processing for a multi-column key.
91322 ** Then clear the column header cache on cursor P3.
91327 ** parameter P3. Clearing the P3 column cache as part of this opcode saves
91898 ** one entry for each column in the P3 table. If array entry a(i)
91899 ** is non-zero, then reading column a(i)-1 from cursor P3 is
91900 ** equivalent to performing the deferred seek and then reading column i
93561 ** Store in register P3 the value of the P2-th column of
93565 ** an unchanging column during an UPDATE operation, then the P5
93568 ** table implementation. The P5 column might also contain other
94264 u16 iCol; /* Table column this handle is open on */
94280 ** contain a value of type TEXT or BLOB in the column nominated when the
94359 const char *zColumn, /* The column containing the blob */
94424 /* Now search pTab for the exact column. */
94432 zErr = sqlite3MPrintf(db, "no such column: \"%s\"", zColumn);
94439 ** column is not indexed, and that it is not part of a foreign key.
94446 /* Check that the column is not part of an FK child key definition. It
94472 zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault);
94543 ** think that the table has one more column than it really
94544 ** does. An OP_Column to retrieve this imaginary column will
94652 ** slightly more efficient). Since you cannot write to a PK column
97709 int i /* Which column to return */
98642 ** table and column.
98677 ** Turn the pExpr expression into an alias for the iCol-th column of the
98698 int iCol, /* A column in the result set. 0..pEList->nExpr-1 */
98702 Expr *pOrig; /* The iCol-th column of the result set */
98761 ** Subqueries stores the original database, table and column names for their
98836 ** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up
98838 ** expression node refer back to that source column. The following changes
98847 ** pExpr->iColumn Set to the column number within the table.
98865 const char *zTab, /* Name of table containing column, or NULL */
98866 const char *zCol, /* Name of the column. */
98868 Expr *pExpr /* Make this EXPR node point to the selected column */
98871 int cnt = 0; /* Number of matching column names */
98881 Column *pCol; /* A column of pTab */
98976 /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */
99122 ** The ability to use an output result-set column in the WHERE, GROUP BY,
99180 ** If X and Y are NULL (in other words if only the column name Z is
99182 ** Z is a string literal if it doesn't match any column names. In that
99195 /* If a double-quoted identifier does not match any known column name,
99212 ** the name of the column being dropped.
99234 zErr = cnt==0 ? "no such column" : "ambiguous column name";
99246 /* If a column from a table in pSrcList is referenced, then record
99249 ** set if the 63rd or any subsequent column is used.
99254 ** avoid setting bits beyond the maximum column number of the table.
99257 ** If a generated column is referenced, set bits for every column
99299 ** Allocate and return a pointer to an expression to load the column iCol
99411 ** column in the FROM clause. This is used by the LIMIT and ORDER BY
99437 ** to the state they where in before the "column" LHS expression was
99438 ** resolved. This prevents "column" from being counted as having been
99469 /* A column name: ID
99470 ** Or table name and column name: ID.ID
99471 ** Or a database, table and column: ID.ID.ID
99590 ** in an index or generated column. Curiously, they can be used
99864 ** SELECT statement. Return the index i of the matching column,
99865 ** as an indication to the caller that it should sort by the i-th column.
99866 ** The left-most column is 1. In other words, the value returned is the
99868 ** the column.
99941 ** the integer column number.
100000 ** case. This allows the code in alter.c to modify column
100017 /* Convert the ORDER BY term into an integer column number iCol,
100046 "column in the result set", i+1);
100058 ** column.
100163 /* If an AS-name match is found, mark this ORDER BY column as being
100164 ** a copy of the iCol-th result-set column. The subsequent call to
100172 /* The ORDER BY term is an integer constant. Again, set the column
100287 ** context containing the column when it resolves a name. */
100325 /* Add the output column list to the name-context before parsing the
100455 ** Z: The name of a column in table Y.
100461 ** Expr.iColumn The column index in X.Y. -1 for the rowid.
100612 ** set to the column number. In case (4), TK_COLUMN nodes cause an error.
100674 ** Return the affinity character for a single column of a table.
100684 ** If pExpr is a column, a reference to a column via an 'AS' alias,
100685 ** or a sub-select with a column as the return value, then the
100686 ** affinity of that column is returned. Otherwise, 0x00 is returned,
100819 ** or by the presence of a column with a defined collating sequence.
100928 /* One side is a column, the other is not. Use the columns affinity. */
100957 ** idx_affinity is the affinity of an indexed column. Return true
101097 ** column of the vector (numbered starting with 0). The caller must
101101 ** that return a single column!) then return pVector unmodified.
101126 ** the iField-th column of the vector expression pVector.
101147 int iField /* Which column of the vector to return */
101156 ** iColumn: Index of a column in pVector
101185 ** sub-select returns more than one column, the first in an array
101202 ** or TK_SELECT that returns more than one column. This function returns
102871 ** Walk an expression tree for the DEFAULT field of a column definition
102981 p->y.pTab==0 || /* Reference to column of index on expression */
103034 ** Return TRUE if the given string is a row-id column name.
103091 ** Generate code that checks the left-most column of index table iCur to see if
103171 ** be used unless <columns> is a single INTEGER PRIMARY KEY column or an
103195 ** one element for each column returned by the SELECT statement on the RHS
103197 ** offset of the index column that matches the i'th column returned by the
103277 ** comparison is the same as the affinity of each column in table
103306 Bitmask mCol; /* Mask for the current column */
103340 if( mCol & colUsed ) break; /* Each column used only once */
103424 ** the affinities to be used for each column of the comparison.
103506 ** If the LHS expression ("x" in the examples) is a column value, or
103507 ** the SELECT statement returns a column value, then the affinity of that
103508 ** column is used to build the index keys. If both 'x' and the
103510 ** if either column has NUMERIC or INTEGER affinity. If neither
103629 ** store it in the temporary table. If <expr> is a column, then use
103631 ** a column, use numeric affinity.
103696 ** Return the register that holds the result. For a multi-column SELECT,
103698 ** return value is the register of the left-most result column.
103869 int *aiMap = 0; /* Map from vector field to index column */
104167 ** appropriate for the iIdxCol-th column of index pIdx.
104171 Index *pIdx, /* The index whose column is to be loaded */
104173 int iIdxCol, /* The column of the index to be loaded */
104174 int regOut /* Store the index column value in this register */
104191 ** Generate code that will compute the value of generated column pCol
104217 ** Generate code to extract the value of the iCol-th column of a table.
104223 int iCol, /* Index of the column to extract */
104244 sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pCol->zName);
104270 ** Generate code that will extract the iColumn-th column from
104271 ** table pTab and store the column value in register iReg.
104279 int iColumn, /* Index of the table column */
104534 ** datatype by applying the Affinity of the table column to the
104559 ** immediately prior to the first column.
104577 sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"",
104597 /* Coding an expression that is part of an index where column names
104882 /* For length() and typeof() functions with a column argument,
104908 ** a virtual table column.
104912 ** see if it is a column in a virtual table. This is done because
105019 ** to a column in the new.* or old.* pseudo-tables available to
105022 ** is set to the column of the pseudo-table to read, or to -1 to
105027 ** to reference another column of the old.* pseudo-table, where
105028 ** i is the index of the column. For a new.rowid reference, p1 is
105030 ** For a reference to any other column in the new.* pseudo-table, p1
105060 /* If the column has REAL affinity, it may currently be stored as an
106153 ** have one or more non-NULL column, then set pWalker->eCode to 1 and abort.
106211 ** is the column of a virtual table */
106244 ** one column of table iTab is non-null. In other words, return true
106245 ** if expression p will always be NULL or false if every column of iTab
106249 ** zero even if expression p will never be true of every column of iTab
106260 ** clause requires that some column of the right table of the LEFT JOIN
106530 /* Check to see if the column is in one of the tables in the FROM
106541 ** Make an entry for the column in pAggInfo->aCol[] if there
106827 const char *zDropColumn /* Name of column being dropped */
107057 ** column definition.
107060 ** the new column during parsing.
107068 char *zCol; /* Null-terminated column definition */
107069 Column *pCol; /* The new column */
107070 Expr *pDflt; /* Default value for the new column */
107097 /* Check that the new column is not specified as PRIMARY KEY or UNIQUE.
107099 ** column must not be NULL.
107102 sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column");
107107 "Cannot add a UNIQUE column");
107111 /* If the default value for the new column was specified with a
107121 "Cannot add a REFERENCES column with non-NULL default value");
107125 "Cannot add a NOT NULL column with default value NULL");
107143 "Cannot add a column with non-constant default");
107148 sqlite3ErrorIfNotEmpty(pParse, zDb, zTab, "cannot add a STORED column");
107202 ** to it. Routines called by the parser as the column definition
107234 sqlite3ErrorMsg(pParse, "Cannot add a column to a view");
107306 (bDrop ? "drop column from" : "rename columns of"),
107325 Token *pOld, /* Name of column being changed */
107326 Token *pNew /* New column name */
107330 int iCol; /* Index of column being renamed */
107331 char *zOld = 0; /* Old column name */
107332 char *zNew = 0; /* New column name */
107357 /* Make sure the old name really is a column name in the table to be
107358 ** altered. Set iCol to be the index of the column being renamed */
107365 sqlite3ErrorMsg(pParse, "no such column: \"%s\"", zOld);
107413 ** * The name of a table column in Column.zName
107438 int iCol; /* Index of column being renamed */
107440 const char *zOld; /* Old column name */
107694 ** if the column being references is the column being renamed by an
107716 ** The RenameCtx contains a list of tokens that reference a column that
107721 ** return all column name tokens in the order that they are encountered
107823 const char *zDropColumn /* Name of column being dropped */
107897 ** quoted version of the new column name. */
107911 ** with the new column name. All that remains is to construct and
108111 ** 5. iCol: Index of column to rename
108112 ** 6. zNew: New column name
108113 ** 7. bQuote: Non-zero if the new column name should be quoted.
108116 ** Do a column rename operation on the CREATE statement given in zSql.
108117 ** The iCol-th column (left-most is 0) of table zTable is renamed from zCol
108487 ** 6: Name of column being dropped, or NULL.
108557 ** argv[2]: An integer - the index of the column to remove.
108560 ** with column argv[2] removed.
108624 ** table being edited, and token pName the name of the column to drop.
108631 char *zCol = 0; /* Name of column to drop */
108632 int iCol; /* Index of column zCol in pTab->aCol[] */
108646 /* Find the index of the column being dropped. */
108654 sqlite3ErrorMsg(pParse, "no such column: \"%s\"", zCol);
108658 /* Do not allow the user to drop a PRIMARY KEY column or a column
108661 sqlite3ErrorMsg(pParse, "cannot drop %s column: \"%s\"",
108670 sqlite3ErrorMsg(pParse, "cannot drop column \"%s\": no other columns exist",zCol);
108688 renameTestSchema(pParse, zDb, iDb==1, "after drop column", zCol);
108811 ** name in the idx column. The tbl column is the name of the table to
108812 ** which the index belongs. In each such row, the stat column will be
108817 ** value in the first column of the index. The third integer is the average
108821 ** a K-column index, there will be K+1 integers in the stat column. If
108824 ** The list of integers in the stat column can optionally be followed
108830 ** If the sqlite_stat1.idx column is NULL, then the sqlite_stat1.stat
108831 ** column contains a single integer which is the (estimated) number of
108840 ** the "idx" column and the "tbl" column is the name of the table to which
108874 ** The idx column names the index and the tbl column is the table of the
108876 ** of the INTEGER PRIMARY KEY. The sample column is a blob which is the
108877 ** binary encoding of a key from the index. The nEq column is a
108879 ** of entries in the index whose left-most column exactly matches
108880 ** the left-most column of the sample. The second integer in nEq
108886 ** left-most column is less than the left-most column of the sample.
108889 ** sample. The nDLt column is like nLt except that it contains the
108902 ** looks at the left-most column of the index. The sqlite_stat3.sample
108903 ** column contains the actual value of the left-most column instead
109269 ** the same column (pNew->iCol==pOld->iCol). Ignoring this column and
109273 ** column for pNew and pOld are equal, is pNew to be preferred over pOld.
109342 /* This sample is being added because the prefix that ends in column
109381 /* The "rows less-than" for the rowid column must be greater than that
109455 ** C Index of left-most column to differ from previous row
109556 #define STAT_GET_STAT1 0 /* "stat" column of stat1 table */
109557 #define STAT_GET_ROWID 1 /* "rowid" column of stat[34] entry */
109558 #define STAT_GET_NEQ 2 /* "neq" column of stat[34] entry */
109559 #define STAT_GET_NLT 3 /* "nlt" column of stat[34] entry */
109560 #define STAT_GET_NDLT 4 /* "ndlt" column of stat[34] entry */
109601 /* Return the value to store in the "stat" column of the sqlite_stat1
109607 ** for each indexed column. This additional integer is an estimate of
109723 ** of the k-th column of the pIdx index.
109727 Index *pIdx, /* Index whose column is being loaded */
109728 int k /* Which column index */
109730 int i; /* Index of column in the table */
109774 int regStat1 = iMem++; /* Value for the stat column of sqlite_stat1 */
109884 ** when building a record to insert into the sample column of
109951 /* For a single-column UNIQUE index, once we have found a non-NULL
110310 ** argv[2] = results of analysis - on integer for each column
110438 ** the nEq values for column iCol for the same set (adding the value
110733 ** identifiers are treated as strings, not possible column names or aliases.
111367 ** the table and the column that are being accessed. The auth function
111372 ** should run but attempts to read the specified column will return NULL
111373 ** and attempts to write the column will be ignored.
111404 ** Invoke the authorization callback for permission to read column zCol from
111442 ** Check to see if it is OK to read this particular column.
111455 const char *zCol; /* Name of the column of the table */
111458 int iCol; /* Index of column in table */
111465 /* An attempt to read a column out of a subquery or other
112238 ** Delete memory allocated for the column names of a table or view (the
112537 ** Convert an table column number into a index column number. That is,
112538 ** for the column iCol in the table (as defined by the CREATE TABLE statement)
112539 ** find the (first) offset of that column in index pIdx. Or return -1
112540 ** if column iCol is not used in index pIdx.
112551 /* Convert a storage column number into a table column number.
112553 ** The storage column number (0,1,2,....) is the index of the value
112554 ** as it appears in the record on disk. The true column number
112555 ** is the index (0,1,2,...) of the column in the CREATE TABLE statement.
112557 ** The storage column number is less than the table column number if
112574 /* Convert a table column number into a storage column number.
112576 ** The storage column number (0,1,2,....) is the index of the value
112577 ** as it appears in the record on disk. Or, if the input column is
112578 ** the N-th virtual column (zero-based) then the storage number is
112581 ** The true column number is the index (0,1,2,...) of the column in
112584 ** If the input column is a VIRTUAL column, then it should not appear
112587 ** avoids computing the same VIRTUAL column multiple times, and provides
112589 ** input column is a VIRTUAL table, put it after all the other columns.
112591 ** In the following, N means "normal column", S means STORED, and
112608 ** is negative (indicating the ROWID column) then this routine return iCol.
112619 /* iCol is a virtual column itself */
112622 /* iCol is a normal or stored column */
112711 ** to an sqlite3_declare_vtab() call. In that case only the column names
112839 /* Set properties of a table column based on the (magical)
112840 ** name of the column.
112927 ** Add a new column to the table currently being constructed.
112929 ** The parser calls this routine once for each column declaration
112932 ** column.
112957 sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
113003 ** been seen on a column. This routine sets the notNull flag on
113004 ** the column currently under construction.
113016 ** on this column. */
113029 ** Scan the column type name zType (length nType) and return the
113121 ** The expression is the default value for the most recently added column
113144 sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
113150 sqlite3ErrorMsg(pParse, "cannot use DEFAULT on a generated column");
113176 ** Historical versions of SQLite accepted strings as column names in
113198 ** Tag the given column as being part of the PRIMARY KEY
113215 ** most recently added column of the table is the primary key.
113221 ** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
113222 ** then we will try to use that column as the rowid. Set the Table.iPKey
113224 ** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is
113336 ** Set the collation function of the most recently parsed table column
113356 /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
113357 ** then an index may have been created on this column before the
113371 /* Change the most recently parsed column to be a GENERATED ALWAYS AS
113372 ** column.
113380 /* generated column in an CREATE TABLE IF NOT EXISTS that already exists */
113411 sqlite3ErrorMsg(pParse, "error in generated column \"%s\"",
113628 /* Return true if column number x is any of the first nCol entries of aiCol[].
113629 ** This is used to determine if the column number x appears in any of the
113651 ** This routine differs from hasColumn() in that both the column and the
113653 ** the column name must match.
113686 ** able to find all instances of a reference to the indexed table column
113688 ** the actual table at hand in order to recompute the virtual column, if
113743 /* Mark every PRIMARY KEY column as NOT NULL (except for imposter tables)
113823 ** the final rowid column into one or more columns of the PRIMARY KEY.
113967 ** "CREATE TABLE ... AS SELECT ..." statement. The column names of
113972 Token *pCons, /* The ',' token after the last column defn. */
114073 sqlite3ErrorMsg(pParse, "must have at least one non-generated column");
114123 ** suitable state to query for the column names and types to be used
114263 ExprList *pCNames, /* Optional list of view column names */
114371 ** trying to compute the column names. If we enter this routine with
114424 ** a VIEW it holds the list of column names.
114437 ** the column names from the SELECT statement that defines the view.
114468 ** Clear the column names from every VIEW in database idx.
114847 ** connect the key to the last column inserted. pTo is the name of
114883 " should reference only one column of table %T",
114931 "unknown column \"%s\" in foreign key definition",
115174 ** is a primary key or unique-constraint on the most recent column added
115368 ** key out of the last column added to the table under construction.
115436 ** a table column, store that column in aiColumn[]. For general expressions,
115533 /* If this index contains every column of its table, then mark
115550 ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
115551 ** a PRIMARY KEY or UNIQUE clause following the column definitions.
115773 ** first column of the index. aiRowEst[2] is an estimate of the number
116808 ExprList *pArglist, /* Optional column name list for the table */
117835 /* Resolve the column names in the WHERE clause.
118143 int iDataCur, /* Cursor from which column data is extracted */
118350 ** a column in common, then the register corresponding to that column already
118359 int iDataCur, /* Cursor number from which to take column data */
118392 /* This column was already computed by the previous index */
118396 /* If the column affinity is REAL but the number is an integer, then it
120863 ** KEY column, then output variable *ppIdx is set to NULL. Otherwise, *ppIdx
120866 ** If the parent key consists of a single column (the foreign key constraint
120870 ** array is the index of the child table column that is mapped by the FK
120871 ** constraint to the parent table column stored in the left-most column
120873 ** child table column that corresponds to the second left-most column of
120906 char *zKey = pFKey->aCol[0].zCol; /* Name of left-most parent key column */
120913 /* If this is a non-composite (single column) foreign key, check if it
120917 ** Otherwise, for a composite foreign key (more than one column), allocate
120924 ** 1) There is an INTEGER PRIMARY KEY column and the FK is implicitly
120926 ** 2) The FK is explicitly mapped to a column declared as INTEGER
120943 ** of columns. If each indexed column corresponds to a foreign key
120944 ** column of pFKey, then this index is a winner. */
120961 ** the default collation sequences for each column. */
120964 i16 iCol = pIdx->aiColumn[i]; /* Index of column in parent tbl */
120965 const char *zDfltColl; /* Def. collation for column */
120966 char *zIdxCol; /* Name of indexed column */
120971 ** the default collation sequence for the column, this index is
121072 ** column of the parent table (table pTab). */
121079 ** the value. Otherwise, the value inserted into the child key column
121135 /* The parent key is a composite key that includes the IPK column */
121178 ** to column iCol of table pTab.
121182 ** column. regBase+2 holds the second column, and so forth.
121188 i16 iCol /* Which column of pTab is desired */
121213 ** Return an Expr object that refers to column iCol of table pTab which
121218 Table *pTab, /* The table whose column is desired */
121220 i16 iCol /* The column that is wanted */
121296 ** the parent key columns. The affinity of the parent key column should
121303 i16 iCol; /* Index of column in child table */
121304 const char *zCol; /* Name of column in child table */
121486 ** is currently being processed. For each column of the table that is
121488 ** is zero or greater (if a column is unmodified the corresponding element
121489 ** is set to -1). If the rowid column is modified by the UPDATE statement
121513 ** is currently being processed. For each column of the table that is
121515 ** is zero or greater (if a column is unmodified the corresponding element
121516 ** is set to -1). If the rowid column is modified by the UPDATE statement
121571 ** rowid of the row being deleted, followed by each of the column values
121817 ** If the i'th column is not modified by the UPDATE, then the corresponding
121818 ** entry in the aChange[] array is set to -1. If the column is modified,
121939 Token tFromCol; /* Name of column in child table */
121940 Token tToCol; /* Name of column in parent table */
121941 int iFromCol; /* Idx of column in child table */
122222 ** Return a pointer to the column affinity string associated with index
122223 ** pIdx. A column affinity string has one character for each column in
122224 ** the table, according to the affinity of the column:
122235 ** rowid that appears as the last column in every index.
122237 ** Memory for the buffer containing the column index affinity string
122243 /* The first time a column affinity string for a particular index is
122247 ** The column affinity string will eventually be deleted by
122290 ** A column affinity string has one character per column:
122374 ** referenced columns in a CHECK constraint or generated column expression.
122394 int iRegStore, /* Register holding the first column */
122449 /* On the second pass, compute the value of each NOT-AVAILABLE column.
122479 sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pRedo->zName);
122820 int iRegStore; /* Register in which to store next column */
122828 int regData; /* register holding first column to insert */
122941 ** remember the column indices.
122943 ** If the table has an INTEGER PRIMARY KEY column and that column
122945 ** the index into IDLIST of the primary key column. ipkColumn is
122974 "cannot INSERT into generated column \"%s\"",
122987 sqlite3ErrorMsg(pParse, "table %S has no column named %s",
123084 ** column index in the original table definition.
123235 ** NULL - we cannot optimize further by skipping the column completely */
123266 /* A column not named in the insert column list gets its
123340 ** table column affinities.
123523 #define CKCNSTRNT_COLUMN 0x01 /* CHECK constraint uses a changing column */
123562 int *aiChng, /* aiChng[x]>=0 if column x changed by the UPDATE */
123655 ** contain the content of the first table column. The third register will
123656 ** contain the content of the second table column. And so forth.
123673 ** value for either the rowid column or its INTEGER PRIMARY KEY alias.
123724 ** value for that column. If the default value
123749 int *aiChng, /* column i is unchanged if aiChng[i]<0 */
123809 int iReg; /* Register holding column value */
123810 Column *pCol = &pTab->aCol[i]; /* The column to check for NOT NULL */
123811 int isGenerated; /* non-zero if column is generated */
123813 if( onError==OE_None ) continue; /* No NOT NULL on this column */
124274 VdbeComment((v, "%s column %d", pIdx->zName, i));
124782 ** * The same collating sequence on each column
124920 return 0; /* The result set must have exactly one column */
124973 ** The reason is that generated column values are returned by the
124986 return 0; /* Both columns have the same generated-column type */
125307 /* sqlite3VdbeSetColName() installs column names as UTF8
126990 /* Names of columns for pragmas that return multi-column result
126991 ** or that return single-column results where the name of the
126992 ** result column is different from the name of the pragma
127057 u8 iPragCName; /* Start of column names in pragCName[] */
127714 ** Set result column names for a pragma.
127898 ** Generate code to output a single-column result row with a value of the
128023 /* Register the result column names for pragmas that return results */
128683 ** Return a single row for each column of the named table. The columns of
128689 ** notnull: True if 'NOT NULL' is part of column declaration
128690 ** dflt_value: The default value for the column, if any.
128951 int *aiCols; /* child to parent column mapping */
129281 ** current key. The entry is unique if (1) any column is NULL
129840 u8 iHidden; /* Index of the first hidden column */
130067 /* The xColumn method simply returns the corresponding column from
130177 (pData->mInitFlags & INITFLAG_AlterRename) ? "rename" : "drop column",
130302 /* If the SQL column is blank it means this is an index that
131424 ** Return the index of a column in a table. Return -1 if the column
131439 ** table that has a column named zCol.
131441 ** When found, set *piTab and *piCol to the table index and column index
131442 ** of the matching column and return TRUE.
131449 const char *zCol, /* Name of the column we are looking for */
131455 int iCol; /* Index of column matching zCol */
131481 ** (iSrc+1)'th. Column col1 is column iColLeft of tab1, and col2 is
131482 ** column iColRight of tab2.
131488 int iColLeft, /* Index of column in first table */
131490 int iColRight, /* Index of column in second table */
131617 ** every column that the two tables have in common.
131626 char *zName; /* Name of column in the right table */
131628 int iLeftCol; /* Matching column in the left table */
131656 /* Create extra terms on the WHERE clause for each column named
131660 ** Report an error if any column mentioned in the USING clause is
131667 int iLeft; /* Table on the left with matching column name */
131668 int iLeftCol; /* Column number of matching column on the left */
131669 int iRightCol; /* Column number of matching column on the right */
131676 sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
131940 ** storing values read from that column in the sorter records, the PK of
132017 ** to get the number of columns and the collation sequence for each column.
132391 ** final OP_Sequence column. The last column is the record as a blob.
132527 int iStart, /* Begin with this column of pList */
132803 ** original CREATE TABLE statement if the expression is a column. The
132805 ** is considered a column can be complex in the presence of subqueries. The
132807 ** considered a column by this function.
132814 ** The declaration type for any expression other than a column is NULL.
132847 /* The expression is a column. Locate the table the column is being
132851 Table *pTab = 0; /* Table structure column is extracted from */
132852 Select *pS = 0; /* Select the column is extracted from */
132853 int iCol = pExpr->iColumn; /* Index of column in pTab */
132876 ** sub-select. In this case, set the column type to NULL, even
132879 ** This is not a problem, as the column type of "t1.col" is never
132890 ** data for the result-set column of the sub-select.
132936 ** origin info for the single column in the result set of the SELECT
132988 /* The vdbe must make its own copy of the column-type and other
132989 ** column specific strings, in case the schema is reset before this
133005 ** Compute the column names for a SELECT statement.
133007 ** The only guarantee that SQLite makes about column names is that if the
133008 ** column has an AS clause assigning it a name, that will be the name used.
133010 ** developed over the years have made baseless assumptions about column names
133026 ** refers directly to a table column, then the
133027 ** result column name is just the table column
133030 ** full=ON, short=ANY: If the result refers directly to a table column,
133031 ** then the result column name with the table name
133036 Select *pSelect /* Generate column names for this SELECT statement */
133057 SELECTTRACE(1,pParse,pSelect,("generating column names\n"));
133097 z = z==0 ? sqlite3MPrintf(db, "column%d", i+1) : sqlite3DbStrDup(db, z);
133107 ** column names for a table that would hold the expression list.
133109 ** All column names will be unique.
133111 ** Only the column names are computed. Column.zType, Column.zColl,
133117 ** The only guarantee that SQLite makes about column names is that if the
133118 ** column has an AS clause assigning it a name, that will be the name used.
133120 ** developed over the years have made baseless assumptions about column names
133128 ExprList *pEList, /* Expr list from which to derive column names */
133130 Column **paCol /* Write the new column list here */
133139 Hash ht; /* Hash table of column names */
133157 /* Get an appropriate name for the column
133160 /* If the column contains an "AS <name>" phrase, use <name> as the name */
133168 /* For columns use the column name name */
133176 /* Use the original text of the column expression as its name */
133183 zName = sqlite3MPrintf(db,"column%d",i+1);
133186 /* Make sure the column name is unique. If the name is not unique,
133220 ** Add type and collation information to a column list based on
133223 ** The column list presumably came from selectColumnNamesFromExprList().
133224 ** The column list has only names, not types or collations. This
133232 Table *pTab, /* Add column type information to this table */
133400 ** Return the appropriate collating sequence for the iCol-th column of
133402 ** the column has no default collating sequence.
133613 sqlite3VdbeAddOp1(v, OP_NullRow, iCurrent); /* To reset column cache */
134653 ** a column in table number iTable with a copy of the iColumn-th
134654 ** entry in pEList. (But leave references to the ROWID column
134710 ** just as it did when it was a column of a view or sub-query. */
135151 ** every reference to any result column from subquery in a join, even
135390 ** ORDER BY column expression is identical to the iOrderByCol'th
135471 ** A structure to keep track of all of the column values that are fixed to
135486 ** The caller guarantees the pColumn is a column and pValue is a constant.
135622 ** column value. Also, to avoid collation problems, this optimization is
135989 ** to a result column of the SELECT statement. This occurs when the
136344 ** If found, expand each "*" to be every column in every table
136345 ** and TABLE.* to be every column in TABLE.
136465 /* For every "*" that occurs in the column list, insert the names of
136468 ** with the TK_ASTERISK operator for each "*" that it found in the column
136543 char *zColname; /* The computed column name */
136545 Token sColname; /* Computed column name as a token */
136554 /* If a column is marked as 'hidden', omit it from the expanded
137088 if( p->pEList->nExpr!=1 ) return 0; /* Single result column */
137422 /* Issue SQLITE_READ authorizations with a fake column name for any
137430 ** The fake column name is an empty string. It is possible for a table to
137431 ** have a column named by the empty string, in which case there is no way to
137433 ** "" column. The original design was for the fake column name to be a NULL,
137435 ** assume the column name is non-NULL and segfault. The use of an empty
137436 ** string for the fake column name seems safer.
137897 sqlite3DebugPrintf("agg-column[%d] iMem=%d\n",
138367 char *z; /* A single column of result */
138622 IdList *pColumns, /* column list if this is an UPDATE OF trigger */
139030 ExprList *pEList, /* The SET clause: list of column and new values */
139796 ** reg+1 OLD.* value of left-most column of pTab
139798 ** reg+N OLD.* value of right-most column of pTab
139800 ** reg+N+2 NEW.* value of left-most column of pTab
139802 ** reg+N+N+1 NEW.* value of right-most column of pTab
139870 ** Bit 0 of the returned mask is set if the left-most column of the
139872 ** the second leftmost column value is required, and so on. If there
139876 ** It is not possible to determine if the old.rowid or new.rowid column is
139958 ** i-th column of table pTab. This routine sets the P4 parameter of the
139961 ** The default value of a column is specified by a DEFAULT clause in the
139962 ** column definition. This was either supplied by the user when the table
139965 ** may not contain a value for the column and the default value, taken
139968 ** for the column and the P4 value is not required.
139977 ** the column is a literal number, string or null. The sqlite3ValueFromExpr()
139981 ** If column as REAL affinity and the table is an ordinary b-tree table
140008 ** Check to see if column iCol of index pIdx references any of the
140014 ** aXRef[j] will be non-negative if column j of the original table is
140020 int iCol, /* Which column of the index to check */
140021 int *aXRef, /* aXRef[j]>=0 if column j is being updated */
140044 ** aXRef[j] will be non-negative if column j of the original table is
140050 int *aXRef, /* aXRef[j]>=0 if column j is being updated */
140061 ** expression to be a TK_COLUMN reading column iCol of the first
140227 ** an expression for the i-th column of the table.
140228 ** aXRef[i]==-1 if the i-th column is not changed. */
140367 /* Resolve the column names in all the expressions of the
140368 ** of the UPDATE statement. Also find the column index
140369 ** for each column to be updated in the pChanges array. For each
140370 ** column to be updated, make sure we have authorization to change
140371 ** that column.
140394 "cannot UPDATE generated column \"%s\"",
140410 sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zEName);
140436 ** reference any changing column. The actual aXRef[] value for
140547 /* Resolve the column names in all the expressions in the
140644 ** be used if any column of the index used for the scan is being
140845 /* This branch loads the value of a column that will not be changed
140959 ** is the column index supplied by the user.
141075 ** (C) The content of every column in the row.
141128 i16 iPk; /* PRIMARY KEY column */
141181 i16 iPk; /* PRIMARY KEY column */
141351 Expr sCol[2]; /* Index column converted into an Expr */
141388 ** single column of an index. The sCol[0] node will be the TK_COLLATE
141390 ** will populate the specific collation and column number values
141430 break; /* Column ii of the index matches column jj of target */
141434 /* The target contains no match for column jj of the index */
141593 ** column. (This will only happen if zSql begins with "SELECT".)
142817 ** or else must have a single-column PRIMARY KEY */
143066 ** If pExpr is a column in a virtual table, then let the virtual
143090 /* Check to see the left operand is a column in a virtual table */
143523 ** where X is a column name and <op> is one of certain operators,
143525 ** cursor number and column number for X. WhereTerm.eOperator records
143619 i16 aiColumn[11]; /* Corresponding column number in the eq-class */
143750 ** in an expression tree to cause that node to point to a column
143751 ** of an index rather than an expression or a virtual column. All
143933 ** Return the name of the i-th column of the pIdx index.
143952 Index *pIdx, /* Index to read column names from */
144225 ** Code an OP_Affinity opcode to apply the column affinity string zAff
144338 if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */
144567 ** copy of the column affinity string of the index allocated using
144736 ** the table CCurHint.iTabCur, verify that the same column can be
144791 ** the specified column into the new register, and
144806 int reg = ++pWalker->pParse->nMem; /* Register for column value */
144948 ** containing one entry for each column of the table cursor iCur is open
144949 ** on. For each table column, if the column is the i'th column of the
144950 ** index, then the corresponding array entry is set to (i+1). If the column
145024 ** mapping from an expression on table columns into a column in an index
145031 int iIdxCol; /* The column for the index */
145032 int iTabCol; /* The column for the table */
145051 ** a reference to an index column for an index on an expression.
145053 ** If pExpr matches, then transform it into a reference to the index column
145075 /* A walker node callback that translates a column reference to a table
145076 ** into a corresponding column reference of an index.
145097 ** column of the index.
145099 ** 2019-10-24: Updated to also translate references to a VIRTUAL column in
145100 ** the table into references to the corresponding (stored) column of the
145141 ** that are contained in the index. Pulling the generated column
145145 ** the column is non-standard */
145513 ** column that immediately follows the N equalities. Only
145514 ** the right-most column can be an inequality - the rest must
145619 /* If the WHERE_BIGNULL_SORT flag is set, then index column nEq uses
145622 ** index entries for which the column is null and for those for which
145874 ** column values are. https://www.sqlite.org/src/info/7fa8049685b50b5a
146572 ** literal that does not begin with a wildcard. The LHS must be a column
146575 ** collating sequence for the column on the LHS must be appropriate for
146655 /* If the LHS is not an ordinary column with TEXT affinity, then the
146730 ** 1. column MATCH expr SQLITE_INDEX_CONSTRAINT_MATCH
146731 ** 2. column GLOB expr SQLITE_INDEX_CONSTRAINT_GLOB
146732 ** 3. column LIKE expr SQLITE_INDEX_CONSTRAINT_LIKE
146733 ** 4. column REGEXP expr SQLITE_INDEX_CONSTRAINT_REGEXP
146734 ** 5. column != expr SQLITE_INDEX_CONSTRAINT_NE
146735 ** 6. expr != column SQLITE_INDEX_CONSTRAINT_NE
146736 ** 7. column IS NOT expr SQLITE_INDEX_CONSTRAINT_ISNOT
146737 ** 8. expr IS NOT column SQLITE_INDEX_CONSTRAINT_ISNOT
146738 ** 9. column IS NOT NULL SQLITE_INDEX_CONSTRAINT_ISNOTNULL
146740 ** In every case, "column" must be a column of a virtual table. If there
146741 ** is a match, set *ppLeft to the "column" expression, set *ppRight to the
146742 ** "expr" expression (even though in forms (6) and (8) the column is on the
146745 ** is a match. The usual return is 1, but if the RHS is also a column
146796 /* We can also match against the first column of overloaded
146973 ** If all subterms are of the form T.C=expr for some single column of C and
147002 ** "T.C <op> <expr>" where C is any column of table T and
147158 ** something other than == on a column in the single table. The 1-bit
147160 ** "table.column=expr" for some single table. The one bit that is set
147162 ** sure the same column is used on all terms. The 2-bit case is when
147163 ** the all terms are of the form "table1.column=table2.column". It
147164 ** might be possible to form an IN operator with either table1.column
147165 ** or table2.column as the LHS if either is common to every term of
147177 /* Search for a table and column that appears on one side or the
147178 ** other of the == operator in every subterm. That table and column
147180 ** such table and column. Set okToChngToIN if an appropriate table
147181 ** and column is found but leave okToChngToIN false if not found.
147212 /* No candidate table+column was found. This can only occur
147221 /* We have found a candidate table and column. Check to see if that
147222 ** table and column is common to every term in the OR clause */
147234 /* If the right-hand side is also a column, then the affinities
147291 ** column references. This routine checks to see if pExpr is an equivalence
147300 ** for the LHS anyplace else in the WHERE clause where the LHS column occurs.
147356 ** number of the table that is indexed and aiCurCol[1] to the column number
147357 ** of the column that is indexed, or XN_EXPR (-2) if an expression is being
147360 ** If pExpr is a TK_COLUMN column reference, then this routine always returns
147361 ** true even if that particular column is not indexed, because the column
147367 int *aiCurCol, /* Write the referenced table cursor and column here */
147391 int *aiCurCol, /* Write the referenced table cursor & column here */
147589 ** 3. Expression <e1> must refer to at least one column from the outer
147590 ** query, and must not refer to any column from the inner query
148069 ** current expression is of the form "column OP expr" where OP
148267 ** a HIDDEN column in the table.
148583 i16 iColumn; /* The column on the LHS of the term. -1 for IPK */
148678 ** for terms of the form "X <op> <expr>" where X is column iColumn of table
148679 ** iCur. Or if pIdx!=0 then X is column iColumn of index pIdx. pIdx
148738 ** Search for terms matching the iColumn-th column of pIdx
148739 ** rather than the iColumn-th column of table iCur.
148752 ** the form "X <op> Y" where Y is a column in another table if no terms of
148784 ** This function searches pList for an entry that matches the iCol-th column
148794 Index *pIdx, /* Index to match column of */
148818 ** Return TRUE if the iCol-th column of index pIdx is NOT NULL
148861 /* If any of the expressions is an IPK column on table iBase, then return
148925 int iRegister, /* The first column is in this register */
149054 int mxBitCol; /* Maximum column in pSrc->colUsed */
149055 CollSeq *pColl; /* Collating sequence to on a column */
149642 ** Return the affinity for a single column of an index.
149671 ** extracted from pLower and pUpper with the corresponding column in each
149779 ** column subject to the range constraint. Or, equivalently, the number of
149785 ** then nEq is set to 1 (as the range restricted column, b, is the second
149786 ** left-most column of the index). Or, if the query is:
149971 ** column of an index and sqlite_stat4 histogram data is available
150609 ** "x" column is boolean or else -1 or 0 or 1 is a common default value
150610 ** on the "x" column and so in that case only cap the output row estimate
150668 ** in the vector can be optimized using column nEq of the index. This
150695 /* Test if comparison i of pTerm is compatible with column (i+nEq)
150708 /* Check that the LHS of the comparison is a column reference to
150709 ** the right column of the right source table. And that the sort
150710 ** order of the index column is the same as the sort order of the
150711 ** leftmost index column. */
150885 ** the left-most index column, M==N.
150905 ("Scan preferred over IN operator on column %d of \"%s\" (%d<%d)\n",
150910 ("IN operator preferred on column %d of \"%s\" (%d>=%d)\n",
151391 ** a column with just two distinct values where each value has about
152058 int iColumn; /* A column number within table iCur */
152083 ** UNIQUE since a UNIQUE column or index can have multiple rows that
152124 /* Mark off any ORDER BY term X that is a column in the table of
152197 ** If the current term is a column of an ((?,?) IN (SELECT...))
152198 ** expression for which the SELECT returns more than one column,
152199 ** check that it is the only column used by this loop. Otherwise,
152227 /* Get the column number in the table (iColumn) and sort order
152228 ** (revIdx) for the j-th column of the index.
152239 /* An unconstrained column that might be NULL means that this
152250 /* Find the ORDER BY term that corresponds to the j-th column
153497 ** it is advantageous to reduce the "column count" field in
153988 ** terminals are column references and aggregate functions.
156778 /* Load the column values for the row returned by the sub-select
157208 sqlite3ErrorMsg(pParse, "syntax error after column name \"%.*s\"",
165660 /* SQLITE_RANGE */ "column index out of range",
167725 ** Return meta information about a specific column of a database table.
167736 int *pPrimaryKey, /* OUTPUT: True if column part of PK */
167737 int *pAutoinc /* OUTPUT: True if column is auto-increment */
167772 /* Find the column for which info is requested */
167797 ** 1. The specified column name was rowid", "oid" or "_rowid_"
167798 ** and there is no explicitly declared IPK column.
167800 ** 2. The table is not a view and the column name identified an
167801 ** explicitly declared column. Copy meta information from *pCol.
167832 zErrMsg = sqlite3MPrintf(db, "no such table column: %s.%s", zTableName,
168287 ** values into a REAL column, so they can be challenging to test. This
169141 ** array { (position list for column 0)
169145 ** varint POS_COLUMN; (marks start of position list for new column)
169146 ** varint column; (index of new column)
169166 ** The 123 value is the first docid. For column zero in this document
169168 ** at D signals the start of a new column; the 1 at E indicates that the
169169 ** new column is column number 1. There are two positions at 12 and 45
169175 ** a single docid. A "column-list" is the set of positions for a single
169176 ** column. Hence, a position-list consists of one or more column-lists,
169746 ** value stored in the "%_segdir.level" column. Given this value L, the index
169767 ** Terminator values for position-lists and column-lists.
169880 char **azColumn; /* column names. malloced */
170001 ** of the column to be searched. For example, in
170006 ** Because the LHS of the MATCH operator is 2nd column "b",
170071 int iColumn; /* Index of column this phrase must match */
170202 int iColFilter; /* If >=0, filter for this column */
170783 ** "Special" FTS4 arguments are column specifications of the following form:
170873 ** to return the docid, followed by each column of text data in order
170875 ** being returned directly each column of text data is passed to an SQL
170930 ** user-defined text column).
171091 ** the name of the corresponding column in table xxx. The array
171104 const char ***pazCol, /* OUT: Malloc'd array of column names */
171126 sqlite3_int64 nStr = 0; /* Size of all column names (incl. 0x00) */
171131 ** space required to store a copy of each column name, including the
171173 ** argv[...] -> "column name" and other module argument fields.
171190 int nString = 0; /* Bytes required to hold all column names */
171192 char *zCsr; /* Space for holding column names */
171196 const char **aCol; /* Array of column names */
171236 ** module (i.e. all the column names and special arguments). This loop
171241 ** of the column names.
171351 /* Otherwise, the argument is a column name. */
171362 ** 2. If no column names were specified as part of the CREATE VIRTUAL
171376 ** column from the aCol[] array. */
171492 sqlite3Fts3ErrMsg(pzErr, "no such column: %s", azNotindexed[i]);
171611 ** 2. Full-text search using a MATCH operator on a non-docid column.
171654 /* A direct lookup on the rowid or docid column. Assign a cost of 1.0. */
171678 /* Equality constraint on the langid column */
172126 ** start of a column-list. After it returns, *ppPoslist points to the
172127 ** to the terminator (POS_COLUMN or POS_END) byte of the column-list.
172129 ** A column-list is list of delta-encoded positions for a single column
172132 ** The column-list is terminated either by a POS_COLUMN varint (1) or
172134 ** the POS_COLUMN or POS_END that terminates the column-list.
172136 ** If pp is not NULL, then the contents of the column-list are copied
172145 /* A column-list is terminated by either a 0x01 or 0x00 byte that is
172204 ** column list.
172238 int iCol1; /* The current column index in pp1 */
172239 int iCol2; /* The current column index in pp2 */
172263 /* At this point, both p1 and p2 point to the start of column-lists
172264 ** for the same column (the column with index iCol1 and iCol2).
172265 ** A column-list is a list of non-negative delta-encoded varints, each
172409 ** column-number in the position list.
172760 ** a token in position 0 (of any column). If so, it writes argument iDelta
173297 ** column on the left-hand side of the MATCH operator is column
173449 ** (iCol < p->nColumn) -> The value of the iCol'th user column.
173450 ** (iCol == p->nColumn) -> Magic column with the same name as the table.
173451 ** (iCol == p->nColumn+1) -> Docid column
173452 ** (iCol == p->nColumn+2) -> Langid column
173457 int iCol /* Index of column to read value from */
173463 /* The column value supplied by SQLite must be in range. */
173468 /* The special 'table-name' column */
173473 /* The docid column */
173490 /* A user column. Or, if this is a full-table scan, possibly the
173491 ** language-id column. Seek the cursor. */
174858 int iCol; /* The column the token must match */
174933 ** data stored in all rows of each column of the table, from left
175854 ** 1. The total number of occurrences of the phrase in each column of
175857 ** 2. For each column, the number of rows in the table for which the
175858 ** column contains at least one instance of the phrase.
175860 ** If no error occurs, SQLITE_OK is returned and the values for each column
175871 ** column of each row of the table.
175914 ** a position-list indicating the occurrences of the phrase in column iCol
175918 ** occurrence of the phrase in the column, stored using the normal (delta+2)
175920 ** if the requested column contains "a b X c d X X" and the position-list
175940 /* If this phrase is applies specifically to some column other than
175941 ** column iCol, return a NULL pointer. */
176143 int iCol; /* Current value of 'col' column */
176275 /* Search for equality and range constraints on the "term" column.
176276 ** And equality constraints on the hidden "languageid" column. */
176419 ** that the following integer will be a column number, or the
176420 ** start of a position list for column 0.
176424 ** increment the column 0 "nDoc" count for this term.
176437 }else if( v==1 ){ /* 0x01. Next integer will be a column number. */
176445 /* State 3. The integer just read is a column number. */
176567 ** xColumn - Return a column value.
176572 int iCol /* Index of column to read value from */
176755 const char **azCol; /* Array of column names for fts3 table */
176758 int iDefaultCol; /* Default column to query */
176825 ** and other information (column names etc.) in pParse. Create an Fts3Expr
177174 ** column specifier for the token.
177176 ** TODO: Strangely, it is not possible to associate a column specifier
177623 char **azCol, /* Array of column names for fts3 table */
177626 int iDefaultCol, /* Default column to query */
177674 ** of each column in the target fts3 table, in order from left to right.
177677 ** The iDefaultCol parameter should be passed the index of the table column
177679 ** column to match against for tokens for which a column name is not explicitly
177681 ** match any table column.
177686 char **azCol, /* Array of column names for fts3 table */
177689 int iDefaultCol, /* Default column to query */
177828 ** fts3_exprtest(<tokenizer>, <expr>, <column 1>, ...);
177833 ** of a column of the fts3 table that the query expression may refer to.
180142 ** xColumn - Return a column value.
180147 int iCol /* Index of column to read value from */
180905 ** Add a docid/column/position entry to a PendingList structure. Non-zero
181009 ** p->iPrevDocid, and the column is specified by argument iCol.
181173 ** apVal[2] Left-most user-defined column
181175 ** apVal[p->nColumn+1] Right-most user-defined column
181176 ** apVal[p->nColumn+2] Hidden column with same name as table
181177 ** apVal[p->nColumn+3] Hidden "docid" column (alias for rowid)
181178 ** apVal[p->nColumn+4] Hidden languageid column
181403 ** with the contents of the blob stored in the "block" column of the
181683 ** *ppOffsetList is set to point to the first column-offset list
181685 ** *pnOffsetList is set to the length of the set of column-offset
182605 sqlite3_int64 iLevel, /* Value for 'level' column of %_segdir */
182606 int iIdx /* Value for 'idx' column of %_segdir */
182680 ** Segment levels are stored in the 'level' column of the %_segdir table.
182829 ** identify the subset of the position list that corresponds to column iCol.
182831 ** If there are no entries in the input position list for column iCol, then
183290 ** Decode the "end_block" field, selected by column iCol of the SELECT
183604 ** Insert the sizes (in tokens) for each column of the document
183611 u32 *aSz /* Sizes of each column, in tokens */
183645 ** Varint 1..nCol: For each column, the total number of tokens stored in
183646 ** the column for all rows of the table.
184335 ** the node would be stored as a blob in the "root" column of the %_segdir
185592 ** + The column it appears in, and
185593 ** + The tokens position within that column.
185936 ** rowid column. So if the conflict mode is REPLACE, then delete any
186085 int iCol; /* Extract snippet from this column */
186525 ** from column iCol that represent the "best" snippet. The best snippet
186541 int iCol, /* Index of column to create snippet from */
186761 int iCol = pFragment->iCol+1; /* Query column to extract text from */
186803 ** of the column. Append any punctuation that occurred between the end
186821 ** or (b) this fragment does not begin at position 0 of its column.
186857 ** This function is used to count the entries in a column-list (a
186858 ** delta-encoded list of term offsets within a single column of a single
186860 ** beginning of the first varint in the column-list (the varint that
186861 ** contains the position of the first matching term in the column data).
186863 ** the last varint in the column-list (either the 0x00 signifying the end
186864 ** of the position-list, or the 0x01 that precedes the column number of
186865 ** the next column in the position-list).
186867 ** The number of elements in the column-list is returned.
186874 /* A column-list is terminated by either a 0x01 or 0x00. */
186959 ** where X is the number of matches for phrase iPhrase is column iCol of all
186960 ** rows of the table. Y is the number of rows for which column iCol contains
187102 ** iterating through a multi-column position-list corresponding to the
187133 ** position list for the next column.
187156 ** column are written into the first nCol elements of the pInfo->aMatchinfo[]
187185 int nLcs = 0; /* LCS value for this column */
187210 /* This iterator is already at EOF for this column. */
187285 const char *a; /* Aggregate column length array */
187465 int iCol, /* Extract snippet from this column */
187515 ** columns of the FTS3 table. Otherwise, only column iCol is considered.
187522 /* Find the best snippet of nFToken tokens in column iRead. */
187645 ** string-buffer res for each column.
187657 /* Initialize the contents of sCtx.aTerm[] for column iCol. There is
187665 /* Retreive the text stored in column iCol. If an SQL NULL is stored
187666 ** in column iCol, jump immediately to the next iteration of the loop.
187681 /* Initialize a tokenizer iterator to iterate through column iCol. */
187702 /* All offsets for this column have been gathered. */
190791 /* Return the value of a column */
190795 int i /* Which column to return */
190898 ** column. Without such a constraint, the table cannot operate. idxNum is
193158 ** The second of each pair of bytes identifies the coordinate column
193159 ** to which the constraint applies. The leftmost coordinate column
194336 ** Parameter iCol is the index of the leftmost column involved in the
194338 ** the unique constraint on the id column. Otherwise, it is the rtree
194422 ** with "column" that are interpreted as table constraints.
194895 ** argv[...] -> column names...
195240 ** IPK value iKey and the second column set to iVal.
195435 sqlite3_stmt *pStmt = 0; /* Used to find column count of rtree table */
196783 ** argv[...] -> column names...
196829 pRtree->nAuxNotNull = 1; /* The _shape column is always not-null */
197133 ** argv[2] = _shape column
197134 ** argv[3] = first application-defined column....
197141 ** argv[3] = new value for first application-defined column....
198558 ** have no PRIMARY KEY or UNIQUE constraints, but each column should have
198559 ** the same type as the corresponding column in the target database.
198560 ** The "rbu_control" column should have no type at all. For example, if
198584 ** PRIMARY KEY declaration, the data_% table must also contain a column
198585 ** named "rbu_rowid". This column is mapped to the tables implicit primary
198586 ** key column - "rowid". Virtual tables for which the "rowid" column does
198601 ** table with a hidden languageid column such as:
198612 ** with the "rbu_control" column set to contain integer value 0. The
198617 ** possible to insert a NULL value into the IPK column. Attempting to
198622 ** with the "rbu_control" column set to contain integer value 1. The
198629 ** with the "rbu_control" column set to contain a value of type text.
198633 ** "rbu_control" column must contain the same number of characters as
198636 ** each column that is being updated, the corresponding character is set to
198649 ** target table with the value stored in the corresponding data_% column, the
198651 ** the target table column. rbu_delta() is invoked with two arguments - the
198652 ** original value currently stored in the target table column and the
198664 ** ota_control string, the contents of the data_xxx table column is assumed
198967 ** the RBU database. The 'tbl' column should contain the name of the source
198968 ** table. The 'cnt' column should contain the number of rows within the
199236 ** set for each column that is either a part of the PK or a part of an
199249 char **azTblCol; /* Array of unquoted target column names */
199250 char **azTblType; /* Array of target column types */
199286 ** 2: Table has an explicit IPK column.
200134 ** RBU_PK_IPK: Table has an explicit IPK column.
200230 *peType = RBU_PK_IPK; /* explicit IPK column */
200308 int bRbuRowid = 0; /* If input table has column "rbu_rowid" */
200357 "table %q %s rbu_rowid column", pIter->zDataTbl,
200378 p->zErrmsg = sqlite3_mprintf("column missing from %q: %s",
200411 ** column names currently stored in the pIter->azTblCol[] array.
200415 RbuObjIter *pIter /* Object iterator for column names */
200429 ** Return a comma separated list of the quoted PRIMARY KEY column names,
200430 ** in order, for the current table. Before each column name, add the text
200431 ** zPre. After each column name, add the zPost text. Use zSeparator as
200436 RbuObjIter *pIter, /* Object iterator for column names */
200437 const char *zPre, /* Before each quoted column name */
200439 const char *zPost /* After each quoted column name */
200647 ** and "t1" is a table with an explicit INTEGER PRIMARY KEY column
200661 RbuObjIter *pIter, /* Object iterator for column names */
200766 ** With the column names escaped.
200850 ** stored in the (p->nCol+1)'th column. Set the error code and error message
200864 ** column of the data_xxx table entry is set to zMask.
201108 /* If the target table column is an "INTEGER PRIMARY KEY", add
201109 ** "PRIMARY KEY" to the imposter table column declaration. */
201142 ** the target table, plus one (for the rbu_control column), plus one more
201143 ** (for the rbu_rowid column) if the target table is an implicit IPK or
201556 ** rbu_control column of the data_xyz table contains zMask.
202250 int iCol = p->objiter.nCol; /* Index of rbu_control column */
202290 ** Assert that column iCol of statement pStmt is named zName.
202334 ** to write a NULL into the IPK column. That is not permitted. */
202431 /* Bind the rbu_rowid value to column _rowid_ */
202481 ** value stored in the RBU_STATE_STAGE column is eStage. All other values
202886 ** database. The 'tbl' column should contain the name of a data_xxx table,
202887 ** and the cnt column the number of rows it contains.
204329 ** The value of the 'path' column describes the path taken from the
204419 u32 iPageno; /* Value of 'pageno' column */
204420 char *zName; /* Value of 'name' column */
204421 char *zPath; /* Value of 'path' column */
204422 char *zPagetype; /* Value of 'pagetype' column */
204424 int nCell; /* Value of 'ncell' column */
204425 int nMxPayload; /* Value of 'mx_payload' column */
204426 i64 nUnused; /* Value of 'unused' column */
204427 i64 nPayload; /* Value of 'payload' column */
204428 i64 iOffset; /* Value of 'pgOffset' column */
204429 i64 szPage; /* Value of 'pgSize' column */
205768 ** the i'th column of the table, counting from left to right in the order
205809 ** table column, counting from left to right within the CREATE TABLE
205819 ** and fields associated with modified columns contain the new column values.
206254 ** The merging of records is done as follows: For each column, if the
206255 ** aRight record contains a value for the column, copy the value from
206257 ** record contains a value for a given column, then neither does the
206450 /* A SessionChange object never has a NULL value in a PK column */
206544 ** point to an array of pointers to column names. And *pabPK (again, if not
206546 ** column is part of the primary key.
206569 const char ***pazCol, /* OUT: Array of column names for table */
206705 ** blob each time a NULL value is read from the "idx" column of the
207595 ** in column iCol of the row that SQL statement pStmt currently points
208453 ** + array of PK flags (1 byte per column),
208536 ** + array of PK flags (1 byte per column),
208800 ** was not modified and is not a PK column), set *ppValue to NULL.
209135 const char **azCol; /* Array of column names */
209136 u8 *abPK; /* Boolean array - true if column is in PK */
209784 ** Or, if conflict handling is not required, bind just the PK column
211262 ** the total number of tokens in column iCol, considering all rows in
211277 ** *pnToken to the number of tokens in column iCol of the current row.
211288 ** This function attempts to retrieve the text of column iCol of the
211308 ** "detail=none" or "detail=column" option. If the FTS5 table is created
211309 ** with either "detail=none" or "detail=column" and "content=" option
211319 ** to the column in which it occurs and *piOff the token offset of the
211324 ** "detail=none" or "detail=column" option.
211339 ** current query is executed. Any column filter that applies to
211414 ** // An instance of phrase iPhrase at offset iOff of column iCol
211423 ** "detail=none" or "detail=column" option. If the FTS5 table is created
211424 ** with either "detail=none" or "detail=column" and "content=" option
211457 ** "detail=column" tables.
211889 ** Each entry in the aiCol[] array is a column that may be matched.
212226 int iPos, /* Position of token within column */
212360 int iPos, /* Position of token within column */
214132 ** a single column of the current row. If the phrase instances in the
214133 ** column being considered do not overlap, this object simply iterates
214195 ** iterate through coalesced phrase instances in column iCol.
214433 int nDocsize, /* Size of column in tokens */
215699 *pzErr = sqlite3_mprintf("reserved fts5 column name: %s", zCol);
215705 *pzErr = sqlite3_mprintf("unrecognized column option: %s", zArg);
216284 u8 bFirst; /* True if token must be first in column */
216439 /* If the LHS of the MATCH expression was a user column, apply the
216440 ** implicit column-filter. */
216486 ** against column iCol. This function creates and compiles an FTS5 MATCH
218141 ** a new colset object containing the contents of (p) with new value column
218150 int iCol /* New column to add to colset object */
218228 sqlite3Fts5ParseError(pParse, "no such column: %s", z);
218341 "fts5: column queries are not supported (detail=none)"
218395 ** trigram indexes that specify either detail=column or detail=none.
219492 int iPos, /* Position of token within column */
219564 ** + 1 byte for a "new column" byte,
219565 ** + 3 bytes for a new column number (16-bit max) as a varint,
219605 /* Append a new column value, if necessary */
219904 ** The first value is the number of rows in the index. Then, for each column
219905 ** from left to right, the total number of tokens in the column for all
219939 ** collist: collist for column 0
219942 ** varint: column number (I)
219943 ** collist: collist for column I
220471 ** table, missing row, non-blob/text in block column - indicate
222765 Fts5Colset *pColset; /* Restrict matches to this column */
222772 Fts5Colset *pColset; /* Restrict matches to this column */
223022 ** column filters are specified.
223055 ** xSetOutputs callback used by detail=col when there is a column filter
223057 ** fts5IterSetOutputs_Col100 if the column-list spans more than one page.
223071 ** * there is a column filter, and
223074 ** The last point is to ensure all column numbers are stored as
223115 ** xSetOutputs callback used by detail=full when there is a column filter.
225247 int iPos, /* Position of token within column */
226870 ** argv[...] -> "column name" and other module argument fields.
227006 ** 1. A MATCH constraint against the table column.
227007 ** 2. A MATCH constraint against the "rank" column.
227008 ** 3. A MATCH constraint against some other column.
227009 ** 4. An == constraint against the rowid column.
227010 ** 5. A < or <= constraint against the rowid column.
227011 ** 6. A > or >= constraint against the rowid column.
227029 ** Match against table column: "m"
227030 ** Match against rank column: "r"
227031 ** Match against other column: "M<column-number>"
227032 ** LIKE against other column: "L<column-number>"
227033 ** GLOB against other column: "G<column-number>"
228024 ** Argument pVal is the value assigned to column "fts" by the INSERT
228034 const char *zCmd, /* Text inserted into table-name column */
228035 sqlite3_value *pVal /* Value inserted into rank column */
228987 int iCol /* Index of column to read value from */
229003 /* User is requesting the value of the special column with the same name
229010 /* The value of the "rank" column. */
229464 i64 *aTotalSize; /* Total sizes of each column */
229803 int szCol; /* Size of column value in tokens */
230106 ** a NULL value is inserted into the rowid column. The new rowid is allocated
230488 ** each table column. This function reads the %_docsize record for the
233162 ** One row for each term/column combination. The value of $doc is set to
233164 ** $term within column $col. Field $cnt is set to the total number of
233165 ** instances of term $term in column $col (in any row of the fts5 table).
233216 Fts5Buffer term; /* Current value of 'term' column */
233421 if( p->iColumn==0 ){ /* term column */
233449 ** the "term" column (column 0). So if the user has requested this
233817 int iCol /* Index of column to read value from */
234083 int i /* Which column to return */