Lines Matching refs:order
1380 ** where the order in which destructors are called is arbitrary.
1478 ** here in order to indicate success or failure.
1661 ** information is written to disk in the same order as calls
1837 ** information is written to disk in the same order as calls
1896 ** file space based on this hint in order to help writes to the database
1956 ** windows [VFS] in order to provide robustness in the presence of
1980 ** in order for the database to be readable. The fourth parameter to
2051 ** shortly after it is opened in order to provide a custom VFS with access
2054 ** to a function of type (int (*)(void *)). In order to invoke the connection's
2109 ** circumstances in order to fix a problem with priority inversion.
2257 ** structure must be typedefed in order to work around compiler warnings
2348 ** order and set up its I/O subsystem accordingly.
2618 ** changes to SQLite in order to tune SQLite to the specific needs of
2686 ** also used during testing of SQLite in order to specify an alternative
2688 ** order to verify that SQLite recovers gracefully from such
2978 ** argument which is interpreted as a boolean in order to enable or disable
3070 ** Usually, when SQLite uses an external sort to order records according
3076 ** from the database as records are returned in sorted order. The default
3291 ** [VACUUM] in order to reset a database back to an empty database
3670 ** UTF-16 string in native byte order.
3818 ** it must pass the result table pointer to sqlite3_free_table() in order to
3862 ** the first parameter. Note that the order of the
4117 ** return either [SQLITE_OK] or one of these two constants in order
4354 ** order for sqlite3_open16(). ^(A [database connection] handle is usually
4366 ** created using sqlite3_open16() will be UTF-16 in the native byte order.
5102 ** in order to find the underlying cause of the problem. With the "v2" prepare
5387 ** [[byte-order determination rules]] ^The byte-order of
5388 ** UTF16 input text is determined by the byte-order mark (BOM, U+FEFF)
5390 ** the byte order is the native byte order of the host
5391 ** machine for sqlite3_bind_text16() or the byte order specified in
5766 ** [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the
6071 ** The application must finalize every [prepared statement] in order to avoid
6284 #define SQLITE_UTF16 4 /* Use native byte order */
6302 ** be deterministic in order to be used in certain contexts such as
6362 ** These functions are [deprecated]. In order to maintain
6427 ** in the native byte-order of the host machine. ^The
6735 ** the same [byte-order determination rules] as [sqlite3_bind_text16()].
6770 ** a text string which is represented as UTF-8, UTF-16 native byte order,
6807 ** byte-order mark (BOM, U+FEFF) then the BOM is removed from the
6809 ** byte-order specified by the BOM. ^The byte-order specified by
6810 ** the BOM at the beginning of the text overrides the byte-order
6813 ** with bytes 0xfe, 0xff (a big-endian byte-order mark) then the
6880 ** higher order bits are discarded.
6895 ** and a UTF-16 string in native byte order for sqlite3_create_collation16().
6910 ** force strings to be UTF16 with native byte order.
7002 ** the names are passed as UTF-16 in machine native byte order.
7273 ** is returned. Transaction states are (in order of lowest to highest):
7290 ** constants in order to describe the transaction state of schema S
7910 ** zero in the order in which they appear within the CREATE TABLE statement
7938 ** the correct order to satisfy the ORDER BY clause so that no separate
8145 ** This superclass exists in order to define fields of the cursor that
8170 ** must exist in order to be overloaded.)^
9343 ** were created automatically in order to help joins run faster.
10716 ** ^In order to succeed, the database connection must not be in
10743 ** database connection in order to make it ready to use snapshots.)
11330 ** are sorted in the same order in which they were attached (or auto-attached)
11331 ** to the sqlite3_session object. The order in which the changes related to
11418 ** <li> Has the same set of columns declared in the same order, and
11492 ** a single table are grouped together, tables appear in the order in which
11845 ** This function does not change the order in which changes appear within
11939 ** new() and delete(), and in any order.
12037 ** in the same order as for the very first changeset added to the changegroup.
12040 ** appended onto the end of the output changeset, again in the order in
12453 ** In order to rebase a local changeset, the remote changeset must first
12464 ** multiple times, in the same order that the multiple
12553 ** In order to avoid this problem, instead of a single large buffer, input
12705 ** changes to the sessions module in order to tune it to the specific needs
13132 ** order that they occur within the input text.
13695 ** Exactly one of the following macros must be defined in order to
13736 ** We need to define _XOPEN_SOURCE as follows in order to enable
13773 ** testcase() must be evaluated both true and false in order to
13820 ** are included in a few cases in order to enhance the resilience
14526 ** For best performance, an attempt is made to guess at the byte-order
14528 ** -DSQLITE_BYTEORDER=0 is set, then byte-order is determined
15316 ** to be filled with content that is already in sorted order.
15324 #define BTREE_BULKLOAD 0x00000001 /* Used to full index in sorted order */
16768 ** A thread must be holding a mutex on the corresponding Btree in order
17525 ** a comparison routine that defines the order of that sequence.
17540 ** A sort order can be either ASC or DESC.
17542 #define SQLITE_SO_ASC 0 /* Sort in ascending order */
17543 #define SQLITE_SO_DESC 1 /* Sort in ascending order */
17544 #define SQLITE_SO_UNDEFINED -1 /* No sort order specified */
17860 u8 *aSortFlags; /* Sort order for each column. */
17867 #define KEYINFO_ORDER_DESC 0x01 /* DESC sort order */
17889 ** is in DESC order.
17906 KeyInfo *pKeyInfo; /* Collation and sort-order information */
17943 ** While parsing a CREATE TABLE or CREATE INDEX statement in order to
18339 ** In order to try to keep memory usage down, the Expr.a.zEName field
18459 ** In the colUsed field, the high-order bit (bit 63) is set if the table
18873 ** the parser and down into all the parser action routine in order to
20772 /* EVIDENCE-OF: R-02982-34736 In order to maintain full backwards
22478 ** order of the parameters is reversed.
24148 ** information to each allocation in order to help detect and fix memory
24971 ** the current mem3.iKeyBlk with the new larger chunk. In order for
25599 ** two in order to create a new free block of size iLogsize.
29100 ** Note that the number is in the usual order, not reversed as with
29211 /* Set length to the number of bytes needed in order to display
30548 ** Random numbers are used by some of the database backends in order
31154 ** all that is required is to swap the byte order. This case is handled
31316 ** This routine checks for a byte-order mark at the beginning of the
31521 ** or to bypass normal error detection during testing in order to let
32217 }else if( nonNum ){ /* UTF16 with high-order bytes non-zero */
32449 ** inline in order to work around bugs in the RVT compiler.
34511 ** Do not accept any file descriptor less than this value, in order to avoid
35007 ** (1) Only the pLockMutex mutex must be held in order to read or write
35046 ** Must hold unixBigLock in order to read or write this variable.
35458 ** in order to coordinate access between separate database connections
35524 ** slightly in order to be compatible with Windows95 systems simultaneously
36085 ** The file suffix added to the data base filename in order to create the
37709 ** writes a single byte into that file in order to work around a bug
37710 ** in the OS-X msdos filesystem. In order to avoid problems with upper
38610 ** last page in order to extend the file. But writing to all new
42586 ** In order to facilitate testing on a WinNT system, the test fixture
44078 ** the provided arguments. The type argument must be 1 in order to set the
44079 ** data directory or 2 in order to set the temporary directory. The zValue
47027 ** If not, return SQLITE_ERROR. The number 17 is used here in order to
47410 ** will open a journal file shortly after it is created in order to do
49231 ** Opcode 5 is used to deliberately induce a fault in order to
49344 ** PgHdr.pDirtyNext and pDirtyPrev. The list is maintained in LRU order
49359 PgHdr *pDirty, *pDirtyTail; /* List of dirty pages in LRU order */
49800 ** must be called after sqlite3PcacheFetch() in order to get a usable
50006 ** Merge two lists of pages connected by pDirty and in pgno order.
50036 ** Sort the list of pages in accending order by pgno. Pages are
50342 ** and is therefore often faster. Mode 2 requires a mutex in order to be
50723 ** allocating a new page cache entry in order to avoid stressing
51499 ** are inserted into the RowSet in an arbitrary order. Inserts
51504 ** elements of the RowSet in sorted order. Once this extraction
51544 ** be possible, but the feature was not used, so it was removed in order
51722 ** assumed to each already be in sorted order.
51756 ** Sort all elements on the list of RowSetEntry objects into order of
51857 ** as deep as it needs to be in order to contain the entire list.
52465 ** database file in function pagerStress() in order to free up
52668 ** to the file-system in order to free up memory).
52681 ** is larger than the database page-size in order to prevent a journal sync
53135 ** This routine has external linkage in order to suppress compiler warnings
53256 ** Write a 32-bit integer into a string buffer in big-endian byte order.
54563 ** for page 1 which is held in use in order to keep the lock on the
55279 /* Verify that the page list is in accending order */
55465 ** performed in the order specified:
56479 ** the pages are written out to the database file in list order. Writing
56913 ** the specific order of the filenames and the \0 separators between them
56918 ** order and formatting if possible. In particular, the details of the
56936 ** specific formatting and order of the various filenames, so if the format
57285 /* If we cannot open the rollback journal file in order to see if
57449 ** In order to get pager_unlock() to do this, set Pager.eState to
57472 ** occurring on the very first access to a file, in order to save a
59216 /* In order to be able to rollback, an in-memory database must journal
59932 ** big-endian format regardless of which byte order is used to compute
59943 ** in reverse order (the largest fibonacci weight occurs on the first element
60004 ** byte order of the host computer.
60080 ** examined in order to either find the last entry for page P, or to
60088 ** Note that entries are added in order of increasing K. Hence, one
60247 ** order to read from any aReadMark[] entries.
60355 ** all frames in the WAL in database page order. Where two or more frames
60514 int nativeCksum, /* True for native byte-order, false for non-native */
60614 int nativeCksum; /* True for native byte-order checksums */
60645 int nativeCksum; /* True for native byte-order checksums */
61524 ** pages in the WAL following frame nBackfill in ascending order. Frames
62090 ** When reading, read [0] first then [1]. Writes are in the reverse order.
63435 ** an out-of-order write following a WAL restart could result in
64045 ** | cell pointer | | 2 bytes per cell. Sorted order.
64052 ** | cell content | | Arbitrary order interspersed with freeblocks.
64075 ** content area. The cell pointers occur in sorted order. The system strives
64085 ** increasing order. Because a freeblock must be at least 4 bytes in size,
64098 ** contiguous or in order, but cell pointers are contiguous and in order.
64168 ** SQLite database in order to identify the file as a real database.
64614 ** in order to keep track of some global state information.
64708 ** To avoid deadlocks, multiple Btrees are locked in the same order
64718 ** connected by pNext and pPrev should be in sorted order by
64766 ** order.
64826 ** Enter the mutexes in accending order by BtShared pointer address
66591 ** allocation. This routine might need to defragment in order to bring
66594 ** allocation is being made in order to insert a new cell, so we will
66711 /* The list of freeblocks must be in ascending order. Find the
66908 /* Freeblock not in ascending order */
67547 ** The list is kept in ascending order by pBt address.
67773 ** order to free up memory.
67805 ** Change the way data is synced to disk in order to increase or decrease
68353 ** returned when there is already a read-lock in order to avoid a deadlock.
69330 ** are also met. These are the conditions that must be met in order
70266 ** in ascending order.
70291 ** key in ascending order.
71317 ** usableSize/4 - 8 entries will be reported as corrupt. In order
71326 ** order that database files created by newer versions of SQLite can be
71748 ** sorted order. This invariants arise because multiple overflows can
71752 assert( j==0 || pPage->aiOvfl[j-1]<(u16)i ); /* Overflows in sorted order */
71849 ** The order of cells is in the array is for an index btree is:
71851 ** 1. All cells from Child-1 in order
71853 ** 3. All cells from Child-2 in order
71855 ** 5. All cells from Child-3 in order
72028 ** area must be extended to before this point in order to accomodate all
72660 /* Make nMaxCells a multiple of 4 in order to preserve 8-byte
72727 ** adjacent and are inserted in order. There is an assert() tagged
72969 ** Reassign page numbers so that the new pages are in ascending order.
72970 ** This helps to keep entries in the disk file in order so that a scan
72988 ** we do the detection here in order to avoid populating the pager
73150 /* Now update the actual sibling pages. The order in which they are updated
74346 ** order either to increase the database filesize, or to decrement the
74982 ** 2. Make sure integer cell keys are in order.
75112 checkAppendMsg(pCheck, "Rowid %lld out of order", info.nKey);
75189 /* EVIDENCE-OF: R-06866-39125 Freeblocks are always connected in order of
75203 ** The loop below pulls entries from the min-heap in order and compares
75747 ** structure, in that order.
76778 ** to be a double-zero byte at an even byte boundary in order to
78793 ** Set a debugger breakpoint on the following routine in order to
82120 ** float in the wrong order. And that error has been propagated
82124 ** ABI get the byte order right.
82128 ** enabled, some asserts below will ensure that the byte order of
82249 ** byte order. Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is
82516 rc = -rc; /* Invert the result for DESC sort order. */
82696 ** than pMem2. Sorting order is NULL's first, followed by numbers (integers
85893 ** Various scripts scan this source file in order to generate HTML
85931 ** field of the sqlite3 structure is set in order to simulate an interrupt.
86894 /* Most jump operations do a goto to this spot in order to update
88078 ** order: NE, EQ, GT, LE, LT, GE */
88190 ** If P5 has the OPFLAG_PERMUTE bit set, then the order of comparison is
88193 ** order.
88211 int bRev; /* True for DESCENDING sort order */
90068 ** by the cursor. The high-order bit is set if any column after
90101 ** This opcode leaves the cursor configured to move in forward order,
90119 ** This opcode leaves the cursor configured to move in forward order,
90137 ** This opcode leaves the cursor configured to move in reverse order,
90155 ** This opcode leaves the cursor configured to move in reverse order,
91363 ** position in order that they can write to the same table. If P3==0
91505 ** This opcode leaves the cursor configured to move in reverse order,
91611 ** This opcode leaves the cursor configured to move in forward order,
92116 ** might be moved into the newly deleted root page in order to keep all
92128 ** db in order to avoid introducing an incompatibility between autovacuum
92369 ** is dropped from disk (using the Destroy opcode) in order to keep
92384 ** in order to keep the internal representation of the
92397 ** is dropped from disk (using the Destroy opcode) in order to keep
92842 ** visited in order to complete the query.
94805 ** The interfaces above must be called in a particular order. Write() can
94942 ** combined into one big PMA in order to be able to step through the sorted
94943 ** records in order.
95090 ** PMA, in sorted order. The next key to be read is cached in nKey/aKey.
95665 ** order of the primary key, which happens to be make up the final part
96289 ** * One or more records packed end-to-end in order of ascending keys.
96881 /* PmaReaders should be normally initialized in order, as if they are
97324 ** in sorted order.
100129 ** If the order-by term is an integer I between 1 and N (where N is the
100132 ** the order-by term is an identifier that corresponds to the AS-name of
100174 ** order-by term to a copy of the result-set expression */
100230 ** this routine in the correct order.
100474 ** The "x" term of the order by is replaced by "a+b" to render:
101022 ** However, if the OP_Commuted flag is set, then the order of the operands
102431 ** Set the sort order for the last element on the given ExprList.
102846 ** be promoted into the WHERE clause. In order for such a promotion to work,
103923 ** so that the fields are in the same order as an existing index. The
103924 ** aiMap[] array contains a mapping from the original LHS field order to
103925 ** the field order that matches the RHS index.
104093 /* Jumps here in order to return true. */
105290 ** VDBE program, in order to factor it out of the evaluation loop.
106343 ** aggregate function, in order to implement the
107721 ** return all column name tokens in the order that they are encountered
109383 ** be out of order. */
111856 ** Run the parser and code generator recursively in order to generate
111914 ** names is done.) The search order is TEMP first, then MAIN, then any
111969 /* Attached databases are in order of attachment */
112081 ** for duplicate index names is done.) The search order is
113680 ** high-order bit of colNotIdxed is always 1. All unindexed columns
113688 ** the actual table at hand in order to recompute the virtual column, if
114256 ** The parser calls this routine in order to create a new VIEW
114503 ** in order to be certain that we got the right one.
114569 ** table and index root-pages in order, starting with the numerically
115093 ** a different order from the main table.
115186 int sortOrder, /* Sort order of primary key when pList==NULL */
115346 ** "sqlite3_butoindex..." in order to make the names distinct.
115735 ** order. So we have to reorder at most one index. */
116523 ** possible to abort a statement prior to completion. In order to
117202 ** 2: UTF16 byte order change required and function takes any number of args.
117205 ** 5: UTF16 byte order conversion required - argument count matches exactly
117467 ** in order to generate code for DELETE FROM statements.
121640 ** before actually dropping it in order to check FK constraints.
122818 u8 bIdListInOrder; /* True if IDLIST is in table order */
122954 ** order. This enables an optimization that avoids shuffling the
122955 ** columns into storage order. False negatives are harmless,
123219 ** are written in storage order into registers starting with regData.
123584 ** the indexes of a table in the order provided in the Table->pIndex list.
123586 ** the indexes in a different order. The following data structures accomplish
123590 ** of a table in either Index.pNext order, or in some other order established
123677 ** indices where aRegIdx[i]==0. The order of indices in aRegIdx[] is
123678 ** the same as the order of indices on the linked list of indices
123947 ** order:
123956 ** could happen in any order, but they are grouped up front for
123960 ** The order of constraints used to have OE_Update as (2) and OE_Abort
123964 ** Constraint checking code is generated in this order:
123994 ** checked first and in order. */
124333 ** must be explicitly deleted in order to ensure any pre-update hook
125034 ** bypassed during testing, in order to exercise other corruption tests
125172 ** order. In this case, instead of seeking within the b-tree as part
125181 ** sorted order. */
125416 ** WARNING: In order to maintain backwards compatibility, add new
126162 ** in order to preserve backwards compatibility.
126698 ** Call this routine when the database connection is closing in order
126922 ** lexicographical order to facility a binary search of the pragma name.
132015 ** are evaluated in order to get the data for this row. If srcTab is
132328 ** ORDER BY in this case since the order of entries in the set
132330 ** case the order does matter */
132387 /* Write the results into a priority queue that is order according to
133489 ** ORDER BY order and the first entry is extracted for each cycle. Without
133553 ** the Distinct table must be exactly one greater than Queue in order
134612 /* Jump to the this point in order to terminate the query.
135355 ** The middle slot is expanded to two slots in order to make space
137644 ** being unused if the data can be extracted in pre-sorted order.
137779 int groupBySort; /* Rows come from source in GROUP BY order */
137804 ** in the correct order. It also may not - the GROUP BY might use a
137812 ** ASC or DESC order - only that each group is returned contiguously.
137815 ** order that makes the ORDER BY redundant. */
137952 /* Begin a loop that will extract all source rows in GROUP BY order.
137955 ** in the right order to begin with.
137965 /* The optimizer is able to deliver rows in group by order so
137971 /* Rows are coming out in undetermined order. We have to push
137973 ** then loop over the sorting index in order to get the output
137974 ** in sorted order
138023 ** will naturally deliver rows in the order required by the ORDER BY
138109 ** order to signal the caller to abort.
138821 ** in order to complete the process of building the trigger.
140095 ** of the table, in order. The results of the query are written to ephemeral
143172 ** statement in order to come into existance. Eponymous virtual table
143311 ** This file was split off from where.c on 2015-06-06 in order to reduce the
143365 ** nested loops as implemented). The order of WhereLevel objects determines
143366 ** the loop nested order, with WhereInfo.a[0] being the outer loop and
143546 ** fields. The translation is used in order to maximize the number of
143551 ** beginning with 0 in order to make the best possible use of the available
144293 ** not be in the correct order for indexing.
144298 ** order. The modified IN expression is returned. The caller is responsible
144309 ** Since only columns e and c can be used with the index, in that order,
144405 int bRev, /* True for reverse-order IN operations */
144584 int bRev, /* Reverse the order of IN operators */
145202 int bRev; /* True if we need to scan in reverse order */
145535 ** constraints but an index is selected anyway, in order
145536 ** to force the output order to conform to an ORDER BY.
145602 ** bottom bit indicates whether the search order is ASC or DESC. */
145641 /* If we are doing a reverse order scan on an ascending index, or
145642 ** a forward order scan on a descending index, interchange the
146571 ** In order for the operator to be optimizible, the RHS must be a string
148377 ** to emit rows in increasing order, and if the last row emitted by the
148413 ** additional looping is required. If the output order is such that
148437 ** Return the VDBE address or label to jump to in order to continue
148446 ** Return the VDBE address or label to jump to in order to break
148918 ** iAutoidxCur cursor, in order to generate unique rowids for the
150710 ** order of the index column is the same as the sort order of the
151232 ** log(nRow) factor is omitted from a non-covering index scan in order to
151613 ** consume the ORDER BY clause because (1) the order of IN terms
151614 ** is not necessarily related to the order of output terms and
152031 ** and DISTINCT do not require rows to appear in any particular order as long
152033 ** the pOrderBy terms can be matched in any order. With ORDER BY, the
152034 ** pOrderBy terms must be matched in strict left-to-right order.
152043 Bitmask *pRevMask /* OUT: Mask of WhereLoops to run in reverse order */
152046 u8 rev; /* Composite sort order */
152047 u8 revIdx; /* Index sort order */
152048 u8 isOrderDistinct; /* All prior WhereLoops are order-distinct */
152078 ** We say the WhereLoop is "order-distinct" if the set of columns from
152081 ** order-distinct. A WhereLoop that has no columns in the ORDER BY clause
152082 ** is not order-distinct. To be order-distinct is not quite the same as being
152084 ** are NULL and NULL values are equivalent for the purpose of order-distinct.
152085 ** To be order-distinct, the columns must be UNIQUE and NOT NULL.
152089 ** automatically order-distinct.
152194 ** the loop need to be marked as not order-distinct because it can
152227 /* Get the column number in the table (iColumn) and sort order
152282 /* Make sure the sort order is compatible in an ORDER BY clause.
152283 ** Sort order is irrelevant for a GROUP BY clause. */
152353 ** BY clause - and so any order that groups rows as required satisfies the
152357 ** whether or not the rows are really being delivered in sorted order, or
152358 ** just in some other order that provides the required grouping. However,
152361 ** true if the rows really will be sorted in the specified order, or false
152394 ** order.
152407 ** Or, if the order-by clause has X terms but only the last Y
152408 ** terms are out of order, then block-sorting will reduce the
152509 ** the ORDER BY clause are already in order, where X is the array
152528 ** are already in the requested order. Set isOrdered to nOrderBy to
152547 Bitmask revMask = 0; /* Mask of rev-order loops for (..) */
152581 ** where the rows emerge in the correct order without any sorting
152623 sqlite3DebugPrintf("Skip %s cost=%-3d,%3d,%3d order=%c\n",
152642 sqlite3DebugPrintf("New %s cost=%-3d,%3d,%3d order=%c\n",
152666 "Skip %s cost=%-3d,%3d,%3d order=%c",
152669 sqlite3DebugPrintf(" vs %s cost=%-3d,%3d,%3d order=%c\n",
152684 "Update %s cost=%-3d,%3d,%3d order=%c",
152687 sqlite3DebugPrintf(" was %s cost=%-3d,%3d,%3d order=%c\n",
152723 sqlite3DebugPrintf(" %s cost=%-3d nrow=%-3d order=%c",
152973 ** in order to complete the WHERE clause processing.
152994 ** Note that the loops might not be nested in the order in which they
152995 ** appear in the FROM clause if a different order is better able to make
153960 ** in order to support window function processing. For example, with the
153977 ** (in this case max()) to process rows sorted in order of (c, d), which
154012 ** so that both min() and max() may process rows in the order defined by
154879 ** are invoked in the correct order as described under "SELECT REWRITING"
155457 ** order to reduce memory requirements - it would always be safe just
155969 ** offset PRECEDING/FOLLOWING frame boundaries. Assuming "ASC" order for
155978 ** If the sort-order for the ORDER BY term in the window is DESC, then the
155981 ** ">" becomes "<", and so on. So, with DESC sort order, if the argument op
156396 ** cases because they change the order in which the three cursors (csrStart,
162961 ** For ASCII, any character with the high-order bit set is
163437 ** with tokens TK_SEMI and 0, in that order. */
164705 ** boolean in order to enable or disable the use of covering indices for
166129 ** A global function must exist in order for name resolution to work
168116 ** The integer returned reveals the byte-order of the computer on which
168343 ** consecutively in memory, in that order. The database filename is prefixed
169103 ** varint. We encode variable-length integers in little-endian order
169208 ** the %_segments table in sorted order. This means that when the end
169312 ** leaf nodes are written in to the %_segments table in order, this
169902 u8 bDescIdx; /* True if doclists are in reverse order */
169983 u8 bDesc; /* True to sort in descending order */
170116 ** Candidate values for Fts3Query.eType. Note that the order of the first
170117 ** four values is in order of precedence when parsing expressions. For
170873 ** to return the docid, followed by each column of text data in order
171270 { "order", 5 }, /* 4 -> ORDER */
171317 sqlite3Fts3ErrMsg(pzErr, "unrecognized order: %s", zVal);
171520 /* Figure out the page-size for the database. This is required in order to
171608 ** are three possible strategies, in order of preference:
171722 ** docid) order. Both ascending and descending are possible.
172184 ** of the previous position is needed in order to compute the value of
172224 ** order and with any duplicates removed. All pointers are
172573 ** sorted in either ascending or descending order.
172581 ** input doclists are sorted in ascending order, parameter bDescDoclist
172582 ** should be false. If they are sorted in ascending order, it should be
172614 ** are delta encoded. If they are in ascending order (bDescDoclist==0),
172618 ** ascending order).
172640 ** order.
172688 ** If the docids in the input doclists are sorted in ascending order,
172690 ** order, it should be passed a non-zero value.
172884 ** doclists are stored in order=ASC order, this padding would not be
172887 ** not true for order=DESC. For example, a doclist containing (1, -1)
174416 ** scanned in forward order, and the phrase consists of
174460 ** pending-terms lists when writing to databases with "order=desc".
174463 ** descending (parameter bDescIdx==1) order of docid. Regardless, this
175024 /* Iterate through all tokens in this AND/NEAR cluster, in ascending order
175236 ** matching rows in docid order. Ascending order if Fts3Cursor.bDesc is zero,
175834 ** order. For this reason, even though it seems more defensive, the
176267 /* This vtab delivers always results in "ORDER BY term ASC" order. */
177208 ** is defined), the order of the operators in precedence from highest to
177674 ** of each column in the target fts3 table, in order from left to right.
178486 ** In these routine, the letters are in reverse order. So the 'y' rule
178526 ** In this routine z[] is in reverse order. So we are really looking
178603 ** The input word *pz and zFrom are both in reverse order. zTo
178604 ** is in normal order.
178905 /* z[] is now the stemmed word in reverse order. Flip it back
178906 ** around into forward order and return.
180532 /* Return segments in order from oldest to newest.*/
180607 /* Return segments in order from oldest to newest.*/
181701 /* A pending-terms seg-reader for an FTS4 table that uses order=desc.
181702 ** Pending-terms doclists are always built up in ascending order, so
181909 ** "firebird", then the iterator visits the following 'terms' (in the order
181962 ** objects in term order using qsort(). This uses the same comparison
182104 ** the final (nSegment-nSuspect) members are already in sorted order
182106 ** the array around until all entries are in sorted order.
183124 ** forward. Then sort the list in order of current term again.
183391 ** order. The contents of level -1 (which is never used, except
187103 ** hits for a single phrase on a single row in order to calculate the
188965 ** by which the JsonNode counter should increment in order to go to the
191097 ** file. Call the following routines in order to register the various SQL
191484 u32 u; /* Unsigned for byte-order conversions */
191561 ** operators in order to constrain a search.
191640 ** For best performance, an attempt is made to guess at the byte-order
191642 ** -DSQLITE_RUNTIME_BYTEORDER=1 is set, then byte-order is determined
193130 ** table scan strategies to choose from (in order from most to
193488 ** (nIdx-1) in no particular order. This function sorts the values
193560 ** (nIdx-1) in no particular order. This function sorts the values
195694 ** We have to use these macros, rather than just say p->a[i] in order
196089 ** counter-clockwise (the correct winding order according to RFC7946)
196090 ** then reverse the order of the vertexes in polygon X.
196093 ** winding order of its input.
196592 ** Sort a list of GeoSegments in order of increasing Y and in the event of
197025 ** table scan strategies to choose from (in order from most to
198417 ** updates are done in sorted key order.
198494 ** The problem is that in order to update a b-tree, the leaf page (at least)
198500 ** random order, access to pages within the database is also likely to be in
198501 ** random order, which is itself quite inefficient.
198569 ** The order of the columns in the data_% table does not matter.
198577 ** tables within the RBU database are always processed in order sorted by
198579 ** of the RBU tables the user can therefore control the order in which they
198684 ** table in "rowid" order is roughly the same as reading them sorted by
199227 ** iterator visits, in order:
200430 ** in order, for the current table. Before each column name, add the text
201354 /* Create the SELECT statement to read keys in sorted order */
202179 ** In order to ensure that there are no database readers, an EXCLUSIVE
203869 ** recovery, the connection must request *-shm pages in order
204314 ** information from an SQLite database in order to implement the
204353 ** sort-order than its child page:
204552 /* Records are always returned in ascending order of (name, path).
205748 ** but may occur in any order (i.e. deletes, updates and inserts are all
205768 ** the i'th column of the table, counting from left to right in the order
206032 ** order to use this macro, the entire data structure must be represented
206033 ** as a series of unsigned integers. In order to calculate a hash-key value
207415 ** simply added to the start of it in order to ensure that tables
207416 ** appear in the correct order when a changeset or patchset is
210561 ** the right order. */
211579 ** order that they occur within the input text.
211928 ** This exists in order to allow the fts5_index.c module to return a
212138 #define FTS5INDEX_QUERY_DESC 0x0002 /* Docs in descending rowid order */
215923 ** arguments passed to it are, in order:
216238 int bDesc; /* Iterate in descending rowid order */
217191 ** Nodes that point to values that come later in the iteration order are
217194 ** This means that if the iteration order is ASC, then numerically larger
217239 ** iterator skips through rowids in the default ascending order, this means
217666 ** order. Or, if it is zero, in ascending order.
217668 ** If iterating in ascending rowid order (bDesc==0), the first document
217670 ** to parameter iFirst. Or, if iterating in ascending order (bDesc==1),
217686 ** the iteration order, move to document iFirst or later. */
218175 /* Check that the array is in order and contains no duplicate entries. */
219308 Fts5HashEntry *pScanNext; /* Next entry in sorted order */
219638 ** each sorted in key order. This function merges the two lists into a
219683 ** in sorted order. The hash table is cleared before returning. It is
220223 ** it is set, iterate through rowid in descending order instead of the
220224 ** default ascending order.
220325 int bRev; /* True to iterate in reverse order */
221902 ** function sets the iterator up so that iterates in reverse order through
223287 int bDesc, /* True for descending rowid order */
224748 PrefixMerger *pNext; /* Next in docid/poslist order */
224802 ** a linked-list starting at pHead in ascending order of rowid. Avoid
225396 ** in ascending or descending rowid order.
225539 ** iSegid/iLeaf is iterated in forwards or reverse order.
225682 ** the index is disabled are the same. In both ASC and DESC order.
226673 ** cursor iterates in ascending order of rowids, iFirstRowid is the lower
226679 ** If the cursor iterates in descending order of rowid, iFirstRowid
227374 ** (in the cursors sort order - ASC or DESC) than the current rowid.
228920 ** concatenated position lists for each phrase, in order.
232886 ** inline in order to work around bugs in the RVT compiler.
233448 /* This virtual table always delivers results in ascending order of
233452 ** are already in sorted order. */