Instalación Ubuntu 12.04 con VirtualBox

1.- Fundamento.

Este tutorial es desarrollado en virtud de que a pesar que se puede instalar Ubuntu Linux sin necesidad de tener mucho conocimiento, es posible que este tutorial sirva como un auxiliar en dicho proceso, considerando que se hará con VirtualBox, pudiendo virtualizar casi en su totalidad la funcionalidad de dicho sistema operativo.

Aunado a ello, damos una pauta sobre el uso de la gestión de redes, ya que VirtualBox por defecto genera un esquema NAT (Network Address Translation), cosa que no nos servirá mucho si deseamos utilizar la máquina virtual como mecanismo de gestión para las redes de computadoras.

Como detalle extra, se considera que ya has descargado anteriormente tu imagen ISO del sistema Ubuntu-Linux de tu elección, existiendo versiones de 32 y de 64 bits. Si no sabes en qué consiste esto, te recomiendo que descargues la versión de 32 bits (ya que funcionará en un procesador de 64 bits), y si ya eres experto, puedes descargar otras versiones (como el “Server”, “Alternate”, etc.).

2.- Instalación.

El proceso inicia con la descarga de VirtualBox, para ello iremos a la siguiente página:

• https://www.virtualbox.org/wiki/Downloads

En la misma, procedemos a descargar la versión de VirtualBox de nuestra elección, sea en ya  Windows, Linux, Mac, etc. Es necesario indicar que hasta este momento no existe una diferencia entre versión de 32 o 6 bits del programa para los sistemas Windows. La siguiente figura indica dónde hay que descargar el programa:

Figura 1.- Descarga de VirtualBox para entornos Windows.

Sobre la descarga de la aplicación, procedemos a la instalación de la misma. No hay mucho que decir sobre ello, solamente dar click a “Siguiente → Siguiente → Siguiente → Aceptar...”, es decir, una instalación convencional de Windows.

Tras tener este punto establecido, nos pedirá instalar algunos “drivers” adicionales, pues instalará una tarjeta de red propia para el equipo, en este punto solamente aceptamos e instalamos dichos “drivers” (en sistemas Windows aparece una ventana indicando este punto, damos click al botón “Aceptar” o “Continuar” dependiendo el caso). Sobre la instalación personal, aparecieron como 4 o 5 veces dicha ventana de instalación de “drivers”. Al finalizar la instalación de todos los elementos, iniciamos el programa (que estará ubicado en el “Escritorio”, o bien en el botón “Inicio” del sistema operativo), y tras iniciar tendremos una ventana como la que aparece en la siguiente figura:

Figura 2.- VirtualBox iniciado.

La figura anterior muestra la interfaz general del programa. No daremos muchos detalles del mismo pues solamente nos enfocaremos a la instalación propia de Ubuntu-Linux como lo plantea o mini-tutorial del mismo. El siguiente paso consiste en dar click al botón “Nueva”,  ubicado en la parte superior izquierda de la interfaz general. Tras hacerlo generaremos una nueva máquina virtual, como se muestra en la figura de abajo. Los parámetros que hay que ubicar en la misma son:

• Nombre.- El de tu elección, pero que sea un nombre característico de tu máquina.
• Sistema operativo.- Que sea “Linux”.
• Versión.- Aquí debe decir “Ubuntu” (aunque más bien debería ser distribución).

Figura 3.- Creación de la nueva máquina virtual.

El siguiente paso consiste en la asignación de memoria RAM para la máquina virtual, a lo cual se recomienda un valor de 512 Mbytes, o bien, 1024 Mbytes (1 Gbyte), recordándote que esta memoria será utilizada por la máquina virtual exclusivamente, y debes dejar suficiente memoria RAM disponible para que tu equipo fluya adecuadamente. Por ejemplo, si tienes 3 Gbytes en total sobre tu equipo y asignas 1 Gbyte a la máquina virtual, tendrás 2 Gbytes para tu propio equipo (es importante siempre considerar este punto). La siguiente figura muestra la asignación de 512 Mbytes de RAM para tu máquina virtual.

Figura 4.- Asignación de memoria RAM para la máquina virtual.

El siguiente pasos consta de la creación del disco duro virtual para tu equipo Ubuntu, siendo que aquí podrías elegir la opción de crear uno nuevo (cosa que haremos), o bien, utilizar uno ya existente. Para ello, seleccionamos la opción “Crear disco duro virtual nuevo”.

Figura 5.- Creación del disco duro virtual.

El punto que sigue a continuación, es el establecimiento de si el disco duro virtual tendrá un tamaño fijo, o si será dinámico. Por asuntos de practicidad, dejaremos que el tamaño del mismo será “Reservado dinámicamente”, ya que el disco duro irá creciendo (hasta un tope establecido) conforme vayamos almacenando archivos o contenido en el mismo (es una gran ventaja, pues el tamaño del archivo del disco no aumenta mientras no ingresemos más elementos).

