Back to index

php5  5.3.10
Functions | Variables
pgsql_driver.c File Reference
#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
#include "pdo/php_pdo.h"
#include "pdo/php_pdo_driver.h"
#include "ext/standard/file.h"
#include "pg_config.h"
#include "php_pdo_pgsql.h"
#include "php_pdo_pgsql_int.h"
#include "zend_exceptions.h"

Go to the source code of this file.

Functions

static char * _pdo_pgsql_trim_message (const char *message, int persistent)
int _pdo_pgsql_error (pdo_dbh_t *dbh, pdo_stmt_t *stmt, int errcode, const char *sqlstate, const char *file, int line TSRMLS_DC)
static void _pdo_pgsql_notice (pdo_dbh_t *dbh, const char *message)
static int pdo_pgsql_fetch_error_func (pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *info TSRMLS_DC)
static size_t pgsql_lob_write (php_stream *stream, const char *buf, size_t count TSRMLS_DC)
static size_t pgsql_lob_read (php_stream *stream, char *buf, size_t count TSRMLS_DC)
static int pgsql_lob_close (php_stream *stream, int close_handle TSRMLS_DC)
static int pgsql_lob_flush (php_stream *stream TSRMLS_DC)
static int pgsql_lob_seek (php_stream *stream, off_t offset, int whence, off_t *newoffset TSRMLS_DC)
php_stream * pdo_pgsql_create_lob_stream (pdo_dbh_t *dbh, int lfd, Oid oid TSRMLS_DC)
static int pgsql_handle_closer (pdo_dbh_t *dbh TSRMLS_DC)
static int pgsql_handle_preparer (pdo_dbh_t *dbh, const char *sql, long sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)
static long pgsql_handle_doer (pdo_dbh_t *dbh, const char *sql, long sql_len TSRMLS_DC)
static int pgsql_handle_quoter (pdo_dbh_t *dbh, const char *unquoted, int unquotedlen, char **quoted, int *quotedlen, enum pdo_param_type paramtype TSRMLS_DC)
static char * pdo_pgsql_last_insert_id (pdo_dbh_t *dbh, const char *name, unsigned int *len TSRMLS_DC)
static int pdo_pgsql_get_attribute (pdo_dbh_t *dbh, long attr, zval *return_value TSRMLS_DC)
static int pdo_pgsql_check_liveness (pdo_dbh_t *dbh TSRMLS_DC)
static int pdo_pgsql_transaction_cmd (const char *cmd, pdo_dbh_t *dbh TSRMLS_DC)
static int pgsql_handle_begin (pdo_dbh_t *dbh TSRMLS_DC)
static int pgsql_handle_commit (pdo_dbh_t *dbh TSRMLS_DC)
static int pgsql_handle_rollback (pdo_dbh_t *dbh TSRMLS_DC)
static PHP_METHOD (PDO, pgsqlCopyFromArray)
static PHP_METHOD (PDO, pgsqlCopyFromFile)
static PHP_METHOD (PDO, pgsqlCopyToFile)
static PHP_METHOD (PDO, pgsqlCopyToArray)
static PHP_METHOD (PDO, pgsqlLOBCreate)
static PHP_METHOD (PDO, pgsqlLOBOpen)
static PHP_METHOD (PDO, pgsqlLOBUnlink)
static const zend_function_entrypdo_pgsql_get_driver_methods (pdo_dbh_t *dbh, int kind TSRMLS_DC)
static int pdo_pgsql_set_attr (pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC)
static int pdo_pgsql_handle_factory (pdo_dbh_t *dbh, zval *driver_options TSRMLS_DC)

Variables

php_stream_ops pdo_pgsql_lob_stream_ops
static const zend_function_entry dbh_methods []
static struct pdo_dbh_methods
pdo_driver_t pdo_pgsql_driver

Function Documentation

int _pdo_pgsql_error ( pdo_dbh_t *  dbh,
pdo_stmt_t *  stmt,
int  errcode,
const char *  sqlstate,
const char *  file,
int line  TSRMLS_DC 
)

Definition at line 63 of file pgsql_driver.c.

{
       pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;
       pdo_error_type *pdo_err = stmt ? &stmt->error_code : &dbh->error_code;
       pdo_pgsql_error_info *einfo = &H->einfo;
       char *errmsg = PQerrorMessage(H->server);

       einfo->errcode = errcode;
       einfo->file = file;
       einfo->line = line;

       if (einfo->errmsg) {
              pefree(einfo->errmsg, dbh->is_persistent);
              einfo->errmsg = NULL;
       }

       if (sqlstate == NULL) {
              strcpy(*pdo_err, "HY000");
       }
       else {
              strcpy(*pdo_err, sqlstate);
       }

       if (errmsg) {
              einfo->errmsg = _pdo_pgsql_trim_message(errmsg, dbh->is_persistent);
       }

       if (!dbh->methods) {
              zend_throw_exception_ex(php_pdo_get_exception(), einfo->errcode TSRMLS_CC, "SQLSTATE[%s] [%d] %s",
                            *pdo_err, einfo->errcode, einfo->errmsg);
       }
       
       return errcode;
}

Here is the call graph for this function:

