Phossa2\Query\Traits\Clause\JoinTrait

Complexity

Total Complexity

26

Size/Duplication

Total Lines	227
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	join()	0	4	1
A	leftJoin()	0	4	1
A	rightJoin()	0	4	1
A	joinRaw()	0	4	1
B	realJoin()	0	24	4
A	fixJoinTable()	0	10	3
A	fixOnClause()	0	10	4
A	buildJoin()	0	19	3
A	buildJoinTable()	0	6	1
A	buildJoinOn()	0	17	2
A	getFirstTableAlias()	0	12	3
A	getSecondTableAlias()	0	8	2
	isRaw()	0	1	?
	getClause()	0	1	?
	flatSettings()	0	1	?
	quoteItem()	0	5	?
	quoteAlias()	0	1	?
	joinClause()	0	6	?

<?php
/**
 * Phossa Project
 *
 * PHP version 5.4
 *
 * @category  Library
 * @package   Phossa2\Query
 * @copyright Copyright (c) 2016 phossa.com
 * @license   http://mit-license.org/ MIT License
 * @link      http://www.phossa.com/
 */
/*# declare(strict_types=1); */

namespace Phossa2\Query\Traits\Clause;

use Phossa2\Query\Interfaces\Clause\JoinInterface;
use Phossa2\Query\Interfaces\ExpressionInterface;

/**
 * JoinTrait
 *
 * Implementation of JoinInterface
 *
 * @package Phossa2\Query
 * @author  Hong Zhang <phossa@126.com>
 * @see     JoinInterface
 * @version 2.0.0
 * @since   2.0.0 added
 */
trait JoinTrait
{
    /**
     * {@inheritDoc}
     */
    public function join($secondTable, $onClause = '', $firstTable = '')
    {
        return $this->realJoin('INNER JOIN', $secondTable, $onClause, $firstTable);
    }

    /**
     * {@inheritDoc}
     */
    public function leftJoin($secondTable, $onClause = '', $firstTable = '')
    {
        return $this->realJoin('LEFT JOIN', $secondTable, $onClause, $firstTable);
    }

    /**
     * {@inheritDoc}
     */
    public function rightJoin($secondTable, $onClause = '', $firstTable = '')
    {
        return $this->realJoin('RIGHT JOIN', $secondTable, $onClause, $firstTable);
    }

    /**
     * {@inheritDoc}
     */
    public function joinRaw(/*# string */ $joinType, /*# string */ $rawString)
    {
        return $this->realJoin($joinType, $rawString, '', '', true);
    }

    /**
     * The real join
     *
     * @param  string $joinType
     * @param  string|string[]|SelectStatementInterface $secondTable
     * @param  string|string[]|ExpressionInterface $onClause
     * @param  string $firstTable
     * @param  bool $rawMode
     * @return $this
     * @access protected
     */
    protected function realJoin(
        /*# string */ $joinType,
        $secondTable,
        $onClause = '',
        $firstTable = '',
        /*# bool */ $rawMode = false
    ) {
        // totally raw
        if ($rawMode || '' === $onClause) {
            $rawMode = true;
            $alias = 0; // no alias
        }

        // fix table, alias, on clause
        if (!$rawMode) {
            $onClause = $this->fixOnClause($onClause);
            list($secondTable, $alias) = $this->fixJoinTable($secondTable);
        }

        $clause = &$this->getClause('JOIN');
        $clause[] = [$rawMode, $joinType, $secondTable, $alias, $onClause, $firstTable];

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

        return $this;
    }

    /**
     * Fix join table
     *
     * @param  string|string[]|SelectStatementInterface $table
     * @return array [table, alias]
     * @access protected
     */
    protected function fixJoinTable($table)
    {
        if (is_object($table)) {
            return [$table, uniqid()]; // need an alias
        } elseif (is_string($table)) {
            return [$table, 0]; // alias set 0
        } else {
            return $table; // array
        }
    }

    /**
     * Fix 'ON' clause
     *
     * @param  mixed $onClause
     * @return array|ExpressionInterface
     * @access protected
     */
    protected function fixOnClause($onClause)
    {
        if (is_string($onClause)) {
            return [$onClause, '=', $onClause];
        } elseif (is_array($onClause) && !isset($onClause[2])) {
            return [$onClause[0], '=', $onClause[1]];
        } else {
            return $onClause;
        }
    }

    /**
     * Build join
     *
     * @param  string $prefix
     * @param  array $settings
     * @return string
     * @access protected
     */
    protected function buildJoin(
        /*# string */ $prefix,

The parameter $prefix is not used and could be removed.

        array $settings
    )/*# : string */ {
        $string = '';
        $clause = &$this->getClause('JOIN');
        foreach ($clause as $cls) {
            $result = [];
            $prefix = $cls[1]; // join type
            if ($cls[0]) { // raw mode
                $result[] = $cls[2];
            } else {
                $result[] = $this->buildJoinTable($cls, $settings);
                $result[] = $this->buildJoinOn($cls, $settings);
            }
            $string .= $this->joinClause($prefix, '', $result, $settings);
        }
        return $string;
    }

    /**
     * Build TABLE part
     *
     * @param  array $cls
     * @param  array $settings
     * @return string
     * @access protected
     */
    protected function buildJoinTable(array $cls, array $settings)/*# : string */
    {
        $table = $cls[2];
        $alias = $cls[3];
        return $this->quoteItem($table, $settings) . $this->quoteAlias($alias, $settings);
    }

    /**
     * Build ON part
     *
     * @param  array $cls
     * @param  array $settings
     * @return string
     * @access protected
     */
    protected function buildJoinOn(array $cls, array $settings)/*# : string */
    {
        $on = $cls[4];
        $res = ['ON'];

        if (is_object($on)) {
            $res[] = $on->getStatement($settings);
        } else {
            // first
            $res[] = $this->quote($this->getFirstTableAlias($cls) . $on[0], $settings);

It seems like quote() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            // operator
            $res[] = $on[1];
            // second
            $res[] = $this->quote($this->getSecondTableAlias($cls) . $on[2], $settings);

It seems like quote() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }
        return join(' ', $res);
    }

    /**
     * Get first table alias
     *
     * @param  array $cls
     * @return string
     * @access protected
     */
    protected function getFirstTableAlias(array $cls)/*# : string */
    {
        // first table specified
        if (!empty($cls[5])) {
            return $cls[5] . '.';
        } else {
            $tables = &$this->getClause('FROM');
            reset($tables);
            $alias = key($tables);
            return (is_int($alias) ? $tables[$alias][0] : $alias) . '.';
        }
    }

    /**
     * Get second table alias
     *
     * @param  array $cls
     * @return string
     * @access protected
     */
    protected function getSecondTableAlias(array $cls)/*# : string */
    {
        $alias = $cls[3];
        if (!is_string($alias)) {
            $alias = $cls[2];
        }
        return $alias . '.';
    }

    abstract protected function isRaw($str, /*# bool */ $rawMode)/*# : bool */;
    abstract protected function &getClause(/*# string */ $clauseName)/*# : array */;
    abstract protected function flatSettings(array $settings)/*# : array */;
    abstract protected function quoteItem(
        $item,
        array $settings,
        /*# bool */ $rawMode = false
    )/*# : string */;
    abstract protected function quoteAlias($alias, array $settings)/*# : string */;
    abstract protected function joinClause(
        /*# : string */ $prefix,
        /*# : string */ $seperator,
        array $clause,
        array $settings
    )/*# : string */;
}