Figura 6.-. Tipo de almacenamiento sobre disco duro virtual.

El punto a establecer a continuación consiste en establecer el tamaño del disco. Como tamaño mínimo se recomiendan 8 Gbytes, aunque queda un tanto limitado, para este caso, y en virtud de la capacidad del equipo “Host”, se tendrá un tamaño de 18 Gbytes aproximadamente. También, si lo deseas, puedes cambiar la ruta de este disco duro en alguna carpeta de tu elección (aunque se recomienda no mover mucho estos parámetros).

Figura 7.- Asignación del tamaño del disco duro virtual.

Sobre los pasos de creación es todo, solamente nos queda revisar que los datos sean correctos (nombre de equipo, sistema operativo, RAM, disco duro virtual, etc.), y damos click al botón “Crear”, iniciando la gestión el programa sobre los parámetros determinados.

Figura 8.- Resumen de la creación de la máquina virtual.

Tras establecer los parámetros de la máquina virtual, en la interfaz del programa aparecerá la misma, con el nombre que hayamos establecido anteriormente (como muestra la figura de abajo), ahora es momento de arrancarla, para ello, la seleccionamos y damos doble click a la misma (o la seleccionamos con un solo click, y elegimos el botón “Iniciar” con los botones propios del programa).

Figura 9.- Arranque de la máquina virtual.

Como es la primera vez que arrancamos la máquina virtual nueva, nos pedirá automáticamente el medio de arranque de la misma, considerando previamente que ya has descargado el archivo ISO de Ubuntu Linux anteriormente (versión de 32 o 64 bits, aunque para la máquina virtual se recomienda la versión de 32 bits). Lo que aparecerá es una interfaz donde nos indicará dónde está el medio de arranque de la máquina virtual, si tienes el CD disponible ingrésalo en tu equipo, y selecciona la “Unidad Anfitrión E:” (a mi me sale la letra “E” porque es la unidad de mi CD en mi equipo, en el tuyo no se cual sea la unidad). Si tienes el archivo ISO en tu máquina da click a la carpetita ubicada del lado derecho (que es como le vamos a hacer nosotros), indicado en la figura 10.

Figura 10.- Selección del ISO de Ubuntu como medio externo.

A continuación se abrirá un cuadro de diálogo, donde elegiremos en este caso, la ruta (para nuestro caso, el “Escritorio” de Windows, que es donde tenemos el archivo ISO), ubicando el archivo ISO correspondiente a Ubuntu Linux, y damos doble click al mismo.

Figura 11.- Ubicación del ISO de Ubuntu en nuestro equipo.

Tras tener el archivo seleccionado, el sistema nos indicará que elegimos un archivo ISO para el arranque de nuestro sistema operativo, simplemente “Finalizamos” y arranca el sistema.

Figura 12.- Establecimiento del medio externo para el arranque.

Tras esperar un rato, aparecerá la máquina virtual, donde tendremos dos opciones a elegir:

• Probar Ubuntu.
• Instalar Ubuntu.

Como nosotros deseamos instalar Ubuntu en nuestra máquina virtual, elegimos la opción “Instalar Ubuntu”, que es donde empezará la gestión propia de nuestro sistema operativo virtual, instalando todos los archivos que necesitaremos sobre este punto.

Figura 13.- Parámetros iniciales sobre la máquina virtual.

Nos aparecerá una imagen donde podremos elegir algunos parámetros extras, y donde se nos da la indicación que debemos estar conectados a una toma de corriente eléctrica (para no dejar inconsistente la instalación). Quitamos la elección donde se indica “Descargar las actualizaciones”, pues las mismas podremos descargarlas posteriormente, dejando la opción como se muestra en la figura inferior.

Figura 14.- Preparación de la instalación de Ubuntu.

Como no entraremos en detalles extensos, en la siguiente pantalla elegimos la opción “Borrar disco e instalar Ubuntu”, pues si no en todo caso tendríamos que gestionar la tabla de particiones (cosa que no haremos por el momento), así gestionaríamos de otra forma la instalación, pero, como dijimos anteriormente, elegiremos la totalidad del disco duro para nuestro sistema operativo invitado.

 

Figura 15.- Parámetros sobre el disco duro virtual.

La siguiente pantalla nos indicará que se utilizará el disco duro entero, y procedemos a “Instalar ahora”, dando pauta a la gestión de archivos y demás parámetros (cosa que hará de forma automática el instalador de Ubuntu).

Figura 16.- Selección de la Unidad.

Ya como detalle especial, puedes elegir la ciudad donde estás ubicado, por la gestión de “Zona horaria”, elegimos “Ciudad de México”, o donde te encuentres ubicado.

