Ya usted, ellos, ellas y yo lo sé: hay infinidad de tutoriales en internet sobre HTML: sería «llover sobre mojado» volver a tratar el tema, pero ¿quién dijo miedo? 😉
En mi caso, el que me ocupa, es actualizarme al HTML 5 y enfrentar a dos viejos «demonios» en esto de la creación de páginas web. Y no, no me refiero a los servicios en GNU/Linux a los cuales llamamos «D.A.E.MON» si no a los dos grandes problemas que debemos enfrentar antes de comenzar a escribir una sola línea de código en HTML:
La multitud de navegadores web existentes y el legado que traemos a rastras, ya que muchas personas se niegan a actualizar sus programas. Agreguemos a eso las particularidades de los nuevos celulares con Android y ni mencionemos los celulares con WAP (y por ende WML) que aún están en uso con sus micronavegadores.
Los gustos de nosotros los seres humanos en cuanto a diseño, colores y funcionalidad de las páginas web (en otra entrada presentaré las hojas de estilo en cascada con las cuales enfrentaremos este aspecto).
Y para no abrumarlos ni abrumarlas más comienzo de una vez el tema.
No , el título de esta entrada no se me ocurrió a mi persona, ojalá yo supiera tanto. El título surge de un escrito del Mayor General del Cuerpo de Infantería de Marina de los Estados Unidos Smedley Darlington Butler quien se dio cuenta de ello en 1935 y sigue tan vigente hoy en día, recomiendo su lectura, descarguen en este enlace.
Siempre me ha llamado la atención los CAPTCHA («Completely Automated Public Turing test to tell Computers and Humans Apart«) que hay en muchas páginas web y que permiten diferenciar consultas hechas por humanos de las hechas por «arañas» que pululan por internet (son también conocidas como «robots»). La diferencia esencial en este caso con respecto a la prueba de Turing es que se trata de convencer a una máquina que es un humano, osea el inverso de la prueba.
En el idioma inglés existe la filosofía K.I.S.S. y la practico frecuentemente ya que los sistemas complejos tienden al caos de manera natural. Es por ello que buscando por internet (precisamente ayudado por las «arañas» que pretendo combatir, ¡qué ironía!) he encontrado el siguiente artículo que me deslumbró por su simplicidad más al cabo de una hora de estudio observo los elementos implícitos sin los cuales NO funciona. Recomiendo vayan y lean dicho artículo y regresen cuando lo hayan asimilado, yo por aquí les espero. 😎
El artículo data del año 2007 pero considero que no ha perdido vigencia alguna, si administran una página web bancaria o son partidarios del último grito de la moda, recomiendo desistan de seguir leyendo esto. 😉
Pues bien manos a la obra.
Requisitos previos.
Utilizo una máquina virtual con Debian Wheezy con la cual estudio el programa para base de datos PostgreSQL a la cual le he instalado también un servidor Apache con PHP: este tipo de configuración es llamado LAMP por sus siglas en inglés, sólo que en aquí en realidad es un LAPP: Linux, Apache, PostgreSQL y PHP. Hay muchísimos tutoriales para instalar este tipo de servidores por ello partimos de la base que ustedes cuentan con uno en funcionamiento y para pruebas (no utilicen un servidor «en producción» hasta tanto no estén completamente seguros de este código). Importante recalcar que no utilizaremos funciones de bases de datos en esta entrada, pero muy frecuentemente las CAPTCHA se utilizan en este tipo de ambiente, por ejemplo, registrar usuarios en una lista de correo electrónico (tremenda tentación para los «robots spam»), así que allí encaja perfectamente.
Configuración adicional.
Al servidor LAPP anteriormente descrito debemos instalarle unas librerías para el trabajo gráfico bajo el lenguaje PHP. Aquí está muy bien descrito a lo que me refiero, haciendo la salvedad que dichas librerías NO SIEMPRE están instaladas por defecto.
En todo caso debemos crear una carpeta bajo la raíz web del servidor Apache con el nombre «captcha» y donde alojaremos el siguiente archivo «info.php»:
<?php
// Archivo "info.php":
// Muestra toda la información, por defecto INFO_ALL
phpinfo();
?>
y luego iremos a nuestro navegador web preferido a la dirección IP que le hayamos asignado en nuestra red de área local. En mi caso dicha dirección es 192.168.1.27 en la carpeta «captcha»:
En dicha página debemos buscar si están instalados los siguientes valores:
Dado el caso que no se encuentren instaladas dichas librerías debemos recurrir a la línea de comandos y escribir lo siguiente:
sudo apt-get install php5-gd
y verán algo más o menos parecido a esto (en mi caso no necesité el comando «sudo» porque ya había ganado acceso como root con el comando «su»):
Dichas librerías son necesarias para el trabajo con imágenes jpg, png y gif, entre otros formatos y funciones.
Imagen de fondo para el CAPTCHA:
Necesitaremos un imagen tipo gif con unas dimensiones de 100×30 píxeles con colores adecuados teniendo en cuenta que las letras serán negras buscaremos colores como azul o verde o el que gusten pero no de color negro. Yo elegí la siguiente imagen (aunque al final agregaremos varios elementos para dificutarles la tarea de lectura a los «robots» con técnicas OCR ): Como ven es una imagen con degradado que busca confundir al OCR pero con legibilidad al ser humano; no obstante usar este mismo fondo siempre y con la ayuda de la «fuerza bruta» se puede descifrar al poco tiempo -pero de eso nos encargaremos luego, de «complicarlo» para tratar de eludir la lectura-. La imagen la guardaremos en la carpeta de trabajo en el servidor web bajo el nombre «bgcaptcha.gif» (nemotécnico ‘BackGroundCaptcha.gif’=’bgcaptcha.gif’).
Dicho archivo se encargará de tomar la imagen anterior y, aleatoriamente, «escribirle» letras encimas, almacenarlas en una variable (que leeremos con luego con el método POST) y mostrarla al navegador; para ello utilizaremos el siguiente código que explicaremos línea por línea:
Para que el servidor sepa dónde comienza y dónde termina el lenguaje PHP debemos encerrarlo todo con los siguientes comandos: «<?php (…) ?>» y donde van los paréntesis y puntos suspensivos ubicaremos nuestro código a ejecutar. Todo lo que esté fuera de estos demarcadores será considerado lenguaje HTML e interpretado como tal.
Cada final de sentencia le será indicado al servidor con un punto y coma «;».
Los comentarios, que son importantísimos para nosotros los seres humanos, para las máquinas carecen de importancia y se identifican con «//» y la derecha el texto explicativo.
La función «session_start()» permite crear o recuperar un identificador único que servirá para que el servidor pueda atender varios clientes al mismo tiempo sin confundir las respuestas de cada usuario. No debemos preocuparnos mucho ya que todo es automatizado, si acaso dedicaremos una sentencia «if-then-else» por si acaso devuelve el valor «falso», es decir, no se pudo iniciar sesión (todo el mundo da por sentado que devuelve «verdadero»). Importante, muy importante, el comprender sobre el cómo PHP compara dos variables y/o valores para devolver «verdadero» o «falso», merece su estudio de 10 minutos.
La función «$_SESSION[]» permite asignar un valor a una variable en la sesión iniciada en el punto anterior y es un variable de arreglo global. El texto, que será aleatorio, lo proporcionará la función «randomText()» que escribiremos luego.
La función «imagecreatefromgif()» nos permitirá «cargar en memoria» la imagen que destinamos como fondo del CAPTCHA y devolverá un «identificador de imagen» representado en una variable que usaremos para agregar el texto que identificará e introducirá el usuario, ser humano. De nuevo digo que deberíamos destinar un «if-then-else» dado el caso la función devuelva «falso».
El comando anterior nos permitió establecer el «lienzo» donde vamos a escribir las letras aleatorias; pues el comando «imagecolorallocate()» nos permite fijar el color con que las «pintaremos»: «0, 0, 0» corresponde al color negro en la codificación de valores «RGB», «Red Green Blue» y cuyos valores van del 0 al 255 cada uno y nos permite usar +16 millones de colores. Luego echaremos mano de esta función para confundir aún más a los «robots», por ahora nos conformaremos con el color negro. Es de hacer notar que para esta función CERO es «falso» y cualquier otro valor es «verdadero», si usted considera esto una tontería le invito a leer la disertación sobre el tema, está avisado o avisada.
La funcíon «imagestring()» dibuja una cadena de texto en nuestro «lienzo», la imagen gif seleccionada. Los parámetros de esta función son: (image, font, x, y, text, color) y los detallo a continuación:
image: la que cargamos en memoria con la función imagecreatefromgif() y que llamamos $captcha.
font: numeradas del 1 al 5 y es la fuente nativa predeterminada en la librería GD e incluso nos permite cargar nuestras propias fuentes pero debemos cargarlas y compilarlas de acuerdo a la arquitectura de nuestro servidor. Si se entusiasman a realizar esto último deberán cargar dicha fuente «compilada» con la función imageloadfont() de acuerdo a unos valores binarios. Más interesante hallo utilizar la función imagettftext() NO SIN ANTES VERIFICAR el phpinfo() devuelva que el ambiente del servidor lo soporte (si quieren saber más sobre fuentes True Type en GD visiten este enlace):
Coordenadas X e Y: tomadas a partir de la esquina superior izquierda, pónganse de cabeza para que las entiendan (ahhh me recuerdo de la materia Geometría Analítica, ¡qué belleza para Autocad! ¡Y dibujábamos por comandos escritos en papel fuera del laboratorio de computación!).
text: en este caso lo que ya tenemos almacenado en la variable global de sesión «$_SESSION[‘tmptxt’]».
color: el que establecimos a negro con la función «imagecolorallocate()».
La función «header()» permite que nuestro servidor se ciña a las normas del lenguaje HTML que consiste en «notificarle» al navegador web (en formato NO html) que le será enviado un flujo de datos, por defecto «application/octet-stream», pero que nosotros utilizaremos para indicarle que es una imagen gif «Content-type: image/gif». Si desean conocer más acerca del nacimiento de la web y sus normas de funcionamiento de la mano del mismísimo Tim Berners-Lee hagan click en este enlace.
Por último la función «imagegif()» instruye a nuestro servidor que le envie la imagen al navegador del usuario, el CAPTCHA que queremos interprete el ser humano.
Una función que considero importante y que yo agrego al código mostrado originalmente -y del que desconozco la autoría- es «imagedestroy()» a fin de liberar la memoria utilizada por la variable «$captcha». Aunque toda la memoria se libera cuando el usuario cierra su navegador o cuando nosotros mismos invocamos «session_destroy()» nunca está demás liberar «trabajo» apenas sea posible.
Creación de la función «randomText()».
Ahora explicaré la función que devuelve una cadena de texto de manera aleatoria pero con dos mejoras al código fuente original, el cual es el siguiente:
Las funciones en PHP se declaran con la palabra clave reservada «function» y los argumentos se pasan entre paréntesis separados por comas.
Todo el cuerpo de la función esta demarcado por inicio y fin de corchetes «{ … }».
La función toma como parámetro la variable «$lenght» la cual toma el valor de «7» al hacer el llamado de la siguiente manera: «randomText(7)». Por ende nuestro CAPTCHA tendrá 7 caracteres, recuerden que estamos limitados al espacio del «bgcaptcha.gif».
En la primera variable «$pattern» establecemos los caracteres que queremos mostrar al usuario, no repetidos, y aquí va la primera mejora que les dije antes: NO incluyo el número uno («1»), ni la letra ele («l») ni tampoco el número cero («0») ni la letra o («O») porque se trata de ponersela difícil al «robot», no al ser humano, quien puede confundir dichos signos.
Utilizamos un ciclo «for» similar al usado en lenguaje C, es decir, un valor de inicio, una condición que se evalúa en cada ciclo y un incremento en cada ciclo. Así establecemos que al escribir «for ( $i=0; $i<$length; $i++ ) {…}» estamos ordenando ejecutar un ciclo basado en la variable «$i» que comienza desde cero y que mientras sea menor que la longitud de caracteres de nuestro CAPTCHA se incremente en una unidad para cada ciclo, «$i++».
Dentro de los corchetes del ciclo «for» anterior colocamos la variable «$key» que se autoconcatena en cada rizo «.=» con una letra aleatoria del patrón elegido y que llevamos asignado en la variable $pattern.
En el lenguaje PHP (e igualmente en Python) cada cadena de caracteres es considerada de manera implícita una matriz de una sola fila, esto nos permite «imprimir» en el navegador del usuario una letra del patrón, por ejemplo «echo $pattern{10}» devolverá «b».
¿Cómo escogemos una letra cualquiera del patrón? Aquí es donde viene la segunda mejora que les comenté: en vez de usar la función «rand()» utilizamos la función «mt_rand()» la cual, aparte de ser más rápida nos permite utilizar números más grandes (de ser necesario). Dicha mejora la propone un usuario llamado «caos30» en los comentarios de la entrada del blog en la cual se inspira este tema. Esta función tiene dos argumentos que nos permiten acotar el número devuelto: para este caso es (0, 32) que es precisamente el largo del patrón que escogimos (el abecedario inglés 26 caracteres más los diez dígitos numéricos son 36 menos 4 que eliminé para evitar confusiones a los humanos).
Es necesario el comando «return» acompañado de la variable que debe devolver la función, en nuestro caso es un tipo «cadena de texto».
Guardado del archivo «captcha.php».
Ya suficientemente explicado línea por línea el código unimos ambos algoritmos y con el editor de texto nano (o el que ustedes prefieran) guardamos en la carpeta «captcha» que hicimos en «\var\www» (donde generalmente Apache guarda el sitio web):
Antes de continuar nos aseguramos que la CAPTCHA se ejecute y muestre correctamente en nuestro navegador conectado a nuestro servidor LAPP de pruebas:
Cada vez que pulsamos CTRL+F5 nos mostrará una CAPTCHA diferente cada vez y asigna a la variable «$_SESSION[‘tmptxt’]» el valor deberá comparar con el valor introducido por el usuario humano. El siguiente paso es hacer la interfaz para la presentación e introducción de los datos.
Formulario web «captchademo.php».
El uso básico de sesiones bajo PHP está explicado en detalle en este enlace. No obstante buscando la simplicidad para la comprensión de todos ustedes, amables y pacientes lectores, haremos un archivo php para mostrar la CAPTCHA e introducir la respuesta del usuario y otro archivo php donde compararemos la respuesta; a este archivo lo llamaremos «captchaanswer.php» y esta explicado más adelante.
Sin más pretensiones de seguridad ni estética escribiremos el siguiente código:
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>CAPTCHA con PHP</title>
<meta name="description" content="CAPTCHA con PHP: ejemplo para demostrar la creacion de Captcha con PHP." />
</head>
<body>
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td align="center">
<strong>CAPTCHA con PHP </strong><br>
Ingresar el texto mostrado en la imagen: <br>
<form action="captchaanswer.php" method="post">
<img src="captcha.php" width="100" height="30" vspace="3"><br>
<input name="tmptxt" type="text" size="30"><br>
<input name="btget" type="submit" class="boton" value="Enviar">
<input name="action" type="hidden" value="checkdata">
</form>
</td>
</tr>
</table>
</body>
</html>
Al navegar nuestro servidor de prueba podrán ver algo parecido a esto:
Todo el código anterior es puro lenguaje HTML y mencionaré brevemente línea por línea y su cierre correspondiente (nota: los términos que usaré para describir lo que sucede probablemente hiera la sensibilidad académica de algún lector, no obstante recuerdenme y escríbanme si estoy equivocado) :
Etiquetas «<html>…</html>»: le indica a nuestro servidor dónde comienza y dónde termina el lenguaje HTML, veremos en una entrada futura que esto es esencialmente útil en nuestros «scripts php».
Etiquetas «<head>…</head>»: contiene información prioritaria que nuestro servidor tendrá que darle tratamiento especial, leer próximo punto.
Etiquetas «<meta (…) />»: estas etiquetas contienen datos que describen datos y están categorizados. La categoría «Content-Type» la describimos anteriormente pero en esta ocasión la usaremos para decirle al navegador del cliente que la vamos a enviar lenguaje HTML y que lo interprete como tal. Envuelve mayor complejidad una solicitud HTTP pues incluye códigos numéricos de respuesta y aceptación pero con saber que esta información es una de las primeras que se envían es más que suficiente.
También en los metadatos podemos incluir la codificación de caracteres utilizados en la página web (algún día cuando usemos todo en 128 bits esto caerá en desuso) por medio del comando «UTF-8».
Hay ciertas palabras claves reservadas en los metadatos y es lenguaje de alto nivel, el que usamos usted y yo, seres humanos. Uno de ellos es la palabra name=»description» que nos permite especificar a manera general el propósito principal de la página.
En este punto es útil preguntarnos ¿para qué es todo esto del encabezado? Para ello debemos recordar que hace 20 años el ancho de banda en internet era «oro en polvo» y el protocolo se diseñó para no cargar la página completa de un solo golpe sino que echaramos «un ojo» antes de descargar completo. Hoy en día se ha vuelto obsoleto (yo escucho una radio por internet, mientras corro una máquina virtual que actualiza su software desde varios repositorios y otra máquina virtual «baja» parches de seguridad mientras escribo estas líneas ‘en línea’ y además de tanto en tanto superviso servidores de datos remotos; el tráfico de datos es asombroso) pero aún sigue siendo útil para las «arañas» o buscadores como https://duckduckgo.com/ a fin de categorizar las páginas web visitadas y de las cuales hasta guardan una copia espejo, datos, datos y más datos; discos duros a reventar (alguien dijo alguna vez «lo que se sube a internet allí se queda», yo lo creo fehacientemente 😯 ).
Con las etiquetas «<title>…</title>», valga la redundancia, titulamos nuestra página (el «caption» de la ventana) y algunos navegadores agregan su propio nombre como pueden ver el ejemplo mostrado.
Dentro de las etiquetas «<body>…</body>» insertaremos la página web en sí, sólo que en este caso es un formulario para mostrar e introducir los datos.
Con «<table><tr><td>…</td></tr></table>» dibujaremos una tabla de un solo cuadro ayudados por el concepto de anidación de etiquetas ¿recuerdan el método de la «doble C» para dividir fracciones? Pues bueno es algo parecido a eso.
Con «<strong>…</strong>» podremos poner en negritas lo escrito entre las etiquetas.
Con «<br>» le decimos al navegador que termina una línea y comience una nueva.
He aquí lo más importante: «<form>…</form>». Allí declaramos y establecemos los elementos del formulario en sí.
Con form <form action=»captchaanswer.php» method=»POST»> indicamos que las variables siguientes sean pasadas a otro «script php» con el método «POST» para que el usuario no visualize las variables(a diferencia del método «GET»).
He aquí la «magia»: al pasar la orden de visualizar la imagen CAPTCHA realmente le indicamos es que ejecute el «script»: <img src=»captcha.php» width=»100″ height=»30″ vspace=»3″> y que lo muestre como tal (con ayuda de «header()»).
Los demás elementos son para dibujar el cuadro de texto y el botón enviar, creo no merecen mayor explicación.
Las normas estéticas las agregaremos en una próxima entrada pero de manera normalizada, como el tema es largo y quiero escribirlo desde hace tiempo le dedicaré una entrada aparte.
Actualizado el lunes 22 de febrero de 2016.
Para prevenir que los servidores proxy instalados en redes de área local NO guarden en caché la imagen de nuestro CAPTCHA podemos hacer uso de generar diferentes nombres al «archivo» de imagen misma con, por ejemplo, la función uniquid de la siguiente manera:
Como ustedes pueden ver loq ue yo llamo «formularios web» o «páginas web» en este servidor LAPP son en realidad unos «scripts» en lenguaje PHP. El que nos ocupa ahora es el que se invoca cuando el usuario pulsa el botón «Enviar»:
De nuevo lo analizamos línea por línea obviando, por supuesto, las funciones y comandos que de nuevo encontremos y hayamos explicado antes:
Es necesario llamar a la función «session_start()», recordemos dicha función también nos permite recuperar los datos de la sesión almacenados en la variable global.
La próxima acción es verificar que la variable ‘action’ esté establecida a ‘checkdata’ de no ser así pues simplemente finaliza y sale sin aviso alguno.
El punto decisivo es la comparación de la cadena aleatoria creada por el script «captcha.php» y compararla con la enviada por el usuario. De ser iguales emite el mensaje «BIENVENIDO» y aquí es donde podemos ubicar el código que nos interesa: la publicación de un comentario a una entrada de blog, la confirmación a una lista de correos, etc.
Conclusiones.
Esto es sólo un abreboca de lo que podemos realizar con PHP en cuanto a gráficos se refiere, estoy consciente que para las normas actuales es un CAPTCHA bastante débil pero lo podemos mejorar hasta llevarlo a un nivel básico. Para mi caso particular lo voy a implementar de una vez en un «servidor de producción» y que trabaje de una vez.
Recién me acabo de percatar que el Ubuntu que uso (14.04 LTS) NO está mostrando el reloj y la fecha, como siempre veo es mi móvil pues, ea, que había desaparecido de mi vista y yo tan tranquilo.
Investigando en este enlace (en inglés) recomiendan abrir una ventana terminal (que en Ubuntu es CTRL+ALT+T) y transcribir lo siguiente:
sudo killall unity-panel-service
colocan su respectiva contraseña ¡y listo!
En el enlace mencionado culpan a ciertas aplicaciones, en mi caso lo que hice fue una «gran» actualización y creo allí fue cuando desapareció de mi Escritorio.
Si desean personalizar aún más hagan click en el botón de apagado y del submenú seleccionan «Configuración del sistema» y al abrir la ventana selecciona «Fecha y Hora» para luego hacer click en la pestaña «Reloj» y cualquier cambio que hagan tomará efecto inmediatamente, prueben y vean.
Dado el caso que «Simple clock» por alguna razón no esté instalado, pues lo reisntalamos con:
para luego reniciarlo (el unity-panel-service ) con el comando que explicamos al principio.
<Eso es todo, por ahora>.
La resolución de monitor que «ha muerto» hoy.
Actualizado el día sábado 04 de febrero de 2017.
Un año y diez meses después de haber comenzado esta entrada -lo cual es muestra de la «estabilidad» de Ubuntu- volvimos a tener problemas con el reloj y la bandeja del sistema. Por supuesto que aplicamos nuestra consabida fórmula aquí explicada pero lamentablemente no funcionó.
Una cosa que notamos al ejecutar el comando arriba descrito, una y otra vez, fue el «parpadeo» de las ventanas abiertas, que se redimensionaban para ocupar la pantalla completa. Como tenemos un solo monitor, un venerable Samsung de 17 pulgadas en diagonal, lo tenemos trabajando en su resolución nativa de 1024 por 768 píxeles. La resolución nativa indica el mejor tamaño sin perder legibilidad (y nosotros ahora por la edad que estamos más cegatones que nunca). Es por ello que no pocas veces, para ciertas tareas, cambiar la resolución al máximo 1280 por 1024 (esto es especialmente útil para cuando nos conectamos de manera remota a varios clientes con Remmina) y he aquí que apareció de nuevo la barra del reloj.
Monitores en Ubuntu ejemplo con Samsung 17 pulgadas.
Tal vez muchos se sorprenderán con lo que vamos a decir: los monitores de 17 pulgadas «han muerto», eso es parte de la vida, lo único constante es el cambio y lo hemos visto pasar con el transcurso de las décadas. Desde Windows 3.11 con 640 por 480 píxeles, a Windows 98 con 800 por 600, a Windows XP con 1024 por 768 y hoy en día con Ubuntu 16 a 1280 por 1024 píxeles (de hecho en las oficinas utilizamos monitores de 22 pulgadas y los celulares a pesar de tener el mismo tamaño la resolución ha aumentado siendo muy distintivo el caso de «Retina Display®», norma indicada por el genial Steve Jobs, fundador de la empresa Apple).
Esta situación se presenta tiempo después que descargamos «grandes» actualizaciones de nuestro sistema operativo libre favorito y que manifestamos públicamente por medio de nuestra cuenta Twitter:
Por ahora nuestra solución será basada en hardware y no en software ya que consideramos que los programadores de Ubuntu tienen razón: 1024 por 768 se nos ha quedado corto en este año 2017. Es por ello que trabajaremos muy duro para ganar dinero y comprar un monitor de 22 pulgadas que lo conectaremos como principal a la tarjeta de video Nvidia y el viejo monitor lo colocaremos en la tarjeta gráfica integrada Radeon de la tarjeta madre.
Lo único constante es el cambio (y el único cambio que le gusta al ser humano es el cambio de pañal).
Evolución de los monitores a lo largo del tiempo.
Actualizado el miércoles 1° de marzo de 2017.
Para complementar lo del punto anterior, el siguiente vídeo ilustra muy bien, por medio de la evolución de los videojuegos, la terminología y evolución de los monitores y sus resoluciones (aparte de tocar con menos importancia el tema del sonido -y muchísimo menos importante el tema de la memoria RAM-). Disfrutad, pues, el documental en idioma inglés con «The 8-Bites Guy»:
Registro de Información Fiscal ( RIF ): su historia en Venezuela.
Sobre el RIF me contaba una fallecida Contadora Pública (que en paz descanse+) con la cual tuve la feliz oportunidad de trabajar, que en los años 70 cuando ella estudiaba en la Universidad de Carabobo ya en clases calculaban el dígito verificador (que viene a ser similar a los códigos de barra), sólo que en aquella época las computadoras NO estaban al alcance del pueblo (ni siquiera las calculadoras electrónicas -oh cómo recuerdo mi querida Casio A1, ¡si A1! funcionaba con una sola pila doble A de pantalla verde-) y ellos/ellas lo hacían manualmente. En fin, que yo conocía lo del RIF desde los años 80 pero desconocía lo del cálculo del dígito verificador hasta que ella me lo dijo:
SIR RIF 07
Al principio de este siglo me dí a la tarea de buscar dicha fórmula y conseguí el siguiente algoritmo escrito en javascript, desconozco su autoría pero es el que he venido utilizando esta última década (más adelante explicaré cómo funciona):
function VerifRIF(RIF)
{
//
// Función JavaScript VerifRIF Versión 1, 18/Marzo/2002
// Recibe el Numero de RIF sin separadores y devuelve
// True si el RIF es correcto
//
var SumRIF;
var NumRif;
NumRif = RIF
var cadena = new Array();
if (NumRif.length == 10)
{
for (i = 0; i < 10; i++)
{
cadena[i] = NumRif.substr(i,1);
}
cadena[0] = 0;
if ((NumRif.substr(0,1) == "V")||(NumRif.substr(0,1) == "v")) cadena[0] = 1
if ((NumRif.substr(0,1) == "E")||(NumRif.substr(0,1) =="e")) cadena[0] = 2
if ((NumRif.substr(0,1) == "J")||(NumRif.substr(0,1) == "j")) cadena[0] = 3
if ((NumRif.substr(0,1) == "P")||(NumRif.substr(0,1) == "p")) cadena[0] = 4
if ((NumRif.substr(0,1) == "G")||(NumRif.substr(0,1) == "g")) cadena[0] = 5
cadena[0] = cadena[0] * 4
cadena[1] = cadena[1] * 3
cadena[2] = cadena[2] * 2
cadena[3] = cadena[3] * 7
cadena[4] = cadena[4] * 6
cadena[5] = cadena[5] * 5
cadena[6] = cadena[6] * 4
cadena[7] = cadena[7] * 3
cadena[8] = cadena[8] * 2
SumRIF = cadena[0] + cadena[1] + cadena[2] + cadena[3] +
cadena[4] + cadena[5] + cadena[6] + cadena[7] + cadena[8];
EntRIF = parseInt(SumRIF/11);
Residuo = SumRIF - (EntRIF * 11)
DigiVal = 11 - Residuo;
if (DigiVal > 9)
DigiVal = 0;
if (DigiVal == cadena[9])
return true;
else
return false;
}
else return false;
}
Es así ahora que recuerdo, con ayuda de mi envejecido y primer comprobante de RIF que fue el Decreto N° 193 del 2 de julio de 1979 (la cual pueden descargar desde la Procuraduría General de la República Bolivariana o desde nuestro sitio web -gracias a «pdfsam» son tres hojas de la Gaceta ) y bajo la Presidencia de Luis Herrera Campíns cuando se estableció de manera obligatoria dicho registro y era muy amplios los datos que debía contener:
n) Cualquier otra información que requiera la Administración del Impuesto Sobre la Renta.
¡hasta exigían apartado postal! (que para la época fungía como suerte de correo electrónico). Interesante es el artículo 10 el cual ya establecía exhibir el RIF y dejar constancia en las facturas que emitieran ¡no fue sino hasta 1994 que el Presidente Rafael Caldera mandó a crear al SENIAT y muchos años después que emitieron normas de facturación e incluyeron ese punto!
Al final del decreto se aclara que quedan derogados los decretos: N° 2.920 del 24 de octubre de 1978 (creación original del RIF) y el decreto N° 3.102 del 23 de febrero de 1979 (prorrogación de entrada en vigencia del mismo). La diferencia fundamental entre ambos decretos (N° 2.920 y N° 193 -diferentes presidentes de la República, Carlos Andrés Pérez y Luis Herrera Campíns-) estriba en que originalmente sólo se les exigía inscribirse a quienes o cuales hubieran obtenido enriquecimiento neto anual -a partir de 1977- mayor a Bs. 24 mil o «ingresoss» (sic) brutos mayor a Bs. 72 mil anual. En el Decreto de Luis Herrera se obliga a todo el mundo a inscribirse y dado el caso la persona o entidad manifestare que no está obligada a hacerlo (artículo 11, parágrafo único), le dieran igual curso a los trámites que a bien tuvieran que hacer ante el Gobierno pero debía ser reportado en paralelo al Ministerio de Hacienda. En ambos decretos (artículo 7) se establecen los famosos «operativos de RIF» que se ejecutan desde la Presidencia de Hugo Rafael Chávez Frías e indican que se extenderá un comprobante provisional y luego de 3 meses emitirán el comprobante definitivo (imagino que debido a la tecnología de la época: yo, por ejemplo, hacía mis trabajos del liceo en una viejísima máquina de escribir que mi tío desechó de una de sus oficinas la cual yo reparé y ajustaba constantemente). Al día de hoy uno mismo llena los datos por primera vez por internet (basado en el número de cédula en las personas naturales y el tomo y registro en las personas jurídicas) para luego ir en persona a la sede más cercana del SENIAT donde le emiten de una vez el RIF ELECTRÓNICO (en este blog explican de manera más detallada el proceso) luego las renovaciónes se hacen vía web sin necesidad de acudir a las oficinas del SENIAT. Dicho proceso ha logrado reducir en 60% las colas en esa institución .
El RIF DIGITAL tal como lo conocemos hoy en día fue creado en la Gaceta Oficial N° 40.214 del jueves 25 de julio de 2013 y entre otras novedades establece 3 códigos de seguridad para evitar su falsificación así como un servicio en línea por internet para comprobar su veracidad con ayuda de un código QR para ahorrar tiempo evitando escribir la dirección en la computadora o teléfono celular.
Es de hacer notar que en este último decreto se exceptúan de la obligatoriedad de inscripción a los menores de edad (siempre y cuando no posean bienes ni realicen actividades económicas) así como exhibir, reflejar y colocar en productos, publicidad, páginas web (internet), libros contables, facturas, etc. También anuncia la extinción definitiva de la forma «SIR RIF 07» con la cual yo obtuve mi primer comprobante de RIF en 1998.
Los puntos más resaltante del RIF DIGITAL es que se denomina ahora «REGISTRO ÚNICO DE INFORMACIÓN FISCAL» (artículo 4 providencia N° SNAT/2013/0048) y especifica que es «…único, exclusivo y excluyente…» y en el artículo 7 se establece la condición «activo o inactivo» (lo cual pienso yo es reflejo del uso de bases de datos por ordenadores) bajo ciertas condiciones (muerte de persona natural, por ejemplo).
Volviendo al artículo 4 podemos observar la necesidad de identificar con correspondencia unívoca las personas naturales o jurídicas a un código alfanumérico.
He aquí entonces que volvemos a la fórmula del «número de chequeo» (así lo llamaba el SENIAT en 1998) y procedo a explicar el código arriba mostrado:
Declaración de variables y una matriz para luego almacenar cada letra y dígito, lo que se le pasa a la función en la variable «RIF» se almacena en otra variable llamada «NumRif»:
var SumRIF;
var NumRif;
NumRif = RIF
var cadena = new Array();
Importante: el RIF a verificar debe tener exactamente 10 caracteres, si no la función devuelve FALSO:
if (NumRif.length == 10)
Cada uno de los caracteres se almacena en la matriz declarada al principo, importante asignar cero a «cadena[0]» ya que si el primer caracter NO es ninguno de los ya normalizados el cálculo mediante fórmula no coincidará con el dígito verificador:
for (i = 0; i < 10; i++)
{
cadena[i] = NumRif.substr(i,1);
}
cadena[0] = 0;
El primer caracter del RIF debe ser alguno de los siguientes:
«V»: Venezolano o venezolana.
«E»: extranjero o extranjera (número de cédula mayor a 80 millones).
«P»: Pasaporte, por ejemplo es útil para los cantantes que se presentan en nuestro país y que hay que retenerles Impuesto sobre la renta.
«J»: Persona jurídica, osea, compañías anónimas, sociedades anónimas, S.R.L., etc.
«G»: Gobierno, entes gubernamentales, de cualquier Poder, estado, municipio e incluso organismos «autónomos» (ejemplo Universidad de Carabobo RIF G-20000041-4).
A futuro es importante considerar lo siguiente:
ACTUALIZACIÓN AL 25 DE MARZO DE 2015: el Presidente de la República Nicolás Maduro Moros ordenó al SENIAT identificar a las Comunas y Consejos Comunales (imagino yo que será extensivo a las Cooperativas, pienso yo PERO el Presidente no las nombró, esto es idea mía) con la letra «C» las cuales antes se venían registrando con la letra «J».
Dependiendo del primer caracter se le asigna el valor a «cadena[0]» según lo siguiente:
if ((NumRif.substr(0,1) == "V")||(NumRif.substr(0,1) == "v")) cadena[0] = 1
if ((NumRif.substr(0,1) == "E")||(NumRif.substr(0,1) =="e")) cadena[0] = 2
if ((NumRif.substr(0,1) == "J")||(NumRif.substr(0,1) == "j")) cadena[0] = 3
if ((NumRif.substr(0,1) == "P")||(NumRif.substr(0,1) == "p")) cadena[0] = 4
if ((NumRif.substr(0,1) == "G")||(NumRif.substr(0,1) == "g")) cadena[0] = 5
IMAGINO YO que los RIF que comienze por la letra «C» se les asignará el siguiente valor disponible, el seis (ES UNA SUPOSICIÓN MÍA, SE DEBE ESPERAR EL PRONUNCIAMIENTO OFICIAL DEL SENIAT):
if ((NumRif.substr(0,1) == "C")||(NumRif.substr(0,1) == "c")) cadena[0] = 6
Luego ese valor asignado a «cadena[0]» se multiplica por 4, los demás caracteres que deben ser números se multiplican por los siguientes valores correspondientes (importante acotar que esta función le falta discriminar si en realidad son números lo que introduce el usuario en la variable «RIF» de lo contrario asigna cero y el cálculo no dará correctamente):
Lo siguiente es calcular el residuo resultante de dividir «SumRIF» entre 11 y para ello se utiliza la función de javascript «parseINT()» que devuelve la parte entera y al multiplicarla por 11 y restar de «SumRIF» devuelve dicho valor.
RECORDAR los miembros que componen una división inexacta (en nuestro ejemplo el divisor es una constante, 11, número primo):
Por último vamos a calcular la diferencia entre el residuo y la constante 11 teniendo en cuenta que si el residuo es 0 u 1 el dígito de verificación valdrá cero :
DigiVal = 11 - Residuo;
if (DigiVal > 9)
DigiVal = 0;
Y listo ya sólo queda comparar si coincide nuestro cálculo con el valor que introdujo el usuario a la función:
if (DigiVal == cadena[9])
return true;
else
return false;
Hagamos un cálculo de ejemplo, para ello tomaremos a la Corporación Socialista del Cemento S.A cuyo RIF es el siguiente: G-20009048-0, comenzemos por eliminar los guiones: G200090480.
«G» toma el valor de 5 multiplicado por 4 =20
2 multplicado por 3 = 6
0 multplicado por 2 = 0
0 multplicado por 7 = 0
0 multplicado por 6 = 0
9 multplicado por 5 = 45
0 multplicado por 4 = 0
4 multplicado por 3 = 12
8 multplicado por 2 = 16
Sumamos:20+6+0+0+0+45+0+12+16=99
Dividimos por 11 y tomamos el residuo que en este caso es cero: 99÷11=9
Dicho residuo lo restamos de once: 11-0=11 y como es mayor que 9 (tiene dos cifras) ENTONCES el dígito de verificación es cero lo cual corresponde con el RIF suministrado: «G-20009048-0»
Es de acotar que en términos de presentación al usuario mi representación favorita es la siguiente:
Dicha forma de interfaz al usuario NO PERMITE introducir letra diferentes a las normalizadas (a futuro incluiré la letra «C» en dicho objeto de programación) y sólo permite números en el resto del RIF haciendo el cálculo del dígito de verificación y es el usuario quien lo debe comparar con el que suministra el cliente a quien se le desea facturar, así se garantiza la correcta escritura del nombre o razón social.
En este último punto debemos tocar el tema de la consulta masiva de RIF cuyo servicio es ofrecido por el SENIAT por medio de su página web, esta consulta (aparte de devolver el nombre o razón social, eso nos ahorra el trabajo de escribir) también devuelve el porcentaje de IVA a retener (75% ó 100% actualmente), en el caso de que la farmacia donde trabajemos sea Agente de Retención; como dicho tema es un poco largo de explicar («Contribuyentes Especiales») he decidido dejarlo para una entrada posterior.
Actualizado el sábado 15 de agosto de 2015:
El día de hoy se tramitó el primer RIF con la letra «C», dicha noticia la recojo vía Twitter, he aquí que incluyo los mensajes:
También el SENIAT en su página web hace el anuncio oficial, más sin embargo aún no veo una Providencia como tal sobre dicho documento de información fiscal.
Son 3 hojitas en formato pdf (agradezco a “pdfsam” y lo recomiendo para dividir y combinar documentos en ese formato); con este aumento las facturas de compra con monto inferior a 20 U.T. (Bs. 3.000,00) podrán ser ingresadas en «caja chica» sin hacerle retención de IVA (Contribuyentes Especiales); también aumentan automáticamente el Bono Alimentación para los Trabajadores y Trabajadoras, el costo de emisión de los pasaportes, multas y un sinfín de cosas más.
Gaceta 0ficial 40.608 sumario.
Para descargar dicho ejemplar electrónico de la Gaceta Oficial desde nuestra página web haga click aquí.
Si desea descargarla desde el Tribunal Supremo de Justicia deberá luego introducir el número “40608” en el cuadro de búsqueda rápida.
Y seguimos aprovechando el receso de Carnaval para continuar nuestro estudio del poderoso motor de base de datos relacional PostgreSQL 9.1.
Nuestra miniserie comienza acá y en la última entrada tocamos el tema de las consultas con uniones las cuales utilizaremos aquí también pero con ayuda del programa psql y tal como lo prometimos vamos a trabajar en profundidad por línea de comandos.
Como recordarán ya habíamos utilizado anteriormente a psql para garantizarle al usuario adminsql acceso íntegro a todas las bases de datos en el servidor PostgreSQL que instalamos.
Breve pausa para hablar sobre seguridad básica.
Normalmente lo que hicimos en el párrafo anterior sólamente se hace si hay un solo usuario y una sola base de datos, un sistema pequeño, tal como era a finales del siglo pasado. Pero ahora con computadoras con procesadores multinúcleo (e incluso hasta computadoras con multiprocesador ) un servidor PostgreSQL puede, tranquilamente, atender muchos usuarios a la vez. Imaginemos que en nuestra Academia de Software Libre de ejemplo cada alumno debe acceder a este recurso único pero debemos de cuidar que cada quien trabaje en su propia base de datos y no toque las ajenas, ya sea por error o a propósito (que se ven casos así). Pues bien PostgreSQL soporta usuarios y grupos internamente, tal como si fuera una computadora con un sistema operativo moderno.
Un usuario pudiera ser cada alumno en clase con su base de datos propia para desarrollar su trabajo y aprobar el curso.
Un grupo, por ejemplo, pudiera ser un sección o curso en determinada aula de clase con derechos de sólo lectura sobre una base de datos perteneciente al instructor de clases y además independiente de otros instructores en otras seccionesde clase; eso nos facilita el trabajo al crear usuarios pues se le asigna al grupo y «hereda» la configuración.
Trabajando con psql.
Lo comentado en la sección anterior lo veremos ahora de forma práctica y de la manera más sencilla posible. En la máquina Debian que corre nuestro PostgresSQL seleccionamos «Aplicaciones->Accesorios->Terminal»:
Abrimos así una ventana terminal donde procederemos a ingresar el comando psql pero en esta oportunidad lo haremos acompañado de opciones adicionales:
«–username=nombre_de_usuario» permite colocar a continuación el nombre del usuario que se va a conectar; la forma abreviada es «-Unombre_de_usuario» con un espacio entre ambos (y tened en cuenta las mayúsculas y minúsculas, tal cual se escriben).
«–password» para que nos pregunte la contraseña («–no-password» será útil en trabajos de procesos por lotes); la forma abreviada es «-W» (notad que las formas largas son con doble guión y las cortas con un solo guión).
«–dbname=nombre_de_la_base_de_datos» nos conecta de una vez a donde vamos a trabajar; la forma abreviada es «-d nombre_de_la_base_de_datos» con un espacio entre ambos.
Por ahora ésas son las opciones que utilizaremos por la terminal interactiva pero en realidad psql tiene gran cantidad de agregados los cuales en otras entradas le daremos uso, pero no a todos. Si queréis echar un ojo a la lista completa, pincha aquí.
Una vez hayamos presionado intro y haber tecleado nuestra consabida contraseña al cabo de otro intro nos aparece el siguiente mensaje de error:
psql: FATAL: Peer authentication failed for user «adminsql»
Y no, no es porque hayamos ingresado mal la contraseña, que es harta sencilla sino por el asunto de seguridad que describí hace poco. Para que podamos conectarnos debemos crear un usuario llamado adminsql con su correspondiente contraseña en el sistema operativo Debian (o GNU/Linux que usemos). Esto no sería deseable, ya que los usuarios tendrían acceso al sistema operativo en sí, amén que también si son muchos usuarios recarga inncesariamente el sistema de archivos (que aunque tengamos poderosas computadoras siempre la frugalidad es bienvenida), y no, no necesitamos ése esquema de trabajo.
Es por ello que contamos con la opción peer por defecto, apoyada por el sistema operativo y contamos con la opción md5 que encripta la contraseña para mayor seguridad, así que sólo registraremos usuarios dentro de PostgreSQL. Para ello ganaremos acceso como superusuario y luego usaremos el programa editor de texto nano para editar la configuración. Por favor observen la imagen para que tengan el panorama completo:
nano /etc/postgresql/9.1/main/pg_hba.conf
y buscaremos la sección «is for Unix domain sockets connections only» donde cambiaremos «peer» por «md5» tal como aparece en la siguiente figura:
lo siguiente será (recuerden, estamos usando nano) CTRL+X -> «y» -> intro osea guardar y salir en el editor de textos que hayan utilizado ustedes. Una vez hecho esto, necesitamos que el servidor tome la nueva configuración, en realidad el servicio o demonio debemos reiniciarlo, no la máquina en si:
service postgresql restart
y si hicimos bien nuestro trabajo veremos más o menos lo siguiente:
De nuevo introducimos el comando descrito para conectarnos a la base de datos pero esta vez si que tenemos éxito en nuestra tarea:
Y allí estamos, a la espera de la primera consulta, usaremos entonces la última de la entrada anterior:
SELECT students.name, phone_numbers.number
FROM students
INNER JOIN phone_numbers
ON students.id=phone_numbers.idstudent
WHERE LOWER(students.email) ~ ‘hotmail.com’;
¿Recuerdan la utilidad del punto y coma para indicar el final de la consulta? Acá nos viene como anillo al dedo pues estas terminales son un tanto incómodas al estar generalmente limitadas a 80 columnas, así que presionamos intro y notad que el prompt cambia de «=#» a «-=» para indicarnos que estamos en una sola sentencia a pesar que son varias lineas:
¡Y listo! hemos hecho nuestra primera consulta por terminal interactiva, ya sólo queda salir de psql y luego de nuestra terminal para ello bastará con teclear:
/quit
exit
En la próxima entrada seguiremos trabajando por línea de comandos para la creación de tablas e insertado de datos en las mismas y ampliaremos el estudio de consultas por uniones JOIN.
Esta vez realizaremos unas consultas por uniones no sin antes dar una breve explicación de la integridad referencial, una característica de las bases de datos relacionales, siempre de la manera más sencilla posible.
Para los que el orden es importante esta serie de artículos sobre PostgreSQL 9.1comienzan acá y la manera de conectarnos al servidor vía phpPgAdmin se describe aquí.
Pues bien, comenzemos ya: tenemos creadas dos tablas llamadas students y phone_numbers y como bien lo describe sus nombres en inglés, sirven para almacenar datos de estudiantes y sus números telefónicos. Como cada persona puede tener varios teléfonos (casa, trabajo, móvil, fax, etc.) y a su vez cada una de esas ubicaciones hoy en día pueden tener varios números diferentes (en mi caso tengo 2 en casa, 3 en el trabajo y uno celular) no tiene sentido crear campos para cada uno de ellos en la tabla students porque no sabemos cuántos va a tener cada inviduo. Cualquiera me puede rebatir diciendo que aunque sea debería suministrar un número de teléfono para alguna emergencia en clase (desde el punto de vista de este ejercicio donde somos una Academia de Software Libre) pero ni con eso contaría yo, es decir, puede darse el caso que no tenga ningún teléfono (hermosa es la película «Enemy of the State» ojalá la disfruten tanto como yo la disfruté en 1999). Es por tanto que en la tabla students no dejamos ningún campo para almacenar el o los que nos suministren y los guardaremos en la tabla phone_numbers teniendo cuidado de guardar de quién es cada cual.
Observemos que al seleccionar la tabla phone_numbers desde phpPgAdmin haciendo click en «constraints» («restricciones») descubriremos el trabajo que hizoVisual Paradigm traduciendo nuestro organigrama a la base de datos:
Como en la entrada anterior agregamos algunos datos de los estudiantes tenemos dicha tabla de ejemplos de la siguiente manera:
De nuevo hacemos click en la tabla phone_numbers e insertamos un registro tal como lo hicimos en la entrada anterior, sólo que en este caso y cuando lleguemos al campo idstudent automáticamente aparecerá una lista de los estudiantes que ya tenemos registrados, en este caso identificados del 1 al 4:
Para probar si la base de datos funciona correctamente en su integridad referencial colocaremos el idstudent = 5 (que aún no está registrado) y le damos click a «insert»:
¡Oh, sorpresa! nos devuelve un mensaje de error y no es para menos ¿para qué querríamos guardar un número de teléfono si no sabemos quién es su propietario? (a menos que trabajeís como detective, hay «caso de casos»).
Desistimos pues en nuestro intento de «embasurar» nuestra base de datos y procedemos a colocarles a los tres números telefónicos que insertemos un idstudent cualquiera entre 1 y 4 y al poco rato tenemos una bonita matrícula lista para clases (aunque falta agregar cursos, aulas, profesores, horarios… «Roma no se construyó en un solo día» reza el refrán, vamos poco a poco).
Una vez hecho esto ya estamos listos para hacer unas consultas entre ambas tablas y con propósitos didácticos ejecutamos la primera consulta (y de manera similar a nuestra entrada anterior):
SELECT students.name, phone_numbers.number
FROM students, phone_numbers
WHERE students.id = phone_numbers.idstudent;
La consulta está en escrita en tres líneas pero la base de datos «sabe» que la misma termina cuando alcanza el punto y coma «;» y dicha manera de escribirla nos proporciona legibilidad para desglosarla y explicarla, línea por línea:
La primera línea ordena que seleccione «SELECT» los campos «name» de la tabla «students» (de allí el punto como unión) e igual con «number» que pertenece a la tabla «phone_numbers». Esta sintaxis permite que, por ejemplo, dos campos con el mismo nombre en diferentes tablas sean identificados sin ambigüedad alguna.
La segunda línea «FROM» instruye de cuáles tablas sacarán los datos.
La tercera línea «WHERE» está el condicional: para cada estudiante que devuelva el o los números telefónico(s) registrado(s) relacionados entre sí por el identificador numérico.
Como sólo insertamos tres números telefónicos pues sólo tres estudiantes con teléfonos será lo que veremos (en este caso para cada estudiante un solo número telefónico que sería el caso más común). ¿Pero y si queremos visualizar TODOS los estudiantes, tengan o no número telefónico registrado?
Uniones o «JOIN»:
En el lenguaje SQL existe el comando JOIN con sus prefijos INNER, LEFT y RIGHT haciendo la salvedad que «JOIN» = «INNER JOIN» y será el primero que veremos para realizar la misma consulta que hicimos con el condicional WHERE:
SELECT students.name, phone_numbers.number
FROM students
INNER JOIN phone_numbers
ON students.id=phone_numbers.idstudent;
De nuevo desglosamos y analizamos línea por línea (recordad el para qué sirve el punto y coma al final de la consulta):
La primera línea solicitamos los campos que nos interesan de ambas tablas, cada uno con su espacio de nombres para evitar confusiones.
La segunda línea específicamos la tabla «principal» (esto tendrá sentido más adelante) es decir los estudiantes, ya que ellos son los propietarios de cada número de teléfono.
La tercera línea indica hacia cual tabla se hará la unión, osea con cual se combinará.
La última linea establece cómo relacionar los datos, en este caso una sola condición posible de relación entre ambas tablas (pudieran haber otras relaciones posibles pero por ahora no complicaremos las cosas).
INNER JOIN
Hasta aquí todo bien pero volvamos a la pregunta:
¿Pero y si queremos visualizar TODOS los estudiantes -y su(s) número(s) telefónico(s)-, tengan o no número telefónico registrado?
Es aquí que utilizaremos LEFT JOIN en vez de INNER JOIN, simplemente ese cambio, una sola palabra por otra:
SELECT students.name, phone_numbers.number
FROM students
LEFT JOIN phone_numbers
ON students.id=phone_numbers.idstudent;
Y AHORA SÍ que observamos que el estudiante Pedro aparece pero en donde va el número telefónico muestra NULL el cual es una palabra que encierra un concepto que en base de datos trae aún hoy en día candentes discusiones pero que en este caso práctico muestra su utilidad: «NO TIENE NÚMERO TELEFÓNICO REGISTRADO Y NO SABEMOS SI REALMENTE LO TIENE YA QUE SIMPLEMENTE O SE NEGÓ A SUMINISTRARLO O EL INSCRIPTOR OLVIDÓ REGISTRARLO». Todo eso encierra el concepto de NULL.
Actualizado el martes 12 de enero de 2016: me hacen la sugerencia que pudieramos colocar un campo lógico (verdadero o falso) para saber a ciencia cierta si la persona posee algún teléfono. No veo mala esa idea pero recomiendo que le coloquen NULL como valor predeterminado pero que sea obligatorio ese dato -y por ende no permitirá guardar con NULL-. A nivel de la interfaz del usuario, el formulario que introduce datos para agregar personas deberá utilizarse un RADIO BUTTON sin valor preseleccionado en ninguno de los dos. Ejemplo:
LEFT JOIN
Ya cerrando la entrada podemos acotar la consulta JOIN con un simple WHERE tal como ejercitamos en otra entrada:
SELECT students.name, phone_numbers.number
FROM students
LEFT JOIN phone_numbers
ON students.id=phone_numbers.idstudent
WHERE LOWER(students.email) ~ ‘hotmail.com’;
sólo que esta vez veremos sólamente los estudiantes que posean correo electrónico en «hotmail.com» (hoy día «outlook.com») y que tengan al menos un número telefónico registrado.
Aprovecho el breve receso de estas fechas carnestolendas de 2015 para continuar con esta miniserie de artículos sobre PostgreSQL 9.1. Para aquellos que quieran llevar la secuencia correcta del tema éste se inicia acá .
Lo que haremos hoy son unas consultas sencillas en SQL no sin antes haber agregado unos cuantos datos de prueba (cualquier semejanza con personas reales es pura y casual coincidencia).
Utilizando el navegador web predeterminado en Debian, el Iceweasel (que cada día aprecio más por su economía de recursos y por ende rapidez) nos vamos a la consabida dirección IP de nuestro servidor virtual:
Introducimos el «login» y la contraseña (si no lo recuerdan ir a esta entrada ) y una vez hayamos logrado acceso hacemos click («o vamos») a la tabla students (aunque soy fanático del castellano, debo reconocer que el inglés es hoy en día lo que fue el latín en el mundo entero) y observamos su estructura de datos más sin embargo nos interesa, por ahora, el enlace «insert» para dar algunas altas en la tabla:
Tras lo cual se nos abre el siguiente cuadro de diálogo el cual procedemos a llenar sin cortapisa:
Observen que dejé el campo «id» intencionalmente en blanco: nuestro primer valor será, naturalmente, el 1 pero en los siguientes registros que insertemos intenten guardar ese valor de nuevo y observarán una de las restricciones de la tabla: los valores no pueden repetirse para ese campo en particular. A la final verán algo parecido a esto, ya con los registros insertados:
Vuelvo a repetir: cualquier parecido con los datos personales en la realidad es simple y feliz coincidencia. Ahora que tenemos unos cuantos registros insertados podemos hacer unas consultas sencillas, para ello bastará con hacer click en el enlace «SQL» que está en el borde superior derecho de la web, cerquita de
«SQL | History |Find | Logout»
¿lo vieron? en el cuadro de diálogo que se abre escribimos la siguiente sentencia para visualizar los correos electrónicos de los estudiantes:
select email from students;
Antes que hagan click en «execute» («ejecutar -sentencia-«) observen atentamente que estamos trabajando con la base de datos «GNU_academy» y que nuestro vía de búsqueda de esquema está apuntada a «public» (ésto último permite que al ejecutar una sentencia SQL los nombres de tablas y campos sean buscados y verificados primero antes de comenzar a buscar datos, e incluso es útil para asuntos de seguridad y privilegios pero ese tema es más avanzado; si luego quieren aprender más sobre ello aquí el enlace introductorio al asunto ).
Así pues, sin más, ejecutamos la sentencia tras lo cual veremos algo parecido a esto:
La explicación breve de la sentencia SQL es traducirla del inglés:
«select»->»selecciona»
«from»->»desde (la tabla)»
«;»-> indica fin de la sentencia, no es obligatorio pero es útil si vamos a introducir varias sentencias que deben ir en un orden específico (por ejemplo insertar más datos de estudiantes y luego mostrarlos en un listado para asistencia -ya le vamos dando utilidad en la vida real a esto de las bases de datos-).
Como hay comandos específicos del lenguaje SQL yo opto (y hay varias personas que lo hacen) por escribir dichos comandos en mayúsculas y los nombres de tablas (y/o variables y/o constantes) en minúsculas y como pueden ver se ejecutan sin ningún problema, el asunto es de legibilidad para nosotros los humanos:
SELECT email FROM students;
Importante: los nombres de campos y tablas han escribirse tal cual fueron creados en la base de datos correspondiente, de no ser así nos devuelve error; es por ello que desde un principio en estos tutoriales los creamos todos en minúsculas -y en inglés, de paso-.
Volviendo al tema de la realidad, supongamos que por cualquier razón necesitamos saber cúales (y cuántos) estudiantes utilizan correo hotmail pues simplemente introducimos la siguiente sentencia SQL
SELECT email FROM students WHERE email ~ ‘hotmail.com’;
Observen el nuevo comando
«WHERE»->»donde (satisfazga la condición)»
y el uso de la virgulilla como comparador lógico indicando que dicha condición tenga la cadena de texto ‘hotmail.com’. Otros detalles a considerar es el uso de las comillas simples y el uso de mayúsculas: si usamos comillas dobles se interpreta como nombre de columna y si usamos mayúsculas NO devuelve los correos electrónicos ya que «hoTMail.com» NO ES IGUAL A «hotmail.com»:
«hoTMail.com» <> «hotmail.com»
Sobre nomenclatura del correo electrónico:
Esto nos plantea desde ya nuevos retos: si vamos a desarrollar una aplicación seria es deber que los usuarios ingresen direcciones de correo válidos (sintaxis usuario@dominio ):
El nombre del usuario NO debe llevar espacios a menos que estén precedidos por una barra inversa y entrecomillado.
El dominio NUNCA debe llevar espacios (ni arrobas, claro está).
No pueden haber espacios antes o después de una dirección válida.
No pueden llevar dobles puntos «..», así estén entrecomillados.
El nombre del usuario no pueden contener dobles arrobas a menos que estén debidamente entrecomillados.
Y son sólo algunas de las reglas que aplican a la sintaxis de una dirección de correo electrónico, para mayor información (en inglés, ¡cuando no!) en RFC 822 y dirección de correo electrónico . La buena noticia es que PosgreSQL admite varios lenguajes de programación que junto con triggers o «disparadores» nos permitirán capturar y revisar los correos electrónicos antes de agregarlos a la base de datos (serán tratados a futuro en una entrada aparte). Y aunque nos hemos salido un poco de las consultas sencillas era necesario ir abonando el terreno hacia temas más avanzados (oh idioma castellano, qué poético eres, nunca cambies 😉 ).
Os ruego hagan la prueba escribiendo las sentencias en sus múltiples variantes, como ayuda os dejo el comando LIKE cuyo uso tiene una sintaxis más elaborada:
SELECT email FROM students WHERE email LIKE ‘%hotmail.com%’;
Produciendo el mismo resultado que con la virgulilla; vale destacar que al colocar el símbolo de porcentaje como comodín le estamos ordenando que nos busque cualquier dirección de correo electrónico registrado en nuestra tabla students que contenga la cadena de caracteres «hotmail.com» (obsérvese que si algún bromista registrara la dirección de correo electrónico «hotmail.com@gmail.com» sería devuelta también en la consulta, os animo a probarla -aunque dudo que alguien en verdad tenga ésa dirección-) pero eso aún no resuelve nuestro problema de mayúsculas y minúsculas.
Una solución sería utilizar una función integrada por defecto en nuestra base de datos, es decir, una serie de programas ya registrados y de propósito general; dicha función para este caso es LOWER() aplicado al campo email (ojo que si es así lo que entrecomillamos como condición debe ir todo en minúsculas):
SELECT email FROM students WHERE LOWER(email) LIKE ‘%hotmail.com%’;
o también podemos usar, como al principio, la virgulilla que nos ahorra el uso de comodines:
SELECT email FROM students WHERE LOWER(email) ~ ‘hotmail.com’;
Si quereís ver el resto de funciones de cadena, haced click aquí.
Por último, si quiséramos el caso contrario, listar los estudiantes que no tienen correo «hotmail» registrado:
SELECT email FROM students WHERE LOWER(email) !~ ‘hotmail.com’;
y lo único que hicimos fue agregarle el operador lógico «!» que indica negación «NOT», el cual si que lo podemos usar con LIKE:
SELECT email FROM students WHERE LOWER(email) NOT LIKE ‘%hotmail.com%’;
Y entonces nos desconectamos de la base de datos como es debido:
Son 3 hojitas en formato pdf (agradezco a «pdfsam» y lo recomiendo para dividir y combinar documentos en ese formato); con este aumento el sueldo mínimo en Venezuela se ubica en Bs. 5.622,48 (si tomamos como referencia el SICAD II serían aproximadamente US$ 114 mensuales).
Para descargar dicho ejemplar electrónico de la Gaceta Oficial desde nuestra página web haga click aquí.
Si desea descargarla desde el Tribunal Supremo de Justicia deberá luego introducir el número «40597» en el cuadro de búsqueda rápida.
