Lines Matching refs:columns
574 ** number of columns in the result. ^The 3rd argument to the sqlite3_exec()
2124 ** names are not also used by explicitly declared columns. ^If
2416 ** The table conceptually has a number of rows and columns. But
2419 ** and M be the number of columns.
2423 ** to zero-terminated strings that contain the names of the columns.
2483 int *pnColumn, /* Number of result columns written here */
2780 ** columns of a table.
3383 ** <dd>The maximum number of columns in a table definition or in the
3384 ** result set of a [SELECT] or the maximum number of columns in an index
3862 ** CAPI3REF: Number Of Columns In A Result Set
3865 ** ^Return the number of columns in the result set returned by the
4070 ** CAPI3REF: Number of columns in a result set
4073 ** ^The sqlite3_data_count(P) interface returns the number of columns in the
4084 ** pragma returns 0 columns of data.
4133 ** ^The number of columns in the result can be determined using
6019 ** to declare the format (the names and datatypes of the columns) of
8200 columns in the table, return
8204 ** If parameter iCol is greater than or equal to the number of columns
8210 ** Return the number of columns in the table.
8215 ** non-negative but less than the number of columns in the table, set
8218 ** If parameter iCol is greater than or equal to the number of columns
8701 ** * Columns in a table
8702 ** * Columns in an index
8703 ** * Columns in a view
8711 ** not have more than a dozen or so columns in any table. And if
10403 ** number of columns of data returned by the statement.
10495 #define OP_OpenPseudo 60 /* synopsis: P3 columns in r[P2] */
11812 #define SQLITE_ShortColNames 0x00000040 /* Show short columns names */
12195 i16 nCol; /* Number of columns in this table */
12220 ** TF_OOOHidden applies to virtual tables that have hidden columns that are
12221 ** followed by non-hidden columns. Example: "CREATE VIRTUAL TABLE x USING
12233 #define TF_OOOHidden 0x80 /* Out-of-Order hidden columns */
12287 int nCol; /* Number of columns in this key */
12292 struct sColMap { /* Mapping of columns in pFrom to columns in zTo */
12295 } aCol[1]; /* One entry for each of nCol columns */
12344 ** are nField slots for the columns of an index then one extra slot
12350 u16 nField; /* Number of key columns in the index */
12351 u16 nXField; /* Number of columns beyond the key columns */
12389 ** The columns of the table that are to be indexed are described
12397 ** three columns in the table. In the Index structure describing
12398 ** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed.
12404 ** The Index.onError field determines whether or not the indexed columns
12421 i16 *aiColumn; /* Which columns are used by this index. 1st is 0 */
12433 u16 nKeyCol; /* Number of columns forming the key */
12434 u16 nColumn; /* Number of columns stored in the index */
12438 unsigned uniqNotNull:1; /* True if UNIQUE and NOT NULL for all columns */
12517 int nSortingColumn; /* Number of columns in the sorting index */
12529 int nAccumulator; /* Number of columns that show through to the output.
12530 ** Additional columns are used only as parameters to
12669 #define EP_Resolved 0x000004 /* IDs have been resolved to COLUMNs */
12837 ** contains more than 63 columns and the 64-th or later column is used.
12939 ExprList *pEList; /* Optional list of result-set columns */
12959 #define NC_IdxExpr 0x0020 /* True if resolving columns of CREATE INDEX */
12975 ** the number of columns in P2 can be computed at the same time
13118 ExprList *pOrderBy; /* Key columns for SRT_Queue and SRT_DistQueue */
13157 ** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns
13160 ** a mask of new.* columns used by the program.
13167 u32 aColmask[2]; /* Masks of old.*, new.* columns accessed */
13265 u32 oldmask; /* Mask of old.* columns referenced */
13266 u32 newmask; /* Mask of new.* columns referenced */
13287 int nAlias; /* Number of aliased result set columns */
13416 * pExprList -> A list of the columns to update and the expressions to update
15333 u64 maskUsed; /* Mask of columns used by this cursor */
15600 u16 nResColumn; /* Number of columns in one row of the result set */
26317 /* 60 */ "OpenPseudo" OpHelp("P3 columns in r[P2]"),
66099 int nCol = pIdx->nColumn; /* Number of index columns including rowid */
68109 ** the result, result columns may become dynamic if the user calls
68647 ** Set the number of result columns that will be returned by this SQL
70128 ** Count the number of fields (a.k.a. columns) in the record given by
71845 ** Return the number of columns in the result set for the statement pStmt.
73477 int *aPermute = 0; /* Permutation of columns for OP_Compare */
75341 ** 3-byte type for each of the maximum of 32768 columns plus three
75436 ** columns. So the result will be either the default value or a NULL.
76173 ** value, it is set to the number of columns in the table.
76202 ** value, it is set to the number of columns in the table, or to the
76319 ** P2 is the number of columns in the ephemeral table.
76429 ** Synopsis: P3 columns in r[P2]
76438 ** individual columns using the OP_Column opcode. The OP_Column opcode
76474 ** SQLITE_ENABLE_COLUMN_USED_MASK) identifies which columns of the
76477 ** first 63 columns of the table or index that are actually used
79345 ** the values of columns in the new row.
79851 ** key columns must be indexed. The check below will pick up this
79914 /* Configure the number of columns. Configure the cursor to
80125 ** the ORDER BY key columns and result columns
82792 int nKeyCol, /* Compare this many columns */
83676 ** means that the form of the name is Z and that columns from any table
84324 ** Attempt to match pE against result set columns in the left-most
84339 ExprList *pEList; /* The columns of the result set */
84394 ** and N where N is the number of columns in the compound SELECT.
84544 ** number of columns in the result set of the SELECT) then the expression
84835 ** table columns and result-set columns. At the same time, do error
84839 ** To resolve table columns references we look for nodes (or subtrees) of the
85188 /* Both sides of the comparison are columns. If one has numeric
85202 /* One side is a column, the other is not. Use the columns affinity. */
86240 sqlite3ErrorMsg(pParse, "too many columns in %s", zObject);
86901 ** SELECT... statement are columns, then numeric affinity is used
86903 ** 'x' nor the SELECT... statement are columns, then numeric affinity
86943 ** that columns affinity when building index keys. If <expr> is not
88047 ** set to (n+1), where n is the number of columns in each pseudo-table.
88878 ** to count references to table columns in the arguments of an
88884 int nThis; /* Number of references to columns in pSrcList */
88885 columns in other FROM clauses */
88889 ** Count the number of references to columns.
88918 ** references columns but not columns of tables found in pSrcList.
90090 ** columns. The N-th integer (for N>1) is the average number of rows in
90091 ** the index which have the same value for the first N-1 columns. For
90141 ** that indexed columns are compared against in the WHERE clauses of
90146 ** index. If the idx and tbl columns are the same, then the sample is
90153 ** first two columns match the first two columns of the sample.
90159 ** where the first K columns are less than the first K columns of the
90178 ** integer in the equivalent columns in sqlite_stat4.
90323 int nCol; /* Number of columns in index + pk/rowid */
90324 int nKeyCol; /* Number of index columns w/o the pk/rowid */
90412 ** N: The number of columns in the index including the rowid/pk (note 1)
90413 ** K: The number of columns in the index excluding the rowid/pk.
90417 ** WITHOUT ROWID table, N is the number of PRIMARY KEY columns, not the
90418 ** total number of columns in the table.
90423 ** WITHOUT ROWID tables, N=K+P where P is the number of columns in the
90438 int nCol; /* Number of columns in index being sampled */
90439 int nKeyCol; /* Number of key columns */
90531 ** considering only any trailing columns and the sample hash value, this
90875 ** if the index is on columns (a,b) and the sqlite_stat1 value is
91058 int nCol; /* Number of columns in pIdx. "N" */
91062 int nColTest; /* Number of columns to test for changes */
91126 ** (1) the number of columns in the index including the rowid
91127 ** (or for a WITHOUT ROWID table, the number of PK columns),
91128 ** (2) the number of columns in the key without the rowid/pk
91624 ** sample columns except the last. The last is always set to 1, as
91724 int nIdxCol = 1; /* Number of columns in stat4 records */
91782 int nCol = 1; /* Number of columns in index */
91959 ** looking for columns of the same name.
93864 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
93890 /* If there is no type specified, columns have the default affinity
94082 ** of columns that form the primary key. If pList is NULL, then the
94411 ** Resize an Index object to hold N columns total. Return SQLITE_OK
94486 ** (4) Set all columns of the PRIMARY KEY schema object to be NOT NULL.
94487 ** (5) Add all table columns to the PRIMARY KEY Index object
94489 ** columns are part of KeyInfo.nXField and are not used for
94492 ** indices with the PRIMARY KEY columns.
94541 ** Remove all redundant columns from the PRIMARY KEY. For example, change
94543 ** code assumes the PRIMARY KEY contains no repeated columns.
94571 ** the final rowid column into one or more columns of the PRIMARY KEY.
94596 /* Add all table columns to the PRIMARY KEY index
94942 ** the columns of the view in the pTable structure. Return the number
94964 /* A positive nCol means the columns names for this view are
95394 ** currently under construction. pFromCol determines which columns
95410 ExprList *pFromCol, /* Columns in this table that point to other table */
95412 ExprList *pToCol, /* Columns in the other table */
95439 "number of columns in foreign key does not match the number of "
95440 "columns in the referenced table");
95631 ** Allocate heap space to hold an Index object with nCol columns.
95639 i16 nCol, /* Total number of columns in the index */
95673 ** pList is a list of columns to be indexed. pList will be NULL if this
95686 ExprList *pList, /* A list of columns to be indexed */
95707 int nExtraCol; /* Number of extra columns needed */
95911 /* Check to see if we should honor DESC requests on index columns
95924 ** TODO: Issue a warning if two or more columns of the index are identical.
96029 ** If there are different collating sequences or if the columns of
96207 ** of rows that match any particular combination of the first 2 columns
97938 i16 nPk = 1; /* Number of columns in the PRIMARY KEY */
98363 u32 mask; /* Mask of OLD.* columns in use */
98522 ** PRIMARY KEY columns of the index.
100464 ** for FK constraints for which the affected columns are actually
100496 ** requires any FK processing and, if so, which columns of the original
100498 ** implemented using triggers, which of the old.* columns would be
100504 ** sqlite3FkOldmask() - Query for the set of required old.* columns.
100533 ** A foreign key constraint requires that the key columns in the parent
100536 ** search the schema for a unique index on the parent key columns.
100545 ** N is the number of columns in the parent key. The first element of the
100554 ** 1) The named parent key columns do not exist, or
100556 ** 2) The named parent key columns do exist, but are not subject to a
100559 ** 3) No parent key columns were provided explicitly as part of the
100563 ** 4) No parent key columns were provided explicitly as part of the
100565 ** consists of a different number of columns to the child key in
100577 int **paiCol /* OUT: Map of index columns in pFKey */
100581 int nCol = pFKey->nCol; /* Number of columns in parent key */
100619 ** of columns. If each indexed column corresponds to a foreign key
100635 ** map to an explicit list of columns in table pParent. Check if this
100636 ** index matches those columns. Also, check that the index uses
100713 Index *pIdx, /* Unique index on parent key columns in pTab */
100715 int *aiCol, /* Map from parent key columns to child table columns */
100729 ** Check if any of the key columns in the child table row are NULL. If
100962 ** the parent key columns. The affinity of the parent key column should
101152 ** This function returns true if any of the columns that are part of the
101158 int *aChange, /* Array indicating modified columns */
101179 ** This function returns true if any of the columns that are part of the
101249 int *aChange, /* Array indicating UPDATEd columns (or 0) */
101271 Index *pIdx = 0; /* Index on key columns in pTo */
101286 ** on the parent key columns in the parent table. If either of these
101329 /* Request permission to read the parent key columns. If the
101342 ** a cursor to use to search the unique index on the parent key columns
101474 ** to an array of size N, where N is the number of columns in table pTab.
101498 ** operation modifies one or more child or parent key columns. */
101501 /* Check if any child key columns are being modified. */
101506 /* Check if any parent key columns are being modified. */
101519 ** passed a pointer to the list of columns being modified. If it is a
101736 int *aChange, /* Array indicating UPDATEd columns (or 0) */
102162 ** then a list of all (non-hidden) columns for the table is substituted.
102187 ** in other words if the SELECT pulls all columns from a single table
102265 int nColumn; /* Number of columns in the data */
102266 int nHidden = 0; /* Number of hidden columns if TABLE is virtual */
102404 ** all elements of the IDLIST really are columns of the table and
102444 /* Figure out how many columns of data are supplied. If the data
102538 /* Make sure the number of columns in the source data matches the number
102539 ** of columns to be inserted into the table.
102548 "table %S has %d columns but %d values were supplied",
102553 sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
102722 /* Compute data for all columns of the new entry, beginning
102962 int nCol; /* Number of columns */
103533 ** * The index is over the same set of columns
103534 ** * The same DESC and ASC markings occurs on all columns
103544 return 0; /* Different number of columns */
103551 return 0; /* Different columns indexed */
103581 ** Columns are not decoded and reassembled, which greatly improves
103706 return 0; /* Number of columns must be the same in tab1 and tab2 */
103715 return 0; /* Affinity must be the same on all columns */
103718 return 0; /* Collating sequence must be the same on all columns */
103723 /* Default values for second and subsequent columns need to match. */
103728 return 0; /* Default values must be the same for all columns */
103850 ** that the destination table is empty. If all indexed columns use
103858 ** If any of the indexed columns use a collation sequence other than
103938 char **azCols = 0; /* Names of result columns */
105994 ** Set the names of the first N columns to the values in azCol[]
105998 int N, /* Number of columns */
105999 const char **azCol /* Names of columns */
106827 ** Return a single row for each column of the named table. The columns of
106914 /* PRAGMA index_xinfo (newer version with more rows and columns) */
107308 /* Verify that all NOT NULL columns really are NOT NULL */
108756 ExprList *pEList, /* which columns to include in the result */
109142 int nExtra /* Add this many extra columns to the end */
109187 int regPrevKey; /* The first nOBSat columns of the previous row */
109191 int nKey; /* Number of sorting key columns, including OP_Sequence */
109296 int nExpr /* Number of result columns returned by SELECT */
109316 ** to get number columns and the datatype for each column.
109335 int nResultCol; /* Number of result columns */
109347 /* Pull the requested columns.
109361 ** on the right-hand side of an INSERT contains more result columns than
109362 ** there are columns in the table on the left. The error will be caught
109580 ** index with pSO->nExpr+2 columns. Build a key using pSO for the first
109581 ** pSO->nExpr columns, then make sure all keys are unique by adding a
109649 ** Allocate a KeyInfo object sufficient for an index of N key columns and
109650 ** X extra columns.
109718 int nExtra /* Add this many extra columns to the end */
109836 int nColumn, /* Number of columns of data */
110126 ** Generate code that will tell the VDBE the declaration types of columns
110165 ** Generate code that will tell the VDBE the names of columns
110249 i16 *pnCol, /* Write the number of columns here */
110255 Column *aCol, *pCol; /* For looping over result columns */
110256 int nCol; /* Number of columns in the result set */
110287 /* For columns use the column name name */
110620 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
111141 int nCol; /* Number of columns in result set */
111192 " do not have the same number of result columns", selectOpName(p->op));
111201 ** pIn->nSdst columns to be output. pDest is where the output should
111465 int *aPermute; /* Mapping from ORDER BY terms to result set columns */
111714 /* Set the number of output columns
111921 ** of result columns. This is actually a requirement for any compound
111928 ** columns of the sub-query.
111936 ** appear as unmodified result columns in the outer query. But we
112313 ** do not necessarily correspond to columns in SELECT statement pParent,
112561 ** result columns as on the ORDER BY clause. See ticket
112763 sqlite3ErrorMsg(pParse, "table %s has %d values for %d columns",
112828 ** (4) Scan the list of columns in the result set (pEList) looking
112936 ** all columns in all tables. And for every TABLE.* insert the names
112937 ** of all columns in TABLE. The parser inserted a special expression
112940 ** each one to the list of all columns in all tables.
113034 /* In a NATURAL join, omit the join columns from the
113039 /* In a join with a USING clause, omit columns in the
113095 sqlite3ErrorMsg(pParse, "too many columns in result set");
113425 ExprList *pEList = 0; /* List of columns to extract. */
113507 /* Catch mismatch in the declared columns of a view and the number of
113508 ** columns in the SELECT on the RHS */
113510 sqlite3ErrorMsg(pParse, "expected %d columns for '%s' but got %d",
114308 u32 nColumn; /* Number of columns in the result */
114341 ** the names of all columns.
114397 int *pnColumn, /* Write the number of columns of result here */
114873 IdList *pColumn, /* List of columns in pTableName to insert into */
115111 ** least one of the columns in pChanges is being modified.
115117 ExprList *pChanges, /* Columns that change in an UPDATE statement */
115470 ** parameter pChanges is passed the list of columns being modified.
115477 ** in the trigger program. If N is the number of columns in table pTab
115544 ** This function returns a 32-bit bitmask indicating which columns of the
115552 ** are more than 32 columns in the table, and at least one of the columns
115622 ExprList *pChanges, /* The columns to change in the UPDATE statement */
115624 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
115729 int newmask; /* Mask of NEW.* columns accessed by BEFORE triggers */
116099 ** registers associated with columns that are (a) not modified by
116154 ** some of the columns of the row being updated. Load the values for
116155 ** all columns not modified by the update statement into their
116308 ExprList *pChanges, /* The columns to change in the UPDATE statement */
116310 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
117345 ** columns of the table to see if any of them contain the token "hidden".
118525 #define WO_EQUIV 0x0800 /* Of the form A==B, both columns */
119010 u16 nSkip; /* Number of left-most columns to skip */
119065 /* The following testcase is true for indices with redundant columns.
119367 ** left-most columns of the index. It may also contain
120906 ** columns, then the original expression is unchanged and a new virtual
121808 ** A DISTINCT list is redundant if any subset of the columns in the
121843 ** 2. All of the columns in the index are either part of the pDistinct
121848 ** 3. All of those index columns for which the WHERE clause does not
122001 int nKeyCol; /* Number of columns in the constructed index */
122016 Bitmask idxCols; /* Bitmap of columns used for indexing */
122017 Bitmask extraCols; /* Bitmap of additional columns */
122031 /* Count the number of columns that will be added to the index
122075 /* Count the number of additional columns needed to create a
122077 ** columns that are needed by the query. With a covering index, the
122120 /* Add additional columns needed to make the automatic index into
122231 /* If the ORDER BY clause contains only columns in the current
122762 ** columns of the index, and $L is the value in pLower.
123190 ** (3) X skips at least as many columns as Y
123618 continue; /* ignore IS [NOT] NULL constraints on NOT NULL columns */
123870 ** the table is used by an index. Only the first 63 columns are considered.
124547 u8 distinctColumns; /* True if the loop has UNIQUE NOT NULL columns */
124549 u16 nKeyCol; /* Number of key columns in pIndex */
124550 u16 nColumn; /* Total number of ordered columns in the index */
124570 ** (a) All index columns match with WHERE_COLUMN_EQ.
124575 ** We say the WhereLoop is "order-distinct" if the set of columns from
124578 ** order-distinct. A WhereLoop that has no columns in the ORDER BY clause
124582 ** To be order-distinct, the columns must be UNIQUE and NOT NULL.
124651 /* Loop through all columns of the index and deal with the ones
124747 } /* end Loop over all index columns */
124825 ** nOrderby columns and that the first nSorted columns are already in
135082 ** A "position-list" is the list of positions for multiple columns for
135762 int nColumn; /* number of named columns in virtual table */
135764 u8 *abNotindexed; /* True for 'notindexed' columns */
135879 ** indicating that all columns should be searched,
135956 ** where nCol is the number of columns in the queried FTS table. The array
136460 char *zCols; /* List of user defined columns */
136466 /* Create a list of user columns for the virtual table */
136517 char *zContentCols; /* Columns of %_content table */
136519 /* Create a list of user columns for the content table */
136696 ** table has the three user-defined columns "a", "b", and "c", the following
136748 ** of columns in the %_content table (one for the docid plus one for each
136754 ** user-defined text columns, the following string is returned:
136882 ** content=xxx option. It determines the number of and names of the columns
136890 ** *pnCol: Set to the number of columns table xxx has,
136893 ** of each columns name, including the nul-terminator.
136932 int nCol; /* Number of table columns */
136933 int i; /* Used to iterate through columns */
136935 /* Loop through the returned columns. Set nStr to the number of bytes of
136996 int nCol = 0; /* Number of columns in the FTS table */
137015 char **azNotindexed = 0; /* The set of notindexed= columns */
137044 ** + Figures out the number of columns the FTSX table will have, and
137167 ** TABLE statement, use all columns from the content table.
137575 ** "SELECT <columns> FROM %_content WHERE rowid = ?"
137830 ** A position list is list of positions (delta encoded) and columns for
138888 int iColumn, /* Column to query (or -ve for all columns) */
140637 ** varints, where nCol is the number of columns in the FTS3 table.
146501 ** The statement returns the following columns from the %_segdir table:
146893 ** defined columns in the FTS3 table, plus one for the docid field.
148483 ** a position list that may (or may not) feature multiple columns. This
149280 ** where N is the number of user defined columns in the fts3 table plus
149281 ** two. If nCol is the number of user defined columns, then values of the
149290 ** columns of all rows of the table.
150242 ** columns:
151273 int i; /* Used to iterate through table columns */
151422 ** <user columns>,
151686 int nCol; /* Number of columns in table */
152664 ** finished iterating through all offsets for all columns.
153036 int iBestScore = -1; /* Best score of columns checked so far */
153037 int iRead; /* Used to iterate through columns */
153042 /* Loop through all columns of the table being considered for snippets.
153044 ** columns of the FTS3 table. Otherwise, only column iCol is considered.
153173 /* Loop through the table columns, appending offset information to
157259 "Wrong number of columns for an rtree table", /* 1 */
157260 "Too few columns for an rtree table", /* 2 */
157261 "Too many columns for an rtree table" /* 3 */
158516 ** * UPDATE statements may not modify PRIMARY KEY columns.
158532 ** named "data_<target name>" containing the same set of columns as the
158545 ** The order of the columns in the data_% table does not matter.
158573 ** All non-hidden columns (i.e. all columns matched by "SELECT *") of the
158575 ** hidden columns are optional - they are updated by RBU if present in
158589 ** other columns should be set to the values that make up the new record
158600 ** corresponding columns of the data_% table. The values stored in the
158601 ** other columns are not used.
158607 ** stored in the corresponding columns of the data_% table row, as should
158608 ** the new values of all columns being update. The text value in the
158610 ** there are columns in the target database table, and must consist entirely
159052 u8 *abTblPk; /* Array of flags, set on target PK columns */
159053 u8 *abNotNull; /* Array of flags, set on NOT NULL columns */
159067 int nCol; /* Number of columns in current object */
159863 ** }else if( "PRAGMA table_info()" lists one or more "pk" columns ){
160017 /* Populate the azTblCol[] and nTblCol variables based on the columns
160018 ** of the input table. Ignore any input table columns that begin with
160051 /* Check that all non-HIDDEN columns in the destination table are also
160142 char **pzImposterCols, /* OUT: Columns for imposter table */
160145 int *pnBind /* OUT: Trbul number of columns */
160231 ** Assuming the current table columns are "a", "b" and "c", and the zObj
160556 ** More precisely, the "same schema" means the same columns, types,
160611 ** The number of bound variables is equal to the number of columns in
160669 char *zCollist = 0; /* List of indexed columns */
160681 char *zImposterCols = 0; /* Columns for imposter table */
160683 char *zWhere = 0; /* WHERE clause on PK columns */
160861 ** If the zMask string does not specify any columns to update, then this
161318 ** point to the text value indicating the columns to update.
165714 ** non-negative but less than the number of columns in the table, return
165718 ** If parameter iCol is greater than or equal to the number of columns
165724 ** Return the number of columns in the table.
165729 ** non-negative but less than the number of columns in the table, set
165732 ** If parameter iCol is greater than or equal to the number of columns
166230 /* Name of rank and rowid columns */
166256 /* If a NEAR() clump or phrase may only match a specific set of columns,
166257 ** then an object of the following type is used to record the set of columns.
166315 int nCol; /* Number of columns */
166317 u8 *abUnindexed; /* True for unindexed columns */
166506 Fts5Colset *pColset, /* Match these columns only */
169898 Fts5Colset *pColset; /* Columns to search (NULL -> all columns) */
170191 Fts5Colset *pColset, /* Restrict matches to these columns */
171473 int nCol = p ? p->nCol : 0; /* Num. columns already in colset object */
176479 ** start of the next columns hits. */
176814 Fts5Colset *pColset, /* Restrict matches to these columns */
177092 Fts5Colset *pColset, /* Match these columns only */
177306 ** the number of user defined columns in the FTS table.
179635 ** 3. Values for each of the nCol matchable columns.
179636 ** 4. Values for the two hidden columns (<tablename> and "rank").
180259 ** If successful, set *pnCol to the number of indexed columns in the
180979 const char *zDefn, /* Columns etc. for shadow table */
181753 int nCol = p->pConfig->nCol; /* Number of user columns in table */
183854 i64 aVal[3]; /* Up to three columns left of 'term' */
