Modificar y eliminar en MySQL

————————
TUTORIAL MYSQL:
————————
I. Instalación y arranque, creación de BDs y tablas, introducción y visualización de datos
II. Actualización de datos, eliminación y alteración de las BDs y las tablas
III. Consultas a MySQL desde un programa Java, Primera parte
IV. Consultas a MySQL desde un programa Java, Segunda parte
————————

Vamos a seguir trabajando con la BD que hemos creado en el post anterior. Ahora intentaremos actualizar los datos de un elemento de la tabla, eliminar algún o algunos elementos y alterar la estructura de la tabla añadiendo o eliminando columnas.

Comenzamos conectándonos al servidor de BDs…
$ mysql -u root -h localhost
Y accediendo a nuestra BD «tienda»:
mysql> use tienda;
Y si hacemos:
mysql> select * from libros;
deberíamos poder ver los títulos que introdujimos con anterioridad.

Si queremos cambiar un campo de todos los elementos, basta con usar la orden «update», indicar la tabla y hacer «set» sobre el atributo con el nuevo valor.
mysql> update libros set stock=2;
Y sin embargo, si quisiéramos alterar un campo de un elemento concreto, haríamos lo mismo pero introduciendo una condición mediante «where»:
mysql> update libros set price=59.95 where title='Sistemas operativos modernos';

Para eliminar un elemento:
mysql> delete from libros where isbn='9701701658';
O introduciendo una condición lógica para eliminar lotes de elementos:
mysql> delete from libros where stock<0;
Tambien podemos eliminar elementos que cumplan que uno de sus campos pertenece a un conjunto dado:
mysql> delete from libros where autor in ('Andrew S. Tanenbaum', 'Dan Brown', 'Joan Ribas Lequerica');

Ahora alteraré la estructura de la tabla, añadiendo una columna llamada «Editor»:
mysql> alter table libros add column editor varchar(30);
Puedo incluso modificar sus parámetros:
mysql> alter table libros modify column editor varchar(30) not null;
Cambiar su nombre:
mysql> alter table libros change column editor editorial varchar(30) not null;
O eliminarla:
mysql> alter table libros drop column editorial;

————————
TUTORIAL MYSQL:
————————
I. Instalación y arranque, creación de BDs y tablas, introducción y visualización de datos
II. Actualización de datos, eliminación y alteración de las BDs y las tablas
III. Consultas a MySQL desde un programa Java, Primera parte
IV. Consultas a MySQL desde un programa Java, Segunda parte
————————

Tutorial de MySQL

————————
TUTORIAL MYSQL:
————————
I. Instalación y arranque, creación de BDs y tablas, introducción y visualización de datos
II. Actualización de datos, eliminación y alteración de las BDs y las tablas
III. Consultas a MySQL desde un programa Java, Primera parte
IV. Consultas a MySQL desde un programa Java, Segunda parte
————————

Hacía tiempo que no escribía una entrada técnica en condiciones y aprovechando que he estado investigando un poco el lenguaje SQL me he decidido a explicar aquí los primeros pasos y las operaciones más sencillas para poder trabajar con este lenguaje de administración de bases de datos. Como quiero cubrir la instalación, la creación de una BD y una tabla, la introducción de datos y algunos aspectos de su visualización (ejemplos incluidos), dividiré todo esto en varios post.

La instalación del gestor MySQL bajo Ubuntu se hace de la forma habitual:
$ sudo apt-get install mysql-server mysql-client
Durante la instalación del servidor se nos preguntará varias veces la contraseña del superusuario de la BD (root). Podemos dejarla vacía si, como en mi caso, solo vamos a hacer pruebas.
El servidor se encargará de almacenar las BDs y procesar las consultas. El cliente es un programa ligero que se conectará al servidor; así que podemos desplegarlos en máquinas diferentes si queremos trabajar en una arquitectura de producción más elaborada.

