Desde la versión 2.0, PHP ha incorporado de forma nativa funciones para la conexión y uso de bases de datos. Al ser la rapidez una de las máximas de este lenguaje, y ante la ventaja de que proporciona mecanismos para la carga de librerías externas, se crearon unas librerías para cada motor de base de datos, que contenían las funciones necesarias para trabajar con él.

Estas API nativas son diferentes para cada SGBD, tanto en los nombres de las funciones que se utilizan para crear una conexión a la base de datos, lanzar una consulta, etc., como en el tratamiento de errores, resultados, etc.
 

Aunque se puede argumentar que al usar la API del SGBD concreto que utilicemos, dispondremos de operadores o funcionalidades específicas de ese motor que una librería estándar no puede proporcionar, con el paso del tiempo se ha visto que la utilización de estas API sólo está indicada (y aun así, no es recomendable) para aplicaciones que sepamos seguro que no van a cambiar el SGBD con el que trabajan, ya que la revisión del código PHP, cuando hay un cambio de SGBD, es muy costosa y proclive a errores.

Para trabajar con la API nativa de MySQL en PHP, deberemos haber compilado el intérprete con soporte para este SGBD, o bien disponer ya del binario de PHP precompilado con el soporte incorporado.

En el caso de tenerlo que compilar, únicamente deberemos indicar como opción --with-mysql. Posteriormente, o en el caso de que ya dispongamos del binario, podemos validar que el soporte para MySQL está incluido correctamente en el intérprete con la ejecución del siguiente comando:

A partir de aquí, PHP proporciona unos parámetros de configuración que nos permitirán controlar algunos aspectos del funcionamiento de las conexiones con el SGBD, y las propias funciones de trabajo con la base de datos.

En cuanto a los parámetros, deberán situarse en el fichero php.ini, o bien configurarse para nuestra aplicación en concreto desde el servidor web. Destacan los siguientes:

mysql.allow_persistent: indica si vamos a permitir conexiones persistentes a MySQL. Los valores posibles son true o false.

mysql.max_persistent: número máximo de conexiones persistentes permitidas por proceso.

mysql.max_links: número máximo de conexiones permitidas por proceso, incluyendo las persistentes.

mysql.connect_timeout: tiempo que ha de transcurrir, en segundos, antes de que PHP abandone el intento de conexión al servidor.

Las conexiones persistentes son conexiones a la base de datos que se mantienen abiertas para evitar el tiempo de latencia que se pierde en conectar y desconectar. El intérprete,
al ejecutar la sentencia de conexión a la base de datos, examina si hay alguna otra conexión abierta sin usar, y devuelve ésta en lugar de abrir una nueva. Lo mismo sucede al desconectar, el intérprete puede realizar la desconexión si hay suficientes conexiones aún abiertas, o bien mantener la conexión abierta para futuras consultas.

Por lo que respecta a la utilización de la API para la conexión y consulta de bases de datos, empezaremos con un ejemplo:

En las cinco primeras líneas se establece la conexión y se selecciona la base de datos con que se va a trabajar. El código es bastante explícito y la mayoría de errores al respecto suelen deberse a una mala configuración de los permisos del usuario sobre la base de datos con la que debe trabajar.

Conviene estar muy atento, sobre todo a las direcciones de origen de la conexión, ya que, aunque podemos usar localhost como nombre de equipo, si el intérprete y el SGBD están en el mismo servidor, suele ocurrir que PHP resuelve localhost al nombre real del equipo e intenta conectarse con esta identificación. Así pues, debemos examinar cuidadosamente los archivos de registro de MySQL y los usuarios y privilegios del mismo si falla la conexión.

Para   establecer   una   conexión   persistente,   debemos   utilizar   la   función mysql_pconnect() con los mismos parámetros.
 

A continuación, se utiliza la función mysql_query() para lanzar la consulta a la base de datos.

La función mysql_error() es universal, y devuelve el último error ocurrido en el SGBD con nuestra conexión, o con la conexión $link que le indique- mos como parámetro.

La función mysql_query() puede devolver los siguientes resultados:

