FluentPdoModel::whereLt() - Code Metrics - Inspection of "Adding deleter field" - terah/fluent-pdo-model - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( f7f9d7...9d7b5e )

by Terry
created 2018-03-18 22:09 UTC
FluentPdoModel::whereLt() A

↳ Parent: FluentPdoModel
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	2
nc	1
nop	2
dl	0
loc	4
rs	10
c	0
b	0
f	0
<?php declare(strict_types=1);
/**
 * @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\LoggerInterface;
use Terah\RedisCache\CacheInterface;
use function Terah\Assert\Assert;
use function Terah\Assert\Validate;
/**
 * Class FluentPdoModel
 *
 * @package Terah\FluentPdoModel
 * @author  Terry Cullen - [email protected]
 */
class FluentPdoModel
{
    const ACTIVE                        = 1;
    const INACTIVE                      = 0;
//    const ARCHIVED                      = -1;
    const GZIP_PREFIX                   = 'gzipped|';
    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;

    const CREATOR_ID_FIELD          = 'creator_id';
    const CREATOR_FIELD             = 'creator';
    const CREATED_TS_FIELD          = 'created_ts';
    const MODIFIER_ID_FIELD         = 'modifier_id';
    const MODIFIER_FIELD            = 'modifier';
    const MODIFIED_TS_FIELD         = 'modified_ts';
    const DELETER_ID_FIELD          = 'deleter_id';
    const DELETER_FIELD             = 'deleter';
    const DELETED_TS_FIELD          = 'deleted_ts';
    const STATUS_FIELD              = 'active';

    /** @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             = '';

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

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

    /** @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          = '';

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

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

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

    /** @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 array */
    protected $_flush_cache_tables      = [];

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

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

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

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

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

    protected $_max_callback_failures   = -1;

    protected $_num_callback_failures   = 0;

    protected $_filter_on_fetch         = false;

    protected $_log_filter_changes      = true;

    protected $_include_count           = false;

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

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

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

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


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

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

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

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

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

    protected $_can_generic_update      = true;
    protected $_can_generic_add         = true;
    protected $_can_generic_delete      = true;

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

    protected $excluded_search_cols     = [];


    /** @var array  */
    protected $globalRemoveUnauthorisedFields = [
        '/global_table_meta#view'               => [
            self::CREATOR_ID_FIELD,
            self::CREATOR_FIELD,
            self::CREATED_TS_FIELD,
            self::MODIFIER_ID_FIELD,
            self::MODIFIER_FIELD,
            self::MODIFIED_TS_FIELD,
            self::STATUS_FIELD,
        ],
    ];


    /**
     * @param AbstractPdo|null $connection
     */
    public function __construct(AbstractPdo $connection=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() : AbstractPdo
    {
        return $this->_connection;
    }

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

    /**
     * @return CacheInterface
     */
    public function getCache() : CacheInterface
    {
        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 FluentPdoModel|$this
     */
    public function table(string $tableName, string $alias='', string $displayColumn='', string $primaryKeyName='id') : FluentPdoModel
    {
        return $this->reset()
            ->tableName($tableName)
            ->tableAlias($alias)
            ->displayColumn($displayColumn)
            ->primaryKeyName($primaryKeyName);
    }

    /**
     * @param string $primaryKeyName
     * @return FluentPdoModel|$this
     */
    public function primaryKeyName(string $primaryKeyName) : FluentPdoModel
    {
        $this->_primary_key = $primaryKeyName;

        return $this;
    }

    /**
     * @param string $tableName
     *
     * @return FluentPdoModel|$this
     */
    public function tableName(string $tableName) : FluentPdoModel
    {
        $this->_table_name  = $tableName;

        return $this;
    }

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

        return $this;
    }

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

        return $this;
    }

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

