kalanis\kw_mapper\Search\Connector\AConnector

Complexity

Total Complexity

38

Size/Duplication

Total Lines	405
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	between()	0	6	1
A	useAnd()	0	4	1
A	regexp()	0	10	1
A	notExact()	0	10	1
A	like()	0	10	1
A	from()	0	10	2
A	exact()	0	10	1
A	offset()	0	4	1
A	groupBy()	0	5	1
A	notNull()	0	9	1
A	null()	0	9	1
A	useOr()	0	4	1
A	orderBy()	0	5	1
A	notLike()	0	10	1
A	in()	0	10	1
A	limit()	0	4	1
A	to()	0	10	2
A	notIn()	0	10	1
A	correctColumn()	0	8	3
A	childNotExist()	0	10	1
C	child()	0	54	12
A	correctTable()	0	3	2

<?php

namespace kalanis\kw_mapper\Search\Connector;


use kalanis\kw_mapper\Interfaces\IQueryBuilder;
use kalanis\kw_mapper\MapperException;
use kalanis\kw_mapper\Mappers\ForeignKey;
use kalanis\kw_mapper\Records\ARecord;
use kalanis\kw_mapper\Storage;


/**
 * Class AConnector
 * @package kalanis\kw_mapper\Search
 * Connect real sources into search engine
 */
abstract class AConnector
{
    use Database\TRecordsInJoins;

    /** @var ARecord */
    protected $basicRecord = null;
    /** @var Storage\Shared\QueryBuilder */
    protected $queryBuilder = null;

    /**
     * @param string $table
     * @param string $column
     * @param string $value
     * @throws MapperException
     * @return $this
     */
    public function notExact(string $table, string $column, $value): self
    {
        $aTable = $this->correctTable($table);
        $this->queryBuilder->addCondition(
            $aTable,
            $this->correctColumn($aTable, $column),
            IQueryBuilder::OPERATION_NEQ,
            $value
        );
        return $this;
    }

    /**
     * @param string $table
     * @param string $column
     * @param string $value
     * @throws MapperException
     * @return $this
     */
    public function exact(string $table, string $column, $value): self
    {
        $aTable = $this->correctTable($table);
        $this->queryBuilder->addCondition(
            $aTable,
            $this->correctColumn($aTable, $column),
            IQueryBuilder::OPERATION_EQ,
            $value
        );
        return $this;
    }

    /**
     * @param string $table
     * @param string $column
     * @param string $value
     * @param bool $equals
     * @throws MapperException
     * @return $this
     */
    public function from(string $table, string $column, $value, bool $equals = true): self
    {
        $aTable = $this->correctTable($table);
        $this->queryBuilder->addCondition(
            $aTable,
            $this->correctColumn($aTable, $column),
            $equals ? IQueryBuilder::OPERATION_GTE : IQueryBuilder::OPERATION_GT,
            $value
        );
        return $this;
    }

    /**
     * @param string $table
     * @param string $column
     * @param string $value
     * @param bool $equals
     * @throws MapperException
     * @return $this
     */
    public function to(string $table, string $column, $value, bool $equals = true): self
    {
        $aTable = $this->correctTable($table);
        $this->queryBuilder->addCondition(
            $aTable,
            $this->correctColumn($aTable, $column),
            $equals ? IQueryBuilder::OPERATION_LTE : IQueryBuilder::OPERATION_LT,
            $value
        );
        return $this;
    }

    /**
     * @param string $table
     * @param string $column
     * @param string $value
     * @throws MapperException
     * @return $this
     */
    public function like(string $table, string $column, $value): self
    {
        $aTable = $this->correctTable($table);
        $this->queryBuilder->addCondition(
            $aTable,
            $this->correctColumn($aTable, $column),
            IQueryBuilder::OPERATION_LIKE,
            $value
        );
        return $this;
    }

    /**
     * @param string $table
     * @param string $column
     * @param string $value
     * @throws MapperException
     * @return $this
     */
    public function notLike(string $table, string $column, $value): self
    {
        $aTable = $this->correctTable($table);
        $this->queryBuilder->addCondition(
            $aTable,
            $this->correctColumn($aTable, $column),
            IQueryBuilder::OPERATION_NLIKE,
            $value
        );
        return $this;
    }

