function query_params($query, $params)
{
//needed to execute only one query
$filter_query = split(";", $query);
$test = pg_send_query_params($this->conn->get_conn(), $filter_query[0], $params);
$res =& pg_get_result($this->conn->get_conn());
if ($test == false) {
throw new kdb_query_err();
}
$this->check_status(&$res);
return new kdb_qresult(&$res);
}
public function rawQuery($sql, array $params = [])
{
if (empty($params)) {
pg_send_query($this->dbconn, $sql);
} else {
pg_send_query_params($this->dbconn, $sql, $params);
}
$result = pg_get_result($this->dbconn);
$err = pg_result_error($result);
if ($err) {
throw new \Pg\Exception($err, 0, null, pg_result_error_field($result, PGSQL_DIAG_SQLSTATE));
}
return new \Pg\Statement($result, $this->typeConverter);
}
/**
* sendQueryWithParameters
*
* Execute a asynchronous query with parameters and send the results.
*
* @access public
* @param string $query
* @param array $parameters
* @throws SqlException
* @return ResultHandler query result wrapper
*/
public function sendQueryWithParameters($query, array $parameters = [])
{
$res = pg_send_query_params($this->getHandler(), $query, $parameters);
try {
return $this->testQuery($res, $query)->getQueryResult($query);
} catch (SqlException $e) {
throw $e->setQueryParameters($parameters);
}
}
if (!($rows = pg_num_rows($result))) {
echo "pg_num_rows() error\n";
}
for ($i = 0; $i < $rows; $i++) {
pg_fetch_array($result, $i, PGSQL_NUM);
}
for ($i = 0; $i < $rows; $i++) {
pg_fetch_object($result);
}
for ($i = 0; $i < $rows; $i++) {
pg_fetch_row($result, $i);
}
for ($i = 0; $i < $rows; $i++) {
pg_fetch_result($result, $i, 0);
}
pg_num_rows(pg_query_params($db, "SELECT * FROM " . $table_name . " WHERE num > \$1;", array(100)));
pg_num_fields(pg_query_params($db, "SELECT * FROM " . $table_name . " WHERE num > \$1;", array(100)));
pg_field_name($result, 0);
pg_field_num($result, $field_name);
pg_field_size($result, 0);
pg_field_type($result, 0);
pg_field_prtlen($result, 0);
pg_field_is_null($result, 0);
if (!pg_send_query_params($db, "INSERT INTO " . $table_name . " VALUES (\$1, \$2);", array(9999, "A'BC"))) {
echo "pg_send_query_params() error\n";
}
pg_last_oid($result);
pg_free_result($result);
}
pg_close($db);
echo "OK";
/**
* Executes the query that was previously passed to the constructor.
*
* @param mixed $arg Query arguments to escape and insert at ? placeholders in $query
* @param mixed ... Additional arguments
**/
public function execute()
{
// We can't very well perform a query wtihout an active connection.
if ($this->dbh === false || pg_connection_status($this->dbh) !== PGSQL_CONNECTION_OK) {
$this->db->error('Lost connection to database.');
return;
}
// Finish any previous statements
$this->finish();
// We need to pre-process the arguments for literals and bytefields. We
// can't safely pass them into the naitve placeholder system, so we'll
// have to stick them into the query at the right places before then.
// Additionally, PG uses the string values 't' and 'f' for boolean true
// and false, and will choke over PHP true/false when passed in this way.
$args = Database::smart_args(func_get_args());
foreach ($args as $i => $arg) {
if (is_bool($arg)) {
$args[$i] = $arg === true ? 't' : 'f';
}
}
list($query, $nargs, $nargn) = $this->reprocess_query($args);
if (!$query) {
return;
}
// Prepare the placeholders. PG uses $1, $2 .. $n as their placeholders.
// Continuing the example from Database_Query::reprocess_query, we should
// have the following $query array:
// 'SELECT * FROM table WHERE a = ',
// ' AND b < NOW() AND c > '
// which will get turned into the following string:
// SELECT * FROM table WHERE a = $1 AND b < NOW() AND c > $2
$this->last_query = '';
$placeholder_count = 1;
foreach ($query as $i => $chunk) {
$this->last_query .= $chunk;
if ($placeholder_count <= $nargn) {
$this->last_query .= '$' . $placeholder_count;
$placeholder_count++;
}
}
// Wrap the actual query execution in a bit of benchmarking.
$before = microtime(true);
// We're only using placeholders here, not prepared statements. Why not?
// The possibility of missing / pre-replaced placeholders means that the
// actual query we get to execute changes each time.
$this->sh = false;
$this->errno = null;
$state = pg_send_query_params($this->dbh, $this->last_query, $nargs);
if ($state) {
// So, here's some fun. Like PDO, PG has error reporting bits at both
// the top level and at the statement level. However, the normal
// query method returns false instead of a statement handle, and we
// need the statement handle to pull errors back. This means that
// we need to use the async query sending method and check every single
// time for an error message. We can then nuke the statement handle
// so things that try to look for it to detect errors can work.
$this->sh = pg_get_result($this->dbh);
$sqlstate = pg_result_error_field($this->sh, PGSQL_DIAG_SQLSTATE);
if ($sqlstate && $sqlstate != '00000') {
$this->errno = $sqlstate;
$this->errstr = pg_result_error_field($this->sh, PGSQL_DIAG_MESSAGE_PRIMARY) . ' [detail=' . pg_result_error_field($this->sh, PGSQL_DIAG_MESSAGE_DETAIL) . '] (hint=' . pg_result_error_field($this->sh, PGSQL_DIAG_MESSAGE_HINT) . ') at character ' . pg_result_error_field($this->sh, PGSQL_DIAG_STATEMENT_POSITION);
$this->sh = false;
}
} else {
$this->db->error('Could not send query to server.');
return;
}
$after = microtime(true);
$this->db->mysql_time += $after - $before;
// The other adapters also fetch the last insert id here, which we can't
// effectively do, as it's not exposed by PG. As an alternative, you can
// use a RETURNING clause in your query to fetch generated values:
// INSERT INTO table(foo, bar) VALUES(?, ?) RETURNING id;
if (is_bool($this->sh) || is_null($this->sh)) {
$this->affected_rows = 0;
$this->num_rows = 0;
} elseif (is_resource($this->sh)) {
$this->affected_rows = pg_affected_rows($this->sh);
$this->num_rows = pg_num_rows($this->sh);
} else {
assert('false; // statement handler was not a bool or resource, it was a: ' . gettype($this->sh));
}
// Upstream code may care about warnings. PG can return multiple notices
// for any given query. It's unclear whether or not this will work, as
// I haven't been able to actually find any query that does emit multiple
// notices. If your code suddenly launches into an infinite loop, now you
// know why. Fun times indeed.
if ($this->db->enable_warning_logging) {
$this->warnings = array();
while (($last_notice = pg_last_notice($this->dbh)) !== false) {
$this->warnings[] = $last_notice;
}
$GLOBALS['_DEBUG']['Database Warnings'][] = array('Query' => $this->last_query, 'Warnings' => $this->warnings);
}
// Finally, did it even work?
if ($this->sh === false) {
$this->db->error('SQL Error:');
return false;
}
return true;
}
/**
* Dispatch an prepared query asynchronously
*
* @param string $query
* @param array $params
* @return \Amp\Promise
*/
public function queryParams(string $query, array $params) : \Amp\Promise
{
if ($this->queryCacheSize > $this->maxOutstandingQueries) {
return new \Amp\Failure(new \RuntimeException("Too busy"));
}
$deferred = new \Amp\Deferred();
$this->queryCache[] = [self::$OP_QUERY_PARAMS, [$query, $params], $deferred];
if (!$this->queryCacheSize++) {
$sendResult = \pg_send_query_params($this->db, $query, $params);
$this->processSendResult($sendResult);
}
return $deferred->promise();
}
