5.0
Secciones

Abstract Class Phalcon\Db\AbstractDb

Código fuente en GitHub

Namespace Phalcon\Db   Uses \PDO

Phalcon\Db y sus clases relacionadas proporcional un interfaz simple de base de datos SQL para el Framework Phalcon. Phalcon\Db es la clase básica que usa para conectar su aplicación PHP a un RDBMS. Hay una clase de adaptador diferente para cada marca de RDBMS.

Este componente está destinado a operaciones de base de datos de más bajo nivel. Si quiere interactuar con bases de datos usando un mayor nivel de abstracción use Phalcon\Mvc\Model.

Phalcon\Db\AbstractDb es una clase abstracta. Sólo puede usarla con un adaptador de base de datos como Phalcon\Db\Adapter\Pdo

use Phalcon\Db;
use Phalcon\Db\Exception;
use Phalcon\Db\Adapter\Pdo\Mysql as MysqlConnection;

try {
    $connection = new MysqlConnection(
        [
            "host"     => "192.168.0.11",
            "username" => "sigma",
            "password" => "secret",
            "dbname"   => "blog",
            "port"     => "3306",
        ]
    );

    $result = $connection->query(
        "SELECTFROM robots LIMIT 5"
    );

    $result->setFetchMode(Enum::FETCH_NUM);

    while ($robot = $result->fetch()) {
        print_r($robot);
    }
} catch (Exception $e) {
    echo $e->getMessage(), PHP_EOL;
}

Métodos

public static function setup( array $options ): void;

Habilita/deshabilita opciones en el componente Base de Datos

Abstract Class Phalcon\Db\Adapter\AbstractAdapter

Código fuente en GitHub

Namespace Phalcon\Db\Adapter   Uses Phalcon\Db\DialectInterface, Phalcon\Db\ColumnInterface, Phalcon\Db\Enum, Phalcon\Db\Exception, Phalcon\Db\Index, Phalcon\Db\IndexInterface, Phalcon\Db\Reference, Phalcon\Db\ReferenceInterface, Phalcon\Db\RawValue, Phalcon\Events\EventsAwareInterface, Phalcon\Events\ManagerInterface   Implements AdapterInterface, EventsAwareInterface

Clase base para adaptadores Phalcon\Db\Adapter

Propiedades

/**
 * Connection ID
 *
 * @var int
 */
protected static connectionConsecutive = 0;

/**
 * Active connection ID
 *
 * @var int
 */
protected connectionId;

/**
 * Descriptor used to connect to a database
 *
 * @var array
 */
protected descriptor;

/**
 * Dialect instance
 *
 * @var object
 */
protected dialect;

/**
 * Name of the dialect used
 *
 * @var string
 */
protected dialectType;

/**
 * Event Manager
 *
 * @var ManagerInterface|null
 */
protected eventsManager;

/**
 * The real SQL statement - what was executed
 *
 * @var string
 */
protected realSqlStatement;

/**
 * Active SQL Bind Types
 *
 * @var array
 */
protected sqlBindTypes;

/**
 * Active SQL Statement
 *
 * @var string
 */
protected sqlStatement;

/**
 * Active SQL bound parameter variables
 *
 * @var array
 */
protected sqlVariables;

/**
 * Current transaction level
 *
 * @var int
 */
protected transactionLevel = 0;

/**
 * Whether the database supports transactions with save points
 *
 * @var bool
 */
protected transactionsWithSavepoints = false;

/**
 * Type of database system the adapter is used for
 *
 * @var string
 */
protected type;

Métodos

public function __construct( array $descriptor );

Constructor Phalcon\Db\Adapter

public function addColumn( string $tableName, string $schemaName, ColumnInterface $column ): bool;

Añade una columna a una tabla

public function addForeignKey( string $tableName, string $schemaName, ReferenceInterface $reference ): bool;

Añade una clave ajena a una tabla

public function addIndex( string $tableName, string $schemaName, IndexInterface $index ): bool;

Añade un índice a una tabla

public function addPrimaryKey( string $tableName, string $schemaName, IndexInterface $index ): bool;

Añade una clave primaria a una tabla

public function createSavepoint( string $name ): bool;

Crea un nuevo punto de guardado

public function createTable( string $tableName, string $schemaName, array $definition ): bool;

Crea una tabla

public function createView( string $viewName, array $definition, string $schemaName = null ): bool;

Crea una vista

public function delete( mixed $table, string $whereCondition = null, array $placeholders = [], array $dataTypes = [] ): bool;

Borra datos de una tabla usando sintaxis SQL del RBDM personalizada

// Deleting existing robot
$success = $connection->delete(
    "robots",
    "id = 101"
);

// Next SQL sentence is generated
DELETE FROM `robots` WHERE `id` = 101

public function describeIndexes( string $table, string $schema = null ): IndexInterface[];

Lista los índices de la tabla

print_r(
    $connection->describeIndexes("robots_parts")
);

public function describeReferences( string $table, string $schema = null ): ReferenceInterface[];

Lista las referencias de la tabla

print_r(
    $connection->describeReferences("robots_parts")
);

public function dropColumn( string $tableName, string $schemaName, string $columnName ): bool;

Elimina una columna de una tabla

public function dropForeignKey( string $tableName, string $schemaName, string $referenceName ): bool;

Elimina una clave ajena de una tabla

public function dropIndex( string $tableName, string $schemaName, mixed $indexName ): bool;

Elimina un índice de una tabla

public function dropPrimaryKey( string $tableName, string $schemaName ): bool;

Elimina una clave primaria de una tabla

public function dropTable( string $tableName, string $schemaName = null, bool $ifExists = bool ): bool;

Elimina una tabla de un esquema/base de datos

public function dropView( string $viewName, string $schemaName = null, bool $ifExists = bool ): bool;

Elimina una vista

public function escapeIdentifier( mixed $identifier ): string;

Escapa un nombre de columna/tabla/esquema

$escapedTable = $connection->escapeIdentifier(
    "robots"
);

$escapedTable = $connection->escapeIdentifier(
    [
        "store",
        "robots",
    ]
);

public function fetchAll( string $sqlQuery, int $fetchMode = static-constant-access, array $bindParams = [], array $bindTypes = [] ): array;

Vuelca el resultado completo de una consulta en un vector

// Getting all robots with associative indexes only
$robots = $connection->fetchAll(
    "SELECTFROM robots",
    \Phalcon\Db\Enum::FETCH_ASSOC
);

foreach ($robots as $robot) {
    print_r($robot);
}

 // Getting all robots that contains word "robot" withing the name
$robots = $connection->fetchAll(
    "SELECTFROM robots WHERE name LIKE :name",
    \Phalcon\Db\Enum::FETCH_ASSOC,
    [
        "name" => "%robot%",
    ]
);
foreach($robots as $robot) {
    print_r($robot);
}

public function fetchColumn( string $sqlQuery, array $placeholders = [], mixed $column = int ): string | bool;

Devuelve el n-ésimo campo de la primera fila en un resultado de consulta SQL

// Getting count of robots
$robotsCount = $connection->fetchColumn("SELECT count(*) FROM robots");
print_r($robotsCount);

// Getting name of last edited robot
$robot = $connection->fetchColumn(
    "SELECT id, name FROM robots ORDER BY modified DESC",
    1
);
print_r($robot);

public function fetchOne( string $sqlQuery, mixed $fetchMode = static-constant-access, array $bindParams = [], array $bindTypes = [] ): array;

Devuelve la primera fila en un resultado de consulta SQL

// Getting first robot
$robot = $connection->fetchOne("SELECTFROM robots");
print_r($robot);

// Getting first robot with associative indexes only
$robot = $connection->fetchOne(
    "SELECTFROM robots",
    \Phalcon\Db\Enum::FETCH_ASSOC
);
print_r($robot);

public function forUpdate( string $sqlQuery ): string;

Devuelve un SQL modificado con una cláusula FOR UPDATE

public function getColumnDefinition( ColumnInterface $column ): string;

Devuelve la definición de columna SQL para una columna

public function getColumnList( mixed $columnList ): string;

Obtiene una lista de columnas

public function getConnectionId(): string;

Obtiene el identificador único de conexión activo

public function getDefaultIdValue(): RawValue;

Devuelve el valor de la identidad predeterminado a ser insertado en una columna identidad

// Inserting a new robot with a valid default value for the column 'id'
$success = $connection->insert(
    "robots",
    [
        $connection->getDefaultIdValue(),
        "Astro Boy",
        1952,
    ],
    [
        "id",
        "name",
        "year",
    ]
);

public function getDefaultValue(): RawValue;

Devuelve el valor por defecto para hacer que el RBDM use el valor predeterminado declarado en la definición de la tabla

// Inserting a new robot with a valid default value for the column 'year'
$success = $connection->insert(
    "robots",
    [
        "Astro Boy",
        $connection->getDefaultValue()
    ],
    [
        "name",
        "year",
    ]
);

@todo Devuelve NULL si no se soporta por el adaptador

public function getDescriptor(): array;

Devuelve el descriptor usado para conectar a la base de datos activa

public function getDialect(): DialectInterface;

Devuelve la instancia interna del dialecto

public function getDialectType(): string;

Name of the dialect used

public function getEventsManager(): ManagerInterface | null;

Devuelve el administrador de eventos interno

public function getNestedTransactionSavepointName(): string;

Devuelve el nombre del punto de guardado a usar en transacciones anidadas

public function getRealSQLStatement(): string;

Sentencia SQL activa en el objeto sin reemplazar parámetros enlazados

public function getSQLBindTypes(): array;

Sentencia SQL activa en el objeto

public function getSQLStatement(): string;

Sentencia SQL activa en el objeto

public function getSQLVariables(): array;

Active SQL variables in the object

public function getType(): string;

Type of database system the adapter is used for

public function insert( string $table, array $values, mixed $fields = null, mixed $dataTypes = null ): bool;

Inserta datos en una tabla usando sintaxis SQL personalizada del RDBMS

// Inserting a new robot
$success = $connection->insert(
    "robots",
    ["Astro Boy", 1952],
    ["name", "year"]
);

// Next SQL sentence is sent to the database system
INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952);

public function insertAsDict( string $table, mixed $data, mixed $dataTypes = null ): bool;

Inserta datos en una tabla usando sintaxis SQL personalizada del RBDM

