La instrucción Select…Case en Visual Basic

La instrucción Select…Case de Visual Basic tiene un funcionamiento similar al Switch…Case de C: nos permite evaluar el valor de una variable y ejecutar un determinado código según su valor, sin tener que acabar recurriendo a un enorme árbol de estructuras if/else anidadas. La variable se evaluará contra una serie de expresiones por orden descendente, parando en cuanto una de las evaluaciones sea verdadera.

Su sintaxis sería la siguiente:

SELECT mivariable
  CASE expresión1
   'código
  CASE expresión2
    'otro código
  CASE ELSE
    'Código por defecto
END SELECT

La variable mivariable del ejemplo sería la que vamos a evaluar. Puede ser una variable de los siguientes tipos: Boolean, Byte, Char, Date, Double, Decimal, Integer, Long, Object, SByte, Short, Single, String, UInteger, ULong, y UShort.

Tanto expresión1, como expresión2 y demás expresiones que queramos usar será valores o conjuntos de valores numéricos o de texto contra los que se evaluará mivariable. Puede responder a tres formas: un valor solo, una comparación con la sintaxis IS seguido de un operador de comparación (mayor, menor, igual, distinto) o un conjunto de valores, que puede mostrarse de dos formas: un grupo de valores separados por comas o un rango del que daremos el valor inicial y el final unidos por un TO.

Finalmente tenemos el CASE ELSE, esto es opcional y es un código que se ejecutará si el valor de mivariable no ha dado true en ninguna de sus evaluaciones.

Veamos una serie de ejemplos. Primero, veamos un código que asigna un valor de color de fondo a un grupo de usuarios:

SELECT Grupo
  CASE "Dirección"
    colorfondo="verde"
  CASE "Producción"
    colorfondo="gris"
  CASE ELSE
    colorfondo="rojo"
END SELECT

Segundo ejemplo, un código que asigna un grupo poblacional según la edad, evaluando por rangos:

SELECT Edad
  CASE 0 to 14
    grupo="Infantil"
  CASE 15 to 20
    grupo="juvenil"
  CASE 20 to 70
    grupo="adulto"
  CASE ELSE
    grupo="anciano"
END SELECT

Tercer ejemplo, en este caso con grupos de valores por comas. Evaluamos el último número de un código y marcamos si es par o impar (sí, ya se que es más fácil hacerlo con una operación de módulo, pero esto es un simple ejemplo teórico):

SELECT Numero
  CASE 1,3,5,7,9
    impar=True 
  CASE ELSE
    impar=False
END SELECT

Y vamos a cerrar con el cuarto ejemplo, usando una expresión aritmética para la evaluación, en este caso para los pesos de una competición de lucha:

SELECT Peso
  CASE IS < 48
    categoria="minimosca" 
  CASE IS < 51
    categoria="mosca" 
  CASE IS < 54
    categoria="gallo" 
  CASE IS < 57
    categoria="pluma" 
  CASE IS < 60
    categoria="ligero"
  CASE IS < 64
    categoria="superligero" 
  CASE IS < 69
    categoria="wélter" 
  CASE IS < 75
    categoria="mediano" 
  CASE IS < 81
    categoria="semipesado" 
  CASE IS = 91
    categoria="superpesado" 
END SELECT
Anuncios

¿Qué es una función hash?

Ayer comentaba en Facebook que una cadena alfanumérica que aparecía en una noticia “parecía el resultado de alguna función hash” y hubo gente que me preguntó qué era eso de una función hash. Así que he pensado que lo mejor será contarlo por aquí que me puedo extender más.

Cifrado

Las funciones hash, también llamadas “digest” o “de resumen“, son algoritmos que calculan y devuelven una cadena de texto alfanumérica de longitud fija calculada a partir de un dato de entrada, que puede ser un texto o un fichero binario. Se trata de funciones unidireccionales, lo que quiere decir que aun teniendo el resultado y conociendo el algoritmo no debe ser posible revertir las operaciones para descifrar el dato de entrada.

Son también funciones determinísticas, siempre devuelven la misma salida para la misma entrada. Al ser resúmenes existe la posibilidad de que dos entradas totalmente distintas devuelvan el mismo resultado, es lo que se llama una “colisión“. Teóricamente es imposible crear una función hash sin colisiones, puesto que las posibilidades de entrada son infinitas pero las de salida están limitadas a la longitud de la cadena de resumen, por tanto a mayor logitud de respuesta menor posibilidad de colisión y mayor robustez para el algoritmo. Las colisiones son lo que facilita un tipo de ataque criptográfico llamado “Ataque de Cumpleaños” del que puedes leer en ese enlace.