•    FALSE si ha habido un error.

•    Una referencia a una estructura si la sentencia es de consulta y ha tenido éxito.

•    TRUE si la sentencia es de actualización, borrado o inserción y ha tenido éxito.

La función mysql_affected_rows() nos permite conocer el número de filas que se han visto afectadas por sentencias de actualización, borrado o inserción.

La función mysql_num_rows() nos permite conocer el número de filas devuelto por sentencias de consulta.

Una vez obtenido el recurso a partir de los resultados de la consulta, PHP proporciona multitud de formas de iterar sobre sus resultados o de acceder a uno de ellos directamente. Comentamos las más destacadas:

•    $fila = mysql_fetch_array($recurso, <tipo_de_array>)

Esta función va iterando sobre el recurso, devolviendo una fila cada vez, hasta que no quedan más filas, y devuelve FALSE. La forma del array devuelto dependerá del parámetro <tipo_de_array> que puede tomar estos valores:

–    MYSQL_NUM: devuelve un array con índices numéricos para los campos. Es decir, en $fila[0] tendremos el primer campo del SELECT, en $fila[1], el segundo, etc.

–    MYSQL_ASSOC: devuelve un array asociativo en el que los índices son los nombres de campo o alias que hayamos indicado en la sentencia SQL.

–    MYSQL_BOTH: devuelve un array con los dos métodos de acceso.

Recuperando el ejemplo inicial, entre las líneas 7 y 21:

•    $objeto = mysql_fetch_object($recurso)

Esta función va iterando sobre los resultados, devolviendo un objeto cada vez, de manera que el acceso a los datos de cada campo se realiza a través de las propiedades del objeto. Al igual que en el array asociativo, hay que vigilar con los nombres de los campos en consulta, evitando que devuelva campos con el mismo nombre fruto de combinaciones de varias tablas, ya que sólo podremos acceder al último de ellos:

Volvemos sobre el ejemplo inicial

•    $valor = mysql_result($recurso,$numero_de_fila,$numero_de_campo)

Esta función consulta directamente un valor de un campo de una fila especificada. Puede ser útil si queremos conocer un resultado sin necesidad de realizar bucles innecesarios. Evidentemente, hemos de saber exactamente dónde se encuentra.

•    $exito = mysql_data_seek($recurso,$fila)

Esta función permite mover el puntero dentro de la hoja de resultados representada por $recurso, hasta la fila que deseemos. Puede ser útil para avanzar o para retroceder y volver a recorrer la hoja de resultados sin tener que ejecutar la sentencia SQL de nuevo. Si la fila solicitada no existe en la hoja de resultados, el resultado será FALSE, al igual que si la hoja no contiene ningún resultado. Es decir, el valor de $fila debe estar entre 0 (la primera  fila)  y  mysql_num_rows()-1,  excepto  cuando  no  hay  ningún resultado, en cuyo caso devolverá FALSE.

Finalmente, comentaremos las funciones de liberación y desconexión. En el primer caso, PHP realiza un excelente trabajo liberando recursos de memoria cuando la ejecución en curso ya no los va a utilizar más. Aun así, si la consulta devuelve una hoja de datos muy grande, puede ser conveniente liberar el recurso cuando no lo necesitemos.

Por lo que respecta al cierre de la conexión, tampoco suele ser necesario, ya que PHP cierra todas las conexiones al finalizar la ejecución y, además, el cierre siempre está condicionado a la configuración de las conexiones persistentes. Tal como ya hemos comentado, si activamos las conexiones persistentes (o bien hemos conectado con mysql_pconnect), esta función no tiene nin gún efecto y, en todo caso, será PHP quien decida cuándo se va a cerrar cada conexión.

Ya  hemos comentado  que las API específicas para cada  motor  incluyen  un conjunto de funciones que podía ayudar a trabajar con sus aspectos particulares, a continuación, enumeramos las más importantes:

•    mysql_field_flags, mysql_field_name, mysql_field_table, mysql_field_type:  estas  funciones  reciben  como  parámetro  un  $recurso y un índice de campo dentro de la consulta ejecutada y devuelven información sobre el campo; en concreto, sus restricciones, nombre, tabla a la que corresponden y tipo de campo. Pueden ser muy útiles para trabajar con consultas genéricas sobre bases de datos y/o campos que no conocemos al realizar el script.

•    mysql_insert_id: esta función devuelve el último identificador obtenido de una inserción en un campo autoincremental.

•    mysql_list_dbs, mysql_list_tables, mysql_list_fields: con distintos parámetros, estas funciones permiten consultar datos de administración del motor de la base de datos.

Para trabajar con la API nativa de PostgreSQL en PHP, deberemos haber compilado el intérprete con soporte para este SGBD, o bien disponer ya del binario de PHP precompilado con el soporte incorporado.

En el caso de tenerlo que compilar, únicamente debemos indicar como opción --with-pgsql. Posteriormente, o en el caso de que ya dispongamos del binario, podemos validar que el soporte para PostgreSQL está incluido correctamente en el intérprete con la ejecución del siguiente comando:

A partir de aquí, PHP proporciona unos parámetros de configuración que nos permitirán controlar algunos aspectos del funcionamiento de las conexiones con el SGBD, y las propias funciones de trabajo con la base de datos.

En cuanto a los parámetros, deberán situarse en el fichero php.ini o bien configurarse para nuestra aplicación en concreto desde el servidor web. Destacan los siguientes:

•    pgsql.allow_persistent: indica si vamos a permitir el uso de conexiones persistentes. Los valores son true o false.

•    pgsql.max_persistent:  número  máximo  de  conexiones  persistentes permitidas por proceso.

•    pgsql.max_links: número máximo de conexiones permitidas por proceso, incluyendo las persistentes.

•    pgsql.auto_reset_persistent: detecta automáticamente conexiones persistentes cerradas y las elimina.

Por lo que respecta a la utilización de la API para la conexión y consulta de bases de datos, reproduciremos el anterior ejemplo:

En las diez primeras líneas, establecemos la conexión y comprobamos que se ha realizado correctamente.

A diferencia de MySQL, la selección de la base de datos se hace en el momento de la conexión. En cambio, la comprobación de la conexión es un poco más complicada.

Para   establecer   una   conexión   persistente,   debemos   utilizar   la   función pg_pconnect() con los mismos parámetros.

A continuación, se utiliza la función pg_query() para lanzar la consulta a la base de datos.

Para comprobar errores, la API de PostgreSQL distingue entre un error de conexión, y errores sobre los recursos devueltos. En el primer caso, deberemos usar pg_connection_status(), mientras que en el segundo podemos optar por pg_last_error() o bien pg_result_error($recurso) para obtener el mensaje de error que pueda haber devuelto un recurso en concreto.

La función pg_query() puede devolver los siguientes resultados:

•    FALSE si ha habido un error.

•    Una referencia a una estructura si la sentencia ha tenido éxito.

La función pg_affected_rows($recurso) nos permite conocer el número de filas que se han visto afectadas por sentencias de actualización, borrado o inserción. Esta función deberá recibir como parámetro el recurso devuelto por la función pg_query().

La función pg_num_rows($recurso) nos permite conocer el número de filas devuelto por sentencias de consulta.

Una vez obtenido el recurso a partir de los resultados de la consulta, PHP proporciona multitud de formas de iterar sobre sus resultados o de acceder a uno de ellos directamente. Comentamos las más destacadas:

•    $fila = pg_fetch_array($recurso, <tipo_de_array>)

Esta función va iterando sobre el recurso, devolviendo una fila cada vez, hasta que no quedan más filas y devuelve FALSE. La forma del array devuelto, dependerá del parámetro <tipo_de_array> que puede tomar estos valores:

•    PG_NUM: devuelve un array con índices numéricos para los campos. Es decir, en $fila[0] tendremos el primer campo del SELECT, en $fila[1],
el segundo, etc.

•    PG_ASSOC: devuelve un array asociativo donde los índices son los nombres de campo o alias que hayamos indicado en la sentencia SQL.

•    PG_BOTH: devuelve un array con los dos métodos de acceso.