        return $this;
    }

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

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

    /**
     * Set the display column
     *
     * @param string $column
     *
     * @return FluentPdoModel|$this
     */
    public function displayColumn(string $column) : FluentPdoModel
    {
        $this->_display_column = $column;

        return $this;
    }
    /**
     * Set the table alias
     *
     * @param string $alias
     *
     * @return FluentPdoModel|$this
     */
    public function tableAlias(string $alias) : FluentPdoModel
    {
        $this->_table_alias = $alias;

        return $this;
    }

    /**
     * @param int $cacheTtl
     * @return FluentPdoModel|$this
     * @throws Exception
     */
    protected function _cacheTtl(int $cacheTtl) : FluentPdoModel
    {
        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() : string
    {
        return $this->_table_alias;
    }

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

        return $this;
    }

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

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

        return $this;
    }

    /**
     * @param $alias
     * @param $displayField
     * @return FluentPdoModel|$this
     * @throws \Terah\Assert\AssertionFailedException
     */
    public function setBelongsToDisplayField(string $alias, string $displayField) : FluentPdoModel
    {
        Assert($alias)->notEmpty();
        Assert($this->_associations['belongsTo'])->keyExists($alias);
        Assert($displayField)->notEmpty();

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

        return $this;
    }

    /**
     * @param PDOStatement $stmt
     * @param Closure $fnCallback
     * @return bool|stdClass
     */
    public function fetchRow(PDOStatement $stmt, Closure $fnCallback=null)
    {
        if ( ! ( $record = $stmt->fetch(PDO::FETCH_OBJ) ) )
        {
            $this->row_meta_data    = [];

            return false;
        }
        $this->row_meta_data  = $this->row_meta_data  ?: $this->getColumnMeta($stmt, $record);
        $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 PDOStatement $stmt
     * @param $record
     * @return array
     */
    protected function getColumnMeta(PDOStatement $stmt, $record) : array
    {
        $meta                   = [];
        if ( ! $this->_connection->supportsColumnMeta() )
        {
            return $meta;
        }
        foreach(range(0, $stmt->columnCount() - 1) as $index)
        {
            $data                   = $stmt->getColumnMeta($index);
            $meta[$data['name']]    = $data;
        }
        foreach ( $record as $field => $value )
        {
            Assert($meta)->keyExists($field);
        }

        return $meta;
    }

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

        return $this;
    }

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

            return $this;
        }
        Assert($field)->string()->notEmpty();
        $this->_schema[$field] = $type;

        return $this;
    }

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

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

    /**
     * @param string $query
     * @param array $parameters
     *
     * @return bool
     * @throws Exception
     */
    public function execute(string $query, array $parameters=[]) : bool
    {
        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 FluentPdoModel|$this
     */
    public function query(string $query, array $params=[]) : FluentPdoModel
    {
        $this->_raw_sql             = $query;
        $this->_where_parameters    = $params;

        return $this;
    }

    /**
     * @param string $sql
     * @param array $params
     *
     * @return string
     */
    public function buildQuery(string $sql, array $params=[]) : string
    {
        $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) : stdClass
    {
        $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() : int
    {
        $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;
    }

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

        return $result;
    }

    /**
     * @param string $tableName
     * @param bool  $dropIfExists
     * @param array $indexes
     * @return boolean
     * @throws Exception
     */
    public function fetchIntoMemoryTable(string $tableName, bool $dropIfExists=true, array $indexes=[]) : bool
    {
        $tableName      = preg_replace('/[^A-Za-z0-9_]+/', '', $tableName);
        $tableName      = $this->_tmp_table_prefix . preg_replace('/^' . $this->_tmp_table_prefix . '/', '', $tableName);
        if ( $dropIfExists )
        {
            $this->execute("DROP TABLE IF EXISTS {$tableName}");
        }
        $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 {$tableName} {$indexSql} ENGINE=MEMORY {$querySql}
SQL;

        return $this->execute($sql, $params);
    }

    /**
     * @param string $keyedOn
     * @param int $cacheTtl
     * @return stdClass[]
     */
    public function fetch(string $keyedOn='', int $cacheTtl=self::CACHE_NO) : array
    {
        $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,
        ]));
        $data = $this->_cacheData($cacheKey, $fnCallback, $this->_cache_ttl);

        return is_array($data) ? $data : [];
    }

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

        return '';
    }

    /**
     * @param string $cacheKey
     * @param Closure $func
     * @param int $cacheTtl - 0 for default ttl, -1 for no cache or int for custom ttl
     * @return mixed
     */
    protected function _cacheData(string $cacheKey, Closure $func, int $cacheTtl=self::CACHE_DEFAULT)
    {
        if ( $cacheTtl === self::CACHE_NO )
        {
            /** @noinspection PhpVoidFunctionResultUsedInspection */
            return $func->__invoke();
        }
        $data = $this->getCache()->get($cacheKey);
        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 ? 0 : $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(string $cacheKey) : bool
    {
        return $this->getCache()->delete($cacheKey);
    }

    /**
     * @param string $table
     * @return bool
     */
    public function clearCacheByTable(string $table='') : bool
    {
        $tables  = $table ? [$table] : $this->getFlushCacheTables();
        foreach ( $tables as $table )
        {
            $this->clearCache("/{$table}/");
        }

        return true;
    }

    /**
     * @return string[]
     */
    public function getFlushCacheTables() : array
    {
        return ! empty($this->_flush_cache_tables) ? $this->_flush_cache_tables : [$this->getTableName()];
    }

    /**
     * @param Closure $fnCallback
     * @return int
     */
    public function fetchCallback(Closure $fnCallback) : int
    {
        $successCnt    = 0;
        $stmt           = $this->fetchStmt();
        while ( $this->_tallySuccessCount($stmt, $fnCallback, $successCnt) )
        {}

        return $successCnt;
    }

    /**
     * @param Closure $fnCallback
     * @param string  $keyedOn
     * @return array
     */
    public function fetchObjectsByCallback(Closure $fnCallback, string $keyedOn='') : array
    {
        $stmt       = $this->fetchStmt();
        $rows       = [];
        while ( $record = $this->fetchRow($stmt, $fnCallback) )
        {
            if ( $keyedOn && property_exists($record, $keyedOn) )
            {
                $rows[$record->{$keyedOn}] = $record;
                continue;
            }
            $rows[] = $record;
        }
        $this->reset();

        return $rows;
    }

    /**
     * @param $numFailures
     * @return FluentPdoModel|$this
     */
    public function maxCallbackFailures(int $numFailures) : FluentPdoModel
    {
        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(PDOStatement $stmt, Closure $fnCallback, int &$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 ( $this->_max_callback_failures !== -1 && $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;
    }

    /**
     * @return bool
     */
    public function canGenericUpdate() : bool
    {
        return $this->_can_generic_update;
    }

    /**
     * @return bool
     */
    public function canGenericAdd() : bool
    {
        return $this->_can_generic_add;
    }

    /**
     * @return bool
     */
    public function canGenericDelete() : bool
    {
        return $this->_can_generic_delete;
    }

    /**
     * @param string $keyedOn
     * @param string $valueField
     * @param int $cacheTtl
     * @return mixed
     */
    public function fetchList(string $keyedOn='', string $valueField='', int $cacheTtl=self::CACHE_NO) : array
    {
        $keyedOn            = $keyedOn ?: $this->getPrimaryKeyName();
        $valueField         = $valueField ?: $this->getDisplayColumn();
        $keyedOnAlias       = strtolower(str_replace('.', '_', $keyedOn));
        $valueFieldAlias    = strtolower(str_replace('.', '_', $valueField));
        if ( preg_match('/ as /i', $keyedOn) )
        {
            list($keyedOn, $keyedOnAlias)   = preg_split('/ as /i', $keyedOn);
            $keyedOn                        = trim($keyedOn);
            $keyedOnAlias                   = trim($keyedOnAlias);
        }
        if ( preg_match('/ as /i', $valueField) )
        {
            list($valueField, $valueFieldAlias) = preg_split('/ as /i', $valueField);
            $valueField                         = trim($valueField);
            $valueFieldAlias                    = trim($valueFieldAlias);
        }

        $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();
        $cacheData          = [
            'sql'               => $this->fetchSqlQuery(),
            'keyed_on'          => $keyedOn,
            'keyed_on_alias'    => $keyedOnAlias,
            'value_field'       => $valueField,
            'value_fieldAlias'  => $valueFieldAlias,
        ];
        $cacheKey           = json_encode($cacheData);
        if ( ! $cacheKey )
        {
            $this->getLogger()->warning('Could not generate cache key from data', $cacheData);
            $result = $fnCallback();
            unset($cacheKey, $fnCallback);

            return $result;
        }
        $cacheKey           = md5($cacheKey);

        return $this->_cacheData("/{$table}/list/{$cacheKey}", $fnCallback, $this->_cache_ttl);
    }

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

        return $unique ? array_unique($list) : $list;
    }

    /**
     * @param string $field
     * @param int $itemId
     * @param int $cacheTtl
     * @return mixed|null
     */
    public function fetchField(string $field='', int $itemId=0, int $cacheTtl=self::CACHE_NO)
    {
        $field      = $field ?: $this->getPrimaryKeyName();
        $object     = $this->select(null)->select($field)->fetchOne($itemId, $cacheTtl);
        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 string $field
     * @param int $itemId
     * @param int $cacheTtl
     * @return string
     */
    public function fetchStr(string $field='', $itemId=0, int $cacheTtl=self::CACHE_NO) : string
    {
        return (string)$this->fetchField($field, $itemId, $cacheTtl);
    }

    /**
     * @param int $cacheTtl
     * @return int
     */
    public function fetchId(int $cacheTtl=self::CACHE_NO) : int
    {
        return $this->fetchInt($this->getPrimaryKeyName(), 0, $cacheTtl);
    }

    /**
     * @param string $field
     * @param int $itemId
     * @param int $cacheTtl
     * @return int
     */
    public function fetchInt(string $field='', int $itemId=0, int $cacheTtl=self::CACHE_NO) : int
    {
        return (int)$this->fetchField($field, $itemId, $cacheTtl);
    }

    /**
     * @param string $field
     * @param int $itemId
     * @param int $cacheTtl
     * @return float
     */
    public function fetchFloat(string $field='', int $itemId=0, int $cacheTtl=self::CACHE_NO) : float
    {
        return (float)$this->fetchField($field, $itemId, $cacheTtl);
    }

    /**
     * @param string $field
     * @param int $itemId
     * @param int $cacheTtl
     * @return bool
     */
    public function fetchBool(string $field='', int $itemId=0, int $cacheTtl=self::CACHE_NO) : bool
    {
        return (bool)$this->fetchField($field, $itemId, $cacheTtl);
    }

    /**
     * @param int|null $id
     * @param int $cacheTtl
     * @return stdClass|bool
     */
    public function fetchOne(int $id=0, int $cacheTtl=self::CACHE_NO)
    {
        if ( $id > 0 )
        {
            $this->wherePk($id, true);
        }
        $this->limit(1);
        $fetchAll   = $this->fetch('', $cacheTtl);

        return $fetchAll ? array_shift($fetchAll) : false;
    }

    /**
     * @param int|null $id
     * @param int $cacheTtl
     * @return boolean
     */
    public function fetchExists(int $id=0, int $cacheTtl=self::CACHE_NO) : bool
    {
        if ( $id > 0 )
        {
            $this->wherePk($id, true);
        }
        $cnt = $this->count('*', $cacheTtl);

        return $cnt > 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 boolean $explicitSelect
     * @return FluentPdoModel|$this
     */
    public function select($columns='*', string $alias='', bool $explicitSelect=true) : FluentPdoModel
    {
        if ( $explicitSelect )
        {
            $this->explicitSelectMode();
        }
        if ( $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) || $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;
    }

    /**
     * @param string $select
     * @return FluentPdoModel|$this
     */
    public function selectRaw(string $select) : FluentPdoModel
    {
        $this->_select_fields[] = $select;

        return $this;
    }

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

        return $this;
    }

    /**
     * @param bool $includeCnt
     *
     * @return FluentPdoModel|$this
     */
    public function includeCount(bool $includeCnt=true) : FluentPdoModel
    {
        $this->_include_count = $includeCnt;

        return $this;
    }

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

        return $this;
    }

    /**
     * @param array $fields
     * @return FluentPdoModel|$this
     */
    public function withBelongsTo(array $fields=[]) : FluentPdoModel
    {
        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 bool   $addSelectField
     * @return FluentPdoModel
     */
    public function autoInnerJoin(string $alias, bool $addSelectField=true) : FluentPdoModel
    {
        return $this->autoJoin($alias, self::INNER_JOIN, $addSelectField);
    }

    /**
     * @param string $alias
     * @param string $type
     * @param bool   $addSelectField
     * @return FluentPdoModel|$this
     */
    public function autoJoin(string $alias, string $type=self::LEFT_JOIN, bool $addSelectField=true) : FluentPdoModel
    {
        Assert($this->_associations['belongsTo'])->keyExists($alias, "Invalid join... the alias does not exists");
        list($table, $join_col, $field, $fieldAlias)    = $this->_associations['belongsTo'][$alias];
        $tableJoinField                                 = "{$this->_table_alias}.{$join_col}";
        // Extra join onto another second level table
        if ( strpos($join_col, '.') !== false )
        {
            $tableJoinField =  $join_col;
            if ( $addSelectField )
            {
                $this->select($join_col, '', false);
            }
        }


        $condition = "{$alias}.id = {$tableJoinField}";
        if ( in_array($alias, $this->_join_aliases) )
        {
            return $this;
        }
        $this->join($table, $condition, $alias, $type);
        if ( $addSelectField )
        {
            $this->select($field, $fieldAlias, false);
        }

        return $this;
    }

    /**
     * @param array $conditions
     * @return FluentPdoModel
     */
    public function whereArr(array $conditions) : FluentPdoModel
    {
        foreach ($conditions as $key => $val)
        {
            $this->where($key, $val);
        }

        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 FluentPdoModel|$this
     */
    public function where($condition, $parameters=[]) : FluentPdoModel
    {
        // 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((string)$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 FluentPdoModel|$this
     */
    public function _and() : FluentPdoModel
    {
        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 FluentPdoModel|$this
     */
    public function _or() : FluentPdoModel
    {
        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 FluentPdoModel|$this
     */
    public function wrap() : FluentPdoModel
    {
        $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 int  $id
     * @param bool $addAlias
     *
     * @return FluentPdoModel|$this
     */
    public function wherePk(int $id, bool $addAlias=true) : FluentPdoModel
    {
        $alias = $addAlias && ! empty($this->_table_alias) ? "{$this->_table_alias}." : '';

        return $this->where($alias . $this->getPrimaryKeyName(), $id);
    }

    /**
     * @param string $name
     * @param bool   $addAlias
     * @return FluentPdoModel
     */
    public function whereDisplayName(string $name, bool $addAlias=true) : FluentPdoModel
    {
        $alias = $addAlias && ! empty($this->_table_alias) ? "{$this->_table_alias}." : '';

        return $this->where($alias . $this->getDisplayColumn(), $name);
    }

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

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

    /**
     * @param string $columnName
     * @param mixed $value1
     * @param mixed $value2
     * @return FluentPdoModel|$this
     */
    public function whereBetween(string $columnName, $value1, $value2) : FluentPdoModel
    {
        $value1 = is_string($value1) ? trim($value1) : $value1;
        $value2 = is_string($value2) ? trim($value2) : $value2;

        return $this->where("$columnName BETWEEN ? AND ?", [$value1, $value2]);
    }

    /**
     * @param string $columnName
     * @param mixed $value1
     * @param mixed $value2
     * @return FluentPdoModel|$this
     */
    public function whereNotBetween(string $columnName, $value1, $value2) : FluentPdoModel
    {
        $value1 = is_string($value1) ? trim($value1) : $value1;
        $value2 = is_string($value2) ? trim($value2) : $value2;

        return $this->where("$columnName NOT BETWEEN ? AND ?", [$value1, $value2]);
    }

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

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

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

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

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

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

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

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

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

        return $this->where("({$columnName} NOT IN ({$placeholders}))", $values);
    }

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

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

    /**
     * @param string $statement
     * @param string $operator
     * @return FluentPdoModel|$this
     */
    public function having(string $statement, string $operator=self::OPERATOR_AND) : FluentPdoModel
    {
        $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 FluentPdoModel|$this
     */
    public function orderBy(string $columnName='', string $ordering='ASC') : FluentPdoModel
    {
        $ordering       = strtoupper($ordering);
        Assert($ordering)->inArray(['DESC', 'ASC']);
        if ( ! $columnName )
        {
            $this->_order_by = [];

            return $this;
        }
        $this->_order_by[] = trim("{$columnName} {$ordering}");

        return $this;
    }

    /**
     * GROUP BY $columnName
     *
     * @param  string   $columnName
     * @return FluentPdoModel|$this
     */
    public function groupBy(string $columnName) : FluentPdoModel
    {
        $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 FluentPdoModel|$this
     */
    public function limit(int $limit, int $offset=0) : FluentPdoModel
    {
        $this->_limit =  $limit;
        if ( $offset )
        {
            $this->offset($offset);
        }
        return $this;
    }

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

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

        return $this;
    }

    /**
     * Return the offset
     *
     * @return integer
     */
    public function getOffset() : int
    {
        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 FluentPdoModel|$this
     */
    public function join(string $table, string $constraint='', string $tableAlias='', string $joinOperator='') : FluentPdoModel
    {
        if ( ! $constraint )
        {
            return $this->autoJoin($table, $joinOperator);
        }
        $join                   = [$joinOperator ? "{$joinOperator} " : ''];
        $join[]                 = "JOIN {$table} ";
        $tableAlias             = $tableAlias ?: Inflector::classify($table);
        $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 FluentPdoModel|$this
     */
    public function leftJoin(string $table, string $constraint, string $tableAlias='') : FluentPdoModel
    {
        return $this->join($table, $constraint, $tableAlias, self::LEFT_JOIN);
    }


    /**
     * Return the build select query
     *
     * @return string
     */
    public function getSelectQuery() : string
    {
        if ( $this->_raw_sql )
        {
            return $this->_raw_sql;
        }
        if ( empty($this->_select_fields) || ! $this->_explicit_select_mode )
        {
            $this->select('*', '', 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);
    }

    /**
     * @param string $field
     * @param string $column
     * @return string
     */
    public function getFieldComment(string $field, string $column) : string
    {
        return $this->_connection->getFieldComment($field, $column);
    }

    /**
     * Prepare columns to include the table alias name
     * @param array $columns
     * @return array
     */
    protected function _prepareColumns(array $columns) : array
    {
        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(bool $purgeAliases=false) : string
    {
        // 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() : string
    {
        // 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(bool $purgeAliases=false) : array
    {
        unset($purgeAliases);

        return $this->_where_parameters;
    }

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

    /**
     * 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 $record
     * @return stdClass
     * @throws Exception
     */
    public function insert(stdClass $record) : stdClass
    {
        Assert((array)$record)->notEmpty("The data passed to insert does not contain any data");
        Assert($record)->isInstanceOf('stdClass', "The data to be inserted must be an object or an array of objects");

        $record = $this->beforeSave($record, self::SAVE_INSERT);
        if ( ! empty($this->_errors) )
        {
            return $record;
        }
        list($sql, $insert_values) = $this->insertSqlQuery([$record]);
        $this->execute((string)$sql, (array)$insert_values);
        $rowCount = $this->rowCount();
        if ( $rowCount === 1 )
        {
            $primaryKeyName                 = $this->getPrimaryKeyName();
            $record->{$primaryKeyName}      = $this->getLastInsertId($primaryKeyName);
        }
        $record = $this->afterSave($record, self::SAVE_INSERT);
        $this->destroy();

        return $record;
    }

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

    /**
     * @param stdClass[] $records
     * @return stdClass[]
     */
    public function insertSqlQuery(array $records) : array
    {
        Assert($records)->notEmpty("The data passed to insert does not contain any data");
        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) && empty($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=[], bool $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 int
     * @throws Exception
     */
    public function update(stdClass $record, $updateAll=false) : int
    {
        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 0;
        }
        list($sql, $values) = $this->updateSqlQuery($record);
        $this->execute($sql, $values);
        $this->afterSave($record, self::SAVE_UPDATE);
        $rowCount = $this->rowCount();
        $this->destroy();

        return $rowCount;
    }

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


    /**
     * @param string  $field
     * @param mixed   $value
     * @param int     $id
     * @param bool|false $updateAll
     * @return int
     * @throws Exception
     */
    public function updateField(string $field, $value, int $id=0, bool $updateAll=false) : int
    {
        if ( $id && $id > 0 )
        {
            $this->wherePk($id);
        }
        $columns    = $this->getColumns();
        if ( $columns )

        {
            Assert($field)->inArray($columns, "The field {$field} does not exist on this table {$this->_table_name}");
        }

        return $this->update((object)[$field => $value], $updateAll);
    }

    /**
     * @param stdClass $record
     * @return bool|int
     * @throws Exception
     */
    public function updateChanged(stdClass $record) : int
    {
        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 FluentPdoModel|$this
     */
    public function updateByExpression(string $expression, array $params) : FluentPdoModel
    {
        $this->_update_raw[] = [$expression, $params];

        return $this;
    }

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

        return $rowCount;
    }

    /**
     * @param stdClass $record
     * @return array
     */
    public function updateSqlQuery(stdClass $record) : array
    {
        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

        return $this->updateSql((array)$record);
    }

    /**
     * @param $record
     * @return array
     */
    protected function updateSql(array $record) : array
    {
        unset($record[$this->getPrimaryKeyName()]);
        Assert($this->_limit)->eq(0, 'You cannot limit updates');
        // Sqlite needs a null primary key
        //$record[$this->getPrimaryKeyName()] = null;
        $fieldList  = [];
        $fieldAlias = $this->_add_update_alias && ! empty($this->_table_alias) ? "{$this->_table_alias}." : '';
        foreach ( $record as $key => $value )
        {
            if ( is_numeric($key) )
            {
                $fieldList[] = $value;
                unset($record[$key]);
                continue;
            }
            $fieldList[] = "{$fieldAlias}{$key} = ?";
        }
        $rawParams  = [];
        foreach ( $this->_update_raw as $rawUpdate )
        {
            $fieldList[]   = $rawUpdate[0];
            $rawParams      = array_merge($rawParams, $rawUpdate[1]);
        }
        $fieldList     = implode(', ', $fieldList);
        $whereStr      = $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 {$fieldList}{$whereStr}";
        $values         = array_merge(array_values($record), $rawParams, $this->_getWhereParameters());

        return [$sql, $values];
    }

    /**
     * @param bool $deleteAll
     * @param bool $force
     * @return int
     * @throws Exception
     */
    public function delete(bool $deleteAll=false, bool $force=false) : int
    {
        if ( ! $force && $this->_soft_deletes )
        {
            return $this->updateDeleted();
        }

        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();
    }

    /**
     * @return bool
     */
    public function isSoftDelete() : bool
    {
        return $this->_soft_deletes;
    }

    /**
     * @param bool|false $force
     * @return FluentPdoModel|$this
     * @throws Exception
     */
    public function truncate(bool $force=false) : FluentPdoModel
    {
        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() : array
    {
        $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 float
     */
    public function count(string $column='*', int $cacheTtl=self::CACHE_NO) : float
    {
        $this->explicitSelectMode();

        if ( empty($this->_group_by) )
        {
            return $this->fetchFloat("COUNT({$column}) AS cnt", 0, $cacheTtl);
        }
        $this->select("COUNT({$column}) AS cnt");
        $sql        = $this->getSelectQuery();
        $params     = $this->_getWhereParameters();
        $sql        = "SELECT COUNT(*) AS cnt FROM ({$sql}) t";
        $object     = $this->query($sql, $params)->fetchOne(0, $cacheTtl);
        if ( ! $object || empty($object->cnt) )
        {
            return 0.0;
        }

        return (float)$object->cnt;
    }


    /**
     * Return the aggregate max count of column
     *
     * @param string $column
     * @param int $cacheTtl
     * @return int|float|string|null
     */
    public function max(string $column, int $cacheTtl=self::CACHE_NO)
    {
        return $this
            ->explicitSelectMode()
            ->fetchField("MAX({$column}) AS max", 0, $cacheTtl);
    }


    /**
     * Return the aggregate min count of column
     *
     * @param string $column
     * @param int $cacheTtl
     * @return int|float|string|null
     */
    public function min(string $column, int $cacheTtl=self::CACHE_NO)
    {
        return $this
            ->explicitSelectMode()
            ->fetchField("MIN({$column}) AS min", 0, $cacheTtl);
    }

    /**
     * Return the aggregate sum count of column
     *
     * @param string $column
     * @param int $cacheTtl
     * @return int|float|string|null
     */
    public function sum(string $column, int $cacheTtl=self::CACHE_NO)
    {
        return $this
            ->explicitSelectMode()
            ->fetchField("SUM({$column}) AS sum", 0, $cacheTtl);
    }

    /**
     * Return the aggregate average count of column
     *
     * @param string $column
     * @param int $cacheTtl
     * @return int|float|string|null
     */
    public function avg(string $column, int $cacheTtl=self::CACHE_NO)
    {
        return $this
            ->explicitSelectMode()
            ->fetchField("AVG({$column}) AS avg", 0, $cacheTtl);
    }

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

    /**
     * Reset fields
     *
     * @return FluentPdoModel|$this
     */
    public function reset() : FluentPdoModel
    {
        $this->_where_parameters        = [];
        $this->_select_fields           = [];
        $this->_join_sources            = [];
        $this->_join_aliases            = [];
        $this->_where_conditions        = [];
        $this->_limit                   = 0;
        $this->_offset                  = 0;
        $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        = [];

        $this->_filter_meta             = [];

        $this->_cache_ttl               = -1;
        $this->_timer                   = [];
        $this->_built_query             = '';
        $this->_paging_meta             = [];
        $this->_raw_sql                 = null;
        $this->_explicit_select_mode    = false;

        return $this;
    }


    /**
     * @return FluentPdoModel|$this
     */
    public function removeUnauthorisedFields() : FluentPdoModel
    {
        return $this;
    }

    /**
     * @return Closure[]
     */
    protected function _getFieldHandlers() : array
    {
        $columns = $this->getColumns(true);
        if ( empty($columns) )
        {
            return [];
        }

        return [
            'id' => function(string $field, $value, string $type='', stdClass $record=null) {

                unset($record);
                $value = $this->_fixType($field, $value);
                if ( $type === self::SAVE_INSERT )
                {
                    Validate($value)->fieldName($field)->nullOr()->id('ID must be a valid integer id, (%s) submitted.');
                    return $value;
                }
                Validate($value)->fieldName($field)->id('ID must be a valid integer id, (%s) submitted.');
                return $value;
            },
            self::CREATOR_ID_FIELD => function(string $field, $value, string $type='', stdClass $record=null) {

                unset($type, $record);
                $value = $this->_fixType($field, $value);
                // Created user id is set to current user if record is an insert or deleted if not (unless override is true)
                $value = $this->_allow_meta_override ? $value : $this->getUserId();
                Validate($value)->fieldName($field)->id('Created By must be a valid integer id, (%s) submitted.');
                return $value;
            },
            self::CREATED_TS_FIELD => function(string $field, $value, string $type='', stdClass $record=null) {

                unset($type, $record);
                $value = $this->_fixType($field, $value);
                // Created ts is set to now if record is an insert or deleted if not (unless override is true)
                $value = static::dateTime($this->_allow_meta_override ? $value : null);
                Validate($value)->fieldName($field)->date('Created must be a valid timestamp, (%s) submitted.');
                return $value;
            },
            self::MODIFIER_ID_FIELD => function(string $field, $value, string $type='', stdClass $record=null) {

                unset($type, $record);
                $value = $this->_fixType($field, $value);
                // Modified user id is set to current user (unless override is true)
                $value = $this->_allow_meta_override ? $value : $this->getUserId();
                Validate($value)->fieldName($field)->id('Modified By must be a valid integer id, (%s) submitted.');
                return $value;
            },
            self::MODIFIED_TS_FIELD => function(string $field, $value, string $type='', stdClass $record=null) {

                unset($type, $record);
                $value = $this->_fixType($field, $value);
                // Modified timestamps are set to now (unless override is true)
                $value = static::dateTime($this->_allow_meta_override ? $value : null);
                Validate($value)->fieldName($field)->date('Modified must be a valid timestamp, (%s) submitted.');
                return $value;
            },
            self::DELETER_ID_FIELD => function(string $field, $value, string $type='', stdClass $record=null) {

                if ( $type === self::SAVE_INSERT )
                {
                    return null;
                }
                if ( empty($record->deleted_ts) )
                {
                    return null;
                }
                unset($type, $record);
                $value = $this->_fixType($field, $value);

                // Modified user id is set to current user (unless override is true)
                $value = $this->_allow_meta_override ? $value : $this->getUserId();
                Validate($value)->fieldName($field)->nullOr()->id('Deleter must be a valid integer id, (%s) submitted.');
                return $value;
            },
            self::DELETED_TS_FIELD => function(string $field, $value, string $type='', stdClass $record=null) {

                if ( $type === self::SAVE_INSERT )
                {
                    return null;
                }
                unset($type, $record);
                $value = $this->_fixType($field, $value);
                if ( $value )
                {
                    $value = static::dateTime($this->_allow_meta_override ? $value : null);
                    Validate($value)->fieldName($field)->date('Deleted Timestamp must be a valid timestamp, (%s) submitted.');
                }

                return $value;
            },
        ];
    }

    /**
     * @return bool
     */
    public function begin() : bool
    {
        $pdo        = $this->getPdo();
        $oldDepth   = $pdo->getTransactionDepth();
        $res        = $pdo->beginTransaction();
        $newDepth   = $pdo->getTransactionDepth();
        $this->getLogger()->debug("Calling db begin transaction", [
            'old_depth'     => $oldDepth,
            'new_depth'     => $newDepth,
            'trans_started' => $newDepth === 1 ? true : false,
        ]);

        return $res;
    }

    /**
     * @return bool
     */
    public function commit() : bool
    {
        $pdo        = $this->getPdo();
        $oldDepth   = $pdo->getTransactionDepth();
        $res        = $pdo->commit();
        $newDepth   = $pdo->getTransactionDepth();
        $this->getLogger()->debug("Calling db commit transaction", [
            'old_depth'     => $oldDepth,
            'new_depth'     => $newDepth,
            'trans_ended'   => $newDepth === 0 ? true : false,
        ]);
        if ( ! $res )
        {
            return false;
        }

        return $res === 0 ? true : $res;
    }

    /**
     * @return bool
     */
    public function rollback() : bool
    {
        $pdo        = $this->getPdo();
        $oldDepth   = $pdo->getTransactionDepth();
        $res        = $pdo->rollback();
        $newDepth   = $pdo->getTransactionDepth();
        $this->getLogger()->debug("Calling db rollback transaction", [
            'old_depth'     => $oldDepth,
            'new_depth'     => $newDepth,
            'trans_ended'   => $newDepth === 0 ? true : false,
        ]);

        return $res;
    }

    /**
     * @param stdClass $record
     * @param  string  $type
     * @return stdClass
     */
    public function applyGlobalModifiers(stdClass $record, string $type) : stdClass
    {
        unset($type);
        foreach ( $record as $field => $value )

        {
            if ( is_string($record->{$field}) )
            {
                $record->{$field} = str_replace(["\r\n", "\\r\\n", "\\n"], "\n", $value);
            }
        }

        return $record;
    }

    /**
     * @param stdClass $record
     * @param  string $type
     * @return stdClass
     */
    public function removeUnneededFields(stdClass $record, string $type) : stdClass
    {
        $creator_id     = self::CREATOR_ID_FIELD;
        $created_ts     = self::CREATED_TS_FIELD;

        // 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});
            }
        }
        if ( property_exists($record, $created_ts) && $type !== 'INSERT' && ! $this->_allow_meta_override )
        {
            unset($record->{$created_ts});
        }
        if ( property_exists($record, $creator_id) && $type !== 'INSERT' && ! $this->_allow_meta_override )
        {
            unset($record->{$creator_id});
        }

        return $record;
    }


    /**
     * @param array $ids
     * @param array $values
     * @param int   $batch
     * @return bool
     */
    public function setById(array $ids, array $values, int $batch=1000) : bool
    {
        $ids        = array_unique($ids);
        if ( empty($ids) )
        {
            return true;
        }
        if ( count($ids) <= $batch )
        {
            return (bool)$this->whereIn('id', $ids)->updateArr($values);
        }
        while ( ! empty($ids) )
        {
            $thisBatch  = array_slice($ids, 0, $batch);
            $ids        = array_diff($ids, $thisBatch);
            $this->reset()->whereIn('id', $thisBatch)->updateArr($values);
        }

        return true;
    }


    /**
     * @param string $displayColumnValue
     * @return int
     */
    public function resolveId(string $displayColumnValue) : int
    {
        $displayColumn  = $this->getDisplayColumn();
        $className      = get_class($this);
        Assert($displayColumn)->notEmpty("Could not determine the display column for model ({$className})");

        return $this
            ->reset()
            ->where($displayColumn, $displayColumnValue)
            ->fetchInt('id', 0, self::ONE_HOUR);
    }

    /**
     * @param int   $resourceId
     * @param array $query
     * @param array $extraFields
     * @param int $cacheTtl
     * @return array
     */
    public function fetchApiResource(int $resourceId, array $query=[], array $extraFields=[], int $cacheTtl=self::CACHE_NO) : array
    {
        Assert($resourceId)->id();

        $query['_limit']    = 1;
        $pagingMetaData        = $this->wherePk($resourceId)->_prepareApiResource($query, $extraFields);
        if ( $pagingMetaData['total'] === 0 )
        {
            return [[], $pagingMetaData];
        }

        return [$this->fetchOne($resourceId, $cacheTtl), $pagingMetaData];
    }

    /**
     * @param array     $query
     * @param array     $extraFields
     * @param int       $cacheTtl
     * @param string    $permEntity
     * @return array
     */
    public function fetchApiResources(array $query=[], array $extraFields=[], int $cacheTtl=self::CACHE_NO, string $permEntity='') : array
    {
        $pagingMetaData    = $this->_prepareApiResource($query, $extraFields);
        if ( $pagingMetaData['total'] === 0 )
        {
            return [[], $pagingMetaData];
        }
        $results = $this->fetch('', $cacheTtl);
        if ( ! $permEntity )
        {
            return [$results, $pagingMetaData];
        }
        foreach ( $results as $record )
        {
            if ( ! empty($record->id) )
            {
                $pagingMetaData['perms'][(int)$record->id] = $this->getMaskByResourceAndId($permEntity, $record->id);
            }
        }

        return [$results, $pagingMetaData];
    }


    /**
     * @return array
     */
    public function getSearchableAssociations() : array
    {
        $belongsTo = ! empty($this->_associations['belongsTo']) ? $this->_associations['belongsTo'] : [];
        unset($belongsTo['CreatedBy'], $belongsTo['ModifiedBy']);

        return $belongsTo;
    }

    /**
     * @param array $fields
     */
    public function removeUnrequestedFields(array $fields)
    {
        foreach ( $this->_select_fields as $idx => $field )
        {
            $field = trim(static::after(' AS ', $field, true));
            if ( ! in_array($field, $fields) )
            {
                unset($this->_select_fields[$idx]);
            }
        }
    }

    /**
     * @param array $removeFields
     */
    public function removeFields(array $removeFields=[])
    {
        $searches = [];
        foreach ( $removeFields as $removeField )
        {
            $removeField    = str_replace("{$this->_table_alias}.", '', $removeField);
            $searches[]     = "{$this->_table_alias}.{$removeField}";
            $searches[]     = $removeField;
        }
        foreach ( $this->_select_fields as $idx => $selected )
        {
            $selected = stripos($selected, ' AS ') !== false ? preg_split('/ as /i', $selected) : [$selected];
            foreach ( $selected as $haystack )
            {
                foreach ( $searches as $search )
                {
                    if ( trim($haystack) === trim($search) )
                    {
                        unset($this->_select_fields[$idx]);
                        continue;
                    }
                }
            }
        }
    }

    /**
     * @return FluentPdoModel|$this
     */
    public function defaultFilters() : FluentPdoModel
    {
        return $this;
    }

    /**
     * @param bool $allow
     *
     * @return FluentPdoModel|$this
     */
    public function allowMetaColumnOverride(bool $allow=false) : FluentPdoModel
    {
        $this->_allow_meta_override = $allow;

        return $this;
    }

    /**
     * @param bool $skip
     *
     * @return FluentPdoModel|$this
     */
    public function skipMetaUpdates(bool $skip=true) : FluentPdoModel
    {
        $this->_skip_meta_updates = $skip;

        return $this;
    }

    /**
     * @param bool $add
     *
     * @return FluentPdoModel|$this
     */
    public function addUpdateAlias(bool $add=true) : FluentPdoModel
    {
        $this->_add_update_alias = $add;

        return $this;
    }

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

        $record     =  $this->fixTypesToSentinel($record);

        return $this->fixTimestamps($record);
    }

    /**
     * @param $value
     * @return string
     */
    public function gzEncodeData(string $value) : string
    {
        if ( $this->_hasGzipPrefix($value) )
        {
            return $value;
        }

        return static::GZIP_PREFIX . base64_encode(gzencode($value, 9));
    }

    /**
     * @param $value
     * @return mixed|string
     */
    public function gzDecodeData(string $value) : string
    {
        if ( ! $this->_hasGzipPrefix($value) )
        {
            return $value;
        }
        $value = substr_replace($value, '', 0, strlen(static::GZIP_PREFIX));

        return gzdecode(base64_decode($value));
    }

    /**
     * @param $value
     * @return bool
     */
    protected function _hasGzipPrefix(string $value) : bool
    {
        return substr($value, 0, strlen(static::GZIP_PREFIX)) === static::GZIP_PREFIX ? true : false;
    }

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

        {
            if ( preg_match('/_ts$/', $field) )
            {
                $record->{$field} = empty($value) ? $value : static::atom($value);
            }
        }

        return $record;
    }

    /**
     * @param int $max
     * @return FluentPdoModel|$this
     */
    public function setMaxRecords(int $max) : FluentPdoModel
    {
        Assert($max)->int();
        $this->_default_max = $max;

        return $this;
    }


    /**
     * @param stdClass $record
     * @param string   $type
     * @return stdClass
     */
    public function afterSave(stdClass $record, string $type) : stdClass
    {
        unset($type);
        $this->clearCacheByTable();
        foreach ( $record as $column => $value )

        {
            if ( !empty($record->{$column}) )
            {
                if ( preg_match('/_ts$/', $column) )
                {
                    $record->{$column} = static::atom($value);
                }
                if ( preg_match('/_am$/', $column) )
                {
                    $record->{$column} = number_format($value, 2, '.', '');
                }
            }
        }

        return $record;
    }

    /**
     * @param stdClass $record
     * @param string $type
     * @return stdClass
     */
    public function addDefaultFields(stdClass $record, string $type) : stdClass
    {
        $columns            = $this->getColumns(true);
        if ( empty($columns) )
        {
            return $record;
        }
        $defaults           = [
            self::SAVE_UPDATE   => [
                self::MODIFIER_ID_FIELD        => null,
                self::MODIFIED_TS_FIELD        => null,
            ],
            self::SAVE_INSERT   => [
                self::CREATOR_ID_FIELD         => null,
                self::CREATED_TS_FIELD         => null,
                self::MODIFIER_ID_FIELD        => null,
                self::MODIFIED_TS_FIELD        => null,
            ]
        ];
        if ( $this->_skip_meta_updates )
        {
            $defaults[self::SAVE_UPDATE] = [];
        }
        $columns            = array_flip($this->getColumns());
        $defaults           = array_intersect_key($defaults[$type], $columns);
        foreach ( $defaults as $column => $def )
        {
            $record->{$column} = $record->{$column} ?? $def;
        }
        unset($record->active);

        return $record;
    }


    /**
     * @return bool
     */
    public function createTable() : bool
    {
        return true;
    }

    /**
     * @param bool|false $force
     * @return FluentPdoModel|$this
     * @throws Exception
     */
    public function dropTable(bool $force=false) : FluentPdoModel

    {
        return $this;
    }

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

        {
            return;
        }
        $parentHandlers      = self::_getFieldHandlers();
        $this->_handlers    = array_merge($parentHandlers, $this->_getFieldHandlers());
    }

    /**
     * @param string $viewName
     * @param int $cacheTtl
     * @return array
     */
    public function getViewColumns($viewName, $cacheTtl=self::CACHE_NO)
    {
        return $this->_getColumnsByTableFromDb($viewName, $cacheTtl);
    }

    /**
     * @param int $id
     * @return string
     */
    public function getDisplayNameById(int $id) : string
    {
        $displayColumn  = $this->getDisplayColumn();
        $className      = get_class($this);
        Assert($displayColumn)->notEmpty("Could not determine the display column for model ({$className})");

        return $this
            ->reset()
            ->fetchStr($displayColumn, $id, self::ONE_HOUR);
    }

    /**
     * @param int $id
     * @param string $displayColumnValue
     * @return bool
     */
    public function validIdDisplayNameCombo(int $id, $displayColumnValue) : bool
    {
        return $displayColumnValue === $this->getDisplayNameById($id);
    }

    /**
     * @param array $toPopulate
     * @return stdClass
     */
    protected function getEmptyObject(array $toPopulate=[]) : stdClass
    {
        $toPopulate[]   = 'id';

        return (object)array_flip($toPopulate);
    }

    /**
     * @param array $toPopulate
     * @return stdClass
     */
    protected static function emptyObject(array $toPopulate=[]) : stdClass
    {
        $toPopulate[]   = 'id';

        return (object)array_flip($toPopulate);
    }

    /**
     * @param int $id
     * @return bool
     */
    public static function isId(int $id) : bool
    {
        return $id > 0;
    }

    /**
     * @param int $cacheTtl
     * @return int
     */
    public function activeCount(int $cacheTtl=self::CACHE_NO) : int
    {
        return (int)$this->whereActive()->count('*', $cacheTtl);
    }

    /**
     * @param string        $tableAlias
     * @param string   $columnName
     * @return FluentPdoModel|$this
     */
    public function whereActive(string $tableAlias='', string $columnName=self::STATUS_FIELD) : FluentPdoModel
    {
        return $this->whereStatus(static::ACTIVE, $tableAlias, $columnName);
    }

    /**
     * @param string        $tableAlias
     * @param string        $columnName
     * @return FluentPdoModel|$this
     */
    public function whereInactive(string $tableAlias='', string $columnName=self::STATUS_FIELD) : FluentPdoModel
    {
        return $this->whereStatus(static::INACTIVE, $tableAlias, $columnName);
    }

    /**
     * @param string        $tableAlias
     * @param string        $columnName
     * @return FluentPdoModel|$this
     */
    public function whereArchived(string $tableAlias='', string $columnName='status') : FluentPdoModel
    {
        return $this->whereStatus(static::ARCHIVED, $tableAlias, $columnName);
    }

    /**
     * @param int $status
     * @param string $tableAlias
     * @param string $columnName
     * @return FluentPdoModel|$this
     */
    public function whereStatus(int $status, string $tableAlias='', string $columnName=self::STATUS_FIELD) : FluentPdoModel
    {
        Assert($status)->inArray([static::ACTIVE, static::INACTIVE, static::ARCHIVED]);

        $tableAlias = empty($tableAlias) ? $this->getTableAlias() : $tableAlias;
        $field      = empty($tableAlias) ? $columnName : "{$tableAlias}.{$columnName}";

        return $this->where($field, $status);
    }

    /**
     * @param int $id
     * @return int
     */
    public function updateActive(int $id=0) : int
    {
        Assert($id)->unsignedInt();
        if ( $id )
        {
            $this->wherePk($id);
        }

        return $this->updateStatus(static::ACTIVE);
    }

    /**
     * @param int $id
     * @return int
     */
    public function updateInactive(int $id=0) : int
    {
        Assert($id)->unsignedInt();
        if ( $id )
        {
            $this->wherePk($id);
        }
        return $this->updateStatus(static::INACTIVE);
    }

    /**
     * @param string $field
     * @param int  $id
     * @return int
     */
    public function updateNow(string $field, int $id=0) : int
    {
        Assert($field)->notEmpty();

        return $this->updateField($field, date('Y-m-d H:i:s'), $id);
    }

    /**
     * @param string $field
     * @param int  $id
     * @return int
     */
    public function updateToday($field, int $id=0) : int
    {
        Assert($field)->notEmpty();

        return $this->updateField($field, date('Y-m-d'), $id);
    }

    /**
     * @param int $id
     * @return int
     */
    public function updateDeleted(int $id=0) : int
    {
        Assert($id)->unsignedInt();
        if ( $id )
        {
            $this->wherePk($id);
        }

        return $this->update((object)[
            self::DELETER_ID_FIELD  => $this->getUserId(),
            self::DELETED_TS_FIELD  => static::dateTime(),
        ]);
    }

    /**
     * @param int $id
     * @return int
     */
    public function updateArchived(int $id=0) : int
    {
        Assert($id)->unsignedInt();
        if ( $id )
        {
            $this->wherePk($id);
        }

        return $this->updateStatus(static::ARCHIVED);
    }

    /**
     * @param int $status
     * @return int
     * @throws \Exception
     */
    public function updateStatus(int $status)
    {
        Assert($status)->inArray([static::ACTIVE, static::INACTIVE, static::ARCHIVED]);

        return $this->updateField('status', $status);
    }

    /**
     * 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(string $datetime='now') : string
    {
        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(int $numberOfPlaceholders=1) : string
    {
        return implode(', ', array_fill(0, $numberOfPlaceholders, '?'));
    }

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

    /**
     * @param array $query
     * @param array $extraFields
     * @return array
     * @throws \Exception
     */
    protected function _prepareApiResource(array $query=[], array $extraFields=[]) : array
    {
        $this->defaultFilters()->filter($query)->paginate($query);
        $pagingMetaData    = $this->getPagingMeta();
        if ( $pagingMetaData['total'] === 0 )
        {
            return $pagingMetaData;
        }
        $this->withBelongsTo($pagingMetaData['fields']);
        if ( ! empty($extraFields) )
        {
            $this->select($extraFields, '', false);
        }
        $this->removeUnauthorisedFields();
class User
{
    private $email;

    public function getEmail()
    {
        return $this->email;
    }

    public function setEmail($email)
    {
        $this->email = $email;
    }
}
        if ( ! empty($pagingMetaData['fields']) )
        {
            $this->removeUnrequestedFields($pagingMetaData['fields']);
        }

        return $pagingMetaData;
    }

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

        return [$query, $ident];
    }

    /**
     * @param string $ident
     * @param string $builtQuery
     */
    protected function _logSlowQueries(string $ident, string $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() : float
    {
        $secondsTaken = $this->_timer['end'] - $this->_timer['start'];

        return (float)$secondsTaken;
    }

    /**
     * @param $secs
     * @return FluentPdoModel|$this
     */
    public function slowQuerySeconds(int $secs) : FluentPdoModel
    {
        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 string  $placeholderPrefix
     *
     * @return array
     */
    public function getNamedWhereIn(string $field, array $values, string $placeholderPrefix='') : array
    {
        Assert($field)->string()->notEmpty();
        Assert($values)->isArray();

        if ( empty($values) )
        {
            return ['', []];
        }
        $placeholderPrefix      = $placeholderPrefix ?: strtolower(str_replace('.', '__', $field));
        $params                 = [];
        $placeholders           = [];
        $count                  = 1;
        foreach ( $values as $val )
        {
            $name                   = "{$placeholderPrefix}_{$count}";
            $params[$name]          = $val;
            $placeholders[]         = ":{$name}";
            $count++;
        }
        $placeholders           = implode(',', $placeholders);

        return ["AND {$field} IN ({$placeholders})\n", $params];
    }

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

        return ['', $field];
    }

    /**
     * @param string $column
     * @param string $term
     * @return FluentPdoModel|$this
     */
    protected function _addWhereClause(string $column, string $term) : FluentPdoModel
    {
        /*

         whereLike          i.e ?name=whereLike(%terry%)
         whereNotLike       i.e ?name=whereNotLike(%terry%)
         whereLt            i.e ?age=whereLt(18)
         whereLte           i.e ?age=whereLte(18)
         whereGt            i.e ?event_dt=whereGt(2014-10-10)
         whereGte           i.e ?event_dt=whereGte(2014-10-10)
         whereBetween       i.e ?event_dt=whereBetween(2014-10-10,2014-10-15)
         whereNotBetween    i.e ?event_dt=whereNotBetween(2014-10-10,2014-10-15)

         */
        list ($func, $matches) = $this->parseWhereClause($term);
        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);
    }

    /**
     * @param string $term
     * @return array
     */
    public function parseWhereClause(string $term) : array
    {
        $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);

                return [$func, $matches];
            }
        }

        return ['', []];
    }

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

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

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

        return new $modelName($connection);
    }

    /**
     * Load a model
     *
     * @param string      $tableName
     * @param AbstractPdo $connection
     * @return FluentPdoModel|$this
     */
    public static function loadTable(string $tableName, AbstractPdo $connection=null) : FluentPdoModel
    {
        $modelName     = Inflector::classify($tableName);
        Assert($modelName)->notEmpty("Could not resolve model name from table name.");

        return static::loadModel($modelName, $connection);
    }

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

        return array_key_exists($columnName, $columns);
    }

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

        return array_key_exists($foreignKeyName, $columns);
    }

    /**
     * @param string   $indexName
     * @param int $cacheTtl
     * @param bool $flushCache
     * @return bool
     */
    public function indexExists(string $indexName, int $cacheTtl=self::CACHE_NO, bool $flushCache=false) : bool
    {
        Assert($indexName)->string()->notEmpty();

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

            $index = $this->execute("SHOW INDEX FROM {$this->_table_name} WHERE Key_name = ':indexName'", compact('indexName'));

            return $index ? true : false;
        };
        if  ( $cacheTtl === self::CACHE_NO )
        {
            return $callback();
        }
        $cacheKey   = '/column_schema/' . $this->_table_name . '/index/' . $indexName;
        if ( $flushCache === true )
        {
            $this->clearCache($cacheKey);
        }

        return (bool)$this->_cacheData($cacheKey, $callback, $cacheTtl);
    }



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

        return $this;
    }

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

        return $schema;
    }

    /**
     * @param int $cacheTtl
     * @param bool $flushCache
     * @return array
     */
    public function getForeignKeysFromDb(int $cacheTtl=self::CACHE_NO, bool $flushCache=false) : array
    {
        $table          = $this->getTableName();
        Assert($table)->string()->notEmpty();
        $schema         = [];
        $foreignKeys    = $this->_getForeignKeysByTableFromDb($table, $cacheTtl, $flushCache);
        foreach ( $foreignKeys[$table] as $key => $meta )
        {
            $schema[$key] = $meta->dataType;
        }

        return $schema;
    }

    /**
     * @param string $table
     * @param int $cacheTtl
     * @param bool $flushCache
     * @return Column[][]
     */
    protected function _getColumnsByTableFromDb(string $table, int $cacheTtl=self::CACHE_NO, bool $flushCache=false) : array
    {
        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 (array)$this->_cacheData($cacheKey, $callback, $cacheTtl);
    }

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

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

            return $this->_connection->getForeignKeys($table);
        };
        $cacheKey   = '/foreign_keys_schema/' . $table;
        if ( $flushCache === true )
        {
            $this->clearCache($cacheKey);
        }

        return (array)$this->_cacheData($cacheKey, $callback, $cacheTtl);
    }

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

    /**
     * @param stdClass $record
     * @return stdClass
     */
    public function cleanseRecord(stdClass $record) : stdClass
    {
        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, string $type) : stdClass
    {
        $record = $this->addDefaultFields($record, $type);
        $record = $this->applyGlobalModifiers($record, $type);
        $record = $this->applyHandlers($record, $type);
        $record = $this->removeUnneededFields($record, $type);

        return $record;
    }

    /**
     * @param array $data
     * @param string $saveType
     * @return array
     */
    public function cleanseWebData(array $data, string $saveType) : array
    {
        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() : array
    {
        $skel       = [];
        $columns    = $this->columns(false);
        foreach ( $columns as $column => $type )
        {
            $skel[$column] = null;
        }

        return $skel;
    }

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

            return implode("\n", $errors);
        }

        return $this->_errors;
    }

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

        return $this;
    }

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

        return $this;
    }

    /**
     * @param int $limit
     * @param int $offset
     * @return FluentPdoModel|$this
     */
    protected function _setLimit(int $limit=0, int $offset=0) : FluentPdoModel
    {
        $limit      = ! $limit || (int)$limit > (int)$this->_default_max ? (int)$this->_default_max : (int)$limit;
        if ( ! is_numeric($limit) )
        {
            return $this;
        }
        $this->limit((int)$limit);
        if ( $offset && is_numeric($offset) )
        {
            $this->offset((int)$offset);
        }

        return $this;
    }

    /**
     * @param array $fields
     * @return FluentPdoModel|$this
     * @throws Exception
     */
    protected function _setFields(array $fields=[]) : FluentPdoModel
    {
        if ( ! $fields )

        {
            return $this;
        }
        $this->explicitSelectMode();
        $columns    = $this->getColumns();

        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[] = $fieldAlias;
                continue;
            }
            // Reference table select field without alias
            $belongsTo = array_key_exists('belongsTo', $this->_associations) ?  $this->_associations['belongsTo'] : [];
            foreach ( $belongsTo as $joinAlias => $config )
            {
                list(, , $join_field, $fieldAlias) = $config;
                if ( $field === $fieldAlias )
                {
                    $this->autoJoin($joinAlias, static::LEFT_JOIN, false);
                    $this->select($join_field, $fieldAlias);
                    $this->_requested_fields[] = $fieldAlias;
                    continue;
                }
            }
        }

        return $this;
    }

    /**
     * @param string $orderBy
     * @return FluentPdoModel|$this|FluentPdoModel
     */
    protected function _setOrderBy(string $orderBy='') : FluentPdoModel
    {
        if ( ! $orderBy )
        {
            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));
        $belongsTo                  = array_key_exists('belongsTo', $this->_associations) ? $this->_associations['belongsTo'] : [];
        // 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($belongsTo)->keyExists($alias, "Invalid table alias ({$alias}) specified for the order query");
            Assert($field)->eq($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 ( $belongsTo as $joinAlias => $config )
        {
            if ( $field === $config[3] )
            {
                return $this->autoJoin($joinAlias)->orderBy($config[2], $direction);
            }
        }

        return $this;
    }

    /**
     * @return array
     */
    public function getPagingMeta()
    {
        if ( empty($this->_paging_meta) )
        {
            $this->setPagingMeta();
        }

        return $this->_paging_meta;
    }

    /**
     * @return FluentPdoModel|$this
     */
    public function setPagingMeta() : FluentPdoModel
    {
        $model                  = clone $this;
        $limit                  = intval($this->getLimit());
        $offset                 = intval($this->getOffset());
        $total                  = intval($model->withBelongsTo()->select('')->offset(0)->limit(0)->orderBy()->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'               => $this->_filter_meta,
            'fields'                => $this->_requested_fields,
            'perms'                 => [],
        ];

        return $this;
    }

    /**
     * Take a web request and format a query
     *
     * @param array $query
     *
     * @return FluentPdoModel|$this
     * @throws Exception
     */
    public function filter(array $query=[]) : FluentPdoModel
    {
        $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((string)$value, '|') !== false ? explode('|', $value) : $value;
            if ( is_array($where) )
            {
                $this->whereIn($field, $where);
            }
            else
            {
                $this->_addWhereClause($field, (string)$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 )
        {
            if ( in_array($column, $this->excluded_search_cols) )
            {
                continue;
            }
            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 string $displayCol
     * @return string|null
     */
    protected function _findFieldByQuery(string $column, string $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;
    }

    /**
     * @param $keysOnly
     * @return array
     */

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

    /**
     * @param string $field
     * @param mixed $value
     * @param array $pdoMetaData
     * @return float|int
     * @throws Exception
     */
    protected function _fixTypeToSentinel(string $field, $value, array $pdoMetaData=[])
    {
        Assert($value)->nullOr()->scalar("var is type of " . gettype($value));

        $fieldType      = strtolower($pdoMetaData['native_type'] ??''?: '');
        if ( ! $fieldType )
        {
            if ( empty($this->_schema) )
            {
                return $value;
            }
            $columns    = $this->getColumns(false);
            Assert($columns)->keyExists($field, "The property {$field} does not exist.");

            $fieldType = $columns[$field] ?: null;
        }


        // Don't cast invalid values... only those that can be cast cleanly
        switch ( $fieldType )
        {
            case 'varchar':
            case 'var_string':
            case 'string':
            case 'text';
            case 'date':
            case 'datetime':
            case 'timestamp':
            case 'blob':

                return (string)$value;

            case 'int':
            case 'integer':
            case 'tinyint':
            case 'tiny':
            case 'long':
            case 'longlong':

                return (int)$value;

            case 'decimal':
            case 'float':
            case 'double':
            case 'newdecimal':

                return (float)$value;

            default:

                Assert(false)->true('Unknown type: ' . $fieldType);

                return $value;
        }
    }

    /**
     * @param string $field
     * @param mixed $value
     * @param bool|false $permissive
     * @return float|int|null|string
     */
    protected function _fixType(string $field, $value, bool $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.");

        $fieldType = ! 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 ( $fieldType )
        {
            case 'varchar':
            case 'text';
            case 'date':
            case 'datetime':
            case 'timestamp':

                // return on null, '' but not 0
                return ! is_numeric($value) && empty($value) ? null : (string)$value;

            case 'int':

                if ( $field === 'id' || substr($field, -3) === '_id' )
                {
                    return $value ? (int)$value : null;
                }

                return ! is_numeric($value) ? null : (int)$value;

            case 'decimal':

                return ! is_numeric($value) ? null : (float)$value;

            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 fixTypesToSentinel(stdClass $record, string $type='') : stdClass
    {
        foreach ( $this->row_meta_data as $column => $pdoMetaData )
        {
            if ( ! property_exists($record, $column) )
            {
                continue;
            }
            $record->{$column} = $this->_fixTypeToSentinel($column, $record->{$column}, $pdoMetaData);
        }
        // PDO might not be able to generate the meta data to sniff types
        if ( ! $this->row_meta_data )

        {
            foreach ( $this->getColumns(false) as $column => $fieldType )
            {
                if ( ! property_exists($record, $column) )
                {
                    continue;
                }
                $record->{$column} = $this->_fixTypeToSentinel($column, $record->{$column});
            }
        }

        unset($type);

        return $record;
    }

    /**
     * @param stdClass $record
     * @param string   $type
     * @return stdClass
     * @throws Exception
     */
    public function applyHandlers(stdClass $record, string $type='INSERT') : stdClass
    {
        $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 stdClass $record
     * @param array    $fields
     * @param string   $type
     * @return bool
     */
    protected function uniqueCheck(stdClass $record, array $fields, string $type) : bool
    {
        if ( $type === self::SAVE_UPDATE )
        {
            $this->whereNot($this->_primary_key, $record->{$this->_primary_key});
        }
        foreach ( $fields as $field )
        {
            $this->where($field, $record->{$field});
        }

        return (int)$this->count() > 0;
    }

    /**
     * @param string $field
     * @param mixed $value
     * @param string $type
     * @param stdClass $record
     * @return null
     * @throws Exception
     */
    protected function applyHandler(string $field, $value, string $type='', stdClass $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;
    }

    /**
     * @param string $start
     * @param string $end
     * @param string $hayStack
     * @return mixed
     */
    public static function between(string $start, string $end, string $hayStack) : string
    {
        return static::before($end, static::after($start, $hayStack));
    }

    /**
     * @param string     $needle
     * @param string     $hayStack
     * @param bool $returnOrigIfNeedleNotExists
     * @return mixed
     */
    public static function before(string $needle, string $hayStack, bool $returnOrigIfNeedleNotExists=false) : string
    {
        $result = mb_substr($hayStack, 0, mb_strpos($hayStack, $needle));
        if ( !$result && $returnOrigIfNeedleNotExists )
        {
            return $hayStack;
        }

        return $result;
    }

    /**
     * @param string     $needle
     * @param string     $hayStack
     * @param bool $returnOrigIfNeedleNotExists
     * @return string
     */
    public static function after(string $needle, string $hayStack, bool $returnOrigIfNeedleNotExists=false) : string
    {
        if ( ! is_bool(mb_strpos($hayStack, $needle)) )
        {
            return mb_substr($hayStack, mb_strpos($hayStack, $needle) + mb_strlen($needle));
        }

        return $returnOrigIfNeedleNotExists ? $hayStack : '';
    }

    /**
     * @return int
     */
    public function getUserId()
    {
        return 0;
    }

    /**
     * @param string $entity
     * @param int $id
     * @return int
     */
    public function getMaskByResourceAndId(string $entity, int $id) : int

    {
        return 31;
    }

    /**
     * @param string|int|null $time
     * @return string
     */
    public static function date($time=null) : string
    {
        return date('Y-m-d', static::getTime($time));
    }

    /**
     * @param string|int|null $time
     * @return string
     */
    public static function dateTime($time=null) : string
    {
        return date('Y-m-d H:i:s', static::getTime($time));
    }

    /**
     * @param string|int|null $time
     * @return string
     */
    public static function atom($time=null) : string
    {
        return date('Y-m-d\TH:i:sP', static::getTime($time));
    }

    /**
     * @param string|int|null $time
     * @return int
     */
    public static function getTime($time=null) : int
    {
        if ( ! $time )
        {
            return time();
        }
        if ( is_int($time) )
        {
            return $time;
        }

        return strtotime($time);
    }

    /**
     * @param int $id
     * @param int $cacheTtl
     * @return string
     */
    public function getCodeById(int $id, int $cacheTtl=self::ONE_DAY) : string
    {
        Assert($id)->id();
        $code   = $this->defaultFilters()->fetchStr($this->getDisplayColumn(), $id, $cacheTtl);
        Assert($code)->notEmpty();

        return $code;
    }

    /**
     * @param array $authUserRoles
     * @param int   $authUserId
     * @return FluentPdoModel
     */
    public function applyRoleFilter(array $authUserRoles, int $authUserId) : FluentPdoModel

    {
        return $this;
    }

    /**
     * @param int    $id
     * @param string[] $authUserRoles
     * @param int    $authUserId
     * @return bool
     */
    public function canAccessIdWithRole(int $id, array $authUserRoles, int $authUserId) : bool

    {
        return true;
    }
}

terah / fluent-pdo-model

Push — master ( f7f9d7...9d7b5e )

FluentPdoModel::whereLt() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
