DatalayerTrait::fetchArrayAssoc() - Code Metrics - brunobmorais/php-database - Measure and Improve Code Quality continuously with Scrutinizer

DatalayerTrait::fetchArrayAssoc() A
last analyzed 2025-10-01 14:22 UTC

↳ Parent: DatalayerTrait
Complexity

Conditions	3
Paths	8
Size

Total Lines	12
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Importance

Changes	5
Bugs	0	Features	0
Metric	Value
cc	3
eloc	10
c	5
b	0
f	0
nc	8
nop	1
dl	0
loc	12
rs	9.9332
<?php
namespace BMorais\Database;

use PDO;
use PDOException;
use PDOStatement;
use stdClass;

/**
 * CLASS TRAIT DATALAYER
 * This class of execution methods in the database
 *
 * @author Bruno Morais <[email protected]>
 * @copyright MIT, bmorais.com
 * @package bmorais\database
 * @subpackage class
 * @access private
 */
trait DatalayerTrait
{
    /** @var PDO|null
     * @deprecated USE $this->setClassModel("NAME");
     * */
    protected ?PDO $instance = null;

    /** @var string
     *  @deprecated
     */
    protected string $fields;

    /** @var PDOStatement|null
     *   @deprecated */
    protected $prepare = null;

    /** @var string
     *  @deprecated
     */
    protected string $database = CONFIG_DATA_LAYER["dbname"];

    /** @var string
     *  @deprecated USE $this->setInstance(PDO);
     */
    protected string $classModel;

    /** @var string
     * @deprecated USE $this->setTableName("name");
     */
    protected string $tableName;

    /** @var string */
    private string $tableAlias;

    /** @var array
     */
    private array $data = [];

    /** @var string */
    private string $logSQL;

    /** @var PDOException */
    private $error;

    /** @var string */
    private string $query = "";

    /** @var array */
    private array $params = [];


    /**
     * @return PDO|false
     * @throws DatabaseException
     */
    private function getConnect()
    {
        try {
            if (strpos($_SERVER['SERVER_NAME'], mb_strtolower(CONFIG_DATA_LAYER["homologation"])) && !strpos($this->getDatabase(), ucfirst(CONFIG_DATA_LAYER["homologation"]))) {
                $database = $this->getDatabase().ucfirst(CONFIG_DATA_LAYER["homologation"] ?? "");
                $this->setDatabase($database);
            }

            if (empty($this->instance)) {
            if (empty(/** @scrutinizer ignore-deprecated */ $this->instance)) {
                $this->instance = new PDO(
                /** @scrutinizer ignore-deprecated */ $this->instance = new PDO(
                    CONFIG_DATA_LAYER['driver'] . ':host=' . CONFIG_DATA_LAYER['host'] . ';dbname=' . $this->getDatabase() . ';port=' . CONFIG_DATA_LAYER['port'],
                    CONFIG_DATA_LAYER['username'],
                    CONFIG_DATA_LAYER['passwd'],
                    CONFIG_DATA_LAYER['options']
                );
            }

            return $this->instance;
            return /** @scrutinizer ignore-deprecated */ $this->instance;
        } catch (PDOException $e) {
            throw new DatabaseException(
                "Database connection failed - TABLE: [{$this->getTableName()}] MESSAGE: [{$e->getMessage()}]",
                $e->getCode(),
                $e
            );
        }
    }

    /**
     * @param ?PDO $pdo
     * @return Crud
     *
     */
    protected function setInstance(?PDO $pdo): self
    {
        $this->instance = $pdo;
        /** @scrutinizer ignore-deprecated */ $this->instance = $pdo;
        return $this;
    }

    /**
     * @return PDO
     * @throws DatabaseException
     */
    protected function getInstance(): PDO
    {
        return $this->getConnect();
    }

    /**
     * @param string $database
     * @return $this
     */
    protected function setDatabase(string $database): self
    {
        if (strpos($_SERVER['SERVER_NAME'], mb_strtolower(CONFIG_DATA_LAYER["homologation"])) && !strpos($database, ucfirst(CONFIG_DATA_LAYER["homologation"]))) {
            $database = $database.ucfirst(CONFIG_DATA_LAYER["homologation"] ?? "");
            $this->database = $database;
            /** @scrutinizer ignore-deprecated */ $this->database = $database;
        } else {
            $this->database = $database;
            /** @scrutinizer ignore-deprecated */ $this->database = $database;
        }

        if (!empty($this->instance)){
        if (!empty(/** @scrutinizer ignore-deprecated */ $this->instance)){
            $this->executeSQL("USE {$this->getDatabase()}");
        }

        return $this;
    }

    /**
     * @return string
     */
    protected function getDatabase(): string
    {
        return $this->database ?? "";
        return /** @scrutinizer ignore-deprecated */ $this->database ?? "";
    }

    /**
     * @param string $fields
     * @return Crud
     */
    protected function setFields(string $fields): self
    {
        $this->fields = $fields;
        /** @scrutinizer ignore-deprecated */ $this->fields = $fields;
        return $this;
    }

    /**
     * @return string
     */
    protected function getFields():string
    {
        return $this->fields;
        return /** @scrutinizer ignore-deprecated */ $this->fields;
    }

    /**
     * @param string $tableName
     * @param string $tableAlias
     * @return CrudBuilder|Crud|DatalayerTrait
     */
    protected function setTableName(string $tableName, string $tableAlias = ""): self
    {
        if (!empty($tableAlias))
            $this->tableAlias = $tableAlias;
        $this->tableName = $tableName;
        /** @scrutinizer ignore-deprecated */ $this->tableName = $tableName;
        return $this;
    }

    /**
     * @return string
     */
    protected function getTableName(): string
    {
        return $this->tableName ?? "";
        return /** @scrutinizer ignore-deprecated */ $this->tableName ?? "";
    }

    protected function getTableAlias(): string
    {
        return $this->tableAlias ?? "";
    }

    /**
     * @param string $classModel
     * @return Crud
     */
    protected function setClassModel(string $classModel): self
    {
        $this->classModel = $classModel;
        /** @scrutinizer ignore-deprecated */ $this->classModel = $classModel;
        return $this;
    }

    protected function getClassModel(): string
    {
        return $this->classModel;
        return /** @scrutinizer ignore-deprecated */ $this->classModel;
    }

    /**
     * @param string $classModel
     * @return Crud
     */
    protected function setPrepare(PDOStatement $prepare): self
    {
        $this->prepare = $prepare;
        /** @scrutinizer ignore-deprecated */ $this->prepare = $prepare;
        return $this;
    }

    protected function getPrepare(): PDOStatement
    {
        return $this->prepare;
        return /** @scrutinizer ignore-deprecated */ $this->prepare;
    }

    /**
     * @param $params
     * @return self
     */
    protected function setParams($params): self
    {
        $this->params = array_merge($this->params, $params);
        return $this;
    }

    /**
     * @param $params
     * @return array
     */
    protected function getParams(): array
    {
        return $this->params;
    }

    protected function getData(): array
    {
        return $this->data;
    }

    protected function setData(array $array): self
    {
        $this->data = $array;
        return $this;
    }

    public function getQuery(): string
    {
        return $this->query;
    }

    public function setQuery(string $query): self
    {
        $this->query = $query;
        return $this;
    }

    /**
     * @param string $query
     * @param array|null $params
     * @return PDOStatement
     * @throws DatabaseException
     */
    protected function executeSQL(string $query, ?array $params = null): PDOStatement
    {
        try {
            $this->setPrepare($this->getInstance()->prepare($query));
            $this->setSQL($query, $params);
            $this->getPrepare()->execute($params);
            return $this->getPrepare();
        } catch (PDOException $e) {
            throw new DatabaseException(
                "SQL execution failed - TABLE: [{$this->getTableName()}] MESSAGE: [{$e->getMessage()}]",
                $e->getCode(),
                $e,
                $query,
                $params
            );
        }
    }

    /**
     * @param PDOStatement|null $prepare
     * @return int|null
     * @throws DatabaseException
     */
    protected function rowCount(?PDOStatement $prepare = null): ?int
    {
        try {
            $prepare = empty($prepare) ? $this->getPrepare() : $prepare;
            return $prepare->rowCount();
        } catch (PDOException $e) {
            throw new DatabaseException(
                "Row count failed - TABLE: [{$this->getTableName()}] MESSAGE: [{$e->getMessage()}]",
                $e->getCode(),
                $e
            );
        }
    }

    /**
     * @param PDOStatement|null $prepare
     * @return array|null
     * @throws DatabaseException
     */
    protected function fetchArrayAssoc(?PDOStatement $prepare = null): ?array
    {
        try {
            $prepare = empty($prepare) ? $this->getPrepare() : $prepare;
            $dados = $prepare->fetchAll(PDO::FETCH_ASSOC);
            $this->setData($dados);
            return $dados;
        } catch (PDOException $e) {
            throw new DatabaseException(
                "Fetch array assoc failed - TABLE: [{$this->getTableName()}] MESSAGE: [{$e->getMessage()}]",
                $e->getCode(),
                $e
            );
        }
    }

    /**
     * @param PDOStatement|null $prepare
     * @return array|null
     * @throws DatabaseException
     */
    protected function fetchArrayObj(?PDOStatement $prepare = null): ?array
    {
        try {
            $prepare = empty($prepare) ? $this->getPrepare() : $prepare;
            $dados = $prepare->fetchAll(PDO::FETCH_OBJ);
            $this->setData($dados);
            return $dados;
        } catch (PDOException $e) {
            throw new DatabaseException(
                "Fetch array object failed - TABLE: [{$this->getTableName()}] MESSAGE: [{$e->getMessage()}]",
                $e->getCode(),
                $e
            );
        }
    }

    /**
     * @param PDOStatement|null $prepare
     * @param String|null $classModel
     * @return array|null
     * @throws DatabaseException
     */
    protected function fetchArrayClass(?PDOStatement $prepare = null, ?string $classModel = null): ?array
    {
        try {
            $prepare = empty($prepare) ? $this->getPrepare() : $prepare;
            $classModel = empty($classModel) ? $this->getClassModel() : $classModel;
            $dados = $prepare->fetchAll(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, CONFIG_DATA_LAYER["directory_models"] . $classModel);
            $this->setData($dados);
            return $dados;
        } catch (PDOException $e) {
            throw new DatabaseException(
                "Fetch array class failed - TABLE: [{$this->getTableName()}] MESSAGE: [{$e->getMessage()}]",
                $e->getCode(),
                $e
            );
        }
    }

    /**
     * @param PDOStatement|null $prepare
     * @return array|null
     * @throws DatabaseException
     */
    protected function fetchOneAssoc(?PDOStatement $prepare = null): ?array
    {
        try {
            $prepare = empty($prepare) ? $this->getPrepare() : $prepare;
            return $prepare->fetch(PDO::FETCH_ASSOC);
        } catch (PDOException $e) {
            throw new DatabaseException(
                "Fetch one assoc failed - TABLE: [{$this->getTableName()}] MESSAGE: [{$e->getMessage()}]",
                $e->getCode(),
                $e
            );
        }
    }

    /**
     * @param PDOStatement|null $prepare
     * @return stdClass|null
     * @throws DatabaseException
     */
    protected function fetchOneObj(?PDOStatement $prepare = null): ?stdClass
    {
        try {
            $prepare = empty($prepare) ? $this->getPrepare() : $prepare;
            return $prepare->fetch(PDO::FETCH_OBJ);
        } catch (PDOException $e) {
            throw new DatabaseException(
                "Fetch one object failed - TABLE: [{$this->getTableName()}] MESSAGE: [{$e->getMessage()}]",
                $e->getCode(),
                $e
            );
        }
    }

    /**
     * @param PDOStatement|null $prepare
     * @param String|null $class
     * @return object|null
     * @throws DatabaseException
     */
    protected function fetchOneClass(?PDOStatement $prepare = null, ?string $class = null): ?object
    {
        try {
            $prepare = empty($prepare) ? $this->getPrepare() : $prepare;
            $class = empty($class) ? $this->getClassModel() : $class;
            return $prepare->fetchObject(CONFIG_DATA_LAYER["directory_models"] . $class);
        } catch (PDOException $e) {
            throw new DatabaseException(
                "Fetch one class failed - TABLE: [{$this->getTableName()}] MESSAGE: [{$e->getMessage()}]",
                $e->getCode(),
                $e
            );
        }
    }

    /**
     * @return bool|null
     * @throws DatabaseException
     */
    protected function beginTransaction(): ?bool
    {
        try {
            $this->getInstance()->beginTransaction();
            return true;
        } catch (PDOException $e) {
            throw new DatabaseException(
                "Begin transaction failed - TABLE: [{$this->getTableName()}] MESSAGE: [{$e->getMessage()}]",
                $e->getCode(),
                $e
            );
        }
    }

    /**
     * @return bool|null
     * @throws DatabaseException
     */
    protected function commitTransaction(): ?bool
    {
        try {
            $this->getInstance()->commit();
            return true;
        } catch (PDOException $e) {
            throw new DatabaseException(
                "Commit transaction failed - TABLE: [{$this->getTableName()}] MESSAGE: [{$e->getMessage()}]",
                $e->getCode(),
                $e
            );
        }
    }

    /**
     * @return bool|null
     * @throws DatabaseException
     */
    protected function rollBackTransaction(): ?bool
    {
        try {
            $this->getInstance()->rollBack();
            return true;
        } catch (PDOException $e) {
            throw new DatabaseException(
                "Rollback transaction failed - TABLE: [{$this->getTableName()}] MESSAGE: [{$e->getMessage()}]",
                $e->getCode(),
                $e
            );
        }
    }

    /**
     * @return string|null
     * @throws DatabaseException
     */
    private function lastId(): ?string
    {
        try {
            return $this->getInstance()->lastInsertId();
        } catch (PDOException $e) {
            throw new DatabaseException(
                "Get last insert ID failed - TABLE: [{$this->getTableName()}] MESSAGE: [{$e->getMessage()}]",
                $e->getCode(),
                $e
            );
        }
    }

    /**
     * @param $sql_string
     * @param array|null $params
     * @return void
     * @throws DatabaseException
     */
    private function setSQL($sql_string, ?array $params = null)
    {
        try {
            if (!empty($params)) {
                $indexed = $params == array_values($params);
                foreach ($params as $k => $v) {
                    if (is_object($v)) {
                        if ($v instanceof \DateTime) {
                            $v = $v->format('Y-m-d H:i:s');
                        } else {
                            continue;
                        }
                    } elseif (is_string($v)) {
                        $v = "'$v'";
                    } elseif ($v === null) {
                        $v = 'NULL';
                    } elseif (is_array($v)) {
                        $v = implode(',', $v);
                    }

                    if ($indexed) {
                        $sql_string = preg_replace('/\?/', $v, $sql_string, 1);
                    } else {
                        if ($k[0] != ':') {
                            $k = ':' . $k;
                        } //add leading colon if it was left out
                        $sql_string = str_replace($k, $v, $sql_string);
                    }
                }
            }
            $this->logSQL = $sql_string;
        } catch (PDOException $e) {
            throw new DatabaseException(
                "Set SQL failed - TABLE: [{$this->getTableName()}] MESSAGE: [{$e->getMessage()}]",
                $e->getCode(),
                $e
            );
        }
    }

    /**
     * @return string|null
     * @throws DatabaseException
     */
    protected function getSQL(): ?string
    {
        try {
            return $this->logSQL ?? "";
        } catch (PDOException $e) {
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
            throw new DatabaseException(
                "Get SQL failed - TABLE: [{$this->getTableName()}] MESSAGE: [{$e->getMessage()}]",
                $e->getCode(),
                $e
            );
        }
    }

    /**
     * @param PDOException $e
     * @return void
     * @throws DatabaseException
     * @deprecated This method is no longer used - exceptions are thrown directly
     */
    protected function setError(PDOException $e)
    {
        $this->error = $e;
        throw new DatabaseException(
            "Database error - TABLE: [{$this->getTableName()}] MESSAGE: [{$e->getMessage()}]",
            $e->getCode(),
            $e
        );
    }
}
brunobmorais / php-database

DatalayerTrait::fetchArrayAssoc() A last analyzed 2025-10-01 14:22 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

DatalayerTrait::fetchArrayAssoc() A
last analyzed 2025-10-01 14:22 UTC
