** Return the index of the hash bucket that the string specified by the ** arguments to this function belongs. */

** Allocate and return a new IdxConstraint object. Set the IdxConstraint.zColl ** variable to point to a copy of nul-terminated string zColl. */

** Free all elements of the linked list starting from pScan up until pLast ** (pLast is not freed). */

** Free all elements of the linked list starting from pStatement up ** until pLast (pLast is not freed). */

** Execute SQL statement zSql. There is no way to obtain any results ** returned by the statement. This function uses the sqlite3_intck error ** code

** Some error has occurred while using database p->db. Save the error message ** and error code currently held by the database handle in p->rc and p->

** If there is already an error in handle p, return it. Otherwise, call ** sqlite3_step() on the statement handle and return that value. */

** Determines if a string is a number of not. */

** This routine reads a line of text from FILE in, stores ** the text in memory obtained from malloc() and returns a pointer ** to the text. NULL is

** Return the name of a lock. */

** Output a single term of CSV. Actually, p->colSeparator is used for ** the separator, which may or may not be a comma. p->nullValue is ** the null

** Output the given string as a hex-encoded blob (eg. X'1234' ) */

** Output the given string with characters that are special to ** HTML escaped. */

** Output the given string as a quoted string using SQL quoting conventions. ** Additionallly , escape the "\n" and "\r" characters so that they do no

Draw horizontal line N characters long using unicode box ** characters */

** Scan line for classification to guide shell's handling. ** The scan is resumable for subsequent lines when prior ** return values are passed as the

** Compile a textual regular expression in zIn[] into a compiled regular ** expression suitable for us by re_match() and return a pointer to the ** co

Make a copy of N opcodes starting at iStart onto the end of the RE ** under construction. */

Return true if c is a "digit" character: [0-9] */

** Compute a reasonable limit on the length of the REGEXP NFA. */

Return true if c is a perl "space" character: [ \t\r\n\v\f] */

Compile RE text into a sequence of opcodes. Continue up to the ** first unmatched ")" character, then return. If an error is found, ** return a poin

Compile an element of regular expression text (anything that can be ** an operand to the "|" operator). Return NULL on success or a pointer ** to the

** Read the content of file zName into memory obtained from sqlite3_malloc64() ** and return a pointer to the buffer. The caller is responsible for fr

** Set the result stored by context ctx to a blob containing the ** contents of file zName. Or, leave the result unchanged (NULL) ** if the file doe

