LaravelFreelancerNL\Aranguent\Query\Concerns\CompilesColumns

Complexity

Total Complexity

20

Size/Duplication

Total Lines	97
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	mergeReturnAttributes()	0	14	4
A	mergeReturnDocs()	0	10	4
A	mergeJoinResults()	0	10	2
A	determineReturnValues()	0	18	5
A	compileColumns()	0	26	5

<?php

namespace LaravelFreelancerNL\Aranguent\Query\Concerns;

use LaravelFreelancerNL\Aranguent\Query\Builder;

trait CompilesColumns
{
    /**
     * Compile the "RETURN" portion of the query.
     *
     * @param Builder $builder
     * @param array   $columns
     *
     * @return Builder
     */
    protected function compileColumns(Builder $builder, array $columns): Builder
    {
        $returnDocs = [];
        $returnAttributes = [];
        $values = [];

The assignment to $values is dead and can be removed.

        // Prepare columns
        foreach ($columns as $column) {
            // Extract rows
            if (substr($column, strlen($column) - 2)  === '.*') {
                $table = substr($column, 0, strlen($column) - 2);
                $returnDocs[] = $this->getTableAlias($table);

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

                continue;
            }

            if ($column != null && $column != '*') {
                [$column, $alias] = $this->extractAlias($column);

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

                $returnAttributes[$alias] = $this->normalizeColumn($builder, $column);

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

            }
        }
        $values = $this->determineReturnValues($builder, $returnAttributes, $returnDocs);
        $builder->aqb = $builder->aqb->return($values, (bool) $builder->distinct);

        return $builder;
    }

    protected function determineReturnValues($builder, $returnAttributes = [], $returnDocs = [])
    {
        $values = $this->mergeReturnAttributes($returnAttributes, $returnDocs);

        $values = $this->mergeReturnDocs($values, $builder, $returnAttributes, $returnDocs);

        if ($builder->aggregate !== null) {
            $values = ['aggregate' => 'aggregateResult'];
        }

        if (empty($values)) {
            $values = $this->getTableAlias($builder->from);
            if (is_array($builder->joins) && !empty($builder->joins)) {
                $values = $this->mergeJoinResults($builder, $values);
            }
        }

        return $values;
    }

    protected function mergeReturnAttributes($returnAttributes, $returnDocs)
    {
        $values = [];
        if (! empty($returnAttributes)) {
            $values = $returnAttributes;
        }

        // If there is just one attribute/column given we assume that you want a list of values
        //  instead of a list of objects
        if (count($returnAttributes) == 1 && empty($returnDocs)) {
            $values = reset($returnAttributes);
        }

        return $values;
    }

    protected function mergeReturnDocs($values, $builder, $returnAttributes, $returnDocs)
    {
        if (! empty($returnAttributes) && ! empty($returnDocs)) {
            $returnDocs[] = $returnAttributes;
        }

        if (! empty($returnDocs)) {
            $values = $builder->aqb->merge(...$returnDocs);
        }
        return $values;
    }


    protected function mergeJoinResults($builder, $baseTable)
    {
        $tablesToJoin = [];
        foreach ($builder->joins as $join) {
            $tablesToJoin[] = $this->getTableAlias($join->table);
        }
        $tablesToJoin = array_reverse($tablesToJoin);
        $tablesToJoin[] = $baseTable;

        return $builder->aqb->merge(...$tablesToJoin);
    }
}