Grammar::wrap() - Code Metrics - FramyFramework/Framy - Measure and Improve Code Quality continuously with Scrutinizer

Grammar::wrap() B
last analyzed 2020-02-14 22:39 UTC

↳ Parent: Grammar
Complexity

Conditions	7
Paths	6
Size

Total Lines	35
Code Lines	15
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	7
eloc	15
c	1
b	0
f	0
nc	6
nop	2
dl	0
loc	35
rs	8.8333
<?php
/**
 * Framy Framework
 *
 * @copyright Copyright Framy
 * @Author  Marco Bier <[email protected]>
 */

namespace app\framework\Component\Database\Query\Grammars;

use app\framework\Component\Database\Query\Builder;
use app\framework\Component\Database\Query\Expression;

class Grammar
{
    /**
     * The grammar table prefix.
     *
     * @var string
     */
    protected $tablePrefix = '';

    /**
     * The components that make up a select clause.
     *
     * @var array
     */
    protected $selectComponents = [
        'aggregate',
        'columns',
        'from',
        'joins',
        'wheres',
        'groups',
        'havings',
        'orders',
        'limit',
        'offset',
        'unions',
        'lock',
    ];

    /**
     * Compile a select query into SQL.
     *
     * @param  Builder $query
     * @return string
     */
    public function compileSelect(Builder $query)
    {
        // If the query does not have any columns set, we'll set the columns to the
        // * character to just get all of the columns from the database. Then we
        // can build the query and concatenate all the pieces together as one.
        $original = $query->columns;

        if (is_null($query->columns)) {

            $query->columns = ['*'];
        }

        // To compile the query, we'll spin through each component of the query and
        // see if that component exists. If it does we'll just call the compiler
        // function for the component which is responsible for making the SQL.
        $sql = trim($this->concatenate(
            $this->compileComponents($query))
        );

        $query->columns = $original;

        return $sql;
    }

    /**
     * Compile an insert and get ID statement into SQL.
     *
     * @param  Builder  $query
     * @param  array   $values
     * @return string
     */
    public function compileInsertGetId(Builder $query, $values)
    {
        return $this->compileInsert($query, $values);
    }

    /**
     * Compile a insert query into SQL
     *
     * @param Builder $query
     * @param array $values
     * @return string
     */
    public function compileInsert(Builder $query, array $values): string
    {
        // Essentially we will force every insert to be treated as a batch insert which
        // simply makes creating the SQL easier for us since we can utilize the same
        // basic routine regardless of an amount of records given to us to insert.
        $table = $this->wrapTable($query->from);

        if (! is_array(reset($values))) {
            $values = [$values];
        }

        $columns = $this->columnize(array_keys(reset($values)));

        // We need to build a list of parameter place-holders of values that are bound
        // to the query. Each insert should have the exact same amount of parameter
        // bindings so we will loop through the record and parameterize them all.
        $parameters = [];

        foreach ($values as $record) {
            $parameters[] = '('.$this->parameterize($record).')';
        }

        $parameters = implode(', ', $parameters);

        return "insert into $table ($columns) values $parameters";
    }

    /**
     * Compile a update query into SQL
     *
     * @param Builder $query
     * @param array $values
     * @return string
     */
    public function compileUpdate(Builder $query, array $values): string
    {
        $table = $this->wrapTable($query->from);

        // Each one of the columns in the update statements needs to be wrapped in the
        // keyword identifiers, also a place-holder needs to be created for each of
        // the values in the list of bindings so we can make the sets statements.
        $columns = [];

        foreach ($values as $key => $value) {
            $columns[] = $this->wrap($key)." = ?";
        }

        $columns = implode(', ', $columns);

        // Of course, update queries may also be constrained by where clauses so we'll
        // need to compile the where clauses and attach it to the query so only the
        // intended records are updated by the SQL statements we generate to run.
        $where = $this->compileWheres($query);

        return "update {$table} set $columns $where";
    }

    /**
     * Compile a delete statement into SQL.
     *
     * @param  Builder  $query
     * @return string
     */
    public function compileDelete(Builder $query)
    {
        $table = $this->wrapTable($query->from);

        $where = is_array($query->wheres) ? $this->compileWheres($query) : '';


        return trim("delete from $table ".$where);
    }

