Daniel Segovia

Blog personal

Archive for the ‘5 – Base de datos con PHP’ Category

Seguridad en los parámetros

Hacer un comentario

La seguridad en los parámetros es un concepto muy viejo pero es muy efectivo.
Los ataques SQL Injection son más comunes de lo que uno piensa, por ende las cadenas de texto (SQL) que enviamos al motor de la base de datos deben, como mínimo, prevenir este tipo de ataques.
La forma más común en estos ataques es cuando ingresamos valores externos a nuestro código a la base de datos, es decir un parámetro que venga por POST o GET.

Sí enviamos el siguiente query a la base

<?php
$query = "SELECT * FROM personas WHERE id = 5";
//envio el query
?>

no existe tal SQL Injection por que id = 5 será siempre id = 5 ya que esta embebido en nuestro código.

Un ejemplo diferente con una vulnerabilidad visible es el siguiente.

<?php
$query = "SELECT * FROM personas WHERE id = " . $_GET['id'];
//envio el query
?>

en este caso debemos prevenir que $_GET['id'] no contenga ningún código malicioso.

Cuando trabajamos con bases de datos Oracle tenemos a nuestro disposición la función oci_bind_by_name que realizará un blindaje sobre los parámetros, un metodología similar a stmt de mysqli.

<?php
$conn = oci_connect("usuario", "contraseña", "localhost/XE");
if (!$conn) {
    $m = oci_error();
    trigger_error(htmlentities($m['message']), E_USER_ERROR);
}
 
$sql = 'SELECT id,nombre,apellido FROM personas WHERE id = :id';
$stid = oci_parse($conn, $sql);
$id = $_GET['id'];
oci_bind_by_name($stid, ':id', $id);
oci_execute($stid);
$fila = oci_fetch_array($stid, OCI_ASSOC);
print_r($fila);
 
oci_free_statement($stid);
oci_close($conn);
?>

Written by Daniel Segovia

diciembre 1st, 2011 at 4:35 pm

Recuperar el contenido desde Oracle

Hacer un comentario

oci_fetch_array es la función que usaremos para transformar la fila de base de datos en array para tenerlo disponible y poder imprimirlo o procesarlo donde querramos

<?php
 
$conn = oci_connect('usuario', 'contraseña', 'localhost/XE');
if (!$conn) {
    $e = oci_error();
    trigger_error(htmlentities($e['message'], ENT_QUOTES), E_USER_ERROR);
}
 
$stid = oci_parse($conn, 'SELECT id, nombre FROM personas');
oci_execute($stid);
 
while (($row = oci_fetch_array($stid, OCI_BOTH))) {
    // El array asociativo poseerá los índices en mayúsculas
    echo $row['ID'] . " - " . $row['NOMBRE'] . "\n<br/>";
}
 
oci_free_statement($stid); //libero la memoria
oci_close($conn); //cierro la conexión
 
?>

Written by Daniel Segovia

noviembre 29th, 2011 at 6:11 pm

ABM desde PHP a Oracle

Un comentario

Como en otras secciones del libro, mysql, sqlite y Microsoft SQL Server, para realizar un ABM necesitamos tener el código SQL correcto para enviarlo a la base de datos a través de una función que nos provee PHP, la función especifica para Oracle es oci_execute, pero para ejecutarla primero debemos preparar la cadena de texto SQL con oci_parse

<?php
//alta.php
$conn = oci_connect('usuario', 'contraseña', 'localhost/XE');
$query = "INSERT INTO mitabla (columna) VALUES ('valor')";
$stid = oci_parse($conn, $query);
oci_execute($stid); // La fila es comiteada y quedará disponible para todos los usuarios
?>
<?php
//baja.php
$conn = oci_connect('usuario', 'contraseña', 'localhost/XE');
$query = "DELETE FROM mitabla id = 10";
$stid = oci_parse($conn, $query);
oci_execute($stid); // La fila es comiteada y quedará disponible para todos los usuarios
?>
<?php
//modificacion.php
$conn = oci_connect('usuario', 'contraseña', 'localhost/XE');
$query = "UPDATE mitabla set columna='otro valor' WHERE id = 5";
$stid = oci_parse($conn, $query);
oci_execute($stid); // La fila es comiteada y quedará disponible para todos los usuarios
?>

Written by Daniel Segovia

noviembre 29th, 2011 at 1:08 pm

Posted in 5.6.3 ABM

Conectar a Oracle desde PHP

Hacer un comentario

PHP nos ofrece 2 posibilidad para conectarnos a Oracle

php_oracle
Es una librería un tanto antigua pero es una muy buena opción sí no deseamos trabajar con datos tipo BLOB o CLOB.

php_oci8
Librería que permite conectarse a Oracle Database desde la versión 8.0 y posteriores. Posee muchas más funciones y funciona con BLOB y CLOB.

Usaremos oci8 a lo largo de esta sección, para conectarnos lo haremos con la función oci_connect

<?php
// Conectandose al servicio "XE" sobre la dirección "localhost"
$conn = oci_connect('usuario', 'contraseña', 'localhost/XE');
if (!$conn) {
    $e = oci_error();
    trigger_error(htmlentities($e['message'], ENT_QUOTES), E_USER_ERROR);
}
echo 'Conectado';
?>

Written by Daniel Segovia

noviembre 21st, 2011 at 5:12 pm

Introducción a Oracle desde PHP

Hacer un comentario

OCI8 nos brinda una serie de funciones para trabajar con bases de datos Oracle 11g, 10g, 9i y 8i. Soportan sentencias SQL y PL/SQL. Incluyen transacciones, marcadores de posición oracle, LOB, colecciones, escalabilidad de la base de datos Oracle, agrupamiento de conexiones residentes o Resident Connection Pooling (DRCP) y el almacenamiento en cache de resultados

La página oficial de Oracle posee un manual de PHP y Oracle
Link directo al manual

Written by Daniel Segovia

noviembre 15th, 2011 at 5:51 pm

Recuperar el contenido en MS SQL Server

