Sid Gifari File Manager

Sid Gifari File Manager

🏠 Root / home / genremedia08 / musicjukebox.overlookedtracks.com / vendor / jetbrains / phpstorm-stubs / SQLite /

Editing: SQLite.php

<?php

// Start of SQLite v.2.0-dev
use JetBrains\PhpStorm\Pure;

/**
 * @link https://php.net/manual/en/ref.sqlite.php
 */
class SQLiteDatabase
{
 /**
 * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
 * @link https://php.net/manual/en/function.sqlite-open.php
 * @param string $filename The filename of the SQLite database. If the file does not exist, SQLite will attempt to create it. PHP must have write permissions to the file if data is inserted, the database schema is modified or to create the database if it does not exist.
 * @param int $mode [optional] The mode of the file. Intended to be used to open the database in read-only mode. Presently, this parameter is ignored by the sqlite library. The default value for mode is the octal value 0666 and this is the recommended value.
 * @param string &$error_message [optional] Passed by reference and is set to hold a descriptive error message explaining why the database could not be opened if there was an error.
 */
 final public function __construct($filename, $mode = 0666, &$error_message) {}

/**
 * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
 * @link https://php.net/manual/en/function.sqlite-query.php
 * @param string $query 
 * The query to be executed.
 * 
 * 
 * Data inside the query should be {@link https://php.net/manual/en/function.sqlite-escape-string.php properly escaped}.
 * 
 * @param int $result_type [optional]
 * The optional result_type parameter accepts a constant and determines how the returned array will be indexed. Using SQLITE_ASSOC will return only associative indices (named fields) while SQLITE_NUM will return only numerical indices (ordinal field numbers). SQLITE_BOTH will return both associative and numerical indices. SQLITE_BOTH is the default for this function.
 * @param string &$error_message [optional] The specified variable will be filled if an error occurs. This is specially important because SQL syntax errors can't be fetched using the {@see sqlite_last_error()} function.
 * @return resource|false 
 * This function will return a result handle or FALSE on failure.
 * For queries that return rows, the result handle can then be used with
 * functions such as {@see sqlite_fetch_array()} and
 * {@see sqlite_seek()}.
 * 
 * 
 * Regardless of the query type, this function will return FALSE if the
 * query failed.
 * 
 * 
 * {@see sqlite_query()} returns a buffered, seekable result
 * handle. This is useful for reasonably small queries where you need to
 * be able to randomly access the rows. Buffered result handles will
 * allocate memory to hold the entire result and will not return until it
 * has been fetched. If you only need sequential access to the data, it is
 * recommended that you use the much higher performance
 * {@see sqlite_unbuffered_query()} instead.
 * 
 */
 public function query($query, $result_type, &$error_message) {}

/**
 * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
 * @link https://php.net/manual/en/function.sqlite-exec.php
 * @param string $query 
 * The query to be executed.
 * 
 * 
 * Data inside the query should be {@link https://php.net/manual/en/function.sqlite-escape-string.php properly escaped}.
 * 
 * @param string &$error_message [optional] The specified variable will be filled if an error occurs. This is specially important because SQL syntax errors can't be fetched using the
 * {@see sqlite_last_error()} function.
 * @return bool 
 * This function will return a boolean result; TRUE for success or FALSE for failure.
 * If you need to run a query that returns rows, see {@see sqlite_query()}.
 * 
 * The column names returned by
 * SQLITE_ASSOC and SQLITE_BOTH will be
 * case-folded according to the value of the
 * {@link https://php.net/manual/en/sqlite.configuration.php#ini.sqlite.assoc-case sqlite.assoc_case} configuration
 * option.
 */
 public function queryExec($query, &$error_message) {}

/**
 * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
 * Execute a query against a given database and returns an array
 * @link https://php.net/manual/en/function.sqlite-array-query.php
 * @param string $query 
 * The query to be executed.
 * 
 * 
 * Data inside the query should be {@link https://php.net/manual/en/function.sqlite-escape-string.php properly escaped}.
 * 
 * @param int $result_type [optional] The optional result_type
 * parameter accepts a constant and determines how the returned array will be
 * indexed. Using SQLITE_ASSOC will return only associative
 * indices (named fields) while SQLITE_NUM will return
 * only numerical indices (ordinal field numbers). SQLITE_BOTH
 * will return both associative and numerical indices.
 * SQLITE_BOTH is the default for this function.
 * @param bool $decode_binary [optional] When the decode_binary
 * parameter is set to TRUE (the default), PHP will decode the binary encoding
 * it applied to the data if it was encoded using the
 * {@see sqlite_escape_string()}. You should normally leave this
 * value at its default, unless you are interoperating with databases created by
 * other sqlite capable applications.
 * 
 * @return array|false
 * Returns an array of the entire result set; FALSE otherwise.
 * 
 * The column names returned by
 * SQLITE_ASSOC and SQLITE_BOTH will be
 * case-folded according to the value of the
 * {@link https://php.net/manual/en/sqlite.configuration.php#ini.sqlite.assoc-case sqlite.assoc_case} configuration
 * option.
 */
 public function arrayQuery($query, $result_type, $decode_binary) {}

/**
     * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.1)
     * Executes a query and returns either an array for one single column or the value of the first row
     * @link https://php.net/manual/en/function.sqlite-single-query.php
     * @param string $query
     * @param bool $first_row_only [optional]
     * @param bool $decode_binary [optional]
     * @return array
     */
    public function singleQuery($query, $first_row_only, $decode_binary) {}

/**
 * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
 * Execute a query that does not prefetch and buffer all data
 * @link https://php.net/manual/en/function.sqlite-unbuffered-query.php
 * @param string $query 
 * The query to be executed.
 * 
 * 
 * Data inside the query should be {@link https://php.net/manual/en/function.sqlite-escape-string.php properly escaped}.
 * 
 * @param int $result_type [optional] The optional result_type parameter accepts a constant and determines how the returned array will be indexed.
 * Using SQLITE_ASSOC will return only associative indices (named fields) while SQLITE_NUM will return only numerical indices (ordinal field numbers).
 * SQLITE_BOTH will return both associative and numerical indices. SQLITE_BOTH is the default for this function.
 * 
 * @param string &$error_message [optional]
 * @return resource Returns a result handle or FALSE on failure.
 * {@see sqlite_unbuffered_query()} returns a sequential forward-only result set that can only be used to read each row, one after the other.
 */
 public function unbufferedQuery($query, $result_type = SQLITE_BOTH, &$error_message = null) {}

/**
     * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
     * Returns the rowid of the most recently inserted row
     * @link https://php.net/manual/en/function.sqlite-last-insert-rowid.php
     * @return int Returns the row id, as an integer.
     */
    public function lastInsertRowid() {}

/**
     * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
     * Returns the number of rows that were changed by the most recent SQL statement
     * @link https://php.net/manual/en/function.sqlite-changes.php
     * @return int Returns the number of changed rows.
     */
    public function changes() {}

/**
 * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
 * Register an aggregating UDF for use in SQL statements
 * @link https://php.net/manual/en/function.sqlite-create-aggregate.php
 * @param string $function_name The name of the function used in SQL statements.
 * @param callable $step_func Callback function called for each row of the result set. Function parameters are &$context, $value, ....
 * @param callable $finalize_func Callback function to aggregate the "stepped" data from each row. Function parameter is &$context and the function should return the final result of aggregation.
 * @param int $num_args [optional] Hint to the SQLite parser if the callback function accepts a predetermined number of arguments.
 */
 public function createAggregate($function_name, $step_func, $finalize_func, $num_args = -1) {}

/**
 * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
 * Registers a "regular" User Defined Function for use in SQL statements
 * @link https://php.net/manual/en/function.sqlite-create-function.php
 * @param string $function_name The name of the function used in SQL statements.
 * @param callable $callback 
 * Callback function to handle the defined SQL function.
 * 
 * <blockquote>Note:
 * Callback functions should return a type understood by SQLite (i.e.
 * {@link https://php.net/manual/en/language.types.intro.php scalar type}).
 * </blockquote>
 * @param int $num_args [optional] <blockquote>Note: Two alternative syntaxes are
 * supported for compatibility with other database extensions (such as MySQL).
 * The preferred form is the first, where the dbhandle
 * parameter is the first parameter to the function.</blockquote>
 */
 public function createFunction($function_name, $callback, $num_args = -1) {}

/**
 * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
 * Set busy timeout duration, or disable busy handlers
 * @link https://php.net/manual/en/function.sqlite-busy-timeout.php
 * @param int $milliseconds The number of milliseconds. When set to 0, busy handlers will be disabled and SQLite will return immediately with a SQLITE_BUSY status code if another process/thread has the database locked for an update.
 * PHP sets the default busy timeout to be 60 seconds when the database is opened.
 * @return int Returns an error code, or 0 if no error occurred.
 */
 public function busyTimeout($milliseconds) {}

/**
     * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
     * Returns the error code of the last error for a database
     * @link https://php.net/manual/en/function.sqlite-last-error.php
     * @return int Returns an error code, or 0 if no error occurred.
     */
    public function lastError() {}

/**
 * (PHP 5 &lt; 5.4.0)
 * Return an array of column types from a particular table
 * @link https://php.net/manual/en/function.sqlite-fetch-column-types.php
 * @param string $table_name The table name to query.
 * @param int $result_type [optional] 
 * The optional result_type parameter accepts a
 * constant and determines how the returned array will be indexed. Using
 * SQLITE_ASSOC will return only associative indices
 * (named fields) while SQLITE_NUM will return only
 * numerical indices (ordinal field numbers).
 * SQLITE_ASSOC is the default for
 * this function.
 * 
 * @return array 
 * Returns an array of column data types; FALSE on error.
 * 
 * The column names returned by
 * SQLITE_ASSOC and SQLITE_BOTH will be
 * case-folded according to the value of the
 * {@link https://php.net/manual/en/sqlite.configuration.php#ini.sqlite.assoc-case sqlite.assoc_case} configuration
 * option.
 */
 public function fetchColumnTypes($table_name, $result_type = SQLITE_ASSOC) {}
}