static void _pdo_pgsql_notice ( pdo_dbh_t *  dbh,
const char *  message 
) [static]

Definition at line 99 of file pgsql_driver.c.

{
/*     pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data; */
}

Here is the caller graph for this function:

static char* _pdo_pgsql_trim_message ( const char *  message,
int  persistent 
) [static]

Definition at line 44 of file pgsql_driver.c.

{
       register int i = strlen(message)-1;
       char *tmp;

       if (i>1 && (message[i-1] == '\r' || message[i-1] == '\n') && message[i] == '.') {
              --i;
       }
       while (i>0 && (message[i] == '\r' || message[i] == '\n')) {
              --i;
       }
       ++i;
       tmp = pemalloc(i + 1, persistent);
       memcpy(tmp, message, i);
       tmp[i] = '\0';
       
       return tmp;
}

Here is the caller graph for this function:

static int pdo_pgsql_check_liveness ( pdo_dbh_t *dbh  TSRMLS_DC) [static]

Definition at line 458 of file pgsql_driver.c.

{
       pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;
       if (PQstatus(H->server) == CONNECTION_BAD) {
              PQreset(H->server);
       }
       return (PQstatus(H->server) == CONNECTION_OK) ? SUCCESS : FAILURE;
}
php_stream* pdo_pgsql_create_lob_stream ( pdo_dbh_t *  dbh,
int  lfd,
Oid oid  TSRMLS_DC 
)

Definition at line 171 of file pgsql_driver.c.

