Unidad vgestion de base de datos

Electiva II. Gambas
Prof. Leany Gonzalez
Unidad N. 5
Gestión de Bases de datos con Gambas,
Conexión y Creación de bases de datos
Conectándonos a una base de datos
Antes que nada es necesario activar el componente de Bases de datos (gb.db) en la pestaña
componentes de la ventana propiedades en el menú Proyecto, luego se puede usar un código como
este:
PUBLIC HConn AS Connection
PUBLIC SUB Main()
HConn = NEW Connection
HConn.Type = "mysql"
HConn.Host = "localhost"
HConn.Login = "root"
HConn.Password = ""
HConn.Name = "basedatos"
Hconn.Open
END
En la primera línea declaramos una variable de tipo Connection yo la hice pública que pueda ser
usada en otros módulos del proyecto en dado caso
En el procedimiento Main creamos primero el objeto y luego colocaremos algunos datos
necesarios para iniciar la conexión, cabe destacar que estos datos son los unicos que deben modificarse,
por ejemplo, el codigo anterior funcionará tanto para mysql, si quieres conectarte usando SQLite solo
tendrías que colocar la ruta de la base de datos en la propiedad Host e ignorar las propiedades Login y
Password, para conectar con ODBC es relativamente mas complicado, aquí les dejo Un Link con un
tutorial al respecto.
Crear una base de datos
En el ejemplo anterior tenemos la siguiente linea de código:

Electiva II. Gambas
La propiedad Name indica el nombre de la base de datos a la que nos queremos conectar, pero
es posible que esa base de datos aún no exista, en ese caso nos daria el siguiente error:
Cannot open database: Unknown database ‘basedatos’
Podemos modificar el código para crear la base de datos en caso de que esta no exista, por
ejemplo:
PUBLIC HConn AS Connection
PUBLIC SUB Main()
HConn = NEW Connection
HConn.Type = "mysql"
HConn.Host = "localhost"
HConn.Login = "root"
HConn.Password = ""
HConn.Open
IF NOT HConn.Databases.Exist("basedatos") THEN
HConn.Databases.Add("basedatos")
ENDIF
HConn.Close
Hconn.Open
END
Se pueden ver varios cambios, en primer lugar se observa que ya no se nombra la base de datos
antes de abrir la conexión, primero se verifica con esta linea:
IF NOT HConn.Databases.Exist("basedatos") THEN
Si existe o no la base de datos, si no existe la creamos con la siguiente función:
HConn.Databases.Add("basedatos")
Luego que ya se tiene la base de datos creada debemos cerrar la conexión para nombrar la base
de datos como parámetro:

Electiva II. Gambas
HConn.Close
Hconn.Open
Ya con esto nos evitamos la posibilidad de que ocurra un error al no existir la base de datos, claro que
una base de datos contiene tablas y campos que también pueden crearse desde el código
Bases de datos con Gambas, creación de tablas y
campos
Ahora que ya se sabe como crear una base de datos y conectarnos a ella, procederemos a crear tablas y
sus respectivos campos en esa base de datos.
DIM hTabla as Table
hTabla = $hConn.Tables.Add("tabla")
hTabla.Fields.Add("id", db.Serial)
hTabla.Fields.Add("campo1", gb.String, 16, "Sin Nombre")
hTabla.Fields.Add("campo2", db.Integer,, 1)
hTabla.Fields.Add("campo3", gb.Date)
hTabla.Fields.Add("campo3", gb.Boolean)
hTabla.Fields.Add("campo4", gb.Float)
hTabla.PrimaryKey = ["id"]
hTabla.Update
Primero se declara una variable de tipo Table, luego con la función:
hTabla = $hConn.Tables.Add(Nombre_De_La_Tabla)
Se crea una nueva tabla en la base de datos que guardaremos en hTabla. El siguiente paso es crear los
campos, para eso usamos la función:
hTabla.Fields.Add(Nombre, Tipo, Tamaño, Valor_Por_Defecto)
El primer parámetro es el nombre del campo.
El segundo parámetro es el tipo de dato que va a guardarse allí, los tipos disponibles son:
db.Blob = -2

