javoaxian cambió a: javoaxian.me
Este blog se mantendrá como histórico del nuevo javoaxian.me. Por tal motivo, sólo serán creados post que harán referencia a los del nuevo blog. Si hay dudas y comentarios, favor de hacerlos en javoaxian.me.

lunes, 30 de junio de 2008

Enviar archivos por Bluetooth desde celular HTC Touch a otro dispositivo

El post del día de hoy he decidido ponerlo para mostrar como envío archivos desde mi celular HTC Touch a algún otro dispositivo. Cabe mencionar que mi celular está en inglés por lo que todas las opciones serán referenciadas en este idioma.

La forma más fácil de hacer ésto es abrir el File Explorer y buscar el archivo que queremos mandar.

Para abrir este programa iremos a Start -> File Explorer:


Se abrirá nuestro explorador de archivos.


Ahora deberemos buscar el archivo que deseamos enviar. Para este ejemplo yo voy a escoger mi archivo with_or_without_you.3gp. Para mandar el archivo podemos realizarlo de dos formas.

Una es dejar presionado sobre el archivo hasta que aparezca el menú contextual y seleccionar la opción Beam File...


La otra opción es movernos sobre nuestros archivos hasta que quede seleccionado el que deseemos enviar y posteriormente presionar sobre la opción Menu -> Beam File...


Nos aparecerá una pantalla donde nos aparecerán todos los dispositivos disponibles. Bastará con presionar sobre el dispositivo al que deseamos enviar el archivo para que inicie la petición de transferencia.


Ahora simplemente hay que aceptar la transferencia en el otro dispositivo y listo.

sábado, 28 de junio de 2008

Usar el comando mysql para conectarse a una base de datos en otro equipo

En esta ocasión nos conectaremos a una base de datos de manera remota, usando el comando mysql.

La forma para conectarnos es muy sencilla, bastará con agregar las siguientes opciones del comando.

javoaxian@darthmaul:~$ mysql -u usuario -h servidor -P #puerto -D base_de_datos -p

Ahora explicaré brevemente las opciones aunque creo que son muy sencillas de adivinar lo que hacen.
  • -u: Nombre del usuario de la base de datos.
  • -h: Nombre o IP del servidor donde se encuentra la base de datos.
  • -P: Puerto donde esta ejecutandose MySQL (el default es: 3306).
  • -D: Nombre de la base de datos.
  • -p: Para que nos solicite nuestra contraseña.
Para concluir pondré un ejemplo para conectarme a mi base de datos:

javoaxian@darthmaul:~$ mysql -u javoaxian -h 127.0.0.1 -P 3306 -D javoaxian -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 12 to server version: 5.0.24-standard

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

jueves, 26 de junio de 2008

Obtener conversión de moneda con Google

Este post es sobre todo para ayuda mia ja ja ja ja, ya que siempre se me olvida cómo se puede obtener el tipo de cambio de una cantidad de una moneda a otra usando Google. Por tal motivo y para no seguir molestando al buen Oníricaweb pongo la forma de hacer ésto.

Ingresar a la página de Google.
Proporcionaremos en la caja de texto donde ingresamos las palabras que deseamos buscar la cantidad que deseamos buscar seguido de la cadena "dollars to pesos". Ésto es en caso de querer convertir una cantidad de dolares estadounidenses a pesos mexicanos.


Presionamos la tecla "Enter" o hacemos clic en el botón "Buscar con Google". Nos aparecerá el resultado de la búsqueda y nos indicará la conversión.


Ojala que esto les sea de utilidad tanto como a mi.

martes, 24 de junio de 2008

Habilitar una base de datos en MySQL para poder conectar a ella vía remota

Vamos a ver el día de hoy cómo podemos configurar nuestra base de datos en MySQL para poder conectarnos a ella de forma remota. Esto nos servirá para permitir conectar clientes de base de datos o el comando mysql a nuestra base de datos que se encuentra en un equipo diferente del que nos estámos conectando.

La forma para habilitar la conexión remota a nuestra base de datos es dandole permisos al usuario que tiene acceso a la base de datos, y la forma de hacerlo es con el comando GRANT. Esto deberá ser ejecutado por el usuario root de mysql.

Aquí pongo un ejemplo de cómo le voy a dar permisos al usuario javoaxian para conectarse a la base de datos javoaxian de manera remota.

javoaxian@darthmaul:~$ mysql -u root -p mysql
Enter password:
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 7 to server version: 5.0.24-standard

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> GRANT ALL PRIVILEGES ON javoaxian.* TO 'javoaxian'@'%' IDENTIFIED BY 'CONTRASENIA';
mysql> FLUSH PRIVILEGES;

Como se puede observar, el signo "%" es el que hace la diferencia, éste le indica al comando GRANT que nuestro usuario tiene permisos para conectarse vía remota a la base de datos que le estamos especificando. Y el comando FLUSH PRIVILEGES sirve para actualizar los permisos;

Recuerden que si tienen un firewall activado, deberán construir las reglas para permitir a los usuarios conectarse al puerto 3306 que es el puerto por donde corre MySQL o el que tengan configurado en caso de haberlo cambiado.