** Bind the value pVal to parameter iBind of statement pStmt. Leave an ** error in the recover handle passed as the first argument if an error ** (e.g

** Free all resources allocated as part of sqlite3_recover_step() calls. */

** Decode an SQLite varint from buffer a[]. Write the decoded value to (*pVal) ** and return the number of bytes consumed. */

** This is a worker function that does the heavy lifting for both init ** functions: ** ** sqlite3_recover_init() ** sqlite3_recover_init_sql(

** This function is a no-op if recover handle p already contains an error ** (if p->errCode!=SQLITE_OK). Zero is returned in this case. ** ** Otherwis

** Write value v to buffer a[] as a 16-bit big-endian unsigned integer. */

** Write value v to buffer a[] as a 32-bit big-endian unsigned integer. */

** Find a string that is not found anywhere in z[]. Return a pointer ** to that string. ** ** Try to use zA and zB first. If both of those are alrea

** Clean up resources allocated by recoverWriteDataInit() (stuff in ** sqlite3_recover.w1). */

** Register UDFs from user database with another. */

** Do C-language style dequoting. ** ** \a -> alarm ** \b -> backspace ** \t -> tab ** \n -> newline ** \v -> vertical t

** Run a single line of SQL. Return the number of errors. */

** Allocate space and save off string indicating current error. */

** Return the number of steps between pCur->iBase and pCur->iTerm if ** the step width is pCur->iStep. */

** Close a single OpenSession object and release all of its associated ** resources. */

** Set or clear a shell flag according to a boolean value. */

** Set the destination table field of the ShellState structure to ** the name of the table given. Escape any quote characters in the ** table name. *

** Update a SHA3Context using a single sqlite3_value. */

** Construct a fake object name and column list to describe the structure ** of the view, virtual table, or table valued function zSchema.zName. ** **

Reset the prepared statement created using shellPreparePrintf(). ** ** This routine is could be marked "static". But it is not always used, ** depend

** This is the callback routine that the shell ** invokes for each row of a query result. */

** Maybe construct two lines of text that point out the position of a ** syntax error. Return a pointer to the text, in memory obtained from ** sqlit

** Free an sqlite3expert object. */

** Free the integrity-check object. */

Encode a byte buffer into base85 text. If pSep!=0, it's a C string ** to be appended to encoded groups to limit their length to B85_DARK_MAX ** or to

** Toggle the reverse_unordered_selects setting. */

** z[] is a line of text that is to be displayed the .mode box or table or ** similar tabular formats. z[] might contain control characters such ** a

** Try to transfer all rows of the schema that match zWhere. For ** each row, invoke xForEach() on the object defined by that row. ** If an error is

** Try to convert an error code into a symbolic name for that error code. */

** This function does the work for the writefile() UDF. Refer to ** header comments at the top of this file for details. */

Skip over as much z[] input char sequence as is valid UTF-8, ** limited per nAccept char's or whole characters and containing ** no char cn such that

** Add object pNew to the linked list that begins at ZipfileTab.pFirstEntry ** and ends with pLastEntry. If argument pBefore is NULL, then pNew is ad

** Set the error message contained in context ctx to the results of ** vprintf(zFmt, ...). */

** Buffer aIn (size nIn bytes) contains uncompressed data. This function ** compresses it and sets (*ppOut) to point to a buffer containing the ** com

** If aBlob is not NULL, then it is a pointer to a buffer (nBlob bytes in ** size) containing an entire zip archive image. Or, if aBlob is NULL, ** th

** Return a 32-bit timestamp in UNIX epoch format. ** ** If the value passed as the only argument is either NULL or an SQL NULL, ** return the current

** Read and return a 32-bit little-endian unsigned integer from buffer aBuf. */

** The opposite of zipfileMtime(). This function populates the mTime and ** mDate fields of the CDS structure passed as the first argument according *

** Advance an ZipfileCsr to its next row of output. */

** If aBlob is not NULL, then it points to a buffer nBlob bytes in size ** containing an entire zip archive image. Or, if aBlob is NULL, then pFile **

** Unless it is NULL, entry pOld is currently part of the pTab->pFirstEntry ** linked list. Remove it from the list and free the object. */

** Reset a cursor back to the state it was in when first returned ** by zipfileOpen(). */

** Serialize the CDS structure into buffer aBuf[]. Return the number ** of bytes written. */

** Determine if simulated binary mode should be used for output to fd */

** Check to see if the file is an appendvfs SQLite database file. ** Return true iff it is such. Parameter sz is the file's size. */

** Check to see if the file is an ordinary SQLite database file. ** Return true iff so. Parameter sz is the file's size. */

** Implementation of .ar "eXtract" command. */

** Implementation of .ar "lisT" command. */

** Parse the command line for an ".ar" command. The results are written into ** structure (*pAr). SQLITE_OK is returned if the command line is parsed

** Implementation of .ar "Remove" command. */

** This is the callback routine that the SQLite library ** invokes for each row of a query result. */

** Advance a completion_cursor to its next row of output. ** ** The ->ePhase, ->j, and ->pStmt fields of the completion_cursor object ** record the cu

** Generate an appropriate SELFTEST table in the main database. */

** Release the allocation managed by buffer pBuf. */

** Ensure the buffer passed as the first argument is at least nMin bytes ** in size. If an error occurs while attempting to resize the buffer, ** SQLI

** Determine the size in pages of database zSchema (where zSchema is ** "main", "temp" or the name of an attached database) and set ** pCsr->szDb acc

** Attempt to figure out the encoding of the database by retrieving page 1 ** and inspecting the header field. If successful, set the pCsr->enc variab

** Move an sqlite_dbdata or sqlite_dbptr cursor to the next entry. */

** Load a value of type eType from buffer pData and use it to set the ** result of context object pCtx. */

** Attempt to display I/O stats on Linux using /proc/PID/io */