Electiva II. Gambas
db.Serial = -1
db.Boolean = 1
db.Integer = 4
db.Long = 5
db.Float = 7
db.Date = 8
db.String = 9
Se asume que los nombres de las constantes se definen por si mismas por eso no se explican, a
excepción de db.Serial, esta constante define el tipo de datos auto_increment.
Luego está el tamaño del campo, y el valor por defecto, eso tampoco necesita mucha explicación.
Cuando ya se tienen todos los campos creados establecemos (en este caso) el campo “id” como clave
primaria, se darán cuenta en la linea
hTabla.PrimaryKey = ["id"]
Vemos que “id” está entre corchetes, esto es porque la variable PrimaryKey es una String Array por lo
que podemos agregar más de una clave primaria.
Al final actualizamos la tabla y listo, ya tenemos una tabla con sus campos.
Manejo de Registros en una base de datos
(Crear, Buscar, Modificar y Eliminar)
Ahora viene el manejo de las funciones más básicas en una Base de datos.
Transacciones
Cuando se haba de una transacción en una base de datos nos referimos a una serie de cambios que, o
todas tienen éxito o todas fracasan, por ejemplo, si estamos intentando cambiar un registro, pero en
alguno no coindiden los tipos, entonces todo el proceso se tiene que revertir y no se guarda nada.
Crear Registros
Lo primero que hacemos es iniciar la transacción con
$hConn.Begin

Electiva II. Gambas
Luego creamos un objeto Result con el método Create
hRes = $hConn.Create("tabla")
Esto nos crea un registro vacío donde vamos a establecer los datos del registro:
hRes!campo1 = "Registro #1"
hRes!campo2 = 300
hRes!campo3 = Date(Now())
hRes!campo4 = TRUE
hRes!campo5 = 2235644.232
El objeto Result también puede usarse como un Array para guardar los datos, sería algo como esto:
hRes["campo1"] = "Registro #1"
hRes["campo2"] = Rnd(200, 20000)
hRes["campo3"] = Date(Now())
hRes["campo4"] = TRUE
hRes["campo5"] = 2235644.232
Una ventaja al hacerlo de esta manera es que podemos por ejemplo usar variables en lugar de cadenas,
pudiendo optimizar más el código, las opciones son variadas.
Luego se actualiza el registro, para guardar estos datos:
hRes.Update
Con esto nos aseguramos de que ingresen los datos al registro, finalmente cerramos la transacción:
$hConn.Commit
En caso de error echamos todo el proceso para atrás:
CATCH
$hConn.Rollback
Podemos ver el código completo acá:
DIM hRes as Result
$hConn.Begin
hRes = $hConn.Create("tabla")
hRes!campo1 = "Registro #1"

Electiva II. Gambas
hRes!campo2 = Rnd(200, 20000)
hRes!campo3 = Date(Now())
hRes!campo4 = TRUE
hRes!campo5 = 2235644.232
hRes.Update
$hConn.Commit
CATCH
$hConn.Rollback
Buscar Registros
Para buscar un registro podemos usar el método Find del objeto Collection:
hRes = $hconn.Find("tabla") ' Esto es equivalente a SELECT * FROM tabla
Esto crea un objeto Result de solo lectura que nos guardará, en este caso buscamos todos los datos que
están guardados en la tabla, podemos filtrar con la clausula where de esta manera:
hRes = $hconn.Find("tabla", "campo2 < 10000") ' Esto es equivalente a SELECT * FROM tabla
WHERE campo2 < 10000
Con esta tendremos como resultado todos los registros cuyo valor para campo2 sea menor a 10000.
Solo nos queda enumerar la salida
FOR EACH hRes
PRINT hRes!campo1
PRINT hRes!campo2
PRINT hRes!campo3
PRINT hRes!campo4
PRINT hRes!campo5
NEXT
Al final el código nos queda así:
DIM hRes AS Result
hRes = $hconn.Find("tabla", "campo2 < 10000")

