SequenceTrait::alterSequenceProps() - Code Metrics - Inspection of "separate Postgres.php class into traits" - HuasoFoundries/phpPgAdmin6 - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — develop ( ce7da4...69770d )

by Felipe
created 2018-04-20 13:12 UTC
SequenceTrait::alterSequenceProps() D

↳ Parent: SequenceTrait
Complexity

Conditions	16
Paths	384
Size

Total Lines	50
Code Lines	21
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	50
rs	4
c	0
b	0
f	0
cc	16
eloc	21
nc	384
nop	8
How to fix Complexity Many Parameters

<?php

/**
 * PHPPgAdmin v6.0.0-beta.40
 */

namespace PHPPgAdmin\Database;

/**
 * Common trait for sequence manipulation.
 */
trait SequenceTrait
{

    /**
     * Returns all sequences in the current database.
     *
     * @param bool $all
     *
     * @return \PHPPgAdmin\ADORecordSet A recordset
     */
    public function getSequences($all = false)
    {
        if ($all) {
            // Exclude pg_catalog and information_schema tables
            $sql = "SELECT n.nspname, c.relname AS seqname, u.usename AS seqowner
				FROM pg_catalog.pg_class c, pg_catalog.pg_user u, pg_catalog.pg_namespace n
				WHERE c.relowner=u.usesysid AND c.relnamespace=n.oid
				AND c.relkind = 'S'
				AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
				ORDER BY nspname, seqname";
        } else {
            $c_schema = $this->_schema;
            $this->clean($c_schema);
                   clean($c_schema);
            $sql = "SELECT c.relname AS seqname, u.usename AS seqowner, pg_catalog.obj_description(c.oid, 'pg_class') AS seqcomment,
				(SELECT spcname FROM pg_catalog.pg_tablespace pt WHERE pt.oid=c.reltablespace) AS tablespace
				FROM pg_catalog.pg_class c, pg_catalog.pg_user u, pg_catalog.pg_namespace n
				WHERE c.relowner=u.usesysid AND c.relnamespace=n.oid
				AND c.relkind = 'S' AND n.nspname='{$c_schema}' ORDER BY seqname";
        }

        return $this->selectSet($sql);
        return $this->/** @scrutinizer ignore-call */ selectSet($sql);
    }

    /**
     * Execute nextval on a given sequence.
     *
     * @param $sequence Sequence name
     *
     * @return int 0 if operation was successful
     */
    public function nextvalSequence($sequence)
    {
        /* This double-cleaning is deliberate */
        $f_schema = $this->_schema;
        $this->fieldClean($f_schema);
               fieldClean($f_schema);
        $this->clean($f_schema);
        $this->fieldClean($sequence);
        $this->clean($sequence);

        $sql = "SELECT pg_catalog.NEXTVAL('\"{$f_schema}\".\"{$sequence}\"')";

        return $this->execute($sql);
        return $this->/** @scrutinizer ignore-call */ execute($sql);
    }

    /**
     * Execute setval on a given sequence.
     *
     * @param $sequence  Sequence name
     * @param $nextvalue The next value
filter:
    dependency_paths: ["lib/*"]
     *
     * @return int 0 if operation was successful
     */
    public function setvalSequence($sequence, $nextvalue)
    {
        /* This double-cleaning is deliberate */
        $f_schema = $this->_schema;
        $this->fieldClean($f_schema);
        $this->clean($f_schema);
        $this->fieldClean($sequence);
        $this->clean($sequence);
        $this->clean($nextvalue);

        $sql = "SELECT pg_catalog.SETVAL('\"{$f_schema}\".\"{$sequence}\"', '{$nextvalue}')";

        return $this->execute($sql);
    }

    /**
     * Restart a given sequence to its start value.
     *
     * @param $sequence Sequence name
     *
     * @return int 0 if operation was successful
     */
    public function restartSequence($sequence)
    {
        $f_schema = $this->_schema;
        $this->fieldClean($f_schema);
        $this->fieldClean($sequence);

        $sql = "ALTER SEQUENCE \"{$f_schema}\".\"{$sequence}\" RESTART;";

        return $this->execute($sql);
    }

