Manejamos para el ejemplo una tabla entradas, que trata sobre la entradas de un blog y que almacena básicamente la siguiente información: identificador, título, cuerpo y tiempo de salida.

DELETE

Borra una serie de filas de la tabla. Podemos usar una claúsula WHERE para limitar las filas a borrar, a las que cumplan una condición. La sintaxis sería:

DELETE FROM nombre_tabla WHERE condicion

Para nuestro caso:

DELETE FROM entradas WHERE id = 2;

TRUNCATE

A diferencia de DELETE, TRUNCATE elimina todas las filas de la tabla sin borrar la tabla. También resetea los contadores de auto incremento a 0. No borra la tabla como tal, la llamada estructura, por lo que luego puede comenzar a hacer inserciones. La sintaxis es:

TRUNCATE TABLE nombre_tabla;

Y para nuestro caso:

TRUNCATE TABLE entradas;

DROP

Finalmente llegamos a DROP. A diferencia de la anterior, DROP no sólo elimina los datos, sino que también eliminar la estructura de la tabla.

DROP TABLE nombre_tabla;

Y para nuestro caso:

DROP TABLE entradas;

DROP DATABASE

A modo de bonus os traigo una instrucción más. Es idéntica a la anterior pero en lugar de borrar una tabla, borra una base de datos al completo. Podemos incluir en la sentencia IF EXISTS de forma que evitemos el error en caso de que no exista la base de datos (muy útil a la hora de hacer copias de seguridad de las bases de datos).

DROP DATABASE [IF EXISTS] nombre_base_datos;

Y para nuestro caso:

DROP DATABASE blog;

Señalar que en MySQL no eliminar la estructura de permisos asociada a la base de datos. Para ello usaremos GRANT, pero de eso ya hablaremos en otra entrada en la que comentaremos los permisos con MySQL.

Imaginemos que guardamos las cantidades de un determinado importe en DOUBLE, al hacer una consulta nos sale una cantidad de números decimales demasiado grande. La idea es redondear el número de forma que sólo aparezcan sólo dos decimales:

SELECT ROUND(importe, 2)
FROM compras;

Si queremos formatear el número de forma que aparezca separado por comas los miles y por un punto la parte decimal (estilo americano), usaremos la función FORMAT. También le indicamos cuántos decimales queremos.

SELECT FORMAT(12332.1,4);

La salida sería: ’12,332.1000′ y será una cadena, no un número.

En MySQL esta operación puede ser directa, imaginemos una tabla personas con la siguiente estructura:

• DNI: varchar que es clave primaria
• Nombre: varchar
• Apellidos: varchar

Queremos hacer una consulta en la que aparezca el dni seguido de los apellidos y el nombre unidos y separados por una coma. Sólo tendremos que hacer lo siguiente, usar la función CONCAT():

SELECT dni, CONCAT(apellidos, ', ', nombre)
FROM personas;

La función acepta un número indeterminado de parámetros de tipo cadena y devuelve la concatenación de las mismas.

Introducción

Como en otros tantos aspectos de las nuevas tecnologías, en el mercado del hosting, tenemos varias posibilidades en cuanto a sistema operativo se refiere. Las dos mayoritarias a día de hoy, GNU/Linux y Microsoft Windows, se reparten una gran cuota de mercado lo que no quiere decir que no existan otras alternativas, como por ejemplo servidores basados en NetBSD o FreeBSD. En este artículo veremos desde el punto de vista de cliente de una empresa de hosting, qué puede hacer que nos decantemos entre una u otra opción.

A priori, cualquier linuxero (entre los que me incluyo) no pensaría en ningún momento en usar un servidor basado en Internet Information Services (el servidor web de Microsoft) sobre un Microsoft Windows Server 2008. Sin embargo, os puedo asegurar que hay circunstancias en las que no sólo es recomendable usar esta opción, sino necesario. De todas maneras si nosotros somos los que elegimos la tecnología a usar y no nos imponen ciertas restricciones (si estamos trabajando para alguien) un poco “especiales”, en líneas generales podríamos decir que la mejor opción es usar GNU/Linux.

Veamos a continuación, desglosados un poco más los detalles que pueden hacer que nos decantemos por una alternativa o por otra.

Precio

Puesto que a la hora de la verdad en todo lo referente a negocios privados, el aspecto más determinante de todos es el presupuesto, comencemos por el precio medio de los hosting. Dado que para poder tener un servidor corriendo bajo Microsoft Windows Server 2003 o 2008, hace falta pagar una licencia comercial y a un precio que no es bajo ni mucho menos, los hosting que ofrecen sistemas Windows suelen ser más caros que los basados en GNU/Linux. Antes de seguir me gustaría aclarar que hay muchas empresas que venden hosting con las dos posibildiades y uno a la hora de contratarlo, elige cuál le interesa.