Electiva II. Gambas
FOR EACH hRes
PRINT hRes!campo1
PRINT hRes!campo2
PRINT hRes!campo3
PRINT hRes!campo4
PRINT hRes!campo5
NEXT
Editar un Registro
Lo primero que debemos hacer es iniciar una transacción
$hconn.Begin
Luego creamos un objeto Result de lectura y escritura usando la función Edit de la clase Connection,
al igual que la función Find usaremos como primer parametro el nombre de la tabla y como segundo
parametro la clausula where para obtener resultados mas precisos.
hRes = $hconn.Edit("tabla", "campo2 < 10000")
En este caso buscará todos los registros cuyo valor de campo2 sea menor a 10000, generalmente se
busca editar un solo registro, para esto buscamos por ejemplo el campo que sea clave primaria que en
nuestro ejemplo es id.
Ahora editamos los campos.
FOR EACH hRes
hRes!campo1 = "Campo con valor menor a 10000"
hRes.Update
NEXT
En este caso iremos registro por registro editando campo1, es importante que luego se coloque la linea
hRes.Update para guardar los registros, si solo van a editar un registro no necesitar usar el FOR
EACH.
Otra cuestión que hay que acotar es sobre el limite que le colocamos a los campos, si recordamos se
había creado campo2 como un campo de tipo string y una longitud de 16 caracteres pero en la edición
colocamos una cadena de 29, no nos dará error pero si vemos el resultado solo nos guardará “Campo
con valor “.
Finalizamos cerrando la transacción.
$hconn.Commit

Electiva II. Gambas
O devolviendola si ha ocurrido un error.
CATCH
$hconn.Rollback
El código completo se vería así.
DIM hRes AS Result
$hconn.Begin
hRes = $hconn.Edit("tabla", "campo2 < 10000")
FOR EACH hRes
hRes!campo1 = "Campo con valor menor a 10000"
hRes.Update
NEXT
$hconn.Commit
CATCH
$hconn.Rollback
El método Exec
Si alguno de métodos anteriores se queda corto siempre podemos crear nuestras propias sentencias
SQL usando el el metodo Exec
hRes = hConn.Exec("Tu sentencia SQL")
Este método siempre va a devolver un objeto Result aunque no será necesario en todos los casos.

