Problema con phpMyAdmin, mbstring extension y Ubuntu 16.04

Supongo que esto dentro de poco tiempo no servirá para nada porque habrán arreglado la instalación de PHP7. Pero en mayo de 2016 ha estado curioso dejar el servidor fino.

Vale, he actualizado Ubuntu a 16.04, además de pasarme a php7 sobre Apache. La cantidad de problemas que estoy encontrando está siendo interesante.

El último ha sido con la configuración de phpmyadmin (en este caso es sobre MariaDB, pero vamos, que sobre MySQL creo que pasa lo mismo).

Instalo mi paquete de phpmyadmin y no funciona, a pesar de reiniciar el servicio. Lo que sucede es que no se ha cargado la configuración de phpmyadmin en apache. Para ello:

sudo nano /etc/apache2/apache2.conf

y dentro incluimos:

Include /etc/phpmyadmin/apache.conf

Tras instalarlo y acceder a http://localhost/phpmyadmin te encuentras el siguiente error:

The mbstring extension is missing. Please check your PHP configuration.

La solución es:

sudo apt-get install php-mbstring php7.0-mbstring php-gettext
sudo service apache2 restart

Me estoy encontrando en muchos casos que el php7 no va NADA FINO y tienes que reinstalar paquetes o instalar algunos que normalmente tienes instalados, véase el php-curl.
Además, el apt-get install php7 me ha estado fallando por culpa del paquete php-fpm. Lo he solucionado descargando los fuentes de PHP e instalando a la vieja usanza, con sus configures, sus makes y sus cosas.

Es lo que pasa por pasarte a una versión «estable» antes de la cuenta.

Ejecutar consultas de larga duración en phpMyAdmin

En ocasiones queremos ejecutar una consulta utilizando phpMyAdmin cuya ejecución es demasiado larga en el tiempo, ya sea porque es muy compleja (o no está muy bien optimizada) o porque nuestro equipo es muy lento.

Ya sé que lo mejor es recurrir al terminal y desde la consola de mysql proceder a la ejecución, pero esto no es lo que quiero.

Nos debemos ir a la configuración de phpMyAdmin y modificar (o añadir) una línea.

Buscamos la carpeta de phpMyAdmin (si utilizamos XAMPP estará en algo como c:\xampp\phpMyAdmin) y dentro de la misma editamos el fichero config.inc.php

Buscamos la línea

$cfg['ExecTimeLimit']=300;

y le insertamos el valor 0 para no tener límite:

$cfg['ExecTimeLimit']=0;

Además, deberíamos modificar el entorno de ejecución de PHP, para ello, nos vamos a la carpeta de la instalación de PHP y abrimos el fichero php.ini

Modificamos las siguientes líneas:

max_execution_time = 300;
max_input_time = 600;
memory_limit = 128M;

Incluso la siguiente:

post_max_size = 80M;


Reiniciamos Apache y volvemos a probar la consulta.

Ahora todo funcionará y sí nos mostrará los resultados de la consulta (aunque tarde mucho).

.

Exportar consulta MySQL a CSV

Hay ocasiones en las que una consulta que ejecutas sobre phpMyAdmin es demasiado «lenta» y los resultados no se muestran, por lo que no puedes exportarlos a ningún otro formato.

Podrías cambiar la configuración de phpMyAdmin para que soportara resultados más largos, pero para no perder tiempo, podemos irnos a la consola y ejecutar desde ahí la exportación.

Tenemos dos opciones:

– Ejecutar desde la consola de MySQL

– Ejecutar desde el propio terminal MSDOS.

Desde la consola de MySQL:

Una vez que hemos accedido a la consola, nos hemos identificado correctamente y hemos conectado con la base de datos correcta, podríamos ejecutar la siguiente consulta:

SELECT  campos
FROM tabla
WHERE condicion
INTO OUTFILE ‘fichero.csv’
FIELDS TERMINATED BY ‘;’
OPTIONALLY ENCLOSED BY ‘\»‘
LINES TERMINATED BY ‘\r\n’;

Gracias a lo anterior generamos un fichero CSV (no incluye los nombres de los campos en la primera fila) que separa los campos por ; y los registros por Intros. El texto de los campos se mete entre «.

El fichero será generado en la carpeta «mysql/data/».

Desde el propio terminal:

Directamente ejecutamos

mysql -h localhost -u root –password=laquesea mibasededatos \ -e «SELECT * FROM tabla where ….» -B > fichero_salida.csv