    /**
     * Resets a given sequence to min value of sequence.
     *
     * @param $sequence Sequence name
     *
     * @return int 0 if operation was successful
     */
    public function resetSequence($sequence)
    {
        // Get the minimum value of the sequence
        $seq = $this->getSequence($sequence);
        if ($seq->recordCount() != 1) {

            return -1;
        }

        $minvalue = $seq->fields['min_value'];

        $f_schema = $this->_schema;
        $this->fieldClean($f_schema);
        /* This double-cleaning is deliberate */
        $this->fieldClean($sequence);
        $this->clean($sequence);

        $sql = "SELECT pg_catalog.SETVAL('\"{$f_schema}\".\"{$sequence}\"', {$minvalue})";

        return $this->execute($sql);
    }

    /**
     * Returns properties of a single sequence.
     *
     * @param $sequence Sequence name
     *
     * @return \PHPPgAdmin\ADORecordSet A recordset
     */
    public function getSequence($sequence)
    {
        $c_schema = $this->_schema;
        $this->clean($c_schema);
        $c_sequence = $sequence;
        $this->fieldClean($sequence);
        $this->clean($c_sequence);

        $sql = "
			SELECT c.relname AS seqname, s.*,
				pg_catalog.obj_description(s.tableoid, 'pg_class') AS seqcomment,
				u.usename AS seqowner, n.nspname
			FROM \"{$sequence}\" AS s, pg_catalog.pg_class c, pg_catalog.pg_user u, pg_catalog.pg_namespace n
			WHERE c.relowner=u.usesysid AND c.relnamespace=n.oid
				AND c.relname = '{$c_sequence}' AND c.relkind = 'S' AND n.nspname='{$c_schema}'
				AND n.oid = c.relnamespace";

        return $this->selectSet($sql);
    }

    /**
     * Creates a new sequence.
     *
     * @param $sequence    Sequence name
     * @param $increment   The increment
     * @param $minvalue    The min value
     * @param $maxvalue    The max value
     * @param $startvalue  The starting value
     * @param $cachevalue  The cache value
     * @param $cycledvalue True if cycled, false otherwise
     *
     * @return int 0 if operation was successful
     */
    public function createSequence(
        $sequence,
        $increment,
        $minvalue,
        $maxvalue,
        $startvalue,
        $cachevalue,
        $cycledvalue
    ) {
        $f_schema = $this->_schema;
        $this->fieldClean($f_schema);
        $this->fieldClean($sequence);
        $this->clean($increment);
        $this->clean($minvalue);
        $this->clean($maxvalue);
        $this->clean($startvalue);
        $this->clean($cachevalue);

        $sql = "CREATE SEQUENCE \"{$f_schema}\".\"{$sequence}\"";
        if ($increment != '') {
            $sql .= " INCREMENT {$increment}";
        }

        if ($minvalue != '') {
            $sql .= " MINVALUE {$minvalue}";
        }

        if ($maxvalue != '') {
            $sql .= " MAXVALUE {$maxvalue}";
        }

        if ($startvalue != '') {
            $sql .= " START {$startvalue}";
        }

        if ($cachevalue != '') {
            $sql .= " CACHE {$cachevalue}";
        }

        if ($cycledvalue) {
            $sql .= ' CYCLE';
        }

        return $this->execute($sql);
    }

    /**
     * Alters a sequence.
     *
     * @param $sequence     The name of the sequence
     * @param $name         The new name for the sequence
     * @param $comment      The comment on the sequence
     * @param $owner        The new owner for the sequence
     * @param $schema       The new schema for the sequence
     * @param $increment    The increment
     * @param $minvalue     The min value
     * @param $maxvalue     The max value
     * @param $restartvalue The starting value
     * @param $cachevalue   The cache value
     * @param $cycledvalue  True if cycled, false otherwise
     * @param $startvalue   The sequence start value when issueing a restart
     *
     * @return bool|int 0 success
     */
    public function alterSequence(
        $sequence,
        $name,
        $comment,
        $owner = null,
        $schema = null,
        $increment = null,
        $minvalue = null,
        $maxvalue = null,
        $restartvalue = null,
        $cachevalue = null,
        $cycledvalue = null,
        $startvalue = null
    ) {
        $this->fieldClean($sequence);

        $data = $this->getSequence($sequence);

        if ($data->recordCount() != 1) {

            return -2;
        }

        $status = $this->beginTransaction();
        if ($status != 0) {
            $this->rollbackTransaction();

            return -1;
        }

        $status = $this->_alterSequence(
            $data,
            $name,
            $comment,
            $owner,
            $schema,
            $increment,
            $minvalue,
            $maxvalue,
            $restartvalue,
            $cachevalue,
            $cycledvalue,
            $startvalue
        );

        if ($status != 0) {
            $this->rollbackTransaction();

            return $status;
        }

        return $this->endTransaction();
    }

