BuildsUpdates::upsert() - Code Metrics - LaravelFreelancerNL/laravel-arangodb - Measure and Improve Code Quality continuously with Scrutinizer

BuildsUpdates::upsert() B
last analyzed 2025-05-12 04:25 UTC

↳ Parent: BuildsUpdates
Complexity

Conditions	9
Paths	50
Size

Total Lines	47
Code Lines	26
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	25
CRAP Score	9.0046
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	9
eloc	26
c	1
b	0
f	0
nc	50
nop	3
dl	0
loc	47
ccs	25
cts	26
cp	0.9615
crap	9.0046
rs	8.0555
<?php

declare(strict_types=1);

namespace LaravelFreelancerNL\Aranguent\Query\Concerns;

use Closure;
use Illuminate\Database\Query\Expression;
use Illuminate\Support\Arr;
use InvalidArgumentException;
use LaravelFreelancerNL\Aranguent\Query\Grammar;
use LaravelFreelancerNL\FluentAQL\Exceptions\BindException;

/**
 * @method applyBeforeQueryCallbacks()
 */
trait BuildsUpdates
{
    /**
     * @param array<mixed> $values
     * @return array<mixed>
     */
    protected function prepareValuesForUpdate(array $values)
    {
        foreach ($values as $key => $value) {
            if ($value instanceof Expression) {
                $values[$key] = $value->getValue($this->grammar);

                continue;
            }

            if (is_array($value)) {
                $values[$key] = $this->prepareValuesForUpdate($value);
                continue;
            }

            $values[$key]  = $this->bindValue($value, 'update');
            $values[$key]  = $this->bindValue($value, 'update');
        }

        return $values;
    }

    /**
     * Update records in the database.
     *
     * @param  array<mixed>  $values
     * @return int
     */
    public function update(array $values)
    {
        assert($this->grammar instanceof Grammar);

        $this->applyBeforeQueryCallbacks();

        $values = Arr::undot($this->grammar->convertJsonFields($values));

        $values = $this->prepareValuesForUpdate($values);

        $aql = $this->grammar->compileUpdate($this, $values);
        $aql = $this->grammar->compileUpdate(/** @scrutinizer ignore-type */ $this, $values);

        return $this->connection->update($aql, $this->getBindings());
        return $this->connection->update($aql, $this->/** @scrutinizer ignore-call */ getBindings());
    }

    /**
     * Insert or update a record matching the attributes, and fill it with values.
     *
     * @param array<mixed> $attributes
     * @param array<mixed>|callable $values
     * @return bool
     * @throws BindException
     */
    public function updateOrInsert(array $attributes, array|callable $values = [])
    {
        $exists = $this->where($attributes)->exists();
        $exists = $this->/** @scrutinizer ignore-call */ where($attributes)->exists();

        if ($values instanceof Closure) {

            $values = $values($exists);
        }

        if (! $exists) {
            $this->bindings['where'] = [];

            return $this->insert(array_merge($attributes, $values));
            return $this->/** @scrutinizer ignore-call */ insert(array_merge($attributes, $values));
        }

        if (empty($values)) {
            return true;
        }

        return (bool) $this->limit(1)->update($values);
        return (bool) $this->/** @scrutinizer ignore-call */ limit(1)->update($values);
    }

    /**
     * Increment the given column's values by the given amounts.
     *
     * @param  array<string, float|int|numeric-string>  $columns

     * @param  array<string, mixed>  $extra
     * @return int
     *
     * @throws \InvalidArgumentException
     */
    public function incrementEach(array $columns, array $extra = [])
    {
        foreach ($columns as $column => $amount) {
            if (!is_numeric($amount)) {
                throw new InvalidArgumentException("Non-numeric value passed as increment amount for column: '$column'.");
            } elseif (!is_string($column)) {
                throw new InvalidArgumentException('Non-associative array passed to incrementEach method.');
            }

            $columns[$column] = new Expression($this->getTableAlias($this->from) . '.' . $column . ' + ' . $amount);
            $columns[$column] = new Expression(/** @scrutinizer ignore-type */ $this->getTableAlias($this->from) . '.' . $column . ' + ' . $amount);
        }

        return $this->update(array_merge($columns, $extra));
    }

    /**
     * Decrement the given column's values by the given amounts.
     *
     * @param  array<string, float|int|numeric-string>  $columns

     * @param  array<string, mixed>  $extra
     * @return int
     *
     * @throws \InvalidArgumentException
     */
    public function decrementEach(array $columns, array $extra = [])
    {
        foreach ($columns as $column => $amount) {
            if (!is_numeric($amount)) {
                throw new InvalidArgumentException("Non-numeric value passed as decrement amount for column: '$column'.");
            } elseif (!is_string($column)) {
                throw new InvalidArgumentException('Non-associative array passed to decrementEach method.');
            }

            $columns[$column] = new Expression($this->getTableAlias($this->from) . '.' . $column . ' - ' . $amount);
            $columns[$column] = new Expression(/** @scrutinizer ignore-type */ $this->getTableAlias($this->from) . '.' . $column . ' - ' . $amount);
        }

        return $this->update(array_merge($columns, $extra));
    }

    /**
     * Insert new records or update the existing ones.
     *
     * @param array<mixed> $values
     * @param array<mixed>|string $uniqueBy
     * @param array<mixed>|null $update
     * @return int
     * @throws BindException
     */
    public function upsert(array $values, $uniqueBy, $update = null)
    {
        assert($this->grammar instanceof Grammar);

        if (empty($values)) {
            return 0;
        } elseif ($update === []) {
            return (int) $this->insert($values);
        }

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

        foreach ($values as $key => $value) {
            $values[$key] = $this->grammar->convertJsonFields($value);
            $values[$key] = $this->convertIdToKey($values[$key]);
            $values[$key] = $this->convertIdToKey($values[$key]);
            $values[$key] = Arr::undot($values[$key]);
        }

        foreach ($values as $key => $value) {
            foreach ($value as $dataKey => $data) {
                $values[$key][$dataKey] = $this->bindValue($data, 'upsert');
            }
        }

        $uniqueBy = $this->grammar->convertJsonFields($uniqueBy);

        if (is_null($update)) {
            $update = array_keys(reset($values));
        }

        foreach ($update as $key => $value) {
            $update[$key] = $this->convertIdToKey($value);
        }

        $update = $this->grammar->convertJsonFields($update);

        $this->applyBeforeQueryCallbacks();

        $bindings = $this->bindings['upsert'];

        $aql = $this->grammar->compileUpsert($this, $values, (array) $uniqueBy, $update);
        $aql = $this->grammar->compileUpsert(/** @scrutinizer ignore-type */ $this, $values, (array) $uniqueBy, $update);

        return $this->connection->affectingStatement(
            $aql,
            $bindings,
        );
    }
}

LaravelFreelancerNL / laravel-arangodb

BuildsUpdates::upsert() B last analyzed 2025-05-12 04:25 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

BuildsUpdates::upsert() B
last analyzed 2025-05-12 04:25 UTC