Esto es todo para activar esta opción, ahora ya podrán conectar Eclipse y SQL Explorer o cualquier otro cliente que deseen usar con su base de datos.

domingo, 22 de junio de 2008

Crear una base de datos en MySQL junto con un usuario para accedera a ella

El motivo de crear este post, es para poder explicarle a una amiga como puede crear una base de datos en MySQL, así como un usuario para conectarse a esta base de datos.

Lo primero que debemos hacer, es conectarnos con el usuario root a mysql.
En caso de que el usuario root tenga asignada una contraseña deberemos ejecutar lo siguiente:

javoaxian@darthmaul:~$ mysql -u root -p mysql

En caso contrario:

javoaxian@darthmaul:~$ mysql -u root mysql

Ahora que ya estamos conectados a mysql, crearemos la base de datos. Para este ejemplo, el nombre de la base de datos será db_proyesp.

mysql> CREATE DATABASE db_proyesp;

Ya que tenemos creada la base de datos, crearemos el usuario que se podrá conectar a la base de datos dandole todos los privilegios, que en este caso será us_proyesp.

mysql> GRANT ALL PRIVILEGES ON db_proyesp.* TO 'us_proyesp'@'localhost' IDENTIFIED BY 'CONTRASEÑA';
mysql> FLUSH PRIVILEGES;

En las instrucciones anteriores, le decimos al comando GRANT que le de todos los privilegios al usuario us_proyesp sobre todos los elementos de la base de datos db_proyesp, además de asignarle una contraseña al usuario. Y con el comando FLUSH PRIVILEGES actualizamos los privilegios del manejador.

Con esto ya tenemos creada tanto la base de datos como nuestro usuario en mysql.

Nuestro siguiente paso será salirnos de nuestra sesión de usuario root de mysql.

mysql> exit;
Bye

Ahora nos conectaremos a la nueva base de datos con el usuario que también creamos.
El comando para conectarse a la base de datos será:

javoaxian@darthmaul:~$ mysql -u us_proyesp -p db_proyesp

Como podemos observar, con la opción -u le indicamos al comando mysql el usuario de la base de datos.
Con la opción -p, indicamos que nos deberá pedir la contraseña del usuario y por último, seguido a la opción -p le indicamos el nombre de la base de datos a la que deseamos conectarnos.

Esto es todo con relación a este tema.

viernes, 20 de junio de 2008

Instalar Subversion (SVN) desde su código fuentes con Apache2 en Debian y Ubuntu

En un post anterior ya había explicado como instalar Subversion desde los repositorios de Debian y Ubuntu, pero el día de hoy voy ha explicar como podemos instalar este software atravéz de su código fuente y además habilitaremos Apache para que se puedan consultar nuestros repositorios desde la Web.

Primeramente nos convertiremos en el usuario root.

javoaxian@darthmaul:~$ su -

Instalaremos los paquetes: zlib1g, zlib1g-dev, openssl, libssl-dev, libxml2, libxml2-dev, libexpat1 y libexpat1-dev.

root@darthmaul:~# apt-get install zlib1g zlib1g-dev openssl libssl-dev libxml2 libxml2-dev libexpat1 libexpat1-dev

Ahora deberemos tener instalado nuestro servidor Apache desde su código fuente. Aquí dejo este artículo de cómo instalarlo, nada más deberemos agregar las siguientes opciones en el comando ./configure para que la línea del comando quede de la siguiente manera:

./configure --prefix=/usr/local/apache --enable-so --enable-mods-shared="most ssl dav"

Ya que contamos con nuestro servidor web instalado, vamos a crearle un certificado de prueba. Supondré que siguieron el artículo que mencioné anteriormente (con la modificación del comando ./configure) e instalaron apache en /usr/local/apache.

root@darthmaul:~# cd /usr/local/apache/conf/
root@darthmaul:~# mkdir ssl.crt
root@darthmaul:~# mkdir ssl.key

Ahora generaremos el certificado:

root@darthmaul:~# openssl req -new -x509 -days 365 -keyout ./ssl.key/server.key -out ./ssl.crt/server.crt -subj '/CN=Certificado JavoAxian'

Este comando nos solicitará el PEM pass Phrase y su confirmación. Este nos será solicitado cada vez que iniciemos nuestro servidor web, pero para efectos de este artículo, lo eliminaremos.

Generating a 1024 bit RSA private key
....................++++++
.......................++++++
writing new private key to './ssl.key/server.key'
Enter PEM pass phrase:
Verifying - Enter PEM pass phrase:
-----

Ya que ingresamos los datos anteriores, eliminaremos el PEM pass phrase que ingresamos de la siguiente manera:

root@darthmaul:~# cp ssl.key/server.key ssl.key/server.key.org
root@darthmaul:~# openssl rsa -in ssl.key/server.key.org -out ssl.key/server.key

Nos pedirá la PEM pass phrase que ingresamos:

Enter pass phrase for ssl.key/server.key.org:
writing RSA key

Ahora le cambiaremos los permisos al archivo server.key:

root@darthmaul:~# chmod 400 ssl.key/server.key