    /**
     * Protected method which alter a sequence
     * SHOULDN'T BE CALLED OUTSIDE OF A TRANSACTION.
     *
     * @param $seqrs        The sequence recordSet returned by getSequence()
     * @param $name         The new name for the sequence
     * @param $comment      The comment on the sequence
     * @param $owner        The new owner for the sequence
     * @param $schema       The new schema for the sequence
     * @param $increment    The increment
     * @param $minvalue     The min value
     * @param $maxvalue     The max value
     * @param $restartvalue The starting value
     * @param $cachevalue   The cache value
     * @param $cycledvalue  True if cycled, false otherwise
     * @param $startvalue   The sequence start value when issueing a restart
     *
     * @return int 0 success
     */
    protected function _alterSequence(

        $seqrs,
        $name,
        $comment,
        $owner,
        $schema,
        $increment,
        $minvalue,
        $maxvalue,
        $restartvalue,
        $cachevalue,
        $cycledvalue,
        $startvalue
    ) {
        $this->fieldArrayClean($seqrs->fields);
               fieldArrayClean($seqrs->fields);

        // Comment
        $status = $this->setComment('SEQUENCE', $seqrs->fields['seqname'], '', $comment);
        $status = $this->setComment('SEQUENCE', $seqrs->fields['seqname'], '', $comment);
        if ($status != 0) {
            return -4;
        }

        // Owner
        $this->fieldClean($owner);
        $status = $this->alterSequenceOwner($seqrs, $owner);
        if ($status != 0) {
            return -5;
        }

        // Props
        $this->clean($increment);
        $this->clean($minvalue);
        $this->clean($maxvalue);
        $this->clean($restartvalue);
        $this->clean($cachevalue);
        $this->clean($cycledvalue);
        $this->clean($startvalue);
        $status = $this->alterSequenceProps(
            $seqrs,
            $increment,
            $minvalue,
            $maxvalue,
            $restartvalue,
            $cachevalue,
            $cycledvalue,
            $startvalue
        );
        if ($status != 0) {
            return -6;
        }

        // Rename
        $this->fieldClean($name);
        $status = $this->alterSequenceName($seqrs, $name);
        if ($status != 0) {
            return -3;
        }

        // Schema
        $this->clean($schema);
        $status = $this->alterSequenceSchema($seqrs, $schema);
        if ($status != 0) {
            return -7;
        }

        return 0;
    }

    // Index functions

    /**
     * Alter a sequence's owner.
     *
     * @param $seqrs The sequence RecordSet returned by getSequence()
     * @param $owner
     *
     * @return int 0 if operation was successful
     *
     * @internal param \PHPPgAdmin\Database\The $name new owner for the sequence
     */
    public function alterSequenceOwner($seqrs, $owner)
    {
        // If owner has been changed, then do the alteration.  We are
        // careful to avoid this generally as changing owner is a
        // superuser only function.
        /* vars are cleaned in _alterSequence */
        if (!empty($owner) && ($seqrs->fields['seqowner'] != $owner)) {
            $f_schema = $this->_schema;
            $this->fieldClean($f_schema);
            $sql = "ALTER SEQUENCE \"{$f_schema}\".\"{$seqrs->fields['seqname']}\" OWNER TO \"{$owner}\"";

            return $this->execute($sql);
        }

        return 0;
    }