Por ejemplo, si calculo el hash de la cadena “hola” con el algoritmo md5 el resultado será: 4d186321c1a7f0f354b297e8914ab240. En cambio si le paso la cadena “Hola“, con mayúscula, el resultado devuelto será: f688ae26e9cfa3ba6235477831d5122e.

¿Qué utilidad tiene esto? Bueno, no se trata de un algoritmo para cifrar un mensaje y poder descifrarlo luego, como pueda ser el caso de AES, no tiene el mismo propósito que la criptografía simétrica o asimétrica. Las funciones hash son útiles por ejemplo para almacenar contraseñas en una base de datos, ya que aunque alguien lograra acceder a ellas no podría descifrar cual es la contraseña original. Otro de sus principales usos es asegurar que un fichero no ha sido modificado durante el trayecto desde su envío: se calcula el hash antes de enviarlo, si al recibirlo lo volvemos a calcular y el resultado no es el mismo implica que alguien ha capturado (un ataque de intermediario o man in the middle) y modificado el fichero. Las funciones hash también se utilizan en los procesos de firma digital de documentos.

¿Cuales son los algoritmos de resumen más populares o más comunes? Te dejo una lista con sus enlaces a Wikipedia:

SQL-Server: Usar Try…Catch en una transacción.

Desde SQL-Server 2008 es posible utilizar la instrucción Try…Catch. Estas instrucciones nos permiten implementar un mecanismo de control de errores: metemos un bloque de código dentro de la instrucción Try, para intentar ejecutarlo, y dentro de Catch metemos las instrucciones para controlar la respuesta en caso de error.

La sintaxis básica de un Try…Catch en SQL-Server es la siguiente:

BEGIN TRY  
     ---Bloque de código 
END TRY  
BEGIN CATCH  
     --Código en caso de error. 
END CATCH  

Cuando realizamos una transacción podemos exprimir al 100% la instrucción Try…Catch. La idea es la siguiente: Comenzamos la transacción, intentamos una acción en un bloque Try. En caso de que falle mostramos el error y ejecutamos un rollback para anular la transacción. En caso de éxito confirmamos la ejecución de la transacción.

Veamos un código de ejemplo:

BEGIN TRANSACTION;  --Comienza

BEGIN TRY  --Aquí empieza el try
    Insert into Ejemplo(Id,Nombre) values(22,'Manuel');
    Delete From Espera Where Nombre = 'Manuel' 
--Intentaremos esas dos acciones
END TRY  
BEGIN CATCH  
--El primer paso en el Catch
--Será recoger y mostrar
--Todos los errores
    SELECT   
        ERROR_NUMBER() AS ErrorNumber  
        ,ERROR_SEVERITY() AS ErrorSeverity  
        ,ERROR_STATE() AS ErrorState  
        ,ERROR_PROCEDURE() AS ErrorProcedure  
        ,ERROR_LINE() AS ErrorLine  
        ,ERROR_MESSAGE() AS ErrorMessage;  
--Si hay transacción abierta
--Hacemos un rollback sobre ella
--Para anularla
    IF @@TRANCOUNT > 0  
        ROLLBACK TRANSACTION;  
END CATCH;  
--Fuera del bloque vamos a
--comprobar que haya transacción abierta.
--Si la hay es que no tuvo que ir por el CATCH
--Por tanto confirmamos.
IF @@TRANCOUNT > 0  
    COMMIT TRANSACTION;  
GO  

Diferentes formas de contar el número de líneas de un fichero desde la consola de Linux.

Si queremos contar el número de líneas que tiene un fichero desde la consola de Linux tenemos, al menos, cuatro métodos para conseguirlo. Os pongo los ejemplos de código:

Usando los comandos cat y wc:

cat fichero | wc -l

Con grep le podemos decir que cuente todo el documento de esta forma:

grep -c '.*' file

La opción -n de sed junto al operador = también nos hace el servicio:

sed -n '$=' file

Y para terminar vamos a ver cómo hacerlo con awk:

awk 'END {print NR}' file

SQL-Server: Intercambiar valores 0 y 1 en un Update

Vamos con una cuestión que seguro que nos hemos encontrado más de una vez: Tenemos un campo en una base de datos donde almacenamos un valor verdadero o falso y tenemos que realizar un Update para cambiar dicho estado. ¿Cómo hacemos para modificarlo con el menor costo posible? Te doy un par de soluciones, todas válidas para SQL-Server desde la versión 2008 hasta la 2017 (y supongo que seguirán valiendo en las posteriores):

Para la primera vamos a usar la operación del OR exclusivo bit a bit:

Update TablaEjemplo SET ValorVF = Convert(Bit,ValorVF ^ 1)

Otra opción lógica es usar el operador lógico de negación para invertir el valor:

Update TablaEjemplo SET ValorVF = Convert(Bit,~ ValorVF)

