Database_Pdosqlite_Driver::compile_select() - Code Metrics - vijinho/kohana2-legacy - Measure and Improve Code Quality continuously with Scrutinizer

Database_Pdosqlite_Driver::compile_select() F
last analyzed 2016-08-25 15:53 UTC

↳ Parent: Database_Pdosqlite_Driver
Complexity

Conditions	11
Paths	512
Size

Total Lines	44
Code Lines	25
Duplication

Lines	44
Ratio	100 %
Importance

Changes	2
Bugs	1	Features	0
Metric	Value
cc	11
eloc	25
c	2
b	1
f	0
nc	512
nop	1
dl	44
loc	44
rs	3.1764
How to fix Complexity

<?php defined('SYSPATH') or die('No direct access allowed.');
/*
 * Class: Database_PdoSqlite_Driver
 *  Provides specific database items for Sqlite.
 *
 * Connection string should be, eg: "pdosqlite://path/to/database.db"
 *
 * Version 1.0 alpha
 *  author    - Doutu, updated by gregmac
 *  copyright - (c) BSD
 *  license   - <no>
 */

class Database_Pdosqlite_Driver extends Database_Driver
{

    // Database connection link
    protected $link;
    protected $db_config;

    /*
     * Constructor: __construct
     *  Sets up the config for the class.
     *
     * Parameters:
     *  config - database configuration
     *
     */
    public function __construct($config)
    {
        $this->db_config = $config;

        Kohana::log('debug', 'PDO:Sqlite Database Driver Initialized');
    }

    public function connect()
    {
        // Import the connect variables
        extract($this->db_config['connection']);

        try {
            $this->link = new PDO('sqlite:'.$socket.$database, $user, $pass,
                array(PDO::ATTR_PERSISTENT => $this->db_config['persistent']));

            $this->link->setAttribute(PDO::ATTR_CASE, PDO::CASE_NATURAL);
            //$this->link->query('PRAGMA count_changes=1;');

            if ($charset = $this->db_config['character_set']) {
                $this->set_charset($charset);
            }
        } catch (PDOException $e) {
            throw new Kohana_Database_Exception('database.error', $e->getMessage());
        }

        // Clear password after successful connect
        $this->db_config['connection']['pass'] = null;

        return $this->link;
    }

    /**
     * @param string $sql
     */
    public function query($sql)
    {
        try {
            $sth = $this->link->prepare($sql);
        } catch (PDOException $e) {
            throw new Kohana_Database_Exception('database.error', $e->getMessage());
        }
        return new Pdosqlite_Result($sth, $this->link, $this->db_config['object'], $sql);
    }

    public function set_charset($charset)
    {
        $this->link->query('PRAGMA encoding = '.$this->escape_str($charset));
    }

    public function escape_table($table)

    {
        if (! $this->db_config['escape']) {
            return $table;
        }

        return '`'.str_replace('.', '`.`', $table).'`';
    }

    public function escape_column($column)

    {
        if (! $this->db_config['escape']) {
            return $column;
        }

        if ($column == '*') {
            return $column;
        }

        // This matches any functions we support to SELECT.
        if (preg_match('/(avg|count|sum|max|min)\(\s*(.*)\s*\)(\s*as\s*(.+)?)?/i', $column, $matches)) {
            if (count($matches) == 3) {
                return $matches[1].'('.$this->escape_column($matches[2]).')';
            } elseif (count($matches) == 5) {
                return $matches[1].'('.$this->escape_column($matches[2]).') AS '.$this->escape_column($matches[2]);
            }
        }

        // This matches any modifiers we support to SELECT.
        if (! preg_match('/\b(?:rand|all|distinct(?:row)?|high_priority|sql_(?:small_result|b(?:ig_result|uffer_result)|no_cache|ca(?:che|lc_found_rows)))\s/i', $column)) {
            if (stripos($column, ' AS ') !== false) {
                // Force 'AS' to uppercase
                $column = str_ireplace(' AS ', ' AS ', $column);

                // Runs escape_column on both sides of an AS statement
                $column = array_map(array($this, __FUNCTION__), explode(' AS ', $column));

                // Re-create the AS statement
                return implode(' AS ', $column);
            }

            return preg_replace('/[^.*]+/', '`$0`', $column);
        }

        $parts = explode(' ', $column);
        $column = '';

        for ($i = 0, $c = count($parts); $i < $c; $i++) {
            // The column is always last
            if ($i == ($c - 1)) {
                $column .= preg_replace('/[^.*]+/', '`$0`', $parts[$i]);
            } else { // otherwise, it's a modifier
                $column .= $parts[$i].' ';
            }
        }
        return $column;
    }