Una vez instalados, comenzamos a trabajar conectándonos al servidor. Como en mi caso he instalado ambos paquetes en la misma máquina, mi servidor será localhost pero podría usar la IP de otra si trabajo en computadoras separadas.
$ mysql -h localhost -u root
El parametro -u define el usuario con el que nos conectamos. No confundir el usuario «root» de mysql con el usuario «root» del PC.
Esto nos lanzará el prompt del servidor, que queda identificado de la siguiente forma:
mysql>
A partir de aquí nos moveremos con las órdenes SQL, las cuales terminan siempre con el caracter «;» (punto y coma). Si queremos introducir una instrucción muy larga podemos pulsar enter para emplear varias líneas, ya que el intérprete no enviará la sentencia al servidor mientras no encuentre el «;».
Las líneas adiccionales cuentan con este prompt:
->
Algo muy útil mientras estemos practicando, será activar que el intérprete nos muestre los WARNINGS (alertas) que se vayan produciendo.
mysql> warnings
Si por el contrario queremos desactivarlos:
mysql> nowarning
Para salir del cliente:
mysql> quit
Estas y otras sentencias útiles las puedes consultar escribiendo:
mysql> help

Creación de bases de datos y tablas
En primer lugar veamos qué hay en el servidor:
mysql> show databases;
Deberíamos obtener una salida como la siguiente:

+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| performance_schema |
| test |
+--------------------+
4 rows in set (0.00 sec)

Recuerda esta última orden porque te será útil para comprobar cambios relativos a las bases de datos.

En este ejemplo crearemos una base de datos llamada «tienda». En principio contendrá una tabla llamada «libros» en la que almacenaremos el código ISBN, el título, el autor, el precio y el stock de cada libro. Al menos por ahora.
Si en el futuro nuestra tienda también pusiese a la venta CDs, haríamos una segunda tabla dentro de la BD.
Podemos crear una nueva BD con:
mysql> create database tienda;
Puedes verificarlo de nuevo:
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| tienda |
| mysql |
| performance_schema |
| test |
+--------------------+
5 rows in set (0.00 sec)

Ahora deberíamos actuar sobre esta nueva BD, así que:
mysql> use tienda;

Para crear la tabla «libros» con los campos de los que hablamos antes:
mysql> create table libros(
-> isbn varchar(13) primary key not null,
-> titulo varchar(30) not null,
-> autor varchar (30) not null,
-> precio double not null,
-> stock int(4) not null
-> );
Query OK, 0 rows affected (0.18 sec)

Como se puede ver, dentro de los paréntesis que siguen a la palabra «libros» definimos los tipos de datos que vamos a almacenar. El ISBN, el título y el autor son cadenas de caracteres (varchar) a las cuales hemos limitado el tamaño (13, 30 y 30 respectivamente).
El precio es un número con hasta dos cifras decimales (double) y el stock, un entero de hasta 4 cifras.
Además hemos establecido que el ISBN sea la clave primaria, es decir, el valor inequívoco por el que se identificará a cada libro. Y ninguno de los campos puede ser nulo.
Verificamos que la tabla se ha creado:
mysql> show tables;
+--------------------+
| Tables_in_tienda |
+--------------------+
| libros |
+--------------------+
1 row in set (0.00 sec)

Y comprobamos la estructura inicial que hemos definido:
mysql> describe libros;
+-----------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-----------+-------------+------+-----+---------+-------+
| isbn | varchar(13) | NO | PRI | NULL | |
| titulo | varchar(30) | NO | | NULL | |
| autor | varchar(30) | NO | | NULL | |
| precio | double | NO | | NULL | |
| stock | int(4) | NO | | NULL | |
+-----------+-------------+------+-----+---------+-------+
5 rows in set (0.01 sec)

Ahora vamos a introducir varios libros de ejemplo:
mysql> insert into libros (isbn, titulo, autor, precio, stock) values(
-> '9788441529373',
-> 'Desarrollo de aplicaciones para Android',
-> 'Joan Ribas Lequerica',
-> 14.95,
-> 1
-> );


La sentencia dice literalmente que hay que introducir en «libros», rellenando los campos isbn, titulo, etc. un primer elemento, que es el fantástico libro de Lequerica «Desarrollo de aplicaciones para Android«.
El servidor rellenará los campos con la información proporcionada en ese mismo orden. Fíjate en que las cadenas de caracteres se delimitan con la comilla simple.

Metamos algo más de información en nuestra BD…
mysql> insert into libros (isbn, titulo, autor, precio, stock) values ('9701701658','Sistemas operativos diseño e implementación','Andrew S. Tanenbaum', 59.95, 1);
Query OK, 1 row affected, 1 warning (0.12 sec)

