FluentPdoModel::clearCacheByTable() - Code Metrics - Inspection of "Cleanup of caching" - terah/fluent-pdo-model - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 7d6fbb...2dc4cf )

by Terry
created 2016-01-15 02:51 UTC
FluentPdoModel::clearCacheByTable() A

↳ Parent: FluentPdoModel
Complexity

Conditions	3
Paths	4
Size

Total Lines	9
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
c	1
b	0
f	0
dl	0
loc	9
rs	9.6666
cc	3
eloc	5
nc	4
nop	1
<?php
/**
 * @package Terah\FluentPdoModel
 *
 * Original work Copyright (c) 2014 Mardix (http://github.com/mardix)
 * Modified work Copyright (c) 2015 Terry Cullen (http://github.com/terah)
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @license       http://www.opensource.org/licenses/mit-license.php MIT License
 */
namespace Terah\FluentPdoModel;

use Closure;
use PDOException;
use Exception;
use PDO;
use PDOStatement;
use stdClass;
use DateTime;
use Terah\FluentPdoModel\Drivers\AbstractPdo;
use Psr\Log\AbstractLogger;
use Terah\RedisCache\RedisCache;
use function Terah\Assert\Assert;
use function Terah\Assert\Validate;

use Prism\Models\Model;

/**
 * Class FluentPdoModel
 *
 * @package Terah\FluentPdoModel
 * @author  Terry Cullen - [email protected]
 */
class FluentPdoModel
{
    const OPERATOR_AND              = ' AND ';
    const OPERATOR_OR               = ' OR ';
    const ORDERBY_ASC               = 'ASC';
    const ORDERBY_DESC              = 'DESC';
    const SAVE_INSERT               = 'INSERT';
    const SAVE_UPDATE               = 'UPDATE';
    const LEFT_JOIN                 = 'LEFT';
    const INNER_JOIN                = 'INNER';
    const ONE_DAY                   = 86400;
    const ONE_WEEK                  = 60480060;
    const ONE_HOUR                  = 3600;
    const TEN_MINS                  = 600;
    const CACHE_NO                  = -1;
    const CACHE_DEFAULT             = 0;

    /** @var AbstractPdo $_connection */
    protected $_connection          = null;

    /** @var string */
    protected $_primary_key         = 'id';

    /** @var array */
    protected $_where_parameters    = [];

    /** @var array */
    protected $_select_fields       = [];

    /** @var array */
    protected $_join_sources        = [];

    /** @var array */
    protected $_join_aliases        = [];

    /** @var array $_associations */
    protected $_associations        = [
        'belongsTo' => [],
    ];

    /** @var array */
    protected $_where_conditions    = [];

    protected $_raw_sql             = null;

    /** @var int */
    protected $_limit               = null;

    /** @var int */
    protected $_offset              = null;

    /** @var array */
    protected $_order_by            = [];

    /** @var array */
    protected $_group_by            = [];

    /** @var string */
    protected $_and_or_operator     = self::OPERATOR_AND;

    /** @var array */
    protected $_having              = [];

    /** @var bool */
    protected $_wrap_open           = false;

    /** @var int */
    protected $_last_wrap_position  = 0;

    /** @var PDOStatement $_pdo_stmt */
    protected $_pdo_stmt            = null;

    /** @var bool */
    protected $_distinct            = false;

    /** @var null */
    protected $_requested_fields    = [];

    /** @var null */
    protected $_filter_meta         = [];

    /** @var bool */
    protected $_log_queries         = false;

    /** @var array */
    protected $_timer               = [];

    /** @var int */
    protected $_slow_query_secs     = 5;

    /** @var array */
    protected $_pagination_attribs  = [
        '_limit',
        '_offset',
        '_order',
        '_fields',
        '_search'
    ];

    /** @var string $_table_name */
    protected $_table_name          = null;

    /** @var string $_table_alias */
    protected $_table_alias         = null;

    /** @var string $_display_column */
    protected $_display_column      = null;

    /** @var string $_connection_name */
    protected $_connection_name     = null;

    /** @var array $_schema */
    protected $_schema              = [];

    /** @var array $_virtual_fields */
    protected $_virtual_fields      = [];

    /** @var array $_errors */
    protected $_errors              = [];

    /**
     * @var int - true  = connection default x days
     *          - false = no cache
     *          - int   = a specific amount
     */
    protected $_cache_ttl               = self::CACHE_NO;

    /** @var string */
    protected $_tmp_table_prefix        = 'tmp_';

    /** @var null|string */
    protected $_built_query             = null;

    // Make handlers public so whe can delete them externally to reduce memory in hhmv
    //protected $_handlers              = [];
    public $_handlers                   = [];

    /** @var bool User want to directly specify the fields */
    protected $_explicit_select_mode    = false;

    /** @var string[] */
    protected $_update_raw              = [];

    protected $_max_callback_failures   = null;

    protected $_num_callback_failures   = 0;

    protected $_filter_on_fetch         = false;

    protected $_log_filter_changes      = true;

    protected $_include_count           = false;

    /**
     * @param AbstractPdo|null $connection
     */
    public function __construct(AbstractPdo $connection=null)
    {
        $connection = !is_null($connection) ? $connection : ConnectionPool::get($this->_connection_name);
        $this->_connection  = $connection;
        $this->_log_queries = $connection->logQueries();
        $this->init();
    }

    public function init()
    {}

    /**
     * @return AbstractPdo
     * @throws Exception
     */
    public function getPdo()
    {
        return $this->_connection;
    }

    /**
     * @return AbstractLogger
     */
    public function getLogger()
    {
        return $this->_connection->getLogger();
    }

    /**
     * @return RedisCache
     */
    public function getCache()
    {
        return $this->_connection->getCache();
    }

    /**
     * Define the working table and create a new instance
     *
     * @param string $tableName - Table name
     * @param string $alias     - The table alias name
     * @param string $displayColumn
     * @param string $primaryKeyName
     *
     * @return $this
     */
    public function table($tableName, $alias='', $displayColumn='', $primaryKeyName='id')
    {
        return $this->reset()
            ->tableName($tableName)
            ->tableAlias($alias)
            ->displayColumn($displayColumn)
            ->primaryKeyName($primaryKeyName);
    }

    /**
     * @param $primaryKeyName
     * @return $this
     */
    public function primaryKeyName($primaryKeyName)
    {
        $this->_primary_key = $primaryKeyName;
        return $this;
    }

    /**
     * @param $tableName
     *
     * @return $this
     */
    public function tableName($tableName)
    {
        $this->_table_name  = $tableName;
        return $this;
    }

    /**
     * @param $explicitSelect
     *
     * @return $this
     */
    public function explicitSelectMode($explicitSelect=true)
    {
        $this->_explicit_select_mode  = (bool)$explicitSelect;
        return $this;
    }

    /**
     * @param bool $filterOnFetch
     *
     * @return $this
     */
    public function filterOnFetch($filterOnFetch=true)
    {
        $this->_filter_on_fetch  = (bool)$filterOnFetch;
        return $this;
    }

    /**
     * @param bool $logFilterChanges
     *
     * @return $this
     */
    public function logFilterChanges($logFilterChanges=true)
    {
        $this->_log_filter_changes  = (bool)$logFilterChanges;
        return $this;
    }

    /**
     * Return the name of the table
     *
     * @return string
     */
    public function getTableName()
    {
        return $this->_table_name;
    }

    /**
     * @return string
     */
    public function getDisplayColumn()
    {
        return $this->_display_column;
    }

    /**
     * Set the display column
     *
     * @param string $column
     *
     * @return $this
     */
    public function displayColumn($column)
    {
        $this->_display_column = $column;
        return $this;
    }
    /**
     * Set the table alias
     *
     * @param string $alias
     *
     * @return $this
     */
    public function tableAlias($alias)
    {
        $this->_table_alias = $alias;
        return $this;
    }

    /**
     * @param int $cacheTtl
     * @return $this
     * @throws Exception
     */
    protected function _cacheTtl($cacheTtl)
    {
        Assert($cacheTtl)->int('Cache ttl must be either -1 for no cache, 0 for default ttl or an integer for a custom ttl');
        if ( $cacheTtl !== self::CACHE_NO && ! is_null($this->_pdo_stmt) )
        {
            throw new Exception("You cannot cache pre-executed queries");
        }
        $this->_cache_ttl = $cacheTtl;
        return $this;
    }

    /**
     * @return string
     */
    public function getTableAlias()
    {
        return $this->_table_alias;
    }

    /**
     * @param array $associations
     *
     * @return $this
     */
    public function associations(array $associations)
    {
        $this->_associations = $associations;
        return $this;
    }

    /**
     * @param string $alias
     * @param array $definition
     * @return $this
     */
    public function setBelongsTo($alias, array $definition)
    {
        Assert($alias)->notEmpty();
        Assert($definition)->isArray()->count(4);

        $this->_associations['belongsTo'][$alias] = $definition;
        return $this;
    }

    public function setBelongsToDisplayField($alias, $displayField)
    {
        Assert($alias)->notEmpty();
        Assert($this->_associations['belongsTo'])->keyExists($alias);
        Assert($displayField)->notEmpty();

        $this->_associations['belongsTo'][$alias][2] = $displayField;
        return $this;
    }

    /**
     * @param PDOStatement $stmt
     *
     * @param PDOStatement $stmt
     * @param Closure $fnCallback
     * @return bool|stdClass
     */
    public function fetchRow(PDOStatement $stmt, Closure $fnCallback=null)
    {
        if ( ! ( $record = $stmt->fetch(PDO::FETCH_OBJ) ) )
        {
            return false;
        }
        $record = $this->onFetch($record);
        if ( empty($fnCallback) )
        {
            return $record;
        }
        $record = $fnCallback($record);
        if ( is_null($record) )
        {
            $this->getLogger()->warning("The callback is not returning any data which might be causing early termination of the result iteration");
        }
        unset($fnCallback);
        return $record;
    }

    /**
     * @param array $schema
     *
     * @return $this
     */
    public function schema(array $schema)
    {
        $this->_schema = $schema;
        return $this;
    }

    /**
     * @param string|array $field
     * @param $type
     * @return $this
     */
    public function addSchema($field, $type)
    {
        if ( is_array($field) )
        {
            foreach ( $field as $field_name => $type_def )
            {
                $this->addSchema($field_name, $type_def);
            }
            return $this;
        }
        $this->_schema[$field] = $type;
        return $this;
    }

    /**
     * @param $keys_only
     * @return array
     */
    public function getColumns($keys_only=true)
    {
        return $keys_only ? array_keys($this->_schema) : $this->_schema;
    }