{
       php_stream *stm;
       struct pdo_pgsql_lob_self *self = ecalloc(1, sizeof(*self));
       pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;

       self->dbh = dbh;
       self->lfd = lfd;
       self->oid = oid;
       self->conn = H->server;

       stm = php_stream_alloc(&pdo_pgsql_lob_stream_ops, self, 0, "r+b");

       if (stm) {
              php_pdo_dbh_addref(dbh TSRMLS_CC);
              return stm;
       }

       efree(self);
       return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int pdo_pgsql_fetch_error_func ( pdo_dbh_t *  dbh,
pdo_stmt_t *  stmt,
zval *info  TSRMLS_DC 
) [static]

Definition at line 105 of file pgsql_driver.c.

{
       pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;
       pdo_pgsql_error_info *einfo = &H->einfo;

       if (einfo->errcode) {
              add_next_index_long(info, einfo->errcode);
              add_next_index_string(info, einfo->errmsg, 1);
       }

       return 1;
}

Here is the call graph for this function:

static int pdo_pgsql_get_attribute ( pdo_dbh_t *  dbh,
long  attr,
zval *return_value  TSRMLS_DC 
) [static]

Definition at line 377 of file pgsql_driver.c.

{
       pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;

       switch (attr) {
              case PDO_ATTR_CLIENT_VERSION:
                     ZVAL_STRING(return_value, PG_VERSION, 1);
                     break;

              case PDO_ATTR_SERVER_VERSION:
                     if (PQprotocolVersion(H->server) >= 3) { /* PostgreSQL 7.4 or later */
                            ZVAL_STRING(return_value, (char*)PQparameterStatus(H->server, "server_version"), 1);
                     } else /* emulate above via a query */
                     {
                            PGresult *res = PQexec(H->server, "SELECT VERSION()");
                            if (res && PQresultStatus(res) == PGRES_TUPLES_OK) {
                                   ZVAL_STRING(return_value, (char *)PQgetvalue(res, 0, 0), 1);
                            }

                            if (res) {
                                   PQclear(res);
                            }
                     }
                     break;

              case PDO_ATTR_CONNECTION_STATUS:
                     switch (PQstatus(H->server)) {
                            case CONNECTION_STARTED:
                                   ZVAL_STRINGL(return_value, "Waiting for connection to be made.", sizeof("Waiting for connection to be made.")-1, 1);
                                   break;

                            case CONNECTION_MADE:
                            case CONNECTION_OK:
                                   ZVAL_STRINGL(return_value, "Connection OK; waiting to send.", sizeof("Connection OK; waiting to send.")-1, 1);
                                   break;

                            case CONNECTION_AWAITING_RESPONSE:
                                   ZVAL_STRINGL(return_value, "Waiting for a response from the server.", sizeof("Waiting for a response from the server.")-1, 1);
                                   break;

                            case CONNECTION_AUTH_OK:
                                   ZVAL_STRINGL(return_value, "Received authentication; waiting for backend start-up to finish.", sizeof("Received authentication; waiting for backend start-up to finish.")-1, 1);
                                   break;
#ifdef CONNECTION_SSL_STARTUP
                            case CONNECTION_SSL_STARTUP:
                                   ZVAL_STRINGL(return_value, "Negotiating SSL encryption.", sizeof("Negotiating SSL encryption.")-1, 1);
                                   break;
#endif
                            case CONNECTION_SETENV:
                                   ZVAL_STRINGL(return_value, "Negotiating environment-driven parameter settings.", sizeof("Negotiating environment-driven parameter settings.")-1, 1);
                                   break;

                            case CONNECTION_BAD:
                            default:
                                   ZVAL_STRINGL(return_value, "Bad connection.", sizeof("Bad connection.")-1, 1);
                                   break;
                     }
                     break;

              case PDO_ATTR_SERVER_INFO: {
                     int spid = PQbackendPID(H->server);
                     char *tmp;
                     spprintf(&tmp, 0, 
                            "PID: %d; Client Encoding: %s; Is Superuser: %s; Session Authorization: %s; Date Style: %s", 
                            spid,
                            (char*)PQparameterStatus(H->server, "client_encoding"),
                            (char*)PQparameterStatus(H->server, "is_superuser"),
                            (char*)PQparameterStatus(H->server, "session_authorization"),
                            (char*)PQparameterStatus(H->server, "DateStyle"));
                     ZVAL_STRING(return_value, tmp, 0);
              }
                     break;

              default:
                     return 0;     
       }

       return 1;
}

Here is the call graph for this function:

static const zend_function_entry* pdo_pgsql_get_driver_methods ( pdo_dbh_t *  dbh,
int kind  TSRMLS_DC 
) [static]

Definition at line 981 of file pgsql_driver.c.

{
       switch (kind) {
              case PDO_DBH_DRIVER_METHOD_KIND_DBH:
                     return dbh_methods;
              default:
                     return NULL;
       }
}
static int pdo_pgsql_handle_factory ( pdo_dbh_t *  dbh,
zval *driver_options  TSRMLS_DC 
) [static]

Definition at line 1027 of file pgsql_driver.c.

{
       pdo_pgsql_db_handle *H;
       int ret = 0;
       char *conn_str, *p, *e;
       long connect_timeout = 30;

       H = pecalloc(1, sizeof(pdo_pgsql_db_handle), dbh->is_persistent);
       dbh->driver_data = H;

       H->einfo.errcode = 0;
       H->einfo.errmsg = NULL;
       
       /* PostgreSQL wants params in the connect string to be separated by spaces,
        * if the PDO standard semicolons are used, we convert them to spaces
        */
       e = (char *) dbh->data_source + strlen(dbh->data_source);
       p = (char *) dbh->data_source;
       while ((p = memchr(p, ';', (e - p)))) {
              *p = ' ';
       }

       if (driver_options) {
              connect_timeout = pdo_attr_lval(driver_options, PDO_ATTR_TIMEOUT, 30 TSRMLS_CC);
       }

       /* support both full connection string & connection string + login and/or password */
       if (dbh->username && dbh->password) {
              spprintf(&conn_str, 0, "%s user=%s password=%s connect_timeout=%ld", dbh->data_source, dbh->username, dbh->password, connect_timeout);
       } else if (dbh->username) {
              spprintf(&conn_str, 0, "%s user=%s connect_timeout=%ld", dbh->data_source, dbh->username, connect_timeout);
       } else if (dbh->password) {
              spprintf(&conn_str, 0, "%s password=%s connect_timeout=%ld", dbh->data_source, dbh->password, connect_timeout);
       } else {
              spprintf(&conn_str, 0, "%s connect_timeout=%ld", (char *) dbh->data_source, connect_timeout);
       }

       H->server = PQconnectdb(conn_str);

       efree(conn_str);

       if (PQstatus(H->server) != CONNECTION_OK) {
              pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, PHP_PDO_PGSQL_CONNECTION_FAILURE_SQLSTATE);
              goto cleanup;
       }

       PQsetNoticeProcessor(H->server, (void(*)(void*,const char*))_pdo_pgsql_notice, (void *)&dbh);

       H->attached = 1;
       H->pgoid = -1;

       dbh->methods = &pgsql_methods;
       dbh->alloc_own_columns = 1;
       dbh->max_escaped_char_length = 2;

       ret = 1;
       
cleanup:
       dbh->methods = &pgsql_methods;
       if (!ret) {
              pgsql_handle_closer(dbh TSRMLS_CC);
       }

       return ret;
}

Here is the call graph for this function:

static char* pdo_pgsql_last_insert_id ( pdo_dbh_t *  dbh,
const char *  name,
unsigned int *len  TSRMLS_DC 
) [static]

Definition at line 345 of file pgsql_driver.c.

{
       pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;
       char *id = NULL;

       if (name == NULL) {
              if (H->pgoid == InvalidOid) {
                     return NULL;
              }
              *len = spprintf(&id, 0, "%ld", (long) H->pgoid);
       } else {
              PGresult *res;
              ExecStatusType status;
              const char *q[1];
              q[0] = name;
              res = PQexecParams(H->server, "SELECT CURRVAL($1)", 1, NULL, q, NULL, NULL, 0);
              status = PQresultStatus(res);

              if (res && (status == PGRES_TUPLES_OK)) {
                     id = estrdup((char *)PQgetvalue(res, 0, 0));
                     *len = PQgetlength(res, 0, 0);
              } else {
                     pdo_pgsql_error(dbh, status, pdo_pgsql_sqlstate(res));
              }

              if (res) {
                     PQclear(res);
              }
       }
       return id;
}

Here is the call graph for this function:

static int pdo_pgsql_set_attr ( pdo_dbh_t *  dbh,
long  attr,
zval *val  TSRMLS_DC 
) [static]

Definition at line 991 of file pgsql_driver.c.