Electiva II. Gambas
Diseño de una Base de Datos
Una base de datos no se empieza pensando qué pantallas vas a rellenar o qué dato será
obligatorio: Se empieza identificando las "Entidades" (Clases) que intervienen en ella.
Los Tipos de Entrada, los modos y formatos de salida, la cualidad de sus relaciones, etc.
etc. eso vendrá después. En otras palabras hay que olvidarse, de momento, de nada que no sea
las propiedades de las Clases. Yo prefiero la palabra "Entidad" que implica que de lo se habla tiene
"existencia" por sí misma, dejando eso de "Clases" para la POO a la hora de diseñar el
programa.
Como norma general se puede identificar "Entidad" con "TablaMaestra" (hay entidades
complejas, pero eso es otra historia). Por ejemplo se habla de manejar en el diseño de: Libros,
Autores, Editoriales, Citas, Tesis.
Se empieza por eso: Pregúntate Qué es y de Qué se compone un Libro, un Autor, una
Cita, etc. Eso te dará los campos y su tipo de una forma natural.
Es evidente que
-Un libro tiene: Título, Autor, editorial, Nº de páginas, etc.
-Un Autor tiene: Un nombre, una fecha de nacimiento, un país de nacimiento, una biografía,
una bibliografía, etc. etc.
-Una Cita tiene: Un texto, un libro de referencia, una página donde aparece, un libro, o varios,
donde es citada, etc. etc.
En el desarrollo de esto verás que el tipo de dato lo marca la naturaleza del mismo y
empezarán a surgir las relaciones entre ellos. Por ejemplo el número de página donde aparece la
cita no puede ser mayor que el número de páginas del libro, etc. También te encontrarás que, a
lo mejor, te aparecen entidades en las que, de entrada, no habías pensado. Por ejemplo, una
Tesis tiene un Autor, no confundir con el autor de los libros que se citan ¿Será necesario también
una tabla de autores de Tesis? ¿Qué características tendría?, etc. etc.
Una vez que tengas diseñadas las características (campos) de tus "Entidades" (tablas
maestras), tendrás que relacionarlas entre sí (esta es la esencia de lasBases de
Datos Relacionales), de forma que se constituyan en una estructura de datos coherentes y eficaz.
Para ello necesitas encontrar primero que todo la Clave Primaria de cada Entidad, es
decir qué identifica cada fila de una forma única y definitiva entre todas las de su clase y
construir los índices que apunten a esas claves. Así una editorial tiene un Id
del registro mercantil, Un libro un ISBN, etc. Esto es básico: Dos libros pueden tener el mismo
título, dos Autores el mismo nombre, etc. Puedes construir tus claves mediante la unión de
varios campos, Título+Autor o puedes crear campos que sirvan de índice (autonuméricos) para
ello.
Con los indices construidos se establecerán las relaciones entre las tablas. Así, en
la tabla de libro, campo editorial, almacenaremos la clave de la tabla editoriales, para lo que

Electiva II. Gambas
crearemos una relación Padre-Hijo (Foreign key) y la base de datos misma se encargará de
mantener la coherencia y de que no haya claves pérdidas o referencias ciegas.
En este paso verás que no es posible, muchas veces, establecer una relación directa y sencilla,
por ejemplo: Un autor ha escrito varios libros. Un libro puede tener varios co-autores. La
solución más sencilla entonces es la creación de una tabla de enlace intermedia. Una tablaque se
componga exclusivamente de tres campos: índice de la relación, clave el autor, clave del libro.
Finalmente, una vez que tengas la estructura creada, es conveniente hacer una serie
de vistas que simplifiquen las consultas más frecuentes que luego usaremos en el programa.
Por ejemplo: una vista que contenga todos los campos del libro y todos los de su autor
(recordemos que en la tabla de libros sólo tenemos la clave de la tabla del autor). Almacenando
estas vista, seremos capaces de mostrar al usuario los datos que necesite de manera muy
sencilla.
Hay mucho más, claro, pero más o menos estos son los pasos básicos para el diseño de
una base de datos. Todo el tiempo que dediques a esto, será tiempo ganado en la
programación. Un error de programación se arregla, a las malas, en unas horas. Un error en el
diseño de la base de datos puede costarte meses o, incluso, hacer inútil todo tu proyecto.
El diseño de tu base de datos es la esencia de tu programa.
Esquema de Gambas - Gestores de Bases de Datos
Este es un esquema que representa como un programa realizado en Gambas accede a una base
de datos.
En primer lugar, comentar, que el acceso a la base de datos no es directo, se realiza mediante los
gestores de Bases de Datos, que pueden ser 5: SQLite, MySQL, PostgreSQL, Firebird y Odbc. Estos
son los que se comunican directamente con la base de datos.

Electiva II. Gambas
En este programa, lo primero que haremos en conectar con el gestor de base de datos dándole
los datos necesarios para que encuentre la base de datos.
Luego se procederá a mandar las distintas consultas en el lenguaje SQL al gestor, que nos
devolverá (objeto result), con los resultados de obtenidos al ejecutar la consulta en la base de datos.
Finalmente, una vez obtenidas todas las consultas necesarias o antes te terminar el programa,
tendremos que desconectarnos del gestor.
Crear/Editar una Base de datos
Para usar una base de datos en nuestros programas, primero hay que crearlas. Dependiendo del
tipo podemos crearlas según:
* Para el tipo MySQL podemos usar phpMyAdmin
* Para el tipo SQLite podemos usar Sqlite Data Brower.
Pero Gambas3, posee su propio entorno para crearla y modificarla.
Programas:
phpMyAdmin: Para crear bases de datos MySQL