Siguiendo con el tema económico, hay que contar que en un servicio de hosting, el precio que se paga por un sistema o por otro, no es sólo la licencia del sistema operativo en sí. Hay muchos factores aparte como por ejemplo, el coste del soporte, el gasto energético o la necesidad de comprar licencias de terceros programas, entre otras.

El coste del soporte era una de las excusas esgrimidas por Microsoft sobre el coste real de mantener un servidor en GNU/Linux, porque afirmaban que el soporte era bastante más caro que en GNU/Linux. Sin embargo, debido a la mayor automatización de muchos procesos en GNU/Linux y lo que es más importante, a su mayor difusión, cada vez el soporte es más barato y fácil para este sistema.

En cuanto a los otros factores que hemos también mencionado, el gasto de energía y la necesidad de comprar licencias a terceros, decir de la primera que para ver un consumo de energía real habría que hacer una serie de test y benchamarks con mucha exactitud para poder emitir un juicio objetivo. En el segundo caso, en el de comprar software de terceros, en Windows suele ser más frecuente esta necesidad, aunque en GNU/Linux también puede darse este caso y por supuesto, en ambos se puede utilizar software libre para satisfacer muchas necesidades.

Seguridad

Se ha hablado tantísimo de este aspecto, comparando además a Windows y a Linux, que creo que no es necesario dar mucha información. La seguridad de los sistemas GNU/Linux está más que contrastada, más aún en ambientes de hosting; y además la facilidad de actualización que tiene el software instalado en este sistema hace que ante cualquier versión nueva que tape algún agujero, la actualización sea rápida y no haya de por medio problemas como obligar a reiniciar el servidor.

Este y otros muchos detalles, provenientes de un sistema que nació en un ambiente profesional, hacen de GNU/Linux el ganador por diferencia de este apartado.

Eficiencia

Este aspecto depende mucho del hardware que se use en la máquina en la que resida el servidor así como de la línea que tenga contratado con su ISP (proveedor de servicios de Internet) nuestro servicio de hosting. A priori puede que GNU/Linux distribuya mejor la carga de trabajo que Microsoft Windows, pero es un aspecto que más que preocuparnos a nosotros que somos los que contratamos el host debe preocuparle al que ofrece el servicio.

También es verdad que cada vez son más las aplicaciones web basadas en tecnologías no tan eficientes como PHP, por ejemplo Ruby On Rails o Python (bastante más eficiente que Ruby pero aún así más lento que PHP) con Django o Turbo Gears; que requieren una mayor cantidad de recursos.

Posibilidades y necesidades específicas

En este punto es donde quizás nos tengamos que decantar por una solución Microsoft Windows por obligaciones de los requisitos. Imaginemos que necesitamos usar por obligación una base de datos SQL Server, de Microsoft. Ante este caso, dado que este sistema gestor de base de datos sólo ejecuta en el sistema operativo de Microsoft, estaremos obligados a usar un host con Windows Server que ofrezca esta posibilidad. También es verdad que éste no suele ser el caso más común, por fortuna, y que para muchísimas otras circunstancias, la solución correcta es Linux, por razones casi idénticas. Por ejemplo, a día de hoy, es difícil encontrar un sistema basado en Windows que ofrezca soporte para ejecutar aplicaciones web implementadas con Ruby o Python, dos tecnologías en alza.

Por lo tanto en este apartado, dependiendo de nuestro caso deberemos elegir una plataforma u otra, aunque como repito en la mayor parte de los casos el resultado es favorable para GNU/Linux. De hecho, en mi caso personal, por ejemplo, nunca elegiría trabajar con ASP.NET y SQL Server, por ejemplo, pudiendo trabajar con tecnologías libres que cubren las mismas necesidades ya que además de resultarme más barato, dispongo de una cantidad de documentación y soporte mucho mayor (aparte de que las tecnologías de Microsoft no son código abierto). Sin embargo, si tenemos un encargo profesional y por razones ajenas a nosotros hay que utilizar dichas tecnologías, tendremos que dencantarnos por un host con Windows Server.

Adaptabilidad

Normalmente, las tecnologías libres suelen estar mejor estandarizadas que sus equivalentes propietarias, por lo que de cara a migrar datos de un sistema gestor de base de datos a otro distinto, o a la hora de cambiar el servidor, si estamos operando con un host que trabaje con GNU/Linux, posiblemente se nos presenten menos problemas.

Futuro