{
       pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;

       switch (attr) {
#if HAVE_PQPREPARE
              case PDO_ATTR_EMULATE_PREPARES:
                     H->emulate_prepares = Z_LVAL_P(val);
                     return 1;
              case PDO_PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT:
                     H->disable_native_prepares = Z_LVAL_P(val);
                     return 1;
#endif

              default:
                     return 0;
       }
}

Here is the call graph for this function:

static int pdo_pgsql_transaction_cmd ( const char *  cmd,
pdo_dbh_t *dbh  TSRMLS_DC 
) [static]

Definition at line 468 of file pgsql_driver.c.

{
       pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;
       PGresult *res;
       int ret = 1;

       res = PQexec(H->server, cmd);

       if (PQresultStatus(res) != PGRES_COMMAND_OK) {
              pdo_pgsql_error(dbh, PQresultStatus(res), pdo_pgsql_sqlstate(res));
              ret = 0;
       }

       PQclear(res);
       return ret;
}

Here is the caller graph for this function:

static int pgsql_handle_begin ( pdo_dbh_t *dbh  TSRMLS_DC) [static]

Definition at line 485 of file pgsql_driver.c.

{
       return pdo_pgsql_transaction_cmd("BEGIN", dbh TSRMLS_CC);
}

Here is the call graph for this function:

static int pgsql_handle_closer ( pdo_dbh_t *dbh  TSRMLS_DC) [static]

Definition at line 194 of file pgsql_driver.c.

{
       pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;
       if (H) {
              if (H->server) {
                     PQfinish(H->server);
                     H->server = NULL;
              }
              if (H->einfo.errmsg) {
                     pefree(H->einfo.errmsg, dbh->is_persistent);
                     H->einfo.errmsg = NULL;
              }
              pefree(H, dbh->is_persistent);
              dbh->driver_data = NULL;
       }
       return 0;
}

Here is the caller graph for this function:

static int pgsql_handle_commit ( pdo_dbh_t *dbh  TSRMLS_DC) [static]

Definition at line 490 of file pgsql_driver.c.

{
       return pdo_pgsql_transaction_cmd("COMMIT", dbh TSRMLS_CC);
}

Here is the call graph for this function:

static long pgsql_handle_doer ( pdo_dbh_t *  dbh,
const char *  sql,
long sql_len  TSRMLS_DC 
) [static]

Definition at line 283 of file pgsql_driver.c.

{
       pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;
       PGresult *res;
       long ret = 1;
       ExecStatusType qs;
       
       if (!(res = PQexec(H->server, sql))) {
              /* fatal error */
              pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, NULL);
              return -1;
       }
       qs = PQresultStatus(res);
       if (qs != PGRES_COMMAND_OK && qs != PGRES_TUPLES_OK) {
              pdo_pgsql_error(dbh, qs, pdo_pgsql_sqlstate(res));
              PQclear(res);
              return -1;
       }
       H->pgoid = PQoidValue(res);
       ret = atol(PQcmdTuples(res));
       PQclear(res);

       return ret;
}
static int pgsql_handle_preparer ( pdo_dbh_t *  dbh,
const char *  sql,
long  sql_len,
pdo_stmt_t *  stmt,
zval *driver_options  TSRMLS_DC 
) [static]

Definition at line 213 of file pgsql_driver.c.

{
       pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;
       pdo_pgsql_stmt *S = ecalloc(1, sizeof(pdo_pgsql_stmt));
       int scrollable;
#if HAVE_PQPREPARE
       int ret;
       char *nsql = NULL;
       int nsql_len = 0;
       int emulate = 0;
#endif

       S->H = H;
       stmt->driver_data = S;
       stmt->methods = &pgsql_stmt_methods;

       scrollable = pdo_attr_lval(driver_options, PDO_ATTR_CURSOR,
              PDO_CURSOR_FWDONLY TSRMLS_CC) == PDO_CURSOR_SCROLL;

       if (scrollable) {
              if (S->cursor_name) {
                     efree(S->cursor_name);
              }
              spprintf(&S->cursor_name, 0, "pdo_crsr_%08x", ++H->stmt_counter);
#if HAVE_PQPREPARE
              emulate = 1;
#endif
       }

#if HAVE_PQPREPARE
       else if (driver_options) {
              if (pdo_attr_lval(driver_options, PDO_PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT, H->disable_native_prepares TSRMLS_CC) == 1 ||
                     pdo_attr_lval(driver_options, PDO_ATTR_EMULATE_PREPARES, H->emulate_prepares TSRMLS_CC) == 1) {
                     emulate = 1;
              }
       } else {
              emulate = H->disable_native_prepares || H->emulate_prepares;
       }

       if (!emulate && PQprotocolVersion(H->server) > 2) {
              stmt->supports_placeholders = PDO_PLACEHOLDER_NAMED;
              stmt->named_rewrite_template = "$%d";
              ret = pdo_parse_params(stmt, (char*)sql, sql_len, &nsql, &nsql_len TSRMLS_CC);

              if (ret == 1) {
                     /* query was re-written */
                     sql = nsql;
              } else if (ret == -1) {
                     /* couldn't grok it */
                     strcpy(dbh->error_code, stmt->error_code);
                     return 0;
              }

              spprintf(&S->stmt_name, 0, "pdo_stmt_%08x", ++H->stmt_counter);
              /* that's all for now; we'll defer the actual prepare until the first execute call */
       
              if (nsql) {
                     S->query = nsql;
              } else {
                     S->query = estrdup(sql);
              }

              return 1;
       }
#endif

       stmt->supports_placeholders = PDO_PLACEHOLDER_NONE;
       return 1;
}