    /**
     * Get the primary key name
     *
     * @return string
     */
    public function getPrimaryKeyName()
    {
        return $this->_formatKeyName($this->_primary_key, $this->_table_name);
    }

    /**
     * @param string $query
     * @param array $parameters
     *
     * @return bool
     * @throws Exception
     */
    public function execute($query, array $parameters=[])
    {
        list($this->_built_query, $ident)  = $this->_logQuery($query, $parameters);
        try
        {
            $this->_pdo_stmt        = $this->getPdo()->prepare($query);
            $result                 = $this->_pdo_stmt->execute($parameters);
            if ( false === $result )
            {
                $this->_pdo_stmt = null;
                throw new PDOException("The query failed to execute.");
            }
        }
        catch(Exception $e)
        {
            $built_query = $this->_built_query ? $this->_built_query : $this->buildQuery($query, $parameters);
            $this->getLogger()->error("FAILED: \n\n{$built_query}\n WITH ERROR:\n" . $e->getMessage());
            $this->_pdo_stmt = null;
            throw $e;
        }
        $this->_logSlowQueries($ident, $this->_built_query);
        return $result;
    }

    /**
     * @param string $query
     * @param array $params
     * @return $this
     */
    public function query($query, array $params=[])
    {
        $this->_raw_sql             = $query;
        $this->_where_parameters    = $params;
        return $this;
    }

    /**
     * @return bool
     */
    public function begin()
    {
        return $this->getPdo()->beginTransaction();
    }

    /**
     * @return bool
     */
    public function commit()
    {
        return $this->getPdo()->commit();
    }

    /**
     * @return bool
     */
    public function rollback()
    {
        $this->getLogger()->debug("Calling db transaction rollback.");
        return $this->getPdo()->rollBack();
    }


    /**
     * @param string $sql
     * @param array $params
     *
     * @return string
     */
    public function buildQuery($sql, array $params=[])
    {
        $indexed = $params == array_values($params);
        if ( $indexed )
        {
            foreach ( $params as $key => $val )
            {
                $val    = is_string($val) ? "'{$val}'" : $val;
                $val    = is_null($val) ? 'NULL' : $val;
                $sql    = preg_replace('/\?/', $val, $sql, 1);
            }
            return $sql;
        }

        uksort($params, function ($a, $b) {
            return strlen($b) - strlen($a);
        });
        foreach ( $params as $key => $val )
        {
            $val    = is_string($val) ? "'{$val}'" : $val;
            $val    = is_null($val) ? 'NULL' : $val;
            $sql    = str_replace(":$key", $val, $sql);
            //$sql    = str_replace("$key", $val, $sql);
        }
        return $sql;
    }

    /**
     * @param stdClass $record
     *
     * @return stdClass
     */
    protected function _trimAndLowerCaseKeys(stdClass $record)
    {
        $fnTrimStrings = function($value) {
            return is_string($value) ? trim($value) : $value;
        };
        $record = array_map($fnTrimStrings, array_change_key_case((array)$record, CASE_LOWER));
        unset($fnTrimStrings);
        return (object)$record;
    }

    /**
     * Return the number of affected row by the last statement
     *
     * @return int
     */
    public function rowCount()
    {
        $stmt = $this->fetchStmt();
        return $stmt ? $stmt->rowCount() : 0;
    }

    /**
     * @return PDOStatement
     * @throws PDOException
     */
    public function fetchStmt()
    {
        if ( null === $this->_pdo_stmt )
        {
            $this->execute($this->getSelectQuery(), $this->_getWhereParameters());
        }
        return $this->_pdo_stmt;
    }

    /**
     * @param bool $build
     * @return array
     */
    public function fetchSqlQuery($build=false)
    {
        $clone  = clone $this;
        $query  = $clone->getSelectQuery();
        $params = $clone->_getWhereParameters();
        $result = $build ? $clone->buildQuery($query, $params) : [$query, $params];
        unset($clone->_handlers, $clone, $query, $params, $build);
        return $result;
    }

    /**
     * @param string $table_name
     * @param bool  $drop_if_exists
     * @param array $indexes
     * @return $this
     * @throws Exception
     */
    public function fetchIntoMemoryTable($table_name, $drop_if_exists=true, array $indexes=[])
    {
        $table_name = preg_replace('/[^A-Za-z0-9_]+/', '', $table_name);
        $table_name = $this->_tmp_table_prefix . preg_replace('/^' . $this->_tmp_table_prefix . '/', '', $table_name);
        if ( $drop_if_exists )
        {
            $this->execute("DROP TABLE IF EXISTS {$table_name}");
        }
        $indexSql = [];
        foreach ( $indexes as $name => $column )
        {
            $indexSql[] = "INDEX {$name} ({$column})";
        }
        $indexSql = implode(", ", $indexSql);
        $indexSql = empty($indexSql) ? '' : "({$indexSql})";
        list($querySql, $params) = $this->fetchSqlQuery();
        $sql = <<<SQL
        CREATE TEMPORARY TABLE {$table_name} {$indexSql} ENGINE=MEMORY {$querySql}
SQL;
        return $this->execute($sql, $params);
    }

    /**
     * @param null $keyedOn
     * @param int $cacheTtl
     * @return mixed
     */
    public function fetch($keyedOn=null, $cacheTtl=self::CACHE_NO)
    {
        $this->_cacheTtl($cacheTtl);
        $fnCallback = function() use ($keyedOn) {

            $stmt   = $this->fetchStmt();
            $rows   = [];
            while ( $record = $this->fetchRow($stmt) )
            {
                if ( $record === false ) continue; // For scrutinizer...
                if ( $keyedOn && property_exists($record, $keyedOn) )
                {
                    $rows[$record->$keyedOn] = $record;
                    continue;
                }
                $rows[] = $record;
            }
            $this->reset();
            return $rows;
        };
        if ( $this->_cache_ttl === self::CACHE_NO )
        {
            return $fnCallback();
        }
        $table              = $this->getTableName();
        $id                 = $this->_parseWhereForPrimaryLookup();
        $id                 = $id ? "/{$id}" : '';
        list($sql, $params) = $this->fetchSqlQuery();
        $sql                = $this->buildQuery($sql, $params);
        $cacheKey           = "/{$table}{$id}/" . md5(json_encode([
            'sql'       => $sql,
            'keyed_on'  => $keyedOn,
        ]));
        return $this->_cacheData($cacheKey, $fnCallback, $this->_cache_ttl);
    }

    protected function _parseWhereForPrimaryLookup()
    {
        if ( ! ( $alias = $this->getTableAlias() ) )
        {
            return null;
        }
        foreach ( $this->_where_conditions as $idx => $conds )
        {
            if ( ! empty($conds['STATEMENT']) && $conds['STATEMENT'] === "{$alias}.id = ?" )
            {
                return ! empty($conds['PARAMS'][0]) ? $conds['PARAMS'][0] : null;
            }
        }
        return null;
    }

    /**
     * @param string $cacheKey
     * @param Closure $func
     * @param int $cacheTtl - 0 for default ttl, -1 for no cache or int for custom ttl
     * @return mixed|null
     */
    protected function _cacheData($cacheKey, Closure $func, $cacheTtl=self::CACHE_DEFAULT)
    {
        if ( $cacheTtl === self::CACHE_NO )
        {
            /** @noinspection PhpVoidFunctionResultUsedInspection */
            return $func->__invoke();
        }
        $data = $this->getCache()->get($cacheKey);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
        if ( $data && is_object($data) && property_exists($data, 'results') )
        {
            $this->getLogger()->debug("Cache hit on {$cacheKey}");
            return $data->results;
        }
        $this->getLogger()->debug("Cache miss on {$cacheKey}");
        /** @noinspection PhpVoidFunctionResultUsedInspection */
        $data = (object)[
            // Watch out... invoke most likely calls reset
            // which clears the model params like _cache_ttl
            'results' => $func->__invoke(),
        ];
        try
        {
            // The cache engine expects null for the default cache value
            $cacheTtl = $cacheTtl === self::CACHE_DEFAULT ? null : $cacheTtl;
            /** @noinspection PhpMethodParametersCountMismatchInspection */
            if ( ! $this->getCache()->set($cacheKey, $data, $cacheTtl) )
            {
                throw new \Exception("Could not save data to cache");
            }
            return $data->results;
        }
        catch (\Exception $e)
        {
            $this->getLogger()->error($e->getMessage(), $e->getTrace());
            return $data->results;
        }
    }

    /**
     * @param string $cacheKey
     * @return bool
     */
    public function clearCache($cacheKey)
    {
        return $this->getCache()->delete($cacheKey);
    }

    /**
     * @param string|null $table
     * @return bool
     */
    public function clearCacheByTable($table=null)
    {
        $table = ! is_null($table) ? $table : $this->getTableName();
        if ( empty($table) )
        {
            return true;
        }
        return $this->clearCache("/{$table}/");
    }

    /**
     * @param Closure $fnCallback
     * @param null     $keyedOn
     * @param bool     $returnSuccessCnt
     * @return stdClass[]|int
     */
    public function fetchCallback(Closure $fnCallback, $keyedOn=null, $returnSuccessCnt=true)
    {
        $successCnt    = 0;
        $stmt           = $this->fetchStmt();
        if ( ! $returnSuccessCnt )
        {
            $rows   = [];
            while ( $record = $this->fetchRow($stmt, $fnCallback) )
            {
                if ( $keyedOn && property_exists($record, $keyedOn) )
                {
                    $rows[$record->$keyedOn] = $record;
                    continue;
                }
                $rows[] = $record;
            }
            $this->reset();
            return $rows;
        }
        while ( $this->_tallySuccessCount($stmt, $fnCallback, $successCnt) )
        {}
        return $successCnt;
    }

    /**
     * @param $numFailures
     * @return $this
     */
    public function maxCallbackFailures($numFailures)
    {
        Assert($numFailures)->int();
        $this->_max_callback_failures = $numFailures;
        return $this;
    }

    /**
     * @param PDOStatement $stmt
     * @param Closure $fnCallback
     * @param int $successCnt
     * @return bool|null|stdClass
     */
    protected function _tallySuccessCount($stmt, Closure $fnCallback, &$successCnt)
    {
        $record = $this->fetchRow($stmt);
        if ( $record === false )
        {
            return false;
        }
        $record = $fnCallback($record);
        // Callback return null then we want to exit the fetch loop
        if ( is_null($record) )
        {
            $this->getLogger()->warning("The callback is not returning any data which might be causing early termination of the result iteration");
            return null;
        }
        // The not record then don't bump the tally
        if ( ! $record )
        {
            $this->_num_callback_failures++;
            if ( ! is_null($this->_max_callback_failures) && $this->_num_callback_failures >= $this->_max_callback_failures )
            {
                $this->getLogger()->error("The callback has failed {$this->_max_callback_failures} times... aborting...");
                $successCnt = null;
                return null;
            }
            return true;
        }
        $successCnt++;
        return $record;
    }