Con esto ya tenemos nuestro certificado. Ahora nos encargaremos de instalar subversion, para esto, lo descargaremos de su página. La versión vigente en el momento de hacer este post es la 1.4.6, por lo que bajaremos los siguientes archivos: subversion-1.4.6.tar.bz2 y subversion-deps-1.4.6.tar.bz2.

La instalación de subversion la haré en el directorio /usr/local.
Copiaremos los archivos de subversion que descargamos al directorio /usr/local/src.

root@darthmaul:~# cp /ruta/de/descarga/subversion-1.4.6.tar.bz2 /usr/local/src/
root@darthmaul:~# cp /ruta/de/descarga/subversion-deps-1.4.6.tar.bz2 /usr/local/src/

Hecho lo anterior, nos moveremos al directorio /usr/local/src y descomprimiremos los 2 archivos.

root@darthmaul:~# cd /usr/local/src/
root@darthmaul:~# tar -jxvf subversion-1.4.6.tar.bz2
root@darthmaul:~# tar -jxvf subversion-deps-1.4.6.tar.bz2

Esto creará un directorio llamado subversion-1.4.6 al cual ingresaremos.

root@darthmaul:~# cd subversion-1.4.6

Ahora ya tenemos todo listo para compilar el paquete de subversion, el cual lo vamos a instalar en el directorio /usr/local/subversion. Vamos a suponer, que si siguieron las instrucciones para instalar apache de este post. Apache deberá estar instalado en /usr/local/apache y abremos creado el usuario apache y el grupo apache.

root@darthmaul:~# ./configure --prefix=/usr/local/subversion --with-apxs=/usr/local/apache/bin/apxs --with-apr=/usr/local/apache --with-apr-util=/usr/local/apache --with-ssl

El comando configure nos mandará un WARNING el cual dice lo siguiente:

You don't seem to have Berkeley DB version 4.0.14 or newer
installed and linked to APR-UTIL. We have created Makefiles which
will build without the Berkeley DB back-end; your repositories will
use FSFS as the default back-end. You can find the latest version of
Berkeley DB here:
http://www.sleepycat.com/download/index.shtml

Éste nos dice que no tenemos instalada la base de datos de Berkeley, pero no la vamos a instalar, en su lugar vamos a usar la base de datos fsfs.
Continuaremos con la instalación ejecutando los siguientes comandos:

root@darthmaul:~# make
root@darthmaul:~# make install

Si desean, pueden agregar las siguientes líneas en el archivo /etc/profile para que los comandos de subversion funcionen sin tener que especificar su ruta completa.

export SVN=/usr/local/subversion
export PATH=$PATH:$SVN/bin

Para que funcione este cambio, deberán reiniciar su ambiente gráfico o su máquina.

Con esto tenemos instalado subversion. Ahora configuraremos un repositorio para que se pueda acceder por medio de nuestro servidor web.

Crearemos el repositorio especificando el tipo de base de datos fsfs en el directorio /usr/local/repositorio y le daremos permisos de escritura al usuario apache para que pueda escribir sobre el repositorio:

root@darthmaul:~# mkdir /usr/local/repositorio
root@darthmaul:~# /usr/local/subversion/bin/svnadmin create --fs-type=fsfs /usr/local/repositorio/
root@darthmaul:~# chown -R apache.apache /usr/local/repositorio/

Creado el repositorio, procederemos a crear una cuenta (javoaxian) para acceder a éste. Esto se hace usando el comando htpasswd que se encuentra en el directorio bin donde fue instalado apache y crearemos el archivo que guarda los passwords y lo pondremos en el directorio /usr/local/apache/svn.

root@darthmaul:~# mkdir /usr/local/apache/svn
root@darthmaul:~# /usr/local/apache/bin/htpasswd -cm /usr/local/apache/svn/svn_auth.txt javoaxian

La opción "c" indica que deberá crear el archivo de las contraseña, cabe destacar que si van a agregar otro usuario omitan esta opción ya que borrará el archivo ya existente.
La opción "m" indica que deberá generar las contraseña con el algoritmo MD5.
Se nos pedirá el password del usuario y que lo volvamos a ingresar:

New password:
Re-type new password:
Adding password for user javoaxian

Por seguiridad cambiaremos el dueño al directorio /usr/local/apache/svn y le cambiaremos los permisos:

root@darthmaul:~# chown -R apache.apache /usr/local/apache/svn/
root@darthmaul:~# chmod 700 /usr/local/apache/svn/

Ahora agregaremos las instrucciones necesarias en apache para tener acceso al repositorio, para ello, deberemos editar el archivo httpd.conf que se encuentra en el directorio conf donde se instaló apache, que en este caso está en /usr/local/apache/conf/httpd.conf.
Primero buscaremos la línea siguiente del archivo:

Listen 80

Y agregaremos la línea Listen 443 debajo de la que encontramos para que quede de la siguiente forma:

Listen 80
Listen 443

Ahora colocaremos las siguiente líneas al final del archivo:

NameVirtualHost *:443

<VirtualHost *:443>
SSLEngine on
SSLCertificateFile /usr/local/apache/conf/ssl.crt/server.crt
SSLCertificateKeyFile /usr/local/apache/conf/ssl.key/server.key