Tanto el soporte como las nuevas versiones de software, están prácticamente aseguradas en los dos sistemas. Los costes de actualización de una versión a otra en el caso de software privado, no os repercutirán demasiado, dado que al igual que el coste de la licencia, estos son gastos que paga la empresa a la que contratamos. Por esta razón suelen ser más caros los servicios de host basados en sistemas Windows. Aparte de eso, aunque este es un tema importante a la hora de elegir un servicio de host, el asegurarnos que el software está siempre actualizado y alejado de posibles vulnerabilidades, no existen diferencias de un sistema a otro.

Conclusiones

A lo largo del artículo, habréis observado que para la mayor parte de las necesidades, excepto para las que necesitan expresamente ciertas tecnologías como .NET, podemos usar GNU/Linux por multitud de razones. Comenzando por el precio, terminando en la seguridad y pasando por variedad de otros aspectos como por ejemplo la capacidad de adaptación, GNU/Linux suele ser el más idóneo o en casos extraños, estar al nivel de su rival. También es cierto que como digo haya aplicaciones que por cuestiones de los requisitos necesiten sistemas Windows o en todo caso ejecuten con Mono (no os lo recomiendo si vais a usarlo como un sistema en producción y no en pruebas o de uso personal). En un futuro, también habrá que tener en cuenta aspectos como la virtualización en servidores, tecnología bastante avanzada ya pero que no se ofrece en muchos servicios de host.

Elegido el sistema, tenéis que elegir la empresa de hosting que contratar. En otros artículos os contarán mejor cómo seleccionar a dicha empresa de entre todas las que se ofertan en la red, pero como primer paso os recomiendo no comprobar sólo la cantidad de servicios que ofrecen, sino la calidad de los mismos.

Por último, os dejo unos cuantos enlaces en la sección “En la red”, de servidores web disponibles para GNU/Linux y un poco más de información para que leáis en la red sobre las versiones de servidor de Microsoft Windows y el servidor web que usan, Internet Information Services.

Conclusiones

Aunque existen otras opciones para realizar labores similares a ésta, como Hibernate o directamente JDBC, siempre es bueno como he dicho desde un comienzo, conocer más posibilidades sobre todo en el caso de este tipo de tecnologías tan difundidas a día de hoy. No digo que Mono esté tan difundido como algunos querríamos, pero sí es verdad que por suerte o por desgracia, .NET Framework está presente en cada vez más ordenadores, y la compatibilidad de Mono con la plataforma de Microsoft le augura un futuro muy prometedor.

A través de este curso, he intentado mostraros las operaciones básicas y preliminares para comenzar a funcionar con ADO sobre Mono, utilizando además, una base de datos libre, MySQL que a su vez tiene una implementación de ADO propia. Sin lugar a dudas, un cocktail interesante.

Lo dicho, espero que os haya gustado y sobre todo que os haya sido lo suficientemente interesante como para que os animéis a desarrollar aplicaciones algo más complejas utilizando estas tecnologías.

Previamente deberemos incluir la referencia a nuestro proyecto para el ensamblado System.Data que lo encontraréis dentro del menú de referencias en la pestaña “Paquetes”. En el comienzo del fichero también deberéis rellenar su respectivo using System.Data.

Una vez hecho esto, para rellenar el DataSet sólo tendremos que hacer:

public static void Main(string[] args)
{
	MySqlConnection conexion = new MySqlConnection();
	conexion.ConnectionString = "database=linuxhispano;
server=localhost;user id=root; pwd=contraseña";
	conexion.Open();
	// nuevos objetos a utilizar
	DataSet datos = new DataSet();
	MySqlDataAdapter adaptador = new MySqlDataAdapter();
	try
	{
		MySqlCommand comando = new MySqlCommand
("SELECT * FROM ejemplo", conexion);
		adaptador.SelectCommand = comando;
		adaptador.Fill(datos);
	}
	catch(MySqlException exc)
	{
		Console.WriteLine("Ocurrió un error : " + exc.Message);
	}
	finally
	{
		conexion.Close();
	}
}

Dentro de datos, tendremos un DataTable con todos los datos. Pero, ¿cómo acceder a ellos? Espero que con el siguiente bucle que voy a mostrar se quede todo un poco más claro. En este bucle recogeremos la tabla del DataSet y posteriormente la recorreremos primero por filas y luego cada fila por elementos. Imprimiremos el resultado por pantalla. Para no repetir código sólo pondremos la parte nueva y dónde va insertada.

[...]
// nuevos objetos a utilizar
DataSet datos = new DataSet();
MySqlDataAdapter adaptador = new MySqlDataAdapter();
[...]
	adaptador.Fill(datos);
	DataTable tabla = datos.Tables[0];
	int i = 0;
	foreach(DataRow fila in tabla.Rows)
	{
		Console.WriteLine("Fila " + i.ToString()
 + " --> Elementos : ");
		int j = 0;
		foreach(Object celda in fila.ItemArray)
		{
			Console.WriteLine("\tElemento : "
 + j.ToString() + " - " +  celda.ToString());
			j++;
		}
		i++;
	}
}
catch(MySqlException exc)
[...]