    /**
     * @param null|string $keyedOn
     * @param null|mixed $valueField
     * @param int $cacheTtl
     * @return mixed
     */
    public function fetchList($keyedOn=null, $valueField=null, $cacheTtl=self::CACHE_NO)
    {
        $keyedOn           = ! is_null($keyedOn) ? $keyedOn : $this->getPrimaryKeyName();
        $valueField        = ! is_null($valueField) ? $valueField : $this->getDisplayColumn();
        $keyedOnAlias     = strtolower(str_replace('.', '_', $keyedOn));
        $valueFieldAlias  = strtolower(str_replace('.', '_', $valueField));

        $this->_cacheTtl($cacheTtl);
        $fnCallback         = function() use ($keyedOn, $keyedOnAlias, $valueField, $valueFieldAlias) {

            $rows = [];
            $stmt = $this->select(null)
                ->select($keyedOn, $keyedOnAlias)
                ->select($valueField, $valueFieldAlias)
                ->fetchStmt();
            while ( $record = $this->fetchRow($stmt) )
            {
                $rows[$record->$keyedOnAlias] = $record->$valueFieldAlias;
            }
            return $rows;
        };
        if ( $this->_cache_ttl === self::CACHE_NO )
        {
            $result = $fnCallback();
            unset($cacheKey, $fnCallback);
            return $result;
        }
        $table              = $this->getTableName();
        $cacheKey           = md5(json_encode([
            'sql'               => $this->fetchSqlQuery(),
            'keyed_on'          => $keyedOn,
            'keyed_on_alias'    => $keyedOnAlias,
            'value_field'       => $valueField,
            'value_fieldAlias'  => $valueFieldAlias,
        ]));
        return $this->_cacheData("/{$table}/list/{$cacheKey}", $fnCallback, $this->_cache_ttl);
    }

    /**
     * @param string $column
     * @param int $cacheTtl
     * @param bool|true $unique
     * @return array|mixed
     */
    public function fetchColumn($column, $cacheTtl=self::CACHE_NO, $unique=true)
    {
        $list = $this->select($column)->fetch(null, $cacheTtl);
        foreach ( $list as $idx => $obj )
        {
            $list[$idx] = $obj->{$column};
        }
        return $unique ? array_unique($list) : $list;
    }

    /**
     * @param null|string $field
     * @param null|int $itemId
     * @param int $cacheTtl
     * @return mixed|null
     */
    public function fetchField($field=null, $itemId=null, $cacheTtl=self::CACHE_NO)
    {
        $field  = !is_null($field) ? $field : $this->getPrimaryKeyName();
        $this->_cacheTtl($cacheTtl);
        $object = $this->select(null)->select($field)->fetchOne($itemId);
        if ( ! $object )
        {
            return null;
        }
        // Handle aliases
        if ( preg_match('/ as /i', $field) )
        {
            list($expression, $alias) = preg_split('/ as /i', $field);
            unset($expression);
            $field = trim($alias);
        }
        if ( strpos($field, '.') !== false )
        {
            list($tableAlias, $field) = explode('.', $field);
            unset($tableAlias);
        }
        return property_exists($object, $field) ? $object->$field : null;
    }

    /**
     * @param int|null $id
     * @param int $cacheTtl
     * @return \stdClass|bool
     */
    public function fetchOne($id=null, $cacheTtl=self::CACHE_NO)
    {
        if ( $id )
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
        {
            $this->wherePK($id, true);
        }
        $this->_cacheTtl($cacheTtl);
        $this->limit(1);
        $fetchAll = $this->fetch();
        return $fetchAll ? array_shift($fetchAll) : false;
    }

    /**
     * @param int|null $id
     * @param int $cacheTtl
     * @return \stdClass|bool
     */
    public function fetchExists($id=null, $cacheTtl=self::CACHE_NO)
    {
        if ( $id )
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
        {
            $this->wherePK($id, true);
        }
        $this->_cacheTtl($cacheTtl);
        return $this->count() !== 0;
    }

    /*------------------------------------------------------------------------------
                                    Fluent Query Builder
    *-----------------------------------------------------------------------------*/

    /**
     * Create the select clause
     *
     * @param  mixed    $columns  - the column to select. Can be string or array of fields
     * @param  string   $alias - an alias to the column
     * @param bool|true $explicitSelect
     * @return $this
     */
    public function select($columns='*', $alias=null, $explicitSelect=true)
    {
        if ( $explicitSelect )
        {
            $this->explicitSelectMode();
        }
        if ( ! empty($alias) && !is_array($columns) & $columns !== $alias )
        {
            $columns .= " AS {$alias} ";
        }
        if ( $columns === '*' && !empty($this->_schema) )
        {
            $columns = $this->getColumns();
        }
        // Reset the select list
        if ( is_null($columns) )
        {
            $this->_select_fields = [];
            return $this;
        }
        $columns = is_array($columns) ? $columns : [$columns];

//        if ( empty($this->_select_fields) && $addAllIfEmpty )
//        {
//            $this->select('*');
//        }
        if ( $this->_table_alias )
        {
            $schema = $this->columns();
            foreach ( $columns as $idx => $col )
            {
                if ( in_array($col, $schema) )
                {
                    $columns[$idx] = "{$this->_table_alias}.{$col}";
                }
            }
        }
        $this->_select_fields = array_merge($this->_select_fields, $columns);
        return $this;
    }

    public function selectRaw($select)
    {
        $this->_select_fields[] = $select;
        return $this;
    }

    /**
     * @param bool $log_queries
     *
     * @return $this
     */
    public function logQueries($log_queries=true)
    {
        $this->_log_queries = $log_queries;
        return $this;
    }

    /**
     * @param bool $include_count
     *
     * @return $this
     */
    public function includeCount($include_count=true)
    {
        $this->_include_count = $include_count;
        return $this;
    }

    /**
     * @param bool $distinct
     *
     * @return $this
     */
    public function distinct($distinct=true)
    {
        $this->_distinct = $distinct;
        return $this;
    }

    /**
     * @param array $fields
     * @return $this
     */
    public function withBelongsTo($fields=[])
    {
        if ( ! empty($this->_associations['belongsTo']) )
        {
            foreach ( $this->_associations['belongsTo'] as $alias => $config )
            {
                $addFieldsForJoins = empty($fields) || in_array($config[3], $fields);
                $this->autoJoin($alias, self::LEFT_JOIN, $addFieldsForJoins);
            }
        }
        return $this;
    }

    /**
     * @param string $alias
     * @param string $type
     * @param bool   $addSelectField
     * @return $this
     */
    public function autoJoin($alias, $type=self::LEFT_JOIN, $addSelectField=true)
    {
        Assert($this->_associations['belongsTo'])->keyExists($alias, "Invalid join... the alias does not exists");
        list($table, $join_col, $field, $fieldAlias) = $this->_associations['belongsTo'][$alias];
        $condition = "{$alias}.id = {$this->_table_alias}.{$join_col}";
        if ( in_array($alias, $this->_join_aliases) )
        {
            return $this;
        }
        $this->join($table, $condition, $alias, $type);
        if ( $addSelectField )
        {
            $this->select($field, $fieldAlias, false);
        }
        return $this;
    }

    /**
     * Add where condition, more calls appends with AND
     *
     * @param string $condition possibly containing ? or :name
     * @param mixed $parameters accepted by PDOStatement::execute or a scalar value
     * @param mixed ...
     * @return $this
     */
    public function where($condition, $parameters = [])
    {
        // By default the and_or_operator and wrap operator is AND,
        if ( $this->_wrap_open || ! $this->_and_or_operator )
        {
            $this->_and();
        }

        // where(array("column1" => 1, "column2 > ?" => 2))
        if ( is_array($condition) )
        {
            foreach ($condition as $key => $val)
            {
                $this->where($key, $val);
            }
            return $this;
        }

        $args = func_num_args();
        if ( $args != 2 || strpbrk($condition, '?:') )
        { // where('column < ? OR column > ?', array(1, 2))
            if ( $args != 2 || !is_array($parameters) )
            { // where('column < ? OR column > ?', 1, 2)
                $parameters = func_get_args();
                array_shift($parameters);
            }
        }
        else if ( !is_array($parameters) )
        {//where(column,value) => column=value
            $condition .= ' = ?';
            $parameters = [$parameters];
        }
        else if ( is_array($parameters) )
        { // where('column', array(1, 2)) => column IN (?,?)
            $placeholders = $this->_makePlaceholders(count($parameters));
            $condition = "({$condition} IN ({$placeholders}))";
        }

        $this->_where_conditions[] = [
            'STATEMENT'   => $condition,
            'PARAMS'      => $parameters,
            'OPERATOR'    => $this->_and_or_operator
        ];
        // Reset the where operator to AND. To use OR, you must call _or()
        $this->_and();
        return $this;
    }

    /**
     * Create an AND operator in the where clause
     *
     * @return $this
     */
    public function _and()
    {
        if ( $this->_wrap_open )
        {
            $this->_where_conditions[] = self::OPERATOR_AND;
            $this->_last_wrap_position = count($this->_where_conditions);
            $this->_wrap_open = false;
            return $this;
        }
        $this->_and_or_operator = self::OPERATOR_AND;
        return $this;
    }


    /**
     * Create an OR operator in the where clause
     *
     * @return $this
     */
    public function _or()
    {
        if ( $this->_wrap_open )
        {
            $this->_where_conditions[] = self::OPERATOR_OR;
            $this->_last_wrap_position = count($this->_where_conditions);
            $this->_wrap_open = false;
            return $this;
        }
        $this->_and_or_operator = self::OPERATOR_OR;
        return $this;
    }

    /**
     * To group multiple where clauses together.
     *
     * @return $this
     */
    public function wrap()
    {
        $this->_wrap_open = true;
        $spliced = array_splice($this->_where_conditions, $this->_last_wrap_position, count($this->_where_conditions), '(');
        $this->_where_conditions = array_merge($this->_where_conditions, $spliced);
        array_push($this->_where_conditions,')');
        $this->_last_wrap_position = count($this->_where_conditions);
        return $this;
    }

