LaravelFreelancerNL\Aranguent\Schema\Concerns\Indexes

Complexity

Total Complexity

24

Size/Duplication

Total Lines	229
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	indexCommand()	0	18	5
A	index()	0	6	1
A	hashIndex()	0	4	1
A	fulltextIndex()	0	4	1
A	geoIndex()	0	4	1
A	spatialIndex()	0	4	1
A	skiplistIndex()	0	4	1
A	persistentIndex()	0	4	1
A	ttlIndex()	0	4	1
A	unique()	0	8	1
A	executeIndexCommand()	0	21	4
A	dropIndex()	0	9	1
A	executeDropIndexCommand()	0	8	2
A	mapIndexType()	0	12	2
A	createIndexName()	0	6	1

<?php

namespace LaravelFreelancerNL\Aranguent\Schema\Concerns;

use ArangoDBClient\Exception;
use Illuminate\Support\Fluent;

trait Indexes
{
    /**
     * Add a new index command to the blueprint.
     *
     * @param string $type
     * @param string|array|null $columns
     * @param $name
     * @param array $indexOptions
     * @return Fluent
     */
    protected function indexCommand($type = '', $columns = null, $name = null, $indexOptions = [])
    {
        if ($type == '') {
            $type = $this->mapIndexType('persistent');
        }

        if ($columns === null) {
            $columns = end($this->columns);

The property columns does not exist. Did you maybe forget to declare it?

        }

        if (is_string($columns)) {
            $columns = [$columns];
        }

        $indexOptions['name'] = $name ?: $this->createIndexName($type, $columns);

        return $this->addCommand('index', compact('type', 'columns', 'indexOptions'));

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

    }



    /**
     * Specify an index for the table.
     *
     * @param  string|array  $columns
     * @param  string  $name
     * @param  string|null  $algorithm
     * @return Fluent
     */
    public function index($columns = null, $name = null, $algorithm = null)

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

    {
        $type = $this->mapIndexType($algorithm);

        return $this->indexCommand($type, $columns);
    }

    /**
     * Create a hash index for fast exact matching.
     *
     * @param null $columns
     * @param array $indexOptions
     * @return Fluent
     */
    public function hashIndex($columns = null, $indexOptions = [])
    {
        return $this->indexCommand('hash', $columns, $indexOptions);
    }

    /**
     * @param null|string $column
     * @param $name
     * @param array $indexOptions
     * @return Fluent
     */
    public function fulltextIndex($column = null,  $name = null, $indexOptions = [])
    {
        return $this->indexCommand('fulltext', $column, $name, $indexOptions);
    }

    /**
     *  Specify a spatial index for the table.
     *
     * @param $columns
     * @param null $name
     * @param array $indexOptions
     * @return Fluent
     */
    public function geoIndex($columns, $name = null, $indexOptions = [])
    {
        return $this->indexCommand('geo', $columns, $name, $indexOptions);
    }

    /**
     * Specify a spatial index for the table.
     * @param  string|array  $columns
     * @param  string  $name
     * @return Fluent
     */
    public function spatialIndex($columns, $name = null)
    {
        return $this->geoIndex($columns, $name);

It seems like $name defined by parameter $name on line 97 can also be of type string; however, LaravelFreelancerNL\Aranguent\Schema\Concerns\Indexes::geoIndex() does only seem to accept null, maybe add an additional type check?

    }

    /**
     * @param $columns
     * @param string|null $name
     * @param array $indexOptions
     * @return Fluent
     */
    public function skiplistIndex($columns, $name = null, $indexOptions = [])
    {
        return $this->indexCommand('skiplist', $columns, $name, $indexOptions);
    }

    public function persistentIndex($columns, $name = null, $indexOptions = [])
    {
        return $this->indexCommand('persistent', $columns, $name, $indexOptions);
    }

    /**
     * Create a TTL index for the table.
     *
     * @param $columns
     * @param null $name
     * @param array $indexOptions
     * @return Fluent
     */
    public function ttlIndex($columns, $name = null, $indexOptions = [])
    {
        return $this->indexCommand('ttl', $columns, $name, $indexOptions);
    }

    /**
     * Specify a unique index for the table.
     *
     * @param  string|array  $columns
     * @param  string  $name
     * @param  string|null  $algorithm
     * @return Fluent
     */
    public function unique($columns = null, $name = null, $algorithm = null)
    {
        $type = $this->mapIndexType($algorithm);

        $indexOptions['unique'] = true;

$indexOptions was never initialized. Although not strictly required by PHP, it is generally a good practice to add $indexOptions = array(); before regardless.

        return $this->indexCommand($type, $columns, $name, $indexOptions);
    }

    /**
     * @param $command
     * @throws Exception
     */
    public function executeIndexCommand($command)
    {
        if ($this->connection->pretending()) {
            $this->connection->logQuery('/* '.$command->explanation." */\n", []);

The property connection does not exist. Did you maybe forget to declare it?

            return;
        }

        $options = [
            'type' => $command->type,
            'fields' => $command->columns,
            'unique' => $command->unique,
            'options' => $command->indexOptions
        ];

        if (isset($command->indexOptions) && is_array($command->indexOptions)) {
            $options = array_merge($options, $command->indexOptions);
        }

        $this->collectionHandler->createIndex($this->table, $options);

The property collectionHandler does not exist. Did you maybe forget to declare it?

The property table does not exist. Did you maybe forget to declare it?

    }

    /**
     * Indicate that the given index should be dropped.
     *
     * @param $name
     * @return Fluent
     */
    public function dropIndex($name)
    {
        $parameters['name'] = 'dropIndex';

$parameters was never initialized. Although not strictly required by PHP, it is generally a good practice to add $parameters = array(); before regardless.

        $parameters['index'] = $name;
        $parameters['explanation'] = "Drop the '".$name."' index on the {$this->table} table.";
        $parameters['handler'] = 'collection';

        return $this->addCommand('dropIndex', $parameters);

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

    }

    /**
     * Drop the index by first getting all the indexes on the table; then selecting the matching one
     * by type and columns.
     * @param $command
    */
    public function executeDropIndexCommand($command)
    {
        if ($this->connection->pretending()) {
            $this->connection->logQuery('/* '.$command->explanation." */\n", []);
            return;
        }
        $this->collectionHandler->dropIndex($this->table, $command->index);
    }

    /**
     * @param string|null $algorithm
     * @return mixed|string
     */
    protected function mapIndexType($algorithm)
    {
        $typeConversion = [
            'HASH' => 'hash',
            'BTREE' => 'persistent',
            'RTREE' => 'geo',
            'TTL' => 'ttl',
        ];
        $algorithm = strtoupper($algorithm);

        return (isset($typeConversion[$algorithm])) ? $typeConversion[$algorithm] : 'persistent';
    }

    /**
     * Create a default index name for the table.
     *
     * @param  string  $type
     * @param  array  $columns
     * @return string
     */
    public function createIndexName($type, array $columns)
    {
        $index = strtolower($this->prefix.$this->table.'_'.implode('_', $columns).'_'.$type);

The property prefix does not exist. Did you maybe forget to declare it?

        return str_replace(['-', '.'], '_', $index);
    }


}