Electiva II. Gambas
SQLite Data Browser
Gestor de Bases de datos de Gambas3: Desde Conexiones en Gambas3
Para usar esta opción de Gambas3, tenemos que activar los componentes: gb.db, gb.db.form y
según el tipo de base de dato que usemos (MySQL, SQLite3, PostgreSQL o ODBC) activaremos uno
de estos controladores. (menú Proyecto/Propiedades/Componentes)

Electiva II. Gambas
Una vez que tenemos activados estos componentes, nos aparece en el ide una nueva carpeta en
el proyecto:
Si se hace click con el botón derecho del ratón sobre "Conexiones", aparecerá un menú donde
se puede elegir "Crear Nueva Conexión". Si pulsamos nos aparece este formulario:

Electiva II. Gambas
En el combobox "Tipo", podemos elegir el tipo (MySQL, SQLite3, PostgreSQL o ODBC), y
también variarán los datos necesarios a rellenar.
Aquí podemos darnos cuenta que no aparece ninguna opción de crear una nueva base de datos.
Pero si se pulsa el botón lateral de la etiqueta "Base de datos",
y se escribe algo en la etiqueta,por ejemplo "a", aparecerá un botón con la opción de "Crear base de
datos"
De esta forma se puede crear la base de datos y estaremos entrando en el modo de edición de la
base de datos. Donde se pueden crear las tablas y definir los campos que tendrán. Aquí vemos el botón
"crear tabla"

Electiva II. Gambas
Captura de pantalla mientras se estaban creando Campos:

Electiva II. Gambas
Además se pueden introducir datos:
y hacer consultas SQL:
Conexiones y Resultados: Connection y Result
La Clase Connection:
Esta clase representa una conexión a una base de datos.
¿Cómo nos conectamos a la base de datos?
Se crea un objeto del tipo Connection, asignandole las propiedades necesarias (tipo de base de

Electiva II. Gambas
datos, lugar donde se encuentra, usuario, contraseña, etc,), y le llama al método Open para abrirla.
* Si por ejemplo queremos conectarnos a una base de datos tipo MySQL, seria así:
PUBLIC $Con AS NEW Connection 'definimos $Con como publica para poder ser usada en todos los
módulos y formularios de la aplicación
PUBLIC SUB Conectar()
$Con=Null ' anulo por si hay conexiones ya abiertas
$Con.Type = "MySQL" ' definimos el tipo
$Con.Host = "localhost" ' definimos el servidor
$Con.Login = "root" ' nombre de usuario con el que conectamos
$Con.Port = "3306" ' puerto al que conectamos
$Con.Name = "Sophia" ' nombre de la base de datos a la que vamos a conectarnos
$Con.Password = "root123" ' contrasela del usuario
TRY $Con.Open() ' abrimos la conexión, y vamos a comprobar si se produce un error...
IF ERROR THEN
Message.error("Error al intentar conectarse a la base de datos")
PRINT ERROR.TEXT
PRINT ERROR.CODE
PRINT ERROR.WHERE
ENDIF
END
* Si queremos conectarnos a una base de datos tipo SQLite3, sería así:
PUBLIC $Con AS NEW Connection 'definimos $Con como publica para poder ser usada en todos
los módulos y formularios de la aplicación
$Con=Null ' anulo por si hay conexiones ya abiertas
$Con.Type = "sqlite3" ' definimos el tipo
$Con.Host = user.home & "/directorio" ' definimos directorio donde se encuentra la base de
datos
$Con.Name = "test" ' nombre de la base de datos a la que vamos a conectarnos
TRY $Con.Open() ' abrimos la conexión
IF ERROR THEN
PRINT ERROR.TEXT
PRINT ERROR.CODE