    /**
     * Where Primary key
     *
     * @param      integer $id
     * @param bool $addAlias
     *
     * @return $this
     */
    public function wherePK($id, $addAlias=true)
    {
        $alias = $addAlias && !empty($this->_table_alias) ? "{$this->_table_alias}." : '';
        return $this->where($alias . $this->getPrimaryKeyName(), $id);
    }

    /**
     * WHERE $columnName != $value
     *
     * @param  string   $columnName
     * @param  mixed    $value
     * @return $this
     */
    public function whereNot($columnName, $value)
    {
        return $this->where("$columnName != ?", $value);
    }
    /**
     * WHERE $columnName != $value
     *
     * @param  string   $columnName
     * @param  mixed    $value
     * @return $this
     */
    public function whereCoercedNot($columnName, $value)
    {
        return $this->where("IFNULL({$columnName}, '') != ?", $value);
    }

    /**
     * WHERE $columnName LIKE $value
     *
     * @param  string   $columnName
     * @param  mixed    $value
     * @return $this
     */
    public function whereLike($columnName, $value)
    {
        return $this->where("$columnName LIKE ?", $value);
    }

    /**
     * @param string $columnName
     * @param mixed $value1
     * @param mixed $value2
     * @return $this
     */
    public function whereBetween($columnName, $value1, $value2)
    {
        return $this->where("$columnName BETWEEN ? AND ?", [$value1, $value2]);
    }

    /**
     * @param string $columnName
     * @param mixed $value1
     * @param mixed $value2
     * @return $this
     */
    public function whereNotBetween($columnName, $value1, $value2)
    {
        return $this->where("$columnName BETWEEN ? AND ?", [$value1, $value2]);
    }

    /**
     * @param string $columnName
     * @param string $regex
     * @return $this
     */
    public function whereRegex($columnName, $regex)
    {
        return $this->where("$columnName REGEXP ?", $regex);
    }

    /**
     * @param string $columnName
     * @param string $regex
     * @return $this
     */
    public function whereNotRegex($columnName, $regex)
    {
        return $this->where("$columnName NOT REGEXP ?", $regex);
    }

    /**
     * WHERE $columnName NOT LIKE $value
     *
     * @param  string   $columnName
     * @param  mixed    $value
     * @return $this
     */
    public function whereNotLike($columnName, $value)
    {
        return $this->where("$columnName NOT LIKE ?", $value);
    }

    /**
     * WHERE $columnName > $value
     *
     * @param  string   $columnName
     * @param  mixed    $value
     * @return $this
     */
    public function whereGt($columnName, $value)
    {
        return $this->where("$columnName > ?", $value);
    }

    /**
     * WHERE $columnName >= $value
     *
     * @param  string   $columnName
     * @param  mixed    $value
     * @return $this
     */
    public function whereGte($columnName, $value)
    {
        return $this->where("$columnName >= ?", $value);
    }

    /**
     * WHERE $columnName < $value
     *
     * @param  string   $columnName
     * @param  mixed    $value
     * @return $this
     */
    public function whereLt($columnName, $value)
    {
        return $this->where("$columnName < ?", $value);
    }

    /**
     * WHERE $columnName <= $value
     *
     * @param  string   $columnName
     * @param  mixed    $value
     * @return $this
     */
    public function whereLte($columnName, $value)
    {
        return $this->where("$columnName <= ?", $value);
    }

    /**
     * WHERE $columnName IN (?,?,?,...)
     *
     * @param  string   $columnName
     * @param  array    $values
     * @return $this
     */
    public function whereIn($columnName, array $values)
    {
        return $this->where($columnName,$values);
    }

    /**
     * WHERE $columnName NOT IN (?,?,?,...)
     *
     * @param  string   $columnName
     * @param  array    $values
     * @return $this
     */
    public function whereNotIn($columnName, array $values)
    {
        $placeholders = $this->_makePlaceholders(count($values));
        return $this->where("({$columnName} NOT IN ({$placeholders}))", $values);
    }

    /**
     * WHERE $columnName IS NULL
     *
     * @param  string   $columnName
     * @return $this
     */
    public function whereNull($columnName)
    {
        return $this->where("({$columnName} IS NULL)");
    }

    /**
     * WHERE $columnName IS NOT NULL
     *
     * @param  string   $columnName
     * @return $this
     */
    public function whereNotNull($columnName)
    {
        return $this->where("({$columnName} IS NOT NULL)");
    }

    /**
     * @param string $statement
     * @param string $operator
     * @return $this
     */
    public function having($statement, $operator = self::OPERATOR_AND)
    {
        $this->_having[] = [
            'STATEMENT'   => $statement,
            'OPERATOR'    => $operator
        ];
        return $this;
    }

    /**
     * ORDER BY $columnName (ASC | DESC)
     *
     * @param  string   $columnName - The name of the column or an expression
     * @param  string   $ordering   (DESC | ASC)
     * @return $this
     */
    public function orderBy($columnName, $ordering=null)
    {
        Assert($ordering)->nullOr()->inArray(['DESC', 'desc', 'ASC', 'asc']);
        if ( is_null($columnName) )
        {
            $this->_order_by = [];
            return $this;
        }
        $this->_order_by[] = trim("{$columnName} {$ordering}");
        return $this;
    }

    /**
     * GROUP BY $columnName
     *
     * @param  string   $columnName
     * @return $this
     */
    public function groupBy($columnName)
    {
        $columnName = is_array($columnName) ? $columnName : [$columnName];
        foreach ( $columnName as $col )
        {
            $this->_group_by[] = $col;
        }
        return $this;
    }


    /**
     * LIMIT $limit
     *
     * @param  int      $limit
     * @param  int|null $offset
     * @return $this
     */
    public function limit($limit, $offset=null)
    {
        $this->_limit =  (int)$limit;
        if ( ! is_null($offset) )
        {
            $this->offset($offset);
        }
        return $this;
    }

    /**
     * Return the limit
     *
     * @return integer
     */
    public function getLimit()
    {
        return $this->_limit;
    }

    /**
     * OFFSET $offset
     *
     * @param  int      $offset
     * @return $this
     */
    public function offset($offset)
    {
        $this->_offset = (int)$offset;
        return $this;
    }

    /**
     * Return the offset
     *
     * @return integer
     */
    public function getOffset()
    {
        return $this->_offset;
    }

    /**
     * Build a join
     *
     * @param  string    $table         - The table name
     * @param  string   $constraint    -> id = profile.user_id
     * @param  string   $tableAlias   - The alias of the table name
     * @param  string   $joinOperator - LEFT | INNER | etc...
     * @return $this
     */
    public function join($table, $constraint=null, $tableAlias = null, $joinOperator = '')
    {
        if ( is_null($constraint) )
        {
            return $this->autoJoin($table, $joinOperator);
        }
        $join                   = [$joinOperator ? "{$joinOperator} " : ''];
        $join[]                 = "JOIN {$table} ";
        $tableAlias            = is_null($tableAlias) ? Inflector::classify($table) : $tableAlias;
        $join[]                 = $tableAlias ? "AS {$tableAlias} " : '';
        $join[]                 = "ON {$constraint}";
        $this->_join_sources[]  = implode('', $join);
        if ( $tableAlias )
        {
            $this->_join_aliases[]  = $tableAlias;
        }
        return $this;
    }

    /**
     * Create a left join
     *
     * @param  string   $table
     * @param  string   $constraint
     * @param  string   $tableAlias
     * @return $this
     */
    public function leftJoin($table, $constraint, $tableAlias=null)
    {
        return $this->join($table, $constraint, $tableAlias, self::LEFT_JOIN);
    }


    /**
     * Return the build select query
     *
     * @return string
     */
    public function getSelectQuery()
    {
        if ( ! is_null($this->_raw_sql) )
        {
            return $this->_raw_sql;
        }
        if ( empty($this->_select_fields) || ! $this->_explicit_select_mode )
        {
            $this->select('*', null, false);
        }
        foreach ( $this->_select_fields as $idx => $cols )
        {
            if ( strpos(trim(strtolower($cols)), 'distinct ') === 0 )
            {
                $this->_distinct = true;
                $this->_select_fields[$idx] = str_ireplace('distinct ', '', $cols);
            }
        }
        if ( $this->_include_count )
        {
            $this->select('COUNT(*) as __cnt');
        }
        $query  = 'SELECT ';
        $query .= $this->_distinct ? 'DISTINCT ' : '';
        $query .= implode(', ', $this->_prepareColumns($this->_select_fields));
        $query .= " FROM {$this->_table_name}" . ( $this->_table_alias ? " {$this->_table_alias}" : '' );
        if ( count($this->_join_sources ) )
        {
            $query .= (' ').implode(' ',$this->_join_sources);
        }
        $query .= $this->_getWhereString(); // WHERE
        if ( count($this->_group_by) )
        {
            $query .= ' GROUP BY ' . implode(', ', array_unique($this->_group_by));
        }
        if ( count($this->_order_by ) )
        {
            $query .= ' ORDER BY ' . implode(', ', array_unique($this->_order_by));
        }
        $query .= $this->_getHavingString(); // HAVING
        return $this->_connection->setLimit($query, $this->_limit, $this->_offset);
    }

    /**
     * Prepare columns to include the table alias name
     * @param array $columns
     * @return array
     */
    protected function _prepareColumns(array $columns)
    {
        if ( ! $this->_table_alias )
        {
            return $columns;
        }
        $newColumns = [];
        foreach ($columns as $column)
        {
            if ( strpos($column, ',') && ! preg_match('/^[a-zA-Z]{2,200}\(.{1,500}\)/', trim($column)) )
            {
                $newColumns = array_merge($this->_prepareColumns(explode(',', $column)), $newColumns);
            }
            elseif ( preg_match('/^(AVG|SUM|MAX|MIN|COUNT|CONCAT)/', $column) )
            {
                $newColumns[] = trim($column);
            }
            elseif (strpos($column, '.') === false && strpos(strtoupper($column), 'NULL') === false)
            {
                $column         = trim($column);
                $newColumns[]   = preg_match('/^[0-9]/', $column) ? trim($column) : "{$this->_table_alias}.{$column}";
            }
            else
            {
                $newColumns[] = trim($column);
            }
        }
        return $newColumns;
    }