<Location /repositorio>
DAV svn
SVNPath /usr/local/repositorio
AuthType Basic
AuthName "Repositorio de Subversion"
AuthUserFile /usr/local/apache/svn/svn_auth.txt
Require valid-user
SSLRequireSSL
</Location>
</VirtualHost>

Como podemos observar, estamos creando un Host virtual para el puerto 443.
SSLCertificateFile: Ruta donde colocamos el archivo server.crt cuando creamos el certificado.
SSLCertificateKeyFile: Ruta donde colocamos el archivo server.key cuando creamos el certificado.
Location: Alias que usaremos para dirigirnos al repositorio, en este caso sería https://localhost/repositorio.
SVNPath: Ruta del repositorio.
AuthUserFile: Ruta del archivo de contraseñas que creamos.

Ahora deberemos reiniciar nuestro servidor de apache.

root@darthmaul:~# /usr/local/apache/bin/apachectl stop
root@darthmaul:~# /usr/local/apache/bin/apachectl start

Podemos entrar con nuestro navegador a la dirección https://localhost/repositorio/, nos aparecerá una pantalla para aceptar el certificado y una vez que aceptemos, nos mostrará una pantalla donde se nos pide el user name y password del usuario que creamos con el comando htpasswd, y una vez introducidos estos datos, nos mostrará el contenido del repositorio.

Ahora si queremos permitir el acceso a más de un usuario al repositorio, deberemos crear nuestros nuevos usuarios de la siguiente manera:

root@darthmaul:~# /usr/local/apache/bin/htpasswd -m /usr/local/apache/svn/svn_auth.txt javoaxian2

Crearemos otro archivo que se encargará de llevar el control de acceso a los usuario. Se les puede dar permisos de lectura o lectura-escritura, además que pueden acomodarse en grupos.

Este es un ejemplo del nuevo archivo:

[groups]
javoaxianteam = javoaxian, javoaxian2
pruebas = prueba1, prueba2

[/]
@javoaxianteam = rw
@pruebas = r
javoaxian3 = r

[/trunk]
javoaxian4 = r

Este archivo nos indica que tenemos dos grupos: javoaxianteam con los usuario javoaxian y javoaxian2 y el grupo pruebas con los usuarios prueba1 y prueba2.
También nos indica que el grupo javoaxianteam tiene permisos de lectura-escritura sobre el directorio "/" del repositorio, el grupo pruebas y el usuario javoaxian3 sólo tienen permisos de lectura para el repositorio.
Por último, el usuario javoaxian4 tiene permisos de lectura dentro del directorio /trunk del repositorio.

Este nuevo archivo lo crearé en /usr/local/apache/svn/svn_control_acceso.txt.

Una vez que se tiene el archivo con la configuración que deseamos, deberemos configurar nuevamente apache.
Deberemos editar el archivo /usr/local/apache/conf/httpd.conf y poner la línea:

AuthzSVNAccessFile /usr/local/apache/svn/svn_control_acceso.txt

Debajo de la línea:

Require valid-user

Por lo que nos quedaría de la siguiente manera esta sección de la configuración de apache.


DAV svn
SVNPath /usr/local/repositorio
AuthType Basic
AuthName "Repositorio de Subversion"
AuthUserFile /usr/local/apache/svn/svn_auth.txt
Require valid-user
AuthzSVNAccessFile /usr/local/apache/svn/svn_control_acceso.txt
SSLRequireSSL

Y nuevamente deberemos reiniciar nuestro apache.

root@darthmaul:~# /usr/local/apache/bin/apachectl stop
root@darthmaul:~# /usr/local/apache/bin/apachectl start

Pueden acceder al repositorio mediante su navegador a la dirección https://localhost/repositorio/ e ingresar los datos de acceso de su usuario.
Espero que esto les pueda ser de utilidad.
Saludos.

miércoles, 18 de junio de 2008

SELECT INTO en MySQL

En algunas ocasiones necesitamos guardar el resultado de una consulta en otra tabla dentro de la base de datos, para ello en algunos manejadores de base de datos contamos con el comando SELECT INTO ..., pero éste no existe en MySQL, en su lugar deberemos usar el comando INSERT INTO ... SELECT.

La manera para usar este comando es muy sencilla. Vamos a suponer que contamos con las tablas pais y usuario:

CREATE TABLE pais (
id INTEGER UNSIGNED NOT NULL,
nombre VARCHAR(100) NOT NULL,
PRIMARY KEY(id)
)
TYPE=InnoDB;

CREATE TABLE usuario (
id BIGINT NOT NULL,
pais_id INTEGER UNSIGNED NOT NULL,
nombre VARCHAR(150) NOT NULL,
PRIMARY KEY(id, pais_id),
INDEX usuario_FKIndex1(pais_id),
FOREIGN KEY(pais_id)
REFERENCES pais(id)
ON DELETE NO ACTION
ON UPDATE NO ACTION
)
TYPE=InnoDB;

Ahora deseamos guardar en otra tabla únicamente el nombre de los usuarios y el nombre del país al que pertenece. Para esto crearemos una tabla llamada usuario_pais en la que vamos a depositar estos datos:

CREATE TABLE usuario_pais (
usuario_nombre VARCHAR(150) NOT NULL,
pais_nombre VARCHAR(100) NOT NULL,
PRIMARY KEY(usuario_nombre)
)
TYPE=InnoDB;