Here is the call graph for this function:

static int pgsql_handle_quoter ( pdo_dbh_t *  dbh,
const char *  unquoted,
int  unquotedlen,
char **  quoted,
int quotedlen,
enum pdo_param_type paramtype  TSRMLS_DC 
) [static]

Definition at line 308 of file pgsql_driver.c.

{
       unsigned char *escaped;
       pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;
       size_t tmp_len;
       
       switch (paramtype) {
              case PDO_PARAM_LOB:
                     /* escapedlen returned by PQescapeBytea() accounts for trailing 0 */
#ifdef HAVE_PQESCAPE_BYTEA_CONN
                     escaped = PQescapeByteaConn(H->server, unquoted, unquotedlen, &tmp_len);
#else
                     escaped = PQescapeBytea(unquoted, unquotedlen, &tmp_len);
#endif
                     *quotedlen = (int)tmp_len + 1;
                     *quoted = emalloc(*quotedlen + 1);
                     memcpy((*quoted)+1, escaped, *quotedlen-2);
                     (*quoted)[0] = '\'';
                     (*quoted)[*quotedlen-1] = '\'';
                     (*quoted)[*quotedlen] = '\0';
                     PQfreemem(escaped);
                     break;
              default:
                     *quoted = safe_emalloc(2, unquotedlen, 3);
                     (*quoted)[0] = '\'';
#ifndef HAVE_PQESCAPE_CONN
                     *quotedlen = PQescapeString(*quoted + 1, unquoted, unquotedlen);
#else
                     *quotedlen = PQescapeStringConn(H->server, *quoted + 1, unquoted, unquotedlen, NULL);
#endif
                     (*quoted)[*quotedlen + 1] = '\'';
                     (*quoted)[*quotedlen + 2] = '\0';
                     *quotedlen += 2;
       }
       return 1;
}

Here is the call graph for this function:

static int pgsql_handle_rollback ( pdo_dbh_t *dbh  TSRMLS_DC) [static]

Definition at line 495 of file pgsql_driver.c.

{
       return pdo_pgsql_transaction_cmd("ROLLBACK", dbh TSRMLS_CC);
}

Here is the call graph for this function:

static int pgsql_lob_close ( php_stream *  stream,
int close_handle  TSRMLS_DC 
) [static]

Definition at line 132 of file pgsql_driver.c.

{
       struct pdo_pgsql_lob_self *self = (struct pdo_pgsql_lob_self*)stream->abstract;
       pdo_dbh_t *dbh = self->dbh;

       if (close_handle) {
              lo_close(self->conn, self->lfd);
       }
       efree(self);
       php_pdo_dbh_delref(dbh TSRMLS_CC);
       return 0;
}

Here is the call graph for this function:

static int pgsql_lob_flush ( php_stream *stream  TSRMLS_DC) [static]

Definition at line 145 of file pgsql_driver.c.

{
       return 0;
}
static size_t pgsql_lob_read ( php_stream *  stream,
char *  buf,
size_t count  TSRMLS_DC 
) [static]

Definition at line 126 of file pgsql_driver.c.

{
       struct pdo_pgsql_lob_self *self = (struct pdo_pgsql_lob_self*)stream->abstract;
       return lo_read(self->conn, self->lfd, buf, count);
}
static int pgsql_lob_seek ( php_stream *  stream,
off_t  offset,
int  whence,
off_t *newoffset  TSRMLS_DC 
) [static]

Definition at line 150 of file pgsql_driver.c.

{
       struct pdo_pgsql_lob_self *self = (struct pdo_pgsql_lob_self*)stream->abstract;
       int pos = lo_lseek(self->conn, self->lfd, offset, whence);
       *newoffset = pos;
       return pos >= 0 ? 0 : -1;
}
static size_t pgsql_lob_write ( php_stream *  stream,
const char *  buf,
size_t count  TSRMLS_DC 
) [static]

Definition at line 120 of file pgsql_driver.c.

{
       struct pdo_pgsql_lob_self *self = (struct pdo_pgsql_lob_self*)stream->abstract;
       return lo_write(self->conn, self->lfd, (char*)buf, count);
}
static PHP_METHOD ( PDO  ,
pgsqlCopyFromArray   
) [static]

Definition at line 502 of file pgsql_driver.c.

