samsonframework\orm\Query

Complexity

Total Complexity

15

Size/Duplication

Total Lines	135
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	2
Bugs	0	Features	1

5 Methods

Rating	Name	Duplication	Size	Complexity
A	flush()	0	8	2
A	exec()	0	5	1
A	first()	0	5	1
A	fields()	0	17	3
C	execute()	0	50	8

<?php
namespace samsonframework\orm;

/**
 * Universal class for creating database queries 
 * @author Vitaly Iegorov <egorov@samsonos.com>
 * @version 2.0
 */
class Query extends QueryHandler
{
    /** Class name for interacting with database */
    protected $class_name;

    /**
     * Collection of query parameters objects
     * @see \samson\activerecord\QueryParams
     */
    protected $parameters = array();

    /**
     * Reset all query parameters
     * @return self Chaining
     */
    public function flush()
    {
        foreach ($this->parameters as $param) {
            $param->flush();
        }

        return $this;
    }

    /**
     * Perform database request and get collection of database record objects
     * @see \samson\activerecord\Query::execute()
     * @param mixed $return External variable to store query results
     * @return mixed If no arguments passed returns query results collection, otherwise query success status
     */
    public function exec(& $return = null)
    {
        $args = func_num_args();
        return $this->execute($return, $args);
    }

    /**
     * Perform database request and get first record from results collection
     * @see \samson\activerecord\Query::execute()
     * @param mixed $return External variable to store query results
     * @return mixed If no arguments passed returns query results first database record object,
     * otherwise query success status
     */
    public function first(& $return = null)
    {
        $args = func_num_args();
        return $this->execute($return, $args, 1);
    }

    /**
     * Perform database request and get array of record field values
     * @see \samson\activerecord\Query::execute()
     * @param string $fieldName Record field name to get value from
     * @param string $return External variable to store query results
     * @return Ambigous <boolean, NULL, mixed>
     */
    public function fields($fieldName, & $return = null)
    {
        // Call handlers stack
        $this->_callHandlers();

        // Perform DB request
        $return = db()->fetchColumn($this->class_name, $this, $fieldName);

        $success = is_array($return) && sizeof($return);

        // If parent function has arguments - consider them as return value and return request status
        if (func_num_args() - 1 > 0) {
            return $success;

The return type of return $success; (boolean) is incompatible with the return type documented by samsonframework\orm\Query::fields of type samsonframework\orm\Ambigous.

        } else { // Parent function has no arguments, return request result
            return $return;
        }
    }

    /**
     * Perform database request and return different results depending on function arguments.
     * @see \samson\activerecord\Record
     * @param array $result External variable to store dabatase request results collection
     * @param integer|bool $rType Amount of arguments passed to parent function
     * @param integer $limit Quantity of records to return
     * @param callable $handler External callable handler for results modification
     * @param array $handlerArgs External callable handler arguments
     * @return boolean/array Boolean if $r_type > 0, otherwise array of request results

The doc-type boolean/array could not be parsed: Unknown type name "boolean/array" at position 0. (view supported doc-types)

     */
    protected function & execute(
        & $result = null,
        $rType = false,
        $limit = null,
        $handler = null,
        $handlerArgs = array()
    ) {
        // Call handlers stack
        $this->_callHandlers();

        // Perform DB request
        $result = db()->find($this->class_name, $this);

        // If external result handler is passed - use it
        if (isset($handler)) {
            // Add results collection to array
            array_unshift($handlerArgs, $result);

            // Call external handler with parameters
            $result = call_user_func_array($handler, $handlerArgs);
        }

        // Clear this query
        $this->flush();

        // Count records
        $count = sizeof($result);

        // Define is request was successful
        $success = is_array($result) && $count;

        // Is amount of records is specified
        if (isset($limit)) {
            // If we have not enough records - return null
            if ($count < $limit) {
                $result = null;
            } elseif ($limit === 1) { // If we need first record
                $result = array_shift($result);
            } elseif ($limit > 1) { // Slice array for necessary amount
                $result = array_slice($result, 0, $limit);
            }
        }

        // If parent function has arguments - consider them as return value and return request status
        if ($rType > 0) {
            return $success;
        } else { // Parent function has no arguments, return request result
            return $result;
        }
    }
}