/**
 * @link https://php.net/manual/en/ref.sqlite.php
 */
final class SQLiteResult implements Iterator, Countable
{
 /**
 * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
 * Fetches the next row from a result set as an array
 * @link https://php.net/manual/en/function.sqlite-fetch-array.php
 * @param int $result_type [optional]
 * 
 * The optional result_type
 * parameter accepts a constant and determines how the returned array will be
 * indexed. Using SQLITE_ASSOC will return only associative
 * indices (named fields) while SQLITE_NUM will return
 * only numerical indices (ordinal field numbers). SQLITE_BOTH
 * will return both associative and numerical indices.
 * SQLITE_BOTH is the default for this function.
 * 
 * @param bool $decode_binary [optional] When the decode_binary
 * parameter is set to TRUE (the default), PHP will decode the binary encoding
 * it applied to the data if it was encoded using the
 * {@link https://php.net/manual/en/sqlite.configuration.php#ini.sqlite.assoc-case sqlite.assoc_case}. You should normally leave this
 * value at its default, unless you are interoperating with databases created by
 * other sqlite capable applications.
 * @return array
 * 
 * Returns an array of the next row from a result set; FALSE if the
 * next position is beyond the final row.
 * 
 * The column names returned by
 * SQLITE_ASSOC and SQLITE_BOTH will be
 * case-folded according to the value of the
 * {@link https://php.net/manual/en/sqlite.configuration.php#ini.sqlite.assoc-case sqlite.assoc_case} configuration
 * option.
 */
 public function fetch($result_type = SQLITE_BOTH, $decode_binary = true) {}

/**
     * (PHP 5 &lt; 5.4.0)
     * Fetches the next row from a result set as an object
     * @link https://php.net/manual/en/function.sqlite-fetch-object.php
     * @param string $class_name [optional]
     * @param array $ctor_params [optional]
     * @param bool $decode_binary [optional]
     * @return object
     */
    public function fetchObject($class_name, $ctor_params, $decode_binary = true) {}

/**
 * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.1)
 * Fetches the first column of a result set as a string
 * @link https://php.net/manual/en/function.sqlite-fetch-single.php
 * @param bool $decode_binary [optional]
 * @return string Returns the first column value, as a string.
 */
 public function fetchSingle($decode_binary = true) {}

/**
 * (PHP 5 &lt; 5.4.0)
 * Fetches the next row from a result set as an object
 * @link https://www.php.net/manual/en/function.sqlite-fetch-all.php
 * @param int $result_type [optional] 
 * The optional result_type parameter accepts a constant and determines how the returned array will be indexed.
 * Using SQLITE_ASSOC will return only associative indices (named fields) while SQLITE_NUM will return only numerical indices (ordinal field numbers).
 * {@see SQLITE_BOTH} will return both associative and numerical indices. {@see SQLITE_BOTH} is the default for this function.
 * @param bool $decode_binary [optional] When the decode_binary parameter is set to TRUE (the default),
 * PHP will decode the binary encoding it applied to the data if it was encoded using the {@see sqlite_escape_string()}.
 * You should normally leave this value at its default, unless you are interoperating with databases created by other sqlite capable applications.
 * @return object
 */
 public function fetchAll($result_type, $decode_binary = true) {}

/**
 * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
 * Fetches a column from the current row of a result set
 * @link https://php.net/manual/en/function.sqlite-column.php
 * @param $index_or_name
 * @param $decode_binary [optional] When the decode_binary
 * parameter is set to TRUE (the default), PHP will decode the binary encoding
 * it applied to the data if it was encoded using the
 * {@see sqlite_escape_string()}. You should normally leave this
 * value at its default, unless you are interoperating with databases created by
 * other sqlite capable applications.
 * @return mixed Returns the column value
 */
 public function column($index_or_name, $decode_binary = true) {}

/**
 * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
 * Returns the number of fields in a result set
 * @link https://php.net/manual/en/function.sqlite-num-fields.php
 * @return int Returns the number of fields, as an integer.
 */
 public function numFields() {}

/**
 * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
 * Returns the name of a particular field
 * @link https://php.net/manual/en/function.sqlite-field-name.php
 * @param int $field_index The ordinal column number in the result set.
 * @return string 
 * Returns the name of a field in an SQLite result set, given the ordinal
 * column number; FALSE on error.
 * 
 * The column names returned by
 * SQLITE_ASSOC and SQLITE_BOTH will be
 * case-folded according to the value of the
 * {@link https://php.net/manual/en/sqlite.configuration.php#ini.sqlite.assoc-case sqlite.assoc_case}configuration
 * option.
 */
 public function fieldName($field_index) {}

/**
 * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
 * Fetches the current row from a result set as an array
 * @link https://php.net/manual/en/function.sqlite-current.php
 * @param int $result_type [optional] The optional result_type
 * parameter accepts a constant and determines how the returned array will be
 * indexed. Using {@see SQLITE_ASSOC} will return only associative
 * indices (named fields) while {@see SQLITE_NUM} will return
 * only numerical indices (ordinal field numbers). SQLITE_BOTH
 * will return both associative and numerical indices.
 * {@see SQLITE_BOTH} is the default for this function.
 * @param bool $decode_binary [optional] When the decode_binary
 * parameter is set to TRUE (the default), PHP will decode the binary encoding
 * it applied to the data if it was encoded using the
 * {@see sqlite_escape_string()}. You should normally leave this
 * value at its default, unless you are interoperating with databases created by
 * other sqlite capable applications.
 * @return array 
 * Returns an array of the current row from a result set; FALSE if the
 * current position is beyond the final row.
 * 
 * The column names returned by
 * SQLITE_ASSOC and SQLITE_BOTH will be
 * case-folded according to the value of the
 * {@link https://php.net/manual/en/sqlite.configuration.php#ini.sqlite.assoc-case sqlite.assoc_case} configuration
 * option.
 */
 public function current($result_type = SQLITE_BOTH, $decode_binary = true) {}

/**
     * Return the key of the current element
     * @link https://php.net/manual/en/iterator.key.php
     * @return mixed scalar on success, or null on failure.
     * @since 5.0.0
     */
    public function key() {}

/**
 * Seek to the next row number
 * @link https://php.net/manual/en/function.sqlite-next.php
 * @return bool Returns TRUE on success, or FALSE if there are no more rows.
 * @since 5.0.0
 */
 public function next() {}

/**
 * Checks if current position is valid
 * @link https://php.net/manual/en/iterator.valid.php
 * @return bool 
 * Returns TRUE if there are more rows available from the
 * result handle, or FALSE otherwise.
 * 
 * @since 5.0.0
 */
 public function valid() {}

/**
     * Rewind the Iterator to the first element
     * @link https://php.net/manual/en/iterator.rewind.php
     * @return void Any returned value is ignored.
     * @since 5.0.0
     */
    public function rewind() {}

/**
 * Count elements of an object
 * @link https://php.net/manual/en/countable.count.php
 * @return int The custom count as an integer.
 * 
 * 
 * The return value is cast to an integer.
 * 
 * @since 5.1.0
 */
 public function count() {}

/**
 * Seek to the previous row number of a result set
 * @link https://php.net/manual/en/function.sqlite-prev.php
 * @return bool Returns TRUE on success, or FALSE if there are no more previous rows.
 * 
 * @since 5.4.0
 */
 public function prev() {}

/**
 *@since 5.4.0
 * Returns whether or not a previous row is available
 * @link https://php.net/manual/en/function.sqlite-has-prev.php
 * @return bool 
 * Returns TRUE if there are more previous rows available from the
 * result handle, or FALSE otherwise.
 * 
 */
 public function hasPrev() {}

/**
     * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
     * Returns the number of rows in a buffered result set
     * @link https://php.net/manual/en/function.sqlite-num-rows.php
     * @return int Returns the number of rows, as an integer.
     */
    public function numRows() {}

/**
 * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0)
 * Seek to a particular row number of a buffered result set
 * @link https://php.net/manual/en/function.sqlite-seek.php
 * @param $row
 * 
 * The ordinal row number to seek to. The row number is zero-based (0 is
 * the first row).
 * 
 * <blockquote>Note: This function cannot be used with
 * unbuffered result handles.</blockquote>
 */
 public function seek($row) {}
}