Recuperando el ejemplo inicial, entre las líneas 11 y 24:

•    $objeto = pg_fetch_object($recurso)

Esta función va iterando sobre los resultados, devolviendo un objeto cada vez, de forma que el acceso a los datos de cada campo se realiza por medio de las propiedades del objeto. Al igual que en el array asociativo, hay que vigilar con los nombres de los campos en consulta, evitando que devuelva campos con el mismo nombre fruto de combinaciones de varias tablas, ya que sólo podremos acceder al último de ellos.

Volvemos sobre el ejemplo inicial

Podemos pasar a la función pg_fetch_object() un segundo parámetro para indicar la fila concreta que queremos obtener:

$resultado = pg_fetch_all($recurso)

Esta función devuelve toda la hoja de datos correspondiente a $recurso; es decir, una array con todas las filas y columnas que forman el resultado de la consulta.

•    $exito = pg_result_seek($recurso,$fila)

Esta función permite mover el puntero dentro de la hoja de resultados representada por $recurso hasta la fila que deseemos. Deben tomarse las mismas consideraciones que en la función mysql_data_seek().

En cuanto a la liberación de recursos y la desconexión de la base de datos, es totalmente aplicable lo explicado para MySQL, incluyendo los aspectos relacionados con las conexiones persistentes.

Al igual que en MySQL, PHP también proporciona funciones específicas para trabajar con algunos aspectos particulares de PostgreSQL. Al tener éste más funcionalidad que se aleja de lo estándar debido a su soporte a objetos, estas funciones cobrarán más importancia.  A continuación  comentamos las más destacadas:

•    pg_field_name, pg_field_num, pg_field_size, pg_field_type: estas funciones  proporcionan información sobre los campos  que  integran una consulta. Sus nombres son suficientemente explícitos acerca de su cometido.

•    pg_last_oid: esta función nos devuelve el OID obtenido por la inserción de una tupla si el recurso que recibe como parámetro es el correspondiente a una sentencia INSERT. En caso contrario devuelve FALSE.

•    pg_lo_create,    pg_lo_open,    pg_lo_export,    pg_lo_import, pg_lo_read, pg_lo_write: estas funciones (entre otras) facilitan el trabajo con objetos grandes (LOB) en PostgreSQL.

Las funciones pg_lo_import y pg_lo_export pueden tomar ficheros como parámetros, facilitando la inserción de objetos binarios en la base de datos.

El PEAR (PHP extension and application repository) se define como un marco de trabajo y un sistema de distribución de librerías reutilizables para PHP. Es similar en concepto al CPAN (comprehensive perl archive network) del lenguaje Perl o al PyPI (Python package index) de Python.

El PEAR pretende proporcionar una librería estructurada de código y librerías reutilizables, mantener un sistema para proporcionar a la comunidad herramientas para compartir sus desarrollos y fomentar un estilo de codificación estándar en PHP.

PEAR, debe ser el primer recurso para solventar cualquier carencia detectada en las funciones nativas de PHP. Como buena práctica general en el mundo del software libre, siempre es mejor usar, aprender o mejorar a partir de lo que han hecho otros, que proponernos reinventar la rueda. Además, si hacemos mejoras a las librerías que usemos de PEAR, siempre podemos contribuir a esos cambios mediante las herramientas que nos proporciona.

En cierta forma, PEAR se comporta como un gestor de paquetes más de los que pueden  incorporar  las  distribuciones  GNU/Linux  más  recientes  (como  apt, yum o YOU). Este

gestor de paquetes se compone del ejecutable ‘pear’ al que podemos proporcionar un conjunto de parámetros según las acciones que deseemos realizar:

PEAR (y PHP) ya viene con un conjunto de paquetes instalados, lo que se denomina el PFC (PHP foundation classes). Estos paquetes proporcionan a PHP la mínima funcionalidad necesaria para que PEAR funcione y para que dispongamos de las librerías básicas de PHP.

A continuación presentamos las opciones más habituales de PEAR:
 

La interfaz JDBC está definida en la librería java.sql. Vamos a importar a nuestra aplicación Java todas las clases definidas en ella.