Importar un DBF a MySQL

Voy a utilizar phpMyAdmin.

En primer lugar hay que pasar el DBF a CSV, sí, es obligatorio (al menos con phpMyAdmin).

1. Lo mejor es abrirse un Excel y desde ahí abrir el DBF. Te preguntará qué idioma tiene tu fichero, seleccionando internacional te funcionará.
2. Ya tengo en Excel abierto el DBF. Ahora, me aseguro de que en la primera fila estén escritos los nombres de los campor por cada una de las columnas.
3. Guardo el fichero DBF en formato CSV utilizando el Guardar como de Excel.
4. ¿Todo hecho? No, ahora me debo abrir el fichero CSV con el Bloc de Notas o con un editor de texto (véase el GEdit).
5. Ya tengo el fichero abierto. Debo asegurarme de lo siguiente para que la carga en phpMyAdmin sea correcta:
   • Los campos de texto deben estar encerrados entre comillas dobles «
   • Los campos deben estar separados por ;
   • Los números con decimales deben utilizar el .
6. Guardo el fichero y me paso a phpMyAdmin.
7. Selecciono la base de datos donde quiero crear la tabla con mis datos.
8. Pulso la pestaña Importar
9. Selecciono el botón Examinar para seleccionar el fichero que quiero cargar
10. Una vez selecccionado, phpMyAdmin detecta que es un CSV y nos va a preguntar ciertas cosas. Únicamente debemos tener en cuenta que nuestro separador de texto son las comillas dobles «, y que nuestro separador de columnas es el ;
11. Recuerda seleccionar el checkbox sobre que la primera fila contiene los nombres de los ficheros
12. Pulsamos importar y ya estará todo hecho

Seguro??

Hay veces que con lo anterior la importación la hace «regulera». Esto se debe a que supone la definición de los campos, es decir, si va entre comillas dobles será un VARCHAR, si lleva decimales será un DECIMAL y por defecto te pondrá 4,2 por ejemplo. ¿Esto qué quiere decir? Que si tienes más de 3 decimales te va a truncar.

Solución

Define la tabla tú mismo. Asegúrate de que los campos los pones en el mismo orden y con el tipo correcto.

Una vez hecho esto. Modifica el fichero CSV para que en la primera fila no aparezcan los nombres de los campos, es decir, que sean datos directamente.

En phpMyAdmin pulsas sobre la tablas que acabas de crear y una vez mostrado que está vacía, pulsa Importar. Haces el mismo procedimiento de antes y lo que te hará será un INSERT por cada fila de tu CSV.

Creando una capa de Realidad Aumentada

La cuestión es montar una capa de Realidad Aumentada (AR) en nuestra base de datos de nuestro servidor web con la que consigamos funcionar con Layar, la app más utilizada de AR.

Esta capa se puede escribir en varios lenguajes, pero voy a utilizar PHP. Es necesario:

• Un servidor web con PHP (5.3 o superior) que soporte JSON.
• Una base de datos MySQL (preferiblemente con phpMyAdmin).
• El servidor web debe poder alcanzarse desde Internet (para poder hacer las  pruebas desde Layar), no podemos estar trabajando on un servidor local que no sirva a Internet.

Crear una capa en Layar.com

En primer lugar debemos crear la capa en Layar.com. Para ello debemos registrarnos en la web.

Al final, como el nombre «capapruebas» estaba ya cogido, he utilizado «capaprugrx». Sólo permite letras en minúscula y números para los nombres de las capas.

Al crear la capa, podremos añadir muchos detalles, pero por ahora no entro, porque lo podremos editar más adelante.

Podremos cambiar iconos, banners, localización, categoría, etc.

Una vez guardada la capa, nos aparecerá en el listado de Layers:

El botón Request approval lo utilizaremos cuando tengamos la capa construida, para que los evaluadores de Layar nos la aprueben.

Preparando la Base de Datos

Con phpMyAdmin creamos un usuario exclusivamente para el acceso a esta base de datos, distinto al del acceso web y creamos una base de datos exlusiva para almacenar la información de la capa.

Esta base de datos será la que almacene la información de los POI (Point of Interest).

En principio sólo crearemos una tabla llamada POI, aunque se deben crear más tablas para habilitar características avanzadas, como acciones u objetos en 3D.

La estructura de la tabla debe ser la siguiente:

Éstos son los campos básicos, pueden ser añadidos más para otras características.