/**
 * Represents an unbuffered SQLite result set. Unbuffered results sets are sequential, forward-seeking only.
 * @link https://php.net/manual/en/ref.sqlite.php
 */
final class SQLiteUnbuffered
{
    /**
     * @param int $result_type [optional]
     * @param bool $decode_binary [optional]
     */
    public function fetch($result_type, $decode_binary) {}

/**
     * @link https://www.php.net/manual/en/function.sqlite-fetch-object.php
     * @param string $class_name [optional]
     * @param array $ctor_params [optional]
     * @param bool $decode_binary [optional]
     */
    public function fetchObject($class_name, $ctor_params, $decode_binary) {}

/**
     * @param bool $decode_binary [optional]
     */
    public function fetchSingle($decode_binary) {}

/**
     * @param int $result_type [optional]
     * @param bool $decode_binary [optional]
     */
    public function fetchAll($result_type, $decode_binary) {}

/**
     * @param $index_or_name
     * @param $decode_binary [optional]
     */
    public function column($index_or_name, $decode_binary) {}

public function numFields() {}

/**
     * @param int $field_index
     */
    public function fieldName($field_index) {}

/**
     * @param int $result_type [optional]
     * @param bool $decode_binary [optional]
     */
    public function current($result_type, $decode_binary) {}

public function next() {}

public function valid() {}
}