Warning (Code 1265): Data truncated for column 'titulo' at row 1
El warning que muestra se debe a que el titulo excede los 30 caracteres que habíamos previsto y la cadena de caracteres ha sido truncada. Otro más:
mysql> insert into libros (isbn, titulo, autor, precio, stock) values ('9786074420463', 'Sistemas operativos modernos', 'Andrew S. Tanenbaum', 59.99, 1);
Query OK, 1 row affected (0.12 sec)

Ahora que tenemos tres elementos en la tabla libros de nuestra BD tienda, comencemos a visualizar la información. La orden que más vas a usar es la siguiente:
mysql> select * from libros;
+---------------+---------------------------------+----------------------+--------+-------+
| isbn | titulo | autor | precio | stock |
+---------------+---------------------------------+----------------------+--------+-------+
| 9701701658 | Sistemas operativos diseño e i | Andrew S. Tanenbaum | 59.95 | 1 |
| 9786074420463 | Sistemas operativos modernos | Andrew S. Tanenbaum | 59.99 | 1 |
| 9788441529373 | Desarrollo de aplicaciones par | Joan Ribas Lequerica | 14.95 | 1 |
+---------------+---------------------------------+----------------------+--------+-------+
3 rows in set (0.00 sec)

que como puedes ver, vuelca todo el contenido de la tabla.
Este tipo de sentencias basadas en expresiones regulares permite hacer selecciones de datos que cumplan unas determinadas condiciones; por ejemplo mostrar los libros con precio superior a 20 €.
mysql> select * from libros where precio>20.00;
+---------------+---------------------------------+---------------------+--------+-------+
| isbn | titulo | autor | precio | stock |
+---------------+---------------------------------+---------------------+--------+-------+
| 9701701658 | Sistemas operativos diseño e i | Andrew S. Tanenbaum | 59.95 | 1 |
| 9786074420463 | Sistemas operativos modernos | Andrew S. Tanenbaum | 59.99 | 1 |
+---------------+---------------------------------+---------------------+--------+-------+
2 rows in set (0.03 sec)

O incluso combinar condiciones mediante los operadores lógicos habituales en programación:
mysql> select * from libros where precio>20.00 && precio<59.99;
+------------+---------------------------------+---------------------+--------+-------+
| isbn | titulo | autor | precio | stock |
+------------+---------------------------------+---------------------+--------+-------+
| 9701701658 | Sistemas operativos diseño e i | Andrew S. Tanenbaum | 59.95 | 1 |
+------------+---------------------------------+---------------------+--------+-------+
1 row in set (0.00 sec)

De la misma forma que para ver todas las columnas usamos el comodín * y no ponemos ninguna condición (es decir, nada precedido por «where»), también podemos mostrar una única columna:
mysql> select titulo from libros;
+---------------------------------+
| titulo |
+---------------------------------+
| Sistemas operativos diseño e i |
| Sistemas operativos modernos |
| Desarrollo de aplicaciones par |
+---------------------------------+
3 rows in set (0.00 sec)

O mejor aún:
mysql> select titulo from libros where autor='Joan Ribas Lequerica';
+--------------------------------+
| titulo |
+--------------------------------+
| Desarrollo de aplicaciones par |
+--------------------------------+
1 row in set (0.03 sec)

Esta última orden selecciona los titulos de la tabla libros, donde el autor sea el señor Lequerica. Obviamente en nuestro ejemplo solo encontrará uno.

————————
TUTORIAL MYSQL:
————————
I. Instalación y arranque, creación de BDs y tablas, introducción y visualización de datos
II. Actualización de datos, eliminación y alteración de las BDs y las tablas
III. Consultas a MySQL desde un programa Java, Primera parte
IV. Consultas a MySQL desde un programa Java, Segunda parte
————————

Esperando a Ubuntu For Android

Cuando me deshice de todos mis PCs para quedarme tan solo con el portatil, estaba intentado optimizar al máximo mi tiempo frente al ordenador. La idea era no tener que sincronizar archivos, tener que transferir constantemente documentos de uno a otro, preocuparme de tener todos siempre actualizados y mantenerlos seguros, etc. En el fondo, simplificar toda la cacharrería de mi casa para perder menos tiempo por su culpa.
Lo mejor vino cuando se presentó la idea de Ubuntu For Android, porque implica la posibilidad de integrar el PC y el teléfono móvil, haciendo que sean ya un único dispositivo alrededor del cual centrar nuestra vida digital. Hoy leo a través de OMG Ubuntu la aparición del siguiente anuncio:

