Initial

system/Database/Postgre/Builder.php

@@ -0,0 +1,313 @@
+<?php
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Database\Postgre;
+
+use CodeIgniter\Database\BaseBuilder;
+use CodeIgniter\Database\Exceptions\DatabaseException;
+
+/**
+ * Builder for Postgre
+ */
+class Builder extends BaseBuilder
+{
+    /**
+     * ORDER BY random keyword
+     *
+     * @var array
+     */
+    protected $randomKeyword = [
+        'RANDOM()',
+    ];
+
+    /**
+     * Specifies which sql statements
+     * support the ignore option.
+     *
+     * @var array
+     */
+    protected $supportedIgnoreStatements = [
+        'insert' => 'ON CONFLICT DO NOTHING',
+    ];
+
+    /**
+     * Checks if the ignore option is supported by
+     * the Database Driver for the specific statement.
+     *
+     * @return string
+     */
+    protected function compileIgnore(string $statement)
+    {
+        $sql = parent::compileIgnore($statement);
+
+        if (! empty($sql)) {
+            $sql = ' ' . trim($sql);
+        }
+
+        return $sql;
+    }
+
+    /**
+     * ORDER BY
+     *
+     * @param string $direction ASC, DESC or RANDOM
+     *
+     * @return BaseBuilder
+     */
+    public function orderBy(string $orderBy, string $direction = '', ?bool $escape = null)
+    {
+        $direction = strtoupper(trim($direction));
+        if ($direction === 'RANDOM') {
+            if (ctype_digit($orderBy)) {
+                $orderBy = (float) ($orderBy > 1 ? "0.{$orderBy}" : $orderBy);
+            }
+
+            if (is_float($orderBy)) {
+                $this->db->simpleQuery("SET SEED {$orderBy}");
+            }
+
+            $orderBy   = $this->randomKeyword[0];
+            $direction = '';
+            $escape    = false;
+        }
+
+        return parent::orderBy($orderBy, $direction, $escape);
+    }
+
+    /**
+     * Increments a numeric column by the specified value.
+     *
+     * @throws DatabaseException
+     *
+     * @return mixed
+     */
+    public function increment(string $column, int $value = 1)
+    {
+        $column = $this->db->protectIdentifiers($column);
+
+        $sql = $this->_update($this->QBFrom[0], [$column => "to_number({$column}, '9999999') + {$value}"]);
+
+        return $this->db->query($sql, $this->binds, false);
+    }
+
+    /**
+     * Decrements a numeric column by the specified value.
+     *
+     * @throws DatabaseException
+     *
+     * @return mixed
+     */
+    public function decrement(string $column, int $value = 1)
+    {
+        $column = $this->db->protectIdentifiers($column);
+
+        $sql = $this->_update($this->QBFrom[0], [$column => "to_number({$column}, '9999999') - {$value}"]);
+
+        return $this->db->query($sql, $this->binds, false);
+    }
+
+    /**
+     * Compiles an replace into string and runs the query.
+     * Because PostgreSQL doesn't support the replace into command,
+     * we simply do a DELETE and an INSERT on the first key/value
+     * combo, assuming that it's either the primary key or a unique key.
+     *
+     * @param array|null $set An associative array of insert values
+     *
+     * @throws DatabaseException
+     *
+     * @return mixed
+     */
+    public function replace(?array $set = null)
+    {
+        if ($set !== null) {
+            $this->set($set);
+        }
+
+        if (! $this->QBSet) {
+            if (CI_DEBUG) {
+                throw new DatabaseException('You must use the "set" method to update an entry.');
+            }
+
+            return false; // @codeCoverageIgnore
+        }
+
+        $table = $this->QBFrom[0];
+        $set   = $this->binds;
+
+        array_walk($set, static function (array &$item) {
+            $item = $item[0];
+        });
+
+        $key   = array_key_first($set);
+        $value = $set[$key];
+
+        $builder = $this->db->table($table);
+        $exists  = $builder->where($key, $value, true)->get()->getFirstRow();
+
+        if (empty($exists) && $this->testMode) {
+            $result = $this->getCompiledInsert();
+        } elseif (empty($exists)) {
+            $result = $builder->insert($set);
+        } elseif ($this->testMode) {
+            $result = $this->where($key, $value, true)->getCompiledUpdate();
+        } else {
+            array_shift($set);
+            $result = $builder->where($key, $value, true)->update($set);
+        }
+
+        unset($builder);
+        $this->resetWrite();
+
+        return $result;
+    }
+
+    /**
+     * Generates a platform-specific insert string from the supplied data
+     */
+    protected function _insert(string $table, array $keys, array $unescapedKeys): string
+    {
+        return trim(sprintf('INSERT INTO %s (%s) VALUES (%s) %s', $table, implode(', ', $keys), implode(', ', $unescapedKeys), $this->compileIgnore('insert')));
+    }
+
+    /**
+     * Generates a platform-specific insert string from the supplied data.
+     */
+    protected function _insertBatch(string $table, array $keys, array $values): string
+    {
+        return trim(sprintf('INSERT INTO %s (%s) VALUES %s %s', $table, implode(', ', $keys), implode(', ', $values), $this->compileIgnore('insert')));
+    }
+
+    /**
+     * Compiles a delete string and runs the query
+     *
+     * @param mixed $where
+     *
+     * @throws DatabaseException
+     *
+     * @return mixed
+     */
+    public function delete($where = '', ?int $limit = null, bool $resetData = true)
+    {
+        if (! empty($limit) || ! empty($this->QBLimit)) {
+            throw new DatabaseException('PostgreSQL does not allow LIMITs on DELETE queries.');
+        }
+
+        return parent::delete($where, $limit, $resetData);
+    }
+
+    /**
+     * Generates a platform-specific LIMIT clause.
+     */
+    protected function _limit(string $sql, bool $offsetIgnore = false): string
+    {
+        return $sql . ' LIMIT ' . $this->QBLimit . ($this->QBOffset ? " OFFSET {$this->QBOffset}" : '');
+    }
+
+    /**
+     * Generates a platform-specific update string from the supplied data
+     *
+     * @throws DatabaseException
+     */
+    protected function _update(string $table, array $values): string
+    {
+        if (! empty($this->QBLimit)) {
+            throw new DatabaseException('Postgres does not support LIMITs with UPDATE queries.');
+        }
+
+        $this->QBOrderBy = [];
+
+        return parent::_update($table, $values);
+    }
+
+    /**
+     * Generates a platform-specific batch update string from the supplied data
+     */
+    protected function _updateBatch(string $table, array $values, string $index): string
+    {
+        $ids   = [];
+        $final = [];
+
+        foreach ($values as $val) {
+            $ids[] = $val[$index];
+
+            foreach (array_keys($val) as $field) {
+                if ($field !== $index) {
+                    $final[$field] = $final[$field] ?? [];
+
+                    $final[$field][] = "WHEN {$val[$index]} THEN {$val[$field]}";
+                }
+            }
+        }
+
+        $cases = '';
+
+        foreach ($final as $k => $v) {
+            $cases .= "{$k} = (CASE {$index}\n"
+                    . implode("\n", $v)
+                    . "\nELSE {$k} END), ";
+        }
+
+        $this->where("{$index} IN(" . implode(',', $ids) . ')', null, false);
+
+        return "UPDATE {$table} SET " . substr($cases, 0, -2) . $this->compileWhereHaving('QBWhere');
+    }
+
+    /**
+     * Generates a platform-specific delete string from the supplied data
+     */
+    protected function _delete(string $table): string
+    {
+        $this->QBLimit = false;
+
+        return parent::_delete($table);
+    }
+
+    /**
+     * Generates a platform-specific truncate string from the supplied data
+     *
+     * If the database does not support the truncate() command,
+     * then this method maps to 'DELETE FROM table'
+     */
+    protected function _truncate(string $table): string
+    {
+        return 'TRUNCATE ' . $table . ' RESTART IDENTITY';
+    }
+
+    /**
+     * Platform independent LIKE statement builder.
+     *
+     * In PostgreSQL, the ILIKE operator will perform case insensitive
+     * searches according to the current locale.
+     *
+     * @see https://www.postgresql.org/docs/9.2/static/functions-matching.html
+     */
+    protected function _like_statement(?string $prefix, string $column, ?string $not, string $bind, bool $insensitiveSearch = false): string
+    {
+        $op = $insensitiveSearch === true ? 'ILIKE' : 'LIKE';
+
+        return "{$prefix} {$column} {$not} {$op} :{$bind}:";
+    }
+
+    /**
+     * Generates the JOIN portion of the query
+     *
+     * @return BaseBuilder
+     */
+    public function join(string $table, string $cond, string $type = '', ?bool $escape = null)
+    {
+        if (! in_array('FULL OUTER', $this->joinTypes, true)) {
+            $this->joinTypes = array_merge($this->joinTypes, ['FULL OUTER']);
+        }
+
+        return parent::join($table, $cond, $type, $escape);
+    }
+}