final class SQLiteException extends RuntimeException
{
    protected $message;
    protected $code;
    protected $file;
    protected $line;

/**
     * Clone the exception
     * @link https://php.net/manual/en/exception.clone.php
     * @return void
     * @since 5.1.0
     */
    final private function __clone() {}

/**
     * Construct the exception
     * @link https://php.net/manual/en/exception.construct.php
     * @param $message [optional]
     * @param $code [optional]
     * @param $previous [optional]
     * @since 5.1.0
     */
    #[Pure]
    public function __construct($message, $code, $previous) {}

/**
     * String representation of the exception
     * @link https://php.net/manual/en/exception.tostring.php
     * @return string the string representation of the exception.
     * @since 5.1.0
     */
    public function __toString() {}
}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Opens a SQLite database and create the database if it does not exist
 * @link https://php.net/manual/en/function.sqlite-open.php
 * @param string $filename 
 * The filename of the SQLite database. If the file does not exist, SQLite
 * will attempt to create it. PHP must have write permissions to the file
 * if data is inserted, the database schema is modified or to create the
 * database if it does not exist.
 * 
 * @param int $mode [optional] 
 * The mode of the file. Intended to be used to open the database in
 * read-only mode. Presently, this parameter is ignored by the sqlite
 * library. The default value for mode is the octal value
 * 0666 and this is the recommended value.
 * 
 * @param string &$error_message [optional] 
 * Passed by reference and is set to hold a descriptive error message
 * explaining why the database could not be opened if there was an error.
 * 
 * @return resource|false a resource (database handle) on success, false on error.
 */
function sqlite_open($filename, $mode = null, &$error_message = null) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Opens a persistent handle to an SQLite database and create the database if it does not exist
 * @link https://php.net/manual/en/function.sqlite-popen.php
 * @param string $filename 
 * The filename of the SQLite database. If the file does not exist, SQLite
 * will attempt to create it. PHP must have write permissions to the file
 * if data is inserted, the database schema is modified or to create the
 * database if it does not exist.
 * 
 * @param int $mode [optional] 
 * The mode of the file. Intended to be used to open the database in
 * read-only mode. Presently, this parameter is ignored by the sqlite
 * library. The default value for mode is the octal value
 * 0666 and this is the recommended value.
 * 
 * @param string &$error_message [optional] 
 * Passed by reference and is set to hold a descriptive error message
 * explaining why the database could not be opened if there was an error.
 * 
 * @return resource|false a resource (database handle) on success, false on error.
 */
function sqlite_popen($filename, $mode = null, &$error_message = null) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Closes an open SQLite database
 * @link https://php.net/manual/en/function.sqlite-close.php
 * @param resource $dbhandle 
 * The SQLite Database resource; returned from sqlite_open
 * when used procedurally.
 * 
 * @return void
 */
function sqlite_close($dbhandle) {}