Puesto que JDBC puede realizar conexiones con múltiples SGDB, la clase DriverManager configura los detalles de la interacción con cada uno en particular. Esta clase es la responsable de realizar la conexión, entregando un objeto de la clase Connection.

El destino de la conexión se especifica mediante un URL de JDBC con la sintaxis siguiente:

La parte protocolo_sgdb de la URL especifica el tipo de SGBD con el que se realizará la conexión, la clase DriverManager cargará el módulo correspondiente a tal efecto.

El subnombre tiene una sintaxis específica para cada SGDB que tanto para MySQL como para PostgreSQL es //servidor/base_de_datos.

Las sentencias en JDBC también son objetos que deberemos crear a partir de una conexión:

Al ejecutar una sentencia, el SGBD entrega unos resultados que JDBC también representa en forma de objeto, en este caso de la clase ResultSet:

Para acceder a los datos de cada columna de la hoja de resultados, la clase ResultSet dispone de varios métodos según el tipo de la información de la columna:

 getArray()                                                            getInt()

 getClob()                                                             getBoolean()

 getString()                                                           getLong()

 getAsciiStream()                                                  getByte()

 getDate()                                                             getObject()

 getTime()                                                             getObject()

 getBigDecimal()                                                   getBytes()

 getDouble()                                                          getBytes()

 getTimestamp()                                                    getRef()

 getBinaryStream()                                                getRef()

 getFloat()                                                            getCraracterStream()

 getURL()                                                          &

En el ejemplo anterior no se ha previsto nada para tratar con los errores que puedan producirse, porque en Java el tratamiento de errores se realiza a través de Exceptions. En JDBC se han previsto excepciones para los errores que pueden producirse a lo largo de todo el uso de la API: conexión, ejecución de la sentencia, etc.

Revisemos el ejemplo, utilizando excepciones para tratar los errores.

Mientras que la operación executeQuery() de la clase Statement devuelve un objeto ResultSet, la operación executeUpdate()sólo devuelve su éxito o fracaso. Las sentencias SQL que se utilizan con executeUpdate() son insert, update, o delete, porque no devuelven ningún resultado. 

 Las sentencias preparadas de JDBC permiten la “precompilación” del código SQL antes de ser ejecutado, permitiendo consultas o actualizaciones más eficientes. En el momento de compilar la sentencia SQL, se analiza cuál es la estrategia adecuada según las tablas, las columnas, los índices y las condiciones de búsqueda implicados. Este proceso, obviamente, consume tiempo de procesador, pero al realizar la compilación una sola vez, se logra mejorar el rendimiento en siguientes consultas iguales con valores diferentes.

Otra ventaja de las sentencias preparadas es que permiten la parametrización: la sentencia SQL se escribe una vez, indicando las posiciones de los datos que van a cambiar y, cada vez que se utilice, le proporcionaremos los argumentos necesarios que serán sustituidos en los lugares correspondientes. Los parámetros se especifican con el carácter ‘?’.

Al utilizar esta clase, obviamente, deberemos llamar primero al método que prepara la inserción, y posteriormente llamar tantas veces como sea necesario al método insertarPersona.

Se definen tres parámetros en la sentencia SQL, a los cuales se hace referencia mediante números enteros consecutivos:

La clase PreparedStatement incluye un conjunto de operaciones de la forma setXXXX(), donde XXXX es el tipo de dato para los campos de la tabla. Una de esas operaciones es precisamente setString() que inserta la variable en un campo de tipo cadena.

 La API JDBC incluye soporte para transacciones, de forma que se pueda deshacer un conjunto de operaciones relacionadas en caso necesario. Este compor- tamiento es responsabilidad de la clase Connection.

Por omisión, cada sentencia se ejecuta en el momento en que se solicita y no se puede deshacer. Podemos cambiar este comportamiento con la operación siguiente:

Después de esta operación, es necesario llamar a commit() para que todas las sentencias SQL pendientes se hagan definitivas:

En caso contrario, desharemos todas las actualizaciones después del último commit():