system/Database/Postgre/Connection.php

@@ -0,0 +1,517 @@
+<?php
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Database\Postgre;
+
+use CodeIgniter\Database\BaseConnection;
+use CodeIgniter\Database\Exceptions\DatabaseException;
+use ErrorException;
+use stdClass;
+
+/**
+ * Connection for Postgre
+ */
+class Connection extends BaseConnection
+{
+    /**
+     * Database driver
+     *
+     * @var string
+     */
+    public $DBDriver = 'Postgre';
+
+    /**
+     * Database schema
+     *
+     * @var string
+     */
+    public $schema = 'public';
+
+    /**
+     * Identifier escape character
+     *
+     * @var string
+     */
+    public $escapeChar = '"';
+
+    /**
+     * Connect to the database.
+     *
+     * @return mixed
+     */
+    public function connect(bool $persistent = false)
+    {
+        if (empty($this->DSN)) {
+            $this->buildDSN();
+        }
+
+        // Strip pgsql if exists
+        if (mb_strpos($this->DSN, 'pgsql:') === 0) {
+            $this->DSN = mb_substr($this->DSN, 6);
+        }
+
+        // Convert semicolons to spaces.
+        $this->DSN = str_replace(';', ' ', $this->DSN);
+
+        $this->connID = $persistent === true ? pg_pconnect($this->DSN) : pg_connect($this->DSN);
+
+        if ($this->connID !== false) {
+            if ($persistent === true && pg_connection_status($this->connID) === PGSQL_CONNECTION_BAD && pg_ping($this->connID) === false
+            ) {
+                return false;
+            }
+
+            if (! empty($this->schema)) {
+                $this->simpleQuery("SET search_path TO {$this->schema},public");
+            }
+
+            if ($this->setClientEncoding($this->charset) === false) {
+                return false;
+            }
+        }
+
+        return $this->connID;
+    }
+
+    /**
+     * Keep or establish the connection if no queries have been sent for
+     * a length of time exceeding the server's idle timeout.
+     */
+    public function reconnect()
+    {
+        if (pg_ping($this->connID) === false) {
+            $this->connID = false;
+        }
+    }
+
+    /**
+     * Close the database connection.
+     */
+    protected function _close()
+    {
+        pg_close($this->connID);
+    }
+
+    /**
+     * Select a specific database table to use.
+     */
+    public function setDatabase(string $databaseName): bool
+    {
+        return false;
+    }
+
+    /**
+     * Returns a string containing the version of the database being used.
+     */
+    public function getVersion(): string
+    {
+        if (isset($this->dataCache['version'])) {
+            return $this->dataCache['version'];
+        }
+
+        if (! $this->connID || ($pgVersion = pg_version($this->connID)) === false) {
+            $this->initialize();
+        }
+
+        return isset($pgVersion['server']) ? $this->dataCache['version'] = $pgVersion['server'] : false;
+    }
+
+    /**
+     * Executes the query against the database.
+     *
+     * @return mixed
+     */
+    protected function execute(string $sql)
+    {
+        try {
+            return pg_query($this->connID, $sql);
+        } catch (ErrorException $e) {
+            log_message('error', $e);
+            if ($this->DBDebug) {
+                throw $e;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Get the prefix of the function to access the DB.
+     */
+    protected function getDriverFunctionPrefix(): string
+    {
+        return 'pg_';
+    }
+
+    /**
+     * Returns the total number of rows affected by this query.
+     */
+    public function affectedRows(): int
+    {
+        return pg_affected_rows($this->resultID);
+    }
+
+    /**
+     * "Smart" Escape String
+     *
+     * Escapes data based on type
+     *
+     * @param mixed $str
+     *
+     * @return mixed
+     */
+    public function escape($str)
+    {
+        if (! $this->connID) {
+            $this->initialize();
+        }
+
+        if (is_string($str) || (is_object($str) && method_exists($str, '__toString'))) {
+            return pg_escape_literal($this->connID, $str);
+        }
+
+        if (is_bool($str)) {
+            return $str ? 'TRUE' : 'FALSE';
+        }
+
+        return parent::escape($str);
+    }
+
+    /**
+     * Platform-dependant string escape
+     */
+    protected function _escapeString(string $str): string
+    {
+        if (! $this->connID) {
+            $this->initialize();
+        }
+
+        return pg_escape_string($this->connID, $str);
+    }
+
+    /**
+     * Generates the SQL for listing tables in a platform-dependent manner.
+     */
+    protected function _listTables(bool $prefixLimit = false): string
+    {
+        $sql = 'SELECT "table_name" FROM "information_schema"."tables" WHERE "table_schema" = \'' . $this->schema . "'";
+
+        if ($prefixLimit !== false && $this->DBPrefix !== '') {
+            return $sql . ' AND "table_name" LIKE \''
+                . $this->escapeLikeString($this->DBPrefix) . "%' "
+                . sprintf($this->likeEscapeStr, $this->likeEscapeChar);
+        }
+
+        return $sql;
+    }
+
+    /**
+     * Generates a platform-specific query string so that the column names can be fetched.
+     */
+    protected function _listColumns(string $table = ''): string
+    {
+        return 'SELECT "column_name"
+			FROM "information_schema"."columns"
+			WHERE LOWER("table_name") = '
+                . $this->escape($this->DBPrefix . strtolower($table))
+                . ' ORDER BY "ordinal_position"';
+    }
+
+    /**
+     * Returns an array of objects with field data
+     *
+     * @throws DatabaseException
+     *
+     * @return stdClass[]
+     */
+    protected function _fieldData(string $table): array
+    {
+        $sql = 'SELECT "column_name", "data_type", "character_maximum_length", "numeric_precision", "column_default"
+			FROM "information_schema"."columns"
+			WHERE LOWER("table_name") = '
+                . $this->escape(strtolower($table))
+                . ' ORDER BY "ordinal_position"';
+
+        if (($query = $this->query($sql)) === false) {
+            throw new DatabaseException(lang('Database.failGetFieldData'));
+        }
+        $query = $query->getResultObject();
+
+        $retVal = [];
+
+        for ($i = 0, $c = count($query); $i < $c; $i++) {
+            $retVal[$i] = new stdClass();
+
+            $retVal[$i]->name       = $query[$i]->column_name;
+            $retVal[$i]->type       = $query[$i]->data_type;
+            $retVal[$i]->default    = $query[$i]->column_default;
+            $retVal[$i]->max_length = $query[$i]->character_maximum_length > 0 ? $query[$i]->character_maximum_length : $query[$i]->numeric_precision;
+        }
+
+        return $retVal;
+    }
+
+    /**
+     * Returns an array of objects with index data
+     *
+     * @throws DatabaseException
+     *
+     * @return stdClass[]
+     */
+    protected function _indexData(string $table): array
+    {
+        $sql = 'SELECT "indexname", "indexdef"
+			FROM "pg_indexes"
+			WHERE LOWER("tablename") = ' . $this->escape(strtolower($table)) . '
+			AND "schemaname" = ' . $this->escape('public');
+
+        if (($query = $this->query($sql)) === false) {
+            throw new DatabaseException(lang('Database.failGetIndexData'));
+        }
+        $query = $query->getResultObject();
+
+        $retVal = [];
+
+        foreach ($query as $row) {
+            $obj         = new stdClass();
+            $obj->name   = $row->indexname;
+            $_fields     = explode(',', preg_replace('/^.*\((.+?)\)$/', '$1', trim($row->indexdef)));
+            $obj->fields = array_map(static function ($v) {
+                return trim($v);
+            }, $_fields);
+
+            if (strpos($row->indexdef, 'CREATE UNIQUE INDEX pk') === 0) {
+                $obj->type = 'PRIMARY';
+            } else {
+                $obj->type = (strpos($row->indexdef, 'CREATE UNIQUE') === 0) ? 'UNIQUE' : 'INDEX';
+            }
+
+            $retVal[$obj->name] = $obj;
+        }
+
+        return $retVal;
+    }
+
+    /**
+     * Returns an array of objects with Foreign key data
+     *
+     * @throws DatabaseException
+     *
+     * @return stdClass[]
+     */
+    protected function _foreignKeyData(string $table): array
+    {
+        $sql = 'SELECT
+            tc.constraint_name, tc.table_name, kcu.column_name,
+            ccu.table_name AS foreign_table_name,
+            ccu.column_name AS foreign_column_name
+        FROM information_schema.table_constraints AS tc
+        JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name
+        JOIN information_schema.constraint_column_usage AS ccu
+            ON ccu.constraint_name = tc.constraint_name
+        WHERE constraint_type = ' . $this->escape('FOREIGN KEY') . ' AND
+            tc.table_name = ' . $this->escape($table);
+
+        if (($query = $this->query($sql)) === false) {
+            throw new DatabaseException(lang('Database.failGetForeignKeyData'));
+        }
+
+        $query  = $query->getResultObject();
+        $retVal = [];
+
+        foreach ($query as $row) {
+            $obj = new stdClass();
+
+            $obj->constraint_name     = $row->constraint_name;
+            $obj->table_name          = $row->table_name;
+            $obj->column_name         = $row->column_name;
+            $obj->foreign_table_name  = $row->foreign_table_name;
+            $obj->foreign_column_name = $row->foreign_column_name;
+
+            $retVal[] = $obj;
+        }
+
+        return $retVal;
+    }
+
+    /**
+     * Returns platform-specific SQL to disable foreign key checks.
+     *
+     * @return string
+     */
+    protected function _disableForeignKeyChecks()
+    {
+        return 'SET CONSTRAINTS ALL DEFERRED';
+    }
+
+    /**
+     * Returns platform-specific SQL to enable foreign key checks.
+     *
+     * @return string
+     */
+    protected function _enableForeignKeyChecks()
+    {
+        return 'SET CONSTRAINTS ALL IMMEDIATE;';
+    }
+
+    /**
+     * Returns the last error code and message.
+     * Must return this format: ['code' => string|int, 'message' => string]
+     * intval(code) === 0 means "no error".
+     *
+     * @return array<string, int|string>
+     */
+    public function error(): array
+    {
+        return [
+            'code'    => '',
+            'message' => pg_last_error($this->connID) ?: '',
+        ];
+    }
+
+    /**
+     * @return int|string
+     */
+    public function insertID()
+    {
+        $v = pg_version($this->connID);
+        // 'server' key is only available since PostgreSQL 7.4
+        $v = explode(' ', $v['server'])[0] ?? 0;
+
+        $table  = func_num_args() > 0 ? func_get_arg(0) : null;
+        $column = func_num_args() > 1 ? func_get_arg(1) : null;
+
+        if ($table === null && $v >= '8.1') {
+            $sql = 'SELECT LASTVAL() AS ins_id';
+        } elseif ($table !== null) {
+            if ($column !== null && $v >= '8.0') {
+                $sql   = "SELECT pg_get_serial_sequence('{$table}', '{$column}') AS seq";
+                $query = $this->query($sql);
+                $query = $query->getRow();
+                $seq   = $query->seq;
+            } else {
+                // seq_name passed in table parameter
+                $seq = $table;
+            }
+
+            $sql = "SELECT CURRVAL('{$seq}') AS ins_id";
+        } else {
+            return pg_last_oid($this->resultID);
+        }
+
+        $query = $this->query($sql);
+        $query = $query->getRow();
+
+        return (int) $query->ins_id;
+    }
+
+    /**
+     * Build a DSN from the provided parameters
+     */
+    protected function buildDSN()
+    {
+        if ($this->DSN !== '') {
+            $this->DSN = '';
+        }
+
+        // If UNIX sockets are used, we shouldn't set a port
+        if (strpos($this->hostname, '/') !== false) {
+            $this->port = '';
+        }
+
+        if ($this->hostname !== '') {
+            $this->DSN = "host={$this->hostname} ";
+        }
+
+        // ctype_digit only accepts strings
+        $port = (string) $this->port;
+
+        if ($port !== '' && ctype_digit($port)) {
+            $this->DSN .= "port={$port} ";
+        }
+
+        if ($this->username !== '') {
+            $this->DSN .= "user={$this->username} ";
+
+            // An empty password is valid!
+            // password must be set to null to ignore it.
+            if ($this->password !== null) {
+                $this->DSN .= "password='{$this->password}' ";
+            }
+        }
+
+        if ($this->database !== '') {
+            $this->DSN .= "dbname={$this->database} ";
+        }
+
+        // We don't have these options as elements in our standard configuration
+        // array, but they might be set by parse_url() if the configuration was
+        // provided via string> Example:
+        //
+        // Postgre://username:password@localhost:5432/database?connect_timeout=5&sslmode=1
+        foreach (['connect_timeout', 'options', 'sslmode', 'service'] as $key) {
+            if (isset($this->{$key}) && is_string($this->{$key}) && $this->{$key} !== '') {
+                $this->DSN .= "{$key}='{$this->{$key}}' ";
+            }
+        }
+
+        $this->DSN = rtrim($this->DSN);
+    }
+
+    /**
+     * Set client encoding
+     */
+    protected function setClientEncoding(string $charset): bool
+    {
+        return pg_set_client_encoding($this->connID, $charset) === 0;
+    }
+
+    /**
+     * Begin Transaction
+     */
+    protected function _transBegin(): bool
+    {
+        return (bool) pg_query($this->connID, 'BEGIN');
+    }
+
+    /**
+     * Commit Transaction
+     */
+    protected function _transCommit(): bool
+    {
+        return (bool) pg_query($this->connID, 'COMMIT');
+    }
+
+    /**
+     * Rollback Transaction
+     */
+    protected function _transRollback(): bool
+    {
+        return (bool) pg_query($this->connID, 'ROLLBACK');
+    }
+
+    /**
+     * Determines if a query is a "write" type.
+     *
+     * Overrides BaseConnection::isWriteType, adding additional read query types.
+     *
+     * @param mixed $sql
+     */
+    public function isWriteType($sql): bool
+    {
+        if (preg_match('#^(INSERT|UPDATE).*RETURNING\s.+(\,\s?.+)*$#is', $sql)) {
+            return false;
+        }
+
+        return parent::isWriteType($sql);
+    }
+}

system/Database/Postgre/Forge.php

@@ -0,0 +1,193 @@
+<?php
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Database\Postgre;
+
+use CodeIgniter\Database\Forge as BaseForge;
+
+/**
+ * Forge for Postgre
+ */
+class Forge extends BaseForge
+{
+    /**
+     * CHECK DATABASE EXIST statement
+     *
+     * @var string
+     */
+    protected $checkDatabaseExistStr = 'SELECT 1 FROM pg_database WHERE datname = ?';
+
+    /**
+     * DROP CONSTRAINT statement
+     *
+     * @var string
+     */
+    protected $dropConstraintStr = 'ALTER TABLE %s DROP CONSTRAINT %s';
+
+    /**
+     * DROP INDEX statement
+     *
+     * @var string
+     */
+    protected $dropIndexStr = 'DROP INDEX %s';
+
+    /**
+     * UNSIGNED support
+     *
+     * @var array
+     */
+    protected $_unsigned = [
+        'INT2'     => 'INTEGER',
+        'SMALLINT' => 'INTEGER',
+        'INT'      => 'BIGINT',
+        'INT4'     => 'BIGINT',
+        'INTEGER'  => 'BIGINT',
+        'INT8'     => 'NUMERIC',
+        'BIGINT'   => 'NUMERIC',
+        'REAL'     => 'DOUBLE PRECISION',
+        'FLOAT'    => 'DOUBLE PRECISION',
+    ];
+
+    /**
+     * NULL value representation in CREATE/ALTER TABLE statements
+     *
+     * @var string
+     *
+     * @internal
+     */
+    protected $null = 'NULL';
+
+    /**
+     * CREATE TABLE attributes
+     *
+     * @param array $attributes Associative array of table attributes
+     */
+    protected function _createTableAttributes(array $attributes): string
+    {
+        return '';
+    }
+
+    /**
+     * @param mixed $field
+     *
+     * @return array|bool|string
+     */
+    protected function _alterTable(string $alterType, string $table, $field)
+    {
+        if (in_array($alterType, ['DROP', 'ADD'], true)) {
+            return parent::_alterTable($alterType, $table, $field);
+        }
+
+        $sql  = 'ALTER TABLE ' . $this->db->escapeIdentifiers($table);
+        $sqls = [];
+
+        foreach ($field as $data) {
+            if ($data['_literal'] !== false) {
+                return false;
+            }
+
+            if (version_compare($this->db->getVersion(), '8', '>=') && isset($data['type'])) {
+                $sqls[] = $sql . ' ALTER COLUMN ' . $this->db->escapeIdentifiers($data['name'])
+                    . " TYPE {$data['type']}{$data['length']}";
+            }
+
+            if (! empty($data['default'])) {
+                $sqls[] = $sql . ' ALTER COLUMN ' . $this->db->escapeIdentifiers($data['name'])
+                    . " SET DEFAULT {$data['default']}";
+            }
+
+            if (isset($data['null'])) {
+                $sqls[] = $sql . ' ALTER COLUMN ' . $this->db->escapeIdentifiers($data['name'])
+                    . ($data['null'] === true ? ' DROP' : ' SET') . ' NOT NULL';
+            }
+
+            if (! empty($data['new_name'])) {
+                $sqls[] = $sql . ' RENAME COLUMN ' . $this->db->escapeIdentifiers($data['name'])
+                    . ' TO ' . $this->db->escapeIdentifiers($data['new_name']);
+            }
+
+            if (! empty($data['comment'])) {
+                $sqls[] = 'COMMENT ON COLUMN' . $this->db->escapeIdentifiers($table)
+                    . '.' . $this->db->escapeIdentifiers($data['name'])
+                    . " IS {$data['comment']}";
+            }
+        }
+
+        return $sqls;
+    }
+
+    /**
+     * Process column
+     */
+    protected function _processColumn(array $field): string
+    {
+        return $this->db->escapeIdentifiers($field['name'])
+            . ' ' . $field['type'] . $field['length']
+            . $field['default']
+            . $field['null']
+            . $field['auto_increment']
+            . $field['unique'];
+    }
+
+    /**
+     * Performs a data type mapping between different databases.
+     */
+    protected function _attributeType(array &$attributes)
+    {
+        // Reset field lengths for data types that don't support it
+        if (isset($attributes['CONSTRAINT']) && stripos($attributes['TYPE'], 'int') !== false) {
+            $attributes['CONSTRAINT'] = null;
+        }
+
+        switch (strtoupper($attributes['TYPE'])) {
+            case 'TINYINT':
+                $attributes['TYPE']     = 'SMALLINT';
+                $attributes['UNSIGNED'] = false;
+                break;
+
+            case 'MEDIUMINT':
+                $attributes['TYPE']     = 'INTEGER';
+                $attributes['UNSIGNED'] = false;
+                break;
+
+            case 'DATETIME':
+                $attributes['TYPE'] = 'TIMESTAMP';
+                break;
+
+            default:
+                break;
+        }
+    }
+
+    /**
+     * Field attribute AUTO_INCREMENT
+     */
+    protected function _attributeAutoIncrement(array &$attributes, array &$field)
+    {
+        if (! empty($attributes['AUTO_INCREMENT']) && $attributes['AUTO_INCREMENT'] === true) {
+            $field['type'] = $field['type'] === 'NUMERIC' || $field['type'] === 'BIGINT' ? 'BIGSERIAL' : 'SERIAL';
+        }
+    }
+
+    /**
+     * Generates a platform-specific DROP TABLE string
+     */
+    protected function _dropTable(string $table, bool $ifExists, bool $cascade): string
+    {
+        $sql = parent::_dropTable($table, $ifExists, $cascade);
+
+        if ($cascade === true) {
+            $sql .= ' CASCADE';
+        }
+
+        return $sql;
+    }
+}

system/Database/Postgre/PreparedQuery.php

@@ -0,0 +1,111 @@
+<?php
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Database\Postgre;
+
+use BadMethodCallException;
+use CodeIgniter\Database\BasePreparedQuery;
+use Exception;
+
+/**
+ * Prepared query for Postgre
+ */
+class PreparedQuery extends BasePreparedQuery
+{
+    /**
+     * Stores the name this query can be
+     * used under by postgres. Only used internally.
+     *
+     * @var string
+     */
+    protected $name;
+
+    /**
+     * The result resource from a successful
+     * pg_exec. Or false.
+     *
+     * @var bool|Result
+     */
+    protected $result;
+
+    /**
+     * Prepares the query against the database, and saves the connection
+     * info necessary to execute the query later.
+     *
+     * NOTE: This version is based on SQL code. Child classes should
+     * override this method.
+     *
+     * @param array $options Passed to the connection's prepare statement.
+     *                       Unused in the MySQLi driver.
+     *
+     * @throws Exception
+     *
+     * @return mixed
+     */
+    public function _prepare(string $sql, array $options = [])
+    {
+        $this->name = (string) random_int(1, 10000000000000000);
+
+        $sql = $this->parameterize($sql);
+
+        // Update the query object since the parameters are slightly different
+        // than what was put in.
+        $this->query->setQuery($sql);
+
+        if (! $this->statement = pg_prepare($this->db->connID, $this->name, $sql)) {
+            $this->errorCode   = 0;
+            $this->errorString = pg_last_error($this->db->connID);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Takes a new set of data and runs it against the currently
+     * prepared query. Upon success, will return a Results object.
+     */
+    public function _execute(array $data): bool
+    {
+        if (! isset($this->statement)) {
+            throw new BadMethodCallException('You must call prepare before trying to execute a prepared statement.');
+        }
+
+        $this->result = pg_execute($this->db->connID, $this->name, $data);
+
+        return (bool) $this->result;
+    }
+
+    /**
+     * Returns the result object for the prepared query.
+     *
+     * @return mixed
+     */
+    public function _getResult()
+    {
+        return $this->result;
+    }
+
+    /**
+     * Replaces the ? placeholders with $1, $2, etc parameters for use
+     * within the prepared query.
+     */
+    public function parameterize(string $sql): string
+    {
+        // Track our current value
+        $count = 0;
+
+        return preg_replace_callback('/\?/', static function () use (&$count) {
+            $count++;
+
+            return "\${$count}";
+        }, $sql);
+    }
+}

system/Database/Postgre/Result.php

@@ -0,0 +1,128 @@
+<?php
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Database\Postgre;
+
+use CodeIgniter\Database\BaseResult;
+use CodeIgniter\Entity\Entity;
+use stdClass;
+
+/**
+ * Result for Postgre
+ */
+class Result extends BaseResult
+{
+    /**
+     * Gets the number of fields in the result set.
+     */
+    public function getFieldCount(): int
+    {
+        return pg_num_fields($this->resultID);
+    }
+
+    /**
+     * Generates an array of column names in the result set.
+     */
+    public function getFieldNames(): array
+    {
+        $fieldNames = [];
+
+        for ($i = 0, $c = $this->getFieldCount(); $i < $c; $i++) {
+            $fieldNames[] = pg_field_name($this->resultID, $i);
+        }
+
+        return $fieldNames;
+    }
+
+    /**
+     * Generates an array of objects representing field meta-data.
+     */
+    public function getFieldData(): array
+    {
+        $retVal = [];
+
+        for ($i = 0, $c = $this->getFieldCount(); $i < $c; $i++) {
+            $retVal[$i]             = new stdClass();
+            $retVal[$i]->name       = pg_field_name($this->resultID, $i);
+            $retVal[$i]->type       = pg_field_type_oid($this->resultID, $i);
+            $retVal[$i]->type_name  = pg_field_type($this->resultID, $i);
+            $retVal[$i]->max_length = pg_field_size($this->resultID, $i);
+            $retVal[$i]->length     = $retVal[$i]->max_length;
+            // $retVal[$i]->primary_key = (int)($fieldData[$i]->flags & 2);
+            // $retVal[$i]->default     = $fieldData[$i]->def;
+        }
+
+        return $retVal;
+    }
+
+    /**
+     * Frees the current result.
+     */
+    public function freeResult()
+    {
+        if ($this->resultID !== false) {
+            pg_free_result($this->resultID);
+            $this->resultID = false;
+        }
+    }
+
+    /**
+     * Moves the internal pointer to the desired offset. This is called
+     * internally before fetching results to make sure the result set
+     * starts at zero.
+     *
+     * @return mixed
+     */
+    public function dataSeek(int $n = 0)
+    {
+        return pg_result_seek($this->resultID, $n);
+    }
+
+    /**
+     * Returns the result set as an array.
+     *
+     * Overridden by driver classes.
+     *
+     * @return mixed
+     */
+    protected function fetchAssoc()
+    {
+        return pg_fetch_assoc($this->resultID);
+    }
+
+    /**
+     * Returns the result set as an object.
+     *
+     * Overridden by child classes.
+     *
+     * @return bool|Entity|object
+     */
+    protected function fetchObject(string $className = 'stdClass')
+    {
+        if (is_subclass_of($className, Entity::class)) {
+            return empty($data = $this->fetchAssoc()) ? false : (new $className())->setAttributes($data);
+        }
+
+        return pg_fetch_object($this->resultID, null, $className);
+    }
+
+    /**
+     * Returns the number of rows in the resultID (i.e., PostgreSQL query result resource)
+     */
+    public function getNumRows(): int
+    {
+        if (! is_int($this->numRows)) {
+            $this->numRows = pg_num_rows($this->resultID);
+        }
+
+        return $this->numRows;
+    }
+}

system/Database/Postgre/Utils.php

@@ -0,0 +1,45 @@
+<?php
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Database\Postgre;
+
+use CodeIgniter\Database\BaseUtils;
+use CodeIgniter\Database\Exceptions\DatabaseException;
+
+/**
+ * Utils for Postgre
+ */
+class Utils extends BaseUtils
+{
+    /**
+     * List databases statement
+     *
+     * @var string
+     */
+    protected $listDatabases = 'SELECT datname FROM pg_database';
+
+    /**
+     * OPTIMIZE TABLE statement
+     *
+     * @var string
+     */
+    protected $optimizeTable = 'REINDEX TABLE %s';
+
+    /**
+     * Platform dependent version of the backup function.
+     *
+     * @return mixed
+     */
+    public function _backup(?array $prefs = null)
+    {
+        throw new DatabaseException('Unsupported feature of the database platform you are using.');
+    }
+}