/**
 * (PHP 5 &lt; 5.4.0, PECL sqlite &gt;= 1.0.0) 
 * Executes a query against a given database and returns a result handle
 * there are two signatures with $query first and with $dbhandle first.
 * @link https://php.net/manual/en/function.sqlite-query.php
 * @param string|resource $query 
 * The query to be executed.
 * 
 * 
 * Data inside the query should be properly escaped.
 * 
 * @param resource|string $dbhandle The SQLite Database resource; returned from sqlite_open() when used procedurally. This parameter is not required when using the object-oriented method.
 * @param int $result_type [optional] The optional result_type
 * parameter accepts a constant and determines how the returned array will be
 * indexed. Using SQLITE_ASSOC will return only associative
 * indices (named fields) while SQLITE_NUM will return
 * only numerical indices (ordinal field numbers). SQLITE_BOTH
 * will return both associative and numerical indices.
 * SQLITE_BOTH is the default for this function.
 * @param string &$error_msg [optional] 
 * The specified variable will be filled if an error occurs. This is
 * specially important because SQL syntax errors can't be fetched using
 * the
 * {@see sqlite_last_error} function.
 * 
 * @return resource|false This function will return a result handle or FALSE on failure.
 * For queries that return rows, the result handle can then be used with
 * functions such as
 * {@see sqlite_fetch_array} and
 * {@see sqlite_seek}.
 * 
 * 
 * Regardless of the query type, this function will return false if the
 * query failed.
 * 
 * 
 * {@see sqlite_query} returns a buffered, seekable result
 * handle. This is useful for reasonably small queries where you need to
 * be able to randomly access the rows. Buffered result handles will
 * allocate memory to hold the entire result and will not return until it
 * has been fetched. If you only need sequential access to the data, it is
 * recommended that you use the much higher performance
 * {@see sqlite_unbuffered_query} instead.
 */
function sqlite_query($query, $dbhandle, $result_type = SQLITE_BOTH, &$error_msg = null) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.3) 
 * Executes a result-less query against a given database
 * @link https://php.net/manual/en/function.sqlite-exec.php
 * @param string $query 
 * The query to be executed.
 * 
 * 
 * Data inside the query should be properly escaped.
 * 
 * @param resource $dbhandle 
 * The SQLite Database resource; returned from
 * {@see sqlite_open()} when used procedurally. This parameter
 * is not required when using the object-oriented method.
 * 
 * @param string &$error_msg [optional] 
 * The specified variable will be filled if an error occurs. This is
 * specially important because SQL syntax errors can't be fetched using
 * the
 * {@see sqlite_last_error} function.
 * 
 * @return bool This function will return a boolean result; true for success or false for failure.
 * If you need to run a query that returns rows, see sqlite_query.
 */
function sqlite_exec($dbhandle, $query, &$error_msg = null) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Execute a query against a given database and returns an array
 * @link https://php.net/manual/en/function.sqlite-array-query.php
 * @param string $query 
 * The query to be executed.
 * 
 * 
 * Data inside the query should be properly escaped.
 * 
 * @param resource $dbhandle 
 * The SQLite Database resource; returned from
 * {@see sqlite_open()}
 * when used procedurally. This parameter is not required
 * when using the object-oriented method.
 * 
 * @param int $result_type [optional] The optional result_type
 * parameter accepts a constant and determines how the returned array will be
 * indexed. Using SQLITE_ASSOC will return only associative
 * indices (named fields) while SQLITE_NUM will return
 * only numerical indices (ordinal field numbers). SQLITE_BOTH
 * will return both associative and numerical indices.
 * SQLITE_BOTH is the default for this function.
 * @param bool $decode_binary [optional] When the decode_binary
 * parameter is set to TRUE (the default), PHP will decode the binary encoding
 * it applied to the data if it was encoded using the
 * {@link sqlite_escape_string()}. You should normally leave this
 * value at its default, unless you are interoperating with databases created by
 * other sqlite capable applications.
 * @return array|false an array of the entire result set; false otherwise.
 * The column names returned by
 * SQLITE_ASSOC and SQLITE_BOTH will be
 * case-folded according to the value of the
 * {@link php.net/en/sqlite.configuration.php#ini.sqlite.assoc-case sqlite.assoc_case} configuration
 * option.
 */
function sqlite_array_query($dbhandle, $query, $result_type = null, $decode_binary = null) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.1) 
 * Executes a query and returns either an array for one single column or the value of the first row
 * @link https://php.net/manual/en/function.sqlite-single-query.php
 * @param resource $db
 * @param string $query
 * @param bool $first_row_only [optional]
 * @param bool $decode_binary [optional]
 * @return array
 */
function sqlite_single_query($db, $query, $first_row_only = null, $decode_binary = null) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Fetches the next row from a result set as an array
 * @link https://php.net/manual/en/function.sqlite-fetch-array.php
 * @param resource $result The SQLite result resource. This parameter is not required when using the object-oriented method.
 * @param int $result_type [optional]
 * @param bool $decode_binary [optional]
 * @return array|false an array of the next row from a result set; false if the
 * next position is beyond the final row.
 */
function sqlite_fetch_array($result, $result_type = SQLITE_BOTH, $decode_binary = null) {}

/**
 * Fetches the next row from a result set as an object
 * @link https://php.net/manual/en/function.sqlite-fetch-object.php
 * @param resource $result
 * @param string $class_name [optional]
 * @param null|array $ctor_params [optional]
 * @param bool $decode_binary [optional]
 * @return object
 */
function sqlite_fetch_object($result, $class_name = null, ?array $ctor_params = null, $decode_binary = null) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.1) 
 * Fetches the first column of a result set as a string
 * @link https://php.net/manual/en/function.sqlite-fetch-single.php
 * @param resource $result The SQLite result resource. This parameter is not required when using the object-oriented method.
 * @param bool $decode_binary [optional] When the decode_binary
 * parameter is set to TRUE (the default), PHP will decode the binary encoding
 * it applied to the data if it was encoded using the
 * {@see sqlite_escape_string()}. You should normally leave this
 * value at its default, unless you are interoperating with databases created by
 * other sqlite capable applications.
 * @return string the first column value, as a string.
 */