Una vez que ya se tienen las 3 tablas, deberemos ejecutar el comando INSERT INTO ... SELECT para guardar los nombres de los usuarios y sus países en la tercer tabla que creamos. Esto se hace de la siguiente manera:

mysql> INSERT INTO usuario_pais (usuario_nombre,pais_nombre)
SELECT usuario.nombre, pais.nombre FROM
usuario
INNER JOIN pais ON usuario.pais_id=pais.id;

Esto habrá guardado los registros que encontró en la tabla usuario_pais, y en mi caso el contenido de mi tabla queda de esta manera:

mysql> select * from usuario_pais;
+----------------+-------------+
| usuario_nombre | pais_nombre |
+----------------+-------------+
| Beatriz Guzmán | Portugal |
| Juan Pérez | México |
+----------------+-------------+

Listo, con esto ya pueden mandar el resultado de una consulta a otra tabla.

lunes, 16 de junio de 2008

Tablatura y Partitura de la canción Transfusión de La Castañeda

Para todos aquellos que desean tocar la buenisima canción de Transfusión de La Castañeda, les dejo este archivo hecho en Tux Guitar y con extensión para que pueda ser abierto con el programa Guitar pro y así, que puedan aprenderse y tocar esta canción.

El archivo puede ser descargado desde aquí.

sábado, 14 de junio de 2008

Cómo conectar: Eclipse + Subclipse + Subversion repositorio sobre Apache

Hace ya algunos tiempo escribí este artículo que explica cómo podemos conectar Eclipse con el plugin Subclipse a un repositorio de Subversion por medio de SSH.

Hoy a petición del buen joven JCTOL, voy a explicar cómo podemos conectar Eclipse con el plugin Subclipse a un repositorio de Subversion que se encuentra sobre Apache (http o https).

Para iniciar supondré que ya cuentan con Eclipse (ver este artículo) y Subclipse (ver este artículo) instalados y configurados, además que cuentan con un repositorio de Subversion configurado con Apache. Para este fin, usaré un repositorio que podré consultarlo desde la dirección: http://localhost/repositorio, ustedes deberán usar el URL de su repositorio.

Ahora abriremos la perspectiva de SVN de Subclipse seleccionando las siguientes opciones del menú de eclipse: Window -> Open Perspective -> Other...


Se presentará la pantalla Open Perspective, donde seleccionaremos SVN Repository Exploring.


Se mostrará la perspectiva de SVN.


Presionaremos la opción Add SVN Repository.


Se abrirá la pantalla Add SVN Repository. Aquí deberemos ingresar en la sección Url el Url de nuestro repositorio, que para este ejemplo es: http://localhost/repositorio y presionaremos "Finish".


En caso que el repositorio no necesite autenticación, se omitirá este paso, en caso contrario, nos aparecerá la pantalla Enter Username and Password donde deberemos ingresar el nombre de usuario y la contraseña de nuestro usuario del repositorio.


Se agregará en la sección SVN Repository el repositorio que acabamos de configurar.

Supondré que este repositorio cuenta con los directorios branches, tags y trunk y dentro de este último tenemos el directorio javoaxian. Teniendo esta estructura, haré una copia en eclipse de la carpeta javoaxian. Para llevar esto acabo, presionaremos sobre la flecha que se encuentra del lado izquierdo de nuestro repositorio, lo cual nos mostrará los directorio branches, tags y trunk y presionaremos en la flecha del lado izquierdo de trunk para que nos aparezca el directorio javoaxian. Ahora con el botón derecho de nuestro ratón, presionaremos sobre el directorio javoaxian, y se mostrará un menú donde presionaremos sobre la opción Checkout...


Para este artículo, me basaré en que el proyecto ya cuenta con archivos y con el archivo .project el cual le indica a eclipse qué tipo de proyecto es (si cuentas con un proyecto desde cero, puedes continuar con lo que indico en esta sección de este artículo). Por tal motivo, ahora que se nos presenta la pantalla Checkout from SVN, aparecerá la opción Check out as a project in the workspace marcada y en el campo Project Name nos mostrará el nombre de nuestro proyecto, al cual le puse javoaxianPHP. Bastará con presionar "Finish" para que se haga la copia de nuestro proyecto en eclipse.


Para finalizar, el proyecto que puse en el ejemplo, es un proyecto de PHP, por lo que abriré la perspectiva de PHP para empezar a trabajar con él. Si desean configurar el plugin de PHP de Eclipse, pueden ver este artículo. Si su proyecto es de otro tipo, como por ejemplo, Java, C, Perl, etc., deberán abrir la perspectiva correspondiente al lenguaje en que está su aplicación.

jueves, 12 de junio de 2008

Generar respaldo de una base de datos en Sybase

Ya que últimamente me he dedicado a escribir más artículos relacionados con operaciones sobre bases de datos. En esta ocasión explicaré como crear un respaldo de una base de datos en Sybase.

La forma de hacer este respaldo es muy sencilla, bastará con ingresar a la base de datos con el dueño de la base de datos y ejecutar el siguiente comando:

javoaxian@darthmaul:~$ isql -Uusuario -Sservidor -Dbasededatos
1> dump database nombre_base to "/ruta/archivo/respaldo/archivo.dump"
2> go

Como podemos observar, deberemos especificar el nombre de la base de datos y la ruta del archivo con extensión .dump que contendrá el respaldo de nuestra base de datos.

Algo IMPORTANTE de mencionar, es que el archivo.dump es creado con la cuenta de usuario sybase del sistema operativo, por lo que deberemos otorgarle permisos de escritura para que este usuario (sybase) escriba sobre el directorio donde queremos guardar nuestro respaldo. Otra opción es que manden el respaldo al directorio /tmp y copiar el respaldo a uno de nuestros directorios. Lo malo de esto, es que debermos solicitar al administrador del equipo que borre el respaldo por cuestiones de seguridad.

Aquí pongo un ejemplo de un respaldo de mi base de datos en sybase:

javoaxian@darthmaul:~$ isql -Ujavoaxian -Sdarthmaul -Djavoaxian
1> dump database javoaxian to "/home/javoaxian/respaldos_sybase/respaldo_2008-06-12.dump"
2> go

martes, 10 de junio de 2008

Acceder a un elemento de un iframe desde la página padre con JavaScript

Continuando con el uso de JavaScript, aquí explico cómo podemos, a través de este lenguaje, hacer referencia a un elemento dentro de un iframe desde la página donde está definido el iframe.

Para comenzar, definiremos un iframe:

<iframe name="iframeXCambiar" src="iframe.html" height="50px"></iframe>

Como se observa en la definición del iframe, deberemos colocar un nombre al iframe, que en este caso es iframeXCambiar, así como el nombre del archivo al que haremos referencia en el iframe, y que aquí lo hemos llamado iframe.html. Recuerda que si lo pones de esta manera, estamos indicando que el archivo que contiene al iframe y el archivo al que hace referencia el iframe (iframe.html) deben estár colocados en el mismo directorio, sino es este el caso, puedes poner el URL del archivo para referirte al él.

Ahora crearemos el contenido del archivo iframe.html. Para este ejemplo, será un archivo muy sencillo:

<html>
<body>
<div id="divIframe" style="border: 1px solid #000000;">
Div dentro del iframe
</div>
</body>
</html><

Lo importante de esta parte, es la definición del div, ya que le colocamos un id llamado divIframe el cual nos permitirá acceder a su contenido y poderlo cambiar.

Ahora declararemos una función de javascript entre las etiquetas <head> y </head>. En esta función pondremos la instrucción que se encargará de modificar el valor del div llamado divIframe definido en el iframe.

<script>
function cambiarIframe()
{
frames.iframeXCambiar.document.getElementById('divIframe').innerHTML = "Nuevo texto del iframe";
}
</script>

En la declaración de la instrucción dentro de la función cambiarIframe, se puede ver que usamos el elemento frames y posteriormente usamos el nombre que le pusimos al iframe para poder manipular su div.

Ahora crearemos un botón que se encargue de llamar a la función de javascript para modificar el contenido del div dentro del iframe.

<input type="button" value="Cambiar" onClick="cambiarIframe();">

Hecho lo anterior, podremos ver nuestra página y presionar sobre el botón Cambiar para que ejecute la función y cambie el contenido del div.

Para observar como funciona este ejemplo, visiten esta página y presionen sobre el botón cambiar. Podrán ver como cambia el texto dentro del recuadro negro.

domingo, 8 de junio de 2008

Implementar trigger en PostgreSQL usando PL/pgSQL

En esta ocasión, voy a explicar como podemos crear un Trigger en PostgreSQL usando PL/pgSQL.

Lo primero que se debe de hacer, es crear una función la cual se encargará de manejar los procedimientos de PL. Esto deberá hacerse con la cuenta de usuario postgres en la base de datos donde vamos a crear el trigger. Por tal motivo abriremos una sesión de postgres con el usuario postgres en nuestra base de datos, la cual para fines de este ejemplo usaré el nombre de javoaxian.

javoaxian@darthmaul:~$ psql -U postgres -d javoaxian

Ya que estamos en el prompt de postgres, crearemos la función plpgsql_call_handler y le debemos de indicar donde debe encontrar el archivo plpgsql.so, el cual se encuentra situado en el directorio lib donde fue instalado postgresql, que en mi caso esta en /opt/pgsql/lib.

javoaxian=# CREATE FUNCTION plpgsql_call_handler() RETURNS language_handler AS '/opt/pgsql/lib/plpgsql.so' LANGUAGE C;

Ahora dejaremos de ser el usuario postgres y nos convertiremos en el dueño de la base de datos, que en mi caso será javoaxian.

javoaxian=# \c javoaxian javoaxian

Esto nos pedirá el password del usuario javoaxian y una vez que ingresemos éste, nos indicará que estamos conectados a la base de datos con el usuario que indicamos.

Password for user javoaxian:
You are now connected to database "javoaxian" as user "javoaxian".
javoaxian=>

Ahora que ya ingresamos con nuestro usuario, podemos crear el lenguaje plpgsql en nuestra base de datos y le indicamos la función plpgsql_call_handler que creamos con el usuario postgres.