Figura 17.- Establecimiento del país para la zona horaria del equipo.

Del teclado, pues dependiendo la configuración de tu equipo elegimos “Español - Latinoamericano”, reitero, acorde a la naturaleza y configuración de tu equipo.

 

Figura 18.- Elección del tipo de teclado de nuestro equipo de cómputo.

Posterior a esto, ubicamos el nombre de usuario que tendrá nuestro equipo (el nombre del equipo para su invocación en la red se hará automáticamente) y una contraseña, la cual habrá que teclear dos veces. Es muy importante NO OLVIDES TU CONTRASEÑA, pues luego cuesta algo de trabajo recuperarla, y es la que utilizarás para ingresar al sistema (sin contraseña no puedes acceder al sistema).

Figura 19.- Establecimiento del usuario, nombre de equipo y contraseñas.

Ya concluyendo con los puntos de ingreso de datos, nos aparecerán pantallas informativas sobre la instalación del sistema operativo, como: carga de archivos, desempaquetar, instalación, borrado, etc. Aquí es normal que tarde un buen rato sobre la instalación, y posiblemente (si estás conectado a Internet) trate de descargar algunas actualizaciones. Solamente se pide algo de paciencia sobre este punto para finalizar la instalación.

Figura 20.- Inicio de la instalación de Ubuntu Linux.

Tras finalizar la carga de archivos, el sistema nos avisará (en modo gráfico) que se necesita reiniciar el equipo, simplemente damos click al botón “Reiniciar ahora” y listo, regresaremos al modo de consola.

Figura 21.- Finalización de la instalación y reinicio del equipo.

La siguiente pantalla informativa simplemente nos indica que se “Extraerá el medio de instalación”, que en este caso fue nuestra imagen ISO, que presionemos “Enter” y el sistema reiniciará automáticamente, lo presionamos y listo, la máquina reiniciará automáticamente.

Figura 22.- Retorno a la consola sobre finalización.

Tras hacerlo, empezará la carga de la máquina virtual, pero ya no como parámetro de instalación, sino como un sistema operativo integrado dentro de VirtualBox.

Figura 23.- Equipo reiniciado como máquina virtual.

Tras cargar los archivos necesarios, el sistema nos pedirá el nombre de usuario (el cual ya aparece en la pantalla) y la contraseña, la cual habías ingresado anteriormente, y por eso se te hizo la observación que no la olvidaras. También, las contraseñas son “Sensibles al Contexto”, esto implica que hay que respetar mayúsculas y minúsculas. La tecleamos y podremos ya ingresar al sistema sin mayor problema.

Figura 24.- Pantalla de inicio de sesión.

En la figura inferior se puede apreciar el entorno Ubuntu-Linux ya instalado y funcionando bajo un esquema visual Gnome.

Figura 25.- El entorno de Escritorio Gnome en Ubuntu-Linux.

Existe un detalle especial sobre la configuración de la red. Por defecto, VirtualBox gestiona una red NAT (Network Address Translation), esto implica que tu máquina virtual no puede conectarse directamente a tu router (o módem, dependiendo el caso), sino a través del sistema operativo “Host” (que es nuestro Windows), siendo precisamente este esquema el indicado como conversión de nombre, siendo que la máquina virtual adquiere una dirección IP que le da el sistema “Host”, pero, para las prácticas de redes que puedes requerir más adelante necesitamos que la red sea de “Puente – Bridge”, para ello modificaremos algunos parámetros más adelante.

De entrada, utilizando un módem-router de Telmex, el esquema normal es una red clase “C” para la conexión (generalmente, 192.168.1.xxx), pero como podemos ver en la figura inferior (figura 26), la dirección no corresponde con el esquema dado por el módem de Telmex, y esto es precisamente porque los parámetros de la máquina virtual consideran NAT y no “Bridge”, siendo con esto que no podemos conectar directamente nuestra máquina virtual con el módem-router. Cambiaremos los parámetros más adelante.

Figura 26.- Dirección IP utilizando NAT.

Para ello, nos iremos al botón “Configuración” de nuestra máquina virtual (una vez que esté apagada), seleccionando primero nuestra máquina virtual.

Figura 27.- Cambio de configuración para el tipo de tarjeta de red.

Lo que haremos dentro de la configuración será elegir la opción “Red” de los botones ubicados del lado izquierdo, y nos ubicamos en la pestaña “Adaptador 1”, siendo ahora que los parámetros que requeriremos son los siguientes:

• Conectado a: antes decía “NAT”, elegimos la opción “Adaptador puente”.
• Nombre: elegimos la tarjeta de red por la que te conectes a Internet (o bueno, al módem-router), en el caso de este equipo es la tarjeta de red inalámbrica (aunque podría ser la red cableada).

