Montar un servidor PHP MySQL en Android

La tarea se me ocurrió puesto que vengo desarrollando buen tiempo para web y el traspaso a aplicaciones puede llevar tiempo, pero conociendo que Android básicamente es Sistema Operativo linux y al igual en los equipos de escritorio deberíamos de ser capaces de convertir nuestro equipo en un servidor web y de base de datos.

Montar un servidor PHP Mysql no es imposible en Android

Bueno con los objetivos planteados en este post empezaremos de la manera fácil describiendo algunas aplicaciones que ya existen y que nos brindan este servicio y la experiencia que me brindo la misma.

1. KSWEB server + PHP + MySQL

Selection_063

Es una aplicación para android que nos brinda una versión de prueba de 5 días

  • lighttpd server v1.4.31
  • PHP v5.4.11
  • MySQL v5.1.62

tras haber instalado el servidor ya podemos acceder al panel a través del puerto 8080 recuerden que si contamos con WiFi y una red interna o podemos ver nuestro servidor en nuestro equipo desktop a través de la IP

Muchos de los últimos modelos de celular también ya vienen con un Thetering que les ayudara a brindar su propia red WiFi.

Nos permite también poder instalar una versión de PHPMyAdmin para que podamos administrar nuestras bases de datos

Selection_066

2. PAW

Selection_064

También es un servidor pero este segundo dependiente de Wifi

te brinda un control mas halla de solo montar tu servidor como pueden apreciar en la imagen pueden revisar SMS, media, etc.

Screenshot_2013-08-26-10-06-33

Selection_068

Selection_069

Tenemos que instalar un plugin para que podamos correr PHP

También nos permite varias configuraciones como puerto de salida cambios de contraseña de nuestro panel entre otros.

3. Servers Ultimate

Selection_065

la tercera opcion es un paquete de varios servidores en una misma aplicación

Screenshot_2013-08-26-10-48-02

Selection_070

Lamentablemente esta versión también es de prueba, pero la experiencia de uso es muy buena ofrece un entorno mas serio administración desde el celular

4. AndroPHP

Selection_067

Este ultimo el mas adecuado a nuestros propósitos Gratuito y solo tiene PHP y MySQL al igual que PAW funciona a través de navegador

Screenshot_2013-08-26-10-55-48

Screenshot_2013-08-26-10-56-08

Selection_003

Screenshot_2013-08-26-11-04-23

Screenshot_2013-08-26-11-03-33

Screenshot_2013-08-26-11-03-49

Esperando que la información les pueda ayudar en algún momento, mi recomendación final es que recuerden que si bien los últimos teléfonos tiene características estos no fueron creados para este propósito.

Escritop por: Gaston Nina

Anuncios

Aplicaciones MySQL GUI

Que es un GUI?

Un GUI (Graphical User Interface)  o Interfaz Gráfica de Usuario es un programa aplicación que permite de forma visual realizar algunas tareas de manera más rápida, intuitiva y eficaz saliendo de la consola utilizando un conjunto de imágenes para este motivo.

Así es que de este modo como desarrolladores siempre intentaremos ganar algo más de tiempo en las tareas y algunos de los GUI que utilizaremos más seguido serán desde un editor de texto hasta alguna herramienta que pueda ayudarnos a realizar diagramas y queries elaborados.

Tambien un GUI Mysql puede ser de gran ayuda al momento de consultar un servidor externo

Algunos GUI para Mysql

guimysql_1

Es una aplicación Abierta pensada para SO Windows, pero que tambien corre dentro de Linux con ayuda de wine. Nos ofrece muchas mejoras en sus versiones previas a la oficial. La ultima version oficial fué 7.0 y lo pueden descargar desde el siguiente link

Entre algunas de sus características tenemos:

  • Auto Ordenado de Consultas Ctrl+F8 y ordena un query de una linea a varias haciéndolo más legible.
  • Guardado de querys como snippets (fragmentos)
  • Filtrado de base de datos para poder ubicar mas rápidamente, filtrado de tablas, filtrado registros dentro de una tabla (mismo que se puede convertir luego en un query)
  • Auto completado en el editor con Ctrl + Space
  • Exportaciones entre Bases de datos (con un detalle de registros y % de progreso por tabla)
  • Administración de indices de forma visual
  • imagepreview en campos BLOB
  • Conexión a diferentes BD con administración de carpetas
  • Detalles de tablas y vistas que pueden ser cambiados entre columnas.
  • logs de los queries ejecutados
  • Update Check que verifica la versión que tienes y puede actualizar a la ultima versión. Generalmente la aplicación realiza una actualización diaria.