// Inserting a new robot
$success = $connection->insertAsDict(
    "robots",
    [
        "name" => "Astro Boy",
        "year" => 1952,
    ]
);

// Next SQL sentence is sent to the database system
INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952);

public function isNestedTransactionsWithSavepoints(): bool;

Devuelve si las transacciones anidadas deberían usar puntos de guardado

public function limit( string $sqlQuery, int $number ): string;

Añade una cláusula LIMIT al argumento $sqlQuery

echo $connection->limit("SELECTFROM robots", 5);

public function listTables( string $schemaName = null ): array;

Lista todas las tablas de una base de datos

print_r(
    $connection->listTables("blog")
);

public function listViews( string $schemaName = null ): array;

Lista todas las vistas de una base de datos

print_r(
    $connection->listViews("blog")
);

public function modifyColumn( string $tableName, string $schemaName, ColumnInterface $column, ColumnInterface $currentColumn = null ): bool;

Modifica una columna de base de datos basada en una definición

public function releaseSavepoint( string $name ): bool;

Lanza el punto de guardado dado

public function rollbackSavepoint( string $name ): bool;

Deshace el punto de guardado dado

public function setDialect( DialectInterface $dialect );

Establece el dialecto usado para producir el SQL

public function setEventsManager( ManagerInterface $eventsManager ): void;

Establece el gestor de eventos

public function setNestedTransactionsWithSavepoints( bool $nestedTransactionsWithSavepoints ): AdapterInterface;

Establece si las transacciones anidadas deberían usar puntos de guardado

public function sharedLock( string $sqlQuery ): string;

Devuelve un SQL modificado con la cláusula LOCK IN SHARE MODE

public function supportSequences(): bool;

Comprueba si el sistema de base de datos necesita una secuencia para producir valores autonuméricos

public function supportsDefaultValue(): bool;

Comprueba si el sistema de base de datos soporta la palabra clave DEFAULT (SQLite no la soporta)

@deprecated Será eliminado en la siguiente versión

public function tableExists( string $tableName, string $schemaName = null ): bool;

Genera SQL que comprueba la existencia de esquema.tabla

var_dump(
    $connection->tableExists("blog", "posts")
);

public function tableOptions( string $tableName, string $schemaName = null ): array;

Obtiene las opciones de creación de una tabla

print_r(
    $connection->tableOptions("robots")
);

public function update( string $table, mixed $fields, mixed $values, mixed $whereCondition = null, mixed $dataTypes = null ): bool;

Actualiza datos en una tabla usando sintaxis SQL RBDM personalizada

// Updating existing robot
$success = $connection->update(
    "robots",
    ["name"],
    ["New Astro Boy"],
    "id = 101"
);

// Next SQL sentence is sent to the database system
UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101

// Updating existing robot with array condition and $dataTypes
$success = $connection->update(
    "robots",
    ["name"],
    ["New Astro Boy"],
    [
        "conditions" => "id = ?",
        "bind"       => [$some_unsafe_id],
        "bindTypes"  => [PDO::PARAM_INT], // use only if you use $dataTypes param
    ],
    [
        PDO::PARAM_STR
    ]
);

¡Atención! Si $whereCondition es cadena sin escapar.

public function updateAsDict( string $table, mixed $data, mixed $whereCondition = null, mixed $dataTypes = null ): bool;

Actualiza datos en una tabla usando sintaxis SQL RBDM personalizada. Otra sintaxis más conveniente

// Updating existing robot
$success = $connection->updateAsDict(
    "robots",
    [
        "name" => "New Astro Boy",
    ],
    "id = 101"
);

// Next SQL sentence is sent to the database system
UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101

public function useExplicitIdValue(): bool;

Comprueba si el sistema de base de datos necesita un valor explícito para columnas identidad

public function viewExists( string $viewName, string $schemaName = null ): bool;

Genera SQL comprobando la existencia de un esquema.vista

var_dump(
    $connection->viewExists("active_users", "posts")
);

Interface Phalcon\Db\Adapter\AdapterInterface

Código fuente en GitHub

Namespace Phalcon\Db\Adapter   Uses Phalcon\Db\DialectInterface, Phalcon\Db\ResultInterface, Phalcon\Db\ColumnInterface, Phalcon\Db\IndexInterface, Phalcon\Db\RawValue, Phalcon\Db\ReferenceInterface

Interfaz para adaptadores Phalcon\Db

Métodos

public function addColumn( string $tableName, string $schemaName, ColumnInterface $column ): bool;

Añade una columna a una tabla

public function addForeignKey( string $tableName, string $schemaName, ReferenceInterface $reference ): bool;

Añade una clave ajena a una tabla

public function addIndex( string $tableName, string $schemaName, IndexInterface $index ): bool;

Añade un índice a una tabla

public function addPrimaryKey( string $tableName, string $schemaName, IndexInterface $index ): bool;

Añade una clave primaria a una tabla

public function affectedRows(): int;

Devuelve el número de filas afectadas por el último INSERT/UPDATE/DELETE informado por el sistema de base de datos

public function begin( bool $nesting = bool ): bool;

Inicia una transacción en la conexión

public function close(): void;

Cierra la conexión activa devolviendo éxito. Phalcon automáticamente cierra y destruye las conexiones activas dentro de Phalcon\Db\Pool

public function commit( bool $nesting = bool ): bool;

Confirma la transacción activa en la conexión

public function connect( array $descriptor = [] ): void;

Este método se llama automáticamente en el constructor \Phalcon\Db\Adapter\Pdo. Llámelo cuando necesite restaurar una conexión de base de datos

public function createSavepoint( string $name ): bool;

Crea un nuevo punto de guardado

public function createTable( string $tableName, string $schemaName, array $definition ): bool;

Crea una tabla

public function createView( string $viewName, array $definition, string $schemaName = null ): bool;

Crea una vista

public function delete( mixed $table, string $whereCondition = null, array $placeholders = [], array $dataTypes = [] ): bool;

Borra datos de una tabla usando sintaxis SQL del RBDMS personalizada

public function describeColumns( string $table, string $schema = null ): ColumnInterface[];

Devuelve un vector de objetos Phalcon\Db\Column que describen una tabla

public function describeIndexes( string $table, string $schema = null ): IndexInterface[];

Lista los índices de la tabla

public function describeReferences( string $table, string $schema = null ): ReferenceInterface[];

Lista las referencias de la tabla

public function dropColumn( string $tableName, string $schemaName, string $columnName ): bool;

Elimina una columna de una tabla

public function dropForeignKey( string $tableName, string $schemaName, string $referenceName ): bool;

Elimina una clave ajena de una tabla

public function dropIndex( string $tableName, string $schemaName, string $indexName ): bool;

Elimina un índice de una tabla

public function dropPrimaryKey( string $tableName, string $schemaName ): bool;

Elimina una clave primaria de una tabla

public function dropTable( string $tableName, string $schemaName = null, bool $ifExists = bool ): bool;

Elimina una tabla de un esquema/base de datos

public function dropView( string $viewName, string $schemaName = null, bool $ifExists = bool ): bool;

Elimina una vista

public function escapeIdentifier( mixed $identifier ): string;

Escapa un nombre de columna/tabla/esquema

public function escapeString( string $str ): string;

Escapa un valor para evitar inyecciones SQL

public function execute( string $sqlStatement, array $bindParams = [], array $bindTypes = [] ): bool;

Envía sentencias SQL al servidor de base de datos devolviendo el estado de éxito. Use este método sólo cuando las sentencias SQL enviadas al servidor no devuelvan ninguna fila

public function fetchAll( string $sqlQuery, int $fetchMode = int, array $bindParams = [], array $bindTypes = [] ): array;

Vuelca el resultado completo de una consulta en un vector

public function fetchColumn( string $sqlQuery, array $placeholders = [], mixed $column = int ): string | bool;

Devuelve el n-ésimo campo de la primera fila en un resultado de consulta SQL

// Getting count of robots
$robotsCount = $connection->fetchColumn("SELECT COUNT(*) FROM robots");
print_r($robotsCount);

// Getting name of last edited robot
$robot = $connection->fetchColumn(
    "SELECT id, name FROM robots ORDER BY modified DESC",
    1
);
print_r($robot);

public function fetchOne( string $sqlQuery, int $fetchMode = int, array $bindParams = [], array $bindTypes = [] ): array;

Devuelve la primera fila en un resultado de consulta SQL

public function forUpdate( string $sqlQuery ): string;

Devuelve un SQL modificado con una cláusula FOR UPDATE

public function getColumnDefinition( ColumnInterface $column ): string;

Devuelve la definición de columna SQL para una columna

public function getColumnList( mixed $columnList ): string;

Obtiene una lista de columnas

public function getConnectionId(): string;

Obtiene el identificador único de conexión activo

public function getDefaultIdValue(): RawValue;

Devuelve el valor de la identidad predeterminado para insertar en una columna de identidad

public function getDefaultValue(): RawValue;

Devuelve el valor por defecto para hacer que el RBDM use el valor predeterminado declarado en la definición de la tabla

// Inserting a new robot with a valid default value for the column 'year'
$success = $connection->insert(
    "robots",
    [
        "Astro Boy",
        $connection->getDefaultValue()
    ],
    [
        "name",
        "year",
    ]
);

@todo Devuelve NULL si no se soporta por el adaptador

public function getDescriptor(): array;

Devuelve el descriptor usado para conectar a la base de datos activa

public function getDialect(): DialectInterface;

Devuelve la instancia interna del dialecto

public function getDialectType(): string;

Devuelve el nombre del dialecto usado

public function getInternalHandler(): mixed;

Devuelve el manejador PDO interno

public function getNestedTransactionSavepointName(): string;

Devuelve el nombre del punto de guardado a usar en transacciones anidadas

public function getRealSQLStatement(): string;

Sentencia SQL activa en el objeto sin reemplazar parámetros enlazados

public function getSQLBindTypes(): array;

Sentencia SQL activa en el objeto

public function getSQLStatement(): string;

Sentencia SQL activa en el objeto

public function getSQLVariables(): array;

Sentencia SQL activa en el objeto

public function getType(): string;

Devuelve el tipo de sistema de base de datos para el que se usa el adaptador

public function insert( string $table, array $values, mixed $fields = null, mixed $dataTypes = null ): bool;

Inserta datos en una tabla usando sintaxis SQL personalizada del RDBMS

public function insertAsDict( string $table, mixed $data, mixed $dataTypes = null ): bool;