Ojalá signifique que la aparición de teléfonos con Ubuntu For Android esté más cerca…

Bumblebee 3.0 en Ubuntu 12.04


Animado por la llegada de Steam a Linux y por las buenas noticias respecto a los drivers de sonido y video, ayer me decidí a instalar Bumblebee en Ubuntu 12.04 en mi netbook. Para quien no lo sepa, es la utilidad que permite sacar partido a la tecnología Optimus de gráficos híbridos.

Para instalar, basta con:
sudo add-apt-repository ppa:bumblebee/stable
sudo apt-get update && sudo apt-get install bumblebee bumblebee-nvidia

Tras el reinicio, podremos ejecutar las aplicaciones que necesiten mayor potencia 3D de la siguiente forma:
optirun <aplicacion>
Por ejemplo:
optirun glxspheres

Precisamente en el test de las esferas mi tasa de frames por segundo se duplicó:
edm@pc:~$ glxspheres
Polygons in scene: 62464
Visual ID of window: 0x85
Context is Direct
OpenGL Renderer: Mesa DRI Intel(R) IGD
14.037769 frames/sec - 15.666151 Mpixels/sec
13.733664 frames/sec - 15.326768 Mpixels/sec
14.394895 frames/sec - 16.064702 Mpixels/sec
14.295911 frames/sec - 15.954237 Mpixels/sec
14.400819 frames/sec - 16.071314 Mpixels/sec
14.642430 frames/sec - 16.340952 Mpixels/sec
14.561547 frames/sec - 16.250686 Mpixels/sec
14.658486 frames/sec - 16.358871 Mpixels/sec

edm@pc:~$ optirun glxspheres
Polygons in scene: 62464
Visual ID of window: 0x20
Context is Direct
OpenGL Renderer: ION/PCIe/SSE2
28.775184 frames/sec - 32.113105 Mpixels/sec
25.689970 frames/sec - 28.670006 Mpixels/sec
24.842321 frames/sec - 27.724031 Mpixels/sec
29.466556 frames/sec - 32.884676 Mpixels/sec
28.941273 frames/sec - 32.298461 Mpixels/sec
30.369444 frames/sec - 33.892300 Mpixels/sec
29.854043 frames/sec - 33.317112 Mpixels/sec
29.825377 frames/sec - 33.285121 Mpixels/sec

Las (últimas) buenas noticias en GNU/Linux


Los usuarios de GNU/Linux, y en especial de Ubuntu, tenemos motivos para alegrarnos porque a lo largo del último mes han aparecido varias noticias que invitan al optimismo sobre el futuro de la plataforma.

En primer lugar, Nvidia se ha puesto las pilas y parece que sí habrá soporte para Optimus (gráficos híbridos) en los driver. Lo confirmó a finales de agosto y aunque ahora hay una discusión sobre si se debe permitir o no implementar unos tokens GNU en el driver privativo. Por parte de los desarrolladores Linux, el Kernel parece que tendrá soporte para gráficos híbridos en algún momento alrededor de la versión 3.8.

Tener un buen soporte para gráficos híbridos también haría mucho más sencillo que los ordenadores portátiles con esta tecnología pudiesen hacer funcionar mejor efectos de escritorio y aplicaciones 3D, principalmente videojuegos. Lo cual me lleva al anuncio que hizo Valve de que estaba trabajando en una versión Linux de Steam, su plataforma de juegos. Esta llegaría con varios juegos disponibles, siendo el más llamativo el Left4Dead 2 aunque ahora también se puede instala Team Fortress 2 de forma gratuita.

Ayer me levantaba con la noticia de que las primeras cuentas con acceso Beta ya podían descargarse el cliente; y hoy con la de que ya se puede saltar el sistema de Beta Cerrada
Además, Valve no está sola en este viaje a Linux. A su descontento con Windows 8, se le suma el de Blizzard, otra gran compañía de la industria.

Tener la posibilidad de ejecutar videojuegos es algo fundamental para cualquier sistema operativo que quiera triunfar en el entorno de escritorio de los hogares; pero consigo traerá mejoras sustanciales que afectarán también a otras áreas. Por ejemplo un sistema de audio con menores latencias, como la propia Valve afirma tanto para audio como para video; así que podemos esperar la aparición de una buena generación de drivers open-source.