No ingresamos nada en las opciones avanzadas, pues solamente nos interesa conectarnos al módem-router como un equipo más en el entorno de red. Damos click al botón “Aceptar” y listo.

Figura 28.- Establecimiento de parámetros de la red.

Y como podemos ver en la figura 29, tras verificar nuestros parámetros de red, podemos visualizar que nuestra máquina virtual ya está conectada al módem-router como un equipo más, ya que nuestra tarjeta de red sirve como “Puente” (“Bridge” en inglés) entre nuestro equipo virtual y el módem-router.

Figura 29.- Dirección IP asignada correctamente.

Con esto finalizamos la instalación de la máquina virtual. Más adelante pondremos algunos parámetros básicos para poder trabajar adecuadamente con nuestro Ubuntu-Linux sin mayor problema.


3.- Referencias y para saber más.

Las referencias que te pueden auxiliar en este proceso son:

• Goga, A. (2008). Linux en Windows, con Virtual Box (Ubuntu). Recuperado el 5 de Julio, 2012, de http://www.arturogoga.com/2008/02/19/linux-en-windows-con-virtual-box-ubuntu/
• Castagnino, P. (nd). Cómo instalar y configurar Virtualbox. Recuperado el 5 de Julio, 2012, de http://usemoslinux.blogspot.mx/2010/06/como-instalar-y-configurar-virtualbox.html
• OpenBSD (2011). PF: Traducción de Direcciones de Red (NAT). Recuperado el 5 de Julio, 2012, de http://www.openbsd.org/faq/pf/es/nat.html
• Virtualbox.org (nd). Chapter 6. Virtual networking. Recuperado el 5 de Julio, 2012, de http://www.virtualbox.org/manual/ch06.html

Fundamentos de Bases de Datos - Parte 2

Continuando la práctica vista anteriormente, retomaremos el principio del manejo de bases de datos, pero utilizando las características ACID que habías comentado anteriormente. No te preocupes, que aquí las explicaremos en gran medida para comprender el término de “Transacción” que es el que estaremos utilizando más adelante para nuestras operaciones.

Solamente recuerda que para ésta práctica retomaremos lo mismo que ya teníamos de la práctica pasada (aplicación, base de datos, enlace DSN, etc.). Y con esta medida, trataremos de explicar cómo funcionan en cierta medida los sistemas de los Bancos (o cualquier lugar donde ocupen sistemas de bases de datos) para responder ante los fallos o errores que pudieran surgir durante el tratamiento de su información.

PostgreSQL Global Development Group (1996-2011) define a las transacciones como elementos clave sobre todos los sistemas de bases de datos, pudiendo efectuar con estos elementos varios pasos dentro de uno mismo, u operaciones de todo o nada (es decir, o se efectúa todo un bloque de operaciones o no se efectúa ninguno). Los estados intermedios entre estos pasos no son visibles a otras transacciones, y en caso de la ocurrencia de algún error se prevé que la transacción se cancele sobre todos los pasos que la componen.

Si te fijas, la definición de transacciones que da PostgreSQL ® implica ciertas características importantes de los sistemas de bases de datos. Éstas características se conocen como ACID:

• Atomicity (Atomicidad).- Se considera a cada transacción como una unidad de trabajo, o un bloque de operaciones, indicando con esto que o el trabajo se realiza en su totalidad (todo el bloque que comprende la transacción) o no se efectúa ninguna operación.
• Coherency (Coherencia).- La transacción mantiene la coherencia de los datos, es decir, que si los datos están en un momento (estado) correcto antes de la transacción, también lo deben estar después de ella.
• Isolating (Aislamiento).- Cada transacción se comporta como si fuera la única transacción dentro del sistema. Una transacción no tiene la posibilidad de ver las fases intermedias de otra transacción, hasta que terminan.
• Durability (Durabilidad o Permanencia).- Si una transacción se realiza de forma satisfactoria, el sistema garantiza que los datos se mantienen aunque el equipo falle (Microsoft, 2011). 

Como puedes ver, el SMBD hace demasiadas cosas por nosotros, y precisamente, es el principio que trataremos de exponer aquí con nuestra aplicación en la base de datos, o se efectúa el bloque de operaciones que hayamos designado, o bien, no se efectúa ninguna, simulando que estamos comprando vía Internet, o directamente en el Banco, realizamos operaciones, y si hubo algún error en un momento determinado, regresaremos a un estado anterior de la transacción.

Para ello, retomaremos la información que nos proporciona PostgreSQL Global Development Group (1996-2011) en su sitio Web, para el manejo esencial de las transacciones en su SMBD. De entrada, algunos conceptos y comandos básicos:

• BEGIN;.- Comando que indica el inicio de una transacción.
• ROLLBACK;.- Retroceso a el estado anterior al inicio de la transacción.
• COMMIT;.- Cumplimiento del bloque de transacción y aseguramiento de la persistencia de los datos que contiene dicha transacción.
• SAVEPOINT nombrePunto;.- Generación de un punto intermedio de la transacción para regresar a dicho punto más que al inicio de la transacción.

Bueno, puede parecer confuso hasta este momento, pero hagamos un ejemplo sencillo, y luego se expondrá un video. Vamos siguiendo estos pasos:

BEGIN;

Select * from toperaciones;

Update toperaciones set ctienda=’ABCD’;

Select * from toperaciones;

ROLLBACK;

Select * from toperaciones;

COMMIT;

Parece extraño este código pero no lo es. Vamos explicándolo:

1. Iniciamos el bloque de transacción con el comando “BEGIN;”
2. Consultamos todos los registros de nuestra tabla “toperaciones” apareciendo en pantalla. 
3. Actualizamos TODOS los registros cambiando el nombre de la tienda (¡oh!, un error severo). 
4. Volvemos a consultar todos los registros y vemos que se ha hecho la actualización de los datos (técnicamente, el error). 
5. Efectuamos un “ROLLBACK;” para regresar nuestra base de datos a su estado anterior. 
6. Realizamos la consulta y vemos que todos nuestros datos persisten, es decir, se canceló la transacción regresando al punto inicial de la misma.
7. Finalizamos la transacción con el comando “COMMIT;”.

Está interesante esta aplicación, pero podemos hacer más operaciones aún, utilizando los puntos de salvado (“savepoints”) para regresar a un punto determinado de la operación, y no solo al principio de la transacción:

BEGIN;

Select * from toperaciones;

Delete from toperaciones where ctienda=’Aurrera’;

Select * from toperaciones;

SAVEPOINT puntoguardado;

Delete from toperaciones;

Select * from toperaciones;

ROLLBACK TO puntoguardado;

Select * from toperaciones;

COMMIT;

La explicación de las operaciones:

1. Iniciamos la transacción con el comando “BEGIN;”.
2. Consultamos todos los registros de la tabla.
3. Borramos todos los registros cuya tienda sea “Aurrera”, aclarando, esto no podremos recuperarlo posteriormente, pues está después del punto de guardado.
4. Consultamos la tabla y vemos que se han borrado dichos registros.
5. Generamos un punto de almacenamiento (al cual regresaremos) llamado “puntoguardado”.
6. Borramos todos los registros.
7. Consultamos que si se hayan borrado todos los registros (¡oh!, error nuevamente).
8. Regresamos pero al punto guardado, no al inicio de la transacción, mediante el comando “ROLLBACK TO”.
9. Consultamos y vemos que regresan todos los registros, excepto los que cuya tienda fuera “Aurrera”.
10. Finalizamos la transacción con el comando “COMMIT;”.

Puede parecer un poco extraño este funcionamiento, pero en el siguiente video se da la explicación del uso de las transacciones utilizando la línea de comandos:

Video 1. Fundamento empírico de las transacciones en línea de comandos.

Con esto concluimos la explicación del primer punto, el uso de las transacciones dentro de nuestro SMBD. Ahora es momento de generar nuestra aplicación simulando las operaciones bancarias, donde tendrá las siguientes características de funcionamiento:

• Se retomará el código pasado de las altas de datos (ventas) y consultas de datos.
• Elegiremos cada qué número de operaciones se tendrá una consistencia de los datos (de 5 a 10 registros). 
•  En caso de algún error se regresará al estado anterior siempre y cuando no se haya cumplido el número de operaciones de almacenamiento definidas (por ejemplo, si elegimos bloques de 5 operaciones, y efectuamos 6, solo podremos retroceder 1 operación, permaneciendo las 5 operaciones previas).

Mucho ruido y pocas nueces, vamos a ver cómo quedaría nuestro programa en vista de diseño:

·         Formulario: nombre “Form1”.

o   Botones:

“btnEjecutaConsulta”, texto “Ejecuta consulta”.

“btnCancelaConsulta”, texto “Cancela consulta”.

“btnAltaDatos”, texto “Ingresa venta”.

“btnEstableceRetroceso”, texto “Establece retroceso”.

“btnErrorOperacion”, texto “Error en operación”.

o   Cuadros de texto:

“txtCliente”, texto “1111222233334444”.

“txtCantidad”, texto “100.50”.

“txtTienda”, texto “Walmart”.

o   Etiquetas:

“lblNumeroCliente”, texto “Cliente: “.

“lblCantidad”, texto “Cantidad: “.

“lblTienda”, texto “Tienda: “.

o   Cuadros de opción:

“cmbEstableceRetroceso”, texto “5”, lista de datos: 5, 6, 7, 8, 9, 10.