Inserta datos en una tabla usando sintaxis SQL personalizada del RBDM

// Inserting a new robot
$success = $connection->insertAsDict(
    "robots",
    [
        "name" => "Astro Boy",
        "year" => 1952,
    ]
);

// Next SQL sentence is sent to the database system
INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952);

public function isNestedTransactionsWithSavepoints(): bool;

Devuelve si las transacciones anidadas deberían usar puntos de guardado

public function isUnderTransaction(): bool;

Comprueba si la conexión está bajo una transacción de base de datos

public function lastInsertId( string $name = null ): string | bool;

Devuelve el id de inserción para una columna auto_increment insertada en la última sentencia SQL

public function limit( string $sqlQuery, int $number ): string;

Añade una cláusula LIMIT al argumento sqlQuery

public function listTables( string $schemaName = null ): array;

Lista todas las tablas de una base de datos

public function listViews( string $schemaName = null ): array;

Lista todas las vistas de una base de datos

public function modifyColumn( string $tableName, string $schemaName, ColumnInterface $column, ColumnInterface $currentColumn = null ): bool;

Modifica una columna de base de datos basada en una definición

public function query( string $sqlStatement, array $bindParams = [], array $bindTypes = [] ): ResultInterface | bool;

Envía sentencias SQL al servidor de base de datos devolviendo el estado de éxito. Use este método sólo cuando las sentencias SQL enviadas al servidor devuelvan filas

public function releaseSavepoint( string $name ): bool;

Lanza el punto de guardado dado

public function rollback( bool $nesting = bool ): bool;

Deshace la transacción activa en la conexión

public function rollbackSavepoint( string $name ): bool;

Deshace el punto de guardado dado

public function setNestedTransactionsWithSavepoints( bool $nestedTransactionsWithSavepoints ): AdapterInterface;

Establece si las transacciones anidadas deberían usar puntos de guardado

public function sharedLock( string $sqlQuery ): string;

Devuelve un SQL modificado con la cláusula LOCK IN SHARE MODE

public function supportSequences(): bool;

Comprueba si el sistema de base de datos necesita una secuencia para producir valores autonuméricos

public function supportsDefaultValue(): bool;

SQLite no soporta la palabra clave DEFAULT

@deprecated Será eliminado en la siguiente versión

public function tableExists( string $tableName, string $schemaName = null ): bool;

Genera SQL que comprueba la existencia de esquema.tabla

public function tableOptions( string $tableName, string $schemaName = null ): array;

Obtiene las opciones de creación de una tabla

public function update( string $table, mixed $fields, mixed $values, mixed $whereCondition = null, mixed $dataTypes = null ): bool;

Actualiza datos en una tabla usando sintaxis SQL personalizada del RDBMS

public function updateAsDict( string $table, mixed $data, mixed $whereCondition = null, mixed $dataTypes = null ): bool;

Actualiza datos en una tabla usando sintaxis SQL RBDM personalizada. Otra sintaxis más conveniente

// Updating existing robot
$success = $connection->updateAsDict(
    "robots",
    [
        "name" => "New Astro Boy",
    ],
    "id = 101"
);

// Next SQL sentence is sent to the database system
UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101

public function useExplicitIdValue(): bool;

Comprueba si el sistema de base de datos necesita un valor explícito para columnas identidad

public function viewExists( string $viewName, string $schemaName = null ): bool;

Genera SQL comprobando la existencia de un esquema.vista

Abstract Class Phalcon\Db\Adapter\Pdo\AbstractPdo

Código fuente en GitHub

Namespace Phalcon\Db\Adapter\Pdo   Uses Phalcon\Db\Adapter\AbstractAdapter, Phalcon\Db\Column, Phalcon\Db\Exception, Phalcon\Db\Result\PdoResult, Phalcon\Db\ResultInterface, Phalcon\Events\ManagerInterface   Extends AbstractAdapter

Phalcon\Db\Adapter\Pdo es el Phalcon\Db que internamente usa PDO para conectar a la base de datos

use Phalcon\Db\Adapter\Pdo\Mysql;

$config = [
    "host"     => "localhost",
    "dbname"   => "blog",
    "port"     => 3306,
    "username" => "sigma",
    "password" => "secret",
];

$connection = new Mysql($config);

Propiedades

/**
 * Last affected rows
 *
 * @var int
 */
protected affectedRows = 0;

/**
 * PDO Handler
 *
 * @var \PDO
 */
protected pdo;

Métodos

public function __construct( array $descriptor );

Constructor de Phalcon\Db\Adapter\Pdo

public function affectedRows(): int;

Devuelve el número de filas afectadas por el último INSERT/UPDATE/DELETE ejecutado en el sistema de base de datos

$connection->execute(
    "DELETE FROM robots"
);

echo $connection->affectedRows(), " were deleted";

public function begin( bool $nesting = bool ): bool;

Inicia una transacción en la conexión

public function close(): void;

Cierra la conexión activa devolviendo éxito. Phalcon automáticamente cierra y destruye las conexiones activas cuando la petición termina

public function commit( bool $nesting = bool ): bool;

Confirma la transacción activa en la conexión

public function connect( array $descriptor = [] ): void;

Este método se llama automáticamente en el constructor \Phalcon\Db\Adapter\Pdo.

Llámelo cuando necesite restaurar una conexión de base de datos.

use Phalcon\Db\Adapter\Pdo\Mysql;

// Make a connection
$connection = new Mysql(
    [
        "host"     => "localhost",
        "username" => "sigma",
        "password" => "secret",
        "dbname"   => "blog",
        "port"     => 3306,
    ]
);

// Reconnect
$connection->connect();

public function convertBoundParams( string $sql, array $params = [] ): array;

Convierte parámetros enlazados como :name: o ?1 en parámetros enlace PDO ?

print_r(
    $connection->convertBoundParams(
        "SELECTFROM robots WHERE name = :name:",
        [
            "Bender",
        ]
    )
);

public function escapeString( string $str ): string;

Escapa un valor para evitar inyecciones SQL de acuerdo al conjunto de caracteres activo en la conexión

$escapedStr = $connection->escapeString("some dangerous value");

public function execute( string $sqlStatement, array $bindParams = [], array $bindTypes = [] ): bool;

Envía sentencias SQL al servidor de base de datos devolviendo el estado de éxito. Use este método sólo cuando las sentencias SQL enviadas al servidor no devuelvan ninguna fila

// Inserting data
$success = $connection->execute(
    "INSERT INTO robots VALUES (1, 'Astro Boy')"
);

$success = $connection->execute(
    "INSERT INTO robots VALUES (?, ?)",
    [
        1,
        "Astro Boy",
    ]
);

public function executePrepared( \PDOStatement $statement, array $placeholders, mixed $dataTypes ): \PDOStatement;

Ejecuta un enlazado de sentencia preparada. Esta función usa índices enteros empezando por cero

use Phalcon\Db\Column;

$statement = $db->prepare(
    "SELECTFROM robots WHERE name = :name"
);

$result = $connection->executePrepared(
    $statement,
    [
        "name" => "Voltron",
    ],
    [
        "name" => Column::BIND_PARAM_STR,
    ]
);

public function getErrorInfo(): array;

Devuelve la información del error, si lo hay

public function getInternalHandler(): mixed;

Devuelve el manejador PDO interno

public function getTransactionLevel(): int;

Devuelve el nivel de anidación de transacción actual

public function isUnderTransaction(): bool;

Comprueba si la conexión está bajo una transacción

$connection->begin();

// true
var_dump(
    $connection->isUnderTransaction()
);

public function lastInsertId( string $name = null ): string | bool;

Devuelve el ID de la inserción para una columna auto_increment/serial insertada en la última sentencia SQL ejecutada

// Inserting a new robot
$success = $connection->insert(
    "robots",
    [
        "Astro Boy",
        1952,
    ],
    [
        "name",
        "year",
    ]
);

// Getting the generated id
$id = $connection->lastInsertId();

public function prepare( string $sqlStatement ): \PDOStatement;

Devuelve la sentencia preparada PDO que se ejecutará con ‘executePrepared’

use Phalcon\Db\Column;

$statement = $db->prepare(
    "SELECTFROM robots WHERE name = :name"
);

$result = $connection->executePrepared(
    $statement,
    [
        "name" => "Voltron",
    ],
    [
        "name" => Column::BIND_PARAM_INT,
    ]
);

public function query( string $sqlStatement, array $bindParams = [], array $bindTypes = [] ): ResultInterface | bool;

Envía sentencias SQL al servidor de base de datos devolviendo el estado de éxito. Use este método sólo cuando la sentencia SQL enviada al servidor devuelve filas

// Querying data
$resultset = $connection->query(
    "SELECTFROM robots WHERE type = 'mechanical'"
);

$resultset = $connection->query(
    "SELECTFROM robots WHERE type = ?",
    [
        "mechanical",
    ]
);

public function rollback( bool $nesting = bool ): bool;

Deshace la transacción activa en la conexión

abstract protected function getDsnDefaults(): array;

Devuelve el DSN predeterminado del adaptador PDO como mapa clave-valor.

protected function prepareRealSql( string $statement, array $parameters ): void;

Construye la sentencia SQL (con parámetros)

@see https://stackoverflow.com/a/8403150

Class Phalcon\Db\Adapter\Pdo\Mysql

Código fuente en GitHub

Namespace Phalcon\Db\Adapter\Pdo   Uses Phalcon\Db\Adapter\Pdo\AbstractPdo, Phalcon\Db\Column, Phalcon\Db\ColumnInterface, Phalcon\Db\Enum, Phalcon\Db\Exception, Phalcon\Db\Index, Phalcon\Db\IndexInterface, Phalcon\Db\Reference, Phalcon\Db\ReferenceInterface   Extends PdoAdapter

Funciones específicas para el sistema de base de datos MySQL

use Phalcon\Db\Adapter\Pdo\Mysql;

$config = [
    "host"     => "localhost",
    "dbname"   => "blog",
    "port"     => 3306,
    "username" => "sigma",
    "password" => "secret",
];

$connection = new Mysql($config);

Propiedades

/**
 * @var string
 */
protected dialectType = mysql;

/**
 * @var string
 */
protected type = mysql;

Métodos

public function __construct( array $descriptor );

Constructor de Phalcon\Db\Adapter\Pdo

public function addForeignKey( string $tableName, string $schemaName, ReferenceInterface $reference ): bool;