    /**
     * Alter a sequence's properties.
     *
     * @param $seqrs        The sequence RecordSet returned by getSequence()
     * @param $increment    The sequence incremental value
     * @param $minvalue     The sequence minimum value
     * @param $maxvalue     The sequence maximum value
     * @param $restartvalue The sequence current value
     * @param $cachevalue   The sequence cache value
     * @param $cycledvalue  Sequence can cycle ?
     * @param $startvalue   The sequence start value when issueing a restart
     *
     * @return int 0 if operation was successful
     */
    public function alterSequenceProps(
        $seqrs,
        $increment,
        $minvalue,
        $maxvalue,
        $restartvalue,
        $cachevalue,
        $cycledvalue,
        $startvalue
    ) {
        $sql = '';
        /* vars are cleaned in _alterSequence */
        if (!empty($increment) && ($increment != $seqrs->fields['increment_by'])) {
            $sql .= " INCREMENT {$increment}";
        }

        if (!empty($minvalue) && ($minvalue != $seqrs->fields['min_value'])) {
            $sql .= " MINVALUE {$minvalue}";
        }

        if (!empty($maxvalue) && ($maxvalue != $seqrs->fields['max_value'])) {
            $sql .= " MAXVALUE {$maxvalue}";
        }

        if (!empty($restartvalue) && ($restartvalue != $seqrs->fields['last_value'])) {
            $sql .= " RESTART {$restartvalue}";
        }

        if (!empty($cachevalue) && ($cachevalue != $seqrs->fields['cache_value'])) {
            $sql .= " CACHE {$cachevalue}";
        }

        if (!empty($startvalue) && ($startvalue != $seqrs->fields['start_value'])) {
            $sql .= " START {$startvalue}";
        }

        // toggle cycle yes/no
        if (!is_null($cycledvalue)) {
            $sql .= (!$cycledvalue ? ' NO ' : '') . ' CYCLE';
        }

        if ($sql != '') {
            $f_schema = $this->_schema;
            $this->fieldClean($f_schema);
            $sql = "ALTER SEQUENCE \"{$f_schema}\".\"{$seqrs->fields['seqname']}\" {$sql}";

            return $this->execute($sql);
        }

        return 0;
    }

    /**
     * Rename a sequence.
     *
     * @param $seqrs The sequence RecordSet returned by getSequence()
     * @param $name  The new name for the sequence
     *
     * @return int 0 if operation was successful
     */
    public function alterSequenceName($seqrs, $name)
    {
        /* vars are cleaned in _alterSequence */
        if (!empty($name) && ($seqrs->fields['seqname'] != $name)) {
            $f_schema = $this->_schema;
            $this->fieldClean($f_schema);
            $sql    = "ALTER SEQUENCE \"{$f_schema}\".\"{$seqrs->fields['seqname']}\" RENAME TO \"{$name}\"";
            $status = $this->execute($sql);
            if ($status == 0) {
                $seqrs->fields['seqname'] = $name;
            } else {
                return $status;
            }
        }

        return 0;
    }

    /**
     * Alter a sequence's schema.
     *
     * @param $seqrs The sequence RecordSet returned by getSequence()
     * @param $schema
     *
     * @return int 0 if operation was successful
     *
     * @internal param The $name new schema for the sequence
     */
    public function alterSequenceSchema($seqrs, $schema)
    {
        /* vars are cleaned in _alterSequence */
        if (!empty($schema) && ($seqrs->fields['nspname'] != $schema)) {
            $f_schema = $this->_schema;
            $this->fieldClean($f_schema);
            $sql = "ALTER SEQUENCE \"{$f_schema}\".\"{$seqrs->fields['seqname']}\" SET SCHEMA {$schema}";

            return $this->execute($sql);
        }

        return 0;
    }

    /**
     * Drops a given sequence.
     *
     * @param $sequence Sequence name
     * @param $cascade  True to cascade drop, false to restrict
     *
     * @return int 0 if operation was successful
     */
    public function dropSequence($sequence, $cascade)
    {
        $f_schema = $this->_schema;
        $this->fieldClean($f_schema);
        $this->fieldClean($sequence);

        $sql = "DROP SEQUENCE \"{$f_schema}\".\"{$sequence}\"";
        if ($cascade) {
            $sql .= ' CASCADE';
        }

        return $this->execute($sql);
    }

}

HuasoFoundries / phpPgAdmin6

Push — develop ( ce7da4...69770d )

SequenceTrait::alterSequenceProps() D

Complexity

Size

Duplication

Importance

How to fix Complexity Many Parameters

Long Method

Many Parameters

Duplication Side-by-Side

Filter issues like
