#class pq\Connection

The connection to the PostgreSQL server.

See the General Usage page for an introduction on how to use this class.

Constants:#

Connection Flags:#

• PERSISTENT#
  (Re-)open a persistent connection.
• ASYNC#
  If the connection is not already open, perform the connection attempt asynchronously.

Connection Status:#

• OK#
  Everything well; if a connection has been newly and synchronously created, the connection will always have this status right after creation.
• BAD#
  Broken connection; consider pq\Connection::reset() or recreation.
• STARTED#
  Waiting for connection to be made.
• MADE#
  Connection okay; waiting to send.
• AWAITING_RESPONSE#
  Waiting for a response from the server.
• AUTH_OK#
  Received authentication; waiting for backend start-up to finish.
• SSL_STARTUP#
  Negotiating SSL encryption.
• SETENV#
  Negotiating environment-driven parameter settings.

Transaction Status:#

• TRANS_IDLE#
  No active transaction.
• TRANS_ACTIVE#
  A transaction command is in progress.
• TRANS_INTRANS#
  Idling in a valid transaction block.
• TRANS_INERROR#
  Idling in a failed transaction block.
• TRANS_UNKNOWN#
  Bad connection.

Polling Status:#

• POLLING_FAILED#
  The connection procedure has failed.
• POLLING_READING#
  Select for read-readiness.
• POLLING_WRITING#
  Select for write-readiness.
• POLLING_OK#
  The connection has been successfully made.

Event Listener Types:#

• EVENT_NOTICE#
  Register the event handler for notices.
• EVENT_RESULT#
  Register the event handler for any created results.
• EVENT_RESET#
  Register the event handler for connection resets.

Properties:#

• public (readonly) int $status#
  A connection status constant value.
• public (readonly) int $transactionStatus#
  A transaction status constant value.
• public (readonly) resource $socket#
  The server socket resource.
• public (readonly) bool $busy#
  Whether the connection is busy with asynchronous operations.
• public (readonly) string $errorMessage#
  Any error message on failure.
• public (readonly) array $eventHandlers#
  List of registered event handlers.
• public string $encoding# = NULL
  Connection character set.
• public bool $unbuffered# = FALSE
  Whether to fetch asynchronous results in unbuffered mode, i.e. each row generates a distinct pq\Result.
• public bool $nonblocking# = FALSE
  Whether to set the underlying socket nonblocking, useful for asynchronous handling of writes. See also pq\Connection::flush().

Connection Information:#

• public (readonly) string $db#
  The database name of the connection.
• public (readonly) string $user#
  The user name of the connection.
• public (readonly) string $pass#
  The password of the connection.
• public (readonly) string $host#
  The server host name of the connection.
• public (readonly) string $port#
  The port of the connection.
• public (readonly) string $options#
  The command-line options passed in the connection request.

Inheritable Defaults:#

• public int $defaultFetchType# = pq\Result::FETCH_ARRAY
  Default fetch type for future pq\Result instances.
• public int $defaultAutoConvert# = pq\Result::CONV_ALL
  Default conversion bitmask for future pq\Result instances.
• public int $defaultTransactionIsolation# = pq\Transaction::READ_COMMITTED
  Default transaction isolation level for future pq\Transaction instances.
• public bool $defaultTransactionReadonly# = FALSE
  Default transaction readonlyness for future pq\Transaction instances.
• public bool $defaultTransactionDeferrable# = FALSE
  Default transaction deferrability for future pq\Transaction instances.

Functions:#

• Connection::__construct#

  Create a new PostgreSQL connection.

  void pq\Connection::__construct([string $dsn = ""[, int $flags = 0]])

• Connection::declare#

  Declare a cursor for a query.

  pq\Cursor pq\Connection::declare(string $name, int $flags, string $query)

• Connection::declareAsync#

  Asynchronously declare a cursor for a query.

  pq\Cursor pq\Connection::declareAsync(string $name, int $flags, string $query)