function sqlite_fetch_single($result, $decode_binary = null) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Alias:
 * {@see sqlite_fetch_single}
 * @link https://php.net/manual/en/function.sqlite-fetch-string.php
 * @param resource $result The SQLite result resource. This parameter is not required when using the object-oriented method.
 * @param bool $decode_binary [optional] When the decode_binary
 * parameter is set to TRUE (the default), PHP will decode the binary encoding
 * it applied to the data if it was encoded using the
 * {@see sqlite_escape_string()}. You should normally leave this
 * value at its default, unless you are interoperating with databases created by
 * other sqlite capable applications.
 * @return string the first column value, as a string.
 */
function sqlite_fetch_string($result, $decode_binary) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Fetches all rows from a result set as an array of arrays
 * @link https://php.net/manual/en/function.sqlite-fetch-all.php
 * @param int $result_type [optional]
 * @param bool $decode_binary [optional]
 * @return array an array of the remaining rows in a result set. If called right
 * after
 * {@see sqlite_query}, it returns all rows. If called
 * after
 * {@see sqlite_fetch_array}, it returns the rest. If
 * there are no rows in a result set, it returns an empty array.
 * The column names returned by SQLITE_ASSOC and SQLITE_BOTH will be case-folded according to the value of the
 * {@link https://php.net/manual/en/sqlite.configuration.php#ini.sqlite.assoc-case sqlite.assoc_case} configuration option.
 */
function sqlite_fetch_all($result_type = null, $decode_binary = null) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Fetches the current row from a result set as an array
 * @link https://php.net/manual/en/function.sqlite-current.php
 * @param resource $result The SQLite result resource. This parameter is not required when using the object-oriented method.
 * @param int $result_type [optional] The optional result_type parameter accepts a constant and determines how the returned array will be indexed. Using SQLITE_ASSOC will return only associative indices (named fields) while SQLITE_NUM will return only numerical indices (ordinal field numbers). SQLITE_BOTH will return both associative and numerical indices. SQLITE_BOTH is the default for this function.
 * @param bool $decode_binary [optional] When the decode_binary parameter is set to TRUE (the default), PHP will decode the binary encoding it applied to the data if it was encoded using the sqlite_escape_string(). You should normally leave this value at its default, unless you are interoperating with databases created by other sqlite capable applications.
 * @return array|false an array of the current row from a result set; false if the
 * current position is beyond the final row.
 */
function sqlite_current($result, $result_type = null, $decode_binary = null) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Fetches a column from the current row of a result set
 * @link https://php.net/manual/en/function.sqlite-column.php
 * @param resource $result The SQLite result resource. This parameter is not required when using the object-oriented method.
 * @param mixed $index_or_name 
 * The column index or name to fetch.
 * 
 * @param bool $decode_binary [optional] When the decode_binary
 * parameter is set to TRUE (the default), PHP will decode the binary encoding
 * it applied to the data if it was encoded using the
 * {@see sqlite_escape_string()}. You should normally leave this
 * value at its default, unless you are interoperating with databases created by
 * other sqlite capable applications.
 * @return mixed the column value.
 */
function sqlite_column($result, $index_or_name, $decode_binary = null) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Returns the version of the linked SQLite library
 * @link https://php.net/manual/en/function.sqlite-libversion.php
 * @return string the library version, as a string.
 */
function sqlite_libversion() {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Returns the encoding of the linked SQLite library
 * @link https://php.net/manual/en/function.sqlite-libencoding.php
 * @return string the library encoding.
 */
function sqlite_libencoding() {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Returns the number of rows that were changed by the most
 * recent SQL statement
 * @link https://php.net/manual/en/function.sqlite-changes.php
 * @param $db
 * @return int the number of changed rows.
 */
function sqlite_changes($db) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Returns the rowid of the most recently inserted row
 * @link https://php.net/manual/en/function.sqlite-last-insert-rowid.php
 * @param resource $dbhandle The SQLite Database resource; returned from
 * {@see sqlite_open()} when used procedurally. This parameter is not required when using the object-oriented method.
 * @return int the row id, as an integer.
 */
function sqlite_last_insert_rowid($dbhandle) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Returns the number of rows in a buffered result set
 * @link https://php.net/manual/en/function.sqlite-num-rows.php
 * @param resource $result 
 * The SQLite result resource. This parameter is not required when using
 * the object-oriented method.
 * 
 * <blockquote>Note: This function cannot be used with
 * unbuffered result handles.</blockquote>
 * @return int the number of rows, as an integer.
 */
function sqlite_num_rows($result) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Returns the number of fields in a result set
 * @link https://php.net/manual/en/function.sqlite-num-fields.php
 * @param resource $result The SQLite result resource. This parameter is not required when using the object-oriented method.
 * @return int the number of fields, as an integer.
 */
function sqlite_num_fields($result) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Returns the name of a particular field
 * @link https://php.net/manual/en/function.sqlite-field-name.php
 * @param resource $result The SQLite result resource. This parameter is not required when using the object-oriented method.
 * @param int $field_index 
 * The ordinal column number in the result set.
 * 
 * @return string the name of a field in an SQLite result set, given the ordinal
 * column number; false on error.
 */
function sqlite_field_name($result, $field_index) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Seek to a particular row number of a buffered result set
 * @link https://php.net/manual/en/function.sqlite-seek.php
 * @param resource $result 
 * The SQLite result resource. This parameter is not required when using
 * the object-oriented method.
 * 
 * <blockquote>Note: This function cannot be used with
 * unbuffered result handles.</blockquote>
 * @param int $rownum 
 * The ordinal row number to seek to. The row number is zero-based (0 is
 * the first row).
 * 
 * @return bool false if the row does not exist, true otherwise.
 */
function sqlite_seek($result, $rownum) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Seek to the first row number
 * @link https://php.net/manual/en/function.sqlite-rewind.php
 * @param resource $result 
 * The SQLite result resource. This parameter is not required when using
 * the object-oriented method.
 * 
 * <blockquote>Note: This function cannot be used with
 * unbuffered result handles.</blockquote>
 * @return bool false if there are no rows in the result set, true otherwise.
 */
function sqlite_rewind($result) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Seek to the next row number
 * @link https://php.net/manual/en/function.sqlite-next.php
 * @param resource $result 
 * The SQLite result resource. This parameter is not required when using
 * the object-oriented method.
 * 
 * <blockquote>Note: This function cannot be used with
 * unbuffered result handles.</blockquote>
 * @return bool TRUE on success, or FALSE if there are no more rows.
 */
function sqlite_next($result) {}

/**
 * Seek to the previous row number of a result set
 * @link https://php.net/manual/en/function.sqlite-prev.php
 * @param resource $result 
 * The SQLite result resource. This parameter is not required when using
 * the object-oriented method.
 * 
 * <blockquote>Note: This function cannot be used with
 * unbuffered result handles.</blockquote>
 * @return bool true on success, or false if there are no more previous rows.
 */
function sqlite_prev($result) {}

/**
 * Returns whether more rows are available
 * @link https://php.net/manual/en/function.sqlite-valid.php
 * @param resource $result 
 * The SQLite result resource. This parameter is not required when using
 * the object-oriented method.
 * 
 * <blockquote>Note: This function cannot be used with
 * unbuffered result handles.</blockquote>
 * @return bool TRUE if there are more rows available from the
 * result handle, or FALSE otherwise.
 */
function sqlite_valid($result) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Finds whether or not more rows are available
 * @link https://php.net/manual/en/function.sqlite-has-more.php
 * @param resource $result 
 * The SQLite result resource.
 * 
 * @return bool TRUE if there are more rows available from the
 * result handle, or FALSE otherwise.
 */
function sqlite_has_more($result) {}

/**
 * Returns whether or not a previous row is available
 * @link https://php.net/manual/en/function.sqlite-has-prev.php
 * @param resource $result 
 * The SQLite result resource. This parameter is not required when using
 * the object-oriented method.
 * 
 * @return bool TRUE if there are more previous rows available from the
 * result handle, or FALSE otherwise.
 */
function sqlite_has_prev($result) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Escapes a string for use as a query parameter
 * @link https://php.net/manual/en/function.sqlite-escape-string.php
 * @param string $item 
 * The string being quoted.
 * 
 * 
 * If the item contains a NUL
 * character, or if it begins with a character whose ordinal value is
 * 0x01, PHP will apply a binary encoding scheme so that
 * you can safely store and retrieve binary data.
 * 
 * @return string an escaped string for use in an SQLite SQL statement.
 */
function sqlite_escape_string($item) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Set busy timeout duration, or disable busy handlers
 * @link https://php.net/manual/en/function.sqlite-busy-timeout.php
 * @param resource $dbhandle The SQLite Database resource; returned from
 * {@see sqlite_open()} when used procedurally.
 * This parameter is not required when using the object-oriented method.
 * @param int $milliseconds 
 * The number of milliseconds. When set to
 * 0, busy handlers will be disabled and SQLite will
 * return immediately with a SQLITE_BUSY status code
 * if another process/thread has the database locked for an update.
 * 
 * 
 * PHP sets the default busy timeout to be 60 seconds when the database is
 * opened.
 * 
 * 
 * There are one thousand (1000) milliseconds in one second.
 * 
 * @return void
 */
function sqlite_busy_timeout($dbhandle, $milliseconds) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Returns the error code of the last error for a database
 * @link https://php.net/manual/en/function.sqlite-last-error.php
 * @param resource $dbhandle The SQLite Database resource; returned from
 * {@see sqlite_open()} when used procedurally.
 * This parameter is not required when using the object-oriented method.
 * @return int an error code, or 0 if no error occurred.
 */
function sqlite_last_error($dbhandle) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Returns the textual description of an error code
 * @link https://php.net/manual/en/function.sqlite-error-string.php
 * @param int $error_code 
 * The error code being used, which might be passed in from
 * {@see sqlite_last_error}.
 * 
 * @return string a human readable description of the error_code,
 * as a string.
 */
function sqlite_error_string($error_code) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Execute a query that does not prefetch and buffer all data
 * @link https://php.net/manual/en/function.sqlite-unbuffered-query.php
 * @param resource $dbhandle The SQLite Database resource; returned from
 * {@see sqlite_open()} when used procedurally.
 * This parameter is not required when using the object-oriented method.
 * @param string $query 
 * The query to be executed.
 * 
 * 
 * Data inside the query should be properly escaped.
 * 
 * @param int $result_type [optional]
 * @param string &$error_msg [optional] 
 * The specified variable will be filled if an error occurs. This is
 * specially important because SQL syntax errors can't be fetched using
 * the sqlite_last_error function.
 * 
 * @return SQLiteUnbuffered|false a result handle or false on failure.
 * 
 * sqlite_unbuffered_query returns a sequential
 * forward-only result set that can only be used to read each row, one after
 * the other.
 * 
 */
function sqlite_unbuffered_query($dbhandle, $query, $result_type = SQLITE_BOTH, &$error_msg = null) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Register an aggregating UDF for use in SQL statements
 * @link https://php.net/manual/en/function.sqlite-create-aggregate.php
 * @param resource $dbhandle The SQLite Database resource; returned from
 * {@see sqlite_open()} when used procedurally.
 * This parameter is not required when using the object-oriented method.
 * @param string $function_name 
 * The name of the function used in SQL statements.
 * 
 * @param callable $step_func 
 * Callback function called for each row of the result set.
 * 
 * @param callable $finalize_func 
 * Callback function to aggregate the "stepped" data from each row.
 * 
 * @param int $num_args [optional] 
 * Hint to the SQLite parser if the callback function accepts a
 * predetermined number of arguments.
 * 
 * @return void
 */
function sqlite_create_aggregate($dbhandle, $function_name, $step_func, $finalize_func, $num_args = null) {}

/**
 * (PHP 5, sqlite &gt;= 1.0.0) 
 * Registers a "regular" User Defined Function for use in SQL statements
 * @link https://php.net/manual/en/function.sqlite-create-function.php
 * @param resource $dbhandle The SQLite Database resource; returned from
 * {@see sqlite_open()} when used procedurally.
 * This parameter is not required when using the object-oriented method.
 * @param string $function_name 
 * The name of the function used in SQL statements.
 * 
 * @param callable $callback 
 * Callback function to handle the defined SQL function.
 * 
 * Callback functions should return a type understood by SQLite (i.e.
 * scalar type).
 * @param int $num_args [optional] 
 * Hint to the SQLite parser if the callback function accepts a
 * predetermined number of arguments.
 * 
 * @return void
 */
function sqlite_create_function($dbhandle, $function_name, $callback, $num_args = null) {}

/**
 * Opens a SQLite database and returns a SQLiteDatabase object
 * @link https://php.net/manual/en/function.sqlite-factory.php
 * @param string $filename 
 * The filename of the SQLite database.
 * 
 * @param int $mode [optional] 
 * The mode of the file. Intended to be used to open the database in
 * read-only mode. Presently, this parameter is ignored by the sqlite
 * library. The default value for mode is the octal value
 * 0666 and this is the recommended value.
 * 
 * @param string &$error_message [optional] 
 * Passed by reference and is set to hold a descriptive error message
 * explaining why the database could not be opened if there was an error.
 * 
 * @return SQLiteDatabase|null a SQLiteDatabase object on success, null on error.
 */
function sqlite_factory($filename, $mode = null, &$error_message = null) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Encode binary data before returning it from an UDF
 * @link https://php.net/manual/en/function.sqlite-udf-encode-binary.php
 * @param string $data 
 * The string being encoded.
 * 
 * @return string The encoded string.
 */
function sqlite_udf_encode_binary($data) {}

/**
 * (PHP 5, PECL sqlite &gt;= 1.0.0) 
 * Decode binary data passed as parameters to an <acronym>UDF</acronym>
 * @link https://php.net/manual/en/function.sqlite-udf-decode-binary.php
 * @param string $data 
 * The encoded data that will be decoded, data that was applied by either
 * sqlite_udf_encode_binary or
 * sqlite_escape_string.
 * 
 * @return string The decoded string.
 */
function sqlite_udf_decode_binary($data) {}

/**
 * Return an array of column types from a particular table
 * @link https://php.net/manual/en/function.sqlite-fetch-column-types.php
 * @param string $table_name 
 * The table name to query.
 * 
 * @param resource $dbhandle The SQLite Database resource; returned from
 * {@see sqlite_open()} when used procedurally.
 * This parameter is not required when using the object-oriented method.
 * @param int $result_type [optional] 
 * The optional result_type parameter accepts a
 * constant and determines how the returned array will be indexed. Using
 * SQLITE_ASSOC will return only associative indices
 * (named fields) while SQLITE_NUM will return only
 * numerical indices (ordinal field numbers).
 * SQLITE_BOTH will return both associative and
 * numerical indices. SQLITE_ASSOC is the default for
 * this function.
 * 
 * @return array|false an array of column data types; false on error.
 */
function sqlite_fetch_column_types($dbhandle, $table_name, $result_type = null) {}

/**
 * Columns are returned into the array having both a numerical index
 * and the field name as the array index.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_BOTH', 3);

/**
 * Columns are returned into the array having a numerical index to the
 * fields. This index starts with 0, the first field in the result.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_NUM', 2);

/**
 * Columns are returned into the array having the field name as the array
 * index.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_ASSOC', 1);

/**
 * Successful result.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_OK', 0);

/**
 * SQL error or missing database.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_ERROR', 1);

/**
 * An internal logic error in SQLite.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_INTERNAL', 2);

/**
 * Access permission denied.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_PERM', 3);

/**
 * Callback routine requested an abort.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_ABORT', 4);

/**
 * The database file is locked.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_BUSY', 5);

/**
 * A table in the database is locked.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_LOCKED', 6);

/**
 * Memory allocation failed.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_NOMEM', 7);

/**
 * Attempt to write a readonly database.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_READONLY', 8);

/**
 * Operation terminated internally.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_INTERRUPT', 9);

/**
 * Disk I/O error occurred.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_IOERR', 10);

/**
 * The database disk image is malformed.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_CORRUPT', 11);

/**
 * (Internal) Table or record not found.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_NOTFOUND', 12);

/**
 * Insertion failed because database is full.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_FULL', 13);

/**
 * Unable to open the database file.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_CANTOPEN', 14);

/**
 * Database lock protocol error.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_PROTOCOL', 15);

/**
 * (Internal) Database table is empty.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_EMPTY', 16);

/**
 * The database schema changed.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_SCHEMA', 17);

/**
 * Too much data for one row of a table.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_TOOBIG', 18);

/**
 * Abort due to constraint violation.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_CONSTRAINT', 19);

/**
 * Data type mismatch.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_MISMATCH', 20);

/**
 * Library used incorrectly.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_MISUSE', 21);

/**
 * Uses of OS features not supported on host.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_NOLFS', 22);

/**
 * Authorized failed.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_AUTH', 23);

/**
 * File opened that is not a database file.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_NOTADB', 26);

/**
 * Auxiliary database format error.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_FORMAT', 24);

/**
 * Internal process has another row ready.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_ROW', 100);

/**
 * Internal process has finished executing.
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE_DONE', 101);

/**
 * Specifies that a function created with {@see SQLite3::createFunction()} is deterministic,
 * i.e. it always returns the same result given the same inputs within a single SQL statement.
 * @since 7.1.4
 * @link https://php.net/manual/en/sqlite.constants.php
 */
define('SQLITE3_DETERMINISTIC', 2048);