o   Visor de datos (DataGridView): dgrDatos.

Tu formulario debe tener la siguiente forma:

Figura 1. Formulario bajo nuevo diseño:

Todo perfecto, es momento de explicar su código, que con respecto al tema pasado si ha cambiado un poco, pero trataremos de explicarlo lo más coherente posible, empecemos con las variables globales (les llamo variables aunque técnicamente según Visual Studio ® deberían ser objetos, pero bueno):

    Public conexion As OdbcConnection

    Public comando As OdbcCommand

    Public adaptador As OdbcDataAdapter

    Public conjunto As DataSet

    Public cantidadOperaciones As Integer

    Public contador As Integer

    Public puntosSalvados As Integer

    Public puntoUltimo As String

Las primeras cuatro variables las habíamos explicado anteriormente, por ello no se repetirán. Donde entra en juego ahora la transacción es en las siguientes variables:

1. cantidadOperaciones.- Variable que irá almacenando cuántas operaciones se irán almacenando, y cada que lleguemos al valor predeterminado, se reiniciará.
2. contador.- Variable común para recorrer las operaciones que llevamos.
3. puntosSalvados.- Variable que almacena los bloques de transacciones, por ejemplo, si establecidos el almacenamiento cada 5 operaciones, y llevamos 10 registros, esta variable tendrá un valor de 2, si llevamos 12, valdrá igual 2, si llevamos 15, valdrá 3, etc.
4. puntoUltimo.- Variable de tipo texto que almacena el último punto de retorno almacenado por nuestra aplicación.

El código correspondiente al inicio de la aplicación (la carga del formulario principal), que cambiará un poco respecto a lo que manejamos anteriormente:

        conexion = New OdbcConnection("dsn=odbcpostgres;uid=;pwd=;")

        comando = New OdbcCommand

        comando.Connection = conexion

        adaptador = New OdbcDataAdapter

        conjunto = New DataSet

        conexion.Open()

        MsgBox("Conexion establecida...", vbInformation)

        dgrDatos.Enabled = False

        btnEjecutaConsulta.Enabled = False

        cmdCancelaConsulta.Enabled = False

        cmdAltaDatos.Enabled = False

        lblNumeroCliente.Enabled = False

        txtCliente.Enabled = False

        lblCantidad.Enabled = False

        txtCantidad.Enabled = False

        lblTienda.Enabled = False

        txtTienda.Enabled = False

        btnErrorOperacion.Enabled = False

        puntosSalvados = 1

Nuevamente, existe código ya repetido del tema pasado (la conexión, la inicialización, etc.), lo único que cambia aquí es lo siguiente:

1. Estamos “inhabilitando” diversos elementos de nuestro programa, específicamente aquellos que implican realizar operaciones, hasta que no se haga la elección del tamaño de transacciones de nuestro bloque.
2. La variable “puntosSalvados” se inicializa con un valor de 1 (uno), puesto que estamos en el primer bloque de transacción.

El código que corresponde ahora es el del establecimiento de la cantidad de operaciones para nuestra transacción:

        dgrDatos.Enabled = True

        btnEjecutaConsulta.Enabled = True

        cmdCancelaConsulta.Enabled = True

        cmdAltaDatos.Enabled = True

        lblNumeroCliente.Enabled = True

        txtCliente.Enabled = True

        lblCantidad.Enabled = True

        txtCantidad.Enabled = True

        lblTienda.Enabled = True

        txtTienda.Enabled = True

        btnErrorOperacion.Enabled = True

        cantidadOperaciones = CInt(cmbEstableceRetroceso.Text)

        contador = 1

        btnEstableceRetroceso.Enabled = False

        cmbEstableceRetroceso.Enabled = False

Nada del otro mundo, salvo los siguientes detalles:

1. Todo lo que teníamos “inhabilitado” se habilitará en este momento, pues como ya elegimos la cantidad de operaciones a considerar para nuestra transacción, podemos ya efectuar dichas operaciones.
2. Inhabilitamos todo lo que tenga que ver con la elección de operaciones para la transacción, pues ya definimos previamente el tamaño.
3. La variable “cantidadOperaciones” almacenará el bloque de operaciones que hayamos elegido del cuadro de opciones previamente.
4. Se inicializa “contador” con un valor de 1 (uno) pues estamos en la primer operación.

Tras haber definido el bloque de transacciones es momento de ver los códigos que ya teníamos anteriormente, el de efectuar la consulta:

        comando.CommandText = "select * from toperaciones"

        adaptador.SelectCommand = comando

        conjunto.Clear()

        adaptador.Fill(conjunto)

        dgrDatos.DataSource = conjunto.Tables(0).DefaultView

Y el código de cancelar la consulta:

        dgrDatos.DataSource = Nothing