javoaxian=> CREATE LANGUAGE 'plpgsql' HANDLER plpgsql_call_handler LANCOMPILER 'PL/pgSQL';

Lo anterior nos mostrará algo similar a esto:

NOTICE: using pg_pltemplate information instead of CREATE LANGUAGE parameters
CREATE LANGUAGE

Creado el lenguaje, procederemos a crear el procedimiento almacenado que llamará el trigger que crearemos. Este procedimiento se encargará de verificar que no se inserten más de 100 registros en una tabla llamada usuario, por tal motivo, deberemos tener creada una tabla llamada usuario y para fines de este post puede estar estructurada de la siguiente manera:

javoaxian=> CREATE TABLE usuario(
id INTEGER NOT NULL PRIMARY KEY,
nombre VARCHAR(80) NOT NULL);

Ahora crearemos el procedimiento:

javoaxian=> CREATE FUNCTION sp_max_100_registros() RETURNS trigger AS $trigger_max_100_registros$
DECLARE
registro RECORD;
BEGIN
SELECT INTO registro COUNT(*) AS numRegistros
FROM usuario;

IF registro.numRegistros < 100 THEN
RETURN NEW;
ELSE
RAISE EXCEPTION 'No pueden existir más de 100 registros en la tabla usuario';
RETURN NULL;
END IF;
END;
$trigger_max_100_registros$ LANGUAGE plpgsql;

Como se puede observar en el procedimiento, se le deberá poner un nombre, que en este caso es sp_max_100_registros(), seguido de esto le indicamos que vamos a devolver un tipo de dato trigger y que tendrá el nombre de trigger_max_100_registros entre signos de "$".
Posteriormente, declaramos una variable llamada registro en la sección de variables DECLARE y le indicamos que es de tipo RECORD ya que en esta variable se almacenará el resultado de nuestra consulta.
Seguido de esta sección, colocamos la sección BEGIN, la cual nos permitirá poner el comportamiente de nuestro procedimiento hasta encontrar una instrucción END que lo finalize.
Entre las instrucciones BEGIN y END ejecutaremos una sentencia SELECT que cuenta el número de registros en la tabla usuario. Dicha sentencia cuenta con la opción INTO, ya que es la que permite asignar el resultado a nuestra variable registro.
Luego encontraremos un IF con su respectivos THEN, ELSE y END IF, donde preguntamos por medio de la variable registro si obtuvo menos de 100 registros, si la condición es afirmativa, entonces devuelve una variable llamada NEW, la cual indica que puede ser insertado el registro en la tabla usuario, pero en caso contrario, entonces nos devuelve una excepción indicando que no pueden existir más de 100 registros en la tabla usuario.
Por último indicamos el nombre del trigger entre signos de "$" que en el ejemplo es: trigger_max_100_registros y el lenguaje del procedimiento, que en este caso es plpgsql.

Ya que contamos con el procedimiento almacenado, crearemos nuestro trigger, y para hacer esto, deberemos hacer lo siguiente:

javoaxian=> CREATE TRIGGER trigger_max_100_registros
BEFORE INSERT ON usuario
FOR EACH ROW EXECUTE PROCEDURE sp_max_100_registros();

La declaración del anterior nos indica que vamos a crear un TRIGGER llamado trigger_max_100_registros, el cual se deberá lanzar antes de realizar un INSERT sobre la tabla usuario para cada registro (FOR EACH ROW), y le indicamos que deberá ejecutar el procedimiento almacenado que creamos, el cual es: sp_max_100_registros().

Ahora ya tenemos creado nuestro trigger y cada vez insertemos un registro, verificará si puede insertar dicho registro.

Para borrar nuestro trigger, lo primero que hay que hacer, será ejecutar la siguiente línea:

javoaxian=> DROP TRIGGER trigger_max_100_registros ON usuario;

En la instrucción anterior indicamos el nombre del trigger que queremos borrar y sobre que tabla está referenciada.

Una vez que borramos el trigger, también deberemos borrar su procedimiento almacenado, y esto lo haremos de esta forma:

javoaxian=> DROP FUNCTION sp_max_100_registros();

Se puede observar, que en el comando anterior deberémos indicar el nombre del procedimiento y que este debe llevar los paréntesis que abren y cierra.

Ahora bien, pondré otro trigger, el cual se encarga de verificar que después de insertar en nuestra tabla usuario un registro cuyo nombre cuente con la palabra luis, ya no permita meter más registros.

El procedimiento sería de esta manera:

CREATE FUNCTION sp_sin_luis() RETURNS trigger AS $trigger_sin_luis$
BEGIN
PERFORM * FROM usuario WHERE UPPER(nombre) LIKE UPPER('%luis%');

IF NOT FOUND THEN
RAISE NOTICE 'Se insertará el registro';
RETURN NEW;
ELSE
RAISE EXCEPTION 'No se insertará el registro';
RETURN NULL;
END IF;
END;
$trigger_sin_luis$ LANGUAGE plpgsql;

Y el trigger:

CREATE TRIGGER trigger_sin_luis
BEFORE INSERT OR UPDATE ON usuario
FOR EACH ROW EXECUTE PROCEDURE sp_sin_luis();