Resultando la siguiente consulta de creación:

CREATE TABLE `POI` (
`id` VARCHAR( 255 ) NOT NULL ,
 `footnote` VARCHAR( 150 ) NOT NULL ,
 `title` VARCHAR( 150 ) NOT NULL ,
 `lat` DECIMAL( 13, 10 ) NOT NULL ,
 `lon` DECIMAL( 13, 10 ) NOT NULL ,
 `imageURL` VARCHAR( 255 ) NOT NULL ,
 `description` VARCHAR( 150 ) NOT NULL ,
 `biwStyle` ENUM( 'classic', 'collapsed' ) NOT NULL ,
 `alt` INT( 10 ) NOT NULL ,
 `doNotIndex` TINYINT( 1 ) NOT NULL ,
 `showSmallBiw` TINYINT( 1 ) NOT NULL ,
 `showBiwOnClick` TINYINT( 1 ) NOT NULL ,
 `poiType` ENUM( 'geo', 'vision' ) NOT NULL ,
 PRIMARY KEY ( `id` )
) TYPE = MYISAM

Recopilando información

Una vez creada la tabla, vamos a insertarle algún POI.

Para calcular la latitud y longitud, usamos el Qué hay aquí de Google Maps: Abrimos Google Maps, nos situamos sobre el punto en el que queremos localizar nuestro POI, pulsamos el botón derecho del ratón sobre el mismo y seleccionamos Qué hay aquí.

Con lo que obtenemos la latitud y longitud del punto:

Y ahora añadiremos la información el POI a la base de datos:

Que resulta en la siguiente consulta INSERT de SQL:

 
INSERT INTO `cgim_ar`.`poi` (
`id` ,
 `footnote` ,
 `title` ,
 `lat` ,
 `lon` ,
 `imageURL` ,
 `description` ,
 `biwStyle` ,
 `alt` ,
 `doNotIndex` ,
 `showSmallBiw` ,
 `showBiwOnClick` ,
 `poiType`
)
VALUES (
'geo_1', 'Creado por @guirado_', 'La plaza de la Caleta de Granada', '37.187318', '-3.610399', 'http://www.movilidadgranada.com/images/maps/inicio.png', 'La localización de la plaza de la Caleta en Granada', 'classic', '', '', '', '', 'geo'
);

Construyendo un Servicio Web (WebService)

Ahora que ya tenemos un POI en la base de datos, debemos construir un webservice para que la plataforma de Layar pueda recoger la información. Necesita que se envíe la información como JSON, si tenemos PHP 5.2 o superior tendremos por defecto instalada esta opción.

Necesitaremos crear dos ficheros PHP para habilitar el webservice:

• config.inc.php – Contiene la información de configuración de la base de datos
• capapruebas.php – Es el fichero php principal. Será llamado por el servidor de Layar. Debe ser el mismo fichero que el definido en el campo API ENDPOINT URL cuando dimos de alta la capa.

config.inc.php

El primer fichero (config.inc.php) debe contener algo parecido a lo siguiente:

<?php
/* Pre-define connection to the MySQL database, please specify these fields based on your database configuration.*/
  define('DBHOST', 'localhost');
  define('DBDATA', 'database_name');
  define('DBUSER', 'database_username');
  define('DBPASS', 'database_password');
?>

Debemos cambiar el nombre del servidor, base de datos, usuario y contraseña.

Fichero principal (capapruebas.php)

En el script principal debemos:

Leer la petición GetPOIs (GetPOIs Request)

Basada en la definición de capa que hemos hecho, una petición HTTP GET con parámetros definidos ha sido enviada al POI URL.

Una lista completa de los parámetros de la petición puede encontrarse en la página de GetPOIs-Request.

Un ejemplo sería:

http://custom.layar.nl/FirstTutorial_POI.php?lang=en&countryCode=NL&lon=4.887339
&userId=6f85d06929d160a7c8a3cc1ab4b54b87db99f74b&developerId=4441
&developerHash=26ec094e19db2c4a82ebafa200ea2a5e87a7d671&version=4.0
&radius=2500&timestamp=1286357071952&lat=52.377544&layerName=layaroffice&accuracy=100

El código para esta implementación básica es el siguiente (más info en la documentación de layar):

<?php

// Incluimos el fichero de configuración de la base de datos
// Contiene el servidor, bd, usuario, contraseña.  
require_once('config.inc.php');

/*** Funciones ***/

