function query($sql, $unbuffered = false)
 {
     if (strrpos($sql, 'LIMIT') !== false) {
         $sql = preg_replace('%LIMIT ([0-9]+),([ 0-9]+)%', 'LIMIT \\2 OFFSET \\1', $sql);
     }
     if (defined('PUN_SHOW_QUERIES')) {
         $q_start = get_microtime();
     }
     @pg_send_query($this->link_id, $sql);
     $this->query_result = @pg_get_result($this->link_id);
     if (pg_result_status($this->query_result) != PGSQL_FATAL_ERROR) {
         if (defined('PUN_SHOW_QUERIES')) {
             $this->saved_queries[] = array($sql, sprintf('%.5f', get_microtime() - $q_start));
         }
         ++$this->num_queries;
         $this->last_query_text[intval($this->query_result)] = $sql;
         return $this->query_result;
     } else {
         if (defined('PUN_SHOW_QUERIES')) {
             $this->saved_queries[] = array($sql, 0);
         }
         $this->error_no = false;
         $this->error_msg = @pg_result_error($this->query_result);
         if ($this->in_transaction) {
             @pg_query($this->link_id, 'ROLLBACK');
         }
         --$this->in_transaction;
         return false;
     }
 }

function safe_dml_query($query, $verbose = True)
{
    global $conn;
    if ($verbose) {
        echo "------------------------\n";
        echo "Executing PG query: {$query}\n";
    }
    $time_start = microtime(true);
    pg_send_query($conn, $query) or die("Failed to execute query {$query}");
    while (pg_connection_busy($conn)) {
        if (microtime(true) - $time_start > 30) {
            if (rand(0, 10) == 0) {
                echo "Busy for " . round((microtime(true) - $time_start) * 1000) . " ms -";
            }
            sleep(5);
        }
        usleep(2000);
    }
    $res = pg_get_result($conn);
    if (pg_result_error($res) != null) {
        die("Error during query: " . pg_result_error($res) . "\n");
    }
    $time_end = microtime(true);
    $rows = pg_affected_rows($res);
    if ($verbose) {
        echo "Done executing {$query}: {$rows} touched\n";
        $t = round(($time_end - $time_start) * 1000);
        echo "Query time: {$t} ms\n";
        echo "------------------------\n";
    }
}

 public function testUniqueCheck($username, $email)
 {
     //Get info from the array
     $final_username = $username;
     $final_email = $email;
     //Connect to the db
     $db = $this->connectProd();
     //Check for username and email address
     $query_user_check = "SELECT username FROM tb_users WHERE username = '" . $final_username . "'";
     $query_email_check = "SELECT email FROM tb_users WHERE email = '" . $final_email . "'";
     pg_send_query($db, $query_user_check) or die('Query failed: ' . pg_last_error());
     $username_check_result = pg_get_result($db);
     $username_check_result_rows = pg_num_rows($username_check_result);
     pg_close($db);
     if ($username_check_result_rows == 0) {
         //Set flag if no user found
         $user_check = 'pass';
     } else {
         $user_check = 'fail';
     }
     if ($email_check_result_rows == 0) {
         //Set flag if no email is found
         $email_check = 'pass';
     } else {
         $email_check = 'fail';
     }
     if ($email_check == 'pass' && $user_check == 'pass') {
         $check_result = 'pass';
         return $check_result;
     } else {
         $check_result = 'fail';
         return $check_result;
     }
 }

 /**
  * Writes the record down to the log of the implementing handler
  *
  * @param  $record[]
  * @return void
  */
 protected function write(array $record)
 {
     if (!$this->initialized) {
         $this->initialize();
     }
     $content = ['channel' => $record['channel'], 'level_name' => $record['level_name'], 'message' => $record['message'], 'context' => json_encode($record['context']), 'extra' => json_encode($record['extra']), 'datetime' => $record['datetime']->format('Y-m-d G:i:s')];
     pg_get_result($this->connection);
     pg_send_execute($this->connection, $this->statement, $content);
 }

 /**
  * 执行数据库查询
  *
  * @param string $query 数据库查询SQL字符串
  * @param mixed $handle 连接对象
  * @param integer $op 数据库读写状态
  * @param string $action 数据库动作
  * @throws Typecho_Db_Exception
  * @return resource
  */
 public function query($query, $handle, $op = Typecho_Db::READ, $action = NULL)
 {
     $isQueryObject = $query instanceof Typecho_Db_Query;
     $this->_lastTable = $isQueryObject ? $query->getAttribute('table') : NULL;
     if ($resource = @pg_query($handle, $isQueryObject ? $query->__toString() : $query)) {
         return $resource;
     }
     /** 数据库异常 */
     throw new Typecho_Db_Query_Exception(@pg_last_error($this->_dbLink), pg_result_error_field(pg_get_result($this->_dbLink), PGSQL_DIAG_SQLSTATE));
 }

 function executeQuery($sql_commands)
 {
     if (!pg_send_query($this->link, $sql_commands)) {
         throw new DatabaseException("PostgreSQL database query failed on following query:\n{$sql_commands}");
     }
     $this->res = pg_get_result($this->link);
     DEBUG("DB: Query was: <em>{$sql_commands}</em>");
     $this->executedQueries++;
     return true;
 }

 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);
 }

 function query($strSQL)
 {
     global $aQueries;
     // Save the query.
     $aQueries[] = $strSQL;
     // Execute the query.
     $querySuccess = pg_send_query($this->objConnection, $strSQL);
     $this->objResult = @pg_get_result($this->objConnection);
     // Return the result.
     if ($querySuccess === FALSE) {
         DatabaseError();
     } else {
         return TRUE;
     }
 }

 function query($sql)
 {
     @pg_send_query($this->link_id, $sql);
     $this->query_result = @pg_get_result($this->link_id);
     if (pg_result_status($this->query_result) != PGSQL_FATAL_ERROR) {
         ++$this->num_queries;
         //$this->last_query_text[$this->query_result] = $sql;
         return $this->query_result;
     } else {
         if ($this->in_transaction) {
             @pg_query($this->link_id, "ROLLBACK");
         }
         --$this->in_transaction;
         die(error(pg_result_error($this->query_result)));
         return false;
     }
 }

 public function query_execute($sql)
 {
     // Make sure the database is connected
     $this->connect();
     if ($result = pg_send_query($this->connection, $sql)) {
         $result = pg_get_result($this->connection);
     }
     if (!is_resource($result)) {
         throw new Database_Exception(':error [ :query ]', array(':error' => pg_last_error($this->connection), ':query' => $sql));
     }
     // Set the last query
     $this->last_query = $sql;
     if ($this->config['fix_booleans']) {
         return Database_Postgresql_Result_Boolean::factory($result, $sql, $this->connection, $this->config['object']);
     }
     return new Database_Postgresql_Result($result, $sql, $this->connection, $this->config['object']);
 }

 public function query($query)
 {
     if (!pg_send_query($this->connection, $query)) {
         throw $this->createException(pg_last_error($this->connection), 0, NULL);
     }
     $time = microtime(TRUE);
     $resource = pg_get_result($this->connection);
     $time = microtime(TRUE) - $time;
     if ($resource === FALSE) {
         throw $this->createException(pg_last_error($this->connection), 0, NULL);
     }
     $state = pg_result_error_field($resource, PGSQL_DIAG_SQLSTATE);
     if ($state !== NULL) {
         throw $this->createException(pg_result_error($resource), 0, $state, $query);
     }
     $this->affectedRows = pg_affected_rows($resource);
     return new Result(new PgsqlResultAdapter($resource), $this, $time);
 }