{
       pdo_dbh_t *dbh;
       pdo_pgsql_db_handle *H;

       zval *pg_rows;

       char *table_name, *pg_delim = NULL, *pg_null_as = NULL, *pg_fields = NULL;
       int table_name_len, pg_delim_len = 0, pg_null_as_len = 0, pg_fields_len;
       char *query;

       PGresult *pgsql_result;
       ExecStatusType status;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s/a|sss",
                                   &table_name, &table_name_len, &pg_rows,
                                   &pg_delim, &pg_delim_len, &pg_null_as, &pg_null_as_len, &pg_fields, &pg_fields_len) == FAILURE) {
              return;
       }

       if (!zend_hash_num_elements(Z_ARRVAL_P(pg_rows))) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot copy from an empty array");
              RETURN_FALSE;
       }

       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
       PDO_CONSTRUCT_CHECK;

       if (pg_fields) {
              spprintf(&query, 0, "COPY %s (%s) FROM STDIN DELIMITERS E'%c' WITH NULL AS E'%s'", table_name, pg_fields, (pg_delim_len ? *pg_delim : '\t'), (pg_null_as_len ? pg_null_as : "\\\\N"));
       } else {
              spprintf(&query, 0, "COPY %s FROM STDIN DELIMITERS E'%c' WITH NULL AS E'%s'", table_name, (pg_delim_len ? *pg_delim : '\t'), (pg_null_as_len ? pg_null_as : "\\\\N"));
       }

       /* Obtain db Handle */
       H = (pdo_pgsql_db_handle *)dbh->driver_data;

       while ((pgsql_result = PQgetResult(H->server))) {
              PQclear(pgsql_result);
       }
       pgsql_result = PQexec(H->server, query);

       efree(query);
       query = NULL;

       if (pgsql_result) {
              status = PQresultStatus(pgsql_result);
       } else {
              status = (ExecStatusType) PQstatus(H->server);
       }

       if (status == PGRES_COPY_IN && pgsql_result) {
              int command_failed = 0;
              int buffer_len = 0;
              zval **tmp;
              HashPosition pos;

              PQclear(pgsql_result);
              zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pg_rows), &pos);
              while (zend_hash_get_current_data_ex(Z_ARRVAL_P(pg_rows), (void **) &tmp, &pos) == SUCCESS) {
                     int query_len;
                     convert_to_string_ex(tmp);
              
                     if (buffer_len < Z_STRLEN_PP(tmp)) {
                            buffer_len = Z_STRLEN_PP(tmp);
                            query = erealloc(query, buffer_len + 2); /* room for \n\0 */
                     }
                     memcpy(query, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
                     query_len = Z_STRLEN_PP(tmp);
                     if (query[query_len - 1] != '\n') {
                            query[query_len++] = '\n';
                     }
                     query[query_len] = '\0';
                     if (PQputCopyData(H->server, query, query_len) != 1) {
                            efree(query);
                               pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "copy failed");
                              RETURN_FALSE;
                     }
                     zend_hash_move_forward_ex(Z_ARRVAL_P(pg_rows), &pos);
                }
              if (query) {
                     efree(query);
              }

              if (PQputCopyEnd(H->server, NULL) != 1) {
                     pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "putcopyend failed");
                     RETURN_FALSE;
              }

              while ((pgsql_result = PQgetResult(H->server))) {
                     if (PGRES_COMMAND_OK != PQresultStatus(pgsql_result)) {
                            pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "Copy command failed");
                            command_failed = 1;
                     }
                     PQclear(pgsql_result);
              }

              RETURN_BOOL(!command_failed);
       } else {
              PQclear(pgsql_result);
              pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "Copy command failed");
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

static PHP_METHOD ( PDO  ,
pgsqlCopyFromFile   
) [static]

Definition at line 610 of file pgsql_driver.c.

{
       pdo_dbh_t *dbh;
       pdo_pgsql_db_handle *H;

       char *table_name, *filename, *pg_delim = NULL, *pg_null_as = NULL, *pg_fields = NULL;
       int  table_name_len, filename_len, pg_delim_len = 0, pg_null_as_len = 0, pg_fields_len;
       char *query;
       PGresult *pgsql_result;
       ExecStatusType status;
       php_stream *stream;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|sss",
                            &table_name, &table_name_len, &filename, &filename_len,
                            &pg_delim, &pg_delim_len, &pg_null_as, &pg_null_as_len, &pg_fields, &pg_fields_len) == FAILURE) {
              return;
       }

       /* Obtain db Handler */
       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
       PDO_CONSTRUCT_CHECK;

       stream = php_stream_open_wrapper_ex(filename, "rb", ENFORCE_SAFE_MODE | REPORT_ERRORS, NULL, FG(default_context));
       if (!stream) {
              pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "Unable to open the file");
              RETURN_FALSE;
       }

       if (pg_fields) {
              spprintf(&query, 0, "COPY %s (%s) FROM STDIN DELIMITERS E'%c' WITH NULL AS E'%s'", table_name, pg_fields, (pg_delim_len ? *pg_delim : '\t'), (pg_null_as_len ? pg_null_as : "\\\\N"));
       } else {
              spprintf(&query, 0, "COPY %s FROM STDIN DELIMITERS E'%c' WITH NULL AS E'%s'", table_name, (pg_delim_len ? *pg_delim : '\t'), (pg_null_as_len ? pg_null_as : "\\\\N"));
       }

       H = (pdo_pgsql_db_handle *)dbh->driver_data;

       while ((pgsql_result = PQgetResult(H->server))) {
              PQclear(pgsql_result);
       }
       pgsql_result = PQexec(H->server, query);

       efree(query);

       if (pgsql_result) {
              status = PQresultStatus(pgsql_result);
       } else {
              status = (ExecStatusType) PQstatus(H->server);
       }

       if (status == PGRES_COPY_IN && pgsql_result) {
              char *buf;
              int command_failed = 0;
              size_t line_len = 0;

              PQclear(pgsql_result);
              while ((buf = php_stream_get_line(stream, NULL, 0, &line_len)) != NULL) {
                     if (PQputCopyData(H->server, buf, line_len) != 1) {
                               efree(buf);
                              pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "copy failed");
                            php_stream_close(stream);
                            RETURN_FALSE;
                     }
                     efree(buf);
              }
              php_stream_close(stream);

              if (PQputCopyEnd(H->server, NULL) != 1) {
                     pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "putcopyend failed");
                     RETURN_FALSE;
              }

              while ((pgsql_result = PQgetResult(H->server))) {
                     if (PGRES_COMMAND_OK != PQresultStatus(pgsql_result)) {
                            pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "Copy command failed");
                            command_failed = 1;
                     }
                     PQclear(pgsql_result);
              }

              RETURN_BOOL(!command_failed);
       } else {
              PQclear(pgsql_result);
              php_stream_close(stream);
              pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "Copy command failed");
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