¿Y qué pasa si la tabla no está bien diseñada y en lugar de almacenar un valor bit estamos almacenando un entero? Si no podemos cambiar el diseño de la tabla todavía podemos recurrir a la primera solución, el OR exclusivo bit a bit, pero sin realizar la conversión a tipo bit:

Update TablaEjemplo SET ValorVF = ValorVF ^ 1

Y además tenemos otra opción, con una simple resta y con la función ABS(), que nos devuelve el valor absoluto del parámetro que recibe:

Update TablaEjemplo SET ValorVF = ABS(ValorVF - 1)

Distintas formas de invertir una cadena de texto en Linux.

Vamos a hablar un poco más sobre programar scripts en Linux y veamos cómo podemos invertir una cadena con distintos métodos:

Empezamos con lo más sencillo, usar la función rev:

echo holiii | rev

Usando el comando sed dos veces, junto con tac, también podemos hacerlo:

echo holiii | sed 's/./&\n/g' | tac | sed -e :a -e 'N;s/\n//g;ta'

Ya os podéis imaginar que si podemos hacerlo con sed es que también podemos hacerlo con awk, en este caso con la función substr() y un bucle for con el que recorreremos la cadena de fin a principio pintando cada letra:

echo holiii | awk '{ for(i=length;i!=0;i--)x=x substr($0,i,1);}END{print x}'

Y no podría faltar el tradicional script de shell. El principio es el mismo que con awk: recorrer la cadena del final hacia el inicio pintando cada elemento

#!/bin/bash
a="holiii"
len=`echo ${#a}`
while [ $len -ne 0 ]
do
        b=$b`echo $a | cut -c $len`
        ((len--))
done
echo $b

Introducción al álgebra booleana: ¿Qué es?

El álgebra booleana es una estructura algebraica que esquematiza las operaciones lógicas, tomando su nombre de George Boole quien fue el primero en definirla como parte de un sistema lógico en 1847, en un intento de utilizar las técnicas algebraicas para tratar expresiones de la lógica proposicional.

El Álgebra de Boole es un conjunto “A”, provisto de dos operaciones binarias AND, OR, una operación unaria NOT y dos elementos 0 (Falso) y 1 (Verdadero), de forma que para todos los elementos a, b y c del conjunto A, se cumplen los siguientes axiomas:

Asociatividad:
a OR ( b OR c ) = ( a OR b ) OR c
a AND ( b AND c ) = ( a AND b ) AND c

Conmutatividad:
a OR b = b OR a
a AND b = b AND a

Absorción:
a OR (a AND b)=a
a AND (a OR b)=a

Distribuitividad:
a OR (b AND c)=(a OR b) AND (a OR c)
a AND (b OR c)=(a AND b) OR (a AND c)

Complementación:
a OR NOT a = 1
a AND NOT a = 0

Como en una computadora digital hay sólo dos posibilidades, usar el 0 o bien el 1 para representar el objeto más pequeño e indivisible, el álgebra booleana se convierte en una de las herramientas fundamentales de la computación y de la electrónica. Todos los datos se reducen finalmente a combinaciones de bits y los circuitos electrónicos permiten que estos recursos de almacenamiento se comuniquen entre sí. Un bit en una parte de un circuito se transmite a otra como voltaje. Por ello se necesitan dos niveles de voltaje: un voltaje alto que comunique el 1 y un voltaje bajo que comunique el 0. Fue Claude Shannon, en 1938, el primero en darle esta utilidad para simplificar circuitos conmutadores.

Operación AND.
La operación AND es exactamente igual a una multiplicación normal por lo cual sus reglas son las siguientes:

  1. Solamente si todas las entradas son 1 la salida será 1.
  2. Cuando una o más entradas sean 0 la salida será 0.

En el caso de una compuerta AND en un circuito electrónico esta opera en tal forma que su salida es ALTA sólo cuando todas sus entradas son ALTAS. En todos los otros casos la salida de la compuerta AND es BAJA.

Operación OR:
La operación OR es básicamente una suma y sus reglas son las siguientes:

  1. Produce un resultado de 1 cuando cualquiera de las variables de entrada es 1.
  2. Produce un resultado de 0 solo cuando todas las variables de entrada son 0.

En el caso de una compuerta OR opera en tal forma que su salida es ALTA si la entrada A, B o ambas están en un nivel lógico 1. La salida de la compuerta OR será BAJA si todas sus entradas están en el nivel lógico 0.

Operación NOT:
La operación NOT también se conoce como inversión o complementación, básicamente nos devuelve el valor complementario al que tengamos. Es decir, si A es igual a 0 entonces NOT A sería uno 1.

En el caso de un circuito electrónico NOT este siempre tiene una sola entrada y su nivel lógico de salida es contrario al nivel lógico de esta entrada.