Una captura de la interfaz, podrán encontrar más en el sitio en este link

gui_mysql_2

gui_mysql_3

Otro buen GUI para mysql es SqlYog quien también se renovó recientemente con mejora en la edición de  datos en tabla a modo de formulario, lamentablemente esta aplicación es de Paga, pero también tiene una versión community pensado nuevamente solo en SO Windows, pero que también funciona muy bien en Linux con ayuda de Wine. Pueden descargarlo desde este link

Algunas características de este GUI son:

  • Permite Copiar las bases de datos de manejar muy sencilla
  • Sacar dumps velozmente.
  • Tiene auto completado de query con el tecla Tab
  • Logs de los queries ejecutados
  • No puedes filtrar entre tus bases de datos lo cual dificulta si tienes una gran cantidad de bases de datos.
  • No puedes filtrar entre tablas
  • Tienes que ordenar los queries manualmente.
  • El verificador de nuevas versiones solo dirige al sitio oficial.

Adjunto una imagen de como se ve corriendo en mi equipo pueden ver mas capturas en el sitio oficial

gui_mysql_4

gui_mysql_5

Esta es otra aplicación bastante util para poder modelar una base de datos y de ahí poder convertir este modelo en tablas reales en tu base de datos. es totalmente libre promocionado por mysql y lo pueden descargar desde el siguiente link pueden bajarlo para SO windows y Linux (deb)

Características:

  • Diseño y modelado de Base de Datos
  • Desarrollo y Administración de SQL (este no es muy avanzado y puede resultar algo incomodo en comparación con las demás opciones mencionadas)
  • Migración de Base de Datos

A criterio personal no existe mejor herramienta para modelado y diagramación que WorkBench ya que nos facilita el trabajo de crear los campos en base de datos.

A continuacion dejo una Captura

gui_mysql_6

gui_mysql_7Esta es una opción reciente que encontré de la cual tengo muchas expectativas. La primera que me llamo la atención es que es plataforma Windows Linux (rpm, deb) y IOs lo pueden  descargar desde el siguiente link

Caracteristicas:

  • Valentina puede trabajar con DB, MySQL, Postgre y SQLite.
  • Maneja multiples bases de datos y multiples operaciones en tabs y vistas.
  • manejo de esquemas de base de datos (al estilo de workbench) con arboles, columnas, etc.
  • Administración de Procedimientos.
  • Data Editor browses/sorts/filters records, export found records, inline edits records, previews images.
  • Editor SQL soporta auto completado, sintxis de colores, logs, etc.
  • Utilidades de diagnostico y reparación de Bases de datos.

gui_mysql_8

Finalmente quería contarles sobre otra GUI esta vez web que nos ayuda siempre al momento de instalar alguna base de datos en un servidor que no tiene acceso externo. es 99% seguro que tendrá phpmyadmin.

Características principales

  • Creación de Bases de Datos
  • backup en zip, tar, tar.gz (formatos comprimidos cargan mas rápido a la hora de restaurar)
  • Filtros por tablas a nivel de campo
  • Formularios de administración de registros
  • Manejo de usuarios
  • Impresión.

Adjunto una captura de pantalla.

gui_mysql_9

Finalizando espero les haya gustado el post y tengan en cuenta que existen muchas mas GUI para Mysql y de las cuales solo detallo las que he podido utilizar. Como siempre espero esta información pueda ser de utilidad para todos.

Escrito por: Gaston Nina

Analizar el rendimiento de las consultas SQL en aplicaciones PHP con FirePHP

FirePHP

FirePHP

FirePHP

FirePHP es un complemento para Mozilla Firefox, el cual permite registrar en la consola de Firebug usando una simple llamada a un método en PHP. Toda la información es enviada por medio de cabeceras de respuesta y no interfiere con el contenido de su página. FirePHP es apropiado para el desarrollo con AJAX donde se requieren respuestas JSON y XML.

