introducción pdo
TRANSCRIPT
Introducción
La extensión Objetos de Datos de PHP (PDO por sus siglás en inglés) define un interfaz
ligera para poder acceder a bases de datos en PHP. Cada controlador de bases de datos que
implemente la interfaz PDO puede exponer características específicas de la base de datos, como
las funciones habituales de la extensión. Obsérvese que no se puede realizar ninguna de las
funciones de la bases de datos utilizando la extensión PDO por sí misma; se debe utilizar
un controlador de PDO específico de la base de datos para tener acceso a un servidor de
bases de datos.
PDO proporciona una capa de abstracción de acceso a datos, lo que significa que,
independientemente de la base de datos que se esté utilizando, se usan las mismas funciones
para realizar consultas y obtener datos. PDO noproporciona una abstracción de bases de
datos; no reescribe SQL ni emula características ausentes. Se debería usar una capa de
abstracción totalmente desarrollada si fuera necesaria tal capacidad.
PDO viene con PHP 5.1, y está disponible como una extensión PECL para PHP 5.0; PDO
requiere las características nuevas de OO del núcleo de PHP 5, por lo que no se ejecutará con
versiones anteriores de PHP.
Constantes predefinidas
Estas constantes están definidas por esta extensión y estarán disponibles sólo cuando la
extensión haya sido compilada con PHP, o bien sea cargada dinámicamente en ejecución.
Advertencia
PDO utiliza constantes de clase desde PHP 5.1. Las versiones anteriores usan constantes
globales bajo la forma PDO_PARAM_BOOL.
PDO::PARAM_BOOL (integer)
Representa un tipo de dato booleano.
PDO::PARAM_NULL (integer)
Representa el tipo de dato NULL de SQL.
PDO::PARAM_INT (integer)
Representa el tipo de dato INTEGER de SQL .
PDO::PARAM_STR (integer)
Representa el tipo de dato CHAR, VARCHAR de SQL, u otro tipo de datos de cadena.
PDO::PARAM_LOB (integer)
Representa el tipo de dato LOB (objeto grande) de SQL.
PDO::PARAM_STMT (integer)
Representa un tipo de conjunto de registros. No está admitido actualmente por ningún
controlador.
PDO::PARAM_INPUT_OUTPUT (integer)
Especifica que el parámetro es de entrada/salida (INOUT) para un procedimiento
almacenado. Se debe realizar un OR a nivel de bits con un tipo de datos
PDO::PARAM_* explícito.
PDO::FETCH_LAZY (integer)
Especifica que el método de obtención debe devolver cada fila como un objeto con los
nombres de las variables que se corresponden a los nombres de las columnas
devueltos en el conjunto de resultados.PDO::FETCH_LAZY crea los nombres de las
variables del objeto a medida que se acceden a ellas. No es válida dentro
de PDOStatement::fetchAll().
PDO::FETCH_ASSOC (integer)
Especifica que el método de obtención debe devolver cada fila como un array
indexado por los nombres de las columnas devueltos en el correspondiente conjunto
de resultados. Si éste contiene múltiples columnas con el mismo
nombre, PDO::FETCH_ASSOC devuelve un único valor por nombre de columna.
PDO::FETCH_NAMED (integer)
Especifica que el método de obtención debe devolver cada fila como un array
indexado por los nombres de las columnas devueltos en el correspondiente conjunto
de resultados. Si éste contiene múltiples columnas con el mismo
nombre, PDO::FETCH_NAMED devuelve un array de valores por nombre de columna.
PDO::FETCH_NUM (integer)
Especifica que el método de obtención debe devolver cada fila como un array
indexado por los números de columna devueltos en el correspondiente conjunto de
resultados, comenzando por la columna 0.
PDO::FETCH_BOTH (integer)
Especifica que el método de obtención debe devolver cada fila como un array
indexado tanto por los nombres como por los números de las columnas devueltos en
el correspondiente conjunto de resultados, comenzando por la columna 0.
PDO::FETCH_OBJ (integer)
Especifica que el método de obtención debe devolver cada fila como un objeto con los
nombres de sus propiedades correspondientes a los nombres de las columnas
devueltos en el conjunto de resultados.
PDO::FETCH_BOUND (integer)
Especifica que el método de obtención debe devolver TRUE y asignar los valores de
las columnas del conjunto de resultados a las variables de PHP a las cuales están
vinculadas con los
métodosPDOStatement::bindParam() o PDOStatement::bindColumn().
PDO::FETCH_COLUMN (integer)
Especifica que el método de obtención debe devolver una única columna solicitada de
la siguiente fila del conjunto de resultados.
PDO::FETCH_CLASS (integer)
Especifica que el método de obtención debe devolver una nueva instancia de la clase
solicitada, haciendo corresponder las columnas con los nombres de las propiedades
de la clase.
Nota: El método mágico __set() se invoca si la propiedad no existe en la clase
solicitada.
PDO::FETCH_INTO (integer)
Especifica que el método de obtencion debe actualizar una instancia existente de la
clase solicitada, haciendo corresponder las columnas con los nombres de las
propiedades de la clase.
PDO::FETCH_FUNC (integer)
Permite personalizar completamente la forma en que los datos son tratados al vuelo
(únicamente válida dentro de PDOStatement::fetchAll()).
PDO::FETCH_GROUP (integer)
Grupo devuelto según valores. Usualmente combinada
con PDO::FETCH_COLUMN o PDO::FETCH_KEY_PAIR.
PDO::FETCH_UNIQUE (integer)
Obtener solamente los valores únicos.
PDO::FETCH_KEY_PAIR (integer)
Obtener un resultado de dos columnas como un array donde la primera columna es la
clave y la segunda el valor. Disponible desde PHP 5.2.3.
PDO::FETCH_CLASSTYPE (integer)
Determinar el nombre de la clase desde el valor de la primera columna.
PDO::FETCH_SERIALIZE (integer)
Igual que PDO::FETCH_INTO salvo que el objeto es proporcionado como una cadena
serializada. Disponible desde PHP 5.1.0.
PDO::FETCH_PROPS_LATE (integer)
Disponible desde PHP 5.2.0
PDO::ATTR_AUTOCOMMIT (integer)
Si este valor es FALSE, PDO intenta descativar la autoconsigna de forma que la
conexión comience una transacción.
PDO::ATTR_PREFETCH (integer)
Establecer el tamaño de la precarga permite obtener un equilibrio entre rapidez y uso
de memoria para la aplicación. No todas las combinaciones base de datos/controlador
admiten establecer el tamaño de la precarga. Un valor más grande de precarga da
como resultado un aumento del rendimiento a costa de un mayor uso de memoria.
PDO::ATTR_TIMEOUT (integer)
Establece el valor del tiempo de espera, en segundos, para las comunicaciones con la
base de datos.
PDO::ATTR_ERRMODE (integer)
Véase la sección Errores y su manejo para obtener más información sobre este
atributo.
PDO::ATTR_SERVER_VERSION (integer)
Este es un atributo de sólo lectura; devolverá información sobre la versión del servidor
de bases de datos al que está conectado PDO.
PDO::ATTR_CLIENT_VERSION (integer)
Este es un atributo de sólo lectura; devolverá información sobre la versión de las
bibliotecas cliente que el controlador de PDO está usando.
PDO::ATTR_SERVER_INFO (integer)
Este es un atributo de sólo lectura; devolverá alguna metainformación sobre el servidor
de bases de datos al que está conectado PDO.
PDO::ATTR_CONNECTION_STATUS (integer)
PDO::ATTR_CASE (integer)
Forzar a los nombres de las columnas al uso de mayúsculas/minúsculas especificado
por las constantesPDO::CASE_*.
PDO::ATTR_CURSOR_NAME (integer)
Obtener o establecer el nombre a usar para un cursor. Es más útil cuando se utilizan
cursores desplazables y actualizacioines posicionadas.
PDO::ATTR_CURSOR (integer)
Selecciona el tipo de cursor. PDO actualmente
admite PDO::CURSOR_FWDONLY y PDO::CURSOR_SCROLL. Cíñase
a PDO::CURSOR_FWDONLY a menos que sepa que necesite un cursor desplazable.
PDO::ATTR_DRIVER_NAME (string)
Devuelve el nombre del controlador.
Ejemplo #1 Usar PDO::ATTR_DRIVER_NAME
<?php
if ($db->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql') {
echo "Ejecutándose sobre mysql; hacer algo específico de mysql aquí\n";
}
?>
PDO::ATTR_ORACLE_NULLS (integer)
Convertir cadenas vacías a valores NULL de SQL en la obtención de datos.
PDO::ATTR_PERSISTENT (integer)
Solicitar una conexión persistente, en vez de crear una nueva conexión.
Véase Conexiones y su administración para obtener más información sobre este
atributo.
PDO::ATTR_STATEMENT_CLASS (integer)
PDO::ATTR_FETCH_CATALOG_NAMES (integer)
Anteponer el nombre del catálogo contenido a cada nombre de columna devuelto en el
conjunto de resultados. El nombre del catálogo y el nombre de columna están
separados por el carácter punto (.). El soporte de este atributo es a nivel del
controlador; podría no estar admitido por el controlador que usted utilice.
PDO::ATTR_FETCH_TABLE_NAMES (integer)
Anteponer el nombre de la tabla contenida a cada nombre de columna devuelto en el
conjunto de resultados. El nombre de la tabla y el nombre de columna están
separados por el carácter punto (.). El soporte de este atributo es a nivel del
controlador; podría no estar admitido por el controlador que usted utilice.
PDO::ATTR_STRINGIFY_FETCHES (integer)
PDO::ATTR_MAX_COLUMN_LEN (integer)
PDO::ATTR_DEFAULT_FETCH_MODE (integer)
Disponible desde PHP 5.2.0.
PDO::ATTR_EMULATE_PREPARES (integer)
Disponible desde PHP 5.1.3.
PDO::ERRMODE_SILENT (integer)
No emitir ningún error o excepción si ocurrieran. El desarrollador es responsable de
comprobar explícitamente los errores. Este es el modo predeterminado. Véase Errores
y su manejo para obtener más información sobre este atributo.
PDO::ERRMODE_WARNING (integer)
Emitir un mensaje de tipo E_WARNING de PHP si ocurre algún error. Véase Errores y
su manejo para obtener más información sobre este atributo.
PDO::ERRMODE_EXCEPTION (integer)
Lanzar una excepción de tipo PDOException si ocurre algún error. Véase Errores y su
manejo para obtener más información sobre este atributo.
PDO::CASE_NATURAL (integer)
Dejar los nombres de las columnas tal como son devueltas por el controlador de la
base de datos.
PDO::CASE_LOWER (integer)
Forzar a los nombres de las columnas a estar en minúsculas.
PDO::CASE_UPPER (integer)
Fuerza a los nombres de las columnas a estar en mayúsculas.
PDO::NULL_NATURAL (integer)
PDO::NULL_EMPTY_STRING (integer)
PDO::NULL_TO_STRING (integer)
PDO::FETCH_ORI_NEXT (integer)
Obtener la siguiente fila del conjunto de resultados. Únicamente válida para cursores
desplazables.
PDO::FETCH_ORI_PRIOR (integer)
Obtener la fila anterior del conjunto de resultados. Únicamente válida para cursores
desplazables.
PDO::FETCH_ORI_FIRST (integer)
Obtener la primera fila del conjunto de resultados. Únicamente válida para cursores
desplazables.
PDO::FETCH_ORI_LAST (integer)
Obtener la última fila del conjunto de resultados. Únicamente válida para cursores
desplazables.
PDO::FETCH_ORI_ABS (integer)
Obtener la fila solicitada mediante el número de fila del conjunto de resultados.
Únicamente válida para cursores desplazables.
PDO::FETCH_ORI_REL (integer)
Obtener la fila solicitada mediante la posición relativa de la posición actual del cursor
del conjunto de resultados. Únicamente válida para cursores desplazables.
PDO::CURSOR_FWDONLY (integer)
Crear un objeto PDOStatement con un cursor de sólo avance. Este es la elección del
cursor predeterminada, ya que es el patrón de acceso a datos más rápido y común en
PHP.
PDO::CURSOR_SCROLL (integer)
Crear un objeto PDOStatement con un cursor desplazable. Pase las
constantes PDO::FETCH_ORI_*para controlar las filas obtenidas del conjunto de
resultados.
PDO::ERR_NONE (string)
Corresponde al SQLSTATE '00000', el cual significa que la sentencia SQL fue
ejecutada con éxito, sin errores ni advertencias. Esta constante sirve para la
comprobación cómoda de PDO::errorCode() oPDOStatement::errorCode() para
determinar si ha ocurrido algún error. En cualquier caso, usualmente se sabrá si este
es el caso examinando el código devuelto por el método que provocó la condición de
error.
PDO::PARAM_EVT_ALLOC (integer)
Evento de asignación
PDO::PARAM_EVT_FREE (integer)
Evento de desasigncación
PDO::PARAM_EVT_EXEC_PRE (integer)
Evento provocado antes de la ejecución de una sentencia preparada.
PDO::PARAM_EVT_EXEC_POST (integer)
Evento provocado después de la ejecución de una sentencia preparada.
PDO::PARAM_EVT_FETCH_PRE (integer)
Evento provocado antes de la obtención de un resultado de un conjunto de resultados.
PDO::PARAM_EVT_FETCH_POST (integer)
Evento provocado después de la obtención de un resultado de un conjunto de
resultados.
PDO::PARAM_EVT_NORMALIZE (integer)
Evento provocado durante el resistro de un parámetro vinculado, permitiendo al
controlador normalizar el nombre del parámetro.
add a noteUser Contributed Notes Constantes predefinidas - [2 notes]
up
down
0
sam at xnet dot tk
5 hours ago
It should be noted that PDO::FETCH_CLASS will call the constructor *after* setting the
values (or calling __set).
up
down
0
Axeia
2 years ago
If you're reading in information from an array to use in a prepared statement you may
find the following function useful.
<?php
function getPDOConstantType( $var )
{
if( is_int( $var ) )
return PDO::PARAM_INT;
if( is_bool( $var ) )
return PDO::PARAM_BOOL;
if( is_null( $var ) )
return PDO::PARAM_NULL;
//Default
return PDO::PARAM_STR;
}
?>
Conexiones y su administración
Las conexiones se establecen creando instancias de la clase base PDO. No importa el
controlador que se utilice; siempre se usará el nombre de la clase PDO. El constructor acepta
parámetros para especificar el origen de datos (conocido como DSN) y, opcionalmente, el
nombre de usuario y la contraseña (si la hubiera).
Ejemplo #1 Conectarse a MySQL
<?php
$gbd = new PDO('mysql:host=localhost;dbname=test', $usuario, $contraseña);
?>
Si hubieran errores de conexión, se lanzará un objeto de tipo PDOException. Se puede
capturar la excepción si fuera necesario manejar la condición del error, o se podría optar por
dejarla en manos de un gestor de excepciones global de una aplicación configurado
mediante set_exception_handler().
Ejemplo #2 Manejo de errores de conexión
<?php
try {
$gbd = new PDO('mysql:host=localhost;dbname=test', $usuario, $contraseña);
foreach($gbd->query('SELECT * from FOO') as $fila) {
print_r($fila);
}
$gbd = null;
} catch (PDOException $e) {
print "¡Error!: " . $e->getMessage() . "<br/>";
die();
}
?>
Advertencia
Si la aplicación no captura la excepción lanzada por el constructor de PDO, la acción
predeterminada que toma el motor zend es la de finalizar el script y mostrar información de
rastreo. Esta información probablemente revelará todos los detalles de la conexión a la base de
datos, incluyendo el nombre de usuario y la contraseña. Es su responsabilidad capturar esta
excepción, ya sea explícitamente (con una sentenciacatch) o implícitamente por medio
de set_exception_handler().
Una vez realizada con éxito una conexión a la base de datos, será devuelta una instancia de la
clase PDO al script. La conexión permanecerá activa durante el tiempo de vida del objeto PDO.
Para cerrar la conexión, es necesario destruir el objeto asegurándose de que todas las referencias
a él existentes sean eliminadas (esto se puede hacer asignando NULL a la variable que contiene
el objeto). Si no se realiza explícitamente, PHP cerrará automáticamente la conexión cuando el
script finalice.
Ejemplo #3 Cerrar una conexión
<?php
$gbd = new PDO('mysql:host=localhost;dbname=test', $usuario, $contraseña);
// Use la conexión aquí
// ya se ha terminado; la cerramos
$gbd = null;
?>
Muchas aplicaciones web se beneficiarán del uso de conexiones persistentes a servidores de
bases de datos. Las conexiones persistentes no son cerradas al final del script, sino que son
almacenadas en caché y reutilizadas cuando otro script solicite una conexión que use las mismas
credenciales. La caché de conexiones persistentes permite evitar la carga adicional de establecer
una nueva conexión cada vez que un script necesite comunicarse con la base de datos, dando
como resultado una aplicación web más rápida.
Ejemplo #4 Conexiones persistentes
<?php
$gbd = new PDO('mysql:host=localhost;dbname=test', $usuario, $contraseña, array(
PDO::ATTR_PERSISTENT => true
));
?>
Nota:
Si se quiere usar conexiones persistentes, se deberá establecer PDO::ATTR_PERSISTENT en
las opciones del array del controlador pasado al constructor de PDO. Si este atributo se
establece con PDO::setAttribute()después de la instanciación del objeto, el controlador no
utilizará conexiones persistentes.
Nota:
Si se usa el controlador PDO y las bibliotecas ODBC admiten el agrupamiento de conexiones
ODBC (unixODBC y Windows lo hacen; podrían haber más), se recomienda no utilizar las
conexiones persistentes de PDO, y, en su lugar, dejar el almacenamiento en caché de
conexiones a la capa del agrupamiento de conexiones de ODBC. El agrupamiento de
conexiones de ODBC se comparte con otros módulos en el proceso; si se le indica a PDO que
almacene en caché la conexión, entonces dicha conexión nunca será devuelta al agrupamiento
de conexiones de ODBC, dando como resultado la creación de conexiones adicionales para
servir a los demás módulos.
Transacciones y 'auto-commit' Constantes predefinidas
[edit] Last updated: Fri, 25 Jan 2013
add a noteUser Contributed Notes Conexiones y su administración - [6 notes]
up
down
2
jak dot spalding at gmail dot com
1 year ago
Just thought I'd add in and give an explanation as to why you need to use 127.0.0.1 if
you have a different port number.
The mysql libraries will automatically use Unix sockets if the host of "localhost" is used.
To force TCP/IP you need to set an IP address.
up
down
1
neville at whitespacers dot com
3 years ago
To avoid exposing your connection details should you fail to remember to catch any
exception thrown by the PDO constructor you can use the following class to implicitly
change the exception handler temporarily.
<?php
Class SafePDO extends PDO {
public static function exception_handler($exception) {
// Output the exception details
die('Uncaught exception: ', $exception->getMessage());
}
public
function __construct($dsn, $username='', $password='', $driver_options=array()) {
// Temporarily change the PHP exception handler while we . . .
set_exception_handler(array(__CLASS__, 'exception_handler'));
// . . . create a PDO object
parent::__construct($dsn, $username, $password, $driver_options);
// Change the exception handler back to whatever it was before
restore_exception_handler();
}
}
// Connect to the database with defined constants
$dbh = new SafePDO(PDO_DSN, PDO_USER, PDO_PASSWORD);
?>
up
down
0
alvaro at demogracia dot com
1 year ago
On connection errors, the PDO constructor seems to do two things no matter your
PDO::ATTR_ERRMODE setting:
1. Trigger a warning
2. Throw a PDOException
If you set the PDO::ATTR_ERRMODE parameter, it will only take effect on further
operations.
up
down
-1
angela
2 years ago
I spent hours today trying to get my portable wamp to update a database, using
localhost:800 and port 3307 for mysql. For it to work I needed to adjust the connect()
instruction as described:
$dsn = "mysql:host=127.0.0.1;port=3307;dbname=mydatabase";
up
down
0
ekkart at ekkart dot de
2 years ago
In order to set the encoding of the database connection, use the exec function:
<?php
try {
$dbh = new PDO('mysql:host=localhost;dbname=test', $user, $pass);
$dbh->exec("SET CHARACTER SET utf8");
$dbh = null;
} catch (PDOException $e) {
print "Error!: " . $e->getMessage() . "<br/>";
die();
}
?>
up
down
-1
dan dot franklin at pearson dot com
4 years ago
Note that you can specify a port number with "port=####", but this port number will be
ignored if the host is localhost. If you want to connect to a local port other than the
default, use host=127.0.0.1 instead of localhost.
Transacciones y 'auto-commit'
Una vez realizada una conexión a través de PDO, es necesario comprender cómo PDO gestiona
las transacciones antes de comenzar a realizar consultas. Si no se han manejado anteriormente
transacciones, estas ofrecen cuatro características principales: Atomicidad, Consistencia,
Aislamiento y Durabilidad (ACID por sus siglas en inglés). En términos sencillos, cualquier
trabajo llevado a cabo en una transacción, incluso si se hace por etapas, se garantiza que será
aplicado a la base de datos de forma segura, y sin interferencia de otras conexiones, cuando sea
consignado ('commit'). El trabajo transaccional puede también ser deshecho automáticamente
bajo petición (siempre y cuando no se haya consignado), lo que hace más sencillo el manejo de
errores en los scripts.
Las transacciones son implementadas típicamente para hacer que el lote de cambios se apliquen
a la vez; esto tiene el buen efecto secundario de mejorar drásticamente la eficiencia de las
actualizaciones. En otras palabras, las transacciones pueden hacer los scripts más rápidos y
potencialmente más robustos (aún así es necesario usarlas correctamente para obtener ese
beneficio).
Desafortunadamente, no todas las bases de datos admiten transacciones, por lo que PDO
necesita ser ejecutado en lo es conocido como el modo "auto-commit" cuando se abra por
primera vez la conexión. El modo auto-commit significa que toda consulta que se ejecute tiene
su propia transacción implícita, si la base de datos lo admite, o ninguna transacción si la base de
datos no las admite. Si fuera necesario el uso de transacciones, se debe usar el
método PDO::beginTransaction() para iniciar una. Si el controlador subyacente no admite
transacciones, se lanzará una PDOException (independientemente de la configuración del
manejo de errores: esto es siempre una condición de error serio). Una vez que se esté en una
transacción, se puede usarPDO::commit() o PDO::rollBack() para finalizarla, dependiendo del
éxito del código que se ejecute durante la transacción.
Advertencia
PDO sólo comprueba las capacidades de la transacción al nivel del controlador. Si una cierta
condición en tiempo de ejecución implica que las transacciones no estén
disponibles, PDO::beginTransaction() seguirá devolviendo TRUE sin ninún error si el
servidor de bases de datos acepta la solicitud de iniciar una transacción.
Un ejemplo de esto podría ser el intentar usar transacciones en tablas MyISAM en una base de
datos MySQL.
Cuando el script finaliza o cuando una conexión está a punto de ser cerrada, si existe una
transacción pendiente, PDO la revertirá automáticamente. Esto es una medida de seguridad que
ayuda a evitar inconsistencia en los casos donde el script finaliza inesperadamente (si no
consignó la transacción, se asume que algo salió mal, con lo cual se realiza la reversión para la
seguridad de los datos).
Advertencia
La reversión automática sólo ocurre si se inicia una transacción a través
dePDO::beginTransaction(). Si se ejecuta manualmente una consulta que inicie una
transacción, PDO no tiene forma de conocer algo acerca de ésta y, por tanto, no puede revertirla
si algo sale mal.
Ejemplo #1 Ejecución de un lote en una transacción
En el siguiente ejemplo, se asume que se ha creado un conjunto de entradas para un nuevo
empleado, al cual se le ha asignado el número de ID 23. Además de introducir los datos básicos
de una persona, también es necesario registrar su sueldo. Es bastante simple hacer dos
actualizaciones independientes, pero encerrándolas en las
llamadas PDO::beginTransaction() y PDO::commit(), se garantiza que nadie más será capaz
de ver los cambios hasta que se hayan completado. Si algo sale mal, el bloque catch revierte los
cambios realizados desde que se creó la transacción, y luego imprime un mensaje de error.
<?php
try {
$gbd = new PDO('odbc:SAMPLE', 'db2inst1', 'ibmdb2',
array(PDO::ATTR_PERSISTENT => true));
echo "Conectado\n";
} catch (Exception $e) {
die("No se pudo conectar: " . $e->getMessage());
}
try {
$gbd->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$gbd->beginTransaction();
$gbd->exec("insert into staff (id, first, last) values (23, 'Joe', 'Bloggs')");
$gbd->exec("insert into salarychange (id, amount, changedate)
values (23, 50000, NOW())");
$gbd->commit();
} catch (Exception $e) {
$gbd->rollBack();
echo "Fallo: " . $e->getMessage();
}
?>
No hay límite en la realización de actualizaciones en una transacción; también es posible
ejecutar consultas complejas para extraer datos, y posiblemente usar esa información para
construir más actualizaciones y consultas; mientras que la transacción esté activa, se garantiza
que nadie más puede realizar cambios mientras se esté en mitad del trabajo. Para más
información sobre transacciones, consulte la documentación proporcionada por su servidor de
base de datos.
add a noteUser Contributed Notes Transacciones y 'auto-commit' - [2 notes]
up
down
2
pasamio at gmail dot com
3 months ago
Typically data definition language clauses (DDL) will trigger the database engine to
automatically commit:
http://dev.mysql.com/doc/refman/5.0/en/implicit-commit.html
Many other databases (e.g. Oracle) will implicitly commit before and after running DDL
statements.
up
down
-1
josh dot ribakoff at gmail dot com
2 years ago
PDO seems to differ from the other mysql libraries in that it will revert to auto-commit
mode if you are issuing certain types of queries on certain drivers (Ex. DROP TABLE)
Sentencias preparadas y procedimientos almacenados
Muchas de las bases de datos más maduras admiten el concepto de sentencias preparadas. Estas
pueden definirse como un tipo de plantillas compiladas para SQL que las aplicaciones quieren
ejecutar, que pueden ser personalizadas usando parámetros de variables. Las sentencias
preparadas ofrecen dos grandes beneficios:
La consulta sólo necesita ser analizada (o preparada) una vez, pero puede ser ejecutada
múltiples veces con los mismos o diferentes parámetros. Cuando la consulta es preparada, la
base de datos analizará, compilará y optimizará su plan para ejecutarla. Para consultas
complejas, este proceso puede tomar suficiente tiempo como para que ralentice notablemente
una aplicación si fuera necesario repetir la misma consulta muchas veces con los mismos
parámetros. Usando una sentencia preparada, la aplicación evita repetir el ciclo de
análisis/compilación/optimización. Esto significa que las sentencias preparadas usan menos
recursos y se ejecutan más rápidamente.
Los parámetros para las sentencias preparadas no necesitan estar entrecomillados; el controlador
automáticamente se encarga de esto. Si una aplicación usa exclusivamente sentencias
preparadas, el desarrollador puede estar seguro de que no ocurrirán inyecciones SQL (sin
embargo, si otras partes de la consulta se construyen con datos de entrada sin escapar, las
inyecciones SQL pueden ocurrir).
Las sentencias preparadas son tan útiles que son la única característica que PDO emulará para
los controladores que no las admitan. Esto asegura que una aplicación sea capaz de usar el
mismo paradigma de acceso a datos independientemente de las capacidades de la base de datos.
Ejemplo #1 Inserciones reiteradas usando sentencias preparadas
Este ejemplo realiza dos consultas de tipo INSERT sustituyendo name y value por los valores
correspondientes.
<?php
$sentencia = $gbd->prepare("INSERT INTO REGISTRY (name, value) VALUES (:nam
e, :value)");
$sentencia->bindParam(':name', $nombre);
$sentencia->bindParam(':value', $valor);
// insertar una fila
$nombre = 'uno';
$vavalorlue = 1;
$sentencia->execute();
// insertar otra fila con diferentes valores
$nombre = 'dos';
$valor = 2;
$stmt->execute();
?>
Ejemplo #2 Inserciones reiteradas usando sentencias preparadas
Este ejemplo realiza dos consultas de tipo INSERT sustituyendo name y value por el
parámetro de sustitución ? posicional.
<?php
$sentencia = $gbd->prepare("INSERT INTO REGISTRY (name, value) VALUES (?, ?)
");
$sentencia->bindParam(1, $nombre);
$sentencia->bindParam(2, $valor);
// insertar una fila
$nombre = 'uno';
$valor = 1;
$sentencia->execute();
// insertar otra fila con diferentes valores
$nombre = 'dos';
$valor = 2;
$sentencia->execute();
?>
Ejemplo #3 Obtener datos usando sentencias preparadas
Este ejemplo obtiene datos basándose en un valor de clave proporcionado por un formulario.
Los datos de usuario son automáticamente entrecomillados, con lo cual no hay riesgo de un
ataque por inyección SQL.
<?php
$sentencia = $gbd->prepare("SELECT * FROM REGISTRY where name = ?");
if ($sentencia->execute(array($_GET['name']))) {
while ($fila = $sentencia->fetch()) {
print_r($fila);
}
}
?>
Si el controlador de la base de datos lo admite, una aplicación podría también vincular
parámetros para salida y para entrada. Los parámetros de salida son típicamente usados para
recuperar valores de procedimientos almacenados. Los parámetros de salida son ligeramente
más complejos de usar que los de entrada, de manera que el desarrollador debe saber lo grande
que podría ser un parámetro dado cuando se vincula. Si el valor resulta ser más grande que el
tamaño que indica, se emitirá un error.
Ejemplo #4 Llamar a un procedimiento almacenado con un parámetro de salida
<?php
$sentencia = $gbd->prepare("CALL sp_returns_string(?)");
$sentencia->bindParam(1, $valor_devuleto, PDO::PARAM_STR, 4000);
// llamar al procedimiento almacenado
$sentencia->execute();
print "El procedimiento devolvió $valor_devuleto\n";
?>
Los desarrolladores podrían también especificar parámetros que contienen valores tanto de
entrada como de salida; la sintaxis es similar a la de los parámetros de salida. En el siguiente
ejemplo, la cadena 'hola' es pasada al procedimiento almacenado, y cuando éste finaliza, 'hola'
es reemplazada con el valor de retorno del procedimiento.
Ejemplo #5 Llamar a un procedimiento almacenado con un parámetro de
entrada/salida
<?php
$sentencia = $gbd->prepare("CALL sp_takes_string_returns_string(?)");
$valor = 'hola';
$sentencia->bindParam(1, $valor, PDO::PARAM_STR|
PDO::PARAM_INPUT_OUTPUT, 4000);
// llamar al procedimiento almacenado
$sentencia->execute();
print "procedure returned $valor\n";
?>
Ejemplo #6 Uso inválido de un parámetro de sustitución
<?php
$sentencia = $gbd->prepare("SELECT * FROM REGISTRY where name LIKE '%?%'");
$sentencia->execute(array($_GET['name']));
// los parámetros de sustitución deben usarse en el lugar del valor completo
$sentencia = $gbd->prepare("SELECT * FROM REGISTRY where name LIKE ?");
$sentencia->execute(array("%$_GET[name]%"));
?>
Errores y su manejo Transacciones y 'auto-commit'
[edit] Last updated: Fri, 25 Jan 2013
add a noteUser Contributed Notes Sentencias preparadas y procedimientos
almacenados - [5 notes]
up
down
7
adam at pyramidpower dot com dot au
2 years ago
Note that when using name parameters with bindParam, the name itself, cannot
contain a dash '-'.
example:
<?php
$stmt = $dbh->prepare ("INSERT INTO user (firstname, surname) VALUES (:f-
name, :s-name)");
$stmt -> bindParam(':f-name', 'John');
$stmt -> bindParam(':s-name', 'Smith');
$stmt -> execute();
?>
The dashes in 'f-name' and 's-name' should be replaced with an underscore or no dash
at all.
See http://bugs.php.net/43130
Adam
up
down
1
oldmoscow dot mail dot ru
2 years ago
Note for MySQL: to use input/output parameters for stored procedures with PDO use
PDO.Query() statement.
For example:
<?php
$dbh->query("CAST
SomeStoredProcedure($someInParameter1, $someInParameter2,
@someOutParameter)");
$dbh->query("SELECT @someOutParameter");
?>
Or, if you want very much to use PDO.Prepare(), insert "SELECT
@someOutParameter" in your stored procedure and then use:
<?php
$stmt = $dbh->prepare("CAST SomeStoredProcedure(?, ?)");
$stmt ->execute(array($someInParameter1, $someInParameter2));
?>
up
down
1
Anonymous
2 years ago
Note for MySQL: to use input/output parameters for stored procedures with PDO use
PDO.Query() statement.
For example:
<?php
$dbh->query("CAST
SomeStoredProcedure($someInParameter1, $someInParameter2,
@someOutParameter)");
$dbh->query("SELECT @someOutParameter");
?>
Or, if you want very much to use PDO.Prepare(), insert "SELECT
@someOutParameter" in your stored procedure and then use:
<?php
$stmt = $dbh->prepare("CAST SomeStoredProcedure(?, ?)");
$stmt ->execute(array($someInParameter1, $someInParameter2));
?>
up
down
0
mackwic at gmail dot com
3 years ago
You have to make attention to the parameters send to the method.
We can imagine that a request like that can work:
<?php
$query = 'SELECT ? FROM ? WHERE id = ?';
?>
But in fact, it's a hijack of prepared query, which MUST be used *ONLY* to change the
condition (here the last '?' ).
You do not send my_table.my_row or my_scheme.my_table because this parameters
are essentials to optimize the query before execution.
Other thing: prepared query can not be serialized to reuse it some time later. For that
you can use a mask (http://fr2.php.net/singleton)
A prepared query is temporary.
up
down
-4
frame at dynamiccreated dot de
4 months ago
Keep in mind, after creating a table on same driver instance you should re-create your
prepared statement too.
If you will not do you will get a nice message "database schema has changed" with
error code "00000" which indicates that is not an error but it is - at least working with
SQlite no data is returned on SELECT-clause.
Errores y su manejo
PDO ofrece tres estrategias diferentes de manejar errores, para adaptarse a su estilo de
desarrollo de aplicaciones.
PDO::ERRMODE_SILENT
Este es el modo predeterminado. PDO simplemente establecerá él mismo el código de error para
su inspección usando los métodos PDO::errorCode() y PDO::errorInfo() tanto en objetos de
sentencias como de bases de datos. Si el error resultó de una llamada sobre un objeto de
sentencia, se deberá invocar al
método PDOStatement::errorCode() o PDOStatement::errorInfo() sobre dicho objeto. Si el
error resultó de una llamada sobre un objeto de bases de datos, se deberá invocar, en su lugar, a
los métodos del objeto de bases de datos.
PDO::ERRMODE_WARNING
Además de establecer el código de error, PDO emitirá un mensaje E_WARNING tradicional.
Esta configuración es útil durante la depuración o las pruebas, si lo que se quiere es ver qué
problemas han ocurrido, sin interrumpir el flujo de la aplicación.
PDO::ERRMODE_EXCEPTION
Además de establecer el código de error, el PDO lanzará una excepción de
tipo PDOException y establecerá sus propiedades para reflejar el error y la información del
mismo. Esta configuración también es útil durante la depuración, ya que, de hecho, señalará el
lugar del error del script, apuntando a áreas pontencialmente problemáticas del código
(recuerde: las transacciones son automáticamente revertidas si la excepción causa que finalice el
script).
El modo 'Exception' también es útil porque se puede estructurar el manejo de errores con más
claridad que con el estilo tradicional de advertencias de PHP, y con menos código/anidación que
con la ejecución en modo silencioso y comprobando explícitamente el valor devuelto de cada
llamada a la base de datos.
Véase la referencia de Excepciones para más información sobre Excepciones en PHP.
PDO utiliza el estándar de cadenas de códigos de error SQLSTATE de SQL-92; cada
controlador de PDO es responsable de hacer que correspondan su códigos nativos con los
códigos SQLSTATE apropiados. El métodoPDO::errorCode() devuelve un único código
SQLSTATE. Si fuera necesaria más información específica sobre el error, PDO también ofrece
el método PDO::errorInfo(), que devuelve un array que contiene el código SQLSTATE, el
código de error específico del controlador, y la cadena de error específica.
Ejemplo #1 Crear una instancia de PDO y establecer el modo de error
<?php
$dsn = 'mysql:dbname=testdb;host=127.0.0.1';
$usuario = 'usuario';
$contraseña = 'contraseña';
try {
$gbd = new PDO($dsn, $usuario, $contraseña);
$gbd->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (PDOException $e) {
echo 'Falló la conexión: ' . $e->getMessage();
}
?>
Objetos grandes (LOBs)
En algún punto de una aplicación, podría ser necesario almacenar datos "grandes" en la base de
datos. Grande típicamente significa "alrededor de 4kb o más", aunque algunas bases de datos
pueden manejar fácilmente hasta 32kb antes de que los datos se consideren "grandes". Los
LOBs (acrónimo de 'Large Objects') pueden ser de texto o binarios. PDO permite trabajar con
este tipo de datos grandes usando el código del tipoPDO::PARAM_LOB en llamadas
a PDOStatement::bindParam() o PDOStatement::bindColumn(). PDO::PARAM_LOBin
dica a PDO que haga corresponder los datos como un flujo, por lo que se pueden manipular
usando la API de flujos de PHP.
Ejemplo #1 Mostrar una imagen desde una base de datos
Este ejemplo vincula un LOB a una variable llamada $lob, y luego lo envía al navegador
usando fpassthru(). Ya que el LOB está representado como un flujo, se pueden usar funciones
tales como fgets(), fread() ystream_get_contents() para manejarlo.
<?php
$bd = new PDO('odbc:SAMPLE', 'db2inst1', 'ibmdb2');
$sentencia = $bd->prepare("select contenttype, imagedata from images where id=?");
$sentencia->execute(array($_GET['id']));
$sentencia->bindColumn(1, $tipo, PDO::PARAM_STR, 256);
$sentencia->bindColumn(2, $lob, PDO::PARAM_LOB);
$sentencia->fetch(PDO::FETCH_BOUND);
header("Content-Type: $tipo");
fpassthru($lob);
?>
Ejemplo #2 Insertar una imagen en una base de datos
Este ejemplo abre un fichero y pasa el gestor del fichero a PDO para insertarlo como un LOB.
PDO hará todo lo posible para enviar el contenido del fichero a la base de datos de la manera
más eficiente.
<?php
$bd = new PDO('odbc:SAMPLE', 'db2inst1', 'ibmdb2');
$sentencia = $bd->prepare("insert into images (id, contenttype, imagedata) values (?,
?, ?)");
$id = get_new_id(); // alguna función para asignar un nuevo ID
// se asume que se está ejecutando como parte de un formulario de subidas de fichero
s
// Se puede encontrar más información en la documentación de PHP
$fp = fopen($_FILES['file']['tmp_name'], 'rb');
$sentencia->bindParam(1, $id);
$sentencia->bindParam(2, $_FILES['file']['type']);
$sentencia->bindParam(3, $fp, PDO::PARAM_LOB);
$bd->beginTransaction();
$sentencia->execute();
$bd->commit();
?>
Ejemplo #3 Insertar una imagen en una base de datos: Oracle
Oracle requiere una sintaxis ligeramente diferente para insertar un LOB desde un fichero.
También es esencial que se realice la inserción bajo una transacción, si no, el LOB recién
insertado será consignado con una longitud cero como parte de la consigna implícita que ocurre
cuando la consulta se ejecuta:
<?php
$bd = new PDO('oci:', 'scott', 'tiger');
$sentencia = $bd->prepare("insert into images (id, contenttype, imagedata) " .
"VALUES (?, ?, EMPTY_BLOB()) RETURNING imagedata INTO ?");
$id = get_new_id(); // alguna función para asignar un nuevo ID
// se asume que se está ejecutando como parte de un formulario de subidas de fichero
s
// Se puede encontrar más información en la documentación de PHP
$fp = fopen($_FILES['file']['tmp_name'], 'rb');
$sentencia->bindParam(1, $id);
$sentencia->bindParam(2, $_FILES['file']['type']);
$sentencia->bindParam(3, $fp, PDO::PARAM_LOB);
$sentencia->beginTransaction();
$sentencia->execute();
$sentencia->commit();
?>
PDO Errores y su manejo
[edit] Last updated: Fri, 25 Jan 2013
add a noteUser Contributed Notes Objetos grandes (LOBs) - [5 notes]
up
down
1
diogoko at gmail dot com
3 years ago
PDOStatement's methods bindParam and bindValue also work with strings, as in:
<?php
$data = file_get_contents($filename);
$stmt->bindValue(1, $data, PDO::PARAM_LOB);
//...
?>
This was the only way I could make it work with PostgreSQL.
up
down
0
xorinox at gmx dot ch
2 years ago
I find it easier to use stream_get_contens to fetch the data of a lob using the file
handle.
<?php
$stmt = $pdo->con->prepare( 'select * from filetable' );
$stmt->execute();
$res = $stmt->fetchAll( PDO::FETCH_ASSOC );
for( $i=0; $i<count($res); $i++ ){
$filename = "C:/tmp/".$res[$i]['FILE_ID'].'.xml';
$content = stream_get_contents( $res[$i]['DATA_FILE'] );
file_put_contents( $filename, $content );
}
?>
up
down
0
Jeremy Cook
2 years ago
There seems to be a bug that affects example 1 above. PDO::PARAM_LOB when
used with pdo::bindColumn() is supposed to return a stream but it returns a string.
Passing this string to fpassthru() then triggers an error with the message 'supplied
argument is not a valid stream resource'. This has been reported in bug #40913. The
work around is to do the following:
<?php
$stmt = $db->prepare("select contenttype, imagedata from images where id=?");
$stmt->execute(array($_GET['id']));
$stmt->bindColumn(1, $type, PDO::PARAM_STR, 256);
$stmt->bindColumn(2, $lob, PDO::PARAM_LOB);
$stmt->fetch(PDO::FETCH_BOUND);
header("Content-Type: $type");
echo($lob);
?>
Since the browser is expecting an image after the call to header() writing the string
representation of the binary output with echo() has the same affect as calling
fpassthru().
up
down
0
http://matts.org/
3 years ago
A big gotcha exists for Oracle users.
You have to save CLOB objects using PDO::PARAM_STR, not PDO::PARAM_LOB.
But you MUST send the 4th argument, usually strlen($subject) or you get a LONG
error.
up
down
0
knl at bitflop dot com
4 years ago
I spend a lot of time trying to get this to work, but no matter what I did PDO corrupted
my data.
I finally discovered that I had been using:
$pdo->exec('SET CHARACTER SET utf8');
in the TRY part of my connection script.
This off course doesn't work when you feed binary input to PDO using the parameter
lob.
La clase PDO
(PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
Introducción
Representa una conexión entre PHP y un servidor de bases de datos.
Sinopsis de la Clase
PDO {
__construct ( string $dsn [, string $username [, string $password [, array $driver_option
s ]]] )
bool beginTransaction ( void )
bool commit ( void )
mixed errorCode ( void )
array errorInfo ( void )
int exec ( string $statement )
mixed getAttribute ( int $attribute )
static array getAvailableDrivers ( void )
bool inTransaction ( void )
string lastInsertId ([ string $name = NULL ] )
PDOStatement prepare ( string $statement [, array $driver_options = array() ] )
PDOStatement query ( string $statement )
string quote ( string $string [, int $parameter_type = PDO::PARAM_STR ] )
bool rollBack ( void )
bool setAttribute ( int $attribute , mixed $value )
}
Tabla de contenidos
PDO::beginTransaction — Inicia una transacción
PDO::commit — Consigna una transacción
PDO::__construct — Crea una instancia de PDO que representa una conexión a una base de
datos
PDO::errorCode — Obtiene un SQLSTATE asociado con la última operación en el manejador
de la base de datos
PDO::errorInfo — Obtiene información extendida del error asociado con la última operación
del manejador de la base de datos
PDO::exec — Ejecuta una sentencia SQL y devuelve el número de filas afectadas
PDO::getAttribute — Devuelve un atributo de la conexión a la base de datos
PDO::getAvailableDrivers — Devuelve un array con los controladores de PDO disponibles
PDO::inTransaction — Comprueba si una transacción está activa
PDO::lastInsertId — Devuelve el ID de la última fila o secuencia insertada
PDO::prepare — Prepara una sentencia para su ejecución y devuelve un objeto sentencia
PDO::query — Ejecuta una sentencia SQL, devolviendo un conjunto de resultados como un
objeto PDOStatement
PDO::quote — Entrecomilla una cadena de caracteres para usarla en una consulta
PDO::rollBack — Revierte una transacción
PDO::setAttribute — Establece un atributo
PDO::beginTransaction Objetos grandes (LOBs)
[edit] Last updated: Fri, 25 Jan 2013
add a noteUser Contributed Notes PDO - [6 notes]
up
down
1
RockMeAmadeus
2 years ago
PDO::getAvailableDrivers is the only PDO static method so it needs a double colon.
The other PDO methods are used by an object, so they should use the -> syntax.
* PDO->beginTransaction — Initiates a transaction
* PDO->commit — Commits a transaction
* PDO->__construct — Creates a PDO instance representing a connection to a
database
* PDO->errorCode — Fetch the SQLSTATE associated with the last operation on
the database handle
* PDO->errorInfo — Fetch extended error information associated with the last
operation on the database handle
* PDO->exec — Execute an SQL statement and return the number of affected rows
* PDO->getAttribute — Retrieve a database connection attribute
* PDO::getAvailableDrivers — Return an array of available PDO drivers
* PDO->lastInsertId — Returns the ID of the last inserted row or sequence value
* PDO->prepare — Prepares a statement for execution and returns a statement
object
* PDO->query — Executes an SQL statement, returning a result set as a
PDOStatement object
* PDO->quote — Quotes a string for use in a query.
* PDO->rollBack — Rolls back a transaction
* PDO->setAttribute — Set an attribute
up
down
3
schizo_mind at hotmail dot com
4 years ago
<?php
class PDOConfig extends PDO {
private $engine;
private $host;
private $database;
private $user;
private $pass;
public function __construct(){
$this->engine = 'mysql';
$this->host = 'localhost';
$this->database = '';
$this->user = 'root';
$this->pass = '';
$dns = $this->engine.':dbname='.$this->database.";host=".$this->host;
parent::__construct( $dns, $this->user, $this->pass );
}
}
?>
up
down
0
Megaloman
3 years ago
"And storing username/password inside class is not a very good idea for production
code."
Good idea is to store database connection settings in *.ini files but you have to restrict
access to them. For example this way:
my_setting.ini:
[database]
driver = mysql
host = localhost
;port = 3306
schema = db_schema
username = user
password = secret
Database connection:
<?php
class MyPDO extends PDO
{
public function __construct($file = 'my_setting.ini')
{
if (!$settings = parse_ini_file($file, TRUE)) throw new exception('Unable to open ' .
$file . '.');
$dns = $settings['database']['driver'] .
':host=' . $settings['database']['host'] .
((!empty($settings['database']['port'])) ? (';port=' . $settings['database']['port']) :'') .
';dbname=' . $settings['database']['schema'];
parent::__construct($dns, $settings['database']['username'], $settings['database']
['password']);
}
}
?>
Database connection parameters are accessible via human readable ini file for those
who screams even if they see one PHP/HTML/any_other command.
up
down
0
kcleung at kcleung dot no-ip dot org
2 years ago
Here is an singleton PDO example:
###### config.ini ######
db_driver=mysql
db_user=root
db_password=924892xp
[dsn]
host=localhost
port=3306
dbname=localhost
[db_options]
PDO::MYSQL_ATTR_INIT_COMMAND=set names utf8
[db_attributes]
ATTR_ERRMODE=ERRMODE_EXCEPTION
############
<?php class Database {
private static $link = null ;
private static function getLink ( ) {
if ( self :: $link ) {
return self :: $link ;
}
$ini = _BASE_DIR . "config.ini" ;
$parse = parse_ini_file ( $ini , true ) ;
$driver = $parse [ "db_driver" ] ;
$dsn = "${driver}:" ;
$user = $parse [ "db_user" ] ;
$password = $parse [ "db_password" ] ;
$options = $parse [ "db_options" ] ;
$attributes = $parse [ "db_attributes" ] ;
foreach ( $parse [ "dsn" ] as $k => $v ) {
$dsn .= "${k}=${v};" ;
}
self :: $link = new PDO ( $dsn, $user, $password, $options ) ;
foreach ( $attributes as $k => $v ) {
self :: $link -> setAttribute ( constant ( "PDO::{$k}" )
, constant ( "PDO::{$v}" ) ) ;
}
return self :: $link ;
}
public static function __callStatic ( $name, $args ) {
$callback = array ( self :: getLink ( ), $name ) ;
return call_user_func_array ( $callback , $args ) ;
}
} ?>
<?php // examples
$stmt = Database :: prepare ( "SELECT 'something' ;" ) ;
$stmt -> execute ( ) ;
var_dump ( $stmt -> fetchAll ( ) ) ;
$stmt -> closeCursor ( ) ;
?>
up
down
-1
williambarry007 at gmail dot com
1 year ago
PDO and Dependency Injection
Dependency injection is good for testing. But for anyone wanting various data mapper
objects to have a database connection, dependency injection can make other model
code very messy because database objects have to be instantiated all over the place
and given to the data mapper objects.
The code below is a good way to maintain dependency injection while keeping clean
and minimal model code.
<?php
class DataMapper
{
public static $db;
public static function init($db)
{
self::$db = $db;
}
}
class VendorMapper extends DataMapper
{
public static function add($vendor)
{
$st = self::$db->prepare(
"insert into vendors set
first_name = :first_name,
last_name = :last_name"
);
$st->execute(array(
':first_name' => $vendor->first_name,
':last_name' => $vendor->last_name
));
}
}
// In your bootstrap
$db = new PDO(...);
DataMapper::init($db);
// In your model logic
$vendor = new Vendor('John', 'Doe');
VendorMapper::add($vendor);
?>
up
down
-1
anrdaemon at freemail dot ru
4 years ago
Keep in mind, you MUST NOT use 'root' user in your applications, unless your
application designed to do a database maintenance.
And storing username/password inside class is not a very good idea for production
code. You would need to edit the actual working code to change settings, which is bad.
La clase PDOStatement
(PHP 5 >= 5.1.0, PECL pdo >= 1.0.0)
Introducción
Representa una sentencia preparada y, después de la ejecución de la instrucción, un conjuntos
de resultados asociado.
Sinopsis de la Clase
PDOStatement implements Traversable {
/* Propiedades */
readonly string $ queryString ;
/* Métodos */
bool bindColumn ( mixed $column , mixed &$param [, int $type [, int $maxlen [, mixed
$driverdata]]] )
bool bindParam ( mixed $parameter , mixed &$variable [, int $data_type =
PDO::PARAM_STR [, int$length [, mixed $driver_options ]]] )
bool bindValue ( mixed $parameter , mixed $value [, int $data_type =
PDO::PARAM_STR ] )
bool closeCursor ( void )
int columnCount ( void )
bool debugDumpParams ( void )
string errorCode ( void )
array errorInfo ( void )
bool execute ([ array $input_parameters ] )
mixed fetch ([ int $fetch_style [, int $cursor_orientation =
PDO::FETCH_ORI_NEXT [, int$cursor_offset = 0 ]]] )
array fetchAll ([ int $fetch_style [, mixed $fetch_argument [, array $ctor_args =
array() ]]] )
string fetchColumn ([ int $column_number = 0 ] )
mixed fetchObject ([ string $class_name = "stdClass" [, array $ctor_args ]] )
mixed getAttribute ( int $attribute )
array getColumnMeta ( int $column )
bool nextRowset ( void )
int rowCount ( void )
bool setAttribute ( int $attribute , mixed $value )
bool setFetchMode ( int $mode )
}
Propiedades
queryString
La cadena de consulta utilizada.
Tabla de contenidos
PDOStatement::bindColumn — Vincula una columna a una variable de PHP
PDOStatement::bindParam — Vincula un parámetro al nombre de variable especificado
PDOStatement::bindValue — Vincula un valor a un parámetro
PDOStatement::closeCursor — Cierra un cursor, habilitando a la sentencia para que sea
ejecutada otra vez
PDOStatement::columnCount — Devuelve el número de columnas de un conjunto de
resultados
PDOStatement::debugDumpParams — Vuelca un comando preparado de SQL
PDOStatement::errorCode — Obtiene el SQLSTATE asociado con la última operación del
gestor de sentencia
PDOStatement::errorInfo — Obtiene información ampliada del error asociado con la última
operación del gestor de sentencia
PDOStatement::execute — Ejecuta una sentencia preparada
PDOStatement::fetch — Obtiene la siguiente fila de un conjunto de resultados
PDOStatement::fetchAll — Devuelve un array que contiene todas las filas del conjunto de
resultados
PDOStatement::fetchColumn — Devuelve una única columna de la siguiente fila de un
conjunto de resultados
PDOStatement::fetchObject — Obtiene la siguiente fila y la devuelve como un objeto
PDOStatement::getAttribute — Recupera un atributo de sentencia
PDOStatement::getColumnMeta — Devuelve metadatos de una columna de un conjunto de
resultados
PDOStatement::nextRowset — Avanza hasta el siguiente conjunto de filas de un gestor de
sentencia multiconjunto de filas
PDOStatement::rowCount — Devuelve el número de filas afectadas por la última sentencia
SQL
PDOStatement::setAttribute — Establece un atributo de sentencia
PDOStatement::setFetchMode — Establece el modo de obtención para esta sentencia
add a noteUser Contributed Notes PDOStatement - [2 notes]
up
down
0
Dmitri Snytkine
1 year ago
It looks like cloning PDOStatement object does not make any sense because while
clone($sth) will not generate any errors, the returned object is not a new object but a
reference to original PDOStatement object $sth.
up
down
0
rosko at zeta dot org dot au
3 years ago
There are many references around for returning a refcursor from a pgSQL function
using pg_query. All essentially boil down to executing the following single statement (or
some variation of it):
begin; select yourFunction(params...); fetch all in cursorname; commit;
In PDO, this doesn't work because PDO won't allow multiple statements submitted as a
single statement (due to SQL injection detection). Instead, try this or similar:
<?php
$sql = 'select yourFunction(params...)';
$db = new PDO('pgsql:dbname=yourDBname');
$db->beginTransaction();
$cmd = $db->prepare($sql);
if ($cmd->execute()) {
if ($query = $db->query('fetch all in cursorname')) {
...processing...
$query->closeCursor();
$cmd->closeCursor();
}
}
$db->commit();
?>
La clase PDOException
(PHP 5 >= 5.1.0)
Introducción
Representa un error generado por PDO. No se debería lanzar una PDOException desde el
código. VéaseExcepciones para más información acerca de las excepciones en PHP.
Sinopsis de la Clase
PDOException extends RuntimeException {
/* Propiedades */
public array $ errorInfo ;
protected string $ message ;
protected string $ code ;
/* Métodos heredados */
final public string Exception::getMessage ( void )
final public Exception Exception::getPrevious ( void )
final public mixed Exception::getCode ( void )
final public string Exception::getFile ( void )
final public int Exception::getLine ( void )
final public array Exception::getTrace ( void )
final public string Exception::getTraceAsString ( void )
public string Exception::__toString ( void )
final private void Exception::__clone ( void )
}
Propiedades
errorInfo
Corresponde a PDO::errorInfo() o PDOStatement::errorInfo()
message
Mensaje de error textual. Exception::getMessage() para acceder a él.
code
Código de error de SQLSTATE. Utilice Exception::getCode() para acceder a él.
Controladores de PDO PDOStatement::setFetchMode
[edit] Last updated: Fri, 25 Jan 2013
add a noteUser Contributed Notes PDOException - [3 notes]
up
down
0
Marco01_809 "at" web "dot" de
2 years ago
This is a PDOException Error handler for Using/Debugging in Web Browser.
<?php
echo '<html><head><title>PHP PDO Tests</title></head><body>';
// Try the following code:
try {
$db = new PDO('sqlite:database.sdb'); // Create a new PDO Object
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); // Set
Errorhandling to Exception
$db->query("BlaBlaBla"); // Query something wrong
$db = null; // "Disconnect"
}
catch (PDOException $err) {
// Catch Expcetions from the above code for our Exception Handling
$trace = '<table border="0">';
foreach ($err->getTrace() as $a => $b) {
foreach ($b as $c => $d) {
if ($c == 'args') {
foreach ($d as $e => $f) {
$trace .= '<tr><td><b>' . strval($a) . '#</b></td><td
align="right"><u>args:</u></td> <td><u>' . $e . '</u>:</td><td><i>' . $f . '</i></td></tr>';
}
} else {
$trace .= '<tr><td><b>' . strval($a) . '#</b></td><td
align="right"><u>' . $c .'</u>:</td><td></td><td><i>' . $d . '</i></td>';
}
}
}
$trace .= '</table>';
echo '<br /><br /><br /><font face="Verdana"><center><fieldset style="width: 66%;
border: 4px solid white; background: black;"><legend><b>[</b>PHP PDO Error
' . strval($err->getCode()) . '<b>]</b></legend> <table border="0"><tr><td
align="right"><b><u>Message:</u></b></td><td><i>' . $err-
>getMessage() . '</i></td></tr><tr><td
align="right"><b><u>Code:</u></b></td><td><i>' . strval($err-
>getCode()) . '</i></td></tr><tr><td
align="right"><b><u>File:</u></b></td><td><i>' . $err->getFile() . '</i></td></tr><tr><td
align="right"><b><u>Line:</u></b></td><td><i>' . strval($err-
>getLine()) . '</i></td></tr><tr><td align="right"><b><u>Trace:</u></b></td><td><br
/><br />' . $trace . '</td></tr></table></fieldset></center></font>';
}
echo '</body></html>';
?>
up
down
0
samuelelliot+php dot net at gmail dot com
2 years ago
PDOException has two methods for retrieving information about an error. When
interpreting the PDOException I run into a problem, the error code that is provided by
getCode() is meaningless. I have come up with a method to make both the error code
and message more usable.
A bad username or password would normally provide the following:
CODE : 0
Message : "SQLSTATE[28000] [1045] Access denied for user 'user'@'example.com'
(using password: YES)"
Using my extended exception class provides:
CODE: "28000"
Message: "Access denied for user 'user'@'example.com' (using password: YES)"
<?php
class pdoDbException extends PDOException {
public function __construct(PDOException $e) {
if(strstr($e->getMessage(), 'SQLSTATE[')) {
preg_match('/SQLSTATE\[(\w+)\] \[(\w+)\] (.*)/', $e->getMessage(), $matches);
$this->code = ($matches[1] == 'HT000' ? $matches[2] : $matches[1]);
$this->message = $matches[3];
}
}
}
?>
To walk threw the method; first the beginning of the message is checked for the
SQLSTATE text. If the text is present, message is then parsed to pull the ANSI code,
the SQL specific code, and the message. The parsed values are stored in there
respective variables. The error code variable stores the ANSI code, unless ANSI is
'HT000' (unmapped error code) then SQL specific code is used.
Using this class is easy; when interacting with PDO use a try catch set of blocks, as
follows:
<?php
try {
$pdo = new PDO($dns, $username, $password, $options);
} catch (PDOException $e) {
throw new pdoDbException($e);
}
?>
Now you can use the normal error methods to retrieve the real error code and
message.
<?php
echo $err->getCode(); // Outputs: "28000"
echo $err->getMessage(); // Outputs: "Access denied for user 'user'@'example.com'
(using password: YES)"
?>
If you decide to use this code, be aware that the error code is a string (as apposed to
PHP standard errors which are integers) as some error codes are alphanumeric.
up
down
0
Typer85 at gmail dot com
3 years ago
Here is something interesting regarding a PDOException and it involves some of the
annoyances that can be associated with PHP's dynamic nature.
PDOException extends from RuntimeException, which in return extends from
Exception. As such, it has access to the $code Protected Class Variable, which
represents the Exception's code as an Integer (duh!) and can be accessed externally
using the Exception::getCode Method.
Here is the interesting part. PDOException actually redefines $code as a String and not
an Integer because for its case, $code actually contains the Exception's SQL State,
which is composed of characters and numbers.
It is actually documented in the manual that $code is a String and not an Integer but it
might not be immedietley clear because it is hidden by the fact that
PDOException::getCode is documented to return an Integer and not a String!
Some developers like to catch a PDOException and rethrow it as a different Exception
if they wrap their database calls in an external library. For example, consider the
following code:
<?php
try {
$PDO = new PDO( '...' ); // PDO Driver DSN. Throws A PDOException.
}
catch( PDOException $Exception ) {
// PHP Fatal Error. Second Argument Has To Be An Integer, But
PDOException::getCode Returns A
// String.
throw new MyDatabaseException( $Exception->getMessage( ) , $Exception-
>getCode( ) );
}
?>
Be careful in that you have to typecast the value returned by PDOException::getCode
to an Integer BEFORE you pass it as an Argument to your Exception's Constructor.
The following will work:
<?php
try {
$PDO = new PDO( '...' ); // PDO Driver DSN. Throws A PDOException.
}
catch( PDOException $Exception ) {
// Note The Typecast To An Integer!
throw new MyDatabaseException( $Exception->getMessage( ) , (int)$Exception-
>getCode( ) );
}
?>
Hope this will save some developers some frustrating hours from an otherwise
enjoyable job :)
Good Luck,
Funciones de CUBRID (PDO_CUBRID)
Introducción
PDO_CUBRID es un controlador que implementa la interfaz de Objetos de Datos de PHP
(PDO) para habilitar el acceso desde PHP a bases de datos de CUBRID.
Nota:
Por ahora, la versión actual de PDO_CUBRID no admite conexiones persistentes.
Instalación
Para construir la extensión PDO_CUBRID, CUBRID DBMS debe estar instalado en el mismo
sistema donde se ejecute PHP. PDO_CUBRID es una extensión » PECL , por lo que se han de
seguir las instrucciones dadas enInstalación de extensiones PECL para instalar la extensión
PDO_CUBRID. Ejecute el comando configure para indicar la ubicación del directorio base de
CUBRID de la siguiente manera:
$ ./configure --with-pdo-cubrid=/path/to/CUBRID[,shared]
El valor predeterminado del comando configure es el de la variable de entorno de CUBRID.
Actualmente, no hay ninguna DLL disponible para esta extensión PECL. Véase también la
sección Compilar en Windows . Para información detallada sobre la instalación manual en
Linux y Windows, por favor lea build-guide.html en el paquete PECL CUBRID para obtener
referencias.
Características
Características de PDO_CUBRID
Característica Descripción
Cursores
desplazables
PDO_CUBRID admite cursores desplazables. El tipo de cursor predeterminado es de sólo
avance, y se puede usar el parámetro driver_options de PDO::prepare() para cambiar el tipo de
cursor.
Tiempo de esperaPDO_CUBRID admite la configuracion del tiempo de espera de las ejecuciones de sentencias
SQL; Se puede utilizar PDO::setAttribute() para establecer el valor del tiempo de espera.
Autocommit_mode y
transacciones
PDO_CUBRID admite autocommit_mode y transacciones, y autocommit_mode está
deshabilitado por omisión. Se puede usar PDO::setAttribute() para cambiar su estado.
Si se usa PDO::beginTransaction() para iniciar una transacción, se desactivará
autocommit_mode automaticamente y PDO::rollBack(). Obsérvese que antes de deshabilitar
Características de PDO_CUBRID
Característica Descripción
autocommit_mode, cualquier trabajo pendiente es consignado automáticamente.
Sentencias SQL
múltiples
PDO_CUBRID admite sentencias SQL múltiples. Las sentencias SQL múltiples están
serparadas por puntos y comas (;)
Información del
esquema
PDO_CUBRID implementa la función PDO::cubrid_schema() para obtener la información del
esquema.
LOBs
PDO_CUBRID admite los tipos de datos BLOB/CLOB. El tipo LOB en PDO es representado
como un flujo, por lo que pueden insertarse LOBs vinculando un flujo, y obtener LOBs leyendo
de un flujo devuelto por CUBRID PDO. Por ejemplo:
Ejemplo #1 Insertar LOBs en CUBRID PDO
<?php
$fp = fopen('lob_test.png', 'rb');
$sent_sql = "INSERT INTO lob_test(name, content) VALUES('lob_test.png', ?)";
$sentencia = $dbh->prepare($sent_sql);
$ret = $sentencia->bindParam(1, $fp, PDO::PARAM_LOB);
$ret = $sentencia->execute();
?>
Ejemplo #2 Obtener LOBs en CUBRID PDO
<?php
$sent_sql = "SELECT content FROM lob_test WHERE name='lob_test.png'";
$sentencia = $dbh->prepare($sent_sql);
$sentencia->execute();
$resultado = $sentencia->fetch(PDO::FETCH_NUM);
header("Content-Type: image/png");
fpassthru($resultado[0]);
?>
Metadatos de
columna
La función PDOStatement::getColumnMeta() de CUBRID PDO devolverá un array
Características de PDO_CUBRID
Característica Descripción
asociativo que contiene los siguientes valores:
type
name
table
def
precision
scale
not_null
auto_increment
unique_key
multiple_key
primary_key
foreign_key
reverse_index
reverse_unique
Constantes predefinidas
Estas constantes están definidas por este controlador, y estarán disponibles sólo cuando la
extensión haya sido compilada con PHP, o bien sea cargada dinámicamente en ejecución.
Además, estas constantes específicas del controlador deberían ser utilizadas sólo si está usando
este controlador. Usar atributos específicos del controlador con otro controlador podría resultar
en un comportamiento inesperado. PDO::getAttribute() puede ser empleado para obtener el
atributo PDO_ATTR_DRIVER_NAME para verificar el controlador, si el código puede
ejecutarse con múltiples controladores.
Las siguientes constantes se puden usar al establecer el atributo de la base de datos. Se puede
pasar aPDO::getAttribute() o a PDO::setAttribute().
Banderas de atributo de PDO::CUBRID
Constante Descripción
PDO::CUBRID_ATTR_ISOLATION_LEVELNivel de aislamiento de las transacciones
para la conexión de la base de datos.
PDO::CUBRID_ATTR_LOCK_TIMEOUT Tiempo de espera de las transacciones en
Banderas de atributo de PDO::CUBRID
Constante Descripción
segundos.
PDO::CUBRID_ATTR_MAX_STRING_LENGTH
Sólo lectura. La longitud máxima de
cadena para los diversos tipos de datos
bit, varbit, char, varchar, nchar, nchar al
utilizar la API de CUBRID PDO.
Las siguientes constantes se puden usar al estableder el nivel de aislamiento de las
transacciones. Se pueden pasar a PDO::getAttribute() o ser devueltas
por PDO::setAttribute().
Banderas de nivel de aislamiento de PDO::CUBRID
Constante Descripción
PDO::TRAN_COMMIT_CLASS_UNCOMMIT_INSTANCE
El nivel de aislamiento más
bajo (1). Podría ocurrir una
lectura sucia, no repetible o
fantasma para la tupla, y puede
ocurrir también una lectura no
repetible para la tabla.
PDO::TRAN_COMMIT_CLASS_COMMIT_INSTANCE
Un nivel relativamente bajo de
aislamiento (2). No ocurre una
lectura sucia, pero podría
ocurrir una lectura no repetible
o fantasma.
PDO::TRAN_REP_CLASS_UNCOMMIT_INSTANCE
El nivel predeterminado de
aislamiento de CUBRID (3).
Podría ocurrir una lectura
sucia, no repetible o fantasma
para la tupla, pero se garantiza
una lectura repetible para la
tabla.
PDO::TRAN_REP_CLASS_COMMIT_INSTANCE Un nivel relativamente bajo de
Banderas de nivel de aislamiento de PDO::CUBRID
Constante Descripción
aislamiento (4). No ocurre una
lectura sucia, pero sí podría
ocurrir una lectura no repetible
o fantasma.
PDO::TRAN_REP_CLASS_REP_INSTANCE
Un nivel de aislamiento
relativamente alto (5). No
ocurre una lectura sucia o no
repetible, pero sí podría ocurrir
una lectura fantasma.
PDO::TRAN_SERIALIZABLE
El nivel de aislamiento más
alto (6). No ocurren los
problemas concernientes a la
concurrencia (p.ej. lectura
sucia, no repetible, fantasma,
etc.).
Las siguientes constantes se pueden usar al obtener la información del esquema. Se pueden
pasar aPDO::cubrid_schema().
Banderas de esquema de PDO::CUBRID
Constante Descripción
PDO::CUBRID_SCH_TABLEObtener el nombre y el tipo de tabla de
CUBRID.
PDO::CUBRID_SCH_VIEWObtener el nombre y el tipo de vista de
CUBRID.
PDO::CUBRID_SCH_QUERY_SPECObtener la definición de la consulta de la
vista.
PDO::CUBRID_SCH_ATTRIBUTEObtener los atributos de la columnas de la
tabla.
PDO::CUBRID_SCH_TABLE_ATTRIBUTE Obtener los atributos de la tabla.
Banderas de esquema de PDO::CUBRID
Constante Descripción
PDO::CUBRID_SCH_METHOD
Obtener el método de instancia. El método
de instancia es un método invocado por
una instancia de clase. Se usa más a
menudo que el método de la clase, ya que
se ejecutan más operaciones en la
instancia.
PDO::CUBRID_SCH_TABLE_METHOD
Obtener el método de la clase. El método
de la clase es un método invocado por un
objeto de clase. Se usa normalmente para
crear una nueva instancia de clase o para
inicializarla. También se usa para acceder o
actualizar los atributos de la clase.
PDO::CUBRID_SCH_METHOD_FILEObtener la información del fichero donde
el método de la tabla está definido.
PDO::CUBRID_SCH_SUPER_TABLEObtener el nombre y el tipo de la tabla
desde la que se heredan atributos.
PDO::CUBRID_SCH_SUB_TABLEObtener el nombre y el tipo de la tabla que
hereda los atributos desde esta tabla.
PDO::CUBRID_SCH_CONSTRAINT Obtener las restricciones de la tabla.
PDO::CUBRID_SCH_TRIGGER Obtener los disparadores de la tabla.
PDO::CUBRID_SCH_TABLE_PRIVILEGEObtener la información de privilegios de la
tabla.
PDO::CUBRID_SCH_COL_PRIVILEGEObtener la información de los privilegios
de la columna.
PDO::CUBRID_SCH_DIRECT_SUPER_TABLE Obtener la super tabla directa de la tabla.
PDO::CUBRID_SCH_PRIMARY_KEY Obtener la clave primaria de la tabla.
Banderas de esquema de PDO::CUBRID
Constante Descripción
PDO::CUBRID_SCH_IMPORTED_KEYS Obtener las claves importadas de la tabla.
PDO::CUBRID_SCH_EXPORTED_KEYS Obtener las claves exportadas de la tabla.
PDO::CUBRID_SCH_CROSS_REFERENCEObtener la relación de referencia de las
tablas a remolque.
Tabla de contenidos
DSN de PDO_CUBRID — Conectar con bases de datos de CUBRID
PDO::cubrid_schema — Obtiene la información del esquema solicitada
Funciones de Microsoft SQL Server y Sybase (PDO_DBLIB)
Introducción
Advertencia
Esta extensión es EXPERIMENTAL. Esto significa que el comportamiento de esta extensión,
los nombres de sus funciones y todo lo documentado sobre esta extensión, puede cambiar en
una futura edición de PHP sin previo aviso. El uso de esta extensión queda bajo su propia
responsabilidad.
PDO_DBLIB es un controlador que implementa la interfaz de objetos de datos de PHP
(PDO) para habilitar el acceso desde PHP a bases de datos de Microsoft SQL Server y Sybase a
través de la biblioteca FreeTDS.
Esta ya extensión no está disponible para Windows con PHP 5.3 o posterior.
En Windows, se debería de usar SqlSrv, un controlador alternativo para MS SQL que está
disponible desde Microsoft: » http://msdn.microsoft.com/en-us/sqlserver/ff657782.aspx .
Si no fuera posible usar SqlSrv, se puede utilizar el controlador PDO_ODBC para conectarse a
bases de datos de Microsoft SQL Server y Sybase, ya que la biblioteca Windows DB-LIB nativa
está anticuado, no es seguro con subprocesos y Microsoft ya no le proporciona soporte.
Tabla de contenidos
PDO_DBLIB DSN — Conectarse a bases de datos de Microsoft SQL Server y Sybase
PDO_DBLIB DSN PDO::cubrid_schema
[edit] Last updated: Fri, 25 Jan 2013
add a noteUser Contributed Notes MS SQL Server (PDO) - [14 notes]
up
down
0
twilson at tridiumtech dot com
3 years ago
Hopefully this will help someone who is having problems connecting to MSSQL. I was
having a heck of a time trying to get my dev server to connect to a remote MSSQL
2005 box.
When using PDO like so:
<?php
$mssql = new PDO('dblib:host=<host>;dbname=<dbname>','<user>','<password>');
?>
I was receiving the message:
Adaptive Server is unavailable or does not exist
And mssql_connect() simply told me "Could not connect to server"
I tried everything, different configuration options for FreeTDS/PHP, different versions,
etc. But the answer was one line in php.ini:
mssql.secure_connection = Off
This line, which defaults to Off, needs to be ON if you are using NT authentication:
mssql.secure_connection = On
Here is my build:
FreeTDS-0.82 configured like:
./configure --with-tdsver=8.0 --enable-msdblib --with-gnu-ld
PHP 5.2.11 configured like:
./configure --with-mssql=/usr/local --with-pdo-dblib=/usr/local [other options]
Running on Apache/2.2.13 (Unix / Linux)
Feel free to email me if you need help as I've spent 20+ hours reading and fiddling with
this issue, so I'm very familiar with it now.
Peace,
Tom
up
down
0
ian at helastel dot com
6 months ago
For people with issues inserting UTF-8 / Unicode data using DBLIB, you can't do this
natively - but you can workaround the problem by converting the data first.
e.g. inserting into a nvarchar column with collation Latin1_General_CI_AS
...
$res = $db->prepare($sql);
$res->bindValue(':value', iconv('UTF-8', 'ISO8859-1', $value);
...
up
down
0
TomF
1 year ago
Note that you must connect with an MS SQL user - FreeTDS does not seem to like
active directory linked users.
up
down
0
meltir at meltir dot com
2 years ago
Keep in mind the limitation sql server imposes on clients using the connection methods
that dblib uses:
no ntext column values can be transmitted, you will get an insightfull '4004' error when
trying.
The full text of the error is:
Unicode data in a Unicode-only collation or ntext data cannot be sent to clients using
DB-Library (such as ISQL) or ODBC version 3.7 or earlier.
For more info on errors that mssql might throw at you, please see:
http://msdn.microsoft.com/en-us/library/aa937595%28v=SQL.80%29.aspx
up
down
0
xwisdom at gmail dot com
2 years ago
Here's how to call a stored procedure from MS SQL Server:
<?php
$return = null;
$param1 = 'value1';
$param2 = 'value2';
$ds = $db->prepare('{? = call ?,?}');
$ds->bindParam(1, $return, PDO::PARAM_INT | PDO::PARAM_INPUT_OUTPUT,4);
$ds->bindParam(2, $param1, PDO::PARAM_INT | PDO::PARAM_INPUT_OUTPUT,4);
$ds->bindParam(3, $param2, PDO::PARAM_INT | PDO::PARAM_INPUT_OUTPUT,4);
$ds->execute();
?>
up
down
0
dpassey at everettsd dot org
3 years ago
For PDO MSSQL connection issues, ensure that you have the updated version of
ntwdblib.dll (currently 8.00.194 as of this post). Overwrite the existing (old) file or place
it in the Windows system32 folder. The version that ships with PHP 5.2.X does not
work. This is a well known issue apparently, but I had a really hard time finding
information on this issue until I was able to lock in a file name. I hope that this helps
someone.
up
down
0
tris+php at tfconsulting dot com dot au
3 years ago
If you are struggling with
'Unicode data in a Unicode-only collation or ntext data cannot be sent to clients using
DB-Library (such as ISQL) or ODBC version 3.7 or earlier.'
when trying to do 'SELECT *' queries:
Obviously the best way to deal with this is change your unicode fields to the ascii
equivalent (ntext > text), but if that is not an option here is an implementation based on
the info athttp://www.rochester.edu/IT/web/WebHelp/mssql/limitations.html which
checks the data types of the fields and casts them as neccesary.
<?php
class mssql {
private static $statement=null;
private static $typemap=array(
'ntext' => 'text',
'bigint' => 'real',
'decimal' => 'real',
'float' => 'real',
'numeric' => 'real'
);
public static function all_fields($table) {
if(self::$statement==null) {
$db=pdodb::instance(); // or however you get your global instance
$query="SELECT COLUMN_NAME, DATA_TYPE FROM
INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME=?";
self::$statement=$db->prepare($query);
}
self::$statement->execute(array($table));
$fields=array();
$need_cast=false;
while($field=self::$statement->fetch()) {
$field_quoted=self::quote_field($field['COLUMN_NAME']);
if(isset(self::$typemap[$field['DATA_TYPE']])) {
$fields[]='CAST('.$field_quoted.' AS '.self::$typemap[$field['DATA_TYPE']].')
AS '.$field_quoted;
$need_cast=true;
} else $fields[]=$field_quoted;
}
return ($need_cast) ? implode(', ',$fields) : '*';
}
public static function quote_field($field) {
$pos=strpos($field,' ');
return ($pos===false) ? $field : '['.$field.']';
}
}
$db=pdodb:instance(); // singleton PDO instance
$stmt=$db->prepare('SELECT '.mssql::all_fields('My_Table').' FROM My_Table');
$stmt->execute();
...
?>
Essentially mssql::all_fields($table) returns '*' if it can, otherwise the fields listed with
the relevant casts in place e.g. 'NoteIdent, Owner, CAST(Note AS text) AS Note'
up
down
0
Bryan
4 years ago
To enable the mssql PDO driver under windows you need to:
1) uncomment the "extension=php_pdo_mssql.dll" line from php.ini
2) copy ntwdblib.dll into the directory where you have installed php
up
down
0
mrshelly at hotmail dot com
4 years ago
to connect MS SQL2005(DE) sample code:
notice:
if u used MSSQL 2005 EXPRESS, must set the instence name 'SQLEXPRESS'
just like
$hostname='127.0.0.1\SQLEXPRESS';
<?php
try {
$hostname = "host"; //host
$dbname = "dbname"; //db name
$username = "user"; // username like 'sa'
$pw = "pass"; // password for the user
$dbh = new PDO ("mssql:host=$hostname;dbname=$dbname","$username","$pw");
} catch (PDOException $e) {
echo "Failed to get DB handle: " . $e->getMessage() . "\n";
exit;
}
$stmt = $dbh->prepare("SELECT * FROM table");
$stmt->execute();
while ($row = $stmt->fetch()) {
print_r($row);
}
unset($dbh); unset($stmt);
?>
up
down
0
Steve H
6 years ago
To connect to SQL Server 2005 Express on Windows, do it like this:
$pdo = new PDO ('mssql:host=localhost,1433;dbname=[redacted]', '[redacted]',
'[redacted]');
localhost
localhost\SQLEXPRESS
localhost\1433
localhost:1433
will not work on Windows.
localhost,1433
does work.
YMMV on other OS's; try each.
Also make sure your TCP/IP Properties -> IP Addresses are correct under SQL Server
Configuration Manager.
up
down
0
support at converters dot ru
7 years ago
If You work with MSSQL Server 7.0/2000/... under Windows and use non latin
Encoding then better To use PDO_MSSQL until PDO_ODBC bugs will be fixed
(MSSQL ext far more stable and usabe for PHP versions <=5.1.2).
If your MSSQL connection use strings in OEM encoding (cp866 for russian charset)
1. Run Microsoft Server/Client Network Utility on work PC and UNCHECK "DBLibrary
options"/"Automatic ANSI to OEM conversion"
2. Restart Web server if needed.
up
down
0
graham1 dot simpson at hsbcib dot com
7 years ago
There is currently little sybase related PDO docs out there. The ones that I found often
mention a spec for a dsn that is invalid. Here's how I am currently connecting to sybase
ASE:
1. Compile up freetds http://www.freetds.org on top of open client;
2. Add the PDO and PD_DBLIB modules to php 5 as per the documentation; Note: I'm
currently using the PDO-beta and PDO_DBLIB-beta;
3. Check mods installed ok using "pear list" and "php -m";
The documentation often says to use "sybase:" as your DSN, this doesn't work. Use
"dblib:" instead. Here's an example:
<?php
try {
$hostname = "myhost";
$port = 10060;
$dbname = "tempdb";
$username = "dbuser";
$pw = "password";
$dbh = new PDO ("dblib:host=$hostname:
$port;dbname=$dbname","$username","$pw");
} catch (PDOException $e) {
echo "Failed to get DB handle: " . $e->getMessage() . "\n";
exit;
}
$stmt = $dbh->prepare("select name from master..sysdatabases where name =
db_name()");
$stmt->execute();
while ($row = $stmt->fetch()) {
print_r($row);
}
unset($dbh); unset($stmt);
?>
Hope this helps.
up
down
-1
Matej
2 years ago
How to use mssql pdo on PHP 5.3 on IIS 7 (Windows Server 2008)
1. Installation of MSSQL driver for PHP:
Download Microsoft Drivers for PHP for SQL Server Microsoft Drivers for PHP for SQL
Server - SQLSRV20.EXE - http://www.microsoft.com/downloads/en/details.aspx
?FamilyID=80e44913-24b4-4113-8807-caae6cf2ca05)
Copy php_sqlsrv_53_ts_vc9.dll and php_pdo_sqlsrv_53_ts_vc9.dll to php extension
directory
2. configure php.ini to work with MSSQL PDO
extension=php_sqlsrv_53_ts_vc9.dll
extension=php_pdo_sqlsrv_53_ts_vc9.dll
3. configure configuration
'connectionString' =>
'sqlsrv:server=hostname_or_ip;Database=database_name;',
Funciones de Firebird/Interbase (PDO_FIREBIRD)
Introducción
PDO_FIREBIRD es un controlador que imlementa la interfaz de Objetos de datos de PHP
(PDO) para habilitar el acceso desde PHP a bases de datos de Firebird e Interbase.
Instalación
Use --with-pdo-firebird[=DIR] para instalar la extensión PDO Firebird, donde [=DIR] es el
directorio base de intalación de Firebird.
$ ./configure --with-pdo-firebird
Constantes predefinidas
Estas constantes están definidas por este controlador, y estarán disponibles sólo cuando la
extensión haya sido compilada con PHP, o bien sea cargada dinámicamente en ejecución.
Además, estas constantes específicas del controlador deberían ser utilizadas sólo si está usando
este controlador. Usar atributos específicos del controlador con otro controlador podría resultar
en un comportamiento inesperado. PDO::getAttribute() puede ser empleado para obtener el
atributo PDO_ATTR_DRIVER_NAME para verificar el controlador, si el código puede
ejecutarse con múltiples controladores.
PDO::FB_ATTR_DATE_FORMAT (integer)
Establece el formato de fecha.
Disponible desde PHP 5.3.0.
PDO::FB_ATTR_TIME_FORMAT (integer)
Establece el formato de hora.
Disponible desde PHP 5.3.0.
PDO::FB_ATTR_TIMESTAMP_FORMAT (integer)
Establece el formato de marca de tiempo.
Disponible desde PHP 5.3.0.
Tabla de contenidos
PDO_FIREBIRD DSN — Conectarse a bases de datos de Firebird e Interbase
PDO_FIREBIRD DSN PDO_DBLIB DSN
[edit] Last updated: Fri, 25 Jan 2013
add a noteUser Contributed Notes Firebird/Interbase (PDO) - [6 notes]
up
down
1
ritsaert at continuit dot nl
7 years ago
The connection string for a firebird PDO connection is different than described above. It
is something like:
$DB = new PDO("firebird:dbname=T:\\Klimreg.GDB", "SYSDBA", "masterkey");
after dbname= the default connection string for Interbase and Firebird databases is
used as presented to either gds32.dll or fbclient.dll.
up
down
0
confik at gmail dot com
1 year ago
Here's the quick guide how to compile pdo_firebird and run tests for the ubuntu:
1) setup firebird superclassic:
$ sudo apt-get install firebird2.5-superclassic firebird2.5-dev
firebird2.5-examples
superclassic is the server itself (if in doubt, read
this:http://www.firebirdsql.org/file/documentation/reference_manuals/user_manuals/
html/qsg25-classic-or-super.html), dev package contains headers to
compile pdo stuff, examples contains example db, i used it to run
tests in it.
Set up credentials for the server (see the link lower).
Get employee.fdb as written here
http://www.firebirdsql.org/manual/ubusetup.html to a some known and
writable path by your user (which tests will be run on).
2) make sure to compile php with following flags, you'll need interbase too (some
tests in pdo_firebird/tests need it)
./configure --enable-pdo --with-pdo-firebird --with-interbase
make
3) Run tests with environment variables that can be found in
ext/pdo_firebird/tests/common.phpt, I ran it like this:
$ PDO_FIREBIRD_TEST_DSN='firebird:dbname=/var/lib/firebird/2.5/data/
employee.fdb'
PDO_FIREBIRD_TEST_USER='SYSDBA' PDO_FIREBIRD_TEST_PASS='masterkey'
TEST_PHP_EXECUTABLE=auto php -n ./run-tests.php ext/pdo_firebird
You're done!
up
down
0
mark-php at vectrex dot org dot uk
5 years ago
If you have a database alias on the server "localhost" called "test.fdb", you can do:
$conn = new PDO("firebird:dbname=localhost:test.fdb",
'SYSDBA','letmein');
Note that as of the time of writing, the Firebird driver doesn't correctly throw an
exception on connection error
http://bugs.php.net/bug.php?id=41522
up
down
0
Darren
6 years ago
After much trial and error i found out you should use the following to connect to a
firebird database:
<?php
$db = new PDO ("firebird:dbname=localhost:C:\\path\\to\\database\\
MyDatabase.FDB","username", "password");
?>
NOTE: in the 1st part of the connection string there can be NO spaces else you will get
NULL.
The string provided on this site does not work and will give no error only NULL.
up
down
0
thomas at last-it dot de
6 years ago
if youre dsn syntax is wrong, see ritsaert's comment, there maybe no errormessage!
up
down
-1
Anonymous
3 months ago
After two days of trouble with no visibile issues, when rebooting the system two popups
come up:
PHP Startup: Unable to load dynamic library
'c:/wamp/bin/php/php.5.3.13/ext/php_interbase.dll' - %1 non è un'applicazione di Win32
valida.
PHP Startup: Unable to load dynamic library
'c:/wamp/bin/php/php.5.3.13/ext/php_pdo_firebird.dll' - %1 non è un'applicazione di
Win32 valida.
I've just re-installed wampserver (http://www.wampserver.com/en/) and all seems run
well.
To see if your Firebird PDO driver runs well:
<?php
foreach(PDO::getAvailableDrivers() as $driver) {
echo $driver.'<br />';
}?>
Funciones de IBM (PDO_IBM)
Introducción
PDO_IBM es un controlador que implementa la interfaz de Objetos de datos de PHP
(PDO) para habilitar el acceso desde PHP a bases de datos de IBM.
Instalación
Para construir la extensión PDO_IBM, DB2 Client v9.1 o posterior debe estar instalado en el
mismo sistema que PHP. DB2 Client se puede descargar Desde el » Sitio de desarrollo de
aplicaciones de IBM.
Nota: Nota
DB2 Client v9.1 o posterior da soporte al acceso directo de DB2 para servidores Linux, UNIX,
y Windows v8 y v9.1.
DB2 Client v9.1 también da soporte para el acceso a DB2 UDB para i5 y DB2 UDB para
servidores z/OS utilizando la adquisición por separada del producto » DB2 Connect .
PDO_IBM es una extensión » PECL , por lo que siga las instrucciones en Instalación de
extensiones PECL para instalar la extensión PDO_IBM. Ejecute el comando configure para
que apunte a la ubicación de los ficheros de cabecera y a las bibliotecas de DB2 como sigue:
bash$ ./configure --with-pdo-ibm=/path/to/sqllib[,shared]
El valor predeterminado de configure es la variables de entorno DB2DIR.
Tabla de contenidos
DSN de PDO_IBM — Conectarse a bases de datos de IBM
Funciones de Informix (PDO_INFORMIX)
Introducción
PDO_INFORMIX es un controlador que implementa la interfaz de Objetos de datos de PHP
(PDO) para habilitar el acceso desde PHP a bases de datos de Informix.
Instalación
Para construir la extensión PDO_INFORMIX, Informix Client SDK 2.81 UC1 o superior debe
estar instalado en el mismo sistema que PHP. Informix Client SDK está disponible desde
el » Sitio de soporte de Informix de IBM .
PDO_INFORMIX es una extensión » PECL , por lo que siga las instrucciones en Instalación
de extensiones PECLpara instalar la extensión PDO_INFORMIX. Ejecute el
comando configure para que apunte a la ubicación de los ficheros de cabecera y las bibliotecas
de Informix Client SDK como sigue:
bash$ ./configure --with-pdo-informix=/path/to/SDK[,shared]
El valor predetermiando de configure es la variable de entorno INFORMIXDIR.
Cursores desplazables
PDO_INFORMIX admite los cursores desplazables; sin embargo, estos no están habilitados de
forma predeterminada. Para habilitar el soporte de cursores desplazables, se debe
establecerENABLESCROLLABLECURSORS=1 en los ajustes de conexión de ODBC
correspondientes en odbc.ini, o pasar la cláusula EnableScrollableCursors=1 en la cadena
de conexión de DSN.
Tabla de contenidos
DSN de PDO_INFORMIX — Conectarse a bases de datos de Informix
DSN de PDO_INFORMIX DSN de PDO_IBM
[edit] Last updated: Fri, 25 Jan 2013
add a noteUser Contributed Notes Informix (PDO) - [5 notes]
up
down
0
rdutan at aplext dot com
10 months ago
tip: in fedora 16 you must set INFORMIXDIR in /etc/sysconfig/httpd
example:
INFORMIXDIR=/home/informix
export INFORMIXDIR
up
down
0
dan at mutagenix dot org
3 years ago
I've just built PHP 5.2.11 with pdo_informix support on Slackware 13.0. I had to use
the following options in order to disable pdo from being compiled in (notice the
difference in the --without-pdo-sqlite option from previous post):
--disable-pdo option --without-pdo-sqlite option
I also could not use the --with-sigchild option which caused problems with phpize.
This fixed the informix -11001 error that I was getting. I was also getting an informix -
23101 error (something about locale mismatches), but it was because I was not
completely removing the compiled in pdo support.
I then had to;
rm -rf /usr/lib/php/.channels
pear update-channels
pecl install --alldeps pdo_informix pdo_mysql pdo_sqlite.
There were other, smaller issues, but that is the lion's share.
up
down
0
cwgraven at gmail dot com
4 years ago
I noticed that SQLite is installed by php by default...oh and it happens to use PDO. So
dont forget to use --without-sqlite.
My successful config looks like this:
./configure --with-mysql --with-apxs=/usr/local/apache/bin/apxs --with-curl --with-xsl --
disable-pdo --without-sqlite
up
down
0
dbeecher at tekops dot com
4 years ago
Solved the issue with PHP 5.2.4 and others.
The embedded PDO in php since 5.1+ is INCOMPATIBLE with the latest PDO_MYSQL
and PDO_INFORMIX, etc. I just spent 2 days working on this. This solution works on
numerous versions of Linux I've tried as well as SunOS and HPUX.
The basic issue, getting this message when running PHP with PDO and trying
to get PDO_INFORMIX working, but having a version conflict:
"PHP Fatal error: PDO: driver informix requires PDO API version 20060409;
this is PDO version 20060511 in Unknown on line 0"
The "embedded" PDO that is within PHP since version 5.1 CONFLICTS with the
PDO the PEAR/PECL modules are expecting.
1) Rebuild PHP with no pdo (--disable-pdo) (and you can't have
any stuff like --with-mysql-pdo, either)
2) Then use PEAR/PECL to install PDO: pear install pdo
3) then use PEAR/PECL to install PDO_INFORMIX:
pear install --alldeps pdo_informix
4) make sure your php.ini extensions_dir points to the directory
where these are placed
5) then add these references to php.ini:
extensions=pdo.so
extensions=pdo_informix.so
extensions=pdo_mysql.so (etc.)
6) run php -v now and you should not see any errors.
7) run "pear list" and "pecl list" to see the installed modules
8) run php -i |egrep "pdo|PDO" to see:
php -i |egrep "pdo|PDO"
Configure Command => './configure' '--disable-pdo'
'--with-apxs2=/usr/local/apache2/bin/apxs' '--with-openssl=/usr'
'--enable-force-cgi-redirect' '--with-gd' '--with-jpeg-dir=/usr/lib'
'--with-zlib' '--enable-bcmath' '--enable-mbstring=all' '--with-curl'
PDO
PDO support => enabled
PDO drivers => mysql, informix
pdo_informix
pdo_informix support => enabled
pdo_mysql
PDO Driver for MySQL, client library version => 5.0.51a
I would have tried the embedded PDO and then also --with-informix-pdo=shared but as
an earlier post here showed, the --with-informix... is unknown. Please correct my
mistake if I am mistyping it.
GOOD LUCK!
David
up
down
0
alan dot acosta at gps dot com dot co
5 years ago
Take care, with php-5.2.4 --with-pdo-informix=shared,/home/informix
doesn't work, just says:
Notice: Following unknown configure options were used:
--with-pdo-informix=shared,/home/informix
Funciones de MySQL (PDO_MYSQL)
Introducción
PDO_MYSQL es un controlador que implementa la interfaz de Objetos de Datos de PHP
(PDO) para permitir el acceso de PHP a bases de datos de MySQL 3.x, 4.x y 5.x.
PDO_MYSQL aprovechará el soporte nativo de sentencias preparadas presente en MySQL 4.1
y superior. Si se utiliza una versión anterior de las bibliotecas cliente de MySQL, PDO las
emulará.
Advertencia
Algunos tipos de tablas (motores de almacenamiento) de MySQL no admiten transacciones.
Cuando se escribe código de base de datos transaccional usando un tipo de tabla que no soporta
transacciones, MySQL aparentará que se inició una transacción éxito. Además, cualquier
consulta DDL ejecutada consignará implícitamente cualquier transacción pendiente.
Instalación
Utilice --with-pdo-mysql[=DIR] para instalar la extensión PDO MySQL, donde la
opción [=DIR] es el directorio base de la instalación de MySQL. Si a [=DIR] se le
pasa mysqlnd, entonces será utilizado el controlador nativo de MySQL.
Opcionalmente, --with-mysql-sock[=DIR] establece la ubicación del puntero del socket de
unix de MySQL para todas las extensiones de MySQL, incluyendo PDO_MYSQL. Si no se
especifica, se buscará en las ubicaciones predeterminadas.
Opcionalmente, --with-zlib-dir[=DIR] se utiliza para establecer la ruta para el prefijo de
instalación de libz.
$ ./configure --with-pdo-mysql --with-mysql-sock=/var/mysql/mysql.sock
El soporte para SSL se habilita mediante las constantes de PDO_MySQL apropiadas, lo cual
es equivalente a llamar a la » función mysql_ssl_set() de la API en C de MySQL .
Asimismo, SSL no se puede habilitar conPDO::setAttribute, debido a que la conexión ya
existe. Véase también la documentación de MySQL sobre» conectarse a MySQL con SSL .
Historial de cambios
Versión Descripción
5.4.0 Ya no se da soporte a las librerías cliente de MySQL 4.1 y anteriores.
5.3.9 Agregado el soporte para SSL con mysqlnd y OpenSSL.
5.3.7 Agregado el soporte para SSL con libmysql y OpenSSL.
Constantes predefinidas
Estas constantes están definidas por este controlador, y estarán disponibles sólo cuando la
extensión haya sido compilada con PHP, o bien sea cargada dinámicamente en ejecución.
Además, estas constantes específicas del controlador deberían ser utilizadas sólo si está usando
este controlador. Usar atributos específicos del controlador con otro controlador podría resultar
en un comportamiento inesperado. PDO::getAttribute() puede ser empleado para obtener el
atributo PDO_ATTR_DRIVER_NAME para verificar el controlador, si el código puede
ejecutarse con múltiples controladores.
MYSQL_ATTR_USE_BUFFERED_QUERY (integer)
Si este atributo es definido como TRUE en PDOStatement, el controlador de MySQL
usará las versiones de la API de MySQL guardadas en el búfer. Si se está escribiendo
código portable, en su lugar se debería usar PDOStatement::fetchAll().
Ejemplo #1 Forzar consultas para que sean guardadas en el búfer en mysql
<?php
if ($bs->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql') {
$sentencia = $bs->prepare('select * from foo',
array(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true));
} else {
die("mi aplicación sólo funciona con mysql; debería usar \$sentencia->fetchAll() en s
u lugar");
}
?>
MYSQL_ATTR_LOCAL_INFILE (integer)
Activa LOAD LOCAL INFILE.
Se ha de tener en cuenta que esta constante se puede usar solamente en el
array driver_optionscuando se construye un nuevo gestor de base de datos.
MYSQL_ATTR_INIT_COMMAND (integer)
Comando a ejecutar cuando se conecta al servidor MySQL. Al reconectar se volverá a ejecutar
automáticamente.
Se ha de tener en cuenta que esta constante se puede usar solamente en el
array driver_optionscuando se construye un nuevo gestor de base de datos.
MYSQL_ATTR_READ_DEFAULT_FILE (integer)
Lee las opciones desde el fichero indicado en lugar de my.cnf. Si se usa mysqlnd, esta opción
no está disponible debido a que mysqlnd no lee los fichero de configuración de mysql.
MYSQL_ATTR_READ_DEFAULT_GROUP (integer)
Opciones de lectura del grupo indicado desde my.cnf o desde el fichero especificado
conMYSQL_READ_DEFAULT_FILE. Si se usa mysqlnd, esta opción no está disponible
debido a que mysqlnd no lee los ficheros de configuración de mysql.
MYSQL_ATTR_MAX_BUFFER_SIZE (integer)
Tamaño máximo del búfer. Lo predeterminado es MiB. Esta constante no está admitida cuando
se compila para mysqlnd.
MYSQL_ATTR_DIRECT_QUERY (integer)
Realiza consultas directas, no usa setencias preparadas.
MYSQL_ATTR_FOUND_ROWS (integer)
Devuelve el número de filas encontradas (coindicentes), no el número de filas modificadas.
MYSQL_ATTR_IGNORE_SPACE (integer)
Permite espacios después de los nombres de función. Hace de todos los nombres de función
palabras reservadas.
MYSQL_ATTR_COMPRESS (integer)
Activa la compresión de comunicación de red. Esta constante no está admitida cuando se
compila para mysqlnd.
MYSQL_ATTR_SSL_CA (integer)
La ruta al fichero de la autoridad certificadora SSL.
Existe a partir de PHP 5.3.7.
MYSQL_ATTR_SSL_CAPATH (integer)
La ruta al directorio que contiene los certificados AC SSL autorizados, los cuales están
almacenados en formato PEM.
Existe a partir de PHP 5.3.7.
MYSQL_ATTR_SSL_CERT (integer)
La ruta al fichero del certificado SSL.
Existe a partir de PHP 5.3.7.
MYSQL_ATTR_CIPHER (integer)
Una lista de uno o más cifradores permisibles a usar para la encriptación SSL, en un formato
entendido por OpenSSL. Por ejemplo: DHE-RSA-AES256-SHA:AES128-SHA
Existe a partir de PHP 5.3.7.
MYSQL_ATTR_KEY (integer)
La ruta al fichero de la clave SSL.
Existe a partir de PHP 5.3.7.
Configuración en tiempo de ejecución
El comportamiento de estas funciones se ve afectado por la configuración de php.ini.
Opciones de configuración de PDO_MYSQL
Nombre Por defecto Cambiable
pdo_mysql.default_socket "/tmp/mysql.sock" PHP_INI_SYSTEM
pdo_mysql.debug NULL PHP_INI_SYSTEM
Para más detalles y definiciones de los modos de PHP_INI_*, vea Dónde se puede realizar
un ajuste de configuración.
He aquí una breve explicación de las directivas de configuración.
pdo_mysql.default_socket string
Establece un socket de dominio Unix. Este valor se puede establecer en tiempo de compilación
si un socket de dominio se encuentra en la configuración. Este ajuste ini es sólo de Unix.
pdo_mysql.debug boolean
Activa la depuración de PDO_MYSQL. Este ajuste solo está disponible cuando PDO_MYSQL
está compilado para mysqlnd y en el modo de depuración de PDO.
Tabla de contenidos
PDO_MYSQL DSN — Conectarse a bases de datos de MySQL
PDO_MYSQL DSN DSN de PDO_INFORMIX
[edit] Last updated: Fri, 25 Jan 2013
add a noteUser Contributed Notes MySQL (PDO) - [11 notes]
up
down
1
david at manifestwebdesign dot com
1 year ago
The SSL options are silently ignored in PHP 5.3.8, see https://bugs.php.net/bug.php?
id=55870
Looks like it's addressed upstream, I just want to save others the hour and a half I just
wasted :)
up
down
1
curt at webmasterbond dot com
1 year ago
Today's PHP snapshot now has SSL support for PDO. Follow the directions here
(http://dev.mysql.com/doc/refman/5.0/en/secure-create-certs.html ) to set up MySQL
and then use the following connection options:
<?php
$pdo = new PDO(
'mysql:host=hostname;dbname=ssldb',
'username',
'password',
array(
PDO::MYSQL_ATTR_SSL_KEY =>'/path/to/client-key.pem',
PDO::MYSQL_ATTR_SSL_CERT=>'/path/to/client-cert.pem',
PDO::MYSQL_ATTR_SSL_CA =>'/path/to/ca-cert.pem'
)
);
?>
up
down
1
brian at diamondsea dot com
4 years ago
SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other
unbuffered queries are active. ...
After spending hours trying to track down why we were getting this error on a new
server, after the same code ran fine on other servers, we found the problem to be an
old MySQL _client_ library running on our web server, and a latest-version MySQL
_server_ running on the database server's box.
Upgraded the MySQL client on the web server to the current revision and the problem
went away.
up
down
1
konrads dot smelkovs at gmail dot com
5 years ago
A note for the eager:
There is no way how to get returned row count from an executed prepared statement
without fetching the rows.
up
down
1
davey at php dot net
5 years ago
To use "PDO::MYSQL_ATTR_USE_BUFFERED_QUERY" you should call
PDO::setAttribute("PDO::MYSQL_ATTR_USE_BUFFERED_QUERY", true);
It will not work when passed into PDO::prepare()
- Davey
up
down
1
dibakar at talash dot net
6 years ago
PDO is much better option for calling procedures, views or triggers of mysql 5.x
versions from PHP instead of using mysqli extension. Following is a simple demo script
which can help anybody on how to call and use mysql procedures through php
try {
$dbh = new PDO('mysql:host=xxx;port=xxx;dbname=xxx', 'xxx', 'xxx',
array( PDO::ATTR_PERSISTENT => false));
$stmt = $dbh->prepare("CALL getname()");
// call the stored procedure
$stmt->execute();
echo "<B>outputting...</B><BR>";
while ($rs = $stmt->fetch(PDO::FETCH_OBJ)) {
echo "output: ".$rs->name."<BR>";
}
echo "<BR><B>".date("r")."</B>";
} catch (PDOException $e) {
print "Error!: " . $e->getMessage() . "<br/>";
die();
}
up
down
0
miller_kurt_e at yahoo dot com
4 years ago
SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other
unbuffered queries are active. ...
This one can be a royal pain to deal with. Never stack statements to be executed in
one go. Nobody ever mentions this possibility in all the posts I've seen dealing with
this error.
This example is a Zend Framework example but the theory is the same.
As in:
<?php
$sql = <<<____SQL
CREATE TABLE IF NOT EXISTS `ticket_hist` (
`tid` int(11) NOT NULL,
`trqform` varchar(40) NOT NULL,
`trsform` varchar(40) NOT NULL,
`tgen` datetime NOT NULL,
`tterm` datetime,
`tstatus` tinyint(1) NOT NULL
) ENGINE=ARCHIVE COMMENT='ticket archive';
CREATE TABLE IF NOT EXISTS `request_hist` (
`rqid` int(11) NOT NULL,
`rqtid` int(11) NOT NULL,
`rqsid` int(11) NOT NULL,
`rqdate` datetime NOT NULL,
`rqcode` tinyint(1) NOT NULL,
`rssid` int(11) NOT NULL,
`rsdate` datetime,
`rscode` tinyint(1)
) ENGINE=ARCHIVE COMMENT='request archive';
CREATE TABLE IF NOT EXISTS `relay_hist` (
`rqid` int(5) NOT NULL,
`sdesc` varchar(40) NOT NULL,
`rqemail` varchar(40) NOT NULL,
`sid` int(11) NOT NULL,
`rlsid` int(11) NOT NULL,
`dcode` varchar(5) NOT NULL
) ENGINE=ARCHIVE COMMENT='relay archive';
____SQL;
$result = $this->db->getConnection()->exec($sql);
?>
This will run fine but PDO will balk with the 'unbuffered' error if you follow this with
another query.
Instead do:
<?php
$sql = <<<____SQL
CREATE TABLE IF NOT EXISTS `ticket_hist` (
`tid` int(11) NOT NULL,
`trqform` varchar(40) NOT NULL,
`trsform` varchar(40) NOT NULL,
`tgen` datetime NOT NULL,
`tterm` datetime,
`tstatus` tinyint(1) NOT NULL
) ENGINE=ARCHIVE COMMENT='ticket archive';
____SQL;
$result = $this->db->getConnection()->exec($sql);
$sql = <<<____SQL
CREATE TABLE IF NOT EXISTS `request_hist` (
`rqid` int(11) NOT NULL,
`rqtid` int(11) NOT NULL,
`rqsid` int(11) NOT NULL,
`rqdate` datetime NOT NULL,
`rqcode` tinyint(1) NOT NULL,
`rssid` int(11) NOT NULL,
`rsdate` datetime,
`rscode` tinyint(1)
) ENGINE=ARCHIVE COMMENT='request archive';
____SQL;
$result = $this->db->getConnection()->exec($sql);
$sql = <<<____SQL
CREATE TABLE IF NOT EXISTS `relay_hist` (
`rqid` int(5) NOT NULL,
`sdesc` varchar(40) NOT NULL,
`rqemail` varchar(40) NOT NULL,
`sid` int(11) NOT NULL,
`rlsid` int(11) NOT NULL,
`dcode` varchar(5) NOT NULL
) ENGINE=ARCHIVE COMMENT='relay archive';
____SQL;
$result = $this->db->getConnection()->exec($sql);
?>
Chopping it into individual queries fixes the problem.
up
down
0
practicegoodtheory at gmail dot com
4 years ago
On Windows, with Apache, it would not load php_pdo_mysql.dll until I put libmysql.dll in
Apache's dll path (e.g. apache/bin)
up
down
0
rmottey at gmail dot com
5 years ago
I have been getting the error below when performing multiple queries within a single
page.
Setting the attribute below did not seem to work for me.
So building on previous example i am initilizing my stmt variable on every query and a
fetch all into an array. Seems to be working for me.
Error:
PDO Error 1.1: Array ( [0] => xxx[1] => yyy[2] => Lost connection to MySQL server
during query )
Fix:
(PDO::setAttribute("PDO::MYSQL_ATTR_USE_BUFFERED_QUERY", true);)
<?
try {
$dbh = new PDO('mysql:host=xxx;port=xxx;dbname=xxx', 'xxx', 'xxx',
array( PDO::ATTR_PERSISTENT => false));
$stmt = $dbh->prepare("CALL getname()");
// call the stored procedure
$stmt->execute();
// fetch all rows into an array.
$rows = $stmt->fetchAll();
foreach ($rows as $rs)
{
$id = $rs['id'];
}
//initilise the statement
unset($stmt);
$stmt = $dbh->prepare("call secondprocedure(?);");
$stmt->bindValue(1, $id);
if ( ! $stmt->execute() )
{
echo "PDO Error 1.1:\n";
print_r($stmt->errorInfo());
exit;
}
unset($stmt);
} catch (PDOException $e) {
print "Error!: " . $e->getMessage() . "<br/>";
die();
}
?>
up
down
-1
marty at excudo dot net
5 years ago
Davey wrote:
> To use "PDO::MYSQL_ATTR_USE_BUFFERED_QUERY" you should call
> PDO::setAttribute("PDO::MYSQL_ATTR_USE_BUFFERED_QUERY", true);
>
>It will not work when passed into PDO::prepare()
>
> - Davey
Almost correct. It should be:
PDO::setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true);
so, without the quotes.
otherwise it still won't work :)
up
down
-2
bratwizard at yahoo dot com
5 years ago
> konrads dot smelkovs at gmail dot com
> 18-Jul-2007 03:39
> A note for the eager:
>> There is no way how to get returned row count from an executed prepared
statement without fetching the rows.
Sure there is, just do something like this:
if ($sth = $pdo->prepare($sql)) {
$sth->execute($values);
$sth->fetch();
// get count of rows in result set
if ($sth_rc = $this->getDataset()->query('SELECT FOUND_ROWS()')) {
$row_count = $sth_rc->fetchColumn(0);
}
}
Funciones de Microsoft SQL Server (PDO_SQLSRV)
Introducción
PDO_SQLSRV es un controlador que implementa la interfaz de Objetos de Datos de PHP
(PDO) para habilitar el acceso desde PHP a bases de datos de MS SQL Server (comenzando
con SQL Server 2005) y de SQL Azure.
Instalación
La extesnión PDO_SQLSRV se habilitada añadiendo el fichero DLL apropiado al directorio de
extensiones de PHP y la entrada correspondiente al fichero php.ini. La descarga de
PDO_SQLSRV viene con ocho ficheros de controlador, cuatro de los cuales son para dar
soporte a PDO. Si se está ejecutando PHP como no seguro con subprocesos (PHP 5.3), use el
fichero php_pdo_sqlsrv_53_nts.dll. (Debería de usarse una versión no segura con subprocesos si
se utiliza IIS como servidor web). Si se está ejecutando PHP como seguro con subprocesos, use
el fichero php_pdo_sqlsrv_53_ts.dll. De manera similar para PHP 5.4, use
php_pdo_sqlsrv_54_nts.dll o php_pdo_sqlsrv_54_ts.dll, dependiendo de si la instalación de
PHP no es o es segura con subprocesos.
La versión más reciente del controlador está disponible aquí: » Descarga de SQLSRV 3.0 . Si
fuera necesario dar soporte paraor PHP 5.2 y/o PHP compilado con VC6, use la versión 2.0 del
controlador: » Descarga de SQLSRV 2.0 .
Para más información sobre los requisitos del sistema, véase » Requisitos del sistema de
SQLSRV.
La extensión PDO_SQLSRV solamente es compatible con PHP ejecutándose bajo Windows.
Para Linux, véaseODBC y » Microsoft's SQL Server ODBC Driver para Linux .
Constantes predefinidas
Estas constantes están definidas por este controlador, y estarán disponibles sólo cuando la
extensión haya sido compilada con PHP, o bien sea cargada dinámicamente en ejecución.
Además, estas constantes específicas del controlador deberían ser utilizadas sólo si está usando
este controlador. Usar atributos específicos del controlador con otro controlador podría resultar
en un comportamiento inesperado. PDO::getAttribute() puede ser empleado para obtener el
atributo PDO_ATTR_DRIVER_NAME para verificar el controlador, si el código puede
ejecutarse con múltiples controladores.
PDO::SQLSRV_TXN_READ_UNCOMMITTED (integer)
Esta constante es un valor aceptable para la clave TransactionIsolation del DSN de
SQLSRV. Esta constante establece el nivel de aislamiento para la conexión a Read
Uncommitted.
PDO::SQLSRV_TXN_READ_COMMITTED (integer)
Esta constante es un valor aceptable para la clave TransactionIsolation del DSN de
SQLSRV. Esta constante establece el nivel de aislamiento para la conexión a Read
Committed.
PDO::SQLSRV_TXN_REPEATABLE_READ (integer)
Esta constante es un valor aceptable para la clave TransactionIsolation del DSN de
SQLSRV. Esta constante establece el nivel de aislamiento para la conexión a
Repeateable Read.
PDO::SQLSRV_TXN_SNAPSHOT (integer)
Esta constante es un valor aceptable para la clave TransactionIsolation del DSN de
SQLSRV. Esta constante establece el nivel de aislamiento para la conexión a
Snapshot.
PDO::SQLSRV_TXN_SERIALIZABLE (integer)
Esta constante es un valor aceptable para la clave TransactionIsolation del DSN de
SQLSRV. Esta constante establece el nivel de aislamiento para la conexión a
Serializable.
PDO::SQLSRV_ENCODING_BINARY (integer)
Specifies that data is sent/retrieved as a raw byte stream to/from the server without
performing encoding or translation. This constant can be passed to
PDOStatement::setAttribute, PDO::prepare, PDOStatement::bindColumn, and
PDOStatement::bindParam.
PDO::SQLSRV_ENCODING_SYSTEM (integer)
Specifies that data is sent/retrieved to/from the server as 8-bit characters as specified
in the code page of the Windows locale that is set on the system. Any multi-byte
characters or characters that do not map into this code page are substituted with a
single byte question mark (?) character. This constant can be passed to
PDOStatement::setAttribute, PDO::setAttribute, PDO::prepare,
PDOStatement::bindColumn, and PDOStatement::bindParam.
PDO::SQLSRV_ENCODING_UTF8 (integer)
Specifies that data is sent/retrieved to/from the server in UTF-8 encoding. This is the
default encoding. This constant can be passed to PDOStatement::setAttribute,
PDO::setAttribute, PDO::prepare, PDOStatement::bindColumn, and
PDOStatement::bindParam.
PDO::SQLSRV_ENCODING_DEFAULT (integer)
Specifies that data is sent/retrieved to/from the server according to
PDO::SQLSRV_ENCODING_SYSTEM if specified during connection. The connection's
encoding is used if specified in a prepare statement. This constant can be passed to
PDOStatement::setAttribute, PDO::setAttribute, PDO::prepare,
PDOStatement::bindColumn, and PDOStatement::bindParam.
PDO::SQLSRV_ATTR_QUERY_TIMEOUT (integer)
A non-negative integer representing the timeout period, in seconds. Zero (0) is the
default and means no timeout. This constant can be passed to
PDOStatement::setAttribute, PDO::setAttribute, and PDO::prepare.
PDO::SQLSRV_ATTR_DIRECT_QUERY (integer)
Indicates that a query should be executed directly, without being prepared. This
constant can be passed to PDO::setAttribute, and PDO::prepare. For more information,
see » Direct and Prepared Statement Execution .
Tabla de contenidos
DSN de PDO_SQLSRV — Conectar a bases de datos de MS SQL Server y de SQL Azure
Funciones de Oracle (PDO_OCI)
Introducción
Advertencia
Esta extensión es EXPERIMENTAL. Esto significa que el comportamiento de esta extensión,
los nombres de sus funciones y todo lo documentado sobre esta extensión, puede cambiar en
una futura edición de PHP sin previo aviso. El uso de esta extensión queda bajo su propia
responsabilidad.
PDO_OCI es un controlador que implementa la interfaz de Objetos de Datos de PHP
(PDO) para habilitar el acceso desde PHP a bases de datos de Oracle a través de la biblioteca
OCI.
Instalación
Utilice --with-pdo-oci[=DIR] para instalar la extensión PDO Oracle OCI, donde el
opcional [=DIR] es el directorio base de la instalación de Oracle. [=DIR] por defecto es la
variable de entorno $ORACLE_HOME.
Utilice --with-pdo-oci=instantclient,prefijo,versión para un cliente de la Instancia
Oracle SDK, donde prefijo y versión se configuran.
// Usando $ORACLE_HOME
$ ./configure --with-pdo-oci
// Usando OCI para Linux con la versión 10.2.0.3 con un prefijo /usr
$ ./configure --with-pdo-oci=instantclient,/usr,10.2.0.3
Tabla de contenidos
DSN de PDO_OCI — Conectar a bases de datos de Oracle
DSN de PDO_OCI DSN de PDO_SQLSRV
[edit] Last updated: Fri, 25 Jan 2013
add a noteUser Contributed Notes Oracle (PDO) - [10 notes]
up
down
0
php at ideacode dot com
1 year ago
If you're getting the "I'm too dumb to find oci.h" error, try creating a variety of paths.
One variety uses just the major and minor of your OIC version (eg, 11.2 for 11.2.0.2)
and another variety uses client64 as well as client.
Something like this (for 11.2.0.2):
ln -s /usr/include/oracle/11.2.0.2/ /usr/include/oracle/11.2
ln -s /usr/include/oracle/11.2/client /usr/include/oracle/11.2/client64
ln -s /usr/lib/oracle/11.2.0.2/ /usr/lib/oracle/11.2
ln -s /usr/lib/oracle/11.2/client /usr/lib/oracle/11.2/client64
This should cover your bases for 64-bit systems, as well as PHP patched to use the
major.minor version number only. See also PHP bug #44989.
up
down
0
redlorry919 at gmail dot com
1 year ago
Take note of the note at the top, this really is an experimental extension. I had a
problem trying to read data from Oracle which resulted in some strange behaviour in
PHP. i.e. foreach loops not ending, with no error messages. I also managed to get the
data from Oracle into an array in PHP, but then couldn't return the array from a
function.
After pulling my hair out for a day, it turned out to be a CLOB column in Oracle that
caused the strange behaviour in PHP. I assume this extension doesn't fully support
them.
Instead I've typecast it within the SQL to a VARCHAR2 which seems to resolve it:
SELECT CAST(columnx AS VARCHAR2(4000)) AS columnx ...
It might help someone else having similar issues.
up
down
0
geompse at gmail dot com
2 years ago
Notice the red block at the beginning of this page... pdo_oci is HIGHLY experimental.
Even though it is under dev from 2004, it lakes today support for things that _do_
matters :
- bind a varchar2 of 3500 chars
- get selected metas
- left join with blobs/clobs
- etc.
For the story, since we use pdo_pgsql in our software, I thought it would be viable to
use pdo_oci for running under Oracle. After a long battle, I finally won :
1) If requested driver has a non-experimental pdo version available, use it.
2) else (well, for pdo_oci at least), use an abstraction layer of your own.
3) you're done.
What I did in more details...
2 "main" classes for being compliant with "$obj instanceof PDO" or such :
- class PhpDb extends PDO
- class PhpDbStatement extends PDOStatement
2 "abstract" classes that defines what PDO actually does :
- abstract class PhpDbAbstract
- abstract class PhpDbAbstractStatement
And at last for each driver, 2 classes doing the abstraction :
- class PhpDbDriverOracle extends PhpDbAbstract
- class PhpDbDriverOracleStatement extends PhpDbAbstractStatement
"main" classes are accessed from your script, simply replace "new PDO" with "new
PhpDb".
"abstract" classes are mainly there for the documentation :p
"driver" classes do the job in background, they are instances by the main classes.
My PhpDb will be in an open source project sooner or later, search google or mail me !
up
down
0
av01 at bugfix dot cc
2 years ago
In order to get this compiled on my CentOS 5.4 x86_64 box, I had to do some extra
settings that might be useful for others:
Install oracle-instantclient11.2-basic and oracle-instantclient11.2-devel RPMs from
Oracle
Create some symbolic links because configure contains some outdated assumptions
about path names and doesn't care about 64-bit systems:
ln -s /usr/lib/oracle/11.2/client64 /usr/lib/oracle/11.2/client
ln -s /usr/include/oracle/11.2/client64 /usr/lib/oracle/11.2/client/include
Add the following to your configure command:
--with-pdo-oci=shared,instantclient,/usr,11.2
up
down
0
sixd at php dot net
3 years ago
From the PHP 5.3 UPGRADING file:
- The PDO_OCI php_pdo_oci8.dll library (for use with Oracle version 8 client
libraries) is no longer being built [with PHP 5.3]. Instead, use php_pdo_oci.dll (note no
'8') with Oracle 10 or 11 client libraries. Connection to other database
versions is still supported.
up
down
0
fernando dot wendt at gmail dot com
4 years ago
To enable PDO support on PHP for Oracle Instant Client 11.1.x, you should follow the
syntax above in the compile command, just as pointed by
Andrew http://bugs.php.net/bug.php?id=39312,taking by default you have installed the
OIC at /usr/lib/oracle (instant client and sdk at subfolder):
./configure --with-oci8=shared,instantclient,/usr/lib/oracle
--with-pdo-oci=instantclient,/usr/lib/oracle,11.1
Just saying your release version from the Oracle OIC.
It compiles fine then.
Best regards.
up
down
0
ken at xpressconnex dot com
4 years ago
Wow, cursade. That's a lot of typing to use the lite client.
Try this:
$db = '//hostname/servicename'; //e.g. '//192.168.1.1/orcl'
$user = 'username';
$pass = 'password';
$conn = new PDO($db,$user,$pass);
up
down
0
moc.aciremi@yvelj
6 years ago
A Statement of Warning:
PDO::oci does not support REF CURSORS.
This is mentioned nowhere (until now!) on this page.
And now you know!
If you want ref cursors avoid PDO for now.
My Reference for this claim:
http://www.oracle.com/technology/pub/articles/
php_experts/otn_pdo_oracle5.html
GREAT article, excellent piece, really. It's not clear to me
how old this document is, but it must have some dust on it,
given it's references to "PHP5.1 ...' which is a little way off yet' "
... as of 2006-06-01, PHP5.1 has been with us for quite some time.
up
down
0
cursade at hotmail dot com
6 years ago
if oracle and oracle instant client has been installed,
without db in the same host
For UNIX/LINUX，set $LD_LIBRARY_PATH
appent your instant client path and client/lib path to it,
For windows set PATH like this
After set the path ,set TNS_ADMIN everioment ,point to
where tnsnames.ora located.
Then,you can use service name to connect to your Database
Test coding
<?php
$param = $_POST;
$db_username = "youusername";
$db_password = "yourpassword";
$db = "oci:dbname=yoursid";
$conn = new PDO($db,$db_username,$db_password);
$name = $param['module'];
$file = $param['file'];
$stmt = $conn->exec("INSERT INTO AL_MODULE (AL_MODULENAME,
AL_MODULEFILE) VALUES ('$name', '$file')");
?>
up
down
0
cursade at hotmail dot com
6 years ago
If instant client has been installed but the full oracle client
not yet ,you can use pdo to connect to oracle database
like following coding:
<?php
$tns = "
(DESCRIPTION =
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST = yourip)(PORT = 1521))
)
(CONNECT_DATA =
(SERVICE_NAME = orcl)
)
)
";
$db_username = "youname";
$db_password = "yourpassword";
try{
$conn = new PDO("oci:dbname=".$tns,$db_username,$db_password);
}catch(PDOException $e){
echo ($e->getMessage());
}
?>
Funciones de ODBC y DB2 (PDO_ODBC)
Introducción
PDO_ODBC es un controlador que implementa la interfaz de Objetos de datos de PHP
(PDO) para habilitar el acceso desde PHP a bases de datos a través de contorladores ODBC o
de la biblioteca IBM DB2 Call Level Interface (DB2 CLI). PDO_ODBC admite actualmente
tres "sabores" diferentes de controladores de bases de datos:
ibm-db2
Da soporte para el acceso a servidores de IBM DB2 Universal Database, Cloudscape, y Apache
a través del cliente gratuito DB2.
unixODBC
Da soporte para el acceso a servidores de bases de datos a través del administrador de gestores
de unixODBC y de los controladores de ODBC proppietarios de bases de datos.
generic
Ofrece una opción de compilación para los administradores de gestores de ODBC que no están
admitidos explícitamente pore PDO_ODBC.
En Windows, PDO_ODBC está construido dentor del núcleo de PHP de manera
predeterminada. Está vinculado con Windows ODBC Driver Manager, por lo que PHP puede
conectarse a cualquier base de datos catalogada en un DSN de sistema, y es el controlador
recomendado para conectarse a bases de datos de Microsoft SQL Server.
Instalación
PDO_ODBC en sistemas UNIX
A partir de PHP 5.1, PDO_ODBC está incluido en los ficheros fuente de PHP. Se puede
compilar la extensión PDO_ODBC como un módulo estático o compartido usando los
siguientes comandosconfigure.
ibm_db2
./configure --with-pdo-odbc=ibm-db2,/opt/IBM/db2/V8.1/
Para contruir PDO_ODBC con el sabor ibm-db2, se han de tener instaladas previamente las
cabeceras de desarrollo de aplicaciones de DB2 en la misma máquina en la que se compile
PDO_ODBC. Las cabeceras de desarrollo de aplicaciones de DB2 son una opción instalable en
los servidores de DB2, y también están disponibles como parte de DB2 Application
Development Client, disponible para descargar gratuitamente desde el » sitio de soporte de
IBM DB2 Universal Database.
Si no se proporciona una ubicación para las bibliotecas y cabeceras de DB2 al
comando configure, PDO_ODBC usará como valor predeterminado /home/db2inst1/sqllib.
unixODBC
./configure --with-pdo-odbc=unixODBC,/usr/local
Si no se proporciona una ubicación para las bibliotecas y cabecerasd de unixODBC al
comandoconfigure, PDO_ODBC usará como valor predetermiando /usr/local.
generic
./configure --with-pdo-odbc=generic,/usr/local,libname,ldflags,cflags
Configuración en tiempo de ejecución
El comportamiento de estas funciones se ve afectado por la configuración de php.ini.
Opciones de configuración de PDO_ODBC
NombrePor
defectoCambiable Historial de cambios
pdo_odbc.connection_pooling "strict" PHP_INI_ALL Disponible desde PHP 5.1.0.
pdo_odbc.db2_instance_name NULL PHP_INI_SYSTEM
Disponible desde PHP 5.1.1. Esta
característica
obsoleta será eliminada con certeza
en el futuro.
Para más detalles y definiciones de los modos de PHP_INI_*, vea Dónde se puede realizar
un ajuste de configuración.
He aquí una breve explicación de las directivas de configuración.
pdo_odbc.connection_pooling string
Si agrupar conexiones de ODBC. Se puede usar "strict", "relaxed" o "off" (que es igual
a ""). El parámetro describe cómo de estricta debería ser el administrador de conexiones cuando
coincidan los parámetros de conexión con conexiones existentes en la agrupación. strict es el
valor predetermiando recomendado, y dará como resultado en el uso de conexiones
almacenadas en caché solamente cuando todos los parámetros de conexión coincidan
exactamente. relaxed dará como resultado el uso de conexiones almacenadas en caché cuando
se utilicen parámetros de conexión similares. Esto puede resultar en el aumento del uso de la
caché, con el riesgo de perder información de conexión entre (por ejemplo) hosts virtuales.
Este ajuste solamente se puede cambiar desde el fichero php.ini, y afecta al proceso completo;
cualquier otro módulo dentro del proceso que utilice las mismas bibliotescas de ODBC también
se verá afectado, incluyendo la Extensión ODBC Unificada.
Advertencia
relaxed no debería usarse en servidores compartidos, por razones de seguridad.
Sugerencia
Deje este ajuste a la configuración strict predeterminada a menos que tenga una buena razón
para cambiarlo.
pdo_odbc.db2_instance_name string
Si se compila PDO_ODBC usando el sabor db2, este ajuste establece el valor de la variable de
entorno DB2INSTANCE en sistemas operativos Linux y UNIX al nombre especificado de la
instancia de DB2. También habilita PDO_ODBC para resolver la ubicación de las bibliotecas de
DB2 y realizar conexiones catalogadas a bases de datos DB2.
Este ajuste solamente se puede cambiar desde el fichero php.ini, y afecta al proceso completo;
cualquier otro módulo dentro del proceso que utilice las mismas bibliotescas de ODBC también
se verá afectado, incluyendo la Extensión ODBC Unificada.
Este ajuste no tiene efecto en Windows.
Tabla de contenidos
DSN de PDO_ODBC — Conectarse a bases de datos de ODBC o de DB2
DSN de PDO_ODBC DSN de PDO_OCI
[edit] Last updated: Fri, 25 Jan 2013
add a noteUser Contributed Notes ODBC y DB2 (PDO) - [4 notes]
up
down
1
harry dot forum at p-boss dot com
2 years ago
MSSQL - PHP on Apache - Linux Redhat
When using php 5.2.10 please beaware of this error:
http://bugs.php.net/bug.php?id=42068
Standard odbc_connect will not work, you must use pdo_odbc
Connecting to MSSQL using pdo odbc - walkthrough..
1. Download and configure FreeTDS with-unixodbc
./configure --prefix=/opt/SYSfreetds --with-unixodbc
make;make test; make install
2. install php-odbc and unixODBC
php-odbc-5.2.10-1.x86_64.rpm
unixODBC.x86_64.x86x64
3. Setup ODBC links
a)
Create a tds.driver file with the following contents
[FreeTDS]
Description = v0.63 with protocol v8.0
Driver = /opt/SYSfreetds/lib/libtdsodbc.so
Register the ODBC driver - the tds.driver file
odbcinst -i -d -f tds.driver
b)
Creating a tds.datasource file - ODBC Data Source with contents:
[SOURCENAME]
Driver=FreeTDS
Description=Test MS SQL Database with FreeTDS
Trace=No
Server=BobTheServer
Port=1433
TDS Version=8.0
Database=youDBname
Register the ODBC data source
odbcinst -i -s -f tds.datasource
Beware that the odbc.ini file will be installed in the current users home directory. This
may need to be used if you are using a webserver as the apache home directory could
be different.
Ensure .odbc.ini is in apaches home directory, possibly "/var/www"
4. Test the ODBC link on the command line
isql -v SOURCENAME 'username' 'password'
+---------------------------------------+
| Connected! |
| |
| sql-statement |
| help [tablename] |
| quit |
| |
+---------------------------------------+
SQL>
5. Edit /etc/php.ini
Make sure the following is set:
mssql.secure_connection = On
6. Restart apache gracefully
7. PHP to run:
<?
$dbh= new PDO('odbc:SOURCENAME', 'username', 'password');
$stmt = $dbh->prepare("$query");
$stmt->execute();
while ($row = $stmt->fetch()) {
print_r($row);
}
unset($dbh); unset($stmt);
?>
Trouble-shooting:
Please try strace/ truss if you encounter issues. It could be you are referencing wrong
libraries somewhere.
Ensure you have restarted apache once the odbc files are in place
up
down
0
Ariz Jacinto
1 year ago
Using SQL Server Native Client 11.0 on Linux as a PDO_ODBC driver:
Download the SQL Server Native Client 11.0 on Linux ODBC Driver:
http://www.microsoft.com/download/en/details.aspx?id=28160
Configuration ODBC:
/usr/local/etc/odbcsys.ini
--
[SQL Server Native Client 11.0]
Description = Microsoft SQL Server ODBC Driver V1.0 for Linux
Driver = /opt/microsoft/sqlncli/lib64/libsqlncli-11.0.so.1720.0
UsageCount = 1
/usr/local/etc/odbc.ini
--
[MSSQLServer]
Driver = SQL Server Native Client 11.0
Description = Sample Database
Trace = Yes
Server =
Port = 1433
Database =
Test the connection:
mssqltest.php
--
<?php
putenv('ODBCSYSINI=/usr/local/etc');
putenv('ODBCINI=/usr/local/etc/odbc.ini');
$username = "";
$password = "";
try {
$dbh = new PDO("odbc:MSSQLServer",
"$username",
"$password"
);
} catch (PDOException $exception) {
echo $exception->getMessage();
exit;
}
echo var_dump($dbh);
unset($dbh);
?>
up
down
0
tuomas
3 years ago
If you want to avoid installing DB2 Connect and/or PECL modules ibm_db2 and
PDO_IBM, you can also use IBM DB2 databases trough unixODBC.
If you have DB2 database on a i server you need to install IBM iAccess
(http://www.ibm.com/systems/i/software/access/linux/index.html) and unixODBC. Just
install the libraries (rpm) and modify configurations in /etc/odbcinst.ini (sample
configuration in /opt/ibm/iSeriesAccess/unixodbcregistration) and /etc/odbc.ini.
To my experience this is much easier way than installing DB2 Connect.
up
down
0
ethan dot nelson at ltd dot org
4 years ago
Using SQL 2005, PDO_ODBC and datetime fields is a royal pain. MSDN
documentation on CAST CONVERT shows that there is supposed to be an implicit
convert between character types and datetime types. That's true... until you put it in a
stored procedure and use variable declarations.
For instance this fails:
declare @date varchar;
SET @date = '20080101';
SELECT cast(@date AS datetime) AS poo
While this succeeds:
declare @date varchar(19);
SET @date = '20080101';
SELECT cast(@date AS datetime) AS poo
The PDO Driver appears to attempt an implicit conversion and so it fails whenever you
try to insert data into datetime column types.
So to workaround this nuance in SQL, declare a character column type with explicit
width. Then your implicit type conversion will work.
Funciones PostgreSQL (PDO_PGSQL)
Introducción
PDO_PGSQL es un controlador que implementa la interfaz PHP Data Objects (PDO) para
permitir el acceso desde PHP a bases de datos PostgreSQL.
Tipos de recursos
Esta extensión define un recurso de secuencia retornado por PDO::pgsqlLOBOpen().
Instalación
Utilice --with-pdo-pgsql[=DIR] para instalar la extensión PDO PostgreSQL, donde el
opcional [=DIR] es el directorio base de la instalación de PostgreSQL, o la ruta a pg_config.
$ ./configure --with-pdo-pgsql
Tabla de contenidos
PDO_PGSQL DSN — Conectarse a bases de datos PostgreSQL
PDO::pgsqlLOBCreate — Crea un nuevo objeto grande
PDO::pgsqlLOBOpen — Abre un flujo de un objeto grande existente
PDO::pgsqlLOBUnlink — Elimina un objeto grande
Funciones de SQLite (PDO_SQLITE)
Introducción
PDO_SQLITE es un controlador que implementa la interfaz Objetos de Datos de PHP
(PDO, siglas en inglés de PHP Data Objects) para habilitar el acceso a bases de datos de
SQLite 3.
En PHP 5.1, la extensión SQLite también proporciona un controlador para bases de datos de
SQLite 2; aunque no es técnicamente una parte del controlador PDO_SQLITE, se comporta de
manera similar, por lo que está documentado codo con codo. El controlador SQLite 2 para PDO
es proporcionado pricipalmente para hacer más la importación de ficheros de bases de datos
atiguos de SQLite a una aplicación que utilice el controlador SQLite 3 más rápido y más
eficiente. Como consecuencia, el controlador SQLite 2 no tiene unas características tan ricas
como el controlador SQLite 3.
Nota:
PDO_SQLITE permite usar cadenas aparte de flujos junto con PDO::PARAM_LOB.
Instalación
El controlador PDO_SQLITE PDO está habilitado por omisión. Para deshabilitarlo, se puede
usar --without-pdo-sqlite[=DIR] , donde el parámetro opcional [=DIR] es el directorio base
de instalación de sqlite.
Tabla de contenidos
PDO_SQLITE DSN — Conectar a las bases de datos de SQLite
PDO::sqliteCreateAggregate — Registra una función acumuladora definida por el usuario
para usarla en sentencias SQL
PDO::sqliteCreateFunction — Registra una función definida por el usuario para utilizarla en
sentencias SQL
PDO_SQLITE DSN PDO::pgsqlLOBUnlink
[edit] Last updated: Fri, 25 Jan 2013
add a noteUser Contributed Notes SQLite (PDO) - [6 notes]
up
down
2
nospam8715 at dririan dot com
2 months ago
Instead of compiling an old version of SQLite to create a database using an older
database format that the version of SQLite bundled with PDO can handle, you can
(much more easily) just run the query "PRAGMA legacy_file_format = TRUE;"
BEFORE creating the database (if you have an existing database, run ".dump" from the
sqlite shell on your database, run the sqlite shell on a new database, run the PRAGMA,
then paste the contents of the .dump). That will ensure SQLite creates a database
readable by SQLite 3.0 and later.
up
down
0
gmac63 at charter dot net
6 years ago
Issue:
Error: SQLSTATE[HY000]: General error: 1 unsupported file format
Resolution:
To solve this (and/or many issues) involving this type of error, I assumed the error to be
generated from php. Well, it was to an extent. The sqlite pdo code offered the solution:
I researched the error by grep'ing the php source code and found the error string to
come from php-5.1.4/ext/pdo_sqlite/sqlite/src/prepare.c, lines 265:278 :
/*
** file_format==1 Version 3.0.0.
** file_format==2 Version 3.1.3.
** file_format==3 Version 3.1.4.
**
** Version 3.0 can only use files with file_format==1. Version 3.1.3
** can read and write files with file_format==1 or file_format==2.
** Version 3.1.4 can read and write file formats 1, 2 and 3.
*/
if( meta[1]>3 ){
sqlite3BtreeCloseCursor(curMain);
sqlite3SetString(pzErrMsg, "unsupported file format", (char*)0);
return SQLITE_ERROR;
}
This is interesting as I am running SQLite version 3.3.5 which the databases were
created in. I see that the SQLite PDO source in the php source is :
# cat ext/pdo_sqlite/sqlite/VERSION
3.2.8
My solution was then to find a version of sqlite that was =< 3.1.4. I found source for
3.1.3, compiled, recreated my database using that version (NOTE: the databases are
unsupported between 3.1.x and 3.2.x versions of SQLite). Once I did this it worked.
Also as a side note, to get SQLite compiled as a PDO, I had to:
1) configure with
...
--enable-pdo=shared \
--with-sqlite=shared \
--with-pdo-sqlite=shared
--with-zlib
... \
'make && make install' if configure is successful.
2) Make sure the pdo libs were copied/installed to the correct directory. On my
installation it was /usr/local/include/php/ext/pdo/
3) Make these changes in my php.ini:
- change ' extension_dir = "./" ' to ' extension_dir="/usr/local/include/php/ext/pdo/" '
- add/edit in this order:
extension=pdo.so
extension=pdo_sqlite.so
extension=sqlite.so
4) test php with : 'php -m' at the command line and solve any issues from there. Mostly
php.ini config issues. Also restart the http service!
up
down
0
Duffalo
6 years ago
Note that as of the date of this post, PDO_SQLITE will not interact with database files
created with the current version of the SQLite console application, sqlite-3.3.6.
It is currently necessary to obtain version 3.2.8, available from http://www.sqlite.org/ but
only by entering the URI manually, as there is no link. Go
tohttp://www.sqlite.org/download.html and find the URI of the version you're looking for,
then make the appropriate version number substitution.
up
down
0
aidan at php dot net
7 years ago
If you receive an error while trying to write to a sqlite database (update, delete, drop):
Warning: PDO::query() [function.query]: SQLSTATE[HY000]: General error: 1 unable
to open database
The folder that houses the database file must be writeable.
up
down
-1
Hayley Watson
1 year ago
If there is anyone using PDO to interface with SQLite and wondering how to create an
SQLite database to begin with; if they're thinking they'll have to detour into one of the
other SQLite interfaces to get the job done - nope!
PDO does need a SQLite database file to exist before it can connect, but that file can
be a completely empty one; so a single touch() is enough to create a brand new virgin
SQLite database ready to receive your CREATE TABLE statements.
up
down
-1
gopal at gopalarathnam dot com
5 years ago
If you get an error reporting "invalid resource" when trying to query the database table
and looping through it, the version of the SQLite extension compiled in to PHP might be
incompatible with the version that had created the database (like SQLite 2.x vs 3.x).
The database open itself might be successful, failing only when querying.
$dbh = new PDO('sqlite:/tmp/foo.db'); // success
foreach ($dbh->query('SELECT * FROM bar') as $row) // prints invalid resource
// ...
Funciones de 4D (PDO_4D)
Introducción
Advertencia
Esta extensión es EXPERIMENTAL. Esto significa que el comportamiento de esta extensión,
los nombres de sus funciones y todo lo documentado sobre esta extensión, puede cambiar en
una futura edición de PHP sin previo aviso. El uso de esta extensión queda bajo su propia
responsabilidad.
PDO_4D es un controlador que implementa la interfaz de Objetos de datos de PHP
(PDO) para habilitar el acceso desde PHP a bases de datos de 4D.
4D es una plataforma integrada que acelera y simplifica el desarrollo y el despliegue de
aplicaciones de negocios, utilizada en más de 70 países, mediante una comunidad de miles de
desarrolladores y proveedores de soluciones verticales, con millones de usuarios finales en todo
el mundo.
Ofreciendo un juego integrado de herramientas, tales como una base de datos relacional y
transaccional ANSI SQL, un entorno de desarrollo gráfico, un lenguaje de cuarta generación
con más de 1000 comandos de alto nivel, un servidor HTTP interno, un servidor de
aplicaciones, etc., 4D facilita la creación y el mantenimiento de aplicaciones desde uno a miles
de usuarios simultáneos, ya sea en Windows, Mac o desde cualquier cliente web.
4D también es una plataforma abierta, ofreciendo una API completa para la creación de
complementos, incluyendo varios conectores que le permiten actuar como un sistema servidor o
cliente para muchos entornos (Oracle mediante OCI, cliente o servidor SOAP, origen de datos
Flex, todas las bases de datos ODBC, XML sobre HTTP, etc.)
Además de la capacidad de interactuar con aplicaciones 4D a través de servicios web, ahora se
puede acceder a las bases de datos de 4D directamente usando el controlador PDO_4D.
Se pueden encontrar más detalles sobre el entorno de desarrollo de 4D
en » http://www.4d.com/ .
Se sabe que PDO_4D funciona con las versiones 12 beta y siguientes de 4D, para Mac OS X y
Windows. Las plataformas antiguas podrían funcionar, pero no están soportadas.
Tabla de contenidos
DSN de PDO_4D — Conectarse a un servidor de 4D SQL
Constantes para PDO_4D — Constantes para PDO_4D
Tipos de SQL con PDO_4D y PHP — Tipos de SQL con PDO_4D y PHP
SQL aceptado por 4D — PDO y SQL 4D
Ejemplos con PDO_4D — Ejemplos con PDO_4D