    /**
     * Compile a truncate table statement into SQL.
     *
     * @param  Builder  $query
     * @return array
     */
    public function compileTruncate(Builder $query)
    {
        return ['truncate '.$this->wrapTable($query->from) => []];
    }

    /**
     * Compile the components necessary for a select clause.
     *
     * @param  Builder $query
     * @return array
     */
    protected function compileComponents(Builder $query)
    {
        $sql = [];

        foreach ($this->selectComponents as $component) {
            // To compile the query, we'll spin through each component of the query and
            // see if that component exists. If it does we'll just call the compiler
            // function for the component which is responsible for making the SQL.
            if (!is_null($query->$component)) {
                $method = 'compile' . ucfirst($component);

                $sql[$component] = $this->$method($query, $query->$component);
            }
        }

        return $sql;
    }

    /**
     * Compile the "select *" portion of the query.
     *
     * @param  Builder $query
     * @param  array $columns
     * @return string|null
     */
    protected function compileColumns(Builder $query, $columns)
    {
        // If the query is actually performing an aggregating select, we will let that
        // compiler handle the building of the select clauses, as it will need some
        // more syntax that is best handled by that function to keep things neat.
        if (!is_null($query->aggregate)) {

            return null;
        }

        $select = $query->distinct ? 'select distinct ' : 'select ';

        return $select . $this->columnize($columns);
    }

    /**
     * Compile the "from" portion of the query.
     *
     * @param  Builder $query
     * @param  string $table
     * @return string
     */
    protected function compileFrom(Builder $query, $table)
    {
        return 'from ' . $this->wrapTable($table);
    }

    /**
     * Compile the "where" portions of the query.
     *
     * @param  Builder  $query
     * @return string
     */
    protected function compileWheres(Builder $query)
    {
        $sql = [];

        if (is_null($query->wheres)) {

            return '';
        }

        // Each type of where clauses has its own compiler function which is responsible
        // for actually creating the where clauses SQL. This helps keep the code nice
        // and maintainable since each clause has a very small method that it uses.
        foreach ($query->wheres as $where) {
            $method = "where{$where['type']}";

            $sql[] = $where['boolean'].' '.$this->$method($query, $where);
        }

        // If we actually have some where clauses, we will strip off the first boolean
        // operator, which is added by the query builders for convenience so we can
        // avoid checking for the first clauses in each of the compilers methods.
        if (count($sql) > 0) {
            $sql = implode(' ', $sql);

            return 'where '.$this->removeLeadingBoolean($sql);
        }

        return '';
    }

    /**
     * Compile the "order by" portions of the query.
     *
     * @param  Builder  $query
     * @param  array  $orders
     * @return string
     */
    protected function compileOrders(Builder $query, $orders)
    {
        return 'order by '.implode(', ', $orders[0])." ".$orders[1];
    }

    /**
     * Compile the "limit" portions of the query.
     *
     * @param  Builder  $query
     * @param  int  $limit
     * @return string
     */
    protected function compileLimit(Builder $query, $limit)
    {
        return 'limit '.(int) $limit;
    }

    /**
     * Compile an aggregated select clause.
     *
     * @param  Builder  $query
     * @param  array  $aggregate
     * @return string
     */
    protected function compileAggregate(Builder $query, $aggregate)
    {
        $column = $this->columnize($aggregate['columns']);

        // If the query has a "distinct" constraint and we're not asking for all columns
        // we need to prepend "distinct" onto the column name so that the query takes
        // it into account when it performs the aggregating operations on the data.
        if ($query->distinct && $column !== '*') {
            $column = 'distinct '.$column;
        }

        return 'select '.$aggregate['function'].'('.$column.') as aggregate';
    }

    /**
     * Compile an exists statement into SQL.
     *
     * @param Builder $query
     * @return string
     */
    public function compileExists(Builder $query)
    {
        $select = $this->compileSelect($query);

        return "select exists($select) as {$this->wrap('exists')}";
    }

