samsonframework / orm

src/dbQuery.php

<?php declare(strict_types = 1);
namespace samson\activerecord;

use samsonframework\orm\ArgumentInterface;
use samsonframework\orm\Condition;
use samsonframework\orm\ConditionInterface;
use samsonframework\orm\QueryHandler;
use samsonframework\orm\QueryInterface;

/**
 * This class will be removed in next major release.
 * @author     Vitaly Iegorov <vitalyiegorov@gmail.com>
 * @deprecated Should be removed ASAP in favor of generated classes or DI
 *
 */
class dbQuery extends QueryHandler

This class is not in CamelCase format.

The class samsonframework\orm\QueryHandler has been deprecated.

{
    /** Virtual field for base table */
    public $own_virtual_fields = array();
    /** Virtual fields */
    public $virtual_fields = array();
    public $empty = false;
    protected $class_name;
    /**
     * @var QueryInterface
     */
    protected $query;
    /** @var bool True to show requests */
    protected $debug = false;

    /** Constructor */
    public function __construct()
    {
        $this->database = $GLOBALS['__core']->getContainer()->getDatabase();

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

        $this->sqlBuilder = $GLOBALS['__core']->getContainer()->getSqlBuilder();

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

    }
    
    /**
     * @param string $metadata
     *
     * @deprecated Use entity()
     * @return QueryInterface|string
     */
    public function className(string $metadata = null)
    {
        if (func_num_args() === 0) {
            return $this->metadata->className;

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

        } else {
            return $this->entity($metadata);

It seems like you code against a specific sub-type and not the parent class samson\activerecord\dbQuery as the method entity() does only exist in the following sub-classes of samson\activerecord\dbQuery: samsonframework\orm\Query. Maybe you want to instanceof check for one of these explicitly?

        }
    }


    /** @deprecated Use QueryInterface implementation */
    public function own_limit($st, $en = 0)

Method name "dbQuery::own_limit" is not in camel caps format

    {
        $this->query->limit($st, $en);

        return $this;
    }

    /** @deprecated Use QueryInterface implementation */
    public function own_group_by($params)

Method name "dbQuery::own_group_by" is not in camel caps format

    {
        $this->query->groupBy($this->class_name, $params);

The call to QueryInterface::groupBy() has too many arguments starting with $params.

        return $this;
    }

    /** @deprecated Use QueryInterface implementation */
    public function own_order_by($field, $direction = 'ASC')

Method name "dbQuery::own_order_by" is not in camel caps format

    {
        $this->query->orderBy($this->class_name, $field, $direction);

The call to QueryInterface::orderBy() has too many arguments starting with $direction.

        return $this;
    }

    /** @see idbQuery::random() */
    public function random(& $return_value = null)
    {
        // Add random ordering
        $this->order_by('', 'RAND()');

The method samson\activerecord\dbQuery::order_by() has been deprecated with message: Use groupBy()

        // Correctly perform db request for multiple data
        return func_num_args() ? $this->exec($return_value) : $this->exec();

The call to dbQuery::exec() has too many arguments starting with $return_value.

The method samson\activerecord\dbQuery::exec() has been deprecated with message: Use self::find()

    }

    /**
     * @param        $columnName
     * @param string $sorting
     *
     * @deprecated Use groupBy()
     * @return QueryInterface|static
     */
    public function order_by($columnName, $sorting = 'ASC')

Method name "dbQuery::order_by" is not in camel caps format

    {
        return $this->orderBy($this->metadata->tableName, $columnName, $sorting);

It seems like you code against a specific sub-type and not the parent class samson\activerecord\dbQuery as the method orderBy() does only exist in the following sub-classes of samson\activerecord\dbQuery: samsonframework\orm\Query. Maybe you want to instanceof check for one of these explicitly?

    }

    /**
     * Execute current query and receive collection of RecordInterface objects from database.
     * @deprecated Use self::find()
     * @return RecordInterface[] Database entities collection
     */
    public function exec() : array
    {
        return $this->find();

It seems like you code against a specific sub-type and not the parent class samson\activerecord\dbQuery as the method find() does only exist in the following sub-classes of samson\activerecord\dbQuery: samsonframework\orm\Query. Maybe you want to instanceof check for one of these explicitly?

    }

    /** @deprecated Use QueryInterface implementation */
    public function or_($relation = 'OR')

Method name "dbQuery::or_" is not in camel caps format

    {
        // Получим либо переданную группу условий, либо создадим новую, потом добавим её в массив групп условий запроса
        $cond_group = new Condition($relation);

        // Установим текущую группу условий с которой работает запрос
        $this->cConditionGroup = &$cond_group;

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

        // Добавим нову группу условий в коллекцию групп
        $this->condition->arguments[] = $cond_group;

The property condition does not seem to exist. Did you mean cConditionGroup?

        // Вернем себя для цепирования
        return $this;
    }

    /** @deprecated Use QueryInterface implementation */
    public function debug($value = true)
    {
        db()->debug($this->debug = $value);

The function db() has been deprecated with message: Use dependency injection or generated class

        return $this;
    }

    /** @deprecated Use QueryInterface implementation */
    public function fieldsNew($fieldName, & $return = null)

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

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

    {
        return call_user_func_array(array($this, 'fields'), func_get_args());
    }

    /** @deprecated Use QueryInterface implementation */
    public function group_by($field)

Method name "dbQuery::group_by" is not in camel caps format

    {
        $this->query->groupBy($this->metadata->tablename, $field);

The call to QueryInterface::groupBy() has too many arguments starting with $field.

        // Вернем себя для цепирования
        return $this;
    }

    /** @deprecated Use QueryInterface implementation */
    public function add_field($field, $alias = null, $own = true)

Method name "dbQuery::add_field" is not in camel caps format

    {
        // Если передан псевдоним для поля, то подставим его
        if (isset($alias)) {
            $field = $field . ' as ' . $alias;
        } else {
            $alias = $field;
        }

        // Добавим виртуальное поле
        if ($own) {
            $this->own_virtual_fields[$alias] = $field;
        } else {
            $this->virtual_fields[$alias] = $field;
        }

        // Вернем себя для цепирования
        return $this;
    }

    /** @deprecated Use QueryInterface implementation */
    public function innerCount($field = '*')

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

    {
        return $this->query->count();
    }

    /** @deprecated Use QueryInterface implementation */
    public function id($value)
    {
        $this->query->primary($value);

        return $this;
    }

    /**
     * Add condition to current query.
     * This method supports receives three possible types for $fieldName,
     * this is deprecated logic and this should be changed to use separate methods
     * for each argument type.
     *
     * @param string|ConditionInterface|ArgumentInterface $fieldName  Entity field name
     * @param string                                      $fieldValue Value
     * @param string                                      $relation   Relation between field name and its value
     *
     * @deprecated Use QueryInterface implementation
     * @return self Chaining
     */
    public function cond($fieldName, $fieldValue = null, $relation = '=')
    {
        // If empty array is passed
        if (is_string($fieldName)) {
            return $this->where($fieldName, $fieldValue, $relation);

It seems like you code against a specific sub-type and not the parent class samson\activerecord\dbQuery as the method where() does only exist in the following sub-classes of samson\activerecord\dbQuery: samsonframework\orm\Query. Maybe you want to instanceof check for one of these explicitly?

        } elseif (is_array($fieldValue) && !sizeof($fieldValue)) {
            $this->empty = true;
            return $this;
        } elseif ($fieldName instanceof ConditionInterface) {
            $this->whereCondition($fieldName);

It seems like you code against a specific sub-type and not the parent class samson\activerecord\dbQuery as the method whereCondition() does only exist in the following sub-classes of samson\activerecord\dbQuery: samsonframework\orm\Query. Maybe you want to instanceof check for one of these explicitly?

        } elseif ($fieldName instanceof ArgumentInterface) {
            $this->whereCondition((new Condition())->addArgument($fieldName));

It seems like you code against a specific sub-type and not the parent class samson\activerecord\dbQuery as the method whereCondition() does only exist in the following sub-classes of samson\activerecord\dbQuery: samsonframework\orm\Query. Maybe you want to instanceof check for one of these explicitly?

        }

        return $this;
    }
}