• Connection::escapeBytea#

  Escape binary data for use within a query with the type bytea.

  string pq\Connection::escapeBytea(string $binary)

• Connection::exec#

  Execute one or multiple SQL queries on the connection.

  pq\Result pq\Connection::exec(string $query)

• Connection::execAsync#

  Asynchronously execute an SQL query on the connection.

  void pq\Connection::exec(string $query[, callable $callback])

• Connection::execParams#

  Execute an SQL query with properly escaped parameters substituted.

  pq\Result pq\Connection::execParams(string $query, array $params[, array $types = NULL])

• Connection::execParamsAsync#

  Asynchronously execute an SQL query with properly escaped parameters substituted.

  pq\Result pq\Connection::execParamsAsync(string $query, array $params[, array $types = NULL, [callable $cb = NULL]])

• Connection::flush#

  Flush pending writes on the connection.

  bool pq\Connection::flush()

• Connection::getResult#

  Fetch the result of an asynchronous query.

  pq\Result pq\Connection::getResult()

• Connection::listen#

  Listen on $channel for notifications.

  void pq\Connection::listen(string $channel, callable $listener)

• Connection::listenAsync#

  Asynchronously start listening on $channel for notifcations.

  void pq\Connection::listenAsync(string $channel, callable $listener)

• Connection::notify#

  Notify all listeners on $channel with $message.

  void pq\Connection::notify(string $channel, string $message)

• Connection::notifyAsync#

  Asynchronously start notifying all listeners on $channel with $message.

  void pq\Connection::notifyAsync(string $channel, string $message)

• Connection::off#

  Stops listening for an event type.

  bool pq\Connection::off(string $event)

• Connection::on#

  Listen for an event.

  int pq\Connection::on(string $event, callable $callback)

• Connection::poll#

  Poll an asynchronously operating connection.

  int pq\Connection::poll()

• Connection::prepare#

  Prepare a named statement for later execution with pq\Statement::execute().

  pq\Statement pq\Connection::prepare(string $name, string $query[, array $types = NULL])

• Connection::prepareAsync#

  Asynchronously prepare a named statement for later execution with pq\Statement::exec().

  pq\Statement pq\Connection::prepareAsync(string $name, string $query[, array $types = NULL])

• Connection::quote#

  Quote a string for safe use in a query.

  string pq\Connection::quote(string $payload)

• Connection::quoteName#

  Quote an identifier for safe usage as name.

  string pq\Connection::quoteName(string $name)

• Connection::reset#

  Attempt to reset a possibly broken connection to a working state.

  void pq\Connection::reset()

• Connection::resetAsync#

  Asynchronously reset a possibly broken connection to a working state.

  void pq\Connection::resetAsync()

• Connection::setConverter#

  Set a data type converter.

  void pq\Connection::setConverter(pq\Converter $converter)

• Connection::startTransaction#

  Begin a transaction.

  pq\Transaction pq\Connection::startTransaction([int $isolation = pq\Transaction::READ_COMMITTED[, bool $readonly = FALSE[, bool $deferrable = FALSE]]])

• Connection::startTransactionAsync#

  Asynchronously begin a transaction.

  pq\Transaction pq\Connection::startTransactionAsync([int $isolation = pq\Transaction::READ_COMMITTED[, bool $readonly = FALSE[, bool $deferrable = FALSE]]])

• Connection::trace#

  Trace protocol communication with the server.

  bool pq\Connection::trace([resource $stream])

• Connection::unescapeBytea#

  Unescape bytea data retrieved from the server.

  string pq\Connection::unescapeBytea(string $bytea)

• Connection::unlisten#

  Stop listening for notifications on channel $channel.

  void pq\Connection::unlisten(string $channel)

• Connection::unlistenAsync#

  Asynchronously stop listening for notifications on channel $channel.

  void pq\Connection::unlistenAsync(string $channel)

• Connection::unsetConverter#

  Stop applying a data type converter.

  void pq\Connection::unsetConverter(pq\Converter $converter)