Añade una clave ajena a una tabla

public function describeColumns( string $table, string $schema = null ): ColumnInterface[];

Devuelve un vector de objetos Phalcon\Db\Column que describen una tabla

print_r(
    $connection->describeColumns("posts")
);

public function describeIndexes( string $table, string $schema = null ): IndexInterface[];

Lista los índices de la tabla

print_r(
    $connection->describeIndexes("robots_parts")
);

public function describeReferences( string $table, string $schema = null ): ReferenceInterface[];

Lista las referencias de la tabla

print_r(
    $connection->describeReferences("robots_parts")
);

protected function getDsnDefaults(): array;

Devuelve el DSN predeterminado del adaptador PDO como mapa clave-valor.

Class Phalcon\Db\Adapter\Pdo\Postgresql

Código fuente en GitHub

Namespace Phalcon\Db\Adapter\Pdo   Uses Phalcon\Db\Adapter\Pdo\AbstractPdo, Phalcon\Db\Column, Phalcon\Db\ColumnInterface, Phalcon\Db\Enum, Phalcon\Db\Exception, Phalcon\Db\RawValue, Phalcon\Db\Reference, Phalcon\Db\ReferenceInterface, Throwable   Extends PdoAdapter

Funciones específicas para el sistema de base de datos PostgreSQL

use Phalcon\Db\Adapter\Pdo\Postgresql;

$config = [
    "host"     => "localhost",
    "dbname"   => "blog",
    "port"     => 5432,
    "username" => "postgres",
    "password" => "secret",
];

$connection = new Postgresql($config);

Propiedades

/**
 * @var string
 */
protected dialectType = postgresql;

/**
 * @var string
 */
protected type = pgsql;

Métodos

public function __construct( array $descriptor );

Constructor para Phalcon\Db\Adapter\Pdo\Postgresql

public function connect( array $descriptor = [] ): void;

A este método se llama automáticamente en el constructor Phalcon\Db\Adapter\Pdo. Llámelo cuando necesite restaurar una conexión de base de datos.

public function createTable( string $tableName, string $schemaName, array $definition ): bool;

Crea una tabla

public function describeColumns( string $table, string $schema = null ): ColumnInterface[];

Devuelve un vector de objetos Phalcon\Db\Column que describen una tabla

print_r(
    $connection->describeColumns("posts")
);

public function describeReferences( string $table, string $schema = null ): ReferenceInterface[];

Lista las referencias de la tabla

print_r(
    $connection->describeReferences("robots_parts")
);

public function getDefaultIdValue(): RawValue;

Devuelve el valor de la identidad predeterminado a ser insertado en una columna identidad

// Inserting a new robot with a valid default value for the column 'id'
$success = $connection->insert(
    "robots",
    [
        $connection->getDefaultIdValue(),
        "Astro Boy",
        1952,
    ],
    [
        "id",
        "name",
        "year",
    ]
);

public function modifyColumn( string $tableName, string $schemaName, ColumnInterface $column, ColumnInterface $currentColumn = null ): bool;

Modifica una columna de base de datos basada en una definición

public function supportSequences(): bool;

Comprueba si el sistema de base de datos necesita una secuencia para producir valores autonuméricos

public function useExplicitIdValue(): bool;

Comprueba si el sistema de base de datos necesita un valor explícito para columnas identidad

protected function getDsnDefaults(): array;

Devuelve el DSN predeterminado del adaptador PDO como mapa clave-valor.

Class Phalcon\Db\Adapter\Pdo\Sqlite

Código fuente en GitHub

Namespace Phalcon\Db\Adapter\Pdo   Uses Phalcon\Db\Adapter\Pdo\AbstractPdo, Phalcon\Db\Column, Phalcon\Db\ColumnInterface, Phalcon\Db\Enum, Phalcon\Db\Exception, Phalcon\Db\Index, Phalcon\Db\IndexInterface, Phalcon\Db\RawValue, Phalcon\Db\Reference, Phalcon\Db\ReferenceInterface   Extends PdoAdapter

Funciones específicas para el sistema de base de datos SQLite

use Phalcon\Db\Adapter\Pdo\Sqlite;

$connection = new Sqlite(
    [
        "dbname" => "/tmp/test.sqlite",
    ]
);

Propiedades

/**
 * @var string
 */
protected dialectType = sqlite;

/**
 * @var string
 */
protected type = sqlite;

Métodos

public function __construct( array $descriptor );

Constructor para Phalcon\Db\Adapter\Pdo\Sqlite

public function connect( array $descriptor = [] ): void;

A este método se llama automáticamente en el constructor Phalcon\Db\Adapter\Pdo. Llámelo cuando necesite restaurar una conexión de base de datos.

public function describeColumns( string $table, string $schema = null ): ColumnInterface[];

Devuelve un vector de objetos Phalcon\Db\Column que describen una tabla

print_r(
    $connection->describeColumns("posts")
);

public function describeIndexes( string $table, string $schema = null ): IndexInterface[];

Lista los índices de la tabla

print_r(
    $connection->describeIndexes("robots_parts")
);

public function describeReferences( string $table, string $schema = null ): ReferenceInterface[];

Lista las referencias de la tabla

public function getDefaultValue(): RawValue;

Devuelve el valor por defecto para hacer que el RBDM use el valor predeterminado declarado en la definición de la tabla

// Inserting a new robot with a valid default value for the column 'year'
$success = $connection->insert(
    "robots",
    [
        "Astro Boy",
        $connection->getDefaultValue(),
    ],
    [
        "name",
        "year",
    ]
);

public function supportsDefaultValue(): bool;

SQLite no soporta la palabra clave DEFAULT

@deprecated Será eliminado en la siguiente versión

public function useExplicitIdValue(): bool;

Comprueba si el sistema de base de datos necesita un valor explícito para columnas identidad

protected function getDsnDefaults(): array;

Devuelve el DSN predeterminado del adaptador PDO como mapa clave-valor.

Class Phalcon\Db\Adapter\PdoFactory

Código fuente en GitHub

Namespace Phalcon\Db\Adapter   Uses Phalcon\Factory\AbstractFactory, Phalcon\Support\Helper\Arr\Get   Extends AbstractFactory

Este fichero es parte del Framework Phalcon.

(c) Phalcon Team [email protected]

Para obtener toda la información sobre derechos de autor y licencias, por favor vea el archivo LICENSE.txt que se distribuyó con este código fuente.

Métodos

public function __construct( array $services = [] );

Constructor

public function load( mixed $config ): AdapterInterface;

Factoría para crear una instancia desde un objeto Config

public function newInstance( string $name, array $options = [] ): AdapterInterface;

Crea una nueva instancia del adaptador

protected function getExceptionClass(): string;

protected function getServices(): array;

Devuelve los adaptadores disponibles

Class Phalcon\Db\Column

Código fuente en GitHub

Namespace Phalcon\Db   Implements ColumnInterface

Permite definir columnas que se usarán en operaciones para crear o alterar una tabla

use Phalcon\Db\Column as Column;

// Column definition
$column = new Column(
    "id",
    [
        "type"          => Column::TYPE_INTEGER,
        "size"          => 10,
        "unsigned"      => true,
        "notNull"       => true,
        "autoIncrement" => true,
        "first"         => true,
        "comment"       => "",
    ]
);

// Add column to existing table
$connection->addColumn("robots", null, $column);

Constantes

const BIND_PARAM_BLOB = 3;
const BIND_PARAM_BOOL = 5;
const BIND_PARAM_DECIMAL = 32;
const BIND_PARAM_INT = 1;
const BIND_PARAM_NULL = 0;
const BIND_PARAM_STR = 2;
const BIND_SKIP = 1024;
const TYPE_BIGINTEGER = 14;
const TYPE_BINARY = 26;
const TYPE_BIT = 19;
const TYPE_BLOB = 11;
const TYPE_BOOLEAN = 8;
const TYPE_CHAR = 5;
const TYPE_DATE = 1;
const TYPE_DATETIME = 4;
const TYPE_DECIMAL = 3;
const TYPE_DOUBLE = 9;
const TYPE_ENUM = 18;
const TYPE_FLOAT = 7;
const TYPE_INTEGER = 0;
const TYPE_JSON = 15;
const TYPE_JSONB = 16;
const TYPE_LONGBLOB = 13;
const TYPE_LONGTEXT = 24;
const TYPE_MEDIUMBLOB = 12;
const TYPE_MEDIUMINTEGER = 21;
const TYPE_MEDIUMTEXT = 23;
const TYPE_SMALLINTEGER = 22;
const TYPE_TEXT = 6;
const TYPE_TIME = 20;
const TYPE_TIMESTAMP = 17;
const TYPE_TINYBLOB = 10;
const TYPE_TINYINTEGER = 26;
const TYPE_TINYTEXT = 25;
const TYPE_VARBINARY = 27;
const TYPE_VARCHAR = 2;

Propiedades

/**
 * Column Position
 *
 * @var string|null
 */
protected after;

/**
 * Column is autoIncrement?
 *
 * @var bool
 */
protected autoIncrement = false;

/**
 * Bind Type
 *
 * @var int
 */
protected bindType = 2;

/**
 * Column's comment
 *
 * @var string|null
 */
protected comment;

/**
 * Default column value
 *
 * @var mixed|null
 */
protected defaultValue;

/**
 * Position is first
 *
 * @var bool
 */
protected first = false;

/**
 * The column have some numeric type?
 *
 * @var bool
 */
protected isNumeric = false;

/**
 * Column's name
 *
 * @var string
 */
protected name;

/**
 * Column not nullable?
 *
 * Default SQL definition is NOT NULL.
 *
 * @var bool
 */
protected notNull = true;

/**
 * Column is part of the primary key?
 *
 * @var bool
 */
protected primary = false;

/**
 * Integer column number scale
 *
 * @var int
 */
protected scale = 0;

/**
 * Integer column size
 *
 * @var int|string
 */
protected size = 0;

/**
 * Column data type
 *
 * @var int
 */
protected type;

/**
 * Column data type reference
 *
 * @var int
 */
protected typeReference = -1;

/**
 * Column data type values
 *
 * @var array|string
 */
protected typeValues;

/**
 * Integer column unsigned?
 *
 * @var bool
 */
protected unsigned = false;

Métodos

public function __construct( string $name, array $definition );

Constructor Phalcon\Db\Column

