hooklife / DynamoDBODM

src/DynamoDB/Builder.php

<?php

namespace Hoooklife\DynamodbPodm\DynamoDB;

use Aws\DynamoDb\DynamoDbClient;
use Aws\DynamoDb\Marshaler;
use Closure;
use Hoooklife\DynamodbPodm\ComparisonOperator;
use Hoooklife\DynamodbPodm\Concerns\HasParsers;
use Hoooklife\DynamodbPodm\DB;
use Hoooklife\DynamodbPodm\Grammars\DynamoDBBuilder;
use Hoooklife\DynamodbPodm\Grammars\DynamoDBGrammar;

class Builder
{
    use HasParsers;
    /**
     * 查询排序
     */
    public $limit;
    public $wheres = [];
    public $bindings = [];
    public $columns;
    public $table;


    /**
     * All of the available clause operators.
     *
     * @var array
     */
    public $operators = [
        '=', '<', '>', '<=', '>=', '<>', '!='
    ];

    public $reservedKey = [
        'key'
    ];

    /** @var DynamoDBGrammar */
    private $dynamoDBBuilder;
    private $client;

    public function __construct($connection = 'default')
    {
        $this->setupExpressions();
        switch (DB::$config[$connection]['driver']) {
            case "dynamedb":
                $this->dynamoDBBuilder = new DynamoDBBuilder(DB::$config[$connection]);

It seems like new Hoooklife\DynamodbPodm\Grammars\DynamoDBBuilder(Hoooklife\DynamodbPodm\DB::config[$connection]) of type Hoooklife\DynamodbPodm\Grammars\DynamoDBBuilder is incompatible with the declared type Hoooklife\DynamodbPodm\Grammars\DynamoDBGrammar of property $dynamoDBBuilder.

                $this->client = new DynamoDbClient(DB::$config[$connection]["S3Config"]);
                break;
            default:
                throw new \Exception("bad driver");
        }
    }


    /**
     * Set the table which the query is targeting.
     *
     * @param  string $table
     * @return $this
     */
    public function from($table)
    {
        $this->table = $table;
        return $this;
    }


    /**
     * Add a basic where clause to the query.
     *
     * @param  string|array|\Closure $column
     * @param  mixed $operator
     * @param  mixed $value
     * @param  string $boolean
     * @param string $type
     * @return $this
     */

    public function where($column, $operator = null, $value = null, $type = "key", $boolean = 'and')
    {
        if (is_array($column)) {
            // 递归
            foreach ($column as $key => $value) {
                if (is_numeric($key) && is_array($value)) {
                    $this->where(...array_values($value));

array_values($value) is expanded, but the parameter $column of Hoooklife\DynamodbPodm\DynamoDB\Builder::where() does not expect variable arguments.

                } else {
                    $this->where($key, '=', $value, $type, $boolean);
                }
            }
            return $this;
        }

        if (func_num_args() === 2 || !ComparisonOperator::isValidOperator($operator)) {
            list($value, $operator) = [$operator, '='];
        }

//        if ($column instanceof Closure) {
//            return $this->whereNested($column, $boolean);
//        }


        // where in
        if (is_array($value)) {
            return $this->whereIn($column, $type, $boolean);

$type of type string is incompatible with the type array expected by parameter $values of Hoooklife\DynamodbPodm\DynamoDB\Builder::whereIn().

It seems like $column can also be of type Closure; however, parameter $column of Hoooklife\DynamodbPodm\DynamoDB\Builder::whereIn() does only seem to accept string, maybe add an additional type check?

        }

        // is null
        if (is_null($value)) {
            return $this->whereNull($column, $type, $boolean, $operator !== '=');

It seems like $column can also be of type Closure; however, parameter $column of Hoooklife\DynamodbPodm\DynamoDB\Builder::whereNull() does only seem to accept string, maybe add an additional type check?

        }

        $this->wheres[] = [
            'column'   => $column,
            'operator' => ComparisonOperator::getDynamoDbOperator($operator),
            'value'    => $value,
            'boolean'  => $boolean,
            'type'     => $type
        ];

        return $this;
    }

    /**
     * Add a "where in" clause to the query.
     *
     * @param  string $column
     * @param  array $values
     * @param string $type
     * @param  string $boolean
     * @return $this
     */
    public function whereIn($column, $values, $type = "key", $boolean = 'and')
    {
        return $this->where($column, ComparisonOperator::IN, $values, $type, $boolean);
    }

    /**
     * Add a "where null" clause to the query.
     *
     * @param  string $column
     * @param  string $boolean
     * @param  bool $not
     * @return $this
     */
    public function whereNull($column, $type = "key", $boolean = 'and', $not = false)
    {
        $operator = $not ? ComparisonOperator::NOT_NULL : ComparisonOperator::NULL;
        $this->wheres[] = compact('column', 'operator', 'boolean', 'type');
        return $this;
    }

    /**
     * Add an "or where null" clause to the query.
     *
     * @param  string $column
     * @param string $type
     * @return $this
     */
    public function orWhereNull($column, $type = "key")
    {
        return $this->whereNull($column, $type, 'or');
    }