    /**
     * Build the WHERE clause(s)
     *
     * @param bool $purgeAliases
     * @return string
     */
    protected function _getWhereString($purgeAliases=false)
    {
        // If there are no WHERE clauses, return empty string
        if ( empty($this->_where_conditions) )
        {
            return '';
        }
        $where_condition = '';
        $last_condition = '';
        foreach ( $this->_where_conditions as $condition )
        {
            if ( is_array($condition) )
            {
                if ( $where_condition && $last_condition != '(' && !preg_match('/\)\s+(OR|AND)\s+$/i', $where_condition))
                {
                    $where_condition .= $condition['OPERATOR'];
                }
                if ( $purgeAliases && ! empty($condition['STATEMENT']) && strpos($condition['STATEMENT'], '.') !== false && ! empty($this->_table_alias) )
                {
                    $condition['STATEMENT'] = preg_replace("/{$this->_table_alias}\./", '', $condition['STATEMENT']);
                }
                $where_condition .= $condition['STATEMENT'];
                $this->_where_parameters = array_merge($this->_where_parameters, $condition['PARAMS']);
            }
            else
            {
                $where_condition .= $condition;
            }
            $last_condition = $condition;
        }
        return " WHERE {$where_condition}" ;
    }

    /**
     * Return the HAVING clause
     *
     * @return string
     */
    protected function _getHavingString()
    {
        // If there are no WHERE clauses, return empty string
        if ( empty($this->_having) )
        {
            return '';
        }
        $having_condition = '';
        foreach ( $this->_having as $condition )
        {
            if ( $having_condition && !preg_match('/\)\s+(OR|AND)\s+$/i', $having_condition) )
            {
                $having_condition .= $condition['OPERATOR'];
            }
            $having_condition .= $condition['STATEMENT'];
        }
        return " HAVING {$having_condition}" ;
    }

    /**
     * Return the values to be bound for where
     *
     * @param bool $purgeAliases
     * @return array
     */
    protected function _getWhereParameters($purgeAliases=false)
    {
        unset($purgeAliases);
        return $this->_where_parameters;
    }

    /**
     * Insert new rows
     * $records can be a stdClass or an array of stdClass to add a bulk insert
     * If a single row is inserted, it will return it's row instance
     *
     * @param stdClass|array $records
     * @return int|stdClass|bool
     * @throws Exception
     */
    public function insert($records)
    {
        Assert($records)->notEmpty("The data passed to insert does not contain any data");
        $records = is_array($records) ? $records : [$records];
        Assert($records)->all()->isInstanceOf('stdClass', "The data to be inserted must be an object or an array of objects");

        foreach ( $records as $key => $record )
        {
            $records[$key] = $this->beforeSave($records[$key], self::SAVE_INSERT);
            if ( ! empty($this->_errors) )
            {
                return false;
            }
        }
        list($sql, $insert_values) = $this->insertSqlQuery($records);
        $this->execute($sql, $insert_values);
        $rowCount = $this->rowCount();
        if ( $rowCount === 1 )
        {
            $primaryKeyName                 = $this->getPrimaryKeyName();
            $records[0]->$primaryKeyName    = $this->getLastInsertId($primaryKeyName);
        }
        foreach ( $records as $key => $record )
        {
            $records[$key] = $this->afterSave($record, self::SAVE_INSERT);
        }
        $this->destroy();
        // On single element return the object
        return $rowCount === 1 ? $records[0] : $rowCount;
    }

    /**
     * @param null $name
     * @return int
     */
    public function getLastInsertId($name=null)
    {
        return (int)$this->getPdo()->lastInsertId($name);
    }

    /**
     * @param $records
     * @return array
     */
    public function insertSqlQuery($records)
    {
        Assert($records)->notEmpty("The data passed to insert does not contain any data");
        $records = is_array($records) ? $records : [$records];
        Assert($records)->all()->isInstanceOf('stdClass', "The data to be inserted must be an object or an array of objects");

        $insert_values  = [];
        $question_marks = [];
        $properties     = [];
        foreach ( $records as $record )
        {
            $properties         = !empty($properties) ? $properties : array_keys(get_object_vars($record));
            $question_marks[]   = '('  . $this->_makePlaceholders(count($properties)) . ')';
            $insert_values      = array_merge($insert_values, array_values((array)$record));
        }
        $properties     = implode(', ', $properties);
        $question_marks = implode(', ', $question_marks);
        $sql            = "INSERT INTO {$this->_table_name} ({$properties}) VALUES {$question_marks}";
        return [$sql, $insert_values];
    }

    /**
     * @param       $data
     * @param array $matchOn
     * @param bool  $returnObj
     * @return bool|int|stdClass
     */
    public function upsert($data, array $matchOn=[], $returnObj=false)
    {
        if ( ! is_array($data) )
        {
            return $this->upsertOne($data, $matchOn, $returnObj);
        }
        Assert($data)
            ->notEmpty("The data passed to insert does not contain any data")
            ->all()->isInstanceOf('stdClass', "The data to be inserted must be an object or an array of objects");
        $num_success    = 0;
        foreach ( $data as $row )
        {
            $clone = clone $this;
            if ( $clone->upsertOne($row, $matchOn) )
            {
                $num_success++;
            }
            unset($clone->_handlers, $clone); // hhvm mem leak
        }
        return $num_success;
    }

    /**
     * @param stdClass $object
     * @param array    $matchOn
     * @param bool     $returnObj
     * @return bool|int|stdClass
     */
    public function upsertOne(stdClass $object, array $matchOn=[], $returnObj=false)
    {
        $primary_key    = $this->getPrimaryKeyName();
        $matchOn       = empty($matchOn) && property_exists($object, $primary_key) ? [$primary_key] : $matchOn;
        foreach ( $matchOn as $column )
        {
            Assert( ! property_exists($object, $column) && $column !== $primary_key)->false('The match on value for upserts is missing.');
            if ( property_exists($object, $column) )
            {
                if ( is_null($object->$column) )
                {
                    $this->whereNull($column);
                }
                else
                {
                    $this->where($column, $object->$column);
                }
            }
        }
        if ( count($this->_where_conditions) < 1 )
        {
            return $this->insert($object);
        }
        if ( ( $id = (int)$this->fetchField($primary_key) ) )
        {
            if ( property_exists($object, $primary_key) && is_null($object->$primary_key) )
            {
                $object->$primary_key = $id;
            }
            $rows_affected = $this->reset()->wherePk($id)->update($object);
            if ( $rows_affected === false )
            {
                return false;
            }
            return $returnObj ? $this->reset()->fetchOne($id) : $id;
        }
        return $this->insert($object);
    }

    /**
     * @param array      $data
     * @param array      $matchOn
     * @param bool|false $returnObj
     * @return bool|int|stdClass
     */
    public function upsertArr(array $data, array $matchOn=[], $returnObj=false)
    {
        return $this->upsert((object)$data, $matchOn, $returnObj);
    }

    /**
     * Update entries
     * Use the query builder to create the where clause
     *
     * @param stdClass $record
     * @param bool     $updateAll
     * @return bool|int
     * @throws Exception
     */
    public function update(stdClass $record, $updateAll=false)
    {
        Assert($record)
            ->notEmpty("The data passed to update does not contain any data")
            ->isInstanceOf('stdClass', "The data to be updated must be an object or an array of objects");

        if ( empty($this->_where_conditions) && ! $updateAll )
        {
            throw new Exception("You cannot update an entire table without calling update with updateAll=true", 500);
        }
        $record = $this->beforeSave($record, self::SAVE_UPDATE);
        if ( ! empty($this->_errors) )
        {
            return false;
        }
        list($sql, $values) = $this->updateSqlQuery($record);
        $this->execute($sql, $values);
        $this->afterSave($record, self::SAVE_UPDATE);
        $row_count = $this->rowCount();
        $this->destroy();
        return $row_count;
    }

    /**
     * @param array      $record
     * @param bool|false $updateAll
     * @return bool|int
     * @throws Exception
     */
    public function updateArr(array $record, $updateAll=false)
    {
        return $this->update((object)$record, $updateAll);
    }

    /**
     * @param array $record
     * @return bool|int|stdClass
     */
    public function insertArr(array $record)
    {
        return $this->insert((object)$record);
    }

    /**
     * @param int     $field
     * @param mixed   $value
     * @param null $id
     * @param bool|false $updateAll
     * @return bool|int
     * @throws Exception
     */
    public function updateField($field, $value, $id=null, $updateAll=false)
    {
        if ( ! is_null($id) )
        {
            $this->wherePk($id);
        }
        return $this->update((object)[$field => $value], $updateAll);
    }

    /**
     * @param int     $field
     * @param mixed   $value
     * @param null $id
     * @param bool|false $updateAll
     * @return bool|int
     * @throws Exception
     */
    public function concatField($field, $value, $id=null, $updateAll=false)

    {

    }

    /**
     * @param stdClass $record
     * @return bool|int
     * @throws Exception
     */
    public function updateChanged(stdClass $record)
    {
        foreach ( $record as $field => $value )

        {
            if ( is_null($value) )
            {
                $this->whereNotNull($field);
                continue;
            }
            $this->whereCoercedNot($field, $value);
        }
        return $this->update($record);
    }

    /**
     * @param string    $expression
     * @param array     $params
     * @return $this
     */
    public function updateByExpression($expression, array $params)
    {
        $this->_update_raw[] = [$expression, $params];
        return $this;
    }

    /**
     * @param array $data
     * @return int
     * @throws Exception
     */
    public function rawUpdate(array $data=[])
    {
        list($sql, $values) = $this->updateSql($data);
        $this->execute($sql, $values);
        $row_count = $this->rowCount();
        $this->destroy();
        return $row_count;
    }

    /**
     * @param stdClass $record
     * @return array
     */
    public function updateSqlQuery(stdClass $record)
    {
        Assert($record)
            ->notEmpty("The data passed to update does not contain any data")
            ->isInstanceOf('stdClass', "The data to be updated must be an object or an array of objects");

        // Make sure we remove the primary key
        $record = (array)$record;
        return $this->updateSql($record);
    }

    /**
     * @param $record
     * @return array
     */
    protected function updateSql(array $record)
    {
        unset($record[$this->getPrimaryKeyName()]);
        // Sqlite needs a null primary key
        //$record[$this->getPrimaryKeyName()] = null;
        $field_list = [];
        foreach ( $record as $key => $value )
        {
            if ( is_numeric($key) )
            {
                $field_list[] = $value;
                unset($record[$key]);
                continue;
            }
            $field_list[] = "{$key} = ?";
        }
        $rawParams  = [];
        foreach ( $this->_update_raw as $rawUpdate )
        {
            $field_list[]   = $rawUpdate[0];
            $rawParams      = array_merge($rawParams, $rawUpdate[1]);
        }
        $field_list     = implode(', ', $field_list);
        $where_str      = $this->_getWhereString();
        $joins          = ! empty($this->_join_sources) ? (' ').implode(' ',$this->_join_sources) : '';
        $alias          = ! empty($this->_table_alias) ? " AS {$this->_table_alias}" : '';
        $sql            = "UPDATE {$this->_table_name}{$alias}{$joins} SET {$field_list}{$where_str}";
        $values         = array_merge(array_values($record), $rawParams, $this->_getWhereParameters());
        return [$sql, $values];
    }