static PHP_METHOD ( PDO  ,
pgsqlCopyToFile   
) [static]

Definition at line 702 of file pgsql_driver.c.

{
       pdo_dbh_t *dbh;
       pdo_pgsql_db_handle *H;

       char *table_name, *pg_delim = NULL, *pg_null_as = NULL, *pg_fields = NULL, *filename = NULL;
       int table_name_len, pg_delim_len = 0, pg_null_as_len = 0, pg_fields_len, filename_len;
       char *query;

       PGresult *pgsql_result;
       ExecStatusType status;

       php_stream *stream;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|sss",
                                   &table_name, &table_name_len, &filename, &filename_len,
                                   &pg_delim, &pg_delim_len, &pg_null_as, &pg_null_as_len, &pg_fields, &pg_fields_len) == FAILURE) {
              return;
       }

       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
       PDO_CONSTRUCT_CHECK;

       H = (pdo_pgsql_db_handle *)dbh->driver_data;

       stream = php_stream_open_wrapper_ex(filename, "wb", ENFORCE_SAFE_MODE | REPORT_ERRORS, NULL, FG(default_context));
       if (!stream) {
              pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "Unable to open the file for writing");
              RETURN_FALSE;
       }

       while ((pgsql_result = PQgetResult(H->server))) {
              PQclear(pgsql_result);
       }

       if (pg_fields) {
              spprintf(&query, 0, "COPY %s (%s) TO STDIN DELIMITERS E'%c' WITH NULL AS E'%s'", table_name, pg_fields, (pg_delim_len ? *pg_delim : '\t'), (pg_null_as_len ? pg_null_as : "\\\\N"));
       } else {
              spprintf(&query, 0, "COPY %s TO STDIN DELIMITERS E'%c' WITH NULL AS E'%s'", table_name, (pg_delim_len ? *pg_delim : '\t'), (pg_null_as_len ? pg_null_as : "\\\\N"));
       }
       pgsql_result = PQexec(H->server, query);
       efree(query);

       if (pgsql_result) {
              status = PQresultStatus(pgsql_result);
       } else {
              status = (ExecStatusType) PQstatus(H->server);
       }

       if (status == PGRES_COPY_OUT && pgsql_result) {
              PQclear(pgsql_result);
              while (1) {
                     char *csv = NULL;
                     int ret = PQgetCopyData(H->server, &csv, 0);

                     if (ret == -1) {
                            break; /* done */
                     } else if (ret > 0) {
                            if (php_stream_write(stream, csv, ret) != ret) {
                                   pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "Unable to write to file");
                                   PQfreemem(csv);
                                   php_stream_close(stream);
                                   RETURN_FALSE;
                            } else {
                                   PQfreemem(csv);
                            }
                     } else {
                            pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "Copy command failed: getline failed");
                            php_stream_close(stream);
                            RETURN_FALSE;
                     }
              }
              php_stream_close(stream);

              while ((pgsql_result = PQgetResult(H->server))) {
                     PQclear(pgsql_result);
              }
              RETURN_TRUE;
       } else {
              php_stream_close(stream);
              PQclear(pgsql_result);
              pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "Copy command failed");
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

static PHP_METHOD ( PDO  ,
pgsqlCopyToArray   
) [static]

Definition at line 791 of file pgsql_driver.c.