Hacer un comentario

PHP nos ofrece varias posibilidades para recuperar la información guardada en la base de datos MS SQL Server.
Veremos 2 funciones, mssql_fetch_array que nos recuperará el contenido de una fila como un array con índices numéricos y también mssql_fetch_assoc que nos traerá el contenido en forma de array con los índices de texto iguales a los nombres de los campos en la base de datos.

<?php
//fetch_array
$server = 'MISERVER\SQLEXPRESS';
 
// Conectando a MSSQL
$link = mssql_connect($server, 'sa', 'password');
 
if (!$link) {
    die('Ha ocurrido un error mientras intentaba conectarse a MSSQL');
}
 
$query = mssql_query('SELECT [usuario], [email] FROM [php].[dbo].[usuarios]');
 
while ($row = mssql_fetch_array($query, MSSQL_NUM)) {
    echo "Usuario: " . $row[0] . " - Email: " . $row[1] . "<br />";
}
?>
<?php
//fetch_assoc
$server = 'MISERVER\SQLEXPRESS';
 
// Conectando a MSSQL
$link = mssql_connect($server, 'sa', 'password');
 
if (!$link) {
    die('Ha ocurrido un error mientras intentaba conectarse a MSSQL');
}
 
$query = mssql_query('SELECT [usuario], [email] FROM [php].[dbo].[usuarios]');
 
while ($row = mssql_fetch_assoc($query)) {
    echo "Usuario: " . $row['usuario'] . " - Email: " . $row['email'] . "<br />";
}
?>

Written by Daniel Segovia

noviembre 4th, 2011 at 5:42 pm

ABM en MS SQL Server

Hacer un comentario

Tenemos la función mssql_query para ejecutar los querys, con la cadena de texto con sintaxis correcta de SQL procederemos a ejecutarlos en el motor de base de datos.

Código SQL

// Insertar
INSERT INTO clientes (razon_social, direccion) VALUES ('Pepsico', 'Florida 55202');
// Actualizar
UPDATE clientes SET razon_social = 'Pepsico Snack' WHERE id = 15;
// Eliminar
DELETE FROM clientes WHERE id = 15

Código para insertarlo en el motor MS SQL Server

<?php
//actualizar.php
$server = 'MISERVER\SQLEXPRESS';
 
// Conectando a MSSQL
$link = mssql_connect($server, 'sa', 'password');
 
if (!$link) {
    die('Ha ocurrido un error mientras intentaba conectarse a MSSQL');
}
$sql = "INSERT INTO clientes (razon_social, direccion) VALUES ('Pepsico', 'Florida 55202')";
mssql_query($sql);
?>
<?php
//insertar.php
$server = 'MISERVER\SQLEXPRESS';
 
// Conectando a MSSQL
$link = mssql_connect($server, 'sa', 'password');
 
if (!$link) {
    die('Ha ocurrido un error mientras intentaba conectarse a MSSQL');
}
$sql = "UPDATE clientes set razon_social = 'Pepsico Snack' WHERE id = 15";
mssql_query($sql);
?>
<?php
//eliminar.php
$server = 'MISERVER\SQLEXPRESS';
 
// Conectando a MSSQL
$link = mssql_connect($server, 'sa', 'password');
 
if (!$link) {
    die('Ha ocurrido un error mientras intentaba conectarse a MSSQL');
}
$sql = "DELETE FROM clientes WHERE id = 15";
mssql_query($sql);
?>

Written by Daniel Segovia

noviembre 1st, 2011 at 4:13 pm

Posted in 5.5.3 ABM

Conexión a MS SQL Server

Hacer un comentario

Para conectarnos a una base de datos Microsoft SQL Server PHP nos proporciona la función mssql_connect
Posee 4 parámetros, servidor, usuario, contraseña y nuevo link (devuelve un nuevo identificador), usualmente los 3 primeros son los más usados.

<?php
$server = 'MISERVER\SQLEXPRESS';
 
// Conectando a MSSQL
$link = mssql_connect($server, 'sa', 'password');
 
if (!$link) {
    die('Ha ocurrido un error mientras intentaba conectarse a MSSQL');
}
?>

Written by Daniel Segovia

noviembre 1st, 2011 at 3:23 pm

Posted in 5.5.2 Conexión

Introducción

Hacer un comentario

PHP brinda soporte para base de datos Microsoft SQL Server pero sobre la plataforma de Windows a partir de la versión 5.3 dejo de brindarle soporte.
Un driver alternativo para MS SQL está disponible para Microsoft: http://msdn.microsoft.com/en-us/sqlserver/ff657782.aspx

La lista de funciones disponibles son las siguientes

  • mssql_bind: Agrega un parámetro a un procedimiento almacenado o a un procedimiento almacenado remoto
  • mssql_close: Cierra una conexión MS SQL Server
  • mssql_connect: Abre una conexión MS SQL Server
  • mssql_data_seek: Mueve el puntero a la fila deseada
  • mssql_execute: Ejecuta un procedimiento almacenado sobre una base de datos MS SQL Server
  • mssql_fetch_array: Devuelve una fila del resultado como matriz asociativa, numérica o ambas
  • mssql_fetch_assoc: Devuelve una fila del resultado como matriz asociativa, con índices de texto
  • mssql_fetch_batch: Devuelve el siguiente lote de registros
  • mssql_fetch_field: Obtiene información del campo
  • mssql_fetch_object: Devuelve la fila como objeto
  • mssql_fetch_row: Obtiene registros como un array enumerado
  • mssql_field_length: Obtener la longitud de un campo
  • mssql_field_name: Obtener el nombre de un campo
  • mssql_field_seek: Mueve el puntero a un campo especifico
  • mssql_field_type: Obtiene el tipo de un campo
  • mssql_free_result: Libera el resultado de la memoria
  • mssql_free_statement: Libera la declaración de la memoria
  • mssql_get_last_message: Devuelve el último mensaje proveniente del Server
  • mssql_guid_string: Convierte un binario de 16 byte a un texto
  • mssql_init: Inicializa un procedimiento almacenado o un procedimiento almacenado remoto
  • mssql_min_error_severity: Establece la gravedad del error mínimo
  • mssql_min_message_severity: Establece la gravedad del mensaje mínimo
  • mssql_next_result: Mueve el puntero al siguiente resultado
  • mssql_num_fields: Gets the number of fields in result
  • mssql_num_rows: Obtiene el número de filas en el resultado
  • mssql_pconnect: Abre una conexión persistente/li>
  • mssql_query: Envía un query a la base MS SQL Server
  • mssql_result: Obtiene el resultado
  • mssql_rows_affected: Retorno el número de registros afectados por el query
  • mssql_select_db: Selecciona una base de datos MS SQL Server