// Ponemos los parámetros de la petición getPOI y sus valores en un array asociativo

function getRequestParams($keys) {

  $paramsArray = array();
  try {
    // En $keys tenemos los nombres de los parámetros GET
    // Para cada parámetro, almacenamos su valor correspondiente: $paramsArray['layarName'] = 'capaprugrx' 
    foreach( $keys as $key ) {
      if ( isset($_GET[$key]) )
        $paramsArray[$key] = $_GET[$key]; 
      else 
        throw new Exception($key .' el parámetro no se ha pasado en la GetPOI request.');
    }
    return $paramsArray;
  }
  catch(Exception $e) {
    echo 'Mensaje: ' .$e->getMessage();
  }
}// fin de la función getRequestParams 

// Conectamos con la base de datos
function connectDb() {
  try {
    $dbconn = 'mysql:host=' . DBHOST . ';dbname=' . DBDATA ; 
    $db = new PDO($dbconn , DBUSER , DBPASS , array(PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES utf8'));
    // set the error mode to exceptions
    $db->setAttribute(PDO::ATTR_ERRMODE , PDO::ERRMODE_EXCEPTION);
     return $db; 
  }// try
  catch(PDOException $e) {
    error_log('message:' . $e->getMessage());
  }// catch
}// fin de la función connectDb

// Pasar string a float
// Devuelve:
//   float ; Si la cadena está vacía devuelve NULL.
//
function changetoFloat($string) {
  if (strlen(trim($string)) != 0) 
    return (float)$string;
  return NULL;
}//changetoFloat

// Coloca los POIs recibidos en un array asociativo. los valores devueltos son asignados a
// $reponse['hotspots'].
//
// Argumentos:
//   db ; El manejador de la base de datos.
//   value ; Un array que contiene los parámetros que se necesitan recuperados desde
//           la GetPOI request. 
//
// Devuelve:
//   array ; Un array de POIs recuperados.
//
function getHotspots( $db, $value ) {
  // Definimos un array vacío llamado $hotspots.
  $hotspots = array();
/* Creamos la consulta SQL para recuperar los POIs que se encuentran dentro
   del 'radius' enviado desde la GetPOI request. 
   Los primeros 50 POIs son seleccionados.
*/

  // Se utiliza PDO::prepare() para preparar la sentencia SQL. Esta sentencia se utiliza por
  // motivos de seguridad, para combatir ataques de inyección SQL.
  // ':lat1', ':lat2', ':long' y ':radius' son marcadores de parámetros con nombre para
  // los que los valores reales serán sustituidos cuando la sentencia se ejecute.
  // $sql es devuelto como un objeto sentencia PDO. 
  $sql = $db->prepare( '
              SELECT id,
               imageURL,
               title,
               description,
               footnote,
               lat,
               lon,
               (((acos(sin((:lat1 * pi() / 180)) * sin((lat * pi() / 180)) +
                        cos((:lat2 * pi() / 180)) * cos((lat * pi() / 180)) * 
                      cos((:long  - lon) * pi() / 180))
                      ) * 180 / pi()
               )* 60 * 1.1515 * 1.609344 * 1000
               ) as distance
                FROM POI
         WHERE POI.poiType = "geo" 
       HAVING distance < :radius
      ORDER BY distance ASC
         LIMIT 0, 50 ' );

  // sentenciaPDO::bindParam() enlaza los marcadores de parámetros con nombre a los valores del parámetro específico   
  $sql->bindParam( ':lat1', $value['lat'], PDO::PARAM_STR );
  $sql->bindParam( ':lat2', $value['lat'], PDO::PARAM_STR );
  $sql->bindParam( ':long', $value['lon'], PDO::PARAM_STR );
  $sql->bindParam( ':radius', $value['radius'], PDO::PARAM_INT );
  // Utilizamos PDO::execute() para ejecutar la sentencia preparada $sql. 
  $sql->execute();
  // Iterador para el array response.
  $i = 0; 
  // Utilizamos fetchAll para devolver un array que contiene todas las filas restantes en
  // el result set.
  // Usamos PDO::FETCH_ASSOC para extraer los resultados de la consulta $sql y devolver cada fila como un
  // array indexado por nombre de columna.
  $rawPois = $sql->fetchAll(PDO::FETCH_ASSOC);

  /* Procesamos el resultado de $pois  */
  // si el array $rawPois no está vacío 
  if ($rawPois) {
    // Poner cada POI en el array $hotspots.
       foreach ( $rawPois as $rawPoi ) {
       $poi = array();
      $poi['id'] = $rawPoi['id'];
      $poi['imageURL'] = $rawPoi['imageURL'];
      // geolocalizamos el punto
      $poi['anchor']['geolocation']['lat'] = changetoFloat($rawPoi['lat']);
      $poi['anchor']['geolocation']['lon'] = changetoFloat($rawPoi['lon']);
      // obtenemos la información textual del objeto
      $poi['text']['title'] = $rawPoi['title'];
      $poi['text']['description'] = $rawPoi['description'];
      $poi['text']['footnote'] = $rawPoi['footnote'];
     // Ponemos el poi en el array $hotspots.
     $hotspots[$i] = $poi;
     $i++;
    }//foreach
  }//if
  return $hotspots;
}//getHotspots

/*** Inicio del programa principal ***/

/* Pone los parámetros de la GetPOI request en un array asociativo llamado $requestParams */
// Pone los nombres de los parámetros de la GetPOI request en un array llamado $keys. 
$keys = array( 'layerName', 'lat', 'lon', 'radius' );

// Inicializa $requestParams con un array vacío.
$requestParams = array(); 
// Llama a la función getRequestParams() para rellenar $requestParams con pares como 'layerName' -> 'capaprugrx'  
$requestParams = getRequestParams($keys);

/* Conecta con el servidor MySQL. Se utiliza PDO para conectar con la base de datos.
     Para más información sobre PDO: http://php.net/manual/en/book.pdo.php. 
 */    
// Conecta con la base de datos en MySQl.  
$db = connectDb(); 

/* Construimos la respuesta en un array asociativo.*/

// Crear array llamado response.
$response = array();

// Asignamos los valores correspondientes a las claves de respuesta obligatorias JSON.
$response['layer'] = $requestParams['layerName'];

// Utilizamos la función Gethotspots() para obtener los POIs en el rango de búsqueda.  
$response['hotspots'] = getHotspots($db, $requestParams);

// Si no se ha encontrado ningún POI, devolvemos un mensaje de error.
if (!$response['hotspots'] ) {
    $response['errorCode'] = 20;
     $response['errorString'] = 'Ning&uacute;n POI ha sido encontrado. Por favor, ajuste el filtro de b&uacute;squeda.';
}//if
else {
  $response['errorCode'] = 0;
  $response['errorString'] = 'ok';
}//else

    /* Todos los datos están en $response, los pasamos al formato JSON.*/

    // Ponemos la representación en JSON de $response en $jsonresponse.
    $jsonresponse = json_encode( $response );

    // Declaramos el tipo de contenido correcto en la cabecera de la respuesta HTTP.
    header( 'Content-type: application/json; charset=utf-8' );

    // Devolvemos la respuesta Json.
    echo $jsonresponse;

?>

Comprobando la capa

Ya estaría construido el webservice. Ahora debemos Testear la capa antes de publicar.

Tenemos dos métodos para probarla:

Página de testeo de la API

Abrimos la página de testeo, seleccionamos la API, el país, el idioma. Centramos el mapa en un punto en el que queramos probar la aplicación (en este caso me he ido a Granada) y pulsamos LOAD POI para probarla.

Desde el móvil, utilizando la aplicación Layar

Abrimos la aplicación Layar, nos debemos identificar con nuestro usuario y contraseña de desarrollador, nos vamos a la pestaña Desarrollador y estará nuestra capa, con lo que podremos probarla.

Por último, antes de poder enviar la petición de aprobación, habrá que añadir algunos detalles, como el icono de la aplicación (que será de 128×128), información detallada sobre la descripción de la capa, etc.

… (Continuará)

Ocultar phpMyAdmin desde fuera del servidor

Para proteger la base de datos de la página web es necesario deshabilitar el acceso a phpMyAdmin desde fuera de nuestro servidor web y poder tener la opción de seguir usándolo desde dentro de nuestro servidor incluso dentro de la red local de la empresa debemos hacer lo siguiente:

Si tenemos Apache sobre Windows, abrimos el fichero http-xampp.conf (si hemos instalado XAMPP) y dentro encontraremos el alias que reenvía /phpmyadmin a la carpeta en la que tengamos instalado el phpmyadmin. Dentro de este alias, que por defecto tiene puesto

Order Allow, Deny

lo cambiamos por

Order Deny, Allow

así conseguimos que se deniegue para todos, esa es la preferencia.

Añadimos la línea

Deny from all

para denegar siempre y, a continuación, añadimos tantas líneas como máquinas queramos que ejecuten el phpmyadmin:

Allow from localhost
Allow from 192.168.1.200

Otra manera de protegernos más aun sería cambiando el nombre del alias, en lugar de phpmyadmin que es el que todo el mundo conoce, poner otro distinto (lógicamente que no coincida con ningún directorio de nuestro sitio web).

Instalar phpMyAdmin

La orden es:

sudo apt-get install phpmyadmin

Entonces nos pregunta sobre qué servidor, Apache o Lighttp.

Elegimos Apache. Continúa configurando y entonces nos pregunta por la base de datos:

A continuación nos solicita la contraseña del administrador de BD y después la contraseña para phpMyAdmin.

Una vez terminada la instalación podras comprobar que esta correcto accediendo a http://localhost/phpmyadmin con los datos que introdujiste durante la instalación.

Si no funciona, ejecutar hacer lo siguiente

sudo gedit /etc/apache2/httpd.conf

Pegar lo siguiente dentro, luego salvar y cerrar:

Include /etc/phpmyadmin/apache.conf

Reiniciar el servidor web :

sudo /etc/init.d/apache2 restart

y listo ya está.

Tras insertar el usuario (root) y la contraseña que proporcionamos en el proceso de instalación, tendremos lo siguiente:

Pasar una BD de Access a MySQL con phpMyAdmin

De manera práctica vamos a ver cómo podemos pasar una BD completa realizada en Access a MySQL utilizando phpMyAdmin.

Si entramos en phpMyAdmin podemos utilizar la opción Importar dentro del menú Más:

Aparece la siguiente página:

Como se puede ver, soporta ficheros en formato SQL, CSV, ODS y XML.

En esta ocasión vamos a utilizar ODS. ¿Por qué? El formato ODS va a ser capaz de leer las tildes y ñ sin problema.

ODS es un formato abierto que utiliza Openoffice.org. Para obtener este formato, debemos abrir nuestro fichero de Access, sobre cada una de las tablas, exportarla a formato Excel (que es el más parecido a ODS).

Una vez obtenido el fichero Excel, lo abrimos. Tras abrirlo, utilizaremos Guardar Como para obtener el fichero ODS.

Ya tenemos generado nuestro fichero ODS.

Ahora volvemos a phpMyAdmin y abrimos la opción IMPORTAR.

Pulsamos el botón Examinar y seleccionamos el fichero ODS anteriormente generado. Veremos cómo automáticamente cambia el Formato del fichero a Hoja de Cálculo de Open Document.

Antes de pulsar el botón Continuar, seleccionaremos el Check La primer línea del archivo contiene los nombres de columna de la tabla.

Si todo ha ido bien, aparecerá un mensaje que nos informará de cuántas estructuras se han creado y cuántas consultas se han ejecutado.

Nos ha creado una base de datos que se llama ODS_DB, podemos cambiarle el nombre.

Nos ha creado una tabla cuyo nombre es igual al nombre del fichero ODS.

Las tablas se han importado casi correctamente. Los nombres de los campos los ha cogido perfectamente, pero nos faltarían algunos detalles.

En primer lugar, la llave primaria, seleccionamos el campo o campos que sean llave primaria (en este ejemplo, el campo ID) y en la parte de abajo de la página pulsamos el botón Primaria

La consulta que ejecuta es la siguiente:

ALTER TABLE `usuarios` ADD PRIMARY KEY ( `ID` ) ;

Otro problema que teníamos era con las fechas. En el ejemplo, tenemos el campo FECHA NACIMIENTO, que es una fecha, pero no está almacenado en MySQL como Date.

Cambiar simplemente el tipo del campo de Varchar a Date no funciona, ya que en el Varchar están almacenadas las fechas en el formato dd-mm-yyyy y ese formato no lo soporta MySQL.

Deberíamos crearnos un campo nuevo, de tipo Date. Tras crearlo, debemos realizar un UPDATE como el siguiente:

UPDATE usuarios SET fechanueva=STR_TO_DATE(fechanacimiento, ‘%Y/%m/%d’);

En el campo nuevo ya tendríamos los valores de manera correcta, así que el campo antiguo podemos borrarlo. Y el campo nuevo renombrarlo para que aparezca con el nombre correcto.

Algo parecido pasa con los campos BOOLEANOS, no los coge correctamente y almacena valores de tipo cadena VERDADERO y FALSO.

Así, deberíamos crear un campo nuevo, de tipo BOOLEAN, y actualizarlo utilizando la siguiente consulta:

UPDATE usuarios SET fumadornuevo=true where fumador=’VERDADERO’;

UPDATE usuarios SET fumadornuevo=false where fumador=’FALSO’;

Con esto tendríamos todo terminado para una única tabla. Si nuestra Base de Datos de Access tiene varias tablas, con llaves externas, tendremos que ir importando todos los ficheros generados para cada tabla.

..

Motor de almacenamiento ¿MyISAM o InnoDB?

El motor de almacenamiento (storage-engine) se encarga de almacenar, manejar y recuperar información de una tabla. Los motores más conocidos son MyISAM e InnoDB. La elección de uno u otro dependerá mucho del escenario donde se aplique.

En la elección se pretende conseguir la mejor relación de calidad acorde con nuestra aplicación. Si necesitamos transacciones, claves foráneas y bloqueos, tendremos que escoger InnoDB. Por el contrario, escogeremos MyISAM en aquellos casos en los que predominen las consultas SELECT a la base de datos.

 

InnoDB dota a MySQL de un motor de almacenamiento transaccional (conforme a ACID) con capacidades de commit (confirmación), rollback (cancelación) y recuperación de fallos. InnoDB realiza bloqueos a nivel de fila y también proporciona funciones de lectura consistente sin bloqueo al estilo Oracle en sentencias SELECT. Estas características incrementan el rendimiento y la capacidad de gestionar múltiples usuarios simultáneos. No se necesita un bloqueo escalado en InnoDB porque los bloqueos a nivel de fila ocupan muy poco espacio. InnoDB también soporta restricciones FOREIGN KEY. En consultas SQL, aún dentro de la misma consulta, pueden incluirse libremente tablas del tipo InnoDB con tablas de otros tipos.

MyISAM es el motor por defecto. Para crear una tabla InnoDB se debe especificar la opción ENGINE = InnoDB o TYPE = InnoDB en la sentencia SQL de creación de tabla:

CREATE TABLE customers (a INT, b CHAR (20), INDEX (a)) ENGINE=InnoDB;

CREATE TABLE customers (a INT, b CHAR (20), INDEX (a)) TYPE=InnoDB;

 

Ventajas: MyISAM vs InnoDB

InnoDB

• Soporte de transacciones
• Bloqueo de registros
• Nos permite tener las características ACID (Atomicity, Consistency, Isolation and Durability: Atomicidad, Consistencia, Aislamiento y Durabilidad en español), garantizando la integridad de nuestras tablas.
• Es probable que si nuestra aplicación hace un uso elevado de INSERT y UPDATE notemos un aumento de rendimiento con respecto a MyISAM.

MyISAM

• Mayor velocidad en general a la hora de recuperar datos.
• Recomendable para aplicaciones en las que dominan las sentencias SELECT ante los INSERT / UPDATE.
• Ausencia de características de atomicidad ya que no tiene que hacer comprobaciones de la integridad referencial, ni bloquear las tablas para realizar las operaciones, esto nos lleva como los anteriores puntos a una mayor velocidad.

¿Aún tienes dudas de qué motor es el que necesitas? Te ayudamos a tomar tu decisión

¿Tu tabla va a recibir INSERTs, UPDATEs y DELETES mucho más tiempo de lo que será consultada?  Te recomendamos InnoDB

¿Necesitarás hacer búsquedas full-text?   Tu motor ha de ser MyISAM

¿Prefieres o requieres diseño relacional de bases de datos?  Entonces necesitas InnoDB

¿Es un problema el espacio en disco o memoria RAM?  Decántate por MyISAM

 

Entrar en PHPMyAdmin

Para acceder al PhpMyAdmin tienes que entrar en el panel de control de tu servidor. Si dispone de Cpanel encontrarás el icono de acceso a PhpMyAdmin que es como este (el de abajo de la imagen):

Si utilizamos XAMPP y lo tenemos instalado en local, utilizaremos la siguiente dirección web: http://localhost/xampp

 

Una vez hemos entrado en XAMPP, accederemos a PhpMyAdmin.

vamos a ver una pantalla como la siguiente:

Fíjense que a la izquierda (en el sector más oscuro) esta el listado de base de datos y a la derecha hay una serie de información.