    /**
     * Delete rows
     * Use the query builder to create the where clause
     * @param bool $deleteAll = When there is no where condition, setting to true will delete all
     * @return int - total affected rows
     * @throws Exception
     */
    public function delete($deleteAll=false)
    {
        list($sql, $params) = $this->deleteSqlQuery();
        if ( empty($this->_where_conditions) && ! $deleteAll )
        {
            throw new Exception("You cannot update an entire table without calling update with deleteAll=true");
        }
        $this->execute($sql, $params);
        return $this->rowCount();
    }

    /**
     * @param bool|false $force
     * @return $this
     * @throws Exception
     */
    public function truncate($force=false)
    {
        if ( $force )
        {
            $this->execute('SET FOREIGN_KEY_CHECKS = 0');
        }
        $this->execute("TRUNCATE TABLE {$this->_table_name}");
        if ( $force )
        {
            $this->execute('SET FOREIGN_KEY_CHECKS = 1');
        }
        return $this;
    }

    /**
     * @return array
     */
    public function deleteSqlQuery()
    {
        $query  = "DELETE FROM {$this->_table_name}";
        if ( !empty($this->_where_conditions) )
        {
            $query .= $this->_getWhereString(true);
            return [$query, $this->_getWhereParameters()];
        }
        return [$query, []];
    }


    /**
     * Return the aggregate count of column
     *
     * @param string $column
     * @param int $cacheTtl
     * @return int
     */
    public function count($column='*', $cacheTtl=self::CACHE_NO)
    {
        $this->explicitSelectMode();
        $this->select("COUNT({$column})", 'cnt');
        $result             = $this->fetchOne(null, $cacheTtl);
        return ($result !== false && isset($result->cnt)) ? (float)$result->cnt : 0;
    }


    /**
     * Return the aggregate max count of column
     *
     * @param string $column
     * @param int $cacheTtl
     * @return mixed|null
     */
    public function max($column, $cacheTtl=self::CACHE_NO)
    {
        $this->explicitSelectMode();
        $this->select("MAX({$column})", 'max');
        $result = $this->fetchOne(null, $cacheTtl);
        return ( $result !== false && isset($result->max) ) ? $result->max : null;
    }


    /**
     * Return the aggregate min count of column
     *
     * @param string $column
     * @param int $cacheTtl
     * @return mixed|null
     */
    public function min($column, $cacheTtl=self::CACHE_NO)
    {
        $this->explicitSelectMode();
        $this->select("MIN({$column})", 'min');
        $result = $this->fetchOne(null, $cacheTtl);
        return ( $result !== false && isset($result->min) ) ? $result->min : null;
    }

    /**
     * Return the aggregate sum count of column
     *
     * @param string $column
     * @param int $cacheTtl
     * @return mixed|null
     */
    public function sum($column, $cacheTtl=self::CACHE_NO)
    {
        $this->explicitSelectMode();
        $this->select("SUM({$column})", 'sum');
        $result = $this->fetchOne(null, $cacheTtl);
        return ( $result !== false && isset($result->sum) ) ? $result->sum : null;
    }

    /**
     * Return the aggregate average count of column
     *
     * @param string $column
     * @param int $cacheTtl
     * @return mixed|null
     */
    public function avg($column, $cacheTtl=self::CACHE_NO)
    {
        $this->explicitSelectMode();
        $this->select("AVG({$column})", 'avg');
        $result = $this->fetchOne(null, $cacheTtl);
        return ( $result !== false && isset($result->avg) ) ? $result->avg : null;
    }

    /*******************************************************************************/
// Utilities methods

    /**
     * Reset fields
     *
     * @return $this
     */
    public function reset()
    {
        $this->_where_parameters        = [];
        $this->_select_fields           = [];
        $this->_join_sources            = [];
        $this->_join_aliases            = [];
        $this->_where_conditions        = [];
        $this->_limit                   = null;
        $this->_offset                  = null;
        $this->_order_by                = [];
        $this->_group_by                = [];
        $this->_and_or_operator         = self::OPERATOR_AND;
        $this->_having                  = [];
        $this->_wrap_open               = false;
        $this->_last_wrap_position      = 0;
        $this->_pdo_stmt                = null;
        $this->_distinct                = false;
        $this->_requested_fields        = null;
        $this->_filter_meta             = null;
        $this->_cache_ttl               = -1;
        $this->_timer                   = [];
        $this->_built_query             = null;
        $this->_paging_meta             = [];
        $this->_raw_sql                 = null;
        $this->_explicit_select_mode    = false;
        return $this;
    }

    /**
     * Return a YYYY-MM-DD HH:II:SS date format
     *
     * @param string $datetime - An english textual datetime description
     *          now, yesterday, 3 days ago, +1 week
     *          http://php.net/manual/en/function.strtotime.php
     * @return string YYYY-MM-DD HH:II:SS
     */
    public static function NOW($datetime = 'now')
    {
        return (new DateTime($datetime ?: 'now'))->format('Y-m-d H:i:s');
    }

    /**
     * Return a string containing the given number of question marks,
     * separated by commas. Eg '?, ?, ?'
     *
     * @param int - total of placeholder to insert
     * @return string
     */
    protected function _makePlaceholders($number_of_placeholders=1)
    {
        return implode(', ', array_fill(0, $number_of_placeholders, '?'));
    }

    /**
     * Format the table{Primary|Foreign}KeyName
     *
     * @param  string $pattern
     * @param  string $tableName
     * @return string
     */
    protected function _formatKeyName($pattern, $tableName)
    {
        return sprintf($pattern, $tableName);
    }

    /**
     * @param string $query
     * @param array $parameters
     *
     * @return array
     */
    protected function _logQuery($query, array $parameters)
    {
        $query = $this->buildQuery($query, $parameters);
        if ( ! $this->_log_queries )
        {
            return [null, null];
        }
        $ident = substr(str_shuffle(md5($query)), 0, 10);
        $this->getLogger()->debug($ident . ': ' . PHP_EOL . $query);
        $this->_timer['start'] = microtime(true);
        return [$query, $ident];
    }

    /**
     * @param $ident
     * @param $builtQuery
     */
    protected function _logSlowQueries($ident, $builtQuery)
    {
        if ( ! $this->_log_queries )
        {
            return ;
        }
        $this->_timer['end']    = microtime(true);
        $seconds_taken          = round($this->_timer['end'] - $this->_timer['start'], 3);
        if ( $seconds_taken > $this->_slow_query_secs )
        {
            $this->getLogger()->warning("SLOW QUERY - {$ident} - {$seconds_taken} seconds:\n{$builtQuery}");
        }
    }

    /**
     * @return float
     */
    public function getTimeTaken()
    {
        $seconds_taken = $this->_timer['end'] - $this->_timer['start'];
        return $seconds_taken;
    }

    /**
     * @param $secs
     * @return $this
     */
    public function slowQuerySeconds($secs)
    {
        Assert($secs)->notEmpty("Seconds cannot be empty.")->numeric("Seconds must be numeric.");
        $this->_slow_query_secs = $secs;
        return $this;
    }


    /**
     * @param       $field
     * @param array $values
     * @param null  $placeholder_prefix
     *
     * @return array
     */
    public function getNamedWhereIn($field, array $values, $placeholder_prefix=null)
    {
        Assert($field)->string()->notEmpty();
        Assert($values)->isArray();
        if ( empty($values) )
        {
            return ['', []];
        }
        $placeholder_prefix     = !is_null($placeholder_prefix) ? $placeholder_prefix : strtolower(str_replace('.', '__', $field));
        $params = $placeholders = [];
        $count                  = 1;
        foreach ( $values as $val )
        {
            $name           = "{$placeholder_prefix}_{$count}";
            $params[$name]  = $val;
            $placeholders[] = ":{$name}";
            $count++;
        }
        $placeholders = implode(',', $placeholders);
        return ["AND {$field} IN ({$placeholders})\n", $params];
    }

    /**
     * @param        $field
     * @param string $delimiter
     *
     * @return array
     */
    protected function _getColumnAliasParts($field, $delimiter=':')
    {
        $parts = explode($delimiter, $field);
        if ( count($parts) === 2 )
        {
            return $parts;
        }
        return ['', $field];
    }

    /**
     * @param string $column
     * @param string $term
     * @return $this
     */
    protected function _addWhereClause($column, $term)
    {
        $modifiers = [
            'whereLike'         => '/^whereLike\(([%]?[ a-z0-9:-]+[%]?)\)$/i',
            'whereNotLike'      => '/^whereNotLike\(([%]?[ a-z0-9:-]+[%]?)\)$/i',
            'whereLt'           => '/^whereLt\(([ a-z0-9:-]+)\)$/i',
            'whereLte'          => '/^whereLte\(([ a-z0-9:-]+)\)$/i',
            'whereGt'           => '/^whereGt\(([ a-z0-9:-]+)\)$/i',
            'whereGte'          => '/^whereGte\(([ a-z0-9:-]+)\)$/i',
            'whereBetween'      => '/^whereBetween\(([ a-z0-9:-]+),([ a-z0-9:-]+)\)$/i',
            'whereNotBetween'  => '/^whereNotBetween\(([ a-z0-9:-]+),([ a-z0-9:-]+)\)$/i',
        ];
        foreach ( $modifiers as $func => $regex )
        {
            if ( preg_match($regex, $term, $matches) )
            {
                array_shift($matches);
                switch ($func)
                {
                    case 'whereLike':

                        return $this->whereLike($column, $matches[0]);

                    case 'whereNotLike':

                        return $this->whereNotLike($column, $matches[0]);

                    case 'whereLt':

                        return $this->whereLt($column, $matches[0]);

                    case 'whereLte':

                        return $this->whereLte($column, $matches[0]);

                    case 'whereGt':

                        return $this->whereGt($column, $matches[0]);

                    case 'whereGte':

                        return $this->whereGte($column, $matches[0]);

                    case 'whereBetween':

                        return $this->whereBetween($column, $matches[0], $matches[1]);

                    case 'whereNotBetween':

                        return $this->whereNotBetween($column, $matches[0], $matches[1]);

                }
            }
        }
        return $this->where($column, $term);
    }