Electiva II. Gambas
PRINT ERROR.WHERE
ENDIF
END
Nota Importante:
* Si hemos creado la conexión desde el Gestor de Conexiones de Gambas3, es mucho más fácil, la
podemos usar directamente así:
PUBLIC $Con AS NEW Connection 'definimos $Con como pública para poder ser usada en todos los
módulos y formularios de la aplicación
$Con= Connections["Connection1"]
IF $Con=NULL THEN
ENDIF
END
Conectando a una base de datos, usando las conexiones creadas desde el Gestor de bases de datos de
Gambas3

Electiva II. Gambas
¿Cómo nos desconectamos a la base de datos?
Para cerrar se usa el método Close.
$Con.Close()
¿como hacemos para confirmamos una operación con los datos?
$Con.Commit()
Al final de este material se tiene un ejemplo donde se insertar, edita, borra y búsqueda de datos
con las funciones de connection: .create, .edit, .delete, y .find
¿Cómo hacer una consulta de modo genérica con sentencias SQL?
Se usa el método .Exec(sentencia_Sql)
Ejecuta una petición SQL dada y devuelve un objeto Result de sólo lectura que contiene el
resultado de la solicitud de sentencia devolución.
PUBLIC SUB Consulta()
DIM $Query AS String
$Query = "SELECT * FROM Friends WHERE Name = '" & TBXName.Text & "'"
$Con.Exec($Query)
END
La clase Result:
¿Cómo operamos con los resultados de una consulta?
Usamos un objeto de la clase Result, llamando a los distintos campos para asignarlos a las
variables.
Para llamar a los campos lo hacemos de esta forma:
Dim $result as result
....
$result!NombreCampo
También se puede usar:
$result["NombredeCampo"]
La clase result, tiene varios métodos para desplazarnos en las consultas: movefist, movelast,
movePrevius, moveNext, moveTo

Electiva II. Gambas
A continuación un ejemplo usando result para desplazarnos por los registros:
En este ejemplo, cagamos una base de datos con una tabla de 2 campos (nombre y edad), y
mostramos los botones para que el usuario pueda desplazarse con ellos por los registros:
Código fuente:
Modulo ModComun:
' Gambas module file
Private hconn As Connection
Public Function ConectarBase() As Connection
hconn = Connections[“Connection1”]
if hconn = Null then
Message.Info(“Error al conectarse a la base de datos”)
else
Return hconn
Endif
Return Null
End
Código Fuente:
Fmain:
' Gambas class file

Electiva II. Gambas
Private hresult As Result
Public Sub _new()
End
Public Sub Form_Open()
hconn = ModComun.ConectarBase()
hresult = hconn.Exec("select * from personas") 'para tener todos los registros en
el hresul
'relleno etiquetas..
LabelTotalRegistros.text = " de " & Str$(hresult.count)
'cargo primer registro
ButtonPrimero_Click()
End
Public Function mostrarRegistro() As Boolean
If hresult.Available Then
TextBoxNombre.text = hresult["nombre"]
ValueBoxEdad.value = hresult["edad"]
ValueBoxRegistro.value = hresult.Index + 1
Return True 'ok, ha sido posible mostrar datos
else
Message.Info("No es posible desplazarse más")
Endif
Return False 'no ha sido posible ir a ese registro
End
Public Sub ButtonPrimero_Click()
hresult.MoveFirst
mostrarRegistro()
End
Public Sub ButtonSiguiente_Click()
If (hresult.index + 1) < hresult.count Then
hresult.MoveNext
mostrarRegistro()

Electiva II. Gambas
Endif
End
Public Sub ButtonAnterior_Click()
If hresult.Index > 0 Then
hresult.MovePrevious
mostrarRegistro()
Endif
End
Public Sub ButtonUltimo_Click()
hresult.MoveLast
mostrarRegistro()
End
Public Sub ValueBoxRegistro_KeyPress()
'ir a un registro determinado... escribiendo el numero y la tecla Enter o Return
If Key.code = Key.enter Or Key.code = Key.Return Then
If hresult.MoveTo(ValueBoxRegistro.value - 1) = False Then
mostrarRegistro()
Else
Message.Info("No existe ese registro")
Endif
Endif
End

