PHPPgAdmin\Controller\DataexportController::render()

Complexity

Conditions	63
Paths	6916

Size

Total Lines	314
Code Lines	198

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function render()
    {
        $lang   = $this->lang;

The assignment to $lang is dead and can be removed.

        $data   = $this->misc->getDatabaseAccessor();
        $action = $this->action;

The assignment to $action is dead and can be removed.

        set_time_limit(0);

        // if (!isset($_REQUEST['table']) && !isset($_REQUEST['query']))
        // What must we do in this case? Maybe redirect to the homepage?

        // If format is set, then perform the export
        if (isset($_REQUEST['what'])) {
            $this->prtrace("REQUEST['what']", $_REQUEST['what']);

            // Include application functions
            $this->setNoOutput(true);

            switch ($_REQUEST['what']) {
                case 'dataonly':
                    // Check to see if they have pg_dump set up and if they do, use that
                    // instead of custom dump code
                    if ($this->misc->isDumpEnabled() && ('copy' == $_REQUEST['d_format'] || 'sql' == $_REQUEST['d_format'])) {
                        $this->prtrace('DUMP ENABLED, d_format is', $_REQUEST['d_format']);
                        $dbexport_controller = new \PHPPgAdmin\Controller\DbexportController($this->getContainer());

                        return $dbexport_controller->render();
                    }
                    $this->prtrace('d_format is', $_REQUEST['d_format'], 'd_oids is', isset($_REQUEST['d_oids']));
                    $format = $_REQUEST['d_format'];
                    $oids   = isset($_REQUEST['d_oids']);

                    break;
                case 'structureonly':
                    // Check to see if they have pg_dump set up and if they do, use that
                    // instead of custom dump code
                    if ($this->misc->isDumpEnabled()) {
                        $dbexport_controller = new \PHPPgAdmin\Controller\DbexportController($this->getContainer());

                        return $dbexport_controller->render();
                    }
                    $clean = isset($_REQUEST['s_clean']);

                    break;
                case 'structureanddata':
                    // Check to see if they have pg_dump set up and if they do, use that
                    // instead of custom dump code
                    if ($this->misc->isDumpEnabled()) {
                        $dbexport_controller = new \PHPPgAdmin\Controller\DbexportController($this->getContainer());

                        return $dbexport_controller->render();
                    }
                    $format = $_REQUEST['sd_format'];
                    $clean  = isset($_REQUEST['sd_clean']);
                    $oids   = isset($_REQUEST['sd_oids']);

                    break;
            }

            // Make it do a download, if necessary
            if ('download' == $_REQUEST['output']) {
                // Set headers.  MSIE is totally broken for SSL downloading, so
                // we need to have it download in-place as plain text
                if (strstr($_SERVER['HTTP_USER_AGENT'], 'MSIE') && isset($_SERVER['HTTPS'])) {
                    header('Content-Type: text/plain');
                } else {
                    header('Content-Type: application/download');

                    if (isset($extensions[$format])) {

The variable $extensions seems to never exist and therefore isset should always be false.

The variable $format does not seem to be defined for all execution paths leading up to this point.

                        $ext = $extensions[$format];
                    } else {
                        $ext = 'txt';
                    }

                    header('Content-Disposition: attachment; filename=dump.' . $ext);
                }
            } else {
                header('Content-Type: text/plain');
            }

            if (isset($_REQUEST['query'])) {
                $_REQUEST['query'] = trim(urldecode($_REQUEST['query']));
            }

            // Set the schema search path
            if (isset($_REQUEST['search_path'])) {
                $data->setSearchPath(array_map('trim', explode(',', $_REQUEST['search_path'])));
            }

            // Set up the dump transaction
            $status = $data->beginDump();

The assignment to $status is dead and can be removed.

            // If the dump is not dataonly then dump the structure prefix
            if ('dataonly' != $_REQUEST['what']) {
                echo $data->getTableDefPrefix($_REQUEST['table'], $clean);

The variable $clean does not seem to be defined for all execution paths leading up to this point.

            }

            // If the dump is not structureonly then dump the actual data
            if ('structureonly' != $_REQUEST['what']) {
                // Get database encoding
                $dbEncoding = $data->getDatabaseEncoding();

The assignment to $dbEncoding is dead and can be removed.

                // Set fetch mode to NUM so that duplicate field names are properly returned
                $data->conn->setFetchMode(ADODB_FETCH_NUM);

                // Execute the query, if set, otherwise grab all rows from the table
                if (isset($_REQUEST['table'])) {
                    $rs = $data->dumpRelation($_REQUEST['table'], $oids);

The variable $oids does not seem to be defined for all execution paths leading up to this point.

                } else {
                    $rs = $data->conn->Execute($_REQUEST['query']);
                }

                if ('copy' == $format) {
                    $data->fieldClean($_REQUEST['table']);
                    echo "COPY \"{$_REQUEST['table']}\"";
                    if ($oids) {
                        echo ' WITH OIDS';
                    }

                    echo " FROM stdin;\n";
                    while (!$rs->EOF) {
                        $first = true;
                        //while (list($k, $v) = each($rs->fields)) {
                        foreach ($rs->fields as $k => $v) {
                            // Escape value
                            $v = $data->escapeBytea($v);

                            // We add an extra escaping slash onto octal encoded characters
                            $v = preg_replace('/\\\\([0-7]{3})/', '\\\\\1', $v);
                            if ($first) {
                                echo (is_null($v)) ? '\\N' : $v;
                                $first = false;
                            } else {
                                echo "\t", (is_null($v)) ? '\\N' : $v;
                            }
                        }
                        echo "\n";
                        $rs->moveNext();
                    }
                    echo "\\.\n";
                } elseif ('html' == $format) {
                    echo "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\r\n";
                    echo "<html xmlns=\"http://www.w3.org/1999/xhtml\">\r\n";
                    echo "<head>\r\n";
                    echo "\t<title></title>\r\n";
                    echo "\t<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />\r\n";
                    echo "</head>\r\n";
                    echo "<body>\r\n";
                    echo "<table class=\"phppgadmin\">\r\n";
                    echo "\t<tr>\r\n";
                    if (!$rs->EOF) {
                        // Output header row
                        $j = 0;
                        foreach ($rs->fields as $k => $v) {
                            $finfo = $rs->fetchField($j++);
                            if ($finfo->name == $data->id && !$oids) {
                                continue;
                            }

                            echo "\t\t<th>", $this->misc->printVal($finfo->name, true), "</th>\r\n";
                        }
                    }
                    echo "\t</tr>\r\n";
                    while (!$rs->EOF) {
                        echo "\t<tr>\r\n";
                        $j = 0;
                        foreach ($rs->fields as $k => $v) {
                            $finfo = $rs->fetchField($j++);
                            if ($finfo->name == $data->id && !$oids) {
                                continue;
                            }

                            echo "\t\t<td>", $this->misc->printVal($v, true, $finfo->type), "</td>\r\n";
                        }
                        echo "\t</tr>\r\n";
                        $rs->moveNext();
                    }
                    echo "</table>\r\n";
                    echo "</body>\r\n";
                    echo "</html>\r\n";
                } elseif ('xml' == $format) {
                    echo "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
                    echo "<data>\n";
                    if (!$rs->EOF) {
                        // Output header row
                        $j = 0;
                        echo "\t<header>\n";
                        foreach ($rs->fields as $k => $v) {
                            $finfo = $rs->fetchField($j++);
                            $name  = htmlspecialchars($finfo->name);
                            $type  = htmlspecialchars($finfo->type);
                            echo "\t\t<column name=\"{$name}\" type=\"{$type}\" />\n";
                        }
                        echo "\t</header>\n";
                    }
                    echo "\t<records>\n";
                    while (!$rs->EOF) {
                        $j = 0;
                        echo "\t\t<row>\n";
                        foreach ($rs->fields as $k => $v) {
                            $finfo = $rs->fetchField($j++);
                            $name  = htmlspecialchars($finfo->name);
                            if (!is_null($v)) {
                                $v = htmlspecialchars($v);
                            }

                            echo "\t\t\t<column name=\"{$name}\"", (is_null($v) ? ' null="null"' : ''), ">{$v}</column>\n";
                        }
                        echo "\t\t</row>\n";
                        $rs->moveNext();
                    }
                    echo "\t</records>\n";
                    echo "</data>\n";
                } elseif ('sql' == $format) {
                    $data->fieldClean($_REQUEST['table']);
                    while (!$rs->EOF) {
                        echo "INSERT INTO \"{$_REQUEST['table']}\" (";
                        $first = true;
                        $j     = 0;
                        foreach ($rs->fields as $k => $v) {
                            $finfo = $rs->fetchField($j++);
                            $k     = $finfo->name;
                            // SQL (INSERT) format cannot handle oids
                            //                        if ($k == $data->id) continue;
                            // Output field
                            $data->fieldClean($k);
                            if ($first) {
                                echo "\"{$k}\"";
                            } else {
                                echo ", \"{$k}\"";
                            }

                            if (!is_null($v)) {
                                // Output value
                                // addCSlashes converts all weird ASCII characters to octal representation,
                                // EXCEPT the 'special' ones like \r \n \t, etc.
                                $v = addcslashes($v, "\0..\37\177..\377");
                                // We add an extra escaping slash onto octal encoded characters
                                $v = preg_replace('/\\\\([0-7]{3})/', '\\\1', $v);
                                // Finally, escape all apostrophes
                                $v = str_replace("'", "''", $v);
                            }
                            if ($first) {
                                $values = (is_null($v) ? 'NULL' : "'{$v}'");
                                $first  = false;
                            } else {
                                $values .= ', ' . ((is_null($v) ? 'NULL' : "'{$v}'"));

The variable $values does not seem to be defined for all execution paths leading up to this point.

                            }
                        }
                        echo ") VALUES ({$values});\n";
                        $rs->moveNext();
                    }
                } else {
                    switch ($format) {
                        case 'tab':
                            $sep = "\t";

                            break;
                        case 'csv':
                        default:
                            $sep = ',';

                            break;
                    }
                    if (!$rs->EOF) {
                        // Output header row
                        $first = true;
                        foreach ($rs->fields as $k => $v) {
                            $finfo = $rs->fetchField($k);
                            $v     = $finfo->name;
                            if (!is_null($v)) {
                                $v = str_replace('"', '""', $v);
                            }

                            if ($first) {
                                echo "\"{$v}\"";
                                $first = false;
                            } else {
                                echo "{$sep}\"{$v}\"";
                            }
                        }
                        echo "\r\n";
                    }
                    while (!$rs->EOF) {
                        $first = true;
                        foreach ($rs->fields as $k => $v) {
                            if (!is_null($v)) {
                                $v = str_replace('"', '""', $v);
                            }

                            if ($first) {
                                echo (is_null($v)) ? '"\\N"' : "\"{$v}\"";
                                $first = false;
                            } else {
                                echo is_null($v) ? "{$sep}\"\\N\"" : "{$sep}\"{$v}\"";
                            }
                        }
                        echo "\r\n";
                        $rs->moveNext();
                    }
                }
            }

            // If the dump is not dataonly then dump the structure suffix
            if ('dataonly' != $_REQUEST['what']) {
                // Set fetch mode back to ASSOC for the table suffix to work
                $data->conn->setFetchMode(ADODB_FETCH_ASSOC);
                echo $data->getTableDefSuffix($_REQUEST['table']);
            }

            // Finish the dump transaction
            $status = $data->endDump();
        } else {
            return $this->doDefault();
        }