    public function destroy()
    {
        if ( !is_null($this->_pdo_stmt) )
        {
            $this->_pdo_stmt->closeCursor();
        }
        $this->_pdo_stmt    = null;
        $this->_handlers    = [];
    }

    public function __destruct()
    {
        $this->destroy();
    }

    /** @var string */
    static protected $_model_namespace = '';

    /** @var bool */
    protected $_validation_exceptions = true;

    /** @var array */
    protected $_paging_meta           = [];

    /** @var int */
    protected $_default_max           = 100;

    /**
     * Load a model
     *
     * @param string $model_name
     * @param AbstractPdo $connection
     * @return Model
     * @throws ModelNotFoundException
     */
    public static function loadModel($model_name, AbstractPdo $connection=null)
    {
        $model_name = static::$_model_namespace . $model_name;
        if ( ! class_exists($model_name) )
        {
            throw new ModelNotFoundException("Failed to find model class {$model_name}.");
        }
        return new $model_name($connection);
    }

    /**
     * Load a model
     *
     * @param string      $table_name
     * @param AbstractPdo $connection
     * @return $this
     */
    public static function loadTable($table_name, AbstractPdo $connection=null)
    {
        $model_name = Inflector::classify($table_name);
        Assert($model_name)->notEmpty("Could not resolve model name from table name.");
        return static::loadModel($model_name, $connection);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    /**
     * @param string   $columnName
     * @param int $cacheTtl
     * @param bool $flushCache
     * @return bool
     */
    public function columnExists($columnName, $cacheTtl=self::CACHE_NO, $flushCache=false)
    {
        $columns = $this->getSchemaFromDb($cacheTtl, $flushCache);
        return array_key_exists($columnName, $columns);
    }

    /**
     * @param int $cacheTtl
     * @param bool $flushCache
     * @return $this
     */
    public function loadSchemaFromDb($cacheTtl=self::CACHE_NO, $flushCache=false)
    {
        $schema = $this->getSchemaFromDb($cacheTtl, $flushCache);
        $this->schema($schema);
        return $this;
    }

    /**
     * @param int $cacheTtl
     * @param bool $flushCache
     * @return array
     * @throws \Terah\Assert\AssertionFailedException
     */
    public function getSchemaFromDb($cacheTtl=self::CACHE_NO, $flushCache=false)
    {
        $table      = $this->getTableName();
        Assert($table)->string()->notEmpty();
        $schema     = [];
        $columns    = $this->_getColumnsByTableFromDb($table, $cacheTtl, $flushCache);
        foreach ( $columns[$table] as $column => $meta )
        {
            $schema[$column] = $meta->data_type;
        }
        return $schema;
    }

    /**
     * @param string $table
     * @param int $cacheTtl
     * @param bool $flushCache
     * @return array
     */
    protected function _getColumnsByTableFromDb($table, $cacheTtl=self::CACHE_NO, $flushCache=false)
    {
        Assert($table)->string()->notEmpty();

        $callback = function() use ($table) {

            return $this->_connection->getColumns(true, $table);
        };
        $cacheKey   = '/column_schema/' . $table;
        if ( $flushCache === true )
        {
            $this->clearCache($cacheKey);
        }
        return $this->_cacheData($cacheKey, $callback, $cacheTtl);
    }

    /**
     * @param string $table
     * @return bool
     */
    public function clearSchemaCache($table)
    {
        return $this->clearCache('/column_schema/' . $table);
    }

    /**
     * @param stdClass $record
     * @return stdClass
     */
    public function onFetch(stdClass $record)
    {
        $record = $this->_trimAndLowerCaseKeys($record);
        if ( $this->_filter_on_fetch )
        {
            $record = $this->cleanseRecord($record);
        }
        return $this->fixTypes($record);
    }

    /**
     * @param stdClass $record
     * @return stdClass
     */
    public function cleanseRecord(stdClass $record)
    {
        foreach ( $record as $field => $value )

        {
            if ( is_string($record->$field) )
            {
                $record->$field = str_replace(["\r\n", "\\r\\n", "\\n"], "\n", filter_var($record->$field, FILTER_SANITIZE_STRING, FILTER_FLAG_NO_ENCODE_QUOTES));
                if ( $this->_log_filter_changes && $value !== $record->$field )
                {
                    $table = $this->_table_name ? $this->_table_name : '';
                    $this->getLogger()->debug("Field {$table}.{$field} has been cleansed", ['old' => $value, 'new' => $record->$field]);
                }
            }
        }
        return $record;
    }

    /**
     * @param stdClass $record
     * @param string   $type
     * @return stdClass
     */
    public function beforeSave(stdClass $record, $type)
    {
        $record = $this->addDefaultFields($record, $type);
        $record = $this->applyGlobalModifiers($record, $type);
        $record = $this->applyHandlers($record, $type);
        $record = $this->removeUnneededFields($record, $type);
        return $record;
    }

    /**
     * @param stdClass $record
     * @param string   $type
     * @return stdClass
     */
    public function afterSave(stdClass $record, $type)
    {
        unset($type);
        $this->clearCacheByTable();
        return $record;
    }

    /**
     * @param stdClass $record
     * @param string   $type
     * @return stdClass
     */
    public function addDefaultFields(stdClass $record, $type)
    {
        unset($type);
        return $record;
    }

    public function applyGlobalModifiers(stdClass $record, $type)
    {
        unset($type);
        return $record;
    }

    public function removeUnneededFields(\stdClass $record, $type)
    {
        unset($type);
        // remove un-needed fields
        $columns = $this->getColumns(true);
        if ( empty($columns) )
        {
            return $record;
        }
        foreach ( $record as $name => $value )

        {
            if ( ! in_array($name, $columns) || in_array($name, $this->_virtual_fields) )
            {
                unset($record->$name);
            }
        }
        return $record;
    }

    /**
     * @param array $data
     * @param string $saveType
     * @return array
     */
    public function cleanseWebData($data, $saveType)
    {
        Assert($saveType)->inArray([self::SAVE_UPDATE, self::SAVE_INSERT]);
        $columns = $this->getColumns(false);
        if ( empty($columns) )
        {
            return $data;
        }
        foreach ( $data as $field => $val )
        {
            $data[$field] = empty($val) && $val !== 0 ? null : $val;
        }
        return array_intersect_key($data, $columns);
    }

    /**
     * @return array
     */
    public function skeleton()
    {
        $skel       = [];
        $columns    = $this->columns(false);
        foreach ( $columns as $column => $type )
        {
            $skel[$column] = null;
        }
        return $skel;
    }


    /**
     * @return Closure[]
     */
    protected function _getFieldHandlers()
    {
        return [];
    }

    /**
     * @param bool $toString
     * @return array|string
     */
    public function getErrors($toString=false)
    {
        if ( $toString )
        {
            $errors = [];
            foreach ( $this->_errors as $field => $error )
            {
                $errors[] = implode("\n", $error);
            }
            return implode("\n", $errors);
        }
        return $this->_errors;
    }

    /**
     * @param bool $throw
     * @return $this
     */
    public function validationExceptions($throw=true)
    {
        $this->_validation_exceptions = $throw;
        return $this;
    }

    /**
     * @param array $query array('_limit' => int, '_offset' => int, '_order' => string, '_fields' => string, _search)
     *
     * @return $this
     * @throws Exception
     */
    public function paginate(array $query=[])
    {
        $_fields = $_order = $_limit = $_offset = null;
        extract($query);
        $this->_setLimit($_limit, $_offset);
        $this->_setOrderBy($_order);
        $this->_setFields($_fields);
        return $this;
    }

    /**
     * @param null|string $limit
     * @param null|string|int $offset
     * @return $this
     */
    protected function _setLimit($limit=null, $offset=null)
    {
        $limit      = ! $limit || (int)$limit > (int)$this->_default_max ? (int)$this->_default_max : (int)$limit;
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
        if ( ! is_numeric($limit) )
        {
            return $this;
        }
        $this->limit((int)$limit);
        if ( $offset && is_numeric($offset) )
        {
            $this->offset((int)$offset);
        }
        return $this;
    }

    /**
     * @param null|string|array $fields
     * @return $this
     * @throws Exception
     */
    protected function _setFields($fields=null)
    {
        if ( ! $fields )
        {
            return $this;
        }
        $this->explicitSelectMode();
        $columns    = $this->getColumns();
        $fields     = is_array($fields) ? $fields : explode('|', $fields);

        foreach ( $fields as $idx => $field )
        {
            list($alias, $field) = $this->_getColumnAliasParts($field);
            $field = $field === '_display_field' ? $this->_display_column : $field;
            // Regular primary table field
            if ( ( empty($alias) || $alias === $this->_table_alias ) && in_array($field, $columns) )
            {
                $this->select("{$this->_table_alias}.{$field}");
                $this->_requested_fields[] = "{$this->_table_alias}.{$field}";
                continue;
            }
            // Reference table field with alias
            if ( ! empty($alias) )
            {
                Assert($this->_associations['belongsTo'])->keyExists($alias, "Invalid table alias ({$alias}) specified for the field query");
                Assert($field)->eq($this->_associations['belongsTo'][$alias][3], "Invalid field ({$alias}.{$field}) specified for the field query");
                list(, , $join_field, $fieldAlias) = $this->_associations['belongsTo'][$alias];
                $this->autoJoin($alias, static::LEFT_JOIN, false);
                $this->select($join_field, $fieldAlias);
                $this->_requested_fields[] = "{$join_field} AS {$fieldAlias}";
                continue;
            }
            // Reference table select field without alias
            foreach ( $this->_associations['belongsTo'] as $joinAlias => $config )
            {
                list(, , $join_field, $fieldAlias) = $config;
                if ( $field === $config[3] )
                {
                    $this->autoJoin($joinAlias, static::LEFT_JOIN, false);
                    $this->select($join_field, $fieldAlias);
                    $this->_requested_fields[] = "{$join_field} AS {$fieldAlias}";
                    continue;
                }
            }
        }
        return $this;
    }

    /**
     * @param null|string $orderBy
     * @return $this|FluentPdoModel
     */
    protected function _setOrderBy($orderBy=null)
    {
        if ( ! $orderBy )
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
        {
            return $this;
        }
        $columns                    = $this->getColumns();
        list($order, $direction)    = strpos($orderBy, ',') !== false ? explode(',', $orderBy) : [$orderBy, 'ASC'];
        list($alias, $field)        = $this->_getColumnAliasParts(trim($order), '.');
        $field                      = explode(' ', $field);
        $field                      = trim($field[0]);
        $direction                  = ! in_array(strtoupper(trim($direction)), ['ASC', 'DESC']) ? 'ASC' : strtoupper(trim($direction));

        // Regular primary table order by
        if ( ( empty($alias) || $alias === $this->_table_alias ) && in_array($field, $columns) )
        {
            return $this->orderBy("{$this->_table_alias}.{$field}", $direction);
        }
        // Reference table order by with alias
        if ( ! empty($alias) )
        {
            Assert($this->_associations['belongsTo'])->keyExists($alias, "Invalid table alias ({$alias}) specified for the order query");
            Assert($field)->eq($this->_associations['belongsTo'][$alias][3], "Invalid field ({$alias}.{$field}) specified for the order query");
            return $this->autoJoin($alias)->orderBy("{$alias}.{$field}", $direction);
        }
        // Reference table order by without alias
        foreach ( $this->_associations['belongsTo'] as $joinAlias => $config )
        {
            if ( $field === $config[3] )
            {
                return $this->autoJoin($joinAlias)->orderBy($config[2], $direction);
            }
        }
        return $this;
    }

    /**
     * @param null $type
     * @return array
     */
    public function getPagingMeta($type=null)
    {
        if ( empty($this->_paging_meta) )
        {
            $this->setPagingMeta();
        }
        return is_null($type) ? $this->_paging_meta : $this->_paging_meta[$type];
    }

    /**
     * @return $this
     */
    public function setPagingMeta()
    {
        $model      = clone $this;
        $limit      = intval($this->getLimit());
        $offset     = intval($this->getOffset());
        $total      = intval($model->withBelongsTo()->select(null)->offset(null)->limit(null)->orderBy(null)->count());
        unset($model->_handlers, $model); //hhmv mem leak
        $order_bys  = !is_array($this->_order_by) ? [] : $this->_order_by;
        $this->_paging_meta  = [
            'limit'     => $limit,
            'offset'    => $offset,
            'page'      => $offset === 0 ? 1 : intval( $offset / $limit ) + 1,
            'pages'     => $limit === 0 ? 1 : intval(ceil($total / $limit)),
            'order'     => $order_bys,
            'total'     => $total = $limit === 1 && $total > 1 ? 1 : $total,
            'filters'   => is_null($this->_filter_meta) ? [] : $this->_filter_meta,
            'fields'    => is_null($this->_requested_fields) ? [] : $this->_requested_fields,
            'perms'     => [],
        ];
        return $this;
    }

    /**
     * Take a web request and format a query
     *
     * @param array $query
     *
     * @return $this
     * @throws Exception
     */
    public function filter(array $query=[])
    {
        $columns   = $this->getColumns(false);
        $alias     = '';
        foreach ( $query as $column => $value )
        {
            if ( in_array($column, $this->_pagination_attribs) )
            {
                continue;
            }
            $field = $this->_findFieldByQuery($column, $this->_display_column);
            if ( is_null($field) )
            {
                continue;
            }
            $this->_filter_meta[$field]     = $value;
            $where                          = !is_array($value) && mb_stripos($value, '|') !== false ? explode('|', $value) : $value;
            if ( is_array($where) )
            {
                $this->whereIn($field, $where);
            }
            else
            {
                $this->_addWhereClause($field, $where);
            }
        }
        if ( empty($query['_search']) )
        {
            return $this;
        }
        $alias          = !empty($alias) ? $alias : $this->_table_alias;
        $string_cols    = array_filter($columns, function($type) {

            return in_array($type, ['varchar', 'text', 'enum']);
        });
        $terms          = explode('|', $query['_search']);
        $where_likes    = [];
        foreach ( $string_cols as $column => $type )
        {
            foreach ( $terms as $term )
            {
                $where_likes["{$alias}.{$column}"] = "%{$term}%";
            }
        }
        // Reference fields...
        $belongsTo = $this->getSearchableAssociations();
        foreach ( $belongsTo as $alias => $config )
        {
            foreach ( $terms as $term )
            {
                $where_likes[$config[2]] = "%{$term}%";
            }
        }
        if ( empty($where_likes) )
        {
            return $this;
        }
        $this->where([1=>1])->wrap()->_and();
        foreach ( $where_likes as $column => $term )
        {
            $this->_or()->whereLike($column, $term);
        }
        $this->wrap();
        return $this;
    }

    /**
     * @param string $column
     * @param $displayCol
     * @return string|null
     */
    protected function _findFieldByQuery($column, $displayCol)
    {
        list($alias, $field)    = $this->_getColumnAliasParts($column);
        $field                  = $field === '_display_field' ? $displayCol : $field;
        $columns                = $this->getColumns();
        $tableAlias             = $this->getTableAlias();
        if ( ! empty($alias) && $alias === $tableAlias )
        {
            // Alias is set but the field isn't correct
            if ( ! in_array($field, $columns) )
            {
                return null;
            }
            return "{$alias}.{$field}";
        }
        // Alias isn't passed in but the field is ok
        if ( empty($alias) && in_array($field, $columns) )
        {
            return "{$tableAlias}.{$field}";
        }
        // Alias is passed but not this table in but there is a matching field on this table
        if ( ! empty($alias) && in_array($field, $columns) )
        {
            return null;
        }
        // Now search the associations for the field
        $associations = $this->getSearchableAssociations();
        if ( ! empty($alias) )
        {
            if ( array_key_exists($alias, $associations) && $associations[$alias][3] === $field )
            {
                return "{$alias}.{$field}";
            }
            return null;
        }
        foreach ( $associations as $assocAlias => $config )
        {
            list(, , $assocField, $fieldAlias) = $config;
            if ( $fieldAlias === $field )
            {
                return $assocField;
            }
        }
        return null;
    }

    public function getSearchableAssociations()
    {
        $belongsTo = ! empty($this->_associations['belongsTo']) ? $this->_associations['belongsTo'] : [];
        return $belongsTo;
    }

    /**
     * @param $keys_only
     * @return array
     */

    public function columns($keys_only=true)
    {
        return $keys_only ? array_keys($this->_schema) : $this->_schema;
    }

    /**
     * @param string $field
     * @param mixed $value
     * @param bool|false $permissive
     * @return float|int|null|string
     */
    protected function _fixType($field, $value, $permissive=false)
    {
        Assert($value)->nullOr()->scalar("var is type of " . gettype($value));
        if ( empty($this->_schema) || ( ! array_key_exists($field, $this->_schema) && $permissive ) )
        {
            return $value;
        }
        $columns    = $this->getColumns(false);
        Assert($columns)->keyExists($field, "The property {$field} does not exist.");

        $field_type = ! empty($columns[$field]) ? $columns[$field] : null;

        if ( is_null($value) )
        {
            return null;
        }
        // return on null, '' but not 0
        if ( ! is_numeric($value) && empty($value) )
        {
            return null;
        }
        // Don't cast invalid values... only those that can be cast cleanly
        switch ($field_type)
        {
            case 'varchar':
            case 'text';
            case 'date':
            case 'datetime':
            case 'timestamp':
                return (string)$value;
            case 'int':
            case 'tinyint':
                return ! is_numeric($value) ? $value : (int)$value;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
            case 'decimal':
                return ! is_numeric($value) ? $value : (float)$value;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
            default:
                return $value;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }
    }

    /**
     * @param stdClass $record
     * @param string $type
     * @return stdClass
     */
    public function fixTypes(stdClass $record, $type=null)
    {
        foreach ( $this->getColumns(false) as $column => $field_type )
        {
            if ( ! property_exists($record, $column) || is_null($record->$column) )
            {
                continue;
            }
            $record->$column = $this->_fixType($column, $record->$column);
        }
        unset($type);
        return $record;
    }

    /**
     * @param stdClass $record
     * @param string   $type
     * @return stdClass
     * @throws Exception
     */
    public function applyHandlers(stdClass $record, $type='INSERT')
    {
        $this->_compileHandlers();
        $this->_errors                  = [];
        // Disable per field exceptions so we can capture all errors for the record
        $tmpExceptions                  = $this->_validation_exceptions;
        $this->_validation_exceptions   = false;
        foreach ( $this->_handlers as $field => $fn_validator )
        {
            if ( ! property_exists($record, $field) )
            {
                // If the operation is an update it can be a partial update
                if ( $type === self::SAVE_UPDATE )
                {
                    continue;
                }
                $record->$field = null;
            }
            $record->$field = $this->applyHandler($field, $record->$field, $type, $record);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
        }
        $this->_validation_exceptions = $tmpExceptions;
        if ( $this->_validation_exceptions && ! empty($this->_errors) )
        {
            throw new ModelFailedValidationException("Validation of data failed", $this->getErrors(), 422);

        }
        return $record;
    }

    /**
     * @param string $field
     * @param mixed $value
     * @param null $type
     * @param null $record
     * @return null
     * @throws Exception
     */
    protected function applyHandler($field, $value, $type=null, $record=null)
    {
        $this->_compileHandlers();
        $fnHandler = ! empty($this->_handlers[$field]) ? $this->_handlers[$field] : null;
        if ( is_callable($fnHandler) )
        {
            try
            {
                $value = $fnHandler($field, $value, $type, $record);
            }
            catch( Exception $e )
            {
                $this->_errors[$field][] = $e->getMessage();
                if ( $this->_validation_exceptions && ! empty($this->_errors) )
                {
                    throw new ModelFailedValidationException("Validation of data failed", $this->getErrors(), 422);

                }
                return null;
            }
        }
        return $value;
    }

    protected function _compileHandlers()
    {
        if ( $this->_handlers )

        {
            return;
        }
        $this->_handlers    = array_merge([], $this->_getFieldHandlers());
    }
}

class ModelNotFoundException extends \Exception{}

class ModelFailedValidationException extends \Exception
{
    private $validationErrors;

    /**
     * @return array
     */
    public function getValidationErrors($asString=false)
    {
        $errors = is_array($this->validationErrors) ? $this->validationErrors : [];
        return $asString ? json_encode($errors, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT) : $errors;
    }

    /**
     * @param string         $message
     * @param array          $validationErrors
     * @param int            $code
     * @param Exception|null $previous
     */
    public function __construct($message="", array $validationErrors=[], $code=0, Exception $previous = null)
    {
        $this->validationErrors = $validationErrors;
        parent::__construct($message, $code, $previous);
    }
}

terah / fluent-pdo-model

Push — master ( 7d6fbb...2dc4cf )

FluentPdoModel::clearCacheByTable() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