public function getAfterPosition(): string | null;

Comprueba si el campo es absoluto para la posición en la tabla

public function getBindType(): int;

Devuelve el tipo de manejador de enlaces

public function getComment(): string | null;

Column’s comment

public function getDefault(): mixed;

Default column value

public function getName(): string;

Column’s name

public function getScale(): int;

Integer column number scale

public function getSize(): int | string;

Integer column size

public function getType(): int;

Column data type

public function getTypeReference(): int;

Column data type reference

public function getTypeValues(): array | string;

Column data type values

public function hasDefault(): bool;

Comprueba si una columna tiene valor predeterminado

public function isAutoIncrement(): bool;

Auto-Increment

public function isFirst(): bool;

Comprueba si una columna tiene la primera posición en la tabla

public function isNotNull(): bool;

Not null

public function isNumeric(): bool;

Comprueba si una columna tiene un tipo numérico

public function isPrimary(): bool;

¿La columna es parte de la clave primaria?

public function isUnsigned(): bool;

Devuelve true si la columna numérica es sin signo

Interface Phalcon\Db\ColumnInterface

Código fuente en GitHub

Namespace Phalcon\Db

Interfaz para Phalcon\Db\Column

Métodos

public function getAfterPosition(): string | null;

Comprueba si el campo es absoluto para la posición en la tabla

public function getBindType(): int;

Devuelve el tipo de manejador de enlaces

public function getDefault(): mixed;

Devuelve el valor predeterminado de una columna

public function getName(): string;

Devuelve el nombre de la columna

public function getScale(): int;

Devuelve la escala de la columna

public function getSize(): int | string;

Devuelve el tamaño de la columna

public function getType(): int;

Devuelve el tipo de la columna

public function getTypeReference(): int;

Devuelve la referencia del tipo de columna

public function getTypeValues(): array | string;

Devuelve los valores del tipo de columna

public function hasDefault(): bool;

Comprueba si una columna tiene valor predeterminado

public function isAutoIncrement(): bool;

Auto-Increment

public function isFirst(): bool;

Comprueba si una columna tiene la primera posición en la tabla

public function isNotNull(): bool;

Not null

public function isNumeric(): bool;

Comprueba si una columna tiene un tipo numérico

public function isPrimary(): bool;

¿La columna es parte de la clave primaria?

public function isUnsigned(): bool;

Devuelve true si la columna numérica es sin signo

Abstract Class Phalcon\Db\Dialect

Código fuente en GitHub

Namespace Phalcon\Db   Implements DialectInterface

Esta es la clase base para cada dialecto de base de datos. Implementa métodos comunes para transformar código intermedio en su sintaxis relacionada RDBMS

Propiedades

/**
 * @var string
 */
protected escapeChar;

/**
 * @var array
 */
protected customFunctions;

Métodos

public function createSavepoint( string $name ): string;

Genera el SQL para crear un nuevo punto de guardado

final public function escape( string $str, string $escapeChar = null ): string;

Escapa identificadores

final public function escapeSchema( string $str, string $escapeChar = null ): string;

Escapa el Esquema

public function forUpdate( string $sqlQuery ): string;

Devuelve un SQL modificado con una cláusula FOR UPDATE

$sql = $dialect->forUpdate("SELECTFROM robots");

echo $sql; // SELECTFROM robots FOR UPDATE

final public function getColumnList( array $columnList, string $escapeChar = null, array $bindCounts = [] ): string;

Devuelve una lista de columnas con los identificadores escapados

echo $dialect->getColumnList(
    [
        "column1",
        "column",
    ]
);

public function getCustomFunctions(): array;

Devuelve las funciones registradas

final public function getSqlColumn( mixed $column, string $escapeChar = null, array $bindCounts = [] ): string;

Resuelve expresiones de Columna