La salida sería algo así:

Fila 0 --> Elementos :
	Elemento : 0 - 25
	Elemento : 1 - Gráficos
Fila 1 --> Elementos :
	Elemento : 0 - 26
	Elemento : 1 - Programación
Fila 2 --> Elementos :
	Elemento : 0 - 27
	Elemento : 1 – Sonido

A partir de aquí, podríamos modificar los registros y no almacenarlos luego en la base de datos, convertir la salida en un fichero XML de manera directa, realizar un mapeo de la base de datos y hacer que los cambios sean instantáneos en ella… en definitiva, todo un mundo de opciones a muy pocas líneas de código de distancia que posibilitan, como he dicho desde un comienzo, un desarrollo del código ligero y rápido en el manejo de datos.

1. Creamos la consulta y la asignamos a una cadena
2. Creamos el comando con la consulta que acabamos de crear
3. Asignamos la conexión pertinente al comando
4. Lo ejecutamos

Ampliando nuestro ejemplo, quedaría así:

public static void Main(string[] args)
{
	MySqlConnection conexion = new MySqlConnection();
	conexion.ConnectionString = "database=linuxhispano;
server=localhost;user id=root; pwd=contraseña";
	conexion.Open();
	try
	{
		string consulta = "INSERT INTO ejemplo (numero , tema)
 VALUES ('27', 'Sonido')";
		MySqlCommand comando = new MySqlCommand(consulta);
		comando.Connection = conexion;
		int resultado = comando.ExecuteNonQuery();
		Console.WriteLine("Filas afectadas : "
 + resultado.ToString());
	}
	catch(MySqlException exc)
	{
		Console.WriteLine("Ocurrió un error : " + exc.Message);
	}
	finally
	{
		conexion.Close();
	}
}

Como se puede apreciar, hemos cuidado que se finalice la conexión aunque existan errores, con finally y hemos controlado los posibles errores que aparezcan. En nuestro caso debería decir: “Filas afectadas: 1”, puesto que la inserción sólo realiza una.

A la hora de realizar la inserción podríamos haber utilizado MySqlParameter, que nos provee de un mejor tratamiento de los datos de cara a mejorar la seguridad y ampliar las posibilidades, pero se escapaba del carácter introductorio de este texto.

Como veis hemos ejecutado el comando con el método ExecuteNonQuery que utilizaremos para operaciones de inserción, borrado y actualización. En el caso de consultas como tales con SELECT, utilizaremos ExecuteReader y en el caso que veremos a continuación, cuando trabajamos con escalares ExecuteScalar. No siempre es así y depende de lo que vayamos a hacer varía el método pero para este punto nos vale.

Las consultas que devuelven escalares son aquellas que devuelven un sólo número, por ejemplo, si preguntamos a la base de datos que nos cuente cuántas filas hay en la tabla. Veamos este ejemplo, el proceso es el mismo pero utilizamos ahora el método ExecuteScalar y cambiamos convenientemente la consulta. Utilizaremos el constructor de MySqlCommand para inicializar con la consulta y la conexión el objeto, de forma que nos ahorremos una sentencia:

public static void Main(string[] args)
{
	MySqlConnection conexion = new MySqlConnection();
	conexion.ConnectionString = "database=linuxhispano;
server=localhost;user id=root; pwd=contraseña";
	conexion.Open();
	try
	{
		MySqlCommand comando = new MySqlCommand
("SELECT COUNT(*) FROM ejemplo", conexion);
		string resultado = comando.ExecuteScalar().ToString();
		Console.WriteLine("Filas en la tabla : " + resultado);
	}
	catch(MySqlException exc)
	{
		Console.WriteLine("Ocurrió un error : " + exc.Message);
	}
	finally
	{
		conexion.Close();
	}
}

La salida por consola debe ser “Filas en la tabla: 3”. Finalmente, veamos cómo recorrer hacia adelante la tabla con ExecuteReader(). La metodología a seguir es ejecutar el comando con este método y posteriormente, imprimir por pantalla el resultado que va devolviendo el lector mientras haya filas que recorrer. El código lo tenéis a continuación:

public static void Main(string[] args)
{
	MySqlConnection conexion = new MySqlConnection();
	conexion.ConnectionString = "database=linuxhispano;
server=localhost;user id=root; pwd=contraseña";
	conexion.Open();
	try
	{
		MySqlCommand comando = new MySqlCommand
("SELECT tema FROM ejemplo", conexion);
		MySqlDataReader lector = comando.ExecuteReader();
		while(lector.Read())
		{
			Console.WriteLine(lector.GetString(0));
		}
		lector.Close();
	}
	catch(MySqlException exc)
	{
		Console.WriteLine("Ocurrió un error : " + exc.Message);
	}
	finally
	{
		conexion.Close();
	}
}

