Code Coverage
 
Classes and Traits
Functions and Methods
Lines
Total
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 4
CRAP
0.00% covered (danger)
0.00%
0 / 244
postgres_extractor
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 4
1560.00
0.00% covered (danger)
0.00%
0 / 244
 write_start
0.00% covered (danger)
0.00%
0 / 1
6.00
0.00% covered (danger)
0.00%
0 / 13
 write_table
0.00% covered (danger)
0.00%
0 / 1
650.00
0.00% covered (danger)
0.00%
0 / 167
 write_data
0.00% covered (danger)
0.00%
0 / 1
110.00
0.00% covered (danger)
0.00%
0 / 56
 write_end
0.00% covered (danger)
0.00%
0 / 1
6.00
0.00% covered (danger)
0.00%
0 / 8
<?php
/**
*
* This file is part of the phpBB Forum Software package.
*
* @copyright (c) phpBB Limited <https://www.phpbb.com>
* @license GNU General Public License, version 2 (GPL-2.0)
*
* For full copyright and license information, please see
* the docs/CREDITS.txt file.
*
*/
namespace phpbb\db\extractor;
use phpbb\db\extractor\exception\extractor_not_initialized_exception;
class postgres_extractor extends base_extractor
{
    /**
    * {@inheritdoc}
    */
    public function write_start($table_prefix)
    {
        if (!$this->is_initialized)
        {
            throw new extractor_not_initialized_exception();
        }
        $sql_data = "--\n";
        $sql_data .= "-- phpBB Backup Script\n";
        $sql_data .= "-- Dump of tables for $table_prefix\n";
        $sql_data .= "-- DATE : " . gmdate("d-m-Y H:i:s", $this->time) . " GMT\n";
        $sql_data .= "--\n";
        $sql_data .= "BEGIN TRANSACTION;\n";
        $this->flush($sql_data);
    }
    /**
    * {@inheritdoc}
    */
    public function write_table($table_name)
    {
        static $domains_created = array();
        if (!$this->is_initialized)
        {
            throw new extractor_not_initialized_exception();
        }
        $sql = "SELECT a.domain_name, a.data_type, a.character_maximum_length, a.domain_default
            FROM INFORMATION_SCHEMA.domains a, INFORMATION_SCHEMA.column_domain_usage b
            WHERE a.domain_name = b.domain_name
                AND b.table_name = '{$table_name}'";
        $result = $this->db->sql_query($sql);
        while ($row = $this->db->sql_fetchrow($result))
        {
            if (empty($domains_created[$row['domain_name']]))
            {
                $domains_created[$row['domain_name']] = true;
                //$sql_data = "DROP DOMAIN {$row['domain_name']};\n";
                $sql_data = "CREATE DOMAIN {$row['domain_name']} as {$row['data_type']}";
                if (!empty($row['character_maximum_length']))
                {
                    $sql_data .= '(' . $row['character_maximum_length'] . ')';
                }
                $sql_data .= ' NOT NULL';
                if (!empty($row['domain_default']))
                {
                    $sql_data .= ' DEFAULT ' . $row['domain_default'];
                }
                $this->flush($sql_data . ";\n");
            }
        }
        $this->db->sql_freeresult($result);
        $sql_data = '-- Table: ' . $table_name . "\n";
        $sql_data .= "DROP TABLE $table_name;\n";
        // PGSQL does not "tightly" bind sequences and tables, we must guess...
        $sql = "SELECT relname
            FROM pg_class
            WHERE relkind = 'S'
                AND relname = '{$table_name}_seq'";
        $result = $this->db->sql_query($sql);
        // We don't even care about storing the results. We already know the answer if we get rows back.
        if ($this->db->sql_fetchrow($result))
        {
            $sql_data .= "DROP SEQUENCE IF EXISTS {$table_name}_seq;\n";
            $sql_data .= "CREATE SEQUENCE {$table_name}_seq;\n";
        }
        $this->db->sql_freeresult($result);
        $field_query = "SELECT a.attnum, a.attname as field, t.typname as type, a.attlen as length, a.atttypmod as lengthvar, a.attnotnull as notnull
            FROM pg_class c, pg_attribute a, pg_type t
            WHERE c.relname = '" . $this->db->sql_escape($table_name) . "'
                AND a.attnum > 0
                AND a.attrelid = c.oid
                AND a.atttypid = t.oid
            ORDER BY a.attnum";
        $result = $this->db->sql_query($field_query);
        $sql_data .= "CREATE TABLE $table_name(\n";
        $lines = array();
        while ($row = $this->db->sql_fetchrow($result))
        {
            // Get the data from the table
            $sql_get_default = "SELECT pg_get_expr(d.adbin, d.adrelid) as rowdefault
                FROM pg_attrdef d, pg_class c
                WHERE (c.relname = '" . $this->db->sql_escape($table_name) . "')
                    AND (c.oid = d.adrelid)
                    AND d.adnum = " . $row['attnum'];
            $def_res = $this->db->sql_query($sql_get_default);
            $def_row = $this->db->sql_fetchrow($def_res);
            $this->db->sql_freeresult($def_res);
            if (empty($def_row))
            {
                unset($row['rowdefault']);
            }
            else
            {
                $row['rowdefault'] = $def_row['rowdefault'];
            }
            if ($row['type'] == 'bpchar')
            {
                // Internally stored as bpchar, but isn't accepted in a CREATE TABLE statement.
                $row['type'] = 'char';
            }
            $line = '  ' . $row['field'] . ' ' . $row['type'];
            if (strpos($row['type'], 'char') !== false)
            {
                if ($row['lengthvar'] > 0)
                {
                    $line .= '(' . ($row['lengthvar'] - 4) . ')';
                }
            }
            if (strpos($row['type'], 'numeric') !== false)
            {
                $line .= '(';
                $line .= sprintf("%s,%s", (($row['lengthvar'] >> 16) & 0xffff), (($row['lengthvar'] - 4) & 0xffff));
                $line .= ')';
            }
            if (isset($row['rowdefault']))
            {
                $line .= ' DEFAULT ' . $row['rowdefault'];
            }
            if ($row['notnull'] == 't')
            {
                $line .= ' NOT NULL';
            }
            $lines[] = $line;
        }
        $this->db->sql_freeresult($result);
        // Get the listing of primary keys.
        $sql_pri_keys = "SELECT ic.relname as index_name, bc.relname as tab_name, ta.attname as column_name, i.indisunique as unique_key, i.indisprimary as primary_key
            FROM pg_class bc, pg_class ic, pg_index i, pg_attribute ta, pg_attribute ia
            WHERE (bc.oid = i.indrelid)
                AND (ic.oid = i.indexrelid)
                AND (ia.attrelid = i.indexrelid)
                AND    (ta.attrelid = bc.oid)
                AND (bc.relname = '" . $this->db->sql_escape($table_name) . "')
                AND (ta.attrelid = i.indrelid)
                AND (ta.attnum = i.indkey[ia.attnum-1])
            ORDER BY index_name, tab_name, column_name";
        $result = $this->db->sql_query($sql_pri_keys);
        $index_create = $index_rows = $primary_key = array();
        // We do this in two steps. It makes placing the comma easier
        while ($row = $this->db->sql_fetchrow($result))
        {
            if ($row['primary_key'] == 't')
            {
                $primary_key[] = $row['column_name'];
                $primary_key_name = $row['index_name'];
            }
            else
            {
                // We have to store this all this info because it is possible to have a multi-column key...
                // we can loop through it again and build the statement
                $index_rows[$row['index_name']]['table'] = $table_name;
                $index_rows[$row['index_name']]['unique'] = ($row['unique_key'] == 't') ? true : false;
                $index_rows[$row['index_name']]['column_names'][] = $row['column_name'];
            }
        }
        $this->db->sql_freeresult($result);
        if (!empty($index_rows))
        {
            foreach ($index_rows as $idx_name => $props)
            {
                $index_create[] = 'CREATE ' . ($props['unique'] ? 'UNIQUE ' : '') . "INDEX $idx_name ON $table_name (" . implode(', ', $props['column_names']) . ");";
            }
        }
        if (!empty($primary_key))
        {
            $lines[] = "  CONSTRAINT $primary_key_name PRIMARY KEY (" . implode(', ', $primary_key) . ")";
        }
        // Generate constraint clauses for CHECK constraints
        $sql_checks = "SELECT pc.conname AS index_name, pg_get_expr(pc.conbin, pc.conrelid) AS constraint_expr
            FROM pg_constraint pc, pg_class bc
            WHERE pc.conrelid = bc.oid
                AND bc.relname = '" . $this->db->sql_escape($table_name) . "'
                AND NOT EXISTS (
                    SELECT *
                    FROM pg_constraint AS c, pg_inherits AS i
                        WHERE i.inhrelid = pc.conrelid
                            AND c.conname = pc.conname
                            AND pg_get_constraintdef(c.oid) = pg_get_constraintdef(pc.oid)
                            AND c.conrelid = i.inhparent
                )";
        $result = $this->db->sql_query($sql_checks);
        // Add the constraints to the sql file.
        while ($row = $this->db->sql_fetchrow($result))
        {
            if (!empty($row['constraint_expr']))
            {
                $lines[] = '  CONSTRAINT ' . $row['index_name'] . ' CHECK ' . $row['constraint_expr'];
            }
        }
        $this->db->sql_freeresult($result);
        $sql_data .= implode(", \n", $lines);
        $sql_data .= "\n);\n";
        if (!empty($index_create))
        {
            $sql_data .= implode("\n", $index_create) . "\n\n";
        }
        $this->flush($sql_data);
    }
    /**
    * {@inheritdoc}
    */
    public function write_data($table_name)
    {
        if (!$this->is_initialized)
        {
            throw new extractor_not_initialized_exception();
        }
        // Grab all of the data from current table.
        $sql = "SELECT *
            FROM $table_name";
        $result = $this->db->sql_query($sql);
        $i_num_fields = pg_num_fields($result);
        $seq = '';
        for ($i = 0; $i < $i_num_fields; $i++)
        {
            $ary_type[] = pg_field_type($result, $i);
            $ary_name[] = pg_field_name($result, $i);
            $sql = "SELECT pg_get_expr(d.adbin, d.adrelid) as rowdefault
                FROM pg_attrdef d, pg_class c
                WHERE (c.relname = '{$table_name}')
                    AND (c.oid = d.adrelid)
                    AND d.adnum = " . strval($i + 1);
            $result2 = $this->db->sql_query($sql);
            if ($row = $this->db->sql_fetchrow($result2))
            {
                // Determine if we must reset the sequences
                if (strpos($row['rowdefault'], "nextval('") === 0)
                {
                    $seq .= "SELECT SETVAL('{$table_name}_seq',(select case when max({$ary_name[$i]})>0 then max({$ary_name[$i]})+1 else 1 end FROM {$table_name}));\n";
                }
            }
        }
        $this->flush("COPY $table_name (" . implode(', ', $ary_name) . ') FROM stdin;' . "\n");
        while ($row = $this->db->sql_fetchrow($result))
        {
            $schema_vals = array();
            // Build the SQL statement to recreate the data.
            for ($i = 0; $i < $i_num_fields; $i++)
            {
                $str_val = $row[$ary_name[$i]];
                if (preg_match('#char|text|bool|bytea#i', $ary_type[$i]))
                {
                    $str_val = str_replace(array("\n", "\t", "\r", "\b", "\f", "\v"), array('\n', '\t', '\r', '\b', '\f', '\v'), addslashes($str_val));
                    $str_empty = '';
                }
                else
                {
                    $str_empty = '\N';
                }
                if (empty($str_val) && $str_val !== '0')
                {
                    $str_val = $str_empty;
                }
                $schema_vals[] = $str_val;
            }
            // Take the ordered fields and their associated data and build it
            // into a valid sql statement to recreate that field in the data.
            $this->flush(implode("\t", $schema_vals) . "\n");
        }
        $this->db->sql_freeresult($result);
        $this->flush("\\.\n");
        // Write out the sequence statements
        $this->flush($seq);
    }
    /**
    * Writes closing line(s) to database backup
    *
    * @return null
    * @throws extractor_not_initialized_exception when calling this function before init_extractor()
    */
    public function write_end()
    {
        if (!$this->is_initialized)
        {
            throw new extractor_not_initialized_exception();
        }
        $this->flush("COMMIT;\n");
        parent::write_end();
    }
}