Categoría: Informática

Leyendo ficheros CSV con PHP

en por Donnie Rocken Informática, Lenguajes de programación6 comentarios

A petición de Jorge de Saliceta, que lo reclamó en la entrada sobre lectura de ficheros en PHP va la explicación sobre cómo leer ficheros CSV con PHP. No es la primera vez que en este blog hablamos sobre el formato CSV (comma separated values).

Bueno, si te vas a la entrada de lectura de ficheros verás que para la lectura secuencial, línea a línea, usábamos la función fgets(). Bueno, pues existe una función similar, llamada fgetcsv(), pensada para trabajar con archivos de este tipo. En lugar de devolver una cadena de texto como fgets(), esta función lo que devuelve por cada línea recorrida es un array, donde cada valor separado por una coma ocupa una de las posiciones del mismo. Veamos un ejemplo:

//supongamos la siguiente fila en un csv:
//Manolo, Rodríguez, Málaga, Fontanero
//y que está guardado en el archivo prueba.csv
//Aplicaríamos el siguiente código

<?php
$file = fopen("prueba.csv","r");
$result = fgetcsv($file);
fclose($file);
?> 

//esto devolvería un array con el siguiente resultado:
Array
(
[0] => Manolo
[1] => Rodríguez
[2] => Málaga
[3] => Fontanero
)

Cuestiones a tener en cuenta hay varias. La primera es que si pilla una línea en blanco devolverá una matriz con un sólo campo con el valor NULL. La segunda es que existen varios parámetros que podemos pasar: Obligatorio, desde PHP5, sólo es el archivo a parsear, pero también acepta la longitud máxima de línea (si la sabes pásalo, porque hará que la función vaya más rápido), el delimitador de campo (por defecto, la coma), el «cercado» de campo (por defecto comillas dobles… ya se que lo de cercado no es muy claro, en inglés sería enclosure) y el caracter de escape (por defecto, la barra invertida). Al igual que con fgets() puede haber problemas para detectar los finales de fila en archivos creados en un Mac, y también hay que tener en cuenta que la función tiene en cuenta la configuración local, así que si estás trabajando con UTF8 tenlo en cuenta a la hora de calcular el tamaño máximo de línea o con los archivos codificados en one-byte.

Finalmente os dejo un gran ejemplo del funcionamiento de esta función sacado de la web de php:


<?php
$fila = 1;
if (($gestor = fopen("test.csv", "r")) !== FALSE) {
    while (($datos = fgetcsv($gestor, 1000, ",")) !== FALSE) {
        $numero = count($datos);
        echo "<p> $numero de campos en la línea $fila: <br /></p>\n";
        $fila++;
        for ($c=0; $c < $numero; $c++) {
            echo $datos[$c] . "<br />\n";
        }
    }
    fclose($gestor);
}
?>

Leer ficheros de texto con PHP

en por Donnie Rocken Informática, Lenguajes de programación2 comentarios

Uno de esos posts a petición de un lector: ¿cómo leer un fichero de texto con PHP? Bueno, a día de hoy no es una práctica muy usada, tal vez sea algo que suena más a tiempos pasados, pero hace año y pico en un trabajo por ejemplo tuve que hacerlo (y no veáis la lata que daba tratar los datos cuando una tabla de MySQL habría ahorrado muchísimo trabajo, pero eso es otra historia).

Bueno, para leer un fichero debemos usar la función fopen(), pasándole como primer parámetro la dirección del fichero a abrir y como segundo el modo (para lectura r, para escritura w).

Entonces, para leer fopen(«archivo.txt», «r»), y ahora tenemos dos opciones: cargar todo el contenido de golpe o ir leyendo línea a línea.

Para cargar todo el contenido de golpe la cosa sería más o menos así:

function leer_completo($direccion_fichero){
   $fichero = fopen ($direccion_fichero, "r");   
   $contenido = fread($fichero, filesize($direccion_fichero));
   return $contenido;
}

Esto devolvería una variable con todo el contenido del fichero. Para la lectura línea a línea en cambio necesitaremos un bucle y la función fgets() en lugar de fread().


<?php
$gestor = @fopen("/tmp/inputfile.txt", "r");
if ($gestor) {
    while (($búfer = fgets($gestor, 4096)) !== false) {
        echo $búfer;
    }
    if (!feof($gestor)) {
        echo "Error: fallo inesperado de fgets()\n";
    }
    fclose($gestor);
}
?>