function SQLLoad($file)
{
    header("SQL: {$file}", false);
    $con = db::RawConnection();
    $sql = file_get_contents($file);
    pg_send_query($con, $sql);
    if (($error = pg_last_error($con)) !== '') {
        die("Failure at loading {{$file}} with {{$error}}");
    }
    while (pg_connection_busy($con)) {
        sleep(1);
    }
    while (pg_get_result($con) !== false) {
        if (($error = pg_last_error($con)) !== '') {
            die("Failure at loading {{$file}} with {{$error}}");
        }
    }
}

 /**
  * Connection constructor.
  *
  * @param resource $handle PostgreSQL connection handle.
  * @param resource $socket PostgreSQL connection stream socket.
  */
 public function __construct($handle, $socket)
 {
     $this->handle = $handle;
     $this->poll = Loop\poll($socket, static function ($resource, bool $expired, Io $poll) use($handle) {
         /** @var \Icicle\Awaitable\Delayed $delayed */
         $delayed = $poll->getData();
         if (!\pg_consume_input($handle)) {
             $delayed->reject(new FailureException(\pg_last_error($handle)));
             return;
         }
         if (!\pg_connection_busy($handle)) {
             $delayed->resolve(\pg_get_result($handle));
             return;
         }
         $poll->listen();
         // Reading not done, listen again.
     });
     $this->await = Loop\await($socket, static function ($resource, bool $expired, Io $await) use($handle) {
         $flush = \pg_flush($handle);
         if (0 === $flush) {
             $await->listen();
             // Not finished sending data, listen again.
             return;
         }
         if (false === $flush) {
             /** @var \Icicle\Awaitable\Delayed $delayed */
             $delayed = $await->getData();
             $delayed->reject(new FailureException(\pg_last_error($handle)));
         }
     });
     $this->onCancelled = static function () use($handle) {
         \pg_cancel_query($handle);
     };
     $this->executeCallback = function (string $name, array $params) : \Generator {
         return $this->createResult(yield from $this->send('pg_send_execute', $name, $params));
     };
 }

 function ejecutarValidandoUniqueANDPrimaryKey($sql)
 {
     if ($sql == "") {
         return 0;
     } else {
         /* Si puede enviar la consulta sin importar que encuentre llaves duplicadas */
         if (pg_send_query($this->connect, $sql)) {
             /* Ejecuta la consulta */
             $this->consulta_ID = pg_get_result($this->connect);
             /* Se tiene algun resultado sin importar que contenga errores de duplidados */
             if ($this->consulta_ID) {
                 /* Detecte un posible error */
                 $state = pg_result_error_field($this->consulta_ID, PGSQL_DIAG_SQLSTATE);
                 /* Si no se genero ningun error */
                 if ($state == 0) {
                     return $this->consulta_ID;
                 } else {
                     /* Si encontro algun error */
                     return false;
                 }
             }
         }
     }
 }

 /**
  * @throws DBQueryException
  * @param ISqlQUery $query
  * @param boolean $isAsync
  * @return resource
  */
 protected function performQuery(ISqlQuery $query, $isAsync)
 {
     Assert::isBoolean($isAsync);
     $parameters = $query->getPlaceholderValues($this->getDialect());
     $queryAsString = $query->toDialectString($this->getDialect());
     if ($isAsync) {
         LoggerPool::log(parent::LOG_VERBOSE, 'sending an async query: %s', $queryAsString);
     } else {
         LoggerPool::log(parent::LOG_VERBOSE, 'sending query: %s', $queryAsString);
     }
     LoggerPool::log(parent::LOG_QUERY, $queryAsString);
     $executeResult = pg_send_query($this->link, $queryAsString);
     if (!$isAsync || !$executeResult) {
         $result = pg_get_result($this->link);
         $resultStatus = pg_result_status($result, PGSQL_STATUS_LONG);
         if (in_array($resultStatus, array(PGSQL_EMPTY_QUERY, PGSQL_BAD_RESPONSE, PGSQL_NONFATAL_ERROR, PGSQL_FATAL_ERROR))) {
             $errorCode = pg_result_error_field($result, PGSQL_DIAG_SQLSTATE);
             $errorMessage = pg_result_error_field($result, PGSQL_DIAG_MESSAGE_PRIMARY);
             if (PgSqlError::UNIQUE_VIOLATION == $errorCode) {
                 LoggerPool::log(parent::LOG_VERBOSE, 'query caused a unique violation: %s', $errorMessage);
                 throw new UniqueViolationException($query, $errorMessage);
             } else {
                 LoggerPool::log(parent::LOG_VERBOSE, 'query caused an error #%s: %s', $errorCode, $errorMessage);
                 throw new PgSqlQueryException($query, $errorMessage, $errorCode);
             }
         }
     }
     return $result;
 }

 /**
  * Complete query
  * @param string $query query string
  * @param array|null $data query parameters
  * @return QueryResult postgres query result
  * @throws DuplicateEntryException when entry was duplicated
  * @throws DuplicateTableException when table was duplicated
  * @throws ConnectionBusyException when connection busy by another request
  * @throws UndefinedTableException when try to query undefined table
  * @throws QueryException for other reasons
  */
 public function query($query, array $data = null)
 {
     if (is_null($this->Resource)) {
         $this->connect();
     }
     $busy = false;
     if ($this->needBusyCheckup()) {
         $busy = pg_connection_busy($this->Resource);
     }
     if (!$busy) {
         $this->sendQuery($query, $data);
         $Result = pg_get_result($this->Resource);
         $Error = pg_result_error($Result);
         if (!empty($Error)) {
             $errorMessage = pg_errormessage($this->Resource);
             $errorCode = pg_result_error_field($Result, PGSQL_DIAG_SQLSTATE);
             switch ($errorCode) {
                 case self::CODE_DUPLICATE_ENTRY:
                     throw new DuplicateEntryException($errorMessage);
                 case self::CODE_UNDEFINED_TABLE:
                     throw new UndefinedTableException($errorMessage);
                 case self::CODE_DUPLICATE_TABLE:
                     throw new DuplicateTableException($errorMessage);
                 case self::CODE_DUPLICATE_TYPE:
                     throw new DuplicateTypeException($errorMessage);
                 case self::CODE_RAISE_EXCEPTION:
                     throw new RaiseException($errorMessage);
                 default:
                     throw new QueryException(sprintf("%s QUERY: %s CODE: %s", $errorMessage, $query, $errorCode));
             }
         } else {
             return new QueryResult($Result);
         }
     } else {
         throw new ConnectionBusyException();
     }
 }

 /**
  * Does a query with placeholders
  */
 function db_query($q)
 {
     $this->db_connect();
     $this->statement_handle = null;
     $this->sql = $this->db_merge($q);
     // Do the query
     $start = microtime(true);
     pg_send_query($this->db, $this->sql);
     $this->statement_handle = pg_get_result($this->db);
     $this->duration = microtime(true) - $start;
     ar_logger('SQL: [' . number_format($this->duration, 6) . '] ' . $this->sql, $this->db_connection);
     $GLOBALS['db_time'] += $this->duration;
     if ($error = pg_result_error($this->statement_handle)) {
         $errorstr = 'SQL ERROR: ' . $error . "\nSTATEMENT: " . $this->sql;
         //debug($errorstr);
         ar_logger($errorstr, $this->db_connection);
         throw_error($errorstr);
     }
     $this->sql = array();
 }

 public function transferDBtoArray($host, $user, $password, $db_or_dsn_name, $cndriver = "mysql")
 {
     $this->m = 0;
     if (!$this->connect($host, $user, $password, $db_or_dsn_name, $cndriver)) {
         echo "Fail to connect database";
         exit(0);
     }
     if ($this->debugsql == true) {
         echo "<textarea cols='100' rows='40'>{$this->sql}</textarea>";
         die;
     }
     if ($cndriver == "odbc") {
         $result = odbc_exec($this->myconn, $this->sql);
         while ($row = odbc_fetch_array($result)) {
             foreach ($this->arrayfield as $out) {
                 $this->arraysqltable[$this->m]["{$out}"] = $row["{$out}"];
             }
             $this->m++;
         }
     } elseif ($cndriver == "psql") {
         pg_send_query($this->myconn, $this->sql);
         $result = pg_get_result($this->myconn);
         while ($row = pg_fetch_array($result, NULL, PGSQL_ASSOC)) {
             foreach ($this->arrayfield as $out) {
                 $this->arraysqltable[$this->m]["{$out}"] = $row["{$out}"];
             }
             $this->m++;
         }
     } else {
         @mysql_query("set names 'utf8'");
         $result = @mysql_query($this->sql);
         //query from db
         while ($row = mysql_fetch_array($result, MYSQL_ASSOC)) {
             foreach ($this->arrayfield as $out) {
                 $this->arraysqltable[$this->m]["{$out}"] = $row["{$out}"];
             }
             $this->m++;
         }
     }
     // print_r(   $this->arraysqltable);die;
     //close connection to db
 }

 /**
  * Executes a query
  *
  * @param string $query SQL query
  * @param bool $debug False allows the query to not show in debug page
  * @author Matthew Lawrence <[email protected]>
  * @since 1.1.9
  * @return resource Executed query
  **/
 function query($query, $debug = true)
 {
     $this->querycount++;
     if (isset($this->get['debug']) && $debug) {
         $this->debug($query);
     }
     if (!pg_send_query($this->connection, $query)) {
         $err = pg_get_result($this->connection);
         error(QUICKSILVER_QUERY_ERROR, pg_result_error($err), $query, 0);
     } else {
         $this->last = pg_get_result($this->connection);
         if (false === $this->last) {
             error(QUICKSILVER_QUERY_ERROR, pg_result_error($err), $query, 0);
         }
     }
     return $this->last;
 }