    /**
     * @param string $table
     * @param string $column
     * @param string $pattern
     * @throws MapperException
     * @return $this
     */
    public function regexp(string $table, string $column, string $pattern): self
    {
        $aTable = $this->correctTable($table);
        $this->queryBuilder->addCondition(
            $aTable,
            $this->correctColumn($aTable, $column),
            IQueryBuilder::OPERATION_REXP,
            $pattern
        );
        return $this;
    }

    /**
     * @param string $table
     * @param string $column
     * @param string $min
     * @param string $max
     * @throws MapperException
     * @return $this
     */
    public function between(string $table, string $column, $min, $max): self
    {
        $aTable = $this->correctTable($table);
        $this->queryBuilder->addCondition($aTable, $this->correctColumn($aTable, $column), IQueryBuilder::OPERATION_GTE, $min);
        $this->queryBuilder->addCondition($aTable, $this->correctColumn($aTable, $column), IQueryBuilder::OPERATION_LTE, $max);
        return $this;
    }

    /**
     * @param string $table
     * @param string $column
     * @throws MapperException
     * @return $this
     */
    public function null(string $table, string $column): self
    {
        $aTable = $this->correctTable($table);
        $this->queryBuilder->addCondition(
            $aTable,
            $this->correctColumn($aTable, $column),
            IQueryBuilder::OPERATION_NULL
        );
        return $this;
    }

    /**
     * @param string $table
     * @param string $column
     * @throws MapperException
     * @return $this
     */
    public function notNull(string $table, string $column): self
    {
        $aTable = $this->correctTable($table);
        $this->queryBuilder->addCondition(
            $aTable,
            $this->correctColumn($aTable, $column),
            IQueryBuilder::OPERATION_NNULL
        );
        return $this;
    }

    /**
     * @param string $table
     * @param string $column
     * @param array<string|int|float> $values
     * @throws MapperException
     * @return $this
     */
    public function in(string $table, string $column, array $values): self
    {
        $aTable = $this->correctTable($table);
        $this->queryBuilder->addCondition(
            $aTable,
            $this->correctColumn($aTable, $column),
            IQueryBuilder::OPERATION_IN,
            $values
        );
        return $this;
    }

    /**
     * @param string $table
     * @param string $column
     * @param array<string|int|float> $values
     * @throws MapperException
     * @return $this
     */
    public function notIn(string $table, string $column, array $values): self
    {
        $aTable = $this->correctTable($table);
        $this->queryBuilder->addCondition(
            $aTable,
            $this->correctColumn($aTable, $column),
            IQueryBuilder::OPERATION_NIN,
            $values
        );
        return $this;
    }

    public function useAnd(): self
    {
        $this->queryBuilder->setRelations(IQueryBuilder::RELATION_AND);
        return $this;
    }

    public function useOr(): self
    {
        $this->queryBuilder->setRelations(IQueryBuilder::RELATION_OR);
        return $this;
    }

    public function limit(?int $limit): self
    {
        $this->queryBuilder->setLimit($limit);
        return $this;
    }

    public function offset(?int $offset): self
    {
        $this->queryBuilder->setOffset($offset);
        return $this;
    }

    /**
     * Add ordering by
     * @param string $table
     * @param string $column
     * @param string $direction
     * @throws MapperException
     * @return $this
     */
    public function orderBy(string $table, string $column, string $direction = IQueryBuilder::ORDER_ASC): self
    {
        $aTable = $this->correctTable($table);
        $this->queryBuilder->addOrderBy($aTable, $this->correctColumn($aTable, $column), $direction);
        return $this;
    }

    /**
     * Add grouping by
     * @param string $table
     * @param string $column
     * @throws MapperException
     * @return $this
     */
    public function groupBy(string $table, string $column): self
    {
        $aTable = $this->correctTable($table);
        $this->queryBuilder->addGroupBy($aTable, $this->correctColumn($aTable, $column));
        return $this;
    }