    /**
     * Add an "or where not null" clause to the query.
     *
     * @param  string $column
     * @param string $type
     * @return $this
     */
    public function orWhereNotNull($column, $type = "key")
    {
        return $this->whereNotNull($column, $type, 'or');
    }

    /**
     * Add a "where not null" clause to the query.
     *
     * @param  string $column
     * @param string $type
     * @param  string $boolean
     * @return $this
     */
    public function whereNotNull($column, $type = "key", $boolean = 'and')
    {
        return $this->whereNull($column, $type, $boolean, true);
    }


    /**
     * Alias to set the "limit" value of the query.
     *
     * @param  int $value
     * @return \Illuminate\Database\Query\Builder|static

The type Illuminate\Database\Query\Builder was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    public function take($value)
    {
        return $this->limit($value);
    }

    public function limit($value)
    {
        $this->limit = $value;
        return $this;
    }

    /**
     * Get the SQL representation of the query.
     *
     * @return string
     */
    public function toQuery()
    {
        return $this->grammar->compileSelect($this);

The property grammar does not exist on Hoooklife\DynamodbPodm\DynamoDB\Builder. Did you maybe forget to declare it?

    }


    /**
     * Get a single column's value from the first result of a query.
     *
     * @param  string $column
     * @return mixed
     */
    public function value($column)
    {
        $result = $this->first([$column])->toArray();

The method toArray() does not exist on Hoooklife\DynamodbPodm\DynamoDB\Builder.

        return $result !== null ? reset($result) : null;
    }


    /**
     * Execute the query and get the first result.
     *
     * @param  array $columns
     * @return \Illuminate\Database\Eloquent\Model|object|static|null

The type Illuminate\Database\Eloquent\Model was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    public function first($columns = ['*'])
    {
        return $this->take(1)->all($columns)->first();
    }

    public function get($columns = [])
    {
        $raw = $this->toDynamoDbQuery($columns, 10);
        if ($raw->op === 'Scan') {
            $res = $raw->scan($raw->query);

The method scan() does not exist on Hoooklife\DynamodbPodm\DynamoDB\RawDynamoDbQuery.

        } else {
            $res = $this->client->query($raw->query);
            $res = $res['Items'];
        }

        foreach ($res as $item) {
            $results[] = (new Marshaler())->unmarshalItem($item);
        }
        return $results;

The variable $results seems to be defined by a foreach iteration on line 255. Are you sure the iterator is never empty, otherwise this variable is not defined?

    }

    public function query($columns = [])

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

    {
        $limit = isset($this->limit) ?: -1;

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

    }

    public function toDynamoDBQuery($columns, $limit)
    {
        if (!empty($this->wheres)) {
            $this->dynamoDBBuilder->setTableName($this->table);

The method setTableName() does not exist on Hoooklife\DynamodbPodm\Grammars\DynamoDBGrammar.

            $this->dynamoDBBuilder->setKeyConditionExpression($this->keyConditionExpression->parse($this->wheres));

The method setKeyConditionExpression() does not exist on Hoooklife\DynamodbPodm\Grammars\DynamoDBGrammar.

            foreach ($this->wheres as $where) {
//                if ($where['type'] === 'key') {
//                } else {
//                    $this->dynamoDBBuilder->setFilterExpression($this->filterExpression->parse($where));
//                }
            }
        }

        $this->dynamoDBBuilder->setLimit($limit);

The method setLimit() does not exist on Hoooklife\DynamodbPodm\Grammars\DynamoDBGrammar.

        if (!empty($columns)) {
            $this->dynamoDBBuilder->setProjectionExpression($this->projectionExpression->parse($columns));

The method setProjectionExpression() does not exist on Hoooklife\DynamodbPodm\Grammars\DynamoDBGrammar.

        }

        $this->dynamoDBBuilder
            ->setExpressionAttributeNames($this->expressionAttributeNames->all())

The method setExpressionAttributeNames() does not exist on Hoooklife\DynamodbPodm\Grammars\DynamoDBGrammar.

            ->setExpressionAttributeValues($this->expressionAttributeValues->all());

        $op = 'Query';
        $raw = new RawDynamoDbQuery($op, $this->dynamoDBBuilder->prepare()->query);

The method prepare() does not exist on Hoooklife\DynamodbPodm\Grammars\DynamoDBGrammar.

        return $raw;
    }

    /**
     * Execute the query as a "select" statement.
     *
     * @param  array $columns
     * @return Collection
     */
    public function all($columns = ['*']): Collection

The type Hoooklife\DynamodbPodm\DynamoDB\Collection was not found. Maybe you did not declare it correctly or list all dependencies?

    {
        $columns = is_array($columns) ? $columns : func_get_args();
        $this->columns = $columns;

        return $this->grammar->all();

The property grammar does not exist on Hoooklife\DynamodbPodm\DynamoDB\Builder. Did you maybe forget to declare it?

    }


    public function getGrammar()
    {
        return $this->grammar;

The property grammar does not exist on Hoooklife\DynamodbPodm\DynamoDB\Builder. Did you maybe forget to declare it?

    }

    public function getBuilder()
    {
        return $this->grammar->getBuilder();

The property grammar does not exist on Hoooklife\DynamodbPodm\DynamoDB\Builder. Did you maybe forget to declare it?

    }
}