{
       pdo_dbh_t *dbh;
       pdo_pgsql_db_handle *H;

       char *table_name, *pg_delim = NULL, *pg_null_as = NULL, *pg_fields = NULL;
       int table_name_len, pg_delim_len = 0, pg_null_as_len = 0, pg_fields_len;
       char *query;

       PGresult *pgsql_result;
       ExecStatusType status;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|sss",
              &table_name, &table_name_len,
              &pg_delim, &pg_delim_len, &pg_null_as, &pg_null_as_len, &pg_fields, &pg_fields_len) == FAILURE) {
              return;
       }

       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
       PDO_CONSTRUCT_CHECK;

       H = (pdo_pgsql_db_handle *)dbh->driver_data;

       while ((pgsql_result = PQgetResult(H->server))) {
              PQclear(pgsql_result);
       }

       if (pg_fields) {
              spprintf(&query, 0, "COPY %s (%s) TO STDIN DELIMITERS E'%c' WITH NULL AS E'%s'", table_name, pg_fields, (pg_delim_len ? *pg_delim : '\t'), (pg_null_as_len ? pg_null_as : "\\\\N"));
       } else {
              spprintf(&query, 0, "COPY %s TO STDIN DELIMITERS E'%c' WITH NULL AS E'%s'", table_name, (pg_delim_len ? *pg_delim : '\t'), (pg_null_as_len ? pg_null_as : "\\\\N"));
       }
       pgsql_result = PQexec(H->server, query);
       efree(query);

       if (pgsql_result) {
              status = PQresultStatus(pgsql_result);
       } else {
              status = (ExecStatusType) PQstatus(H->server);
       }

       if (status == PGRES_COPY_OUT && pgsql_result) {
              PQclear(pgsql_result);
                array_init(return_value);

              while (1) {
                     char *csv = NULL;
                     int ret = PQgetCopyData(H->server, &csv, 0);
                     if (ret == -1) {
                            break; /* copy done */
                     } else if (ret > 0) { 
                            add_next_index_stringl(return_value, csv, ret, 1);
                            PQfreemem(csv);
                     } else {
                            pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "Copy command failed: getline failed");
                            RETURN_FALSE;
                     }
              }

              while ((pgsql_result = PQgetResult(H->server))) {
                     PQclear(pgsql_result);
              }
       } else {
              PQclear(pgsql_result);
              pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "Copy command failed");
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

static PHP_METHOD ( PDO  ,
pgsqlLOBCreate   
) [static]

Definition at line 864 of file pgsql_driver.c.

{
       pdo_dbh_t *dbh;
       pdo_pgsql_db_handle *H;
       Oid lfd;

       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
       PDO_CONSTRUCT_CHECK;

       H = (pdo_pgsql_db_handle *)dbh->driver_data;
       lfd = lo_creat(H->server, INV_READ|INV_WRITE);

       if (lfd != InvalidOid) {
              char *buf;
              spprintf(&buf, 0, "%lu", (long) lfd);
              RETURN_STRING(buf, 0);
       }
       
       pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "HY000");
       RETURN_FALSE;
}

Here is the call graph for this function:

static PHP_METHOD ( PDO  ,
pgsqlLOBOpen   
) [static]

Definition at line 889 of file pgsql_driver.c.

{
       pdo_dbh_t *dbh;
       pdo_pgsql_db_handle *H;
       Oid oid;
       int lfd;
       char *oidstr;
       int oidstrlen;
       char *modestr = "rb";
       int modestrlen;
       int mode = INV_READ;
       char *end_ptr;

       if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s",
                            &oidstr, &oidstrlen, &modestr, &modestrlen)) {
              RETURN_FALSE;
       }

       oid = (Oid)strtoul(oidstr, &end_ptr, 10);
       if (oid == 0 && (errno == ERANGE || errno == EINVAL)) {
              RETURN_FALSE;
       }

       if (strpbrk(modestr, "+w")) {
              mode = INV_READ|INV_WRITE;
       }
       
       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
       PDO_CONSTRUCT_CHECK;

       H = (pdo_pgsql_db_handle *)dbh->driver_data;

       lfd = lo_open(H->server, oid, mode);

       if (lfd >= 0) {
              php_stream *stream = pdo_pgsql_create_lob_stream(dbh, lfd, oid TSRMLS_CC);
              if (stream) {
                     php_stream_to_zval(stream, return_value);
                     return;
              }
       } else {
              pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "HY000");
       }
       RETURN_FALSE;
}

Here is the call graph for this function:

static PHP_METHOD ( PDO  ,
pgsqlLOBUnlink   
) [static]

Definition at line 938 of file pgsql_driver.c.

{
       pdo_dbh_t *dbh;
       pdo_pgsql_db_handle *H;
       Oid oid;
       char *oidstr, *end_ptr;
       int oidlen;

       if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
                            &oidstr, &oidlen)) {
              RETURN_FALSE;
       }

       oid = (Oid)strtoul(oidstr, &end_ptr, 10);
       if (oid == 0 && (errno == ERANGE || errno == EINVAL)) {
              RETURN_FALSE;
       }

       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
       PDO_CONSTRUCT_CHECK;

       H = (pdo_pgsql_db_handle *)dbh->driver_data;
       
       if (1 == lo_unlink(H->server, oid)) {
              RETURN_TRUE;
       }
       pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, "HY000");
       RETURN_FALSE;
}

Here is the call graph for this function:


Variable Documentation

const zend_function_entry dbh_methods[] [static]
Initial value:

Definition at line 970 of file pgsql_driver.c.

struct pdo_dbh_methods [static]
Initial value:

Definition at line 1094 of file pgsql_driver.c.

Initial value:

Definition at line 159 of file pgsql_driver.c.