public function getSqlExpression( array $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Transforma una representación intermedia de una expresión en una expresión válida para el sistema de base de datos

final public function getSqlTable( mixed $table, string $escapeChar = null ): string;

Transforma una representación intermedia de un esquema/tabla en una expresión válida del sistema de base de datos

public function limit( string $sqlQuery, mixed $number ): string;

Genera el SQL para la cláusula LIMIT

// SELECTFROM robots LIMIT 10
echo $dialect->limit(
    "SELECTFROM robots",
    10
);

// SELECTFROM robots LIMIT 10 OFFSET 50
echo $dialect->limit(
    "SELECTFROM robots",
    [10, 50]
);

public function registerCustomFunction( string $name, callable $customFunction ): Dialect;

Registra funciones SQL personalizadas

public function releaseSavepoint( string $name ): string;

Genera el SQL para lanzar un punto de guardado

public function rollbackSavepoint( string $name ): string;

Genera el SQL para deshacer un punto de guardado

public function select( array $definition ): string;

Construye una sentencia SELECT

public function supportsReleaseSavepoints(): bool;

Comprueba si la plataforma soporta el lanzamiento de puntos de guardado.

public function supportsSavepoints(): bool;

Comprueba si la plataforma soporta puntos de guardado

protected function checkColumnType( ColumnInterface $column ): string;

Comprueba el tipo de columna y si no es cadena devuelve la referencia del tipo

protected function checkColumnTypeSql( ColumnInterface $column ): string;

Comprueba el tipo de columna y devuelve la sentencia SQL actualizada

protected function getColumnSize( ColumnInterface $column ): string;

Devuelve el tamaño de la columna encerrado entre paréntesis

protected function getColumnSizeAndScale( ColumnInterface $column ): string;

Devuelve el tamaño y escala de la columna encerrados entre paréntesis

final protected function getSqlExpressionAll( array $expression, string $escapeChar = null ): string;

Resuelve

final protected function getSqlExpressionBinaryOperations( array $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Resuelve expresiones de operaciones binarias

final protected function getSqlExpressionCase( array $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Resuelve expresiones CASE

final protected function getSqlExpressionCastValue( array $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Resuelve CAST de valores

final protected function getSqlExpressionConvertValue( array $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Resuelve CONVERT de codificación de valores

final protected function getSqlExpressionFrom( mixed $expression, string $escapeChar = null ): string;

Resuelve una cláusula FROM

final protected function getSqlExpressionFunctionCall( array $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Resuelve llamadas a funciones

final protected function getSqlExpressionGroupBy( mixed $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Resuelve una cláusula GROUP BY

final protected function getSqlExpressionHaving( array $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Resuelve una cláusula HAVING

final protected function getSqlExpressionJoins( mixed $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Resuelve una cláusula JOIN

final protected function getSqlExpressionLimit( mixed $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Resuelve una cláusula LIMIT

final protected function getSqlExpressionList( array $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Resuelve Listas

final protected function getSqlExpressionObject( array $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Resuelve expresiones de objeto

final protected function getSqlExpressionOrderBy( mixed $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Resuelve una cláusula ORDER BY

final protected function getSqlExpressionQualified( array $expression, string $escapeChar = null ): string;

Resuelve expresiones cualitativas

final protected function getSqlExpressionScalar( array $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Resuelve expresiones de Columna

final protected function getSqlExpressionUnaryOperations( array $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Resuelve expresiones de operaciones unitarias

final protected function getSqlExpressionWhere( mixed $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Resuelve una cláusula WHERE

protected function prepareColumnAlias( string $qualified, string $alias = null, string $escapeChar = null ): string;

Prepara la columna para este RDBMS

protected function prepareQualified( string $column, string $domain = null, string $escapeChar = null ): string;

Prepara el calificado para este RDBMS

protected function prepareTable( string $table, string $schema = null, string $alias = null, string $escapeChar = null ): string;

Prepara tabla para este RDBMS

Class Phalcon\Db\Dialect\Mysql

Código fuente en GitHub

Namespace Phalcon\Db\Dialect   Uses Phalcon\Db\Dialect, Phalcon\Db\Column, Phalcon\Db\Exception, Phalcon\Db\IndexInterface, Phalcon\Db\ColumnInterface, Phalcon\Db\ReferenceInterface, Phalcon\Db\DialectInterface   Extends Dialect

Genera SQL específico de base de datos para el RDBMS MySQL

Propiedades

/**
 * @var string
 */
protected escapeChar = `;

Métodos

public function addColumn( string $tableName, string $schemaName, ColumnInterface $column ): string;

Genera SQL para añadir una columna a una tabla

public function addForeignKey( string $tableName, string $schemaName, ReferenceInterface $reference ): string;

Genera SQL para añadir un índice a una tabla

public function addIndex( string $tableName, string $schemaName, IndexInterface $index ): string;

Genera SQL para añadir un índice a una tabla

public function addPrimaryKey( string $tableName, string $schemaName, IndexInterface $index ): string;

Genera SQL para añadir la clave primaria a una tabla

public function createTable( string $tableName, string $schemaName, array $definition ): string;

Genera SQL para crear una tabla

public function createView( string $viewName, array $definition, string $schemaName = null ): string;

Genera SQL para crear una vista

public function describeColumns( string $table, string $schema = null ): string;

Genera SQL que describe una tabla

print_r(
    $dialect->describeColumns("posts")
);

public function describeIndexes( string $table, string $schema = null ): string;

Genera SQL para consultar índices de una tabla

public function describeReferences( string $table, string $schema = null ): string;

Genera SQL para consultar claves ajenas de una tabla

public function dropColumn( string $tableName, string $schemaName, string $columnName ): string;

Genera SQL para eliminar una columna de una tabla

public function dropForeignKey( string $tableName, string $schemaName, string $referenceName ): string;

Genera SQL para eliminar una clave ajena de una tabla

public function dropIndex( string $tableName, string $schemaName, string $indexName ): string;

Genera SQL para eliminar un índice de una tabla

public function dropPrimaryKey( string $tableName, string $schemaName ): string;

Genera SQL para eliminar la clave primaria de una tabla

public function dropTable( string $tableName, string $schemaName = null, bool $ifExists = bool ): string;

Genera SQL para eliminar una tabla

public function dropView( string $viewName, string $schemaName = null, bool $ifExists = bool ): string;

Genera SQL para eliminar una vista

public function getColumnDefinition( ColumnInterface $column ): string;

Obtiene el nombre de columna en MySQL

public function getForeignKeyChecks(): string;

Genera SQL para comprobar el parámetro de base de datos FOREIGN_KEY_CHECKS.

public function listTables( string $schemaName = null ): string;

Lista todas las tablas de la base de datos

print_r(
    $dialect->listTables("blog")
);

public function listViews( string $schemaName = null ): string;

Genera el SQL para listar todas las vistas de un esquema o usuario

public function modifyColumn( string $tableName, string $schemaName, ColumnInterface $column, ColumnInterface $currentColumn = null ): string;

Genera SQL para modificar una columna de una tabla

public function sharedLock( string $sqlQuery ): string;

Devuelve un SQL modificado con la cláusula LOCK IN SHARE MODE

$sql = $dialect->sharedLock("SELECTFROM robots");

echo $sql; // SELECTFROM robots LOCK IN SHARE MODE

public function tableExists( string $tableName, string $schemaName = null ): string;

Genera SQL que comprueba la existencia de esquema.tabla

echo $dialect->tableExists("posts", "blog");

echo $dialect->tableExists("posts");

public function tableOptions( string $table, string $schema = null ): string;

Genera el SQL que describe las opciones de creación de una tabla

public function truncateTable( string $tableName, string $schemaName ): string;

Genera SQL para truncar una tabla

public function viewExists( string $viewName, string $schemaName = null ): string;

Genera SQL comprobando la existencia de un esquema.vista

protected function getTableOptions( array $definition ): string;

Genera SQL para añadir las opciones de creación de una tabla

Class Phalcon\Db\Dialect\Postgresql

Código fuente en GitHub

Namespace Phalcon\Db\Dialect   Uses Phalcon\Db\Dialect, Phalcon\Db\Column, Phalcon\Db\Exception, Phalcon\Db\IndexInterface, Phalcon\Db\ColumnInterface, Phalcon\Db\ReferenceInterface, Phalcon\Db\DialectInterface   Extends Dialect

Genera SQL específico de la base de datos para el RDBMS PostgreSQL

Propiedades

/**
 * @var string
 */
protected escapeChar = \";

Métodos

public function addColumn( string $tableName, string $schemaName, ColumnInterface $column ): string;

Genera SQL para añadir una columna a una tabla

public function addForeignKey( string $tableName, string $schemaName, ReferenceInterface $reference ): string;

Genera SQL para añadir un índice a una tabla

public function addIndex( string $tableName, string $schemaName, IndexInterface $index ): string;

Genera SQL para añadir un índice a una tabla

public function addPrimaryKey( string $tableName, string $schemaName, IndexInterface $index ): string;

Genera SQL para añadir la clave primaria a una tabla

public function createTable( string $tableName, string $schemaName, array $definition ): string;

Genera SQL para crear una tabla

public function createView( string $viewName, array $definition, string $schemaName = null ): string;

Genera SQL para crear una vista

public function describeColumns( string $table, string $schema = null ): string;

Genera SQL que describe una tabla

print_r(
    $dialect->describeColumns("posts")
);

public function describeIndexes( string $table, string $schema = null ): string;

Genera SQL para consultar índices de una tabla

public function describeReferences( string $table, string $schema = null ): string;

Genera SQL para consultar claves ajenas de una tabla

public function dropColumn( string $tableName, string $schemaName, string $columnName ): string;

Genera SQL para eliminar una columna de una tabla

public function dropForeignKey( string $tableName, string $schemaName, string $referenceName ): string;

Genera SQL para eliminar una clave ajena de una tabla

public function dropIndex( string $tableName, string $schemaName, string $indexName ): string;

Genera SQL para eliminar un índice de una tabla

public function dropPrimaryKey( string $tableName, string $schemaName ): string;

Genera SQL para eliminar la clave primaria de una tabla

public function dropTable( string $tableName, string $schemaName = null, bool $ifExists = bool ): string;

Genera SQL para eliminar una tabla

public function dropView( string $viewName, string $schemaName = null, bool $ifExists = bool ): string;

Genera SQL para eliminar una vista

public function getColumnDefinition( ColumnInterface $column ): string;

Obtiene el nombre de columna en PostgreSQL

public function listTables( string $schemaName = null ): string;

Lista todas las tablas de la base de datos

print_r(
    $dialect->listTables("blog")
);

public function listViews( string $schemaName = null ): string;

Genera el SQL para listar todas las vistas de un esquema o usuario

public function modifyColumn( string $tableName, string $schemaName, ColumnInterface $column, ColumnInterface $currentColumn = null ): string;

Genera SQL para modificar una columna de una tabla

public function sharedLock( string $sqlQuery ): string;

Devuelve un SQL modificado con una sentencia de bloque compartido. Por ahora este método devuelve la consulta original

public function tableExists( string $tableName, string $schemaName = null ): string;

Genera SQL que comprueba la existencia de esquema.tabla

echo $dialect->tableExists("posts", "blog");

echo $dialect->tableExists("posts");

public function tableOptions( string $table, string $schema = null ): string;

Genera el SQL que describe las opciones de creación de una tabla

public function truncateTable( string $tableName, string $schemaName ): string;

Genera SQL para truncar una tabla

public function viewExists( string $viewName, string $schemaName = null ): string;

Genera SQL comprobando la existencia de un esquema.vista

protected function castDefault( ColumnInterface $column ): string;

protected function getTableOptions( array $definition ): string;

Class Phalcon\Db\Dialect\Sqlite

Código fuente en GitHub

Namespace Phalcon\Db\Dialect   Uses Phalcon\Db\Column, Phalcon\Db\Exception, Phalcon\Db\IndexInterface, Phalcon\Db\Dialect, Phalcon\Db\DialectInterface, Phalcon\Db\ColumnInterface, Phalcon\Db\ReferenceInterface   Extends Dialect

Genera SQL específico de la base de datos para el RDBMS SQLite

Propiedades

/**
 * @var string
 */
protected escapeChar = \";

Métodos

public function addColumn( string $tableName, string $schemaName, ColumnInterface $column ): string;

Genera SQL para añadir una columna a una tabla

public function addForeignKey( string $tableName, string $schemaName, ReferenceInterface $reference ): string;

Genera SQL para añadir un índice a una tabla

public function addIndex( string $tableName, string $schemaName, IndexInterface $index ): string;

Genera SQL para añadir un índice a una tabla

public function addPrimaryKey( string $tableName, string $schemaName, IndexInterface $index ): string;

Genera SQL para añadir la clave primaria a una tabla

public function createTable( string $tableName, string $schemaName, array $definition ): string;

Genera SQL para crear una tabla

public function createView( string $viewName, array $definition, string $schemaName = null ): string;

Genera SQL para crear una vista

public function describeColumns( string $table, string $schema = null ): string;

Genera SQL que describe una tabla

print_r(
    $dialect->describeColumns("posts")
);

public function describeIndex( string $index ): string;

Genera SQL para consultar el detalle de los índices en una tabla

public function describeIndexes( string $table, string $schema = null ): string;

Genera SQL para consultar índices de una tabla

public function describeReferences( string $table, string $schema = null ): string;

Genera SQL para consultar claves ajenas de una tabla

public function dropColumn( string $tableName, string $schemaName, string $columnName ): string;

Genera SQL para eliminar una columna de una tabla

public function dropForeignKey( string $tableName, string $schemaName, string $referenceName ): string;

Genera SQL para eliminar una clave ajena de una tabla

public function dropIndex( string $tableName, string $schemaName, string $indexName ): string;

Genera SQL para eliminar un índice de una tabla

public function dropPrimaryKey( string $tableName, string $schemaName ): string;

Genera SQL para eliminar la clave primaria de una tabla

public function dropTable( string $tableName, string $schemaName = null, bool $ifExists = bool ): string;

Genera SQL para eliminar una tabla

public function dropView( string $viewName, string $schemaName = null, bool $ifExists = bool ): string;

Genera SQL para eliminar una vista

public function forUpdate( string $sqlQuery ): string;

Devuelve un SQL modificado con una cláusula FOR UPDATE. Para SQLite devuelve la consulta original

public function getColumnDefinition( ColumnInterface $column ): string;

Devuelve el nombre de columna en SQLite

public function listIndexesSql( string $table, string $schema = null, string $keyName = null ): string;

Genera el SQL para obtener la consulta de la lista de índices

print_r(
    $dialect->listIndexesSql("blog")
);

public function listTables( string $schemaName = null ): string;

Lista todas las tablas de la base de datos

print_r(
    $dialect->listTables("blog")
);

public function listViews( string $schemaName = null ): string;

Genera el SQL para listar todas las vistas de un esquema o usuario

public function modifyColumn( string $tableName, string $schemaName, ColumnInterface $column, ColumnInterface $currentColumn = null ): string;

Genera SQL para modificar una columna de una tabla

public function sharedLock( string $sqlQuery ): string;

Devuelve un SQL modificado con una sentencia de bloque compartido. Por ahora este método devuelve la consulta original

public function tableExists( string $tableName, string $schemaName = null ): string;

Genera SQL que comprueba la existencia de esquema.tabla

echo $dialect->tableExists("posts", "blog");

echo $dialect->tableExists("posts");

public function tableOptions( string $table, string $schema = null ): string;

Genera el SQL que describe las opciones de creación de una tabla

public function truncateTable( string $tableName, string $schemaName ): string;

Genera SQL para truncar una tabla

public function viewExists( string $viewName, string $schemaName = null ): string;

Genera SQL comprobando la existencia de un esquema.vista

Interface Phalcon\Db\DialectInterface

Código fuente en GitHub

Namespace Phalcon\Db

Interfaz para dialectos Phalcon\Db

Métodos

public function addColumn( string $tableName, string $schemaName, ColumnInterface $column ): string;

Genera SQL para añadir una columna a una tabla

public function addForeignKey( string $tableName, string $schemaName, ReferenceInterface $reference ): string;

Genera SQL para añadir un índice a una tabla

public function addIndex( string $tableName, string $schemaName, IndexInterface $index ): string;

Genera SQL para añadir un índice a una tabla

public function addPrimaryKey( string $tableName, string $schemaName, IndexInterface $index ): string;

Genera SQL para añadir la clave primaria a una tabla

public function createSavepoint( string $name ): string;

Genera el SQL para crear un nuevo punto de guardado

public function createTable( string $tableName, string $schemaName, array $definition ): string;

Genera SQL para crear una tabla

public function createView( string $viewName, array $definition, string $schemaName = null ): string;

Genera SQL para crear una vista

public function describeColumns( string $table, string $schema = null ): string;

Genera SQL para describir una tabla

public function describeIndexes( string $table, string $schema = null ): string;

Genera SQL para consultar índices de una tabla

public function describeReferences( string $table, string $schema = null ): string;

Genera SQL para consultar claves ajenas de una tabla

public function dropColumn( string $tableName, string $schemaName, string $columnName ): string;

Genera SQL para eliminar una columna de una tabla

public function dropForeignKey( string $tableName, string $schemaName, string $referenceName ): string;

Genera SQL para eliminar una clave ajena de una tabla

public function dropIndex( string $tableName, string $schemaName, string $indexName ): string;

Genera SQL para eliminar un índice de una tabla

public function dropPrimaryKey( string $tableName, string $schemaName ): string;

Genera SQL para eliminar la clave primaria de una tabla

public function dropTable( string $tableName, string $schemaName, bool $ifExists = bool ): string;

Genera SQL para eliminar una tabla

public function dropView( string $viewName, string $schemaName = null, bool $ifExists = bool ): string;

Genera SQL para eliminar una vista

public function forUpdate( string $sqlQuery ): string;

Devuelve un SQL modificado con una cláusula FOR UPDATE

public function getColumnDefinition( ColumnInterface $column ): string;

Obtiene el nombre de columna en el RDBMS

public function getColumnList( array $columnList ): string;

Obtiene una lista de columnas

public function getCustomFunctions(): array;

Devuelve las funciones registradas

public function getSqlExpression( array $expression, string $escapeChar = null, array $bindCounts = [] ): string;

Transforma una representación intermedia para una expresión en una expresión válida para el sistema de base de datos

public function limit( string $sqlQuery, mixed $number ): string;

Genera el SQL para la cláusula LIMIT

public function listTables( string $schemaName = null ): string;

Lista todas las tablas de la base de datos

public function modifyColumn( string $tableName, string $schemaName, ColumnInterface $column, ColumnInterface $currentColumn = null ): string;

Genera SQL para modificar una columna de una tabla

public function registerCustomFunction( string $name, callable $customFunction ): Dialect;

Registra funciones SQL personalizadas

public function releaseSavepoint( string $name ): string;

Genera el SQL para lanzar un punto de guardado

public function rollbackSavepoint( string $name ): string;

Genera el SQL para deshacer un punto de guardado

public function select( array $definition ): string;

Construye una sentencia SELECT

public function sharedLock( string $sqlQuery ): string;

Devuelve un SQL modificado con la cláusula LOCK IN SHARE MODE

public function supportsReleaseSavepoints(): bool;

Comprueba si la plataforma soporta el lanzamiento de puntos de guardado.

public function supportsSavepoints(): bool;

Comprueba si la plataforma soporta puntos de guardado

public function tableExists( string $tableName, string $schemaName = null ): string;

Genera SQL que comprueba la existencia de esquema.tabla

public function tableOptions( string $table, string $schema = null ): string;

Genera el SQL que describe las opciones de creación de una tabla

public function viewExists( string $viewName, string $schemaName = null ): string;

Genera SQL comprobando la existencia de un esquema.vista

Class Phalcon\Db\Enum

Código fuente en GitHub

Namespace Phalcon\Db

Constantes para Phalcon\Db

Constantes

const FETCH_ASSOC;
const FETCH_BOTH;
const FETCH_BOUND;
const FETCH_CLASS;
const FETCH_CLASSTYPE;
const FETCH_COLUMN;
const FETCH_DEFAULT = 0;
const FETCH_FUNC;
const FETCH_GROUP;
const FETCH_INTO;
const FETCH_KEY_PAIR;
const FETCH_LAZY;
const FETCH_NAMED;
const FETCH_NUM;
const FETCH_OBJ;
const FETCH_ORI_NEXT;
const FETCH_PROPS_LATE;
const FETCH_SERIALIZE;
const FETCH_UNIQUE;

Class Phalcon\Db\Exception

Código fuente en GitHub

Namespace Phalcon\Db   Extends \Exception

Las excepciones lanzadas en Phalcon\Db usarán esta clase

Class Phalcon\Db\Index

Código fuente en GitHub

Namespace Phalcon\Db   Implements IndexInterface

Permite definir índices a usar en las tablas. Los índices son una manera común de mejorar el rendimiento de una base de datos. Un índice permite al servidor de base de datos encontrar y obtener filas específicas mucho más rápido que si lo tuviese que hacer sin ningún índice

// Define new unique index
$index_unique = new \Phalcon\Db\Index(
    'column_UNIQUE',
    [
        'column',
        'column',
    ],
    'UNIQUE'
);

// Define new primary index
$index_primary = new \Phalcon\Db\Index(
    'PRIMARY',
    [
        'column',
    ]
);

// Add index to existing table
$connection->addIndex("robots", null, $index_unique);
$connection->addIndex("robots", null, $index_primary);

Propiedades

/**
 * Index columns
 *
 * @var array
 */
protected columns;

/**
 * Index name
 *
 * @var string
 */
protected name;

/**
 * Index type
 *
 * @var string
 */
protected type;

Métodos

public function __construct( string $name, array $columns, string $type = string );

Constructor Phalcon\Db\Index

public function getColumns(): array;

Index columns

public function getName(): string;

Index name

public function getType(): string;

Index type

Interface Phalcon\Db\IndexInterface

Código fuente en GitHub

Namespace Phalcon\Db

Interfaz para Phalcon\Db\Index

Métodos

public function getColumns(): array;

Obtiene las columnas que corresponden al índice

public function getName(): string;

Obtiene el nombre del índice

public function getType(): string;

Obtiene el tipo de índice

Class Phalcon\Db\Profiler

Código fuente en GitHub

Namespace Phalcon\Db   Uses Phalcon\Db\Profiler\Item

Las instancias de Phalcon\Db pueden generar perfiles de ejecución en sentencias SQL enviadas a la base de datos relacional. La información perfilada incluye el tiempo de ejecución en milisegundos. Esto le ayuda a identificar cuellos de botella en sus aplicaciones.

use Phalcon\Db\Profiler;
use Phalcon\Events\Event;
use Phalcon\Events\Manager;

$profiler = new Profiler();
$eventsManager = new Manager();

$eventsManager->attach(
    "db",
    function (Event $event, $connection) use ($profiler) {
        if ($event->getType() === "beforeQuery") {
            $sql = $connection->getSQLStatement();

            // Start a profile with the active connection
            $profiler->startProfile($sql);
        }

        if ($event->getType() === "afterQuery") {
            // Stop the active profile
            $profiler->stopProfile();
        }
    }
);

// Set the event manager on the connection
$connection->setEventsManager($eventsManager);


$sql = "SELECT buyer_name, quantity, product_name
FROM buyers LEFT JOIN products ON
buyers.pid=products.id";

// Execute a SQL statement
$connection->query($sql);

// Get the last profile in the profiler
$profile = $profiler->getLastProfile();

echo "SQL Statement: ", $profile->getSQLStatement(), "\n";
echo "Start Time: ", $profile->getInitialTime(), "\n";
echo "Final Time: ", $profile->getFinalTime(), "\n";
echo "Total Elapsed Time: ", $profile->getTotalElapsedSeconds(), "\n";

Propiedades

/**
 * Active Item
 *
 * @var Item
 */
protected activeProfile;

/**
 * All the Items in the active profile
 *
 * @var Item[]
 */
protected allProfiles;

/**
 * Total time spent by all profiles to complete in nanoseconds
 *
 * @var float
 */
protected totalNanoseconds = 0;

Métodos

public function getLastProfile(): Item;

Devuelve el último perfil ejecutado en el perfilador

public function getNumberTotalStatements(): int;

Devuelve el número total de sentencias SQL procesadas

public function getProfiles(): Item[];

Obtiene todos los perfiles procesados

public function getTotalElapsedMilliseconds(): double;

Returns the total time in milliseconds spent by the profiles

public function getTotalElapsedNanoseconds(): double;

Returns the total time in nanoseconds spent by the profiles

public function getTotalElapsedSeconds(): double;

Devuelve el tiempo total empleado por los perfiladores en segundos

public function reset(): Profiler;

Restablece el perfilador, limpiando todos los perfiladores

public function startProfile( string $sqlStatement, array $sqlVariables = [], array $sqlBindTypes = [] ): Profiler;

Inicia el perfil de una sentencia SQL

public function stopProfile(): Profiler;

Detiene el perfil activo

Class Phalcon\Db\Profiler\Item

Código fuente en GitHub

Namespace Phalcon\Db\Profiler

Esta clase identifica cada perfil de un Phalcon\Db\Profiler

Propiedades

/**
 * Timestamp when the profile ended
 *
 * @var double
 */
protected finalTime;

/**
 * Timestamp when the profile started
 *
 * @var double
 */
protected initialTime;

/**
 * SQL bind types related to the profile
 *
 * @var array
 */
protected sqlBindTypes;

/**
 * SQL statement related to the profile
 *
 * @var string
 */
protected sqlStatement;

/**
 * SQL variables related to the profile
 *
 * @var array
 */
protected sqlVariables;

Métodos

public function getFinalTime(): double;

Return the timestamp when the profile ended

public function getInitialTime(): double;

Return the timestamp when the profile started

public function getSqlBindTypes(): array;

Return the SQL bind types related to the profile

public function getSqlStatement(): string;

Return the SQL statement related to the profile

public function getSqlVariables(): array;

Return the SQL variables related to the profile

public function getTotalElapsedMilliseconds(): double;

Returns the total time in milliseconds spent by the profile

public function getTotalElapsedNanoseconds(): double;

Returns the total time in nanoseconds spent by the profile

public function getTotalElapsedSeconds(): double;

Devuelve el tiempo total gastado por el perfil en segundos

public function setFinalTime( double $finalTime ): Item;

Return the timestamp when the profile ended

public function setInitialTime( double $initialTime ): Item;

Return the timestamp when the profile started

public function setSqlBindTypes( array $sqlBindTypes ): Item;

Return the SQL bind types related to the profile

public function setSqlStatement( string $sqlStatement ): Item;

Return the SQL statement related to the profile

public function setSqlVariables( array $sqlVariables ): Item;

Return the SQL variables related to the profile

Class Phalcon\Db\RawValue

Código fuente en GitHub

Namespace Phalcon\Db

Esta clase permite insertar/actualizar datos brutos sin comillas ni formatos.

El ejemplo siguiente muestra como usar la función MySQL now() como valor de un campo.

$subscriber = new Subscribers();

$subscriber->email     = "[email protected]";
$subscriber->createdAt = new \Phalcon\Db\RawValue("now()");

$subscriber->save();

Propiedades

/**
 * Raw value without quoting or formatting
 *
 * @var string
 */
protected value;

Métodos

public function __construct( mixed $value );

Constructor Phalcon\Db\RawValue

public function __toString(): string;

public function getValue(): string;

Class Phalcon\Db\Reference

Código fuente en GitHub

Namespace Phalcon\Db   Implements ReferenceInterface

Permite definir restricciones de referencia en tablas

$reference = new \Phalcon\Db\Reference(
    "field_fk",
    [
        "referencedSchema"  => "invoicing",
        "referencedTable"   => "products",
        "columns"           => [
            "producttype",
            "product_code",
        ],
        "referencedColumns" => [
            "type",
            "code",
        ],
    ]
);

Propiedades

/**
 * Local reference columns
 *
 * @var array
 */
protected columns;

/**
 * Constraint name
 *
 * @var string
 */
protected name;

/**
 * Referenced Columns
 *
 * @var array
 */
protected referencedColumns;

/**
 * Referenced Schema
 *
 * @var string
 */
protected referencedSchema;

/**
 * Referenced Table
 *
 * @var string
 */
protected referencedTable;

/**
 * Schema name
 *
 * @var string
 */
protected schemaName;

/**
 * ON DELETE
 *
 * @var string
 */
protected onDelete;

/**
 * ON UPDATE
 *
 * @var string
 */
protected onUpdate;

Métodos

public function __construct( string $name, array $definition );

Constructor Phalcon\Db\Reference

public function getColumns(): array;

Local reference columns

public function getName(): string;

Constraint name

public function getOnDelete(): string;

ON DELETE

public function getOnUpdate(): string;

ON UPDATE

public function getReferencedColumns(): array;

Referenced Columns

public function getReferencedSchema(): string;

Referenced Schema

public function getReferencedTable(): string;

Referenced Table

public function getSchemaName(): string;

Schema name

Interface Phalcon\Db\ReferenceInterface

Código fuente en GitHub

Namespace Phalcon\Db

Interfaz para Phalcon\Db\Reference

Métodos

public function getColumns(): array;

Obtiene las columnas locales en las que se basa la referencia

public function getName(): string;

Obtiene el nombre del índice

public function getOnDelete(): string;

Obtiene la referencia al eliminar

public function getOnUpdate(): string;

Obtiene la referencia al actualizar

public function getReferencedColumns(): array;

Obtiene las columnas referenciadas

public function getReferencedSchema(): string;

Obtiene el esquema donde está la tabla referenciada

public function getReferencedTable(): string;

Obtiene la tabla referenciada

public function getSchemaName(): string;

Obtiene el esquema donde está la tabla referenciada

Class Phalcon\Db\Result\PdoResult

Código fuente en GitHub

Namespace Phalcon\Db\Result   Uses Phalcon\Db\Enum, Phalcon\Db\ResultInterface, Phalcon\Db\Adapter\AdapterInterface   Implements ResultInterface

Encapsula el conjunto de resultados interno

$result = $connection->query("SELECTFROM robots ORDER BY name");

$result->setFetchMode(
    \Phalcon\Db\Enum::FETCH_NUM
);

while ($robot = $result->fetchArray()) {
    print_r($robot);
}

Propiedades

/**
 * @var array
 */
protected bindParams;

/**
 * @var array
 */
protected bindTypes;

/**
 * @var AdapterInterface
 */
protected connection;

/**
 * Active fetch mode
 *
 * @var int
 */
protected fetchMode;

/**
 * Internal resultset
 *
 * @var \PDOStatement
 */
protected pdoStatement;

/**
 * @var mixed
 * TODO: Check if this property is used
 */
protected result;

/**
 * @var bool
 */
protected rowCount = false;

/**
 * @var string|null
 */
protected sqlStatement;

Métodos

public function __construct( AdapterInterface $connection, \PDOStatement $result, mixed $sqlStatement = null, mixed $bindParams = null, mixed $bindTypes = null );

Constructor Phalcon\Db\Result\Pdo

public function dataSeek( int $number ): void;

Mueve el cursor del conjunto de resultados interno a otra posición permitiéndonos obtener una fila determinada

$result = $connection->query(
    "SELECTFROM robots ORDER BY name"
);

// Move to third row on result
$result->dataSeek(2);

// Fetch third row
$row = $result->fetch();

public function execute(): bool;

Permite ejecutar la sentencia otra vez. Algunos sistemas de base de datos no soportan cursores desplazables. Por lo tanto, como los cursores sólo son hacia delante, necesitamos ejecutar el cursos otra vez para obtener filas desde el principio

public function fetch( int $fetchStyle = null, int $cursorOrientation = static-constant-access, int $cursorOffset = int );

Obtiene un vector/objeto de cadenas que corresponden a las filas obtenidas, o FALSE si no hay más filas. Este método se ve afectado por el indicador de obtención activo configurado usando Phalcon\Db\Result\Pdo::setFetchMode()

$result = $connection->query("SELECT * FROM robots ORDER BY name");

$result->setFetchMode(
    \Phalcon\Enum::FETCH_OBJ
);

while ($robot = $result->fetch()) {
    echo $robot->name;
}

public function fetchAll( int $mode = Enum::FETCH_DEFAULT, mixed $fetchArgument = Enum::FETCH_ORI_NEXT, mixed $constructorArgs = null ): array;

Devuelve un vector de vectores que contiene todos los registros del resultado Este método se ve afectado por el indicador de obtención activo configurado usando Phalcon\Db\Result\Pdo::setFetchMode()

$result = $connection->query(
    "SELECT * FROM robots ORDER BY name"
);

$robots = $result->fetchAll();

public function fetchArray();

Devuelve un vector de cadenas que corresponden a la fila obtenida, o FALSE si no hay más filas. Este método se ve afectado por el indicador de obtención activo configurado usando Phalcon\Db\Result\Pdo::setFetchMode()

$result = $connection->query("SELECT * FROM robots robots ORDER BY name");

$result->setFetchMode(
    \Phalcon\Enum::FETCH_NUM
);

while ($robot = result->fetchArray()) {
    print_r($robot);
}

public function getInternalResult(): \PDOStatement;

Obtiene el objeto de resultado PDO interno

public function numRows(): int;

Obtiene el número de filas devueltas por un conjunto de resultados

$result = $connection->query(
    "SELECT * FROM robots robots ORDER BY name"
);

echo "There are ", $result->numRows(), " rows in the resultset";

public function setFetchMode( int $fetchMode, mixed $colNoOrClassNameOrObject = null, mixed $ctorargs = null ): bool;

Cambia el modo de obtención que afecta a Phalcon\Db\Result\Pdo::fetch()

// Return array with integer indexes
$result->setFetchMode(
    \Phalcon\Enum::FETCH_NUM
);

// Return associative array without integer indexes
$result->setFetchMode(
    \Phalcon\Enum::FETCH_ASSOC
);

// Return associative array together with integer indexes
$result->setFetchMode(
    \Phalcon\Enum::FETCH_BOTH
);

// Return an object
$result->setFetchMode(
    \Phalcon\Enum::FETCH_OBJ
);

Interface Phalcon\Db\ResultInterface

Código fuente en GitHub

Namespace Phalcon\Db

Interfaz para objetos Phalcon\Db\Result

Métodos

public function dataSeek( int $number );

Mueve el cursor del conjunto de resultados interno a otra posición permitiéndonos obtener una fila determinada

public function execute(): bool;

Permite ejecutar la sentencia otra vez. Algunos sistemas de base de datos no soportan cursores desplazables. Por lo tanto, como los cursores sólo son hacia delante, necesitamos ejecutar el cursos otra vez para obtener filas desde el principio

public function fetch(): mixed;

Obtiene un vector/objeto de cadenas que corresponden a las filas obtenidas, o FALSE si no hay más filas. Este método se ve afectado por el indicador de obtención activo configurado usando Phalcon\Db\Result\Pdo::setFetchMode()

public function fetchAll(): array;

Devuelve un vector de vectores que contienen todos los registros de un resultado. Este método se ve afectado por el indicador de obtención activo configurado usando Phalcon\Db\Result\Pdo::setFetchMode()

public function fetchArray(): mixed;

Devuelve un vector de cadenas que corresponden a la fila obtenida, o FALSE si no hay más filas. Este método se ve afectado por el indicador de obtención activo configurado usando Phalcon\Db\Result\Pdo::setFetchMode()

public function getInternalResult(): \PDOStatement;

Obtiene el objeto de resultado PDO interno

public function numRows(): int;

Obtiene el número de filas devueltas por un conjunto de resultados

public function setFetchMode( int $fetchMode ): bool;

Cambia el modo de obtención que afecta a Phalcon\Db\Result\Pdo::fetch()

General
Introducción
Notas de la Versión
Actualizar
Patrocinadores
Contribuciones
Resumen
Pull Requests
NFR (Solicitud de Nuevas Características)
Generación de Backtrace
Pruebas Reproducibles
Entorno de prueba
Estándar de codificación
Cómo Empezar
Instalación
Configuración de Servidor Web
Entornos
Devilbox
Nanobox
Herramientas de Desarrollo
DevTools
Depuración
Migraciones
Pruebas Unitarias
Tutoriales
Básico
Invo
REST
Vokuro
Casos de uso
Rendimiento
Núcleo
Índice del API
Application
Micro
CLI
Contenedor DI
MVC
Espacios de nombres
Servicios
Cache
Configuración
Escaper
Loader
Logger
Base de Datos
Capa
PHQL
ODM
Modelos
Comportamientos
Cache
Eventos
Metadatos
Relaciones
Transacciones
Validadores
Paginación
Migraciones
Front End
Recursos Activos
Mensajes Flash
Formularios
Imagen
Tag
Tag (legacy)
Vistas
Volt
Lógica de Negocio
Listas de Control de Acceso
Anotaciones
Controladores
Dispatcher
Gestor de Eventos
Filtros
Ruteo
Sesiones
Url
Validación
HTTP
Cookies
Consulta
Respuesta
Seguridad
Crypto
Seguridad
JWT
i18n
Internacionalización
Traducciones
Utilidad
Coleccion
Domain
Ayudantes
Registro
Versión