Repository.php

Go to the documentation of this file.

<?php
 
namespace Elgg\Database;
 
use Elgg\Database\Clauses\GroupByClause;
use Elgg\Database\Clauses\HavingClause;
use Elgg\Database\Clauses\JoinClause;
use Elgg\Database\Clauses\OrderByClause;
use Elgg\Database\Clauses\SelectClause;
use Elgg\Database\Clauses\WhereClause;
use Elgg\Exceptions\DataFormatException;
 
abstract class Repository {
 
    protected QueryOptions $options;
 
    public function __construct(array $options = []) {
        $this->options = new QueryOptions($options, \ArrayObject::ARRAY_AS_PROPS);
    }
 
    public function __get($name) {
        if (!isset($this->options->$name)) {
            return;
        }
 
        $val = &$this->options->$name;
 
        return $val;
    }
 
    public function __set($name, $value) {
        $this->options->$name = $value;
    }
 
    public function __unset($name) {
        unset($this->options->$name);
    }
 
    public function __isset($name) {
        return isset($this->options->$name);
    }
 
    public static function with(array $options = []) {
        return new static($options);
    }
    
    abstract public function count();
    
    abstract public function calculate($function, $property, $property_type = null);
    
    abstract public function get($limit = null, $offset = null, $callback = null);
 
    public static function find(array $options = []) {
        return static::with($options)->execute();
    }
 
    public function batch($limit = null, $offset = null, $callback = null) {
        $options = $this->options->getArrayCopy();
 
        $options['limit'] = (int) $limit;
        $options['offset'] = (int) $offset;
        $options['callback'] = $callback;
        unset($options['count'],
            $options['batch'],
            $options['batch_size'],
            $options['batch_inc_offset']
        );
 
        $batch_size = $this->options->batch_size;
        $batch_inc_offset = $this->options->batch_inc_offset;
 
        return new \ElggBatch([static::class, 'find'], $options, null, $batch_size, $batch_inc_offset);
    }
    
    abstract public function execute();
 
    public function filter(\Closure $closure) {
        $this->options->where(new WhereClause($closure));
 
        return $this;
    }
 
    public function select($expression) {
        $this->options->select(new SelectClause($expression));
 
        return $this;
    }
 
    public function join($joined_table, $joined_alias = null, $join_column = null, $comparison = null, $values = null, $type = null, $case_sensitive = null) {
        $join = new JoinClause($joined_table, $joined_alias, function (QueryBuilder $qb, $joined_alias) use ($join_column, $comparison, $values, $type, $case_sensitive) {
            return $qb->compare("{$joined_alias}.{$join_column}", $comparison, $values, $type, $case_sensitive);
        });
        $this->options->join($join);
 
        return $this;
    }
 
    public function groupBy($expression) {
        $this->options->groupBy(new GroupByClause($expression));
 
        return $this;
    }
 
    public function having($expression) {
        $this->options->having(new HavingClause($expression));
 
        return $this;
    }
 
    public function orderBy($expression, $direction) {
        $this->options->orderBy(new OrderByClause($expression, $direction));
 
        return $this;
    }
 
    public function expandInto(QueryBuilder $qb, $table_alias = null) {
        foreach ($this->options->selects as $select_clause) {
            $select_clause->prepare($qb, $table_alias);
        }
 
        foreach ($this->options->group_by as $group_by_clause) {
            $group_by_clause->prepare($qb, $table_alias);
        }
 
        foreach ($this->options->having as $having_clause) {
            $having_clause->prepare($qb, $table_alias);
        }
 
        if (!empty($this->options->order_by)) {
            foreach ($this->options->order_by as $order_by_clause) {
                $order_by_clause->prepare($qb, $table_alias);
            }
        }
    }
}