En este caso ya os pego el ejemplo que aparece en la web oficial de php. En ese caso se especifica a fgets() el parámetro del tamaño a leer. Y es que puedes especificarle el tamaño de bloque que debe hacer en cada lectura o, por el contrario, no pasarle ningún parámetro y que lea hasta el final de línea. Esto último puede dar problemas con archivos creados en un Mac, pero se puede solventar activando la opcion en tiempo de ejecución auto_detect_line_endings.

Otro día, si queréis, hablamos de csv, o de escritura… estoy abierto a sugerencias.

Cinco frameworks a tener en cuenta para desarrollo web

en por Donnie Rocken HTML5, Informática, Javascript/jquery, Lenguajes de programación2 comentarios

Soy evangelista de jQuery, lo sabéis, estoy enamorado, tando de jQuery (sobre todo para frontend), jQueryUI (este mejor para backend) o jQueryMobile. Es fácil de usar, productivo y libre, por lo que merece la pena usarlo. Pero no todo en esta vida es jQuery, por lo que hoy voy a hablar de cinco frameworks que os pueden interesar:

  • backbone.js: Con una documentación muy completa, este proyecto está siendo una de las estrellas de los frameworks javascript de los últimos dos años. Además de un catálogo de eventos y un API bastante entendible, el atractivo de backbone.js es que nos permite implementar el patrón Model-View-Controller en nuestra apliación de javascript. Sí, MVC en el lado del cliente. Piensa todo el código que se aprovechará, y la independencia que ganarás sobre el marcado.
  • Image Mapster:: En este caso nos encontramos con un plugin de jQuery para crear interacción con las imágenes. ¿Quieres un mapa donde haya un enlace sobre cada provincias? ¿quieres unas siluetas en negro que al sobrevolarlas con el ratón muestren la foto de la persona? Echa un ojo a la página de demos y hazte una idea de las posibilidades de este framework.
  • QUnit: Y si arriba hablábamos de implementar el patrón MVC en Javascript ¿por qué no hacer tests unitarios? QUnit es un proyecto de los creadores de jQuery, en principio pensado para testear su propio código, y que han liberado para uso y disfrute de la comunidad.
  • Canvas Query: Usar el elemento Canvas de HTML5 con sintaxis de jQuery. Eso es lo que nos ofrece Canvas Query, una herramienta que facilitará la vida del desarrollador que se lance a trastear con Canvas. Principalmente está pensado para el desarrollo de juegos en HTML5, donde puede tornarse una enorme ayuda a la hora de manipular sprites, jugar con paletas de colores…
  • Junior: Y termino con un framework para la creación de apps móbiles en HTML5. He de decir que ayer me encontré uno que me gustaba más, trasteando por la web, pero que no apunté el nombre… por lo que le he perdido la pista. En todo caso, este Junior puede ser una buena alternativa a jQueryMobile, dándonos una presentación diferente, más atractiva. Implementa varias librerías, como la antes citada backbone.js.

Y una cosa que me pregunto ¿realmente hacen falta tantos frameworks de maquetaciones tipo grid y metro? Los hay a patadas en los últimos tiempos.

Crear un chat con PHP y jQuery

en por Donnie Rocken Informática, Javascript/jquery, Lenguajes de programación5 comentarios

En este caso no se trata de un artículo original, sino de una medio traducción medio interpretación de este original en inglés. Podéis descargaros todo el código desde el enlace.

Se trata de un chat web simple, programado en php y basado en Ajax, haciendo uso de jQuery, con función de login y logout y soporte para varios usuarios.

El tutorial comienza creando un archivo index.php tal cual este:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">  
<html xmlns="http://www.w3.org/1999/xhtml">  
<head>  
<title>Chat - Customer Module</title>  
<link type="text/css" rel="stylesheet" href="style.css" />  
</head>  
<div id="wrapper">  
    <div id="menu">  
        <p class="welcome">Welcome, <b></b></p>  
        <p class="logout"><a id="exit" href="#">Exit Chat</a></p>  
        <div style="clear:both"></div>  
    </div>  
    <div id="chatbox"></div>  
    <form name="message" action="">  
        <input name="usermsg" type="text" id="usermsg" size="63" />  
        <input name="submitmsg" type="submit"  id="submitmsg" value="Send" />  
    </form>  