    public function compileOffset(Builder $query)
    {
        return "offset ".$query->offset;
    }

    /**
     * Compile a basic where clause.
     * TODO: probably only temporarily so figure out if this is fine
     *
     * @param  Builder  $query
     * @param  array  $where
     * @return string
     */
    protected function whereBasic(Builder $query, $where)
    {
//        $value = $this->parameter($where['value']);
        return $this->wrap($where['column']).' '.$where['operator'].' ?'; //.$value;
    }

    /**
     * Compile a "between" where clause.
     *
     * @param  Builder  $query
     * @param  array  $where
     * @return string
     */
    protected function whereBetween(Builder $query, $where)
    {
        $between = $where['not'] ? 'not between' : 'between';

        return $this->wrap($where['column']).' '.$between.' ? and ?';
    }

    /**
     * Compile a "in" where clause.
     *
     * @param Builder $query
     * @param $where
     * @return string
     */
    protected function whereIn(Builder $query, $where)
    {
        $in = $where['not'] ? 'not in' : 'in';

        $values = " (";

        $count = count($query->getBindings());
        for ($i = 1; $i <= $count; $i++) {
            $append = ($count >  $i) ? "," : "";
            $values .= "?" . $append;
        }
        $values .= ")";

        return $this->wrap($where['column']). ' '.$in.$values;
    }

    /**
     * Compile a "null" where clause.
     *
     * @param Builder $query
     * @param $where
     * @return string
     */
    protected function whereNull(Builder $query, $where)
    {
        $null = $where['not'] ? 'is not null' : 'is null';

        return $this->wrap($where['column']). ' '.$null;
    }

    /**
     * Compile a "date" where clause.
     *
     * @param Builder $builder
     * @param $where
     * @return string
     */
    protected function whereDate(Builder $builder, $where)
    {
        return $this->wrap($where['column']).$where['operator'].$where['value'];
    }

    /**
     * Compile a "date year" where clause.
     *
     * @param Builder $builder
     * @param $where
     * @return string
     */
    protected function whereYear(Builder $builder, $where)
    {
        return "year(".$this->wrap($where['column']).")".$where['operator'].$where['value'];
    }

    /**
     * Compile a "date month" where clause.
     *
     * @param Builder $builder
     * @param $where
     * @return string
     */
    protected function whereMonth(Builder $builder, $where)
    {
        return "month(".$this->wrap($where['column']).")".$where['operator'].$where['value'];
    }

    /**
     * Compile a "date day" where clause.
     *
     * @param Builder $builder
     * @param $where
     * @return string
     */
    protected function whereDay(Builder $builder, $where)
    {
        return "day(".$this->wrap($where['column']).")".$where['operator'].$where['value'];
    }

    /**
     * Concatenate an array of segments, removing empties.
     *
     * @param  array $segments
     * @return string
     */
    protected function concatenate($segments)
    {
        return implode(' ', array_filter($segments, function ($value) {
            return (string)$value !== '';
        }));
    }

    /**
     * Convert an array of column names into a delimited string.
     *
     * @param  array $columns
     * @return string
     */
    public function columnize(array $columns)
    {
        return implode(', ', array_map([$this, 'wrap'], $columns));
    }

    /**
     * Create query parameter place-holders for an array.
     *
     * @param  array   $values
     * @return string
     */
    public function parameterize(array $values)
    {
        $val = array_map([$this, 'parameter'], $values);

        foreach ($val as $key => $item) {
            $val[$key] = $this->quoteString($item);
        }

        return implode(', ', $val);
    }

    public function parameterizeForUpdate(array $columns, array $values)
    {
        $queryValues = [];

        $count = count($values);
        for ($i = 0; $i < $count; $i++) {
            $queryValues[] = $columns[$i]."=".$this->quoteString(array_values($values)[$i]);
        }

        return implode(", ", $queryValues);
    }

    /**
     * Get the appropriate query parameter place-holder for a value.
     *
     * @param  mixed   $value
     * @return string
     */
    public function parameter($value)
    {
        return $this->isExpression($value) ? $this->getValue($value) : $value;
    }