    /**
     * Add child which will be mounted to results
     * @param string $childAlias
     * @param string $joinType
     * @param string $parentAlias
     * @param string $customAlias
     * @throws MapperException
     * @return $this
     */
    public function child(string $childAlias, string $joinType = IQueryBuilder::JOIN_LEFT, string $parentAlias = '', string $customAlias = ''): self
    {
        // from mapper - children's mapper then there table name
        if (!empty($parentAlias)) {
            $parentLookup = $this->recordLookup($parentAlias);
            if ($parentLookup && $parentLookup->getRecord()) {
                $parentRecord = $parentLookup->getRecord();
            }
        } else {
            $parentRecord = $this->basicRecord;
            $parentAlias = $parentRecord->getMapper()->getAlias();
        }
        if (empty($parentRecord)) {
            throw new MapperException(sprintf('Unknown record for parent alias *%s*', $parentAlias));
        }
        /** @var array<string|int, ForeignKey> $parentKeys */
        $parentKeys = $parentRecord->getMapper()->getForeignKeys();
        if (!isset($parentKeys[$childAlias])) {
            throw new MapperException(sprintf('Unknown alias *%s* in mapper for parent *%s*', $childAlias, $parentAlias));
        }
        $parentKey = $parentKeys[$childAlias];
        $parentRelations = $parentRecord->getMapper()->getRelations();

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

        if (empty($parentRelations[$parentKey->getLocalEntryKey()])) {
            throw new MapperException(sprintf('Unknown relation key *%s* in mapper for parent *%s*', $parentKey->getLocalEntryKey(), $parentAlias));
        }

        $childTableAlias = empty($customAlias) ? $childAlias : $customAlias;
        $childLookup = $this->recordLookup($childTableAlias, $childAlias);
        if (empty($childLookup) || empty($childLookup->getRecord())) {
            // might never happens - part already checked, so it must exists
            // @codeCoverageIgnoreStart
            throw new MapperException(sprintf('Unknown record for child alias *%s*', $childAlias));
        }
        // @codeCoverageIgnoreEnd
        $childRecord = $childLookup->getRecord();
        $childRelations = $childRecord->getMapper()->getRelations();
        if (empty($childRelations[$parentKey->getRemoteEntryKey()])) {
            throw new MapperException(sprintf('Unknown relation key *%s* in mapper for child *%s*', $parentKey->getRemoteEntryKey(), $childAlias));
        }
        if ($parentRecord->getMapper()->getSource() != $childRecord->getMapper()->getSource()) {
            throw new MapperException(sprintf('Parent *%s* and child *%s* must both have the same source', $parentAlias, $childAlias));
        }

        $this->queryBuilder->addJoin(
            $childAlias,
            $childRecord->getMapper()->getAlias(),
            $childRelations[$parentKey->getRemoteEntryKey()],
            $parentAlias,
            $parentRelations[$parentKey->getLocalEntryKey()],
            $joinType,
            $childTableAlias
        );

        return $this;
    }

    /**
     * That child is not set for chosen parent
     * @param string $childAlias
     * @param string $table
     * @param string $column
     * @param string $parentAlias
     * @throws MapperException
     * @return $this
     */
    public function childNotExist(string $childAlias, string $table, string $column, string $parentAlias = ''): self
    {
        $this->child($childAlias, IQueryBuilder::JOIN_LEFT_OUTER, $parentAlias);
        $aTable = $this->correctTable($table);
        $this->queryBuilder->addCondition(
            $aTable,
            $this->correctColumn($aTable, $column),
            IQueryBuilder::OPERATION_NULL
        );
        return $this;
    }

    /**
     * Return count of all records selected by params
     * @throws MapperException
     * @return int
     */
    abstract public function getCount(): int;

    /**
     * Return records
     * @throws MapperException
     * @return ARecord[]
     */
    abstract public function getResults(): array;


    protected function correctTable(string $table): string
    {
        return empty($table) ? $this->basicRecord->getMapper()->getAlias() : $table ;
    }

    /**
     * @param string $table
     * @param string $column
     * @throws MapperException
     * @return string|int
     */
    protected function correctColumn(string $table, string $column)
    {
        $record = !empty($table) ? $this->recordLookup($table)->getRecord() : $this->basicRecord ;
        $relations = $record->getMapper()->getRelations();

The method getMapper() does not exist on null.

        if (empty($relations[$column])) {
            throw new MapperException(sprintf('Unknown relation key *%s* in mapper for table *%s*', $column, $table));
        }
        return $relations[$column];
    }
}