No se dan más detalles sobre los mismos puesto que ya habían sido explicados en el tema pasado y sería un tanto redundante comentarlos nuevamente. Vamos con el primer código interesante, el de ingresar una venta, recordando que ciertas fracciones de código ya fueron dadas en el tema pasado:

        Dim fechahora As Date

        Dim fecha As String

        Dim hora As String

        If (txtCantidad.Text = "" Or txtCliente.Text = "" Or txtTienda.Text = "") Then

            MsgBox("Error, dejaste algún parámetro sin contenido...", vbCritical)

        Else

            fecha = ""

            hora = ""

            fechahora = DateTime.Now

            fecha = fechahora.Year & "/"

            If fechahora.Month < 10 Then

                fecha = fecha & "0" & fechahora.Month & "/"

            Else

                fecha = fecha & fechahora.Month & "/"

            End If

            If fechahora.Day < 10 Then

                fecha = fecha & "0" & fechahora.Day

            Else

                fecha = fecha & fechahora.Day

            End If

            If fechahora.Hour < 10 Then

                hora = hora & "0" & fechahora.Hour & ":"

            Else

                hora = hora & fechahora.Hour & ":"

            End If

            If fechahora.Minute < 10 Then

                hora = hora & "0" & fechahora.Minute & ":"

            Else

                hora = hora & fechahora.Minute & ":"

            End If

            If fechahora.Second < 10 Then

                hora = hora & "0" & fechahora.Second

            Else

                hora = hora & fechahora.Second

            End If

            If contador = 1 Then

                comando.CommandText = "BEGIN;"

                comando.ExecuteNonQuery()

                comando.CommandText = "SAVEPOINT punto" & puntosSalvados & ";"

                puntoUltimo = "punto" & puntosSalvados

                comando.ExecuteNonQuery()

            End If

            comando.CommandText = "insert into toperaciones values ('" & fecha & "','" & hora & "','" & txtCliente.Text & "'," & txtCantidad.Text & ",'" & txtTienda.Text & "')"

            comando.ExecuteNonQuery()

            comando.CommandText = "select * from toperaciones"

            adaptador.SelectCommand = comando

            conjunto.Clear()

            adaptador.Fill(conjunto)

            dgrDatos.DataSource = conjunto.Tables(0).DefaultView

            MsgBox("Venta realizada exitosamente...", vbInformation)

            contador = contador + 1

            If (contador > cantidadOperaciones) Then

                puntosSalvados = puntosSalvados + 1

                contador = 1

                comando.CommandText = "COMMIT;"

                comando.ExecuteNonQuery()

            End If

        End If

Las fracciones de código que nos competen en estos momentos se explicarán a continuación:

1. Si el contador vale uno (1) entonces es señal de que deberemos efectuar el inicio de la transacción, mediante la ejecución del comando “BEGIN;”.
2. Generamos el punto de almacenamiento, mediante el comando “SAVEPOINT”, pasando como parámetro extra el punto en el cual nos encontramos (como se explicó anteriormente).
3. Almacenamos la posición del punto en la variable “puntoUltimo”.
4. Efectuamos el alta de los datos, tal y como hicimos en el tema pasado (“insert into toperaciones values….”).
5. Las siguientes sentencias implican que tan pronto vamos insertando los datos en la tabla “toperaciones” se va actualizando el “DataGridView” (que este código es igual al de las consultas, por eso no se especifica más de él).
6. Se incrementa la variable “contador”, para ver cuántas operaciones llevamos.
7. Si el contador es mayor que el número válido de operaciones que tenemos (cantidadOperaciones), incrementamos el número de “puntosSalvados” en uno (1), reiniciamos el “contador”, y terminamos el bloque de transacción con uso del comando “COMMIT;”.
8. Esto puede parecer extraño pero recuerda que determinamos que cada “N” operaciones se iba a generar el guardado de las mismas, y no podríamos regresar al punto anterior a ellas dentro de nuestro programa.

La última fracción de código que nos interesa es la de ejecución del botón en caso de ocurrir algún problema con nuestras operaciones (efectuar un “ROLLBACK;”):

        If contador <> 1 Then

            comando.CommandText = "ROLLBACK TO " & puntoUltimo & ";"

            comando.ExecuteNonQuery()

            MsgBox("Operación regresada al estado anterior...", vbInformation)

            comando.CommandText = "select * from toperaciones"

            adaptador.SelectCommand = comando

            conjunto.Clear()

            adaptador.Fill(conjunto)

            dgrDatos.DataSource = conjunto.Tables(0).DefaultView

            contador = 1

        End If

La explicación del código:

1. Si el contador es distinto de uno (1), señal de que llevamos más de una operación.
2. Efectuamos un “ROLLBACK;” al punto que nosotros hayamos definido mediante el uso de la variable “puntoUltimo”.
3. Mostramos un mensaje indicando esta situación.
4. Volvemos a consultar todos los datos para reflejar el cambio dentro del “DataGridView”.
5. Si no llevamos ninguna operación de inicio del bloque de transacción, simplemente no podemos efectuar ninguno de estos comandos.

Listo, ya tenemos nuestra aplicación funcionando, pero, pues vamos a explicarla a detalle para ir demostrando su funcionamiento, de igual forma se ubicará un video explicando el funcionamiento de la aplicación. Empecemos con el inicio de la aplicación:

Figura 2. Interfaz inicial de la aplicación.

Vamos definir un bloque de transacción de 5 operaciones (es decir, cada 5 ventas se almacenará la información y no podremos regresar a un estado anterior):

Figura 3. Establecimiento del bloque de transacción.

Teniendo todo esto, ingresemos tres (3) ventas dentro de la tabla de operaciones:

Figura 4. Ventas ingresadas dentro de la tabla.

Generemos un error en la operación:

Figura 5. Mensaje informativo de retorno al punto anterior.

Vemos como dentro del “DataGridView” hemos regresado al punto anterior, señal de que hemos efectuado adecuadamente el “ROLLBACK;”. Vamos más allá, ingresemos siete (7) operaciones, cinco (5) operaciones con una tienda, y dos (2) operaciones con otra tienda:

Figura 6. Siete operaciones dentro de nuestra aplicación.

Hagamos la ejecución del error en la operación, y vemos cómo únicamente recuperamos las primeras cinco (5) operaciones, tal y como definimos dentro de nuestro bloque de transacciones:

Figura 7. Recuperación del bloque de transacción.

Si aún tras demostrar el funcionamiento de esta aplicación en este marco, tuvieras alguna duda, puedes observar el siguiente video, donde se demuestra, en tiempo real, el funcionamiento de esta aplicación que acabamos de generar:

Video 2. Sistema de transacciones en Visual Studio ®.

Con esto terminamos la utilización de las bases de datos, vinculadas con un lenguaje de programación, y mediante el uso de transacciones demostrando las propiedades ACID de los SMBD. Como se expresó, si algún motivo implica que el Banco, u otro servicio de cobranza, se ha hecho un cobro injusto, no le eches la culpa al SMBD, sino más bien a la aplicación que fue realizada (o a los hábiles vendedores que pasan dos veces tu tarjeta de crédito, ja, ja, ja).

Recuerda que se pueden armar cursos acorde a tus necesidades, tanto de sistemas computacionales, tecnologías educativas y educación en general, o bien, apoyo para tareas y desarrollo de proyectos conforme lo necesites. Actualmente ofrecemos los siguientes cursos ya disponibles y armados para su impartición conforme lo necesites:
 

• Programación en Java con Swing.
• Programación de sistemas Pocket PC.
• Programación de Sistemas Palm.
• Programación en lenguaje C (fundamentos de programación).
• Programación en PHP.
• Fundamentos de Bases de Datos.

De igual forma, la enseñanza es en línea, se resuelven dudas vía correo electrónico, chat, foros de discusión y distintos medios para que siempre estés comunicado y al pendiente de todo, y dispones del material completo vía Internet para su disposición cuando lo quieras, al momento que quieras y cuantas veces quieras. Para ello contamos con una plataforma de enseñanza en línea con varias herramientas para que estudies y aprendas de la mejor forma, a tu ritmo, conforme tus necesidades y enfatizando la comunicación en todo momento.

Pregunta por los cursos existentes o bien, si deseas, se te puede armar un curso acorde a tus necesidades de aprendizaje. Recordándote, tenemos (y podemos armar) cursos de los siguientes temas:

• Sistemas Computacionales.
• Control asistido por computadora.
• Paquetes informáticos.
• Lenguajes de programación.
• Bases de datos.
• Tecnologías educativas.
• Educación en general.

Referencias.

• Microsoft (2011). Propiedades ACID. Portal Web de MSDN Microsoft. Recuperado el 20 de Julio, 2011 de http://msdn.microsoft.com/es-es/library/aa719484%28v=vs.71%29.aspx
• PostgreSQL Global Development Group (1996-2011). 3.4. Transactions. Portal Web de PostgreSQL en su apartado de documentación técnica, capítulo 3, características avanzadas. Recuperado el 20 de Julio, 2011 de http://www.postgresql.org/docs/8.3/static/tutorial-transactions.html

Para descargar.

Si deseas descargar la información en formato de Microsoft ® Word para su posterior lectura, así como el código fuente de la aplicación, da click al enlace correspondiente:

• Información en Microsoft ® Word: Enlace.
• Código fuente de la aplicación: Enlace.