Electiva II. Gambas
Un ejemplo completo de insertar, editar, borrar y buscar:
En este este programa vamos a poder insertar, editar, borrar y realizar búsquedas en una base de datos
llamada "DatosEjemplos", que tiene una tabla llamada "Personas".
Los campos de esta tabla son: nombre, apellidos, edad y la fecha de nacimiento
La estructura del proyecto es la siguiente:
Código fuente:
Modulo ModComun:
' Gambas module file
Public Function ConectarBase() As Connection
hconn = New Connection
hconn.host = User.home &/ ".ejemploBD"

Electiva II. Gambas
hconn.name = "DatosEjemplos"
hconn.type = "sqlite3"
Try hconn.Open()
If Error Then
Message.Info("Error al conectarse a la base de datos")
Print Error.Text
Print Error.Where
Print Error.Code
Else
Return hconn
Endif
Return Null
End
Public Function copiarBase()
If Exist(User.home &/ ".ejemploBD/DatosEjemplos") Then
'existe el archivo, no hago nada.
Else
Try Mkdir User.home &/ ".ejemploBD"
Try Copy "DatosEjemplos" To User.home &/ ".ejemploBD/DatosEjemplos"
Endif
End
Módulo fuente:
FormMostrarResultados
' Gambas class file
Private hresult As Result
'ajuste la posición de la ventana al lado del formulario principal
ColumnViewTabla.PopupMenu = "Menu1"
'formateo columview
formato()
'cargo los datos en el columview
recarga("")
End
Public Sub formato()
With ColumnViewTabla
.Columns.count = 5

Electiva II. Gambas
.Columns[0].text = "id"
.Columns[0].Width = 20
.Columns[1].text = "Nombre"
.Columns[2].text = "Apellidos"
.Columns[3].text = "Edad"
.Columns[4].text = "Fecha nacimiento"
End With
End
Public Sub recarga(sentenciaSQL As String)
ColumnViewTabla.Clear
formato()
If sentenciaSQL = "" Then
hresult = hconn.Exec("Select * from Personas")
Else
hresult = hconn.Exec(sentenciaSQL)
Endif
'relleno los datos
RellenarColumnView(hresult)
End
Public Sub RellenarColumnView(resultado As Result)
Dim clave As String
ColumnViewTabla.Clear
formato()
'relleno los datos
Do While resultado.Available
clave = resultado["id"]
ColumnViewTabla.Add(clave, clave)
ColumnViewTabla[clave][1] = resultado["nombre"]
ColumnViewTabla[clave][2] = resultado["apellidos"]
ColumnViewTabla[clave][3] = resultado["edad"]
ColumnViewTabla[clave][4] = Format(resultado["fecha_nacimiento"], "dd/mm/yyyy")
resultado.MoveNext
Loop
End
Public Sub Menu1Editar_Click()
hresult = hconn.Edit("Personas", "id=&1", ColumnViewTabla.Current.key)

Electiva II. Gambas
FMain.SetActivoModoEditor(hresult)
End
Public Sub Menu1Borrar_Click()
hconn.Delete("Personas", "id=&1", ColumnViewTabla.Current[0])
'cargo los datos en el columview
recarga("")
End
Public Sub Menu1Buscar_Click()
Dim cadena As String
cadena = InputBox("Busqueda por nombre:", "Filtrar contenido de nombre", "")
cadena = "%" & cadena & "%" 'uso % para busquedas por contendio
hresult = hconn.Find("Personas", "nombre like &1", cadena) 'solo busco en el
campo "nombre"
RellenarColumnView(hresult)
End
Public Sub Menu1QuitarFiltro_click()
'quito el filtro, mostrando todos los registros
recarga("")
End
Módulo fuente:
Fmain:
' Gambas class file
Public hconn As Connection
Public hresult As Result
Public ideditando As Integer
Public Sub _new()
End
Me.x = FormMostrarResultados.w + 10
Me.y = FormMostrarResultados.y + 20