Instalar los complementos para Firefox

El primer paso es instalar el complemento Firebug en Firefox, el cual se puede descargar de Firebug 1.11.2.

Luego, se tiene que instalar el complemento FirePHP, el cual se puede descargar de FirePHP 0.7.1.

Para abrir FireBug presiona las teclas Ctrl + F12, posteriormente lo puedes acoplar a la ventana principal de Mozilla FireFox. Al principio el panel de Red (Network) por defecto está desactivado, por tanto se tiene que activar el panel de Red para mostrar algunas salidas de FirePHP en la consola de Firebug.

FireBug: Panel desactivado

Instalar la librería en el servidor

Se tiene que descargar la versión más reciente de la librería FirePHPCore, la cual se puede descargar de FirePHPCore.

Luego, descomprime el archivo y mueve el contenido del directorio lib/FirePHPCore a una carpeta en tu servidor.

Para el ejemplo, se sugiere la siguiente estructura de archivos:

FirePHP: archivos

Registrar las consultas SQL ejecutadas

Como todo buen desarrollador, de seguro tienes una clase PHP que permite establecer la conexión con tu base de datos y ejecutar las consultas. Por tanto, se puede incluir las funciones que se muestran a continuación en clase.

Primero incluimos la clase FirePHP y FB.

if (!class_exists('FirePHP')) {
  require_once(dirname(__FILE__) . DIRECTORY_SEPARATOR . "FirePHPCore/FirePHP.class.php");
  }
if (!class_exists('FB')) {
    require_once('FirePHPCore/fb.php');
}

En la función que permite ejecutar consultas SQL, calculamos el tiempo que duró la ejecución de la consulta. Además declaramos una variable global $allQuery en la cual se irá almacenando todas las consultas sql.

Nota.- La siguiente función deberá ser empleada sólo en consultas de selección (SELECT)

public function executeSelectQuery($query) {
    global $allQuery;
    $time_ini = microtime(true);
    $this->id_query = mysql_query($query, $this->id);
    $time_fin = microtime(true);
    $timeProcess = $time_fin - $time_ini;
    $totRows = ($this->id) ? $this->numRecords() : 0;
    $allQuery[] = array("query" => $query, "time" => $timeProcess, 'totalRows' => $totRows);
    return $this->id_query;
}

La siguiente función estática permite calcular el número total de consultas, tiempo total de ejecución de todas las consultas y la consulta con mayor duración. Además muestra el detalle de todas las consultas ejecutadas:

Nota.- Se recomienda emplear la función ob_start () si output_buffering no está establecido en “on” en el archivo php.ini, .htaccess, etc.

Revise los permisos del archivo, esté seguro de que los archivos a los que está accediendo puedan ser leídos por el servidor.

static function firePhpShowQueries() {
    global $allQuery;
    ob_start();
    $firephp = FirePHP::getInstance(true);
    $expensive_query_time = 0;
    $expensive_query = "";
    $total_time = 0;

    $query_time = 0;
    $query_arr = array();
    $query_arr[] = array('Num', 'Total Rows', 'Time', 'SQL Statement');
    $query_c = 0;
    foreach ($allQuery as $query) {
        $query_time+=$query['time'];
        $query_arr[] = array(++$query_c, $query['totalRows'], round($query['time'], 5), $query['query']);
        if ($query['time'] > $expensive_query_time) {
            $expensive_query_time = $query['time'];
            $expensive_query = $query['query'];
            $total_time += $query['time'];
        }
    }
    // Display the query summary 
    $firephp->group('Query Summary', array('Collapsed' => false,'Color' => '#000'));
    $firephp->log(count($allQuery), 'Total Queries');
    $firephp->log($total_time, 'Time');
    $firephp->log($expensive_query, 'Expensive Query Time');
    fb(array(count($allQuery) . ' SQL queries took ' . ($query_time) . ' seconds', $query_arr), FirePHP::TABLE);
}

A continuación, se muestra el archivo database.php

<?php
if (!class_exists('FirePHP')) {
  require_once(dirname(__FILE__) . DIRECTORY_SEPARATOR . "FirePHPCore/FirePHP.class.php");
  }
if (!class_exists('FB')) {
    require_once('FirePHPCore/fb.php');
}
class DataBase {
    var $host;
    var $user;
    var $password;
    var $database;
    var $id;
    var $id_query;