    /**
     * Quote the given string literal.
     *
     * @param  string|array  $value
     * @return string
     */
    public function quoteString($value)
    {
        if (is_array($value)) {
            return implode(', ', array_map([$this, __FUNCTION__], $value));
        }

        return "'$value'";
    }

    /**
     * Wrap a table in keyword identifiers.
     *
     * @param  Expression|string $table
     * @return string
     */
    public function wrapTable($table)
    {
        if (!$this->isExpression($table)) {
            return $this->wrap($this->tablePrefix . $table, true);
        }

        return $this->getValue($table);
        return $this->getValue(/** @scrutinizer ignore-type */ $table);
    }

    /**
     * Wrap a value in keyword identifiers.
     *
     * @param  Expression|string $value
     * @param  bool $prefixAlias
     * @return string
     */
    public function wrap($value, $prefixAlias = false)
    {
        if ($this->isExpression($value)) {
            return $this->getValue($value);
            return $this->getValue(/** @scrutinizer ignore-type */ $value);
        }

        // If the value being wrapped has a column alias we will need to separate out
        // the pieces so we can wrap each of the segments of the expression on it
        // own, and then joins them both back together with the "as" connector.
        if (strpos(strtolower($value), ' as ') !== false) {
            $segments = explode(' ', $value);

            if ($prefixAlias) {
                $segments[2] = $this->tablePrefix.$segments[2];
            }

            return $this->wrap($segments[0]).' as '.$this->wrapValue($segments[2]);
        }

        $wrapped = [];

        $segments = explode('.', $value);

        // If the value is not an aliased table expression, we'll just wrap it like
        // normal, so if there is more than one segment, we will wrap the first
        // segments as if it was a table and the rest as just regular values.
        foreach ($segments as $key => $segment) {
            if ($key == 0 && count($segments) > 1) {
                $wrapped[] = $this->wrapTable($segment);
            } else {
                $wrapped[] = $this->wrapValue($segment);
            }
        }

        return implode('.', $wrapped);
    }

    /**
     * Wrap a value that has an alias.
     *
     * @param  string $value
     * @param  bool $prefixAlias
     * @return string
     */
    protected function wrapAliasedValue($value, $prefixAlias = false)
    {
        $segments = preg_split('/\s+as\s+/i', $value);

        // If we are wrapping a table we need to prefix the alias with the table prefix
        // as well in order to generate proper syntax. If this is a column of course
        // no prefix is necessary. The condition will be true when from wrapTable.
        if ($prefixAlias) {
            $segments[1] = $this->tablePrefix . $segments[1];
        }

        return $this->wrap(
                $segments[0]) . ' as ' . $this->wrapValue($segments[1]
            );
    }

    /**
     * Wrap the given value segments.
     *
     * @param  array $segments
     * @return string
     */
    protected function wrapSegments($segments)
    {
        return arr($segments)->map(function ($segment, $key) use ($segments) {
            return $key == 0 && count($segments) > 1
                ? $this->wrapTable($segment)
                : $this->wrapValue($segment);
        })->implode('.');
    }

    /**
     * Wrap a single string in keyword identifiers.
     *
     * @param  string $value
     * @return string
     */
    protected function wrapValue($value)
    {
        if ($value !== '*') {
            return '`' . str_replace('"', '""', $value) . '`';
        }

        return $value;
    }

    /**
     * Get the value of a raw expression.
     *
     * @param  Expression $expression
     * @return string
     */
    public function getValue($expression)
    {
        return $expression->getValue();
    }

    /**
     * Determine if the given value is a raw expression.
     *
     * @param  mixed $value
     * @return bool
     */
    public function isExpression($value)
    {
        return $value instanceof Expression;
    }

    /**
     * Remove the leading boolean from a statement.
     *
     * @param  string  $value
     * @return string
     */
    protected function removeLeadingBoolean($value)
    {
        return preg_replace('/and |or /i', '', $value, 1);
    }
}

FramyFramework / Framy

Grammar::wrap() B last analyzed 2020-02-14 22:39 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Grammar::wrap() B
last analyzed 2020-02-14 22:39 UTC