Electiva II. Gambas
'copio la base de datos... al disco duro
ModComun.copiarBase()
'muestro resultados
FormMostrarResultados.Show()
'conectar a la base de datos...
'modo insertar:
ButtonAnade.tag = "insertar"
End
Public Sub ButtonAnade_Click()
If ButtonAnade.tag = "insertar" Then
'Una forma de hacerlo:
'hconn.Exec("insert into Personas values (&1,&2,&3,&4,&5)", Null,
TextBoxNombre.text, TextBoxApellidos.text, ValueBoxEdad.value, DateBoxFecha.value)
'Otra forma de hacerlo:
hresult = hconn.Create("Personas")
hresult["id"] = Null
hresult["nombre"] = TextBoxNombre.Text
hresult["apellidos"] = TextBoxApellidos.Text
hresult["edad"] = ValueBoxEdad.Value
hresult["fecha_nacimiento"] = DateBoxFecha.Value
'actualizamos valores
hresult.Update
hconn.Commit
'hconn.Close()
FormMostrarResultados.recarga("")
Else
'editando
hresult["nombre"] = TextBoxNombre.Text
hresult["apellidos"] = TextBoxApellidos.Text
hresult["edad"] = ValueBoxEdad.value
hresult["fecha_nacimiento"] = DateBoxFecha.value
'actualizo los datos
hresult.Update()
hconn.Commit()
FormMostrarResultados.recarga("")
'fin de editar
ButtonAnade.tag = "insertar"
ButtonAnade.text = "Añadir Registro"
Frame1.text = "Añadir Registro"
TextBoxNombre.Text = ""

Electiva II. Gambas
TextBoxApellidos.Text = ""
ValueBoxEdad.value = 0
DateBoxFecha.value = 0
Endif
End
Public Sub SetActivoModoEditor(data As Result)
ButtonAnade.tag = "editando"
ButtonAnade.text = "Actualizar Registro"
Frame1.text = "Editando Registro"
hresult = data
TextBoxNombre.text = data["nombre"]
TextBoxApellidos.text = data["apellidos"]
ValueBoxEdad.Value = data["edad"]
DateBoxFecha.value = data["fecha_nacimiento"]
End
Public Sub ButtonSalir_Click()
hconn.Close()
FormMostrarResultados.Close()
Me.Close
End
Ejemplo de la aplicación funcionando:
Varias cosas a comentar:
1) El propio programa tiene la base de datos internamente, que la copia al directorio User.home &/
".ejemploBD" si no la encuentra en el disco duro.
2) Si pulsáis el botón derecho del ratón en alguna fila del ColumView, tendréis acceso al menú
popup :"Editar/Borrar/Filtrar/Quitar Filtro"

Electiva II. Gambas
3) Se han usado los métodos de la clase connection para editar, insert, borrar y filtrar información.
También se podía haber echo con sentencias SQL y usando el método .Exec()
4) El esquema de la tabla Personas:
El campo Id es una llave primaria integer, la cual se autoenumera cuando le damos valor Null.
5) Las fechas se guardan internamente en la base de datos en el formato mes/dia/año, por eso para
mostrarlas en el columnview uso el formateo "dd/mm/yyyy".
Para mostrarla en el formulario Fmain (añade o edita registros), al usar un DateBox, automáticamente
se formatea correctamente.

Unidad vgestion de base de datos

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (19)

Similar a Unidad vgestion de base de datos

Similar a Unidad vgestion de base de datos (20)

Más de Sol Hernández

Más de Sol Hernández (20)

Último

Último (20)

Unidad vgestion de base de datos