Lines Matching defs:Blob
650 ** [prepared statements], [sqlite3_blob_close | close] all [BLOB handles], and
654 ** statements, BLOB handlers, and/or unfinished sqlite3_backup objects then
657 ** statements, unclosed BLOB handlers, and/or unfinished sqlite3_backups,
661 ** connection after all prepared statements are finalized, all BLOB handles
789 #define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */
4679 ** <dd>The maximum size of any string or BLOB or table row, in bytes.<dd>)^
5258 ** ^The fifth argument to the BLOB and string binding interfaces controls
5261 ** ^ (1) A destructor to dispose of the BLOB or string after SQLite has finished
5262 ** with it may be passed. ^It is called to dispose of the BLOB or string even
5288 ** ^The sqlite3_bind_zeroblob() routine binds a BLOB of length N that
5293 ** [sqlite3_blob_open | incremental BLOB I/O] routines.
5294 ** ^A negative value for the zeroblob results in a zero-length BLOB.
5319 ** ^[SQLITE_TOOBIG] might be returned if the size of a string or BLOB
5664 ** <li> BLOB
5693 ** <tr><td><b>sqlite3_column_blob</b><td>→<td>BLOB result
5702 ** <tr><td><b>sqlite3_column_bytes</b><td>→<td>Size of a BLOB
5753 ** If the result is a BLOB or a TEXT string, then the sqlite3_column_bytes()
5755 ** of that BLOB or string.
5757 ** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes()
5758 ** routine returns the number of bytes in that BLOB or string.
5766 ** ^If the result is a BLOB or UTF-16 string then the sqlite3_column_bytes16()
5767 ** routine returns the number of bytes in that BLOB or string.
5783 ** value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer.
5815 ** <tr><td> NULL <td> BLOB <td> Result is a NULL pointer
5818 ** <tr><td> INTEGER <td> BLOB <td> Same as INTEGER->TEXT
5821 ** <tr><td> FLOAT <td> BLOB <td> [CAST] to BLOB
5824 ** <tr><td> TEXT <td> BLOB <td> No change
5825 ** <tr><td> BLOB <td> INTEGER <td> [CAST] to INTEGER
5826 ** <tr><td> BLOB <td> FLOAT <td> [CAST] to REAL
5827 ** <tr><td> BLOB <td> TEXT <td> [CAST] to TEXT, ensure zero terminator
5838 ** <li> The initial content is a BLOB and sqlite3_column_text() or
6337 ** <tr><td><b>sqlite3_value_blob</b><td>→<td>BLOB value
6348 ** <tr><td><b>sqlite3_value_bytes</b><td>→<td>Size of a BLOB
6765 ** an application-defined function to be the BLOB whose content is pointed
6771 ** a BLOB containing all zero bytes and N bytes in size.
6801 ** error indicating that a string or BLOB is too long to represent.
6846 ** function as the destructor on the text or BLOB result when it has
6850 ** assumes that the text or BLOB result is in constant space and does not
8390 ** CAPI3REF: A Handle To An Open BLOB
8391 ** KEYWORDS: {BLOB handle} {BLOB handles}
8393 ** An instance of this object represents an open BLOB on which
8394 ** [sqlite3_blob_open | incremental BLOB I/O] can be performed.
8398 ** can be used to read or write small subsections of the BLOB.
8399 ** ^The [sqlite3_blob_bytes()] interface returns the size of the BLOB in bytes.
8404 ** CAPI3REF: Open A BLOB For Incremental I/O
8408 ** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located
8410 ** in other words, the same BLOB that would be selected by:
8422 ** ^If the flags parameter is non-zero, then the BLOB is opened for read
8423 ** and write access. ^If the flags parameter is zero, the BLOB is opened for
8426 ** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is stored
8440 ** a TEXT or BLOB value)^,
8442 ** constraint and the blob is being opened for read/write access)^,
8444 ** column zColumn is part of a [child key] definition and the blob is
8452 ** A BLOB referenced by sqlite3_blob_open() may be read using the
8454 ** [sqlite3_blob_write()]. The [BLOB handle] can be moved to a
8456 ** interface. However, the column, table, or database of a [BLOB handle]
8457 ** cannot be changed after the [BLOB handle] is opened.
8459 ** ^(If the row that a BLOB handle points to is modified by an
8461 ** then the BLOB handle is marked as "expired".
8463 ** other than the one the BLOB handle is open on.)^
8465 ** an expired BLOB handle fail with a return code of [SQLITE_ABORT].
8466 ** ^(Changes written into a BLOB prior to the BLOB expiring are not
8467 ** rolled back by the expiration of the BLOB. Such changes will eventually
8471 ** the opened blob. ^The size of a blob may not be changed by this
8473 ** blob.
8477 ** zero-filled blob to read or write using the incremental-blob interface.
8479 ** To avoid a resource leak, every open [BLOB handle] should eventually
8497 ** CAPI3REF: Move a BLOB Handle to a New Row
8500 ** ^This function is used to move an existing [BLOB handle] so that it points
8503 ** changed. ^The database, table and column on which the blob handle is open
8504 ** remain the same. Moving an existing [BLOB handle] to a new row is
8508 ** it must exist and there must be either a blob or text value stored in
8510 ** it does not contain a blob or text value, or if another error occurs, an
8511 ** SQLite error code is returned and the blob handle is considered aborted.
8513 ** [sqlite3_blob_reopen()] on an aborted blob handle immediately return
8514 ** SQLITE_ABORT. ^Calling [sqlite3_blob_bytes()] on an aborted blob handle
8522 ** CAPI3REF: Close A BLOB Handle
8525 ** ^This function closes an open [BLOB handle]. ^(The BLOB handle is closed
8529 ** ^If the blob handle being closed was opened for read-write access, and if
8531 ** blob handles or active write statements, the current transaction is
8536 ** open blob handle results in undefined behavior. ^Calling this routine
8539 ** is passed a valid open blob handle, the values returned by the
8545 ** CAPI3REF: Return The Size Of An Open BLOB
8548 ** ^Returns the size in bytes of the BLOB accessible via the
8549 ** successfully opened [BLOB handle] in its only argument. ^The
8550 ** incremental blob I/O routines can only read or overwrite existing
8551 ** blob content; they cannot change the size of a blob.
8553 ** This routine only works on a [BLOB handle] which has been created
8561 ** CAPI3REF: Read Data From A BLOB Incrementally
8564 ** ^(This function is used to read data from an open [BLOB handle] into a
8566 ** from the open BLOB, starting at offset iOffset.)^
8568 ** ^If offset iOffset is less than N bytes from the end of the BLOB,
8571 ** ^The size of the blob (and hence the maximum value of N+iOffset)
8574 ** ^An attempt to read from an expired [BLOB handle] fails with an
8580 ** This routine only works on a [BLOB handle] which has been created
8590 ** CAPI3REF: Write Data Into A BLOB Incrementally
8593 ** ^(This function is used to write data into an open [BLOB handle] from a
8595 ** into the open BLOB, starting at offset iOffset.)^
8603 ** ^If the [BLOB handle] passed as the first argument was not opened for
8607 ** This function may only modify the contents of the BLOB; it is
8608 ** not possible to increase the size of a BLOB using this API.
8609 ** ^If offset iOffset is less than N bytes from the end of the BLOB,
8611 ** BLOB (and hence the maximum value of N+iOffset) can be determined
8615 ** ^An attempt to write to an expired [BLOB handle] fails with an
8616 ** error code of [SQLITE_ABORT]. ^Writes to the BLOB that occurred
8617 ** before the [BLOB handle] expired are not rolled back by the
8619 ** have been overwritten by the statement that expired the BLOB handle
8622 ** This routine only works on a [BLOB handle] which has been created
11207 ** When the [sqlite3_blob_write()] API is used to update a blob column,
12026 ** rows a zero-length blob (SQL value X'') is stored in the changeset or
12032 ** zero-length blob back to a NULL value when updating the sqlite_stat1
12275 ** A patchset blob may be used with up to date versions of all
12278 ** attempting to use a patchset blob with old versions of the
12346 ** Assuming the changeset blob was created by one of the
12365 int nChangeset, /* Size of changeset blob in bytes */
12366 void *pChangeset /* Pointer to blob containing changeset */
12370 int nChangeset, /* Size of changeset blob in bytes */
12371 void *pChangeset, /* Pointer to blob containing changeset */
13091 void *pChangeset, /* Changeset blob */
13106 void *pChangeset, /* Changeset blob */
13123 void *pChangeset, /* Changeset blob */
13824 ** CAPI3REF: Add a blob to a changegroup
13827 ** the currently accumulated change with a blob value instead of a 64-bit
13828 ** integer. Parameter pVal points to a buffer containing the blob. Parameter
13829 ** nVal is the size of the blob in bytes.
14693 ** The maximum length of a TEXT or BLOB in bytes. This also
17190 ** BTREE_BLOBKEY, the key is an arbitrary BLOB and no content is stored
19254 ** record BLOB generated by the OP_MakeRecord
19352 ** for a numeric type is a single comparison. And the BLOB type is first.
19722 ** the key of an index. A blob encoding of a record is created by
24244 "BLOB",
24329 /* A cache of large TEXT or BLOB values in a VdbeCursor */
24404 VdbeTxtBlbCache *pCache; /* Cache of large TEXT or BLOB values */
24430 ** Large TEXT or BLOB values can be slow to load, so we want to avoid
24431 ** loading them more than once. For that reason, large TEXT and BLOB values
24510 char *z; /* String or BLOB value */
24556 ** * MEM_Blob A blob, stored in Mem.z length Mem.n.
24560 ** * MEM_Blob|MEM_Zero A blob in Mem.z of length Mem.n plus
24584 #define MEM_Blob 0x0010 /* Value is a BLOB */
24594 #define MEM_Zero 0x0400 /* Mem.i contains count of 0s appended to blob */
24598 /* Bits that determine the storage for Mem.z for a string or blob or
33925 ** Reference counted string/blob storage
34102 case COLTYPE_BLOB: printf(" BLOB"); break;
38247 ** Convert a BLOB literal of the form "x'hhhhhh'" into its binary
38981 /* 79 */ "Blob" OpHelp("r[P2]=P4 (len=P1)"),
82572 ** expecting an index b-tree, then the caller should be inserting blob
82575 ** blob of associated data. */
84465 ** This function returns a pointer to a blob of memory associated with
84472 ** call the nBytes parameter is ignored and a pointer to the same blob
84475 ** If the nBytes parameter is 0 and the blob of memory has not yet been
84476 ** allocated, a null pointer is returned. If the blob has already been
84481 ** blob of allocated memory. The xFree function should not call sqlite3_free()
84595 ** Mark this cursor as an incremental blob cursor.
85542 /* If p holds a string or blob, the Mem.z must point to exactly
85547 ** (3) An ephemeral string or blob
85548 ** (4) A static string or blob
85708 ** blob if bPreserve is true. If bPreserve is false, any prior content
85717 ** contain a valid string or blob value. */
85766 ** Any prior string or blob content in the pMem object may be discarded.
85871 ** blob stored in dynamically allocated space.
85883 /* Set nByte to the number of bytes required to store the expanded blob. */
85920 ** or a BLOB.
86090 ** If pMem is a string or blob, then we make an attempt to convert
86227 ** value. If it is a string or blob, try to convert it to a double.
86389 case SQLITE_AFF_BLOB: { /* Really a cast to BLOB */
86465 ** Delete any previous value and set the value to be a BLOB of length
86594 ** Return true if the Mem object contains a TEXT or BLOB that is
86712 ** Change the value of a Mem to be a string or a BLOB.
86727 ** to store a blob.
86741 int iLimit; /* Maximum allowed string or blob size */
87040 /* Return true if sqlit3_value object pVal is a string or blob value
89696 zP4 = "(blob)";
89962 ** that deletes the Frame object that is attached to it as a blob.
90008 /* pSub is initiallly NULL. It is initialized to a BLOB by
91581 ** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned
91585 ** the blob of data that it corresponds to. In a table record, all serial
91588 ** serial-type and data blob separately.
91605 ** N>=12 and even (N-12)/2 BLOB
91783 ** Deserialize the data blob pointed to by buf as serial type serial_type
91922 /* EVIDENCE-OF: R-14606-31564 Value is a BLOB that is (N-12)/2 bytes in
92212 ** The input pBlob is guaranteed to be a Blob that is not marked
92213 ** with MEM_Zero. Return true if it could be a zero-blob.
92226 ** If one blob is a prefix of the other, then the shorter is the lessor.
92233 /* It is possible to have a Blob value that has some non-zero content
92295 ** sequence pColl and finally blob's ordered by memcmp().
92358 /* If one value is a string and the other is a blob, the string is less.
92383 ** to the blob case and use memcmp(). */
92436 ** greater than key2. The {nKey1, pKey1} key must be a blob
92591 /* RHS is a blob */
92809 res = pPKey2->r2; /* (pKey1/nKey1) is a blob */
93771 ** point number string BLOB NULL
93791 SQLITE_BLOB, /* 0x10 BLOB */
93795 SQLITE_INTEGER, /* 0x14 INTEGER + BLOB */
93799 SQLITE_FLOAT, /* 0x18 FLOAT + BLOB */
93909 ** result as a string or blob. Appropriate errors are set if the string/blob
94233 sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1,
95222 ** Bind a text or BLOB value.
95275 ** Bind a blob value to an SQL statement variable.
96332 int nOut; /* Number of bytes of the blob to include in output */
96482 ** not misused. A shallow copy of a string or blob just copies a
96483 blob, not the content. If the original
96484 ** is changed while the copy is still in use, the string or blob might
96531 ** use this information to make sure that the zero-blob functionality
96566 ** Test a register to see if it exceeds the current maximum blob size.
96567 ** If it does, record the new maximum blob size.
96705 /* Find the memory cell that will be used to store the blob of memory
96860 ** representation (blob and NULL do not get converted) but no string
96908 ** pMem currently only holds a string type (or maybe a BLOB that we can
97185 ** profitable for larger TEXT and BLOB values.
97282 /* SQLITE_BLOB */ "BLOB",
97898 ** the datatype of the register P2 is converted to BLOB. The content is
97899 ** the same sequence of bytes, it is merely interpreted as a BLOB instead
97902 ** if( P3!=0 and reg[P3]==P5 ) reg[P2] := CAST(reg[P2] as BLOB)
97984 ** instruction, but do not free any string or blob memory associated with
97985 ** the register, so that if the value was a string or blob that was
97995 /* Opcode: Blob P1 P2 * P4 *
97998 ** P4 points to a blob of data P1 bytes long. Store this
97999 ** blob in register P2. If P4 is a NULL pointer, then construct
98000 ** a zero-filled blob that is P1 bytes long in P2.
98096 ** is made of any string or blob constant. See also OP_SCopy.
98129 ** is a string or blob, then the copy is only a pointer to the
98238 i64 nByte; /* Total size of the output string or blob */
98599 ** <li> P2=='A' → BLOB
99678 ** 2. the length(X) function if X is a blob, and
99902 ** If P4 is NULL then all index fields have the affinity BLOB.
100011 ** N>=12 and even BLOB
100294 ** statements (i.e. open read/write incremental blob handles).
101308 ** blob, or NULL. But it needs to be an integer before we can do
101707 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
101724 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
101774 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
102467 ** record blob in register P3 against a prefix of the entry that
105804 /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH
105808 sqlite3VdbeError(p, "string or blob too big");
105844 ** This file contains code used to implement incremental BLOB I/O.
105857 int nByte; /* Size of open blob, in bytes */
105858 int iOffset; /* Byte offset of blob in cursor data */
105860 BtCursor *pCsr; /* Cursor pointing at blob row */
105870 ** the b-tree cursor associated with blob handle p to point to row iRow.
105875 ** contain a value of type TEXT or BLOB in the column nominated when the
105876 ** blob handle was opened, then an error code is returned and *pzErr may
105950 ** Open a blob handle.
105954 const char *zDb, /* The attached database containing the blob */
105955 const char *zTable, /* The table containing the blob */
105956 const char *zColumn, /* The column containing the blob */
105959 sqlite3_blob **ppBlob /* Handle for accessing the blob returned here */
106188 ** Close a blob handle that was previously created using
106210 ** Perform a read or write operation on a blob
106233 /* If there is no statement handle, then the blob-handle has
106256 ** using the incremental-blob API, this works. For the sessions module
106300 ** Read data from a blob handle.
106307 ** Write data to a blob handle.
106314 ** Query a blob handle for the size of the data.
106325 ** Move an existing blob handle to point to a different row of the same
106329 ** contain a blob or text value, then an error code is returned and the
106344 /* If there is no statement handle, then the blob-handle has
106395 ** object. The row is a binary blob in the
106409 ** sqlite3VdbeSorterRowkey() Return the complete binary blob for the
106412 ** sqlite3VdbeSorterCompare() Compare the binary blob for the row
106414 ** another binary blob X and report if
106860 PmaReader *p, /* PmaReader from which to take the blob */
107943 ** Each record consists of a varint followed by a blob of data (the
107944 ** key). The varint is the number of bytes in the blob of data.
112748 ** 0x04 Blob
117316 const char *azAff[] = { "blob", "text", "numeric", "integer",
119120 ** If pExpr is a simple SQL value - an integer, real, string, blob
123518 ** of the INTEGER PRIMARY KEY. The sample column is a blob which is the
123546 ** of a blob encoding of the complete index key as is found in
123725 /* Initialize the BLOB value of a ROWID
123807 ** return value is BLOB, but it is really just a pointer to the StatAccum
124212 ** has type BLOB but it is really just a pointer to the StatAccum object.
127881 ** 'BLOB' with a default size of 4 bytes. */
127955 ** 'BLOB' | SQLITE_AFF_BLOB
127980 }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b') /* BLOB */
128009 /* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */
128016 v = 16; /* BLOB, TEXT, CLOB -> r=5 (approx 20 bytes)*/
128992 ** a datatype that is one of INT, INTEGER, REAL, TEXT, or BLOB.
133794 static const char *azType[] = { "integer", "real", "text", "blob", "null" };
133931 ** IMP: R-01992-00519 Abs(X) returns 0.0 if X is a string or blob
134051 ** If x is a blob, then we count bytes.
134190 ** If nByte is larger than the maximum string or blob length, then
134289 ** Implementation of randomblob(N). Return a random blob
135041 ** The hex() function. Interpret the argument as a blob. Return
135088 ** decoded and returned as a blob.
135161 ** The zeroblob(N) function returns a zero-filled blob of size N bytes.
138722 ** 'A' BLOB
138821 ** 'A' BLOB
146462 ** NULL, TEXT, or BLOB.
146517 sqlite3VdbeChangeP5(v, 0x0f); /* INT, REAL, TEXT, or BLOB */
146520 sqlite3VdbeChangeP5(v, 0x0d); /* INT, TEXT, or BLOB */
146545 0x18, /* BLOB */
146561 ** NULL, TEXT, or BLOB. */
146563 sqlite3VdbeChangeP5(v, 0x1c); /* NULL, TEXT, or BLOB */
146572 sqlite3VdbeChangeP5(v, 0x1b); /* NULL, INT, FLOAT, or BLOB */
146579 sqlite3VdbeChangeP5(v, 0x1c); /* NULL, TEXT, or BLOB */
150220 ** final OP_Sequence column. The last column is the record as a blob.
151998 ** final OP_Sequence column. The last column is the record as a blob.
153484 int bHasAffBlob; /* At least one column in apExpr[] as affinity BLOB */
153625 ** + pExpr is a column with an affinity other than BLOB that matches
153699 ** columns with BLOB affinity is only allowed if the constant is used with
164555 ** with equality constraints that use BLOB or NONE affinity are set to
164562 ** the right hand side of the equality constraint (t2.b) has BLOB/NONE affinity,
164677 ** to a BLOB at appropriate times.
166796 ** that may only be NULL, a string, or a BLOB, never a number. (This means
169883 /* The Bloom filter is a Blob held in a register. Initialize it
169884 ** to zero-filled blob of at least 80K bits, but maybe more if the
169887 ** P3==1 and use that value to initialize the blob. But that makes
169888 ** testing complicated. By basing the blob size on the value in the
172471 ** (c) Column "a" has an affinity other than NONE or BLOB.
178660 ** from it. Or, if reg1 is not numeric (it is a NULL, a text value or a blob),
181135 0, /* BLOB => nothing */
181405 /* 155 */ "BLOB",
181762 /* 183 */ "term ::= NULL|FLOAT|BLOB",
182701 218, /* (183) term ::= NULL|FLOAT|BLOB */
183118 -1, /* (183) term ::= NULL|FLOAT|BLOB */
184149 case 183: /* term ::= NULL|FLOAT|BLOB */
185356 #define CC_X 0 /* The letter 'x', or start of BLOB literal */
186379 /* If it is not a BLOB literal, then it must be an ID, since no
188770 /* SQLITE_TOOBIG */ "string or blob too big",
193508 sqlite3_blob *pSegments; /* Blob handle open on %_segments table */
194294 "(id INTEGER PRIMARY KEY, value BLOB);",
194339 "CREATE TABLE %Q.'%q_segments'(blockid INTEGER PRIMARY KEY, block BLOB);",
194349 "root BLOB,"
194356 "CREATE TABLE %Q.'%q_docsize'(docid INTEGER PRIMARY KEY, size BLOB);",
195651 char *zBlob = 0; /* Blob read from %_segments table */
197300 ** If the value passed as the third argument is a blob of size
197301 ** sizeof(Fts3Cursor*), then the blob contents are copied to the
198621 ** Entry 0 of the %_stat table is a blob containing (nCol+1) FTS3
202816 ** If the <pointer> argument is specified, it must be a blob value
202823 ** is a blob containing the pointer stored as the hash data corresponding
204130 sqlite3_blob *pBlob; /* If not NULL, blob handle to read node */
205175 ** CREATE TABLE %_segments(blockid INTEGER PRIMARY KEY, block BLOB)
205180 ** with the contents of the blob stored in the "block" column of the
205182 ** to the size of the blob in bytes before returning.
205192 ** sqlite3Fts3SegmentsClose() function. Reusing a blob handle is a handy
205193 ** performance improvement, but the blob handle should always be closed
205202 char **paBlob, /* OUT: Blob data in malloc'd buffer */
205203 int *pnBlob, /* OUT: Size of blob data */
205252 ** Close the blob handle at p->pSegments, if it is open. See comments above
205976 char *zRoot, /* Blob value for "root" field */
207359 ** Encode N integers as varints into a blob.
207364 char *zBuf, /* Write the BLOB here */
207375 ** Decode a blob of varints into N integers
207380 const char *zBuf, /* The BLOB containing the varints */
207381 int nBuf /* size of the BLOB */
207398 ** a blob of varints.
207405 char *pBlob; /* The BLOB encoding of the document size */
207406 int nBlob; /* Number of bytes in the BLOB */
207430 ** Record 0 of the %_stat table contains a blob consisting of N varints,
207451 char *pBlob; /* Storage for BLOB written into %_stat */
207452 int nBlob; /* Size of BLOB written into %_stat */
207453 u32 *a; /* Array of integers that becomes the BLOB */
207689 typedef struct Blob Blob;
207698 struct Blob {
207710 Blob key; /* Last key written to the current block */
207711 Blob block; /* Current block image */
207745 Blob term; /* Current term */
207759 static void blobGrowBuffer(Blob *pBlob, int nMin, int *pRc){
207895 Blob *pBlk = &pNode->block;
207944 ** stored in blob *pNode. The node need not contain any terms, but the
207954 ** If the size of the value in blob pPrev is zero, then this is the first
207967 Blob *pNode, /* Current node image to append to */
207968 Blob *pPrev, /* Buffer containing previous term written */
208136 ** the node would be stored as a blob in the "root" column of the %_segdir
208151 Blob *pBlock = &pWriter->aNodeWriter[1].block;
208602 static void fts3StartNode(Blob *pNode, int iHeight, sqlite3_int64 iChild){
208617 ** This function creates a new node image in blob object *pNew by copying
208624 Blob *pNew, /* OUT: Write new node image here */
208630 Blob prev = {0, 0, 0}; /* Previous term written to new node */
208687 Blob root = {0,0,0}; /* New root page image */
208688 Blob block = {0,0,0}; /* Buffer used for any other block */
208816 static int fts3IncrmergeHintStore(Fts3Table *p, Blob *pHint){
208836 ** If successful, populate blob *pHint with the value read from the %_stat
208840 static int fts3IncrmergeHintLoad(Fts3Table *p, Blob *pHint){
208869 ** Otherwise, append an entry to the hint stored in blob *pHint. Each entry
208877 Blob *pHint, /* Hint blob to append to */
208890 ** Read the last entry (most recently pushed) from the hint blob *pHint
208894 ** If no error occurs, return SQLITE_OK. If the hint blob in *pHint does
208897 static int fts3IncrmergeHintPop(Blob *pHint, i64 *piAbsLevel, int *pnInput){
208935 Blob hint = {0, 0, 0}; /* Hint read from %_stat table */
208936 int bDirtyHint = 0; /* True if blob 'hint' has been modified */
208993 ** is removed from the hint blob. */
212430 ** accept BLOB values that have JSON encoded using a binary representation
212443 ** a JSONB blob is the same size as the equivalent RFC-8259 text.
212512 ** A valid JSONB blob consists of a single element, as described above.
212514 ** elements as its content. But the overall blob is just a single element.
212518 ** (header plus payload) is the same as the size of the BLOB. If those
212519 ** checks are true, the BLOB is assumed to be JSONB and processing continues.
212739 #define JSON_BLOB 0x10 /* Use the BLOB output format */
213244 sqlite3_result_error(p->pCtx, "JSON cannot hold BLOB values", -1);
213551 ** Utility routines for dealing with the binary BLOB representation of JSON
214591 ** If an error is detected in the BLOB input, the pOut->eErr flag
214592 ** might get set to JSTRING_MALFORMED. But not all BLOB input errors
214826 JsonParse *pParse; /* The BLOB being rendered */
214851 ** If an error is detected in the BLOB input, the pOut->eErr flag
214852 ** might get set to JSTRING_MALFORMED. But not all BLOB input errors
215043 ** Modify the JSONB blob at pParse->aBlob by removing nDel bytes of
215336 JsonParse *pIns, /* Populate this with the blob data to insert */
215376 ** This routine will also modify the blob. If pParse->eEdit is one of
215483 JsonParse v; /* BLOB encoding of the value to be inserted */
215594 ** Convert a JSON BLOB into text and make that text the return value
215616 ** Return the value of the BLOB node at index i.
215620 ** JSON text or the BLOB encoding, depending on the eMode flag
215802 ** value. Figure out what it is and encode it as a JSONB blob.
215813 ** If the argument is a BLOB that is clearly not a JSONB, then this
215834 sqlite3_result_error(ctx, "JSON cannot hold BLOB values", -1);
215931 /* argv[0] is a BLOB that seems likely to be a JSONB. Subsequent
215998 ** If pArg is a blob that seems like a JSONB blob, then initialize
216000 ** a JSONB blob, then return FALSE.
216006 ** checked to verify that the BLOB is superficially valid JSONB.
216009 ** also be text JSON that has been incorrectly cast into a BLOB.
216011 ** If the BLOB is 9 bytes are larger, then it is not possible for the
216021 ** or less. So if we do full JSONB validation for every BLOB where the
216110 /* If the blob is not valid JSONB, fall through into trying to cast
216111 ** the blob into text which is then interpreted as JSON. (tag-20240123-a)
216114 ** JSON functions were suppose to work. From the beginning, blob was
216115 ** reserved for expansion and a blob value should have raised an error.
216118 ** JSON text using readfile(), which returns a blob. For this reason
216177 ** Make the return value of a JSON function either the raw JSONB blob
216383 ** is a BLOB, throw an error.
216590 #define JSON_MERGE_BADTARGET 1 /* Malformed TARGET blob */
216591 #define JSON_MERGE_BADPATCH 2 /* Malformed PATCH blob */
216828 ** is not a string or if any value is a BLOB, throw an error.
217080 ** assuming the BLOB is already in memory. The performance advantage
217139 /* Strict checking. Check by translating BLOB->TEXT->BLOB. If
217178 ** If the argument is BLOB, do a full validity check and return non-zero
218114 ** CREATE TABLE %_node(nodeno INTEGER PRIMARY KEY, data BLOB)
218282 /* Blob I/O on xxx_node */
218506 ** An instance of this structure (in the form of a BLOB) is returned by
219937 RtreeMatchArg *pBlob, *pSrc; /* BLOB returned by geometry function */
220035 /* A MATCH operator. The right-hand-side must be a blob that
221386 ** it uses this hook to close any open blob handle. This is done because a
221388 ** succeed if there are any open blob handles. i.e. if the blob handle were
221838 ** to the rtree (between 1 and 5, inclusive) and (2) a blob of data containing
221893 ** from the front of a blob that is an r-tree node. For example:
222753 ** If the input is a well-formed Geopoly BLOB or JSON string
222754 ** then return the BLOB representation of the polygon. Otherwise
222905 ** If the input is a well-formed Geopoly BLOB then return the area
224294 ** This routine frees the BLOB that is returned by geomCallback().
224313 ** as a BLOB.
224315 ** The R-Tree MATCH operator will read the returned BLOB, deserialize
225562 ** to be a "fossil delta" - a patch to be applied to a blob value in the
225564 ** the existing value within the target database table must be of type BLOB.
226607 ** This function applies a fossil delta patch to a blob. Exactly two
226608 ** arguments must be passed to this function. The first is the blob to
226610 ** function returns the patched blob.
228913 ** blob starting at byte offset 40.
232303 ** value must be a BLOB which is the correct page size, otherwise the
232363 "CREATE TABLE x(pgno INTEGER PRIMARY KEY, data BLOB, schema HIDDEN)");
233510 ** 0x04: Blob value.
233523 ** Blob values:
233617 ** REBASE BLOB FORMAT:
233619 ** A rebase blob may be output by sqlite3changeset_apply_v2() and its
233621 ** existing changesets. A rebase blob contains one entry for each conflict
233625 ** The format used for a rebase blob is very similar to that used for
233641 ** In a rebase blob, the first field is set to SQLITE_INSERT if the change
233876 ** Append the hash of the blob passed via the second and third arguments to
234917 ** blob each time a NULL value is read from the "idx" column of the
235897 ** called. Otherwise, append a blob of data to the buffer.
236846 ** first argument to a copy of the string or blob held in the aData[]
236852 u8 *aData, /* Buffer containing string or blob data */
237799 "WHEN length(?4)=0 AND typeof(?4)='blob' THEN NULL "
237996 "CASE WHEN length(?2)=0 AND typeof(?2)='blob' THEN NULL ELSE ?2 END, "
238003 "CASE WHEN length(?2)=0 AND typeof(?2)='blob' THEN NULL ELSE ?2 END "
238069 ** corrupt changeset blob. */
238256 /* Instead of invoking the conflict handler, append the change blob
238842 void *pChangeset, /* Changeset blob */
238882 void *pChangeset, /* Changeset blob */
238910 void *pChangeset, /* Changeset blob */
238939 void *pChangeset, /* Changeset blob */
239447 int bRebase /* True if this is a rebase blob */
240410 ** Configure the change currently under construction with a blob value.
241847 ** Close the reader blob handle, if it is open.
241901 ** Also close any open blob handles.
250160 ** CREATE TABLE %_data(id INTEGER PRIMARY KEY, block BLOB);
250213 ** blob: first term data
250218 ** blob: nNew bytes of new term data
250281 ** blob: first term data
250385 ** Each time a blob is read from the %_data table, it is padded with this
250444 sqlite3_blob *pReader; /* RO incr-blob open on %_data table */
250638 "fts5: corruption found reading blob %lld from table \"%s\"",
250859 ** Compare the contents of the pLeft buffer with the pRight/nRight blob.
250902 ** Close the read-only blob handle, if it is open.
250927 ** rollback since it was last used. In this case a new blob handle
250940 /* If the blob handle is not open at this point, open it and seek
250952 ** table, missing row, non-blob/text in block column - indicate
250957 u8 *aOut = 0; /* Read blob data into this buffer */
255140 ** Close the read-only blob handle, if it is open.
256905 ** and the initial version of the "averages" record (a zero-byte blob).
256948 pConfig, "data", "id INTEGER PRIMARY KEY, block BLOB", 0, pzErr
259077 /* Make a copy of the second argument (a blob) in aBlob[]. The aBlob[]
260966 ** If the blob was created using zeroblob(), then sqlite3_value_blob()
262599 ** Return a "position-list blob" corresponding to the current position of
262600 ** cursor pCsr via sqlite3_result_blob(). A position-list blob contains
262604 ** A position-list blob begins with (nPhrase-1) varints, where nPhrase is
262611 ** as it can be derived from the total size of the blob.
263259 ** text, and the value returned is a blob consisting of:
263924 const char *zCols = "id INTEGER PRIMARY KEY, sz BLOB";
263926 zCols = "id INTEGER PRIMARY KEY, sz BLOB, origin INTEGER";
264570 Fts5Buffer buf; /* Buffer used to build up %_docsize blob */
267396 ** of a 1048569-byte BLOB or string.
Indexes created Tue May 05 00:25:04 UTC 2026