    public function limit($limit, $offset = 0)
    {
        return 'LIMIT '.$offset.', '.$limit;
    }

    public function compile_select($database)

    {
        $sql = ($database['distinct'] == true) ? 'SELECT DISTINCT ' : 'SELECT ';
        $sql .= (count($database['select']) > 0) ? implode(', ', $database['select']) : '*';

        if (count($database['from']) > 0) {
            $sql .= "\nFROM ";
            $sql .= implode(', ', $database['from']);
        }

        if (count($database['join']) > 0) {
            foreach ($database['join'] as $join) {
                $sql .= "\n".$join['type'].'JOIN '.implode(', ', $join['tables']).' ON '.$join['conditions'];
            }
        }

        if (count($database['where']) > 0) {
            $sql .= "\nWHERE ";
        }

        $sql .= implode("\n", $database['where']);

        if (count($database['groupby']) > 0) {
            $sql .= "\nGROUP BY ";
            $sql .= implode(', ', $database['groupby']);
        }

        if (count($database['having']) > 0) {
            $sql .= "\nHAVING ";
            $sql .= implode("\n", $database['having']);
        }

        if (count($database['orderby']) > 0) {
            $sql .= "\nORDER BY ";
            $sql .= implode(', ', $database['orderby']);
        }

        if (is_numeric($database['limit'])) {
            $sql .= "\n";
            $sql .= $this->limit($database['limit'], $database['offset']);
        }

        return $sql;
    }

    public function escape_str($str)
    {
        if (! $this->db_config['escape']) {
            return $str;
        }

        if (function_exists('sqlite_escape_string')) {
            $res = sqlite_escape_string($str);
        } else {
            $res = str_replace("'", "''", $str);
        }
        return $res;
    }

    public function list_tables()
    {
        $sql = "SELECT `name` FROM `sqlite_master` WHERE `type`='table' ORDER BY `name`;";
        try {
            $result = $this->query($sql)->result(false, PDO::FETCH_ASSOC);
            $tables = array();
            foreach ($result as $row) {
                $tables[] = current($row);
            }
        } catch (PDOException $e) {
            throw new Kohana_Database_Exception('database.error', $e->getMessage());
        }
        return $tables;
    }

    public function show_error()
    {
        $err = $this->link->errorInfo();
        return isset($err[2]) ? $err[2] : 'Unknown error!';
    }

    public function list_fields($table, $query = false)
    {
        static $tables;
        if (is_object($query)) {
            if (empty($tables[$table])) {
                $tables[$table] = array();

                foreach ($query->result() as $row) {
                    $tables[$table][] = $row->name;
                }
            }

            return $tables[$table];
        } else {
            $result = $this->link->query('PRAGMA table_info('.$this->escape_table($table).')');

            foreach ($result as $row) {
                $tables[$table][$row['name']] = $this->sql_type($row['type']);
            }

            return $tables[$table];
        }
    }

    public function field_data($table)
    {
        Kohana::log('error', 'This method is under developing');
    }
    /**
     * Version number query string
     *
     * @access	public
     * @return	string
     */
    public function version()
    {
        return $this->link->getAttribute(constant("PDO::ATTR_SERVER_VERSION"));
    }
} // End Database_PdoSqlite_Driver Class

/*
 * PDO-sqlite Result
 */
class Pdosqlite_Result extends Database_Result
{

    // Data fetching types
    protected $fetch_type  = PDO::FETCH_OBJ;
    protected $return_type = PDO::FETCH_ASSOC;