</div>  
<script type="text/javascript" src="http://code.jquery.com/jquery-1.9.0.js"></script>  
<script type="text/javascript">  
// jQuery Document  
$(document).ready(function(){  
});  
</script>  
</body>  
</html>

Como podéis ver se trata de un marcado HTML normal. La referencia a jQuery del código original está anticuada, en este ejemplo ya veréis una apuntando una dirección actualizada. En cuanto a la estructura hay tres grandes divs: el #wrapper, que contiene los otros dos y el formulario de envío de mensaje; el #menu, que sólo es un mensaje de bienvenida y un botón de logout y, finalmente, el #chatbox, que es donde se incluirán los mensajes.

El css sería tal que así:

    /* CSS Document */  
    body {  
        font:12px arial;  
        color: #222;  
        text-align:center;  
        padding:35px; }  
    form, p, span {  
        margin:0;  
        padding:0; }  
    input { font:12px arial; }  
    a {  
        color:#0000FF;  
        text-decoration:none; }  
        a:hover { text-decoration:underline; }  
    #wrapper, #loginform {  
        margin:0 auto;  
        padding-bottom:25px;  
        background:#EBF4FB;  
        width:504px;  
        border:1px solid #ACD8F0; }  
    #loginform { padding-top:18px; }  
        #loginform p { margin: 5px; }  
    #chatbox {  
        text-align:left;  
        margin:0 auto;  
        margin-bottom:25px;  
        padding:10px;  
        background:#fff;  
        height:270px;  
        width:430px;  
        border:1px solid #ACD8F0;  
        overflow:auto; }  
    #usermsg {  
        width:395px;  
        border:1px solid #ACD8F0; }  
    #submit { width: 60px; }  
    .error { color: #ff0000; }  
    #menu { padding:12.5px 25px 12.5px 25px; }  
    .welcome { float:left; }  
    .logout { float:rightright; }  
    .msgln { margin:0 0 2px 0; }

Poca cosa que comentar, pero entre esto y el marcado ya tenemos la apariencia definida del chat.

Ahora toca el formulario de login en PHP:

    <?  
    session_start();  
    function loginForm(){  
        echo' 
        <div id="loginform"> 
        <form action="index.php" method="post"> 
            <p>Please enter your name to continue:</p> 
            <label for="name">Name:</label> 
            <input type="text" name="name" id="name" /> 
            <input type="submit" name="enter" id="enter" value="Enter" /> 
        </form> 
        </div> 
        ';  
    }  
    if(isset($_POST['enter'])){  
        if($_POST['name'] != ""){  
            $_SESSION['name'] = stripslashes(htmlspecialchars($_POST['name']));  
        }  
        else{  
            echo '<span class="error">Please type in a name</span>';  
        }  
    }  
    ?>

En este caso se trata de un login simple, no comprueba usuarios registrados en una base de datos. Sobre su funcionamiento hay poco que comentar: nos pide un nombre y lo incluye dentro de una variable de sesión (de ahí la llamada a session_start()). El uso de htmlspecialchars() es para evitar ataques XSS.

Lo siguiente es motrar tanto el nombre de usuario en el Welcome como el formulario si el usuario no está logueado. La idea es dejar el primer archivo, el index.php tal cual este:

    <?php  
    if(!isset($_SESSION['name'])){  
        loginForm();  
    }  
    else{  
    ?>  
    <div id="wrapper">  
        <div id="menu">  
            <p class="welcome">Welcome, <b><?php echo $_SESSION['name']; ?></b></p>  
            <p class="logout"><a id="exit" href="#">Exit Chat</a></p>  
            <div style="clear:both"></div>  
        </div>  
        <div id="chatbox"></div>  
        <form name="message" action="">  
            <input name="usermsg" type="text" id="usermsg" size="63" />  
            <input name="submitmsg" type="submit"  id="submitmsg" value="Send" />  
        </form>  
    </div>  
    <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3/jquery.min.js"></script>  
    <script type="text/javascript">  
    // jQuery Document  
    $(document).ready(function(){  
    });  
    </script>  
    <?php  
    }  
    ?>

Bien, ahora vamos con el código de Javascript para la funcionalidad de logout. Dentro del script que ya tenemos creado en nestro código insertamos:

    <script type="text/javascript">  
    // jQuery Document  
    $(document).ready(function(){  
        //If user wants to end session  
        $("#exit").click(function(){  
            var exit = confirm("Are you sure you want to end the session?");  
            if(exit==true){window.location = 'index.php?logout=true';}  
        });  
    });  
    </script>

Esto no sólo nos permite enviar una llamada por el método GET para desconectar al usuario, sino que también nos sacará una ventana de confirmación antes de hacerlo. Y claro está, tendremos que tocar nuestro código del index.php para comprobar que se ha hecho una petición de logout y destruir la sesión que se había creado en el login:

    if(isset($_GET['logout'])){  
        //Simple exit message  
        $fp = fopen("log.html", 'a');  
        fwrite($fp, "<div class='msgln'><i>User ". $_SESSION['name'] ." has left the chat session.</i><br></div>");  
        fclose($fp);  
        session_destroy();  
        header("Location: index.php"); //Redirect the user  
    }

Este código, además, escribe en un archivo de logs (más tarde vemos para qué se usará) que el usuario se ha desconectado y redirecciona de nuevo a la página principal.

Lo siguiente es manejar las inserciones de mensajes de los usuarios. Hay que empezar por definir una función de jQuery para enviar los mensajes por el método POST haciendo uso de Ajax. El proceso sería recoger el evento de click del formulario, leer los datos del campo de texto, enviarlos al script de php que los va a tratar y borrar el campo de texto para que quede de nuevo en blanco:

    //If user submits the form  
    $("#submitmsg").click(function(){  
        var clientmsg = $("#usermsg").val();  
        $.post("post.php", {text: clientmsg});  
        $("#usermsg").attr("value", "");  
        return false;  
    });

Y claro, esto implica crear el archivo post.php para manejar los datos en el lado del servidor. Un archivo que llevaría este código:

    <?  
    session_start();  
    if(isset($_SESSION['name'])){  
        $text = $_POST['text'];  
        $fp = fopen("log.html", 'a');  
        fwrite($fp, "<div class='msgln'>(".date("g:i A").") <b>".$_SESSION['name']."</b>: ".stripslashes(htmlspecialchars($text))."<br></div>");  
        fclose($fp);  
    }  
    ?>

De nuevo iniciamos sesión, comprobamos que el usuario está logueado, recogemos el texto del mensaje del array $_POST y escribimos el mensaje junto al nombre de usuario en el log del chat.

Finalmente llevamos a la parte de mostrar los mensajes de chat en pantalla. Lo primero es cargar el log del chat dentro del #chatbox si este existe, para ahorrarnos tiempo:

    <div id="chatbox"><?php  
    if(file_exists("log.html") && filesize("log.html") > 0){  
        $handle = fopen("log.html", "r");  
        $contents = fread($handle, filesize("log.html"));  
        fclose($handle);  
        echo $contents;  
    }  
    ?></div>

Lo siguiente es la carga por Ajax de los datos contenidos en el archivo de log. La cosa se arreglaría con el método de jQuery para Ajax:

    //Load the file containing the chat log  
        function loadLog(){  
            $.ajax({  
                url: "log.html",  
                cache: false,  
                success: function(html){  
                    $("#chatbox").html(html); //Insert chat log into the #chatbox div  
                },  
            });  
        }

El parámetro url nos indica a qué archivo intentamos acceder por Ajax, cache es para definir si queremos cachear el archivo o no (en este caso, por lógica, no, porque queremos recargarlo en cada llamada) y finalmente la función que se ejecutará en caso de éxito (en este caso insertar el log en el div #chatbowx).

Para añadir autoscrolling, modificas el código anterior añadiendo lo siguiente:

    //Load the file containing the chat log  
    function loadLog(){  
        var oldscrollHeight = $("#chatbox").attr("scrollHeight") - 20; //Scroll height before the request  
        $.ajax({  
            url: "log.html",  
            cache: false,  
            success: function(html){  
                $("#chatbox").html(html); //Insert chat log into the #chatbox div  
                //Auto-scroll  
                var newscrollHeight = $("#chatbox").attr("scrollHeight") - 20; //Scroll height after the request  
                if(newscrollHeight > oldscrollHeight){  
                    $("#chatbox").animate({ scrollTop: newscrollHeight }, 'normal'); //Autoscroll to bottom of div  
                }  
            },  
        });  
    }

Básicamente consiste en ir modificando el tamaño para ocultar la parte de arriba y ampliar la de abajo. Simple truquillo. Ahora nos falta que el chat se auto recargue, cosa que haremos desde javascript:

setInterval (loadLog, 2500);

Esto lanza la función loadLog cada dos segundos y medio, logrando recargar los datos.

En el artículo orginal además encontraréis al final una serie de artículos con consejos varios para mejorar el código (en inglés) y todo el código completo para descargar.

Redimensionar imágenes en PHP

en por Donnie Rocken Informática, Lenguajes de programación10 comentarios

Es habitual que cuando en una web trabajamos con imágenes tengas que presentar la misma en varios tamaños. Una opción es redimensionarla en pantalla con CSS… pero es una mala opción. Es una mala opción porque lo que haces es cargar una imagen grande y luego procesarla para hacerla pequeña, por lo que ralentizas la carga de la página. ¿La solución? Guardar una copia reducida de la imagen, lo que se llama un thumbnail.

¿Y cómo reducir la imagen? Bueno, PHP incluye la librería GD que nos permite tratar y creawr imágenes. Y además, en este caso, vamos a redimensionar la imagen manteniendo la proporción. 

//Ruta de la original
$rtOriginal="/images/example.jpg";
	
//Crear variable de imagen a partir de la original
$original = imagecreatefromjpeg($rtOriginal);
	
//Definir tamaño máximo y mínimo
$max_ancho = 150;
$max_alto = 150;

//Recoger ancho y alto de la original
list($ancho,$alto)=getimagesize($rtOriginal);

//Calcular proporción ancho y alto
$x_ratio = $max_ancho / $ancho;
$y_ratio = $max_alto / $alto;

Con esto ya tenemos los datos para mantener las proporciones de la imagen. Ahora toca calcular el tamaño:

if( ($ancho <= $max_ancho) && ($alto <= $max_alto) ){
//Si es más pequeña que el máximo no redimensionamos
	$ancho_final = $ancho;
	$alto_final = $alto;
}
//si no calculamos si es más alta o más ancha y redimensionamos
elseif (($x_ratio * $alto) < $max_alto){
	$alto_final = ceil($x_ratio * $alto);
	$ancho_final = $max_ancho;
}
else{
	$ancho_final = ceil($y_ratio * $ancho);
	$alto_final = $max_alto;
}

Con esto ya tenemos el tamaño de la imagen con las proporciones guardadas. Finalmente nos queda crear la imagen y guardarla:

//Crear lienzo en blanco con proporciones
$lienzo=imagecreatetruecolor($ancho_final,$alto_final);	

//Copiar $original sobre la imagen que acabamos de crear en blanco ($tmp)
imagecopyresampled($lienzo,$original,0,0,0,0,$ancho_final, $alto_final,$ancho,$alto);

//Limpiar memoria
imagedestroy($original);

//Definimos la calidad de la imagen final
$cal=90;

//Se crea la imagen final en el directorio indicado
imagejpeg($lienzo,"./images/thumb.jpg",$cal);

Todo el cálculo, por otra parte, es necesario sólo si quieres mantener la proporción, si no la cosa queda más sencilla:

//Ruta de la original
$rtOriginal="/images/example.jpg";
	
//Crear variable de imagen a partir de la original
$original = imagecreatefromjpeg($rtOriginal);
	
//Definir tamaño máximo y mínimo
$ancho_final = 150;
$alto_final = 150;

//Recoger ancho y alto de la original
list($ancho,$alto)=getimagesize($rtOriginal);

$lienzo=imagecreatetruecolor($ancho_final,$alto_final);	

//Copiar $original sobre la imagen que acabamos de crear en blanco ($tmp)
imagecopyresampled($lienzo,$original,0,0,0,0,$ancho_final, $alto_final,$ancho,$alto);

//Limpiar memoria
imagedestroy($original);

//Definimos la calidad de la imagen final
$cal=90;

//Se crea la imagen final en el directorio indicado
imagejpeg($lienzo,"./images/thumb.jpg",$cal);

Esto para imágenes jpg. Para png la diferencia sería usar imagepng() para crear, y para gif imagegif(). En la web de php puedes investigar más sobre la librería GD y sacarle todo el jugo.

Convierte tu navegador en un block de notas

en por Donnie Rocken Informática, sistemas y redes1 comentario

Este es un pequeño truco que he leído en el facebook de un colega, y desconocía su existencia.

Si en la barra del navegador escribes la siguiente línea:

data:text/html, <html contenteditable>

Verás una página en blanco. Si pulsas podrás escribir sobre ella, como si fuera el notepad o el gedit. Y para salvar, ctrl+S y te lo guardará, añadiendo las pertinentes etiquetas html.

Una simple curiosidad.

Eventos en MySQL (planificar tareas por fecha y hora)

en por Donnie Rocken Informática, SQL17 comentarios

Seas un dba o seas un programador (y yo en mi caso soy ambas cosas) la automatización de tareas es algo no sólo útil, sino a veces indispensable. Al estilo de los cron jobs de Linux MySQL nos ofrece la posibilidad de definir una acción o serie de acciones que se repita periódicamente o se ejecuten en un momento concreto.

Lo primero es habilitar a nuestro servidor MySQL para que pueda hacerlo, con la siguiente línea:

SET GLOBAL event_scheduler = ON;

Si usas PHPMyAdmin tienes por ahí un botón para activarlo, no necesitas comandos.

Bueno, la sintaxis básica de la creación de eventos, y a la guía de usuario de MySQL me remito, es la siguiente:


CREATE
[DEFINER = { user | CURRENT_USER }]
EVENT
[IF NOT EXISTS]
event_name
ON SCHEDULE schedule
[ON COMPLETION [NOT] PRESERVE]
[ENABLE | DISABLE | DISABLE ON SLAVE]
[COMMENT 'comment']
DO sql_statement;

schedule:
AT timestamp [+ INTERVAL interval] ...
| EVERY interval
[STARTS timestamp [+ INTERVAL interval] ...]
[ENDS timestamp [+ INTERVAL interval] ...]

interval:
quantity {YEAR | QUARTER | MONTH | DAY | HOUR | MINUTE |
WEEK | SECOND | YEAR_MONTH | DAY_HOUR | DAY_MINUTE |
DAY_SECOND | HOUR_MINUTE | HOUR_SECOND | MINUTE_SECOND}

Ok, visto así, acojona. Pero no todos los parámetros son obligatorios, y explicado es fácil. Reamente necesitas sólo un nombre para el event_name, una condición para que se cumpla el ON SCHEDULE y un código sql que ejecutar después del DO. Te meto un ejemplillo sacado del curro, por ejemplo:

CREATE EVENT `close_expired_campaigns` 
ON SCHEDULE EVERY 1 DAY STARTS '2013-01-21 00:00:01' 
ON COMPLETION NOT PRESERVE ENABLE 
DO update tabla
set valido = 0
where
DATE_ADD(fechaCreacion, INTERVAL 45 DAY)<NOW() and valido=1;

Tiene algo más de código porque lo genera automáticamente PHPMyAdmin pero la idea es que crea un evento con ese nombre que, cada día un segundo después de medianoche actualice la tabla seleccionada poniendo a cero la columna indicada cuando se cumpla una condición (en este caso, que hayan pasado 45 días desde la creación). Bueno, como el código es tocho, os pongo debajo un ejemplo con la sintaxis más básica posible. Imaginemos una funcion que actualiza el saldo de una cuenta diaria de gastos a 1000 euros:

CREATE EVENT e_ActualizaSaldoDiario
ON SCHEDULE EVERY 1 DAY STARTS ‘2013-01-01 00:00:00’
DO UPDATE gastos SET saldo = 1000

Los dos ejemplos son recurrentes, se ejecutan todos los días a una hora (el parámetro Starts no permite definir el momento en que comenzará a ejecutarse, acuérdate de ponerlo porque si pones solo EVERY 1 DAY debería fallar, y no tiene por qué ser cada día, puedes poner un periodo concreto de horas, minutos, días, semanas…). Existe la posibilidad de que un evento se ejecute sólo una vez, en el momento que le indiques y luego se borre. Por ejemplo imaginemos que quieres que dentro de 6 horas se borren todos los registros del año 2012:

CREATE EVENT e_Borra2012
ON SCHEDULE AT now() + INTERVAL 6 HOUR
DO DELETE cuentas WHERE year = 2012

Y en estos tres ejemplos sólo hemos utilizado sentencias de SQL simples, pero imagina la potencia (y los riesgos de joderlo todo si la cagas, claro está) si los combinamos con procedimientos almacenados y con disparadores… Me imagino una bombillita alumbrando tu cabeza, y todas las cuestiones de mantenimiento y actualización que se te están ocurriendo.

Seleccionar filas aleatoriamente en MySQL

en por Donnie Rocken Informática, Lenguajes de programación, SQL1 comentario

Existen varias opciones a la hora de seleccionar filas de forma aleatoria en MySQL, haciendo uso de la función RAND(). Vamos a imaginar que quieres obtener 3 filas aleatorias de una base de datos. Lo más sencillo es usar la siguiente sintaxis:

SELECT * FROM tabla ORDER BY RAND() LIMIT 3;

El problema de este método es que tiene que generar una tabla temporal completa con todos los datos de la tabla original reordenados aleatoriamente… en fin, que es una sangría de recursos. Existe una opción, que es generar sólo una tabla con los registros que queramos, mediante una subconsulta. Tal que así:

SELECT * FROM tabla WHERE RAND()<(SELECT ((3/COUNT(*))*10) FROM tabla) ORDER BY RAND() LIMIT 3;

Un método que sigue gastando muchos recursos, pero menos al crear sólo una tabla temporal con la cantidad de filas que necesitamos (cantidad que necesitamos / total * 10).

Pero si tenemos un índice autonúmerico en nuestra tabla podemos ahorrar más recursos:

SELECT t.* FROM tabla AS t JOIN (SELECT ROUND(RAND() * (SELECT MAX(id) FROM tabla)) AS id) AS x WHERE t.id >= x.id LIMIT 3;

Este método no genera un valor aleatorio para cada fila consultada, por lo que ahorra muchos recursos en el servidor. Eso sí, no te dará los registros ordenados aleatoriamente, sino que será registros secuenciales, pero comenzando en un valor aleatorio. Es decir, los dos primeros podrían devolverte las filas 1, 21 y 42, este en cambio te devolvería 1,2,3 – 41,42,43… si quieres que sea un resultado aleatorio de verdad deberías realizar la consulta varias veces con limit 1… con lo que el ahorro de recursos se va al carajo. Además, puede fallar si hay algún hueco en la secuencia del campo autonumérico (por ejemplo, si has borrado un valor).

Una última opción, en lugar de generar el valor aleatorio a nivel de base de datos generarlo antes, en el código del servidor. Un ejemplo en PHP (que también tiraría de id autonumérica y que también daría problemas si tuviera huecos, ojo):

$result = $mysqli->query("SELECT * FROM tabla WHERE id in ROUND(".lcg_value()."*(SELECT COUNT(*) FROM tabla)) LIMIT 1")

El ejemplo de arriba nos devolvería una fila aleatoriamente, por lo que bastaría con repetirla en un bucle tantas veces como necesitemos (en este caso el problema vendría de la cantidad de conexiones que hay que abrir a la base de datos). Puedes intentar implementar lcg_value() en los otros métodos citados, y comprobar si el rendimiento mejora.

Consumir JSON en Android

en por Donnie Rocken Informática, Lenguajes de programación2 comentarios

Si el otro día hablaba de crear y consumir JSON en PHP, ahora toca su turno a Android.

¿Por qué usar JSON? Bueno, es un formato de intercambio de datos independiente de cualquier lenguaje y autodefinido. Ok, XML también, pero JSON es más ligero y fácil de parsear.

Existen varias librerías para JSON en Android, pero en el ejemplo usaremos los métodos nativos del SDK: las clases JSONArray y JSONObject.

JSONArray necesita recibir una cadena JSON para devolvernos un array de JSONObject. Supongamos que hemos recibido esos datos (sea de un web service o de un archivo) y los tenemos en una variable llamada data:

JSONArray jsArray = new JSONArray(data);

Ahora ya tenemos los datos dentro de un JSONArray. ¿Cómo lo recorremos? Pues con un for:

for (int i = 0; i < jsArray.length(); i++) {
    JSONObject jsObject = jsArray.getJSONObject(i);
    
    int intejemplo = jsObject.getInt(atributo1);
    String stringejemplo = jsObject.getString(atributo2);
}

El problema es que trabajar así puede ser muy plomífero, tratando los datos a mano, uno a uno. Existen librerías que te pueden echar un cable en esto, dándote mayores funcionalidades. En este caso las dos más populares son GSon y Jackson. En los enlaces podrás ver documentación sobre su uso.

El saber manipular JSON se torna capital cuando quieres trabajar con servicios web, o para comunicar apps con widgets.

Trabajando con JSON en PHP: crear y consumir JSON

en por Donnie Rocken Informática, Javascript/jquery, Lenguajes de programación5 comentarios

JSON se ha convertido en una herramienta fundamental en la programación web, ya sea en servicios web, para comunicar con apps de móviles, pasar datos de php a javascript…

Desde PHP podemos tanto crear un JSON como recibirlo y manejarlo. Para la creación debemos utilizar la función json_encode(), que recibe lo que queramos serializar (una cadena, una variable numérica, un array, un objeto) y devuelve una cadena con los datos serializados. Si le pasamos un array normal o una cadena, no veríamos mucho cambio tras la serialización, pero si le pasamos un array asociativo, tendríamos un resultado como el del ejemplo:

$miArray = array("ferrari"=>"rojo", "porsche"=>"plateado", "mercedes"=>"negro");
$string = json_encode($miArray);
//el valor de string sería {"ferrari":"rojo","porsche":"plateado","mercedes":"negro"}

Pero la verdadera potencia la encontramos cuando la aplicamos a objetos, ya que JSON nos permite serializar cualquier objeto de PHP, con el mismo procedimiento que usamos arriba: la función json_encode.

Una cuestión a la hora de trabajar con JSON que debemos tener en cuenta es la codificación de caracteres. En principio json_encode() ya convierte a Unicode los resultados, ya que en la notación JSON usamos siempre Unicode. El problema es que PHP por defecto tratará la cadena de origen como UTF-8, así que si no estás trabajando con esta codificación, y estás usando, por ejemplo, ISO-8859-1, se tornará necesario que codifiques las cadenas a UTF-8 antes de convertirlas en JSON. Esto se hace con la función utf8_encode().

$miArray = array("palabro1"=>utf8_enconde("ñandú"), "palabro2"=>"maniqueo", "palabro3"=>utf8_encode("bandoneón");
$cadenajson = json_encode($miArray);

Con esto ya recibiríamos las cadenas codificadas en UTF-8 y prevendríamos errores de codificación.

Ok, con esto hemos visto como generar un JSON, pero ¿cómo lo consumimos?.

Bueno, primero habría que destacar que existen varias librerías para JSON en PHP, pero desde PHP 5.2 este incluye librerías nativas desarrolladas en C, que son las más recomendables por cuestiones de rendimiento. Ahora vamos a suponer un objeto tal como el del ejemplo:

$strjson = '{
   "elemento1": "valor1",
   "elemento2": "valor2",
   "elemento3": null,
   "otroobj": {
      "a ver": "oh",
      "venga": "va"
   };

Esa sería la cadena JSON que recibiría nuestro código PHP con un objeto serializado ¿cómo la transformamos en objeto? Pues si serializábamos con json_encode() el paso contrario será con json_decode():

$objetophp = json_decode($strjson);

//si imprimimos objetophp con print_r() nos dará:
stdClass Object
(
   [elemento1] => valor1
   [elemento2] => valor2
   [elemento3] =>
   [otroobj] => stdClass Object
   (
      [a ver] => oh
      [venga] => va
   )
)

Al tener un objeto puedes acceder a sus propiedades como en cualquier objeto normal de PHP.

Una serie de avisos: Recuerda, como dijimos antes, que las cadenas deben estar en UTF-8, si usas otra codificación tendrás que tirar de utf8_encode. Los nombres tanto de las propiedades como de los valores deben ir entre comillas dobles, no se aceptan comillas simples y sólo los valores numéricos o null pueden ir sin comillas. No te dejes ni llaves ni corchetes abiertos, ni ninguna coma de más. Todo eso provocará fallos.