El resultado debería ser en tres líneas distintas, los tres temas que hay presentes en estos momentos en la base de datos. Pasadas estas primeras operaciones, en el siguiente punto vamos a rellenar un DataSet con los datos de la base de datos y vamos a recorrerlo a través de las clases: DataTable, DataColumn y DataRow antes de dar por terminado este artículo.

Uno de los aspectos esenciales de ADO, como no podía ser de otra manera, es la interacción directa con los datos provenientes de las bases de datos. Para comenzar a operar con ello os presento estas cuatro clases: DataSet, DataTable, DataColumn y DataRow; conjunto de datos, tabla de datos, columna de datos y fila de datos, respectivamente.

Un conjunto de datos, es un objeto que almacena datos, en forma de tablas por ejemplo, y que pueden provenir de distintos orígenes. Una tabla de datos, es el objeto que almacena los datos de, una consulta, por ejemplo, en forma de tabla en la memoria y a la que podremos acceder, básicamente, a través de sus filas y columnas. Todas estas clases suelen tener una representación física en la base de datos, pero no tiene que ser así siempre, y podemos trabajar de manera asíncrona con la base de datos o directamente con datos provenientes de otras fuentes como por ejemplo ficheros XML.

Una de las ventajas de ADO es lo transparente que hace al desarrollador el origen de los datos así como la interacción con los mismos, pues al hacer a través de objetos, el manejo en la aplicación es muy intuitivo. Llegados a este punto y para seguir progresando vamos a crear una tabla en la base de datos a la que le agregaremos una serie de registros, de manera que posteriormente podamos interactuar con ellos. Se tratará de una base de datos de revistas.

En la tabla almacenaremos sólo dos campos para el ejemplo: uno de tipo entero que representará el número de la revista, “numero”; y otro de tipo cadena donde almacenaremos la temática de ese número de revista, “tema”. El número será la clave primaria y ambos no podrán ser nulos.

Nos dirigimos de nuevo a la shell de MySQL y escribimos:

CREATE TABLE `linuxhispano`.`ejemplo` (
`numero` INT NOT NULL ,
`tema` VARCHAR( 64 ) NOT NULL ,
PRIMARY KEY ( `numero` )
) ENGINE = MYISAM CHARACTER SET utf8 COLLATE utf8_general_ci

Como comprobaréis, además de indicar los campos he añadido a la tabla el motor a utilizar, ISAM y el juego de caracteres UTF-8 para evitar problemas de acentos y eñes, entre otros. Pasemos a agregar un par de registros:

INSERT INTO `lpmagazine`.`ejemplo` (
`numero` ,
`tema`
)
VALUES (
'25', 'Gráficos'
);
INSERT INTO `linuxhispano`.`ejemplo` (
`numero` ,
`tema`
)
VALUES (
'26', 'Programación'
);

Ya tenemos los datos en la base de datos. Nuestra labor ahora es conectarnos para realizar consultas sobre ellos. Veamos cómo.

Integrar estadísticas con Google Analytics

Las estadísticas son algo básico para un blogger, así que si usáis Google Analytics os interesará esta parte. Dentro de la configuración hay una parte que lo especifica: “AdSense, estadísticas y código a medida”, sin embargo, no es trivial la configuración.

Dentro de esa parte tenemos un textarea para rellenar con título: “Estadísticas y código a medida”. Deberemos introducir el siguiente código JavaScript, modificando sólo nuestro identificador de cliente de Google Analytics (es una cadena de la siguiente forma: “UA-XXXXXX-X). Veamos:

<script type=”text/javascript”>

var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-EL_TUYO-X']);
_gaq.push(['_trackPageview']);