Written by Daniel Segovia

octubre 31st, 2011 at 5:38 pm

Transacciones en Sqlite

Hacer un comentario

Una transacción es una secuencia de operaciones realizadas como una sola unidad lógica, ésta debe exponer 4 propiedades.

  1. Atomicidad: Asegura que la operación se ha realizado o no.
  2. Consistencia: Asegura que sólo empieza todo lo que se puede acabar.
  3. Aislamiento: Asegura que una operación no puede afectar a otras. Es decir, la realización de dos o más transacciones sobre la misma información sean independientes y no esto no producirá ningún tipo de error.
  4. Durabilidad: Asegura que una vez realizada la operación, ésta quedará persistente y no podrá deshacerse aunque el sistema.

Sí el motor de base de datos posee estás 4 propiedades éste puede ser considerado ACID Compliant (Atomicity, Consistency, Isolation and Durability)

Veamos el ejemplo de recuperar los datos con una transacción

<?php
$db = new SQLiteDatabase("db.sqlite");
 
// Traigo todos los registros de la tabla personas
$result = $db->query("BEGIN; SELECT * FROM personas; COMMIT;");
 
// ciclo el resultado
while($result->valid()) {
    $row = $result->current();
    echo $row['id'].' - '.$row['nombre'].' - '.$row['apellido'].'<br />';
    $result->next();
}
?>

Como puede observarse en el query poseemos BEGIN; y COMMIT; en medio de nuestra consulta que recupera los datos (los puntos y comas separan cada consulta). Esto se debe a que iniciamos una transacción en la base de datos, BEGIN da comienzo a ésta, luego se realiza el o los querys y por último COMMIT hace efectivos estos querys. Las transacciones nos dan la posibilidad de volver atrás en cualquier momento y deshacer todo lo hecho previamente con ROLLBACK.
Por ejemplo sí tenemos que crear 10 tablas podemos iniciar una transacción, sí por algún motivo los 6 primeros querys tienen la sintaxis correcta y no hacen ningún tipo de colisión y nuestra séptima instrucción da algún error con ROLLBACK podemos deshacer todos los querys después del comienzo de la transacción.

Es un tema muy amplio el de las transacciones y las bases de datos en general, así que como dije al principio del capítulo estaremos más abocados a aprender PHP

Written by Daniel Segovia

octubre 26th, 2011 at 1:32 pm

Recuperar el contenido en Sqlite

Hacer un comentario

El procedimiento es similar a los demás motores de base de datos.
Ejecutamos el query, ciclamos el resultado y cuando no hay más contenido el método nos devolverá false y esto acabará con el ciclo while

<?php
$db = new SQLiteDatabase("db.sqlite");
 
// Traigo todos los registros de la tabla personas
$result = $db->query("SELECT * FROM personas");
 
// ciclo el resultado
while($result->valid()) {
    $row = $result->current();
    echo $row['id'].' - '.$row['nombre'].' - '.$row['apellido'].'<br />';
    $result->next();
}
?>

Written by Daniel Segovia

octubre 24th, 2011 at 1:34 pm

Alta, baja y modificación en Sqlite

Hacer un comentario

Como hemos visto en el ejemplo de creación de tablas con sqlite, solamente tenemos que enviar el código correcto en lenguaje SQL a través del método query, para realizar un ABM seguiremos éste mismo camino.
Tendremos nuestro código SQL y lo enviaremos al motor de base de datos.
Usaremos el modelo de la tabla que ya hemos creado.

Aquí todo en lenguaje SQL

//Insetar (A = alta)
INSERT INTO personas (nombre, apellido) VALUES ('Juan', 'Car');
//Actualizar (M = modificar)
UPDATE personas SET apellido = 'Perez' WHERE id = 5
//Eliminar (B = baja)
DELETE FROM personas WHERE id = 10

Código para insertar en Sqlite

<?php
$db = new SQLiteDatabase("db.sqlite");
// Inserto un registro en la tabla personas
$sql = "INSERT INTO personas (nombre, apellido) VALUES ('Juan', 'Car');";
$db->query($sql);
?>

Código para actualizar en Sqlite

<?php
$db = new SQLiteDatabase("db.sqlite");
// Actualizo el registro id=5 en la tabla personas
$sql = "UPDATE personas set apellido = 'Perez' WHERE id = 5";
$db->query($sql);
?>

Código para eliminar en Sqlite

<?php
$db = new SQLiteDatabase("db.sqlite");
// Elimino el registro id=10 en la tabla personas
$sql = "DELETE FROM personas WHERE id = 10";
$db->query($sql);
?>

Written by Daniel Segovia

octubre 19th, 2011 at 12:33 pm

Tablas en Sqlite

Hacer un comentario

Actualmente no he probado ningún gestor de Sqlite, mi manera para crear las tablas es a la vieja usanza, con el código SQL.
El código SQL (al igual que en los motores de base de datos que ya hemos visto) es simplemente una cadena de texto que mediante un método o función le es enviada a la base de datos para que sea procesado.
Al instanciar la clase sqlite nos encontramos con una lista de métodos, query es el que nos permitirá realizar el envío del código a la base.
Para crear las tablas usaremos el siguiente código SQL

    CREATE TABLE personas (
      id INTEGER PRIMARY KEY,
      nombre VARCHAR(255) NOT NULL,
      apellido VARCHAR(255) NOT NULL
    );