    /**
     * Sets up the result variables.
     *
     * @param  resource  query result
     * @param  resource  database link
     * @param  boolean   return objects or arrays
     * @param  string    SQL query that was run
     * @param PDOStatement $result
     * @param PDO $link
     */
    public function __construct($result, $link, $object = true, $sql)
    {
        if (is_object($result) or $result = $link->prepare($sql)) {
            // run the query. Return true if success, false otherwise
            if (! $result->execute()) {
                // Throw Kohana Exception with error message. See PDOStatement errorInfo() method
                $arr_infos = $result->errorInfo();
                throw new Kohana_Database_Exception('database.error', $arr_infos[2]);
            }

            if (preg_match('/^SELECT|PRAGMA|EXPLAIN/i', $sql)) {
                $this->result = $result;
                $this->current_row = 0;

                $this->total_rows = $this->sqlite_row_count();

                $this->fetch_type = ($object === true) ? PDO::FETCH_OBJ : PDO::FETCH_ASSOC;
            } elseif (preg_match('/^DELETE|INSERT|UPDATE/i', $sql)) {
                $this->insert_id  = $link->lastInsertId();

                $this->total_rows = $result->rowCount();
            }
        } else {
            // SQL error
            throw new Kohana_Database_Exception('database.error', $link->errorInfo().' - '.$sql);
        }

        // Set result type
        $this->result($object);

        // Store the SQL
        $this->sql = $sql;
    }

    private function sqlite_row_count()
    {
        $count = 0;
        while ($this->result->fetch()) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            $count++;
        }

        // The query must be re-fetched now.
        $this->result->execute();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        return $count;
    }

    /*
     * Destructor: __destruct
     *  Magic __destruct function, frees the result.
     */
    public function __destruct()
    {
        if (is_object($this->result)) {
            $this->result->closeCursor();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            $this->result = null;
        }
    }

    public function result($object = true, $type = PDO::FETCH_BOTH)
    {
        $this->fetch_type = (bool) $object ? PDO::FETCH_OBJ : PDO::FETCH_BOTH;

        if ($this->fetch_type == PDO::FETCH_OBJ) {
            $this->return_type = (is_string($type) and Kohana::auto_load($type)) ? $type : 'stdClass';
        } else {
            $this->return_type = $type;
        }

        return $this;
    }

    public function as_array($object = null, $type = PDO::FETCH_ASSOC)
    {
        return $this->result_array($object, $type);
    }

    public function result_array($object = null, $type = PDO::FETCH_ASSOC)
    {
        $rows = array();

        if (is_string($object)) {
            $fetch = $object;
        } elseif (is_bool($object)) {
            if ($object === true) {
                $fetch = PDO::FETCH_OBJ;

                // NOTE - The class set by $type must be defined before fetching the result,
                // autoloading is disabled to save a lot of stupid overhead.
                $type = (is_string($type) and Kohana::auto_load($type)) ? $type : 'stdClass';
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            } else {
                $fetch = PDO::FETCH_OBJ;
            }
        } else {
            // Use the default config values
            $fetch = $this->fetch_type;

            if ($fetch == PDO::FETCH_OBJ) {
                $type = (is_string($type) and Kohana::auto_load($type)) ? $type : 'stdClass';
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            }
        }
        try {
            while ($row = $this->result->fetch($fetch)) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                $rows[] = $row;
            }
        } catch (PDOException $e) {
            throw new Kohana_Database_Exception('database.error', $e->getMessage());
            return false;
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
        }
        return $rows;
    }

    public function list_fields()
    {
        $field_names = array();
        for ($i = 0, $max = $this->result->columnCount(); $i < $max; $i++) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            $info = $this->result->getColumnMeta($i);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            $field_names[] = $info['name'];
        }
        return $field_names;
    }

    /**
     * @param integer $offset
     */
    public function seek($offset)
    {
        // To request a scrollable cursor for your PDOStatement object, you must
        // set the PDO::ATTR_CURSOR attribute to PDO::CURSOR_SCROLL when you
        // prepare the statement.
        Kohana::log('error', get_class($this).' does not support scrollable cursors, '.__FUNCTION__.' call ignored');

        return false;
    }

    public function offsetGet($offset)
    {
        try {
            return $this->result->fetch($this->fetch_type, PDO::FETCH_ORI_ABS, $offset);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        } catch (PDOException $e) {
            throw new Kohana_Database_Exception('database.error', $e->getMessage());
        }
    }

    public function rewind()
    {
        // Same problem that seek() has, see above.
        return $this->seek(0);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }
} // End PdoSqlite_Result Class

Database_Pdosqlite_Driver::compile_select() F
last analyzed 2016-08-25 15:53 UTC

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

vijinho / kohana2-legacy

Database_Pdosqlite_Driver::compile_select() F last analyzed 2016-08-25 15:53 UTC

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

Database_Pdosqlite_Driver::compile_select() F
last analyzed 2016-08-25 15:53 UTC