Entre las cosas diferentes del procedimiento de este nuevo trigger, es que no definimos la sección DECLARE, aparte en lugar de poner la sentencia SELECT ponemos la palabra PERFORM. La diferencia radica en que PERFORM se usa para cuando hacemos consultas en las cuales no vamos a usar el resultado de ésta.
También otra diferencia es en la instrucción IF, ya que usamos la palabra NOT FOUND, la cual sirve para preguntar si no se encontraron registro en la consulta hecha.
La última diferencia del procedimiento está dentro del IF, podemos observar que antes de devolver el nuevo registro (RETURN NEW), usamos la instrucción: RAISE NOTICE, y ésta nos permite mandar un mensaje a la salida estandar de notificación.

La diferencia en la creación del trigger, es que también indicamos que se ejecute cuando se hagan UPDATE's.

Por último, pondré un ejemplo, el cual se encarga de verificar que no se pueda insertar un registro en la tabla usuario que contenga la cadena luis.

Procedimiento:

CREATE FUNCTION sp_no_luis() RETURNS trigger AS $trigger_no_luis$
BEGIN
IF UPPER(NEW.nombre) LIKE '%LUIS%' THEN
RAISE EXCEPTION 'El registro contiene el nombre de luis';
RETURN NULL;
ELSE
RAISE NOTICE 'Se agregará el registro';
RETURN NEW;
END IF;
END;
$trigger_no_luis$ LANGUAGE plpgsql;

Trigger:

CREATE TRIGGER trigger_no_luis
BEFORE INSERT OR UPDATE ON usuario
FOR EACH ROW EXECUTE PROCEDURE sp_no_luis();

La diferencia en este último, es que usamos la instrucción NEW para hacer la comparación. Esta instrucción contiene el nuevo registro y por consiguiente los datos de los campos ha insertar, los cuales podemos hacer referencia por medio del nombre del campo como se puede observar. Algo IMPORTANTE de mencionar, es que para poder usar la instrucción NEW u otra llamada OLD, es que cuando creemos el trigger, deberemos poner la instrucción FOR EACH ROW, ya que sin esta no se crearán estos elementos.

Si deseean ver un poco más de las opciones con que cuenta un trigger, puede ver este archivo, el cual encontré en esta página.

viernes, 6 de junio de 2008

Crear el respaldo de una base de datos en MySQL

La forma de generar un respaldo en MySQL es muy fácil de hacer, lo único que necesitaremos es usar el comando mysqldump.

Aquí muestro un ejemplo de como hago el respaldo de mi base de datos javoaxian con el dueño de la base de datos javoaxian y lo mando al archivo respaldo_javoaxian_2008-06-06.sql.

javoaxian@darthmaul:~$ mysqldump -u javoaxian -p javoaxian > respaldo_javoaxian_2008-06-06.sql

Con esto generará el archivo respaldo_javoaxian_2008-06-06.sql.

Ahora bien, si manejan tablas de tipo innoDB quiza deseen bloquear la base de datos para que el respaldo cuente con una consistencia de los datos. Para hacer esto, deberemos ejecutar el comando de la siguiente manera:

javoaxian@darthmaul:~$ mysqldump -u javoaxian -p --single-transaction javoaxian > respaldo_javoaxian_2008-06-06.sql

Si quisieran respaldar algunas tablas de la base de datos, podrían hacer esto:

javoaxian@darthmaul:~$ mysqldump -u javoaxian -p javoaxian tabla1 tabla2 > respaldo_javoaxian_2008-06-06.sql

Ojala que esto les sirva para generar sus respaldos.

miércoles, 4 de junio de 2008

Cambiar el contenido de un div usando JavaScript

Para muchos que usan Javascript, el cambiar el contenido de un div es muy sencillo, pero opte por mostrar como se puede hacer ésto para las personas que apenas se están iniciando con Javascript.

Para demostrar como podemos hacer la modificación del contenido de un div al vuelo con javascript, usaré un botón para llamar a una función que se encargará de cambiar el contenido.

Definiremos el div que vamos a usar de la siguiente manera:

<div id="divXCambiar" style="width: 100%;border:1px solid #000000;">HOLA</div>

En la definición anterior del div, es importante el atributo id, ya que con él, es con el que podremos alterar el contenido del div.

La función que se va a encargar de cambiar el contenido será la siguiente (recuerda que deberá ponerse ya sea en un archivo .js o definirla de preferencia entre las etiquetas <head> y </head>):

<head>
function cambiar()
{
document.getElementById('divXCambiar').innerHTML = "ADIOS";
}
</head>

Como podemos ver, la función únicamente cuenta con una línea, en la que por medio del id divXCambiar le asignaremos el valor ADIOS, haciendo referencia a través de la propiedad innerHTML.

Ahora colocaremos el botón que hara el cambio del texto HOLA por el texto ADIOS.

<input type="button" value="Cambiar" onClick="cambiar();">

Aquí podemos observar que asignamos la función cambiar() que anteriormente definimos, al evento onClick del botón.

Esto es todo lo que tenemos que hacer, para ver como funciona este ejemplo, presiona sobre el botón cambiar y podremos ver el cambio del texto que se encuentra dentro del div.

HOLA