Ahora el ejemplo completo con PHP

<?php
$db = new SQLiteDatabase("db.sqlite");
// Creo la tabla personas
$db->query("
    CREATE TABLE personas (
      id INTEGER PRIMARY KEY,
      nombre varchar(255) NOT NULL,
      apellido varchar(255) NOT NULL
    );
");
?>

Written by Daniel Segovia

octubre 18th, 2011 at 6:04 pm

Posted in 5.4.3 Tablas

Crear una base de datos con sqlite

Hacer un comentario

Crear una base de datos con sqlite es sumamente sencillo, solo basta con instanciar la clase para que esta sea creada.
En la instancia el primer parámetro será el nombre de la base, sí no existe intentara crearla y sí ya previamente existe solamente generará la instancia de la clase y la base quedará seleccionada.

<?php
$bd_nombre = 'base';
 
$objeto = new SQLiteDatabase($bd_nombre, 0666, $error);
if ($error){
    exit($error);
}
?>

Written by Daniel Segovia

octubre 11th, 2011 at 6:48 pm

PHP y Sqlite

Hacer un comentario

SQLite es una librería escrita en C que implementa un motor de base de datos SQL.
Con PHP podemos tener acceso a una base de datos SQL, sin tener que ejecutar un programa de RDBMS separado, esto reduce el tiempo de conexión y también de las transacciones siguientes.
La base de datos y su definición (tablas, índices y los datos), son guardados como un sólo archivo en donde esta corriendo el script. Este diseño simple se logra bloqueando todo el fichero de base de datos al principio de cada transacción.

Sus desarrolladores resaltan que sus principales características:

  • Completo soporte para tablas e índices en un único archivo por base de datos
  • Soporte transaccional
  • Rapidez, unas 2 veces mas veloz que MySQL y PostgreSQL
  • Escaso tamaño de la librería
  • Completa portabilidad.

Written by Daniel Segovia

octubre 6th, 2011 at 4:45 pm

Seguridad con stmt

Hacer un comentario

La seguridad en las consultas enviadas a la base de datos la daremos con el método bind_param.
Éste método agrega variables a una sentencia preparada como parámetros.
bind_param buscará en la sentencia preparada todos los signos de pregunta ? y los reemplazará por las variables que le asignemos.
Es obligatorio indicar de que tipo es el valor que estamos inyectando, la sintaxis es la siguiente

SELECT * from paises WHERE nombre = ?
bind_param('s', 'Argentina');
SELECT * from paises WHERE nombre = 'Argentina'

Como puede observarse en la primera línea tenemos “nombre = ?”, no escapamos los caracteres ni tampoco agregamos las comillas que encierran la cadena de texto.
El primer parámetro ‘s’ indica que la variable que vamos a reemplazar es de tipo string, aquí la tabla con los tipos permitidos

  • i variable de tipo entero
  • d variable de tipo doble
  • s variable de tipo texto
  • b variable de tipo blob y se envía en paquetes

Un ejemplo concreto

<?php
$mysqli = new mysqli("localhost", "usuario", "password", "base");
 
if (mysqli_connect_errno()) {
    printf("Imposible conectarse: %s\n", mysqli_connect_error());
    exit();
}
 
$cliente = 'coto'; 
 
$query = "SELECT client, partner FROM business WHERE client=?";
 
/* Ejecuto el método prepare y este me va a devolver el objeto */
if ($stmt = $mysqli->prepare($query)) {
 
    $stmt->bind_param('s', $cliente);
 
    /* ejecuto el  query */
    $stmt->execute();
 
    $stmt->bind_result($client, $partner);
 
    $stmt->fetch();
 
    /* cierro stmt */
    $stmt->close();
}
 
echo $client . "<br />";
echo $partner . "<br />";
 
$mysqli->close();
?>

Muchas veces necesitamos inyectar más de una variable en una misma consulta preparada, de esta manera podemos ingresar ilimitadas variables

<?php
$mysqli = new mysqli("localhost", "usuario", "password", "base");
 
if (mysqli_connect_errno()) {
    printf("Imposible conectarse: %s\n", mysqli_connect_error());
    exit();
}
 
$cliente = 'coto'; 
$product_id = 1;
 
$query = "SELECT client, partner FROM business WHERE client=? AND product_id=?";
 
/* Ejecuto el método prepare y este me va a devolver el objeto */
if ($stmt = $mysqli->prepare($query)) {
    /* El primero parámetro es tipo string y el segundo es entero */
    $stmt->bind_param('si', $cliente, $product_id);
 
    /* ejecuto el  query */
    $stmt->execute();
 
    $stmt->bind_result($client, $partner);
 
    $stmt->fetch();
 
    /* cierro stmt */
    $stmt->close();
}
 
echo $client . "<br />";
echo $partner . "<br />";
 
$mysqli->close();
?>

Written by Daniel Segovia

septiembre 29th, 2011 at 12:25 pm

Recuperar datos con stmt

Hacer un comentario

Para recuperar datos con stmt es sencillo y seguro, nos proporciona los métodos bind_result y fetch para realizar esta acción.
Con bind_result le indicaremos los nombres de variable con el que queremos que nos los datos de cada columna y con fetch asignaremos a éstas variables los datos extraídos de la base de datos.

<?php
$mysqli = new mysqli("localhost", "usuario", "passwords", "negocios");
 
if (mysqli_connect_errno()) {
    printf("Imposible conectarse: %s\n", mysqli_connect_error());
    exit();
}
 
$query = "SELECT client, partner FROM business LIMIT 1";
 
/* Ejecuto el método prepare y este me va a devolver el objeto */
if ($stmt = $mysqli->prepare($query)) {
 
    /* ejecuto el  query */
    $stmt->execute();
 
    /* Por cada columna necesito un nombre de variable */
    $stmt->bind_result($client, $partner);
 
    /* Con fetch le asigno a $client y $partner los valores de la DB respectivamente */
    $stmt->fetch();
 
    /* cierro stmt */
    $stmt->close();
}
 
echo $client . "<br />";
echo $partner . "<br />";
 
$mysqli->close();
?>

Para recuperar muchos registros de la db ciclaremos el método fetch, para que por cada vuelta nos asigne los valores en las variables definidas en bind_fetch

<?php
$mysqli = new mysqli("localhost", "usuario", "passwords", "negocios");
 
if (mysqli_connect_errno()) {
    printf("Imposible conectarse: %s\n", mysqli_connect_error());
    exit();
}
 
$query = "SELECT client, partner FROM business LIMIT 10";
 
/* Ejecuto el método prepare y este me va a devolver el objeto */
if ($stmt = $mysqli->prepare($query)) {
 
    /* ejecuto el  query */
    $stmt->execute();
 
    /* Por cada columna necesito un nombre de variable */
    $stmt->bind_result($client, $partner);
 
    /* Con fetch le asigno a $client y $partner los valores de la DB respectivamente */
    while($stmt->fetch()){
        echo $client . "<br />";
        echo $partner . "<br />";
    }
 
    /* cierro stmt */
    $stmt->close();
}
 
$mysqli->close();
?>

Written by Daniel Segovia

septiembre 28th, 2011 at 4:03 pm

Posted in 5.3.5 STMT

Tagged with , , , ,

Ejecutar un query con stmt

Hacer un comentario

Para ejecutar un query con stmt previamente tenemos que prepararlo con el método prepare, sí la sintaxis del query es correcta podremos ejecutarlo

<?php
$mysqli = new mysqli("localhost", "usuario", "password", "base");
 
if (mysqli_connect_errno()) {
    printf("Imposible conectarse: %s\n", mysqli_connect_error());
    exit();
}
 
$query = "SELECT client, partner FROM business LIMIT 1";
 
/* Ejecuto el método prepare y este me va a devolver el objeto */
if ($stmt = $mysqli->prepare($query)) {
 
    /* ejecuto el  query */
    $stmt->execute();
 
    /* cierro stmt */
    $stmt->close();
}
 
$mysqli->close();
?>

Written by Daniel Segovia

septiembre 28th, 2011 at 2:06 pm

STMT

Hacer un comentario

STMT representa una consulta preparada, aquí la definición de la clase.

MySQLi_STMT {
    /* Propiedades */
    int $MySQLi_STMT->affected_rows;
    int $errno;
    string $error;
    int $field_count;
    int $insert_id;
    int $num_rows;
    int $param_count;
    string $sqlstate;
 
    /* Métodos */
    int mysqli_stmt_affected_rows ( mysqli_stmt $stmt )
    int mysqli_stmt::attr_get ( int $attr )
    bool mysqli_stmt::attr_set ( int $attr , int $mode )
    bool mysqli_stmt::bind_param ( string $types , mixed &$var1 [, mixed &$... ] )
    bool mysqli_stmt::bind_result ( mixed &$var1 [, mixed &$... ] )
    bool mysqli_stmt::close ( void )
    void mysqli_stmt::data_seek ( int $offset )
    int mysqli_stmt_errno ( mysqli_stmt $stmt )
    string mysqli_stmt_error ( mysqli_stmt $stmt )
    bool mysqli_stmt::execute ( void )
    bool mysqli_stmt::fetch ( void )
    int mysqli_stmt_field_count ( mysqli_stmt $stmt )
    void mysqli_stmt::free_result ( void )
    mysqli_result mysqli_stmt::get_result ( void )
    object mysqli_stmt::get_warnings ( mysqli_stmt $stmt )
    mixed mysqli_stmt_insert_id ( mysqli_stmt $stmt )
    int mysqli_stmt_num_rows ( mysqli_stmt $stmt )
    int mysqli_stmt_param_count ( mysqli_stmt $stmt )
    mixed mysqli_stmt::prepare ( string $query )
    bool mysqli_stmt::reset ( void )
    mysqli_result mysqli_stmt::result_metadata ( void )
    bool mysqli_stmt::send_long_data ( int $param_nr , string $data )
    string mysqli_stmt_sqlstate ( mysqli_stmt $stmt )
    bool mysqli_stmt::store_result ( void )
}

Y aquí una breve descripción de los métodos

  • mysqli_stmt::affected_rows — Devuelve el número total de filas en la última sentencia ejecutada
  • mysqli_stmt::attr_get — Se utiliza para obtener el valor actual de un atributo de la sentencia
  • mysqli_stmt::attr_set — Se utiliza para modificar el comportamiento de una sentencia preparada
  • mysqli_stmt::bind_param — Agrega variables a una sentencia preparada como parámetros
  • mysqli_stmt::bind_result — Enlaza variables a una sentencia preparada para el almacenamiento de resultados
  • mysqli_stmt::close — Cierra una sentencia preparada
  • mysqli_stmt::data_seek — Posiciona el puntero en una fila arbitraria
  • mysqli_stmt::errno — Devuelve el código de error de la última sentencia ejecutada
  • mysqli_stmt::error — Retorno un texto con la descripción de la última sentencia ejecutada erronea
  • mysqli_stmt::execute — Ejecuta el Query preparado
  • mysqli_stmt::fetch — Obtiene los resultados de una sentencia preparada en las variables
  • mysqli_stmt::field_count — Devuelve el número de campo en la instrucción dada
  • mysqli_stmt::free_result — Libera la memoria almacenada en una sentencia ejecutada
  • mysqli_stmt::get_result — Obtiene un conjunto de resultados a partir de una sentencia preparada
  • mysqli_stmt::get_warnings — Obtiene los resultados de SHOW WARNINGS
  • mysqli_stmt::insert_id — Obtiene el ID generado en el último INSERT realizado
  • mysqli_stmt::num_rows — Obtiene el número de filas de la sentencia ejecutada
  • mysqli_stmt::param_count — Retorno el número de parametros
  • mysqli_stmt::prepare — Prepara un SQL para su ejección
  • mysqli_stmt::reset — Resetea un SQL preparado
  • mysqli_stmt::result_metadata — Devuelve un conjunto de metadatos de resultados de una sentencia preparada
  • mysqli_stmt::send_long_data — Envía los datos en bloques
  • mysqli_stmt::sqlstate — Devuelve el error SQLSTATE de la operación anterior
  • mysqli_stmt::store_result — Transfiere un conjunto de resultados de una sentencia preparada

Veremos en profundidad algunos de éstos métodos

Written by Daniel Segovia

septiembre 20th, 2011 at 1:01 pm

Posted in 5.3.5 STMT

Recuperar el contenido como objeto

Hacer un comentario

Para recuperar el contenido en forma de objeto usaremos el método fetch_object
El método nos devolverá un objeto con los resultados y cada propiedad tendrá el nombre del campo en la tabla.
Sí el método devuelve NULL es por que no hay más resultados.

En este ejemplo haremos una consulta con la condición que nos traiga una sola fila (LIMIT 1)

<?php
$mysqli = new mysqli("localhost", "user", "pass", "negocios");
 
if (mysqli_connect_errno()) {
    printf("Imposible conectarse: %s\n", mysqli_connect_error());
    exit();
}
 
$query = "SELECT client, partner FROM business LIMIT 1";
$result = $mysqli->query($query);
 
/* Objeto */
$row = $result->fetch_object();
echo "Client: " . $row->client . "<br />Partner: " . $row->partner . "<hr />";
$mysqli->close();
?>

Sí la consulta nos trae más de un resultado podemos ciclarla con while, como en los ejemplos anteriores, hasta que se acaben los resultados, el ciclo terminará cuando el método nos devuelva NULL

<?php
$mysqli = new mysqli("localhost", "user", "pass", "negocios");
 
if (mysqli_connect_errno()) {
    printf("Imposible conectarse: %s\n", mysqli_connect_error());
    exit();
}
 
$query = "SELECT client, partner FROM business";
$result = $mysqli->query($query);
 
/* objeto */
while($row = $result->fetch_object()){
    echo "Client: " . $row->client . "<br />Partner: " . $row->partner . "<hr />";
}
$mysqli->close();
?>

Written by Daniel Segovia

septiembre 20th, 2011 at 11:46 am

Recuperar el contenido como array con índices de texto

2 comentarios

Para recuperar el contenido en forma de array con índices de texto usaremos el método fetch_assoc
El método nos devolverá una fila de resultados y los índices del array tendrán el nombre del campo en la tabla o NULL en caso que no haya resultados.

En este ejemplo haremos una consulta con la condición que nos traiga una sola fila (LIMIT 1)

<?php
$mysqli = new mysqli("localhost", "user", "pass", "database");
 
if (mysqli_connect_errno()) {
    printf("Imposible conectarse: %s\n", mysqli_connect_error());
    exit();
}
 
$query = "SELECT client, partner FROM business LIMIT 1";
$result = $mysqli->query($query);
 
/* array numérico */
$row = $result->fetch_assoc();
echo "Client: " . $row['client'] . "<br />Partner: " . $row['partner'];
$mysqli->close();
?>

Si la consulta nos trae más de un resultado podemos ciclarla con while hasta que se acaben los resultados, el ciclo terminará cuando el método nos devuelva NULL

<?php
$mysqli = new mysqli("localhost", "user", "pass", "database");
 
if (mysqli_connect_errno()) {
    printf("Imposible conectarse: %s\n", mysqli_connect_error());
    exit();
}
 
$query = "SELECT client, partner FROM business";
$result = $mysqli->query($query);
 
/* array numérico en cada vuelta del ciclo*/
while($row = $result->fetch_assoc()){
    echo "Client: " . $row['client'] . "<br />Partner: " . $row['partner'] . "<hr />";
}
$mysqli->close();
?>

Written by Daniel Segovia

septiembre 5th, 2011 at 2:10 pm

Recuperar el contenido como array con índices numéricos

Hacer un comentario

Para recuperar el contenido en forma de array con índices numéricos usaremos el método fetch_array
El método nos devolverá una fila de resultados o NULL en caso que no haya resultados.

En este ejemplo haremos una consulta con la condición que nos traiga una sola fila (LIMIT 1)

<?php
$mysqli = new mysqli("localhost", "user", "pass", "database");
 
if (mysqli_connect_errno()) {
    printf("Imposible conectarse: %s\n", mysqli_connect_error());
    exit();
}
 
$query = "SELECT client, partner FROM business LIMIT 1";
$result = $mysqli->query($query);
 
/* array numérico */
$row = $result->fetch_array();
echo "Client: " . $row[0] . "<br />Partner: " . $row[1];
$mysqli->close();
?>

Si la consulta nos trae más de un resultado podemos ciclarla hasta que se acaben los resultados, el ciclo terminará cuando el método nos devuelva NULL

<?php
$mysqli = new mysqli("localhost", "user", "pass", "database");
 
if (mysqli_connect_errno()) {
    printf("Imposible conectarse: %s\n", mysqli_connect_error());
    exit();
}
 
$query = "SELECT client, partner FROM business";
$result = $mysqli->query($query);
 
/* array numérico en cada vuelta del ciclo*/
while($row = $result->fetch_array()){
    echo "Client: " . $row[0] . "<br />Partner: " . $row[1] . "<hr />";
}
$mysqli->close();
?>

Written by Daniel Segovia

agosto 24th, 2011 at 1:27 pm

Recuperar el contenido con Mysqli

Hacer un comentario

Extraeremos la información de la base de datos en 4 pasos

  • Nos conectamos (mysqli)
  • Preparamos la sentencia SQL (prepare)
  • La ejecutamos (execute)
  • Definimos variables para asignar los resultados (bind_result(
  • Recorremos las filas (fetch)
<?php
$mysqli = new mysqli("localhost", "root", "", "teste");
 
if (mysqli_connect_errno()) {
    echo "No se pudo conectar: " . mysqli_connect_error();
    exit();
}
 
$sql = "SELECT nombre, apellido FROM personas";
 
if ($stmt = $mysqli->prepare($sql)) {
    $stmt->execute();
 
    $stmt->bind_result($nombre, $apellido);
 
     while ($stmt->fetch()) {
        echo "$nombre $apellido<br />";
    }
 
    $stmt->close();
}
 
$mysqli->close();
?>

Written by Daniel Segovia

agosto 1st, 2011 at 5:40 pm

Enviar una consulta con mysqli

Hacer un comentario

Para enviar una consulta tenemos el método query, el mismo lo tendremos disponible luego de instanciar la clase

<?php 
$mysqli = new mysqli('localhost', 'usuario', 'contrasena', 'test');
 
/* Testeamos que se haya conectado correctamente */
if (mysqli_connect_errno()) {
    echo "Error en la conexión: " . mysqli_connect_error();
    die();
}
 
$sql = "SELECT * FROM usuarios";
if(!$result = $mysqli->query($sql)){
    die("Query invalido: " . $sql);
}
 
echo "Todo correcto";
$mysqli->close();
?>

Written by Daniel Segovia

julio 19th, 2011 at 12:07 pm

Seleccionar base de datos con mysqli

Hacer un comentario

La clase mysqli nos proporciona el método select_db, luego de abrir la conexión usaremos este método para seleccionar la base con la que trabajaremos posteriormente.

Usaremos la manera abreviada para conectarnos, osea desde el constructor.

<?php 
$mysqli = new mysqli('localhost', 'root', '');
 
/* Testeamos que se haya conectado correctamente */
if (mysqli_connect_errno()) {
    echo "Error en la conexión: " . mysqli_connect_error();
    die();
}
 
if(!$mysqli->select_db("test")){
    echo "Imposible seleccionar la base de datos: " . mysqli_connect_error();
    die();
}
$mysqli->close();
?>

Por otro lado, otra forma de seleccionar la base de datos es desde el constructor con el cuarto parámetro. Esta es la manera más común de generar la conexión y seleccionar la base de datos, de aquí en adelante usaremos esta manera para realizar las conexiones.

<?php 
$mysqli = new mysqli('localhost', 'usuario', 'contrasena', 'test');
 
/* Testeamos que se haya conectado correctamente */
if (mysqli_connect_errno()) {
    echo "Error en la conexión: " . mysqli_connect_error();
    die();
}
echo "Conectado ...";
$mysqli->close();
?>

Written by Daniel Segovia

julio 12th, 2011 at 12:34 pm

Conexión con mysqli

Hacer un comentario

Para abrir una conexión poseemos el método real_connect dentro de la clase mysqli
Primero instanciamos la clase para obtener el objeto que nos proporcionará el método para conectarnos.

<?php
$db = new mysqli;
if (!$db->real_connect('localhost', 'usuario', 'contrasena')) {
    echo "Error en la conexión: " . mysqli_connect_error();
    die();
}
echo "Conectado";
$mysqli->close();
?>

Por otro lado, mysqli, no proporciona la posibilidad de conectarnos al servidor MySQL desde el constructor de la clase, los 3 primeros parametros son host, usuario y contraseña.

<?php 
$mysqli = new mysqli('localhost', 'usuario', 'contrasena');
 
/* Testeamos que se haya conectado correctamente */
if (mysqli_connect_errno()) {
    echo "Error en la conexión: " . mysqli_connect_error();
    die();
}
echo "Conectado";
$mysqli->close();
?>

Written by Daniel Segovia

julio 11th, 2011 at 1:49 pm

Posted in 5.3.1 Conexión

PHP y MySQLi

Hacer un comentario

La extensión mysqli permite acceder a la funcionalidad proporcionada por MySQL 4.1 y superior, para contar con esta funcionalidad debe compilar PHP con soporte para mysqli.
Ésta extensión viene incluida en PHP 5 y versiones posteriores.

Ventajas de mysqli sobre la extensión mysql

  • Interfaz orientada a objetos
  • Soporte para Declaraciones Preparadas
  • Soporte para Múltiples Declaraciones
  • Soporte para Transacciones
  • Mejoradas las opciones de depuración
  • Soporte para servidor empotrado

El manual de PHP recomienda encarecidamente usar esta extensión si están trabajando con MySQL versión 4.1.3 o superior.
La extensión mysqli está desarrollada mediante el framework de extensiones de PHP. Su código fuente se ubica en el directorio ext/mysqli.

Written by Daniel Segovia

julio 8th, 2011 at 1:36 pm

Posted in 5.3 PHP y MySQLi

Tagged with , ,

Insertar, modificar y eliminar

Un comentario

Veremos como realizar las acciones de agregar, editar y eliminar datos de la base de datos a la que estemos conectados.
Estás acciones son código SQL que posteriormente se ejecutará con mysql_query, este capítulo podría ser obviado ya que no veremos ninguna función nueva de PHP, pero considero importante saberlo ya que con estás 4 opciones (seleccionar, insertar, editar y eliminar) se nos abren un abanico de posibilidad a realizar.

Vamos a definir la tabla para trabajar con una estructura definida.

Tenemos una tabla llamada personas que posee los campos id, nombre y apellido
estructura tabla

<?php
//insertar.php
$identificador = mysql_connect('localhost', 'usuario', 'contrasena');
if (!$identificador) {
    die('No se pudo conectar : ' . mysql_error());
}
 
$db_seleccionada = mysql_select_db('nombre_base', $identificador);
if (!$db_seleccionada) {
    die ("Imposible usar  nombre_base " . mysql_error());
}
 
//Consulta
$sql = "INSERT INTO personas (nombre, apellido) VALUES ('Daniel', 'Segovia')";
$resultado = mysql_query($sql, $identificador);
if (!$resultado) {
    die('Query invalido: ' . mysql_error());
}
echo "Insercción exitosa";
?>

Actualización

<?php
//modificar.php
$identificador = mysql_connect('localhost', 'usuario', 'contrasena');
if (!$identificador) {
    die('No se pudo conectar : ' . mysql_error());
}
 
$db_seleccionada = mysql_select_db('nombre_base', $identificador);
if (!$db_seleccionada) {
    die ("Imposible usar  nombre_base " . mysql_error());
}
 
$sql = "UPDATE personas set nombre='Daniel'";
$resultado = mysql_query($sql, $identificador);
if (!$resultado) {
    die('Query invalido: ' . mysql_error());
}
 
/*Aquí en este ejemplo actualiza el campo nombre con el texto Daniel, pero nosotros
no estamos indicando que registro queremos actualizar, por lo que va a actualizar 
todos los nombres de la tabla personas, para evitar esto en SQL existe la 
clausula WHERE, donde especificaremos la condición que deseemos.*/
 
$sql = "UPDATE personas set nombre='Daniel' WHERE nombre='Dani'";
$resultado = mysql_query($sql, $identificador);
if (!$resultado) {
    die('Query invalido: ' . mysql_error());
}
/*De esta manera solamente actualizará los registros que contengan Dani*/
 
/*Si deseamos modificar un registro especifico podemos acceder a él por ID*/
$sql = "UPDATE personas set nombre='Daniel' WHERE id=30";
$resultado = mysql_query($sql, $identificador);
if (!$resultado) {
    die('Query invalido: ' . mysql_error());
}
/*Actualizaremos el nombre a Daniel en el registro id igual a 30 */
 
echo "Actualizaciones exitosas";
?>

Eliminación

<?php
//eliminar.php
$identificador = mysql_connect('localhost', 'usuario', 'contrasena');
if (!$identificador) {
    die('No se pudo conectar : ' . mysql_error());
}
 
$db_seleccionada = mysql_select_db('nombre_base', $identificador);
if (!$db_seleccionada) {
    die ("Imposible usar  nombre_base " . mysql_error());
}
 
$sql = "DELETE FROM personas WHERE id = 40";
$resultado = mysql_query($sql, $identificador);
if (!$resultado) {
    die('Query invalido: ' . mysql_error());
}
echo "Eliminación correcta";
?>

En este último ejemplo directamente eliminamos el registro con id igual a 40

Written by Daniel Segovia

julio 7th, 2011 at 7:18 pm

Recuperar múltiples filas

Hacer un comentario

Las funciones mysql_fetch_assoc y mysql_fetch_array nos crean un array de 1 fila, pero la consulta puede traernos muchas más filas. Para acceder fila por fila debemos ciclar el resource del query que realizamos, cuando las funciones nos devuelvan un false querrá decir que no quedan más filas por lo que concluiremos el ciclo.
Como es un ciclo condicional usaremos while

<?php
$link = mysql_connect('localhost', 'usuario', 'contrasena');
if (!$link) {
    die('No se pudo conectar: ' . mysql_error());
}
if (!mysql_select_db('base_nombre')) {
    die('No puede seleccionarse "base_nombre" con esta conexión : ' . mysql_error());
}
$result = mysql_query('SELECT nombre, apellido, direccion FROM estudiantes');
if (!$result) {
    die('Error al ejecutar el query:' . mysql_error());
}
while($row = mysql_fetch_assoc($result)){
    echo $row['nombre']  . " - " . $row['apellido']  . " - " . $row['direccion']  . "<br />";
}
?>

Written by Daniel Segovia

julio 4th, 2011 at 10:46 pm

Recuperar el contenido

Un comentario

Hasta ahora hemos visto como conectarnos, seleccionar y ejecutar un query en una base de datos MySQL.
Es hora de ejecutar un query y traer esa información para poder manipularla en PHP.
Existen varias funciones para este trabajo, veremos 3, mysql_result, mysql_fetch_array y mysql_fetch_assoc.

mysql_result recuperará en contenido de una celda.

<?php
$link = mysql_connect('localhost', 'usuario', 'contrasena');
if (!$link) {
    die('No se pudo conectar: ' . mysql_error());
}
if (!mysql_select_db('base_nombre')) {
    die('No puede seleccionarse "base_nombre" con esta conexión : ' . mysql_error());
}
$result = mysql_query('SELECT nombre FROM estudiantes');
if (!$result) {
    die('Error al ejecutar el query:' . mysql_error());
}
echo mysql_result($result, 1); // Imprimirá el segundo nombre de la tabla (el primero esta en la posición 0)
?>

mysql_fetch_array generará una array con índices numericos, empezando desde el 0, por cada campo que traiga la consulta

<?php
$link = mysql_connect('localhost', 'usuario', 'contrasena');
if (!$link) {
    die('No se pudo conectar: ' . mysql_error());
}
if (!mysql_select_db('base_nombre')) {
    die('No puede seleccionarse "base_nombre" con esta conexión : ' . mysql_error());
}
$result = mysql_query('SELECT nombre, apellido, direccion FROM estudiantes');
if (!$result) {
    die('Error al ejecutar el query:' . mysql_error());
}
$row = mysql_fetch_array($result);
echo $row[0]  . " - " . $row[1]  . " - " . $row[2]  . " - ";
?>

mysql_fetch_assoc generará una array con índices que serán iguales a los nombres de los campos en la base de datos

<?php
$link = mysql_connect('localhost', 'usuario', 'contrasena');
if (!$link) {
    die('No se pudo conectar: ' . mysql_error());
}
if (!mysql_select_db('base_nombre')) {
    die('No puede seleccionarse "base_nombre" con esta conexión : ' . mysql_error());
}
$result = mysql_query('SELECT nombre, apellido, direccion FROM estudiantes');
if (!$result) {
    die('Error al ejecutar el query:' . mysql_error());
}
$row = mysql_fetch_assoc($result);
echo $row['nombre']  . " - " . $row['apellido']  . " - " . $row['direccion']  . " - ";
?>

Written by Daniel Segovia

julio 4th, 2011 at 10:36 pm