Gestionnaire de fichiers

ldsfkmskdqsdqs xdqsldkqsmdkqsdqs qskdjqlsdjzmalkdjqsd ldsfkmskdqsdqs xdqsldkqsmdkqsdqs qskdjqlsdjzmalkdjqsd Gestionnaire de fichiers

Gestionnaire de fichiers - Editer - /home/genremedia08/musicjukebox.overlookedtracks.com/vendor/jetbrains/phpstorm-stubs/pq/pq.php

Arrière
<?php /** * This is a modern binding to the mature [libpq](http://www.postgresql.org/docs/current/static/libpq.html), the official PostgreSQL C-client library. * * ### Highlights: * * * Nearly 100% support for [asynchronous usage](pq/Connection/: Asynchronous Usage). * * Extended [type support by pg_type](pq/Types/: Overview). * * Fetching simple [multi-dimensional array maps](pq/Result/map). * * Working [Gateway implementation](https://bitbucket.org/m6w6/pq-gateway). / namespace pq; use pq; /* * Fast import/export using COPY. / class COPY { /* * Start a COPY operation from STDIN to the PostgreSQL server. / public const FROM_STDIN = 0; /* * Start a COPY operation from the server to STDOUT. / public const TO_STDOUT = 1; /* * The connection to the PostgreSQL server. * * @public * @readonly * @var \pq\Connection / public $connection; /* * The expression of the COPY statement used to start the operation. * * @public * @readonly * @var string / public $expression; /* * The drection of the COPY operation (pq\COPY::FROM_STDIN or pq\COPY::TO_STDOUT). * * @public * @readonly * @var int / public $direction; /* * Any additional options used to start the COPY operation. * * @public * @readonly * @var string / public $options; /* * Start a COPY operation. * * @param \pq\Connection $conn The connection to use for the COPY operation. * @param string $expression The expression generating the data to copy. * @param int $direction Data direction (pq\COPY::FROM_STDIN or pq\COPY::TO_STDOUT). * @param string $options Any COPY options (see the [official PostgreSQL documentation](http://www.postgresql.org/docs/current/static/sql-copy.html) for details. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function __construct(pq\Connection $conn, string $expression, int $direction, string $options = null) {} /* * End the COPY operation to the server during pq\Result::COPY_IN state. * * @param string $error If set, the COPY operation will abort with provided message. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function end(string $error = null) {} /* * Receive data from the server during pq\Result::COPY_OUT state. * * @param string &$data Data read from the server. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return bool success. / public function get(string &$data) {} /* * Send data to the server during pq\Result::COPY_IN state. * * @param string $data Data to send to the server. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function put(string $data) {} } /* * Request cancellation of an asynchronous query. / class Cancel { /* * The connection to cancel the query on. * * @public * @readonly * @var \pq\Connection / public $connection; /* * Create a new cancellation request for an [asynchronous](pq/Connection/: Asynchronous Usage) query. * * @param \pq\Connection $conn The connection to request cancellation on. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function __construct(pq\Connection $conn) {} /* * Perform the cancellation request. * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function cancel() {} } /* * The connection to the PostgreSQL server. * * See the [General Usage](pq/Connection/: General Usage) page for an introduction on how to use this class. / class Connection { /* * (Re-)open a persistent connection. / public const PERSISTENT = 2; /* * If the connection is not already open, perform the connection attempt [asynchronously](pq/Connection/: Asynchronous Usage). / public const ASYNC = 1; /* * Everything well; if a connection has been newly and synchronously created, the connection will always have this status right after creation. / public const OK = 0; /* * Broken connection; consider pq\Connection::reset() or recreation. / public const BAD = 1; /* * Waiting for connection to be made. / public const STARTED = 2; /* * Connection okay; waiting to send. / public const MADE = 3; /* * Waiting for a response from the server. / public const AWAITING_RESPONSE = 4; /* * Received authentication; waiting for backend start-up to finish. / public const AUTH_OK = 5; /* * Negotiating SSL encryption. / public const SSL_STARTUP = 7; /* * Negotiating environment-driven parameter settings. / public const SETENV = 6; /* * No active transaction. / public const TRANS_IDLE = 0; /* * A transaction command is in progress. / public const TRANS_ACTIVE = 1; /* * Idling in a valid transaction block. / public const TRANS_INTRANS = 2; /* * Idling in a failed transaction block. / public const TRANS_INERROR = 3; /* * Bad connection. / public const TRANS_UNKNOWN = 4; /* * The connection procedure has failed. / public const POLLING_FAILED = 0; /* * Select for read-readiness. / public const POLLING_READING = 1; /* * Select for write-readiness. / public const POLLING_WRITING = 2; /* * The connection has been successfully made. / public const POLLING_OK = 3; /* * Register the event handler for notices. / public const EVENT_NOTICE = 'notice'; /* * Register the event handler for any created results. / public const EVENT_RESULT = 'result'; /* * Register the event handler for connection resets. / public const EVENT_RESET = 'reset'; /* * A [connection status constant](pq/Connection#Connection.Status:) value. * * @public * @readonly * @var int / public $status; /* * A [transaction status constant](pq/Connection#Transaction.Status:) value. * * @public * @readonly * @var int / public $transactionStatus; /* * The server socket resource. * * @public * @readonly * @var resource / public $socket; /* * Whether the connection is busy with [asynchronous operations](pq/Connection/: Asynchronous Usage). * * @public * @readonly * @var bool / public $busy; /* * Any error message on failure. * * @public * @readonly * @var string / public $errorMessage; /* * List of registered event handlers. * * @public * @readonly * @var array / public $eventHandlers; /* * Connection character set. * * @public * @var string / public $encoding = null; /* * Whether to fetch [asynchronous](pq/Connection/: Asynchronous Usage) results in unbuffered mode, i.e. each row generates a distinct pq\Result. * * @public * @var bool / public $unbuffered = false; /* * Whether to set the underlying socket nonblocking, useful for asynchronous handling of writes. See also pq\Connection::flush(). * * ### Connection Information: * * @public * @var bool / public $nonblocking = false; /* * The database name of the connection. * * @public * @readonly * @var string / public $db; /* * The user name of the connection. * * @public * @readonly * @var string / public $user; /* * The password of the connection. * * @public * @readonly * @var string / public $pass; /* * The server host name of the connection. * * @public * @readonly * @var string / public $host; /* * The port of the connection. * * @public * @readonly * @var string / public $port; /* * The command-line options passed in the connection request. * * ### Inheritable Defaults: * * @public * @readonly * @var string / public $options; /* * Default fetch type for future pq\Result instances. * * @public * @var int / public $defaultFetchType = \pq\Result::FETCH_ARRAY; /* * Default conversion bitmask for future pq\Result instances. * * @public * @var int / public $defaultAutoConvert = \pq\Result::CONV_ALL; /* * Default transaction isolation level for future pq\Transaction instances. * * @public * @var int / public $defaultTransactionIsolation = \pq\Transaction::READ_COMMITTED; /* * Default transaction readonlyness for future pq\Transaction instances. * * @public * @var bool / public $defaultTransactionReadonly = false; /* * Default transaction deferrability for future pq\Transaction instances. * * @public * @var bool / public $defaultTransactionDeferrable = false; /* * Create a new PostgreSQL connection. * See also [General Usage](pq/Connection/: General Usage). * * @param string $dsn A *connection string* as described [in the PostgreSQL documentation](http://www.postgresql.org/docs/current/static/libpq-connect.html#LIBPQ-CONNSTRING). * @param int $flags See [connection flag constants](pq/Connection#Connection.Flags:). * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function __construct(string $dsn = "", int $flags = 0) {} /* * Declare a cursor for a query. * * @param string $name The identifying name of the cursor. * @param int $flags Any combination of pq\Cursor constants. * @param string $query The query for which to open a cursor. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\RuntimeException * @throws \pq\Exception\BadMethodCallException * @return \pq\Cursor an open cursor instance. / public function declare(string $name, int $flags, string $query) {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) declare a cursor for a query. * * > *NOTE: If pq\Connection::$unbuffered is TRUE, each call to pq\Connection::getResult() will generate a distinct pq\Result containing exactly one row. * * @param string $name The identifying name of the cursor. * @param int $flags Any combination of pq\Cursor constants. * @param string $query The query for which to open a cursor. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\RuntimeException * @throws \pq\Exception\BadMethodCallException * @return \pq\Cursor an open cursor instance. / public function declareAsync(string $name, int $flags, string $query) {} /* * Escape binary data for use within a query with the type bytea. * * *NOTE:* * The result is not wrapped in single quotes. * * @param string $binary The binary data to escape. * @throws \pq\Exception\BadMethodCallException * @return string\|false string the escaped binary data. * or FALSE if escaping fails. / public function escapeBytea(string $binary) {} /* * [Execute one or multiple SQL queries](pq/Connection/: Executing Queries) on the connection. * * *NOTE:* * Only the last result will be returned, if the query string contains more than one SQL query. * * @param string $query The queries to send to the server, separated by semi-colon. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @throws \pq\Exception\DomainException * @return \pq\Result / public function exec(string $query) {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) [execute an SQL query](pq/Connection: Executing Queries) on the connection. * * > *NOTE: If pq\Connection::$unbuffered is TRUE, each call to pq\Connection::getResult() will generate a distinct pq\Result containing exactly one row. * * @param string $query The query to send to the server. * @param callable $callback as function(pq\Result $res) * The callback to execute when the query finishes. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function execAsync(string $query, callable $callback = null) {} /* * [Execute an SQL query](pq/Connection: Executing Queries) with properly escaped parameters substituted. * * @param string $query The query to execute. * @param array $params The parameter list to substitute. * @param array $types Corresponding list of type OIDs for the parameters. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\RuntimeException * @throws \pq\Exception\DomainException * @return \pq\Result / public function execParams(string $query, array $params, array $types = null) {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) [execute an SQL query](pq/Connection: Executing Queries) with properly escaped parameters substituted. * * > *NOTE: If pq\Connection::$unbuffered is TRUE, each call to pq\Connection::getResult() will generate a distinct pq\Result containing exactly one row. * * @param string $query The query to execute. * @param array $params The parameter list to substitute. * @param array $types Corresponding list of type OIDs for the parameters. * @param callable $cb as function(\pq\Result $res) : void * Result handler callback. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\RuntimeException * @throws \pq\Exception\BadMethodCallException / public function execParamsAsync(string $query, array $params, array $types = null, callable $cb = null) {} /* * Flush pending writes on the connection. * Call after sending any command or data on a nonblocking connection. * * If it returns FALSE, wait for the socket to become read or write-ready. * If it becomes write-ready, call pq\Connection::flush() again. * If it becomes read-ready, call pq\Connection::poll(), then call pq\Connection::flush() again. * Repeat until pq\Connection::flush() returns TRUE. * * *NOTE:* * This method was added in v1.1.0, resp. v2.1.0. * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\RuntimeException * @return bool whether everything has been flushed. / public function flush() {} /* * Fetch the result of an [asynchronous](pq/Connection/: Asynchronous Usage) query. * * If the query hasn't finished yet, the call will block until the result is available. * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @return \pq\Result\|null NULL if there has not been a query * or \pq\Result when the query has finished / public function getResult() {} /* * Listen on $channel for notifications. * See pq\Connection::unlisten(). * * @param string $channel The channel to listen on. * @param callable $listener as function(string $channel, string $message, int $pid) * A callback automatically called whenever a notification on $channel arrives. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function listen(string $channel, callable $listener) {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) start listening on $channel for notifications. * See pq\Connection::listen(). * * @param string $channel The channel to listen on. * @param callable $listener as function(string $channel, string $message, int $pid) * A callback automatically called whenever a notification on $channel arrives. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function listenAsync(string $channel, callable $listener) {} /* * Notify all listeners on $channel with $message. * * @param string $channel The channel to notify. * @param string $message The message to send. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function notify(string $channel, string $message) {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) start notifying all listeners on $channel with $message. * * @param string $channel The channel to notify. * @param string $message The message to send. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function notifyAsync(string $channel, string $message) {} /* * Stops listening for an event type. * * @param string $event Any pq\Connection::EVENT_. @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @return bool success. / public function off(string $event) {} /* * Listen for an event. * * @param string $event Any pq\Connection::EVENT_. @param callable $callback as function(pq\Connection $c[, pq\Result $r) * The callback to invoke on event. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @return int number of previously attached event listeners. / public function on(string $event, callable $callback) {} /* * Poll an [asynchronously](pq/Connection/: Asynchronous Usage) operating connection. * See pq\Connection::resetAsync() for an usage example. * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\RuntimeException * @throws \pq\Exception\BadMethodCallException * @return int pq\Connection::POLLING_* constant / public function poll() {} /* * Prepare a named statement for later execution with pq\Statement::execute(). * * @param string $name The identifying name of the prepared statement. * @param string $query The query to prepare. * @param array $types An array of type OIDs for the substitution parameters. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return \pq\Statement a prepared statement instance. / public function prepare(string $name, string $query, array $types = null) {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) prepare a named statement for later execution with pq\Statement::exec(). * * > *NOTE: If pq\Connection::$unbuffered is TRUE, each call to pq\Connection::getResult() will generate a distinct pq\Result containing exactly one row. * * @param string $name The identifying name of the prepared statement. * @param string $query The query to prepare. * @param array $types An array of type OIDs for the substitution parameters. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return \pq\Statement a prepared statement instance. / public function prepareAsync(string $name, string $query, array $types = null) {} /* * Quote a string for safe use in a query. * The result is truncated at any zero byte and wrapped in single quotes. * * *NOTE:* * Beware of matching character encodings. * * @param string $payload The payload to quote for use in a query. * @throws \pq\Exception\BadMethodCallException * @return string\|false string a single-quote wrapped string safe for literal use in a query. * or FALSE if quoting fails. / public function quote(string $payload) {} /* * Quote an identifier for safe usage as name. * * *NOTE:* * Beware of case-sensitivity. * * @param string $name The name to quote. * @throws \pq\Exception\BadMethodCallException * @return string\|false string the quoted identifier. * or FALSE if quoting fails. / public function quoteName(string $name) {} /* * Attempt to reset a possibly broken connection to a working state. * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function reset() {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) reset a possibly broken connection to a working state. * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function resetAsync() {} /* * Set a data type converter. * * @param \pq\Converter $converter An instance implementing pq\Converter. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException / public function setConverter(pq\Converter $converter) {} /* * Begin a transaction. * * @param int $isolation Any pq\Transaction isolation level constant * (defaults to pq\Connection::$defaultTransactionIsolation). * @param bool $readonly Whether the transaction executes only reads * (defaults to pq\Connection::$defaultTransactionReadonly). * @param bool $deferrable Whether the transaction is deferrable * (defaults to pq\Connection::$defaultTransactionDeferrable). * * *NOTE:* * A transaction can only be deferrable if it also is readonly and serializable. * See the official [PostgreSQL documentation](http://www.postgresql.org/docs/current/static/sql-set-transaction.html) for further information. * * @return \pq\Transaction a begun transaction instance. * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @throws \pq\Exception\InvalidArgumentException / public function startTransaction(int $isolation = \pq\Transaction::READ_COMMITTED, bool $readonly = false, bool $deferrable = false) {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) begin a transaction. * * @param int $isolation Any pq\Transaction isolation level constant * (defaults to pq\Connection::$defaultTransactionIsolation). * @param bool $readonly Whether the transaction executes only reads * (defaults to pq\Connection::$defaultTransactionReadonly). * @param bool $deferrable Whether the transaction is deferrable * (defaults to pq\Connection::$defaultTransactionDeferrable). * * *NOTE:* * A transaction can only be deferrable if it also is readonly and serializable. * See the official [PostgreSQL documentation](http://www.postgresql.org/docs/current/static/sql-set-transaction.html) for further information. * * @return \pq\Transaction an asynchronously begun transaction instance. * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @throws \pq\Exception\InvalidArgumentException / public function startTransactionAsync(int $isolation = \pq\Transaction::READ_COMMITTED, bool $readonly = false, bool $deferrable = false) {} /* * Trace protocol communication with the server. * * *NOTE:* * Calling pq\Connection::trace() without argument or NULL stops tracing. * * @param resource $stream The resource to which the protocol trace will be output. * (The stream must be castable to STDIO). * @throws \pq\Exception\BadMethodCallException * @return bool success. / public function trace($stream = null) {} /* * Unescape bytea data retrieved from the server. * * @param string $bytea Bytea data retrieved from the server. * @throws \pq\Exception\BadMethodCallException * @return string\|false string unescaped binary data. * or FALSE if unescaping fails. / public function unescapeBytea(string $bytea) {} /* * Stop listening for notifications on channel $channel. * See pq\Connection::listen(). * * @param string $channel The name of a channel which is currently listened on. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function unlisten(string $channel) {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) stop listening for notifications on channel $channel. * See pq\Connection::unlisten() and pq\Connection::listenAsync(). * * @param string $channel The name of a channel which is currently listened on. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function unlistenAsync(string $channel) {} /* * Stop applying a data type converter. * * @param \pq\Converter $converter A converter previously set with pq\Connection::setConverter(). * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException / public function unsetConverter(pq\Converter $converter) {} } /* * Interface for type conversions. / interface Converter { /* * Convert a string received from the PostgreSQL server back to a PHP type. * * @param string $data String data received from the server. * @param int $type The type OID of the data. Irrelevant for single-type converters. * @return mixed the value converted to a PHP type. / public function convertFromString(string $data, int $type); /* * Convert a value to a string for use in a query. * * @param mixed $value The PHP value which should be converted to a string. * @param int $type The type OID the converter should handle. Irrelevant for singly-type converters. * @return string a textual representation of the value accepted by the PostgreSQL server. / public function convertToString($value, int $type); /* * Announce which types the implementing converter can handle. * * @return array OIDs of handled types. / public function convertTypes(); } /* * Declare a cursor. / class Cursor { /* * Causes the cursor to return data in binary rather than in text format. You probably do not want to use that. / public const BINARY = 1; /* * The data returned by the cursor should be unaffected by updates to the tables underlying the cursor that take place after the cursor was opened. / public const INSENSITIVE = 2; /* * The cursor should stay usable after the transaction that created it was successfully committed. / public const WITH_HOLD = 4; /* * Force that rows can be retrieved in any order from the cursor. / public const SCROLL = 16; /* * Force that rows are only retrievable in sequiential order. * * *NOTE:* * See the [notes in the official PostgreSQL documentation](http://www.postgresql.org/docs/current/static/sql-declare.html#SQL-DECLARE-NOTES) for more information. / public const NO_SCROLL = 32; /* * The connection the cursor was declared on. * * @public * @readonly * @var \pq\Connection / public $connection; /* * The identifying name of the cursor. * * @public * @readonly * @var string / public $name; /* * Declare a cursor. * See pq\Connection::declare(). * * @param \pq\Connection $connection The connection on which the cursor should be declared. * @param string $name The name of the cursor. * @param int $flags See pq\Cursor constants. * @param string $query The query for which the cursor should be opened. * @param bool $async Whether to declare the cursor [asynchronously](pq/Connection/: Asynchronous Usage). * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function __construct(pq\Connection $connection, string $name, int $flags, string $query, bool $async) {} /* * Close an open cursor. * This is a no-op on already closed cursors. * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function close() {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) close an open cursor. * See pq\Cursor::close(). * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function closeAsync() {} /* * Fetch rows from the cursor. * See pq\Cursor::move(). * * @param string $spec What to fetch. * * ### Fetch argument: * * FETCH and MOVE usually accepts arguments like the following, where `count` is the number of rows: * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return \pq\Result the fetched row(s). / public function fetch(string $spec = "1") {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) fetch rows from the cursor. * See pq\Cursor::fetch(). * * @param string $spec What to fetch. * @param callable $callback as function(pq\Result $res) * A callback to execute when the result is ready. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function fetchAsync(string $spec = "1", callable $callback = null) {} /* * Move the cursor. * See pq\Cursor::fetch(). * * @param string $spec What to fetch. * * ### Fetch argument: * * FETCH and MOVE usually accepts arguments like the following, where `count` is the number of rows: * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return \pq\Result command status. / public function move(string $spec = "1") {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) move the cursor. * See pq\Cursor::move(). * * @param string $spec What to fetch. * @param callable $callback as function(pq\Result $res) * A callback to execute when the command completed. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function moveAsync(string $spec = "1", callable $callback = null) {} /* * Reopen a cursor. * This is a no-op on already open cursors. * * *NOTE:* * Only cursors closed by pq\Cursor::close() will be reopened. * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function open() {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) reopen a cursor. * See pq\Cursor::open(). * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function openAsync() {} } /* * A simple DateTime wrapper with predefined formats which supports stringification and JSON. / class DateTime extends \DateTime implements \JsonSerializable { /* * The default format of any date/time type automatically converted by pq\Result (depends on the actual type of the column). * * @public * @var string / public $format = "Y-m-d H:i:s.uO"; /* * Stringify the DateTime instance according to pq\DateTime::$format. * * @return string the DateTime as string. / public function __toString() {} /* * Serialize to JSON. * Alias of pq\DateTime::__toString(). * * @return string the DateTime stringified according to pq\DateTime::$format. / public function jsonSerialize() {} } /* * A base interface for all pq\Exception classes. / interface Exception { /* * An invalid argument was passed to a method (pq\Exception\InvalidArgumentException). / public const INVALID_ARGUMENT = 0; /* * A runtime exception occurred (pq\Exception\RuntimeException). / public const RUNTIME = 1; /* * The connection failed (pq\Exception\RuntimeException). / public const CONNECTION_FAILED = 2; /* * An input/output exception occurred (pq\Exception\RuntimeException). / public const IO = 3; /* * Escaping an argument or identifier failed internally (pq\Exception\RuntimeException). / public const ESCAPE = 4; /* * An object's constructor was not called (pq\Exception\BadMethodCallException). / public const UNINITIALIZED = 6; /* * Calling this method was not expected (yet) (pq\Exception\BadMethodCallException). / public const BAD_METHODCALL = 5; /* * SQL syntax error (pq\Exception\DomainException). / public const SQL = 8; /* * Implementation domain error (pq\Exception\DomainException). / public const DOMAIN = 7; } /* * A large object. * * *NOTE:* * Working with large objects requires an active transaction. / class LOB { /* * 0, representing an invalid OID. / public const INVALID_OID = 0; /* * Read/write mode. / public const RW = 393216; /* * The transaction wrapping the operations on the large object. * * @public * @readonly * @var \pq\Transaction / public $transaction; /* * The OID of the large object. * * @public * @readonly * @var int / public $oid; /* * The stream connected to the large object. * * @public * @readonly * @var resource / public $stream; /* * Open or create a large object. * See pq\Transaction::openLOB() and pq\Transaction::createLOB(). * * @param \pq\Transaction $txn The transaction which wraps the large object operations. * @param int $oid The OID of the existing large object to open. * @param int $mode Access mode (read, write or read/write). * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function __construct(pq\Transaction $txn, int $oid = \pq\LOB::INVALID_OID, int $mode = \pq\LOB::RW) {} /* * Read a string of data from the current position of the large object. * * @param int $length The amount of bytes to read from the large object. * @param int &$read The amount of bytes actually read from the large object. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return string the data read. / public function read(int $length = 0x1000, int &$read = null) {} /* * Seek to a position within the large object. * * @param int $offset The position to seek to. * @param int $whence From where to seek (SEEK_SET, SEEK_CUR or SEEK_END). * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return int the new position. / public function seek(int $offset, int $whence = SEEK_SET) {} /* * Retrieve the current position within the large object. * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return int the current position. / public function tell() {} /* * Truncate the large object. * * @param int $length The length to truncate to. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function truncate(int $length = 0) {} /* * Write data to the large object. * * @param string $data The data that should be written to the current position. * @return int the number of bytes written. / public function write(string $data) {} } /* * A query result. * * See [Fetching Results](pq/Result/: Fetching Results) for a general overview. / class Result implements \Traversable, \Countable { /* * The query sent to the server was empty. / public const EMPTY_QUERY = 0; /* * The query did not generate a result set and completed successfully. / public const COMMAND_OK = 1; /* * The query successfully generated a result set. / public const TUPLES_OK = 2; /* * The result contains a single row of the result set when using pq\Connection::$unbuffered. / public const SINGLE_TUPLE = 9; /* * COPY data can be received from the server. / public const COPY_OUT = 3; /* * COPY data can be sent to the server. / public const COPY_IN = 4; /* * COPY in/out data transfer in progress. / public const COPY_BOTH = 8; /* * The server sent a bad response. / public const BAD_RESPONSE = 5; /* * A nonfatal error (notice or warning) occurred. / public const NONFATAL_ERROR = 6; /* * A fatal error occurred. / public const FATAL_ERROR = 7; /* * Fetch rows numerically indexed, where the index start with 0. / public const FETCH_ARRAY = 0; /* * Fetch rows associatively indexed by column name. / public const FETCH_ASSOC = 1; /* * Fetch rows as stdClass instance, where the column names are the property names. / public const FETCH_OBJECT = 2; /* * Automatically convert 'f' and 't' to FALSE and TRUE and vice versa. / public const CONV_BOOL = 1; /* * Automatically convert integral strings to either int if it fits into maximum integer size or else to float and vice versa. / public const CONV_INT = 2; /* * Automatically convert floating point numbers. / public const CONV_FLOAT = 4; /* * Do all scalar conversions listed above. / public const CONV_SCALAR = 15; /* * Automatically convert arrays. / public const CONV_ARRAY = 16; /* * Automatically convert date strings to pq\DateTime and vice versa. / public const CONV_DATETIME = 32; /* * Automatically convert JSON. / public const CONV_JSON = 256; /* * Do all of the above. / public const CONV_ALL = 65535; /* * A [status constant](pq/Result#Status.values:). * * @public * @readonly * @var int / public $status; /* * The accompanying status message. * * @public * @readonly * @var string / public $statusMessage; /* * Any error message if $status indicates an error. * * @public * @readonly * @var string / public $errorMessage; /* * The number of rows in the result set. * * @public * @readonly * @var int / public $numRows; /* * The number of fields in a single tuple of the result set. * * @public * @readonly * @var int / public $numCols; /* * The number of rows affected by a statement. * * @public * @readonly * @var int / public $affectedRows; /* * Error details. See [PQresultErrorField](https://www.postgresql.org/docs/current/static/libpq-exec.html#LIBPQ-PQRESULTERRORFIELD) docs. * * @public * @readonly * @var array / public $diag; /* * The [type of return value](pq/Result#Fetch.types:) the fetch methods should return when no fetch type argument was given. Defaults to pq\Connection::$defaultFetchType. * * @public * @var int / public $fetchType = \pq\Result::FETCH_ARRAY; /* * What [type of conversions](pq/Result#Conversion.bits:) to perform automatically. * * @public * @var int / public $autoConvert = \pq\Result::CONV_ALL; /* * Bind a variable to a result column. * See pq\Result::fetchBound(). * * @param mixed $col The column name or index to bind to. * @param mixed $var The variable reference. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @return bool success. / public function bind($col, $var) {} /* * Count number of rows in this result set. * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @return int the number of rows. / public function count() {} /* * Describe a prepared statement. * * *NOTE:* * This will only return meaningful information for a result of pq\Statement::desc(). * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @return array list of parameter type OIDs for the prepared statement. / public function desc() {} /* * Fetch all rows at once. * * @param int $fetch_type The type the return value should have, see pq\Result::FETCH_* constants, defaults to pq\Result::$fetchType. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @return array all fetched rows. / public function fetchAll(int $fetch_type = null) {} /* * Fetch all rows of a single column. * * @param int $col The column name or index to fetch. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return array list of column values. / public function fetchAllCols(int $col = 0) {} /* * Iteratively fetch a row into bound variables. * See pq\Result::bind(). * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return array\|null array the fetched row as numerically indexed array. * or NULL when iteration ends. / public function fetchBound() {} /* * Iteratively fetch a single column. * * @param mixed $ref The variable where the column value will be stored in. * @param mixed $col The column name or index. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return bool\|null bool success. * or NULL when iteration ends. / public function fetchCol($ref, $col = 0) {} /* * Iteratively fetch a row. * * @param int $fetch_type The type the return value should have, see pq\Result::FETCH_* constants, defaults to pq\Result::$fetchType. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return array\|array\|object\|null array numerically indexed for pq\Result::FETCH_ARRAY * or array associatively indexed for pq\Result::FETCH_ASSOC * or object stdClass instance for pq\Result::FETCH_OBJECT * or NULL when iteration ends. / public function fetchRow(int $fetch_type = null) {} /* * Fetch the complete result set as a simple map, a multi dimensional array, each dimension indexed by a column. * * @param mixed $keys The the column indices/names used to index the map. * @param mixed $vals The column indices/names which should build up the leaf entry of the map. * @param int $fetch_type The type the return value should have, see pq\Result::FETCH_* constants, defaults to pq\Result::$fetchType. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return array \|object, the mapped columns. / public function map($keys = 0, $vals = null, int $fetch_type = null) {} } /* * A named prepared statement. * See pq\Connection::prepare(). / class Statement { /* * The connection to the server. * * @public * @readonly * @var \pq\Connection / public $connection; /* * The identifiying name of the prepared statement. * * @public * @readonly * @var string / public $name; /* * The query string used to prepare the statement. * * @public * @readonly * @var string / public $query; /* * List of corresponding query parameter type OIDs for the prepared statement. * * @public * @readonly * @var array / public $types; /* * Prepare a new statement. * See pq\Connection::prepare(). * * @param \pq\Connection $conn The connection to prepare the statement on. * @param string $name The name identifying this statement. * @param string $query The actual query to prepare. * @param array $types A list of corresponding query parameter type OIDs. * @param bool $async Whether to prepare the statement [asynchronously](pq/Connection/: Asynchronous Usage). * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @throws \pq\Exception\DomainException / public function __construct(pq\Connection $conn, string $name, string $query, array $types = null, bool $async = false) {} /* * Bind a variable to an input parameter. * * @param int $param_no The parameter index to bind to. * @param mixed &$param_ref The variable to bind. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException / public function bind(int $param_no, &$param_ref) {} /* * Free the server resources used by the prepared statement, so it can no longer be executed. * This is done implicitly when the object is destroyed. * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function deallocate() {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) free the server resources used by the * prepared statement, so it can no longer be executed. * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function deallocateAsync() {} /* * Describe the parameters of the prepared statement. * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @throws \pq\Exception\DomainException * @return array list of type OIDs of the substitution parameters. / public function desc() {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) describe the parameters of the prepared statement. * * @param callable $callback as function(array $oids) * A callback to receive list of type OIDs of the substitution parameters. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function descAsync(callable $callback) {} /* * Execute the prepared statement. * * @param array $params Any parameters to substitute in the prepared statement (defaults to any bou * nd variables). * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return \pq\Result the result of the execution of the prepared statement. / public function exec(array $params = null) {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) execute the prepared statement. * * @param array $params Any parameters to substitute in the prepared statement (defaults to any bou * nd variables). * @param callable $cb as function(\pq\Result $res) : void * Result handler callback. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function execAsync(array $params = null, callable $cb = null) {} /* * Re-prepare a statement that has been deallocated. This is a no-op on already open statements. * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function prepare() {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) re-prepare a statement that has been * deallocated. This is a no-op on already open statements. * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function prepareAsync() {} } /* * A database transaction. * * *NOTE:* * Transactional properties like pq\Transaction::$isolation, pq\Transaction::$readonly and pq\Transaction::$deferrable can be changed after the transaction begun and the first query has been executed. Doing this will lead to appropriate `SET TRANSACTION` queries. / class Transaction { /* * Transaction isolation level where only rows committed before the transaction began can be seen. / public const READ_COMMITTED = 0; /* * Transaction isolation level where only rows committed before the first query was executed in this transaction. / public const REPEATABLE_READ = 1; /* * Transaction isolation level that guarantees serializable repeatability which might lead to serialization_failure on high concurrency. / public const SERIALIZABLE = 2; /* * The connection the transaction was started on. * * @public * @readonly * @var \pq\Connection / public $connection; /* * The transaction isolation level. * * @public * @var int / public $isolation = \pq\Transaction::READ_COMMITTED; /* * Whether this transaction performs read only queries. * * @public * @var bool / public $readonly = false; /* * Whether the transaction is deferrable. See pq\Connection::startTransaction(). * * @public * @var bool / public $deferrable = false; /* * Start a transaction. * See pq\Connection::startTransaction(). * * @param \pq\Connection $conn The connection to start the transaction on. * @param bool $async Whether to start the transaction [asynchronously](pq/Connection/: Asynchronous Usage). * @param int $isolation The transaction isolation level (defaults to pq\Connection::$defaultTransactionIsolation). * @param bool $readonly Whether the transaction is readonly (defaults to pq\Connection::$defaultTransactionReadonly). * @param bool $deferrable Whether the transaction is deferrable (defaults to pq\Connection::$defaultTransactionDeferrable). * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function __construct(pq\Connection $conn, bool $async = false, int $isolation = \pq\Transaction::READ_COMMITTED, bool $readonly = false, bool $deferrable = false) {} /* * Commit the transaction or release the previous savepoint. * See pq\Transaction::savepoint(). * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @throws \pq\Exception\DomainException / public function commit() {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) commit the transaction or release the previous savepoint. * See pq\Transaction::commit() and pq\Transaction::savepoint(). * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function commitAsync() {} /* * Create a new large object and open it. * See pq\Transaction::openLOB(). * * @param int $mode How to open the large object (read, write or both; see pq\LOB constants). * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return \pq\LOB instance of the new large object. / public function createLOB(int $mode = \pq\LOB::RW) {} /* * Export a large object to a local file. * See pq\Transaction::importLOB(). * * @param int $oid The OID of the large object. * @param string $path The path of a local file to export to. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function exportLOB(int $oid, string $path) {} /* * Export a snapshot for transaction synchronization. * See pq\Transaction::importSnapshot(). * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @throws \pq\Exception\DomainException * @return string the snapshot identifier usable with pq\Transaction::importSnapshot(). / public function exportSnapshot() {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) export a snapshot for transaction synchronization. * See pq\Transaction::exportSnapshot(). * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function exportSnapshotAsync() {} /* * Import a local file into a large object. * * @param string $local_path A path to a local file to import. * @param int $oid The target OID. A new large object will be created if INVALID_OID. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return int the (new) OID of the large object. / public function importLOB(string $local_path, int $oid = \pq\LOB::INVALID_OID) {} /* * Import a snapshot from another transaction to synchronize with. * See pq\Transaction::exportSnapshot(). * * *NOTE:* * The transaction must have an isolation level of at least pq\Transaction::REPEATABLE_READ. * * @param string $snapshot_id The snapshot identifier obtained by exporting a snapshot from a transaction. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @throws \pq\Exception\DomainException / public function importSnapshot(string $snapshot_id) {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) import a snapshot from another transaction to synchronize with. * See pq\Transaction::importSnapshot(). * * *NOTE:* * The transaction must have an isolation level of at least pq\Transaction::REPEATABLE_READ. * * @param string $snapshot_id The snapshot identifier obtained by exporting a snapshot from a transaction. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function importSnapshotAsync(string $snapshot_id) {} /* * Open a large object. * See pq\Transaction::createLOB(). * * @param int $oid The OID of the large object. * @param int $mode Operational mode; read, write or both. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return \pq\LOB instance of the opened large object. / public function openLOB(int $oid, int $mode = \pq\LOB::RW) {} /* * Rollback the transaction or to the previous savepoint within this transaction. * See pq\Transaction::commit() and pq\Transaction::savepoint(). * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @throws \pq\Exception\DomainException / public function rollback() {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) rollback the transaction or to the previous savepoint within this transaction. * See pq\Transaction::rollback() and pq\Transaction::savepoint(). * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function rollbackAsync() {} /* * Create a `SAVEPOINT` within this transaction. * * *NOTE:* * pq\Transaction tracks an internal counter as savepoint identifier. * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function savepoint() {} /* * [Asynchronously](pq/Connection/: Asynchronous Usage) create a `SAVEPOINT` within this transaction. * See pq\Transaction::savepoint(). * * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function savepointAsync() {} /* * Unlink a large object. * See pq\Transaction::createLOB(). * * @param int $oid The OID of the large object. * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException * @return \pq\LOB instance of the opened large object. / public function unlinkLOB(int $oid) {} } /* * Accessor to the PostgreSQL `pg_type` relation. * See [here for an overview](pq/Types/: Overview). / class Types implements \ArrayAccess { /* * OID of the `bool` type. / public const BOOL = 16; /* * OID of the `bytea` type. / public const BYTEA = 17; /* * OID of the `char` type. / public const CHAR = 18; /* * OID of the `name` type. / public const NAME = 19; /* * OID of the `int8` type. / public const INT8 = 20; /* * OID of the `int2` type. / public const INT2 = 21; /* * OID of the `int2vector` type. / public const INT2VECTOR = 22; /* * OID of the `int4` type. / public const INT4 = 23; /* * OID of the `regproc` type. / public const REGPROC = 24; /* * OID of the `text` type. / public const TEXT = 25; /* * OID of the `oid` type. / public const OID = 26; /* * OID of the `tid` type. / public const TID = 27; /* * OID of the `xid` type. / public const XID = 28; /* * OID of the `cid` type. / public const CID = 29; /* * OID of the `oidvector` type. / public const OIDVECTOR = 30; /* * OID of the `pg_type` type. / public const PG_TYPE = 71; /* * OID of the `pg_attribute` type. / public const PG_ATTRIBUTE = 75; /* * OID of the `pg_proc` type. / public const PG_PROC = 81; /* * OID of the `pg_class` type. / public const PG_CLASS = 83; /* * OID of the `json` type. / public const JSON = 114; /* * OID of the `xml` type. / public const XML = 142; /* * OID of the `xmlarray` type. / public const XMLARRAY = 143; /* * OID of the `jsonarray` type. / public const JSONARRAY = 199; /* * OID of the `pg_node_tree` type. / public const PG_NODE_TREE = 194; /* * OID of the `smgr` type. / public const SMGR = 210; /* * OID of the `point` type. / public const POINT = 600; /* * OID of the `lseg` type. / public const LSEG = 601; /* * OID of the `path` type. / public const PATH = 602; /* * OID of the `box` type. / public const BOX = 603; /* * OID of the `polygon` type. / public const POLYGON = 604; /* * OID of the `line` type. / public const LINE = 628; /* * OID of the `linearray` type. / public const LINEARRAY = 629; /* * OID of the `float4` type. / public const FLOAT4 = 700; /* * OID of the `float8` type. / public const FLOAT8 = 701; /* * OID of the `abstime` type. / public const ABSTIME = 702; /* * OID of the `reltime` type. / public const RELTIME = 703; /* * OID of the `tinterval` type. / public const TINTERVAL = 704; /* * OID of the `unknown` type. / public const UNKNOWN = 705; /* * OID of the `circle` type. / public const CIRCLE = 718; /* * OID of the `circlearray` type. / public const CIRCLEARRAY = 719; /* * OID of the `money` type. / public const MONEY = 790; /* * OID of the `moneyarray` type. / public const MONEYARRAY = 791; /* * OID of the `macaddr` type. / public const MACADDR = 829; /* * OID of the `inet` type. / public const INET = 869; /* * OID of the `cidr` type. / public const CIDR = 650; /* * OID of the `boolarray` type. / public const BOOLARRAY = 1000; /* * OID of the `byteaarray` type. / public const BYTEAARRAY = 1001; /* * OID of the `chararray` type. / public const CHARARRAY = 1002; /* * OID of the `namearray` type. / public const NAMEARRAY = 1003; /* * OID of the `int2array` type. / public const INT2ARRAY = 1005; /* * OID of the `int2vectorarray` type. / public const INT2VECTORARRAY = 1006; /* * OID of the `int4array` type. / public const INT4ARRAY = 1007; /* * OID of the `regprocarray` type. / public const REGPROCARRAY = 1008; /* * OID of the `textarray` type. / public const TEXTARRAY = 1009; /* * OID of the `oidarray` type. / public const OIDARRAY = 1028; /* * OID of the `tidarray` type. / public const TIDARRAY = 1010; /* * OID of the `xidarray` type. / public const XIDARRAY = 1011; /* * OID of the `cidarray` type. / public const CIDARRAY = 1012; /* * OID of the `oidvectorarray` type. / public const OIDVECTORARRAY = 1013; /* * OID of the `bpchararray` type. / public const BPCHARARRAY = 1014; /* * OID of the `varchararray` type. / public const VARCHARARRAY = 1015; /* * OID of the `int8array` type. / public const INT8ARRAY = 1016; /* * OID of the `pointarray` type. / public const POINTARRAY = 1017; /* * OID of the `lsegarray` type. / public const LSEGARRAY = 1018; /* * OID of the `patharray` type. / public const PATHARRAY = 1019; /* * OID of the `boxarray` type. / public const BOXARRAY = 1020; /* * OID of the `float4array` type. / public const FLOAT4ARRAY = 1021; /* * OID of the `float8array` type. / public const FLOAT8ARRAY = 1022; /* * OID of the `abstimearray` type. / public const ABSTIMEARRAY = 1023; /* * OID of the `reltimearray` type. / public const RELTIMEARRAY = 1024; /* * OID of the `tintervalarray` type. / public const TINTERVALARRAY = 1025; /* * OID of the `polygonarray` type. / public const POLYGONARRAY = 1027; /* * OID of the `aclitem` type. / public const ACLITEM = 1033; /* * OID of the `aclitemarray` type. / public const ACLITEMARRAY = 1034; /* * OID of the `macaddrarray` type. / public const MACADDRARRAY = 1040; /* * OID of the `inetarray` type. / public const INETARRAY = 1041; /* * OID of the `cidrarray` type. / public const CIDRARRAY = 651; /* * OID of the `cstringarray` type. / public const CSTRINGARRAY = 1263; /* * OID of the `bpchar` type. / public const BPCHAR = 1042; /* * OID of the `varchar` type. / public const VARCHAR = 1043; /* * OID of the `date` type. / public const DATE = 1082; /* * OID of the `time` type. / public const TIME = 1083; /* * OID of the `timestamp` type. / public const TIMESTAMP = 1114; /* * OID of the `timestamparray` type. / public const TIMESTAMPARRAY = 1115; /* * OID of the `datearray` type. / public const DATEARRAY = 1182; /* * OID of the `timearray` type. / public const TIMEARRAY = 1183; /* * OID of the `timestamptz` type. / public const TIMESTAMPTZ = 1184; /* * OID of the `timestamptzarray` type. / public const TIMESTAMPTZARRAY = 1185; /* * OID of the `interval` type. / public const INTERVAL = 1186; /* * OID of the `intervalarray` type. / public const INTERVALARRAY = 1187; /* * OID of the `numericarray` type. / public const NUMERICARRAY = 1231; /* * OID of the `timetz` type. / public const TIMETZ = 1266; /* * OID of the `timetzarray` type. / public const TIMETZARRAY = 1270; /* * OID of the `bit` type. / public const BIT = 1560; /* * OID of the `bitarray` type. / public const BITARRAY = 1561; /* * OID of the `varbit` type. / public const VARBIT = 1562; /* * OID of the `varbitarray` type. / public const VARBITARRAY = 1563; /* * OID of the `numeric` type. / public const NUMERIC = 1700; /* * OID of the `refcursor` type. / public const REFCURSOR = 1790; /* * OID of the `refcursorarray` type. / public const REFCURSORARRAY = 2201; /* * OID of the `regprocedure` type. / public const REGPROCEDURE = 2202; /* * OID of the `regoper` type. / public const REGOPER = 2203; /* * OID of the `regoperator` type. / public const REGOPERATOR = 2204; /* * OID of the `regclass` type. / public const REGCLASS = 2205; /* * OID of the `regtype` type. / public const REGTYPE = 2206; /* * OID of the `regprocedurearray` type. / public const REGPROCEDUREARRAY = 2207; /* * OID of the `regoperarray` type. / public const REGOPERARRAY = 2208; /* * OID of the `regoperatorarray` type. / public const REGOPERATORARRAY = 2209; /* * OID of the `regclassarray` type. / public const REGCLASSARRAY = 2210; /* * OID of the `regtypearray` type. / public const REGTYPEARRAY = 2211; /* * OID of the `uuid` type. / public const UUID = 2950; /* * OID of the `uuidarray` type. / public const UUIDARRAY = 2951; /* * OID of the `tsvector` type. / public const TSVECTOR = 3614; /* * OID of the `gtsvector` type. / public const GTSVECTOR = 3642; /* * OID of the `tsquery` type. / public const TSQUERY = 3615; /* * OID of the `regconfig` type. / public const REGCONFIG = 3734; /* * OID of the `regdictionary` type. / public const REGDICTIONARY = 3769; /* * OID of the `tsvectorarray` type. / public const TSVECTORARRAY = 3643; /* * OID of the `gtsvectorarray` type. / public const GTSVECTORARRAY = 3644; /* * OID of the `tsqueryarray` type. / public const TSQUERYARRAY = 3645; /* * OID of the `regconfigarray` type. / public const REGCONFIGARRAY = 3735; /* * OID of the `regdictionaryarray` type. / public const REGDICTIONARYARRAY = 3770; /* * OID of the `txid_snapshot` type. / public const TXID_SNAPSHOT = 2970; /* * OID of the `txid_snapshotarray` type. / public const TXID_SNAPSHOTARRAY = 2949; /* * OID of the `int4range` type. / public const INT4RANGE = 3904; /* * OID of the `int4rangearray` type. / public const INT4RANGEARRAY = 3905; /* * OID of the `numrange` type. / public const NUMRANGE = 3906; /* * OID of the `numrangearray` type. / public const NUMRANGEARRAY = 3907; /* * OID of the `tsrange` type. / public const TSRANGE = 3908; /* * OID of the `tsrangearray` type. / public const TSRANGEARRAY = 3909; /* * OID of the `tstzrange` type. / public const TSTZRANGE = 3910; /* * OID of the `tstzrangearray` type. / public const TSTZRANGEARRAY = 3911; /* * OID of the `daterange` type. / public const DATERANGE = 3912; /* * OID of the `daterangearray` type. / public const DATERANGEARRAY = 3913; /* * OID of the `int8range` type. / public const INT8RANGE = 3926; /* * OID of the `int8rangearray` type. / public const INT8RANGEARRAY = 3927; /* * OID of the `record` type. / public const RECORD = 2249; /* * OID of the `recordarray` type. / public const RECORDARRAY = 2287; /* * OID of the `cstring` type. / public const CSTRING = 2275; /* * OID of the `any` type. / public const ANY = 2276; /* * OID of the `anyarray` type. / public const ANYARRAY = 2277; /* * OID of the `void` type. / public const VOID = 2278; /* * OID of the `trigger` type. / public const TRIGGER = 2279; /* * OID of the `event_trigger` type. / public const EVENT_TRIGGER = 3838; /* * OID of the `language_handler` type. / public const LANGUAGE_HANDLER = 2280; /* * OID of the `internal` type. / public const INTERNAL = 2281; /* * OID of the `opaque` type. / public const OPAQUE = 2282; /* * OID of the `anyelement` type. / public const ANYELEMENT = 2283; /* * OID of the `anynonarray` type. / public const ANYNONARRAY = 2776; /* * OID of the `anyenum` type. / public const ANYENUM = 3500; /* * OID of the `fdw_handler` type. / public const FDW_HANDLER = 3115; /* * OID of the `anyrange` type. / public const ANYRANGE = 3831; /* * The connection which was used to obtain type information. * * @public * @readonly * @var \pq\Connection / public $connection; /* * Create a new instance populated with information obtained from the `pg_type` relation. * * @param \pq\Connection $conn The connection to use. * @param array $namespaces Which namespaces to query (defaults to `public` and `pg_catalog`). * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function __construct(pq\Connection $conn, array $namespaces = null) {} /* * Refresh type information from `pg_type`. * * @param array $namespaces Which namespaces to query (defaults to `public` and `pg_catalog`). * @throws \pq\Exception\InvalidArgumentException * @throws \pq\Exception\BadMethodCallException * @throws \pq\Exception\RuntimeException / public function refresh(array $namespaces = null) {} } namespace pq\Exception; /* * A method call was not expected. / class BadMethodCallException extends \BadMethodCallException implements \pq\Exception {} /* * Implementation or SQL syntax error. / class DomainException extends \DomainException implements \pq\Exception { /* * The SQLSTATE code, see the [official documentation](http://www.postgresql.org/docs/current/static/errcodes-appendix.html) for further information. * * @public * @readonly * @var string / public $sqlstate; } /* * An invalid argument was passed to a method. / class InvalidArgumentException extends \InvalidArgumentException implements \pq\Exception {} /* * A runtime exception occurred. */ class RuntimeException extends \RuntimeException implements \pq\Exception {}