(function() {
var ga = document.createElement(‘script’); ga.type = ‘text/javascript’; ga.async = true;
ga.src = (‘https:’ == document.location.protocol ? ‘https://ssl’ : ‘http://www’) + ‘.google-analytics.com/ga.js’;
var s = document.getElementsByTagName(‘script’)[0]; s.parentNode.insertBefore(ga, s);
})();

</script>

Una vez hecho esto guardamos y nuestro blog móvil también contará en la visitas de Analytics.

Integrar publicidad con Google AdSense

Los canales convencionales de publicidad para AdSense no tienen el formato apropiado para la web móvil. Por lo tanto, deberemos comenzar creando un canal para móviles en nuestra cuenta de AdSense.

Para ello inicias sesión en la plataforma de anuncios de Google y dentro de ella te diriges a:

1. Mis anuncios
2. Contenido para móviles
3. Criterios de seguimiento personalizados

Una vez creado el criterio de seguimiento, dentro de “Contenido para móviles”, elegimos “Bloques de anuncios” y creamos un anuncio a nuestro gusto. Guardamos y obtenemos el código.

Con este código, el criterio que acabamos de crear y nuestra identidad de AdSense, tenemos ya todo listo. Rellenamos nuestra identidad y nuestro canal dentro de los campos preparados para ello en la configuración de WPtouch:

• Identidad de Google AdSense
• Canal de Google AdSense

Y el código lo incluimos en el mismo textarea en el que hemos introducido el código de Analytics, incluyendo algún salto de línea entre ellos.

Con ésto estará todo listo.

Dentro de los modelos de negocio del software libre, la consultaría es un pilar básico. Existe el asesoramiento clásico, donde particulares o empresas ofrecen mediante comunicaciones a otros particulares o empresas; soluciones para problemas puntuales.

Sin embargo, gracias a los sistemas en la nube, es posible extrapolar este servicio para hacerlo llegar al gran público. WordPress Questions es un proyecto creado por Lawrence Krubner y Darren Hoyt. Nos ofrece una plataforma en la que todos podemos ser:

• Asesores de WordPress, recibiendo una recompensa económica por cada asesoramiento prestado
• Usuarios, podemos preguntar cualquier cosa sobre WordPress y obtener una respuesta rápida y fiable a cambio de un precio que nosotros fijaremos entre 1 y 100 dólares.

Os dejo un vídeo presentándolo (está en inglés):

Ésto puede ser también útil no sólo para problemas de pantallazos, sino para ahorrar tiempo en la habilitación o deshabilitación de plugins.

Veamos, lo primero que tenemos que hacer es acceder a nuestra base de datos. Con los datos de inicio de sesión que tiene WordPress almacenados internamente en “wp-config.php” podemos acceder usando un cliente como:

• phpMyAdmin
• HeidiSQL
• SQLyog (la versión Community es de código libre y funciona bien con Wine)
• O directamente con la línea de comandos

Una vez dentro de la base de datos de WordPress, nos dirigimos a la tabla de opciones, normalmente “wp_options” (puede cambiar el prefijo). Dentro de dicha tabla, hacemos una consulta para ver los plugins activos:

SELECT * FROM wp_options WHERE option_name = 'active_plugins';

El resultado será algo similar a esto:

a:20:{i:0;s:19:”akismet/akismet.php”;i:1;s:43:”all-in-one-seo-pack/all_in_one_seo_pack.php”;i:2;s:19:”anti-email-spam.php”;i:3;s:36:”contact-form-7/wp-contact-form-7.php”;i:4;s:28:”embed-iframe/embediframe.php”;i:5;s:32:”facepress-ii/FT-Facepress-II.php”;i:6;s:50:”google-analytics-for-wordpress/googleanalytics.php”;i:7;s:36:“google-sitemap-generator/sitemap.php”;i:8;s:21:”hgk-smtp/hgk-smtp.php”;i:9;s:24:”ic-besocial/besocial.php”;i:10;s:45:”limit-login-attempts/limit-login-attempts.php”;i:11;s:37:”shutter-reloaded/shutter-reloaded.php”;i:12;s:65:”subscribe-to-comments-reloaded/subscribe-to-comments-reloaded.php”;i:13;s:23:”wp-minify/wp-minify.php”;i:14;s:27:”wp-pagenavi/wp-pagenavi.php”;i:15;s:39:”wp-recentcomments/wp-recentcomments.php”;i:16;s:25:“wp-smushit/wp-smushit.php”;i:17;s:27:”wp-super-cache/wp-cache.php”;i:18;s:31:”wp-to-twitter/wp-to-twitter.php”;i:19;s:19:”wptouch/wptouch.php”;} 

Guardamos este resultado en un fichero de texto y lo conservamos (nos lo mandamos por correo o algo por si lo necesitamos restaurar). Ahora nos toca actualizar esta opción para deshabilitarlos todos en una sola instrucción, depende de la versión de WordPress que manejemos:

• Si usamos WordPress 2.9 o superior (lo recomendable):

UPDATE wp_options
SET option_value = 'a:0:{}'
WHERE option_name = 'active_plugins';

• Si usamos una versión anterior:

UPDATE wp_options
SET option_value = ''
WHERE option_name = 'active_plugins';

Para volver a habilitar los plugins deshabilitados, haríamos lo mismo pero dentro de SET  option_value = ‘aquí el contenido antiguo’ y todo volverá a estar como antes (esto es útil por ejemplo si estamos seguros de que el problema no es de los plugins).

Antes de seguir sería conveniente que copiarais al directorio del proyecto el fichero “mysql.data.dll” que venía dentro del paquete comprimido del conector. Os dirigís a referencias y haciendo clic sobre el mismo título “Referencias”, elegís “Editar referencias…”. De las tres pestañas que aparecen en el diálogo elegís “Ensamblado .NET” y os dirigís al directorio del proyecto o donde tengáis guardado el fichero. Lo elegís y lo añadís.

Desde este momento tenéis referenciado el conector dentro de vuestro programa. Ahora el siguiente paso es importarlo al fichero Main.cs. Para ello escribís debajo de “using System; ”, “using MySql.Data.MySqlClient;”. El archivo quedaría así:

using System;
using MySql.Data.MySqlClient;
namespace ejemplo_mono_ado
{
	class MainClass
	{
		public static void Main(string[] args)
		{
			Console.WriteLine("¡Hola Mundo!");
// Hola Mundo inicial creado por el IDE
		}
	}
}

Con ésto ya tendríamos el espacio de nombres del conector MySQL disponible en nuestro código por lo que a partir de ahora sí que podríamos tratar con las clases del mismo.

Antes de nada, de forma básica, vamos a revisar qué necesitamos, cómo obtenerlo y en caso necesario, cómo configurarlo. En este momento ,creo conveniente señalar que utilizaremos MonoDevelop,el entorno de desarrollo integrado para Mono más popular, en lugar de utilizar directamente el compilador, mcs; para centrarnos directamente en el desarrollo con ADO y dejar de lado los detalles que no son necesarios.

Mono y MonoDevelop

En función de la distribución que utilicéis, las circunstancias particulares cambiaran, pero básicamente os comento dos alternativas que probablemente os sirvan prácticamente a todos. La primera es dirigiros a vuestro gestor de paquetes y buscar los paquetes correspondientes. Como monodevelop, que será más o menos así el nombre del paquete, depende de Mono, si elegís éste se os seleccionaran los demás paquetes necesarios para desarrollar y ejecutar programas con Mono. Es decir, básicamente instalando MonoDevelop a través del paquete homónimo, tendréis todo preparado. Además, es más que probable que tengáis instalado Mono en vuestro equipo por defecto. Por ejemplo, el entorno de escritorio Gnome utiliza esta tecnología ampliamente.

La segunda solución, la más larga y menos recomendable es instalar Mono compilando el código fuente. Necesitaremos tener instalados: cmpilador de C (gcc), Bison y las librerías de desarrollo para glib. Descargaremos el código fuente desde la sección de descargas del Proyecto Mono (pondrá algo así como Mono el número de la versión seguido de “sources”). Utilizaremos el directorio “/opt” para evitar problemas. Más o menos el proceso de instalación sería:

1. Descomprimimos y desempaquetamos el código fuente, gráficamente o mediante la consola: $ tar zxvf mono-X.XX.tar.gz
2. Configuramos los archivos para realizar el make: $ ./configure –prefix=/opt/mono
3. Ejecutamos make para ejecutar el código fuente: $ make
4. Finalmente instalamos: $ sudo make install

Tras la instalación deberemos configurar debidamente las variables de entorno. Para ello ejecutamos desde la terminal:

$ export PATH=$PATH:/opt/mono/bin
$ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/mono/lib
$ export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/opt/mono/lib/pkgconfig
$ export MONO_PATH=/opt/mono/lib

Una vez ya tenemos instalado Mono, pasamos a instalar MonoDevelop de una forma análoga. Accedemos al sitio de MonoDevelop, descargamos el código fuente y:

1. Desempaquetamos el código fuente y lo descomprimimos: $ tar zxvf monodevelop-X.X.tar.bz2
2. Configuramos para crear el make: ./configure –prefix=`pkg-config –variable=prefix mono`
3. Compilamos: $ make
4. Instalamos: $ make install

Ya tendríamos esta parte lista, pero como dije antes, mucho mejor utilizar el sistema gestor de paquetes para evitar problemas derivados de no poder actualizar tan fácilmente o por ejemplo, las dependencias insatisfechas.

MySQL

De igual manera instalaremos el servidor MySQL al que nos conectaremos desde nuestra aplicación con C#. Dado que hay gran cantidad de tutoriales y manuales en la red, voy a ser bastante breve. Básicamente deberéis buscar en vuestro gestor de repositorios el paquete mysql-server y ya tendréis el servidor de base de datos instalado.

Conector

Finalmente, descargaremos el fichero con el conector de MySQL para .NET y Mono. Es un fichero con extensión .dll, que es la extensión con que suelen ser almacenados los ensamblados, como es el caso de .NET/Mono. Si queréis saber más sobre ensamblados, el CLI, o cualquier otro detalle más técnico propio de .NET/Mono, podéis visitar la Wikipedia (preferiblemente en inglés) o la MSDN (antes también Mono-Hispano pero ahora mismo parece que no está accesible). Aunque no sea el objetivo de este artículo definiré brevemente dichos conceptos para que quede algo más claro. Podríamos decir que un ensamblado en Mono es un conjunto de clases implementadas junto con sus metadatos correspondientes para ser utilizados, recogidos en un fichero que puede ser llamado desde un proyecto Mono.

En el caso que nos ocupa utilizaremos una implementación de la arquitectura ADO.NET creada por el propio proyecto MySQL para posibilitar una comunicación lo más nativa e integrada posible entre aplicaciones desarrolladas con .NET/Mono y MySQL. El conector, que así se llama, podéis encontrarlo en la web de MySQL (http://dev.mysql.com/downloads/connector/net/).

Una vez nos encontremos en el sitio, descargamos los ficheros para Windows sin instalador (un fichero .zip con varios ensamblados), lo descomprimimos y ya tendremos todo preparado para comenzar el proyecto.

Antes de continuar un detalle importante. Microsoft Windows no es case sensitive, sensible a mayúsculas/minúsculas, en cuanto a rutas, pero GNU/Linux sí lo es, por lo que deberéis renombrar los ficheros dll que utilicemos conforme se llaman en el programa que será: “MySql.Data” en lugar de “mysql.data” como vienen nombrados por defectos (los demás también de manera análoga).

• Página oficial del Primer Ministro Británico: http://www.number10.gov.uk
• Mozilla Labs: http://mozillalabs.com
• Spotify: http://www.spotify.com
• Mashable: http://mashable.com
• Stallone: http://sylvesterstallone.com
• Jane Fonda: http://janefonda.com
• Tom Jones: http://www.tomjones.com
• Fresh Apps: http://www.freshapps.com
• ZDNet: http://news.zdnet.com

¿Qué otra web famosa o de empresa u organismo de relevancia conoces que esté hecha con WordPress? A ver si entre todos, vía comentarios, conseguimos hacer una lista de más de 100 webs de este tipo que usen webs. Porque no sé si lo sabéis pero WordPress está detrás del 15% de las páginas web más visitadas.

Por supuesto, Linux Hispano funciona bajo WordPress y otro proyecto personal que llevo adelante con Alberto y otro amigo, Red de Autores, también.

Las facilidades que provee una tecnología multiplataforma de alto nivel como Mono, unido a la integración en el mismo de MySQL a través de un conector nativo para ADO.NET, hacen que tengamos al alcance de nuestra mano un binomio de software libre con una potencia envidiable. Siempre tenemos otras opciones también libres, como Java en el caso de tecnología de desarrollo multiplataforma; y otras bases de datos como PostgreSQL para arquitecturas cliente-servidor, o SQLite para máquinas locales, que gozan de muy buena salud.

A lo largo de este curso explicaremos de una manera introductoria el uso de ADO.NET; y lo utilizaremos a través de un interfaz en modo texto. Sin lugar a dudas, las personas que hayan programado anteriormente para la .NET Framework de Microsoft en Windows, conocerán bastantes de los detalles que aquí relatamos y es que como ya muchos sabréis, Mono es una implementación libre de esta plataforma.

Mono, MySQL y ADO.NET

Vamos a ser breves en la presentación de las herramientas con las que vamos a tratar, pero siempre considero útil situar al lector, para que en caso de que no conozca las herramientas sepa situarse en un contexto apropiado.

Mono es un proyecto libre, creado por Ximian en su día y actualmente impulsado por Novell tras la compra de la primera por parte de la segunda, que ofrece una serie de herramientas libres que cumplen las especificaciones de .NET. La figura más destacada del Proyecto Mono es Miguel de Icaza, cofundador de Gnome, hombre fuerte en Novell y una persona un tanto polémica dentro del software libre por sus aportaciones a la vez que sus acercamientos a Microsoft.

MySQL como sabréis, es el sistema gestor de base de datos creado por una empresa del mismo nombre y que posteriormente ha sido adquirido por Sun Microsystems, y recientemente por Oracle. Su popularidad en la red gracias al binomio que forma con PHP la han llevado a convertirse en la base de datos más conocidas del mundo web y una de las alternativas libres más eficaces en este tema.

Finalmente, ADO.NET, es un conjunto de componentes que permiten acceder a datos y a servicios de datos, a través de un arquitectura completa que facilita enormemente ciertas labores al desarrollador. Está integrado dentro de Mono y existe un conector creado ex profeso para ligar a MySQL con Mono/.NET a través de esta arquitectura. Existen otras alternativas similares como Hibernate que nunca está de más conocer.