pdo.php

Ir a la documentación de este archivo.

<?php
require_once CORE_PATH . 'libs/db/adapters/pdo/interface.php';

abstract class DbPDO extends DbBase implements DbPDOInterface
{

    protected $pdo;
    public $pdo_statement;
    protected $last_query;
    protected $last_error;
    protected $affected_rows;
    protected $db_rbdm;

    const DB_ASSOC = PDO::FETCH_ASSOC;

    const DB_BOTH = PDO::FETCH_BOTH;

    const DB_NUM = PDO::FETCH_NUM;

    public function connect($config)
    {

        if (!extension_loaded('pdo')) {
            throw new KumbiaException('Debe cargar la extensión de PHP llamada php_pdo');
        }

        try {
            $this->pdo = new PDO($config['type'] . ":" . $config['dsn'], $config['username'], $config['password']);
            if (!$this->pdo) {
                throw new KumbiaException("No se pudo realizar la conexion con $this->db_rbdm");
            }
            if ($this->db_rbdm != 'odbc') {
                $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
                $this->pdo->setAttribute(PDO::ATTR_CASE, PDO::CASE_LOWER);
                $this->pdo->setAttribute(PDO::ATTR_CURSOR, PDO::CURSOR_FWDONLY);
            }
            //Selecciona charset
            if ($config['type'] == 'mysql' and isset($config['charset'])) {
                $this->pdo->exec('set character set ' . $config['charset']);
            }
            $this->initialize();
            return true;
        } catch (PDOException $e) {
            throw new KumbiaException($this->error($e->getMessage()));
        }
    }

    public function query($sql_query)
    {
        $this->debug($sql_query);
        if ($this->logger) {
            Logger::debug($sql_query);
        }
        if (!$this->pdo) {
            throw new KumbiaException('No hay conexión para realizar esta acción');
        }
        $this->last_query = $sql_query;
        $this->pdo_statement = null;
        try {
            if ($pdo_statement = $this->pdo->query($sql_query)) {
                $this->pdo_statement = $pdo_statement;
                return $pdo_statement;
            } else {
                return false;
            }
        } catch (PDOException $e) {
            throw new KumbiaException($this->error($e->getMessage() . " al ejecutar <em>\"$sql_query\"</em>"));
        }
    }

    public function exec($sql_query)
    {
        $this->debug(">" . $sql_query);
        if ($this->logger) {
            Logger::debug($sql_query);
        }
        if (!$this->pdo) {
            throw new KumbiaException('No hay conexión para realizar esta acción');
        }
        $this->last_query = $sql_query;
        $this->pdo_statement = null;
        try {
            $result = $this->pdo->exec($sql_query);
            $this->affected_rows = $result;
            if ($result === false) {
                throw new KumbiaException($this->error(" al ejecutar <em>\"$sql_query\"</em>"));
            }
            return $result;
        } catch (PDOException $e) {
            throw new KumbiaException($this->error(" al ejecutar <em>\"$sql_query\"</em>"));
        }
    }

    public function close()
    {
        if ($this->pdo) {
            unset($this->pdo);
            return true;
        }
        return false;
    }

    public function fetch_array($pdo_statement=NULL, $opt='')
    {
        if ($opt === '') {
            $opt = self::DB_BOTH;
        }
        if (!$this->pdo) {
            throw new KumbiaException('No hay conexión para realizar esta acción');
        }
        if (!$pdo_statement) {
            $pdo_statement = $this->pdo_statement;
            if (!$pdo_statement) {
                return false;
            }
        }
        try {
            $pdo_statement->setFetchMode($opt);
            return $pdo_statement->fetch();
        } catch (PDOException $e) {
            throw new KumbiaException($this->error($e->getMessage()));
        }
    }

    public function __construct($config)
    {
        $this->connect($config);
    }

    public function num_rows($pdo_statement='')
    {
        if ($pdo_statement) {
            $pdo = clone $pdo_statement;
            return count($pdo->fetchAll(PDO::FETCH_NUM));
        } else {
            return 0;
        }
    }

    public function field_name($number, $pdo_statement=NULL)
    {
        if (!$this->pdo) {
            throw new KumbiaException('No hay conexión para realizar esta acción');
        }
        if (!$pdo_statement) {
            $pdo_statement = $this->pdo_statement;
            if (!$pdo_statement) {
                return false;
            }
        }
        try {
            $meta = $pdo_statement->getColumnMeta($number);
            return $meta['name'];
        } catch (PDOException $e) {
            throw new KumbiaException($this->error($e->getMessage()));
        }
    }

    public function data_seek($number, $pdo_statement=NULL)
    {
        return false;
    }

    public function affected_rows($pdo_statement=NULL)
    {
        if (!$this->pdo) {
            throw new KumbiaException('No hay conexión para realizar esta acción');
        }
        if ($pdo_statement) {
            try {
                $row_count = $pdo_statement->rowCount();
                if ($row_count === false) {
                    throw new KumbiaException($this->error(" al ejecutar <em>\"$sql_query\"</em>"));
                }
                return $row_count;
            } catch (PDOException $e) {
                throw new KumbiaException($this->error($e->getMessage()));
            }
        } else {
            return $this->affected_rows;
        }
    }

    public function error($err='')
    {
        if ($this->pdo) {
            $error = $this->pdo->errorInfo();
            $error = $error[2];
        } else {
            $error = "";
        }
        $this->last_error.= $error . " [" . $err . "]";
        if ($this->logger) {
            Logger::error($this->last_error);
        }
        return $this->last_error;
    }

    public function no_error($number=0)
    {
        if ($this->pdo) {
            $error = $this->pdo->errorInfo();
            $number = $error[1];
        }
        return $number;
    }

    public function last_insert_id($table='', $primary_key='')
    {
        return $this->pdo->lastInsertId();
    }

    public function begin()
    {
        return $this->pdo->beginTransaction();
    }

    public function rollback()
    {
        return $this->pdo->rollBack();
    }

    public function commit()
    {
        return $this->pdo->commit();
    }

    static public function add_quotes($value)
    {
        return "'" . addslashes($value) . "'";
    }

    public function insert($table, $values, $fields=null)
    {
        //$insert_sql = "";
        if (is_array($values)) {
            if (!count($values)) {
                throw new KumbiaException("Imposible realizar inserción en $table sin datos");
            }
            if (is_array($fields)) {
                $insert_sql = "INSERT INTO $table (" . join(",", $fields) . ") VALUES (" . join(",", $values) . ")";
            } else {
                $insert_sql = "INSERT INTO $table VALUES (" . join(",", $values) . ")";
            }
            return $this->exec($insert_sql);
        } else {
            throw new KumbiaException('El segundo parametro para insert no es un Array');
        }
    }

    public function update($table, $fields, $values, $where_condition=null)
    {
        $update_sql = "UPDATE $table SET ";
        if (count($fields) != count($values)) {
            throw new KumbiaException('El número de valores a actualizar no es el mismo de los campos');
        }
        $i = 0;
        $update_values = array();
        foreach ($fields as $field) {
            $update_values[] = $field . ' = ' . $values[$i];
            $i++;
        }
        $update_sql.= join(',', $update_values);
        if ($where_condition != null) {
            $update_sql.= " WHERE $where_condition";
        }
        return $this->exec($update_sql);
    }

    public function delete($table, $where_condition)
    {
        if ($where_condition) {
            return $this->exec("DELETE FROM $table WHERE $where_condition");
        } else {
            return $this->exec("DELETE FROM $table");
        }
    }

    public function last_sql_query()
    {
        return $this->last_query;
    }

}