    public function __construct() {
        $this->host = "localhost";
        $this->user = "root";
        $this->password = "";
        $this->database = "bd_prueba";
        $this->id_query = 0;
        $this->Conectar();
    }

    private function Conectar() {
        if (!($this->id = mysql_connect($this->host, $this->user, $this->password))) {
            echo "Error conectando a la base de datos.";
            exit();
        }
        if (!mysql_select_db($this->database, $this->id)) {
            echo "Error seleccionando la base de datos.";
            exit();
        }
        mysql_query("SET NAMES 'utf8'");
        return $this->id;
    }

    function numRecords() {
        return @mysql_num_rows($this->id_query);
    }

    public function executeSelectQuery($query) {
        global $allQuery;
        $time_ini = microtime(true);
        $this->id_query = mysql_query($query, $this->id);
        $time_fin = microtime(true);
        $timeProcess = $time_fin - $time_ini;
        $totRows = ($this->id) ? $this->numRecords() : 0;
        $allQuery[] = array("query" => $query, "time" => $timeProcess, 'totalRows' => $totRows);
        return $this->id_query;
    }
    static function firePhpShowQueries() {
        global $allQuery;
        ob_start();
        $firephp = FirePHP::getInstance(true);
        $expensive_query_time = 0;
        $expensive_query = "";
        $total_time = 0;

        $query_time = 0;
        $query_arr = array();
        $query_arr[] = array('Num', 'Total Rows', 'Time', 'SQL Statement');
        $query_c = 0;
        foreach ($allQuery as $query) {
            $query_time+=$query['time'];
            $query_arr[] = array(++$query_c, $query['totalRows'], round($query['time'], 5), $query['query']);

            if ($query['time'] > $expensive_query_time) {
                $expensive_query_time = $query['time'];
                $expensive_query = $query['query'];
                $total_time += $query['time'];
            }
        }
        // Display the query summary
        $firephp->group('Query Summary', array('Collapsed' => false,'Color' => '#000'));
        $firephp->log(count($allQuery), 'Total Queries');
        $firephp->log($total_time, 'Time');
        $firephp->log($expensive_query, 'Expensive Query Time');
        fb(array(count($allQuery) . ' SQL queries took ' . ($query_time) . ' seconds', $query_arr), FirePHP::TABLE);
    }
}
?>

Nota.- Recuerda que solo puedes insertar las nuevas funciones en tu clase con la cual conectas y realizar tus consultas a tu base de datos.

A continuación se presenta un archivo de ejemplo, index.php, en el cual se incluye la el archivo database.php, se realizan algunas consultas de prueba y una vez ejecutadas todas las consultas se realiza una llamada al método estático DataBase::firePhpShowQueries().

<!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>Queries</title>
        <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
    </head>
    <body>
        <?php
        include("lib/database.php");
        $db = new DataBase();
        $min = 1;
        $max = 10;
        $inicio = rand($min, $max);
        $fin = rand($inicio, $max);
        for ($i = $inicio; $i <= $fin; $i++) {
            switch(rand(0,2)){
                case 0; $query = "select round(RAND()*100000) as c1,round(RAND()*100000) as c2"; break;
                case 1: $query = "SELECT DATE(NOW()) as c1, DATE(DATE(NOW())-10) as c2"; break;
                case 2: $query = "SELECT ADDTIME(HOUR(now()), '02:00:00.999998') as c2, ADDTIME('01:00:00.999999', '02:00:00.999998') as c2"; break;
            }
            $result = $db->executeSelectQuery($query);
            echo "<h1>Consulta - ".$i."</h1>";
            echo "<table>";
            echo "<tr><th>Columna 1</th><th>Columna 2</th></tr>";
            while ($r = mysql_fetch_array($result)) {
                echo "<tr>";
                echo "<td>".$r[0] . "</td><td>".$r[1] . "</td>";
                echo "</tr>";
            }
            echo "<table>";
        }
        DataBase::firePhpShowQueries();
        ?>
    </body>
</html>

Resultado

A continuación se muestra el detalle de todas las consultas en la consola de Firebug.

FirePHP: resultados en consola

Conclusión

FirePHP es una herramienta bastante útil en el desarrollo de aplicaciones PHP porque permite verificar si las consultas SQL que construye dinámicamente la aplicación están correctas, además permite medir el rendimiento de las consultas al realizar las pruebas y el mantenimiento del sistema. Sin embargo, cabe mencionar que este es un simple ejemplo de lo que se puede conseguir con FirePHP debido que este complemento otras funcionalidades las cuales se puede investigar.

Referencias:

http://www.ecartservice.net/04082009/using-firephp-firebug-with-prestashop/
http://www.firephp.org/HQ/Use.htm
http://agileadam.com/firephp-introduction
http://www.codediesel.com/mysql/benchmarking-wordpress-sql-using-firephp/

Optimizar nuestras consultas a base de datos MySQL

Optimizar MySQL es una tarea que debemos tener en mente desde el minuto cero al empezar a programar. Por lo tanto es tarea de los programadores estructurar apropiadamente, escribir peticiones apropiadas, y programar mejor código. A continuación mostramos algunas técnicas de optimización MySQL.

  • En una consulta SELECT, hay que evitar en lo posible el uso del comodín “*”, e indicar sólo los campos que se necesitan. Eso reducirá el tamaño de la consulta. Considerar que cada campo extra genera tiempo extra.

Ejemplo:

      mysql> SELECT campo1, campo2 FROM table;
  • Usa frecuentemente el LIMIT.
    • Usa LIMIT 1 Cuando sólo quieras una única fila; en estos casos, añadir LIMIT 1 a tu query puede mejorar significativamente la velocidad. De esta forma la base de datos dejará de escanear resultados en el momento que encuentre uno, en lugar de recorrer toda la tabla o un índice.
    • Esto es a la vez un consejo de rendimiento y de seguridad. Si estamos seguros de que vamos a borrar un registro de la tabla, entonces podemos añadirle un LIMIT 1 al final y así nos aseguraremos que no se borrará en ninguno de los casos nada fuera de control. Esto es aplicable también para SELECTs y UPDATEs.
    • Cuando la cantidad de resultados a devolver por MySQL no va a ser utilizada en su conjunto, como cuando se usa un paginador, devolver la cantidad apropiada utilizando la cláusula LIMIT.
  • Pruebe sus consultas con anterioridad, mediante el comando EXPLAIN; utilizar la palabra clave EXPLAIN te dará muchos detalles internos de lo que hace MySQL para ejecutar tu consulta.
    • Gracias a EXPLAIN podemos obtener toda la información sobre el modo en el que una consulta SQL se ejecutaría en el servidor. Es extremadamente útil para conocer la configuración de índices en las tablas, los índices que podrían ser configurados para mejorar su rendimiento, el número de filas que se revisan, el tipo de query, etc.

Ejemplo:

      mysql> EXPLAIN SELECT * FROM table;
  • Optimizar la cláusula WHERE:
    • Evite el uso de paréntesis innecesarios.
    • Use COUNT (*) sólo en consultas sin cláusula WHERE y que afecten a una única tabla.
    • Si conoce que el resultado de una claúsula GROUP BY o DISTINCT va a ser muy reducido haga uso de la opción SQL_SMALL_RESULT. MySQL usará tablas temporales de acceso rápido para el resultado en vez métodos de ordenación.
  • Especificar el alias de la tabla delante de cada campo definido en el SELECT, esto le ahorra tiempo al motor de tener que buscar a que tabla pertenece el campo especificado.
  • Utilizar INNER JOIN, LEFT JOIN, RIGHT JOIN, para unir las tablas en lugar del WHERE, esto permite que a medida que se declaran las tablas se vayan uniendo mientras que si utilizamos el WHERE el motor genera primero el producto cartesiano de todos los registros de las tablas para luego filtrar las correctas, un trabajo definitivamente lento.
  • No uses ORDER BY RAND(); el problema es que MySQL tendrá que ejecutar RAND() (que requiere de potencia de procesado) para cada una de las filas antes de ordenarlas y devolver una simple fila.
  • Usa NOT NULL si puedes; las columnas NULL requieren espacio adicional en la fila a grabar donde los valores son NULL. Para las tablas MyISAM, cada columna NULL toma un bit extra, redondeando hacia arriba al byte más cercano.