# Administración de conexiones: dba.* Las funciones `dba.*` de `dbr.dkh` administran el **repositorio de conexiones** desde un programa: crean bases de datos y registros de conexión, los consultan, listan y eliminan. Sirven para instaladores, para dar de alta la base de un cliente nuevo y para herramientas de soporte. Para hacerlo desde la consola sin programar, use la utilidad `dba` (ver [DDM](/es/devkron/2.0/bibliotecas/ddm/)). El repositorio local es el archivo `connections.xml` (ver [conexiones](/es/devkron/2.0/bibliotecas/motor/dbr/)). El proceso necesita permiso de escritura sobre él. ## Funciones | Función | Qué hace | |---|---| | `dba.addapp(app)` | Agrega una aplicación (grupo de conexiones) vacía | | `dba.delapp(app)` | Elimina una aplicación | | `dba.apps(qn)` | Lista de cadenas con los nombres de aplicación. `""` o `"*"` = repositorio local; un nombre cualificado de conexión = repositorio en esa base de datos | | `dba.cnns(app)` | Lista de cadenas con los nombres de conexión de la aplicación | | `dba.cnnexists(qn)` | `@true` si existe la conexión `qn` (nunca lanza error) | | `dba.getconnection(qn)` | Registro con los datos de la conexión: `Engine`, `Host`, `Port`, `UserName`, `Password`, `DefaultSchema`… (como texto) | | `dba.createconnection(qn, info, predeterminada, sqldic)` | Registra una conexión a una base **existente**. `info` es un registro con `Engine` y los datos del motor; `predeterminada` (`@true`/`@false`) la marca como la de `@app`; `sqldic` es la ruta de un diccionario de consultas SQL (normalmente `""`). Crea la aplicación si no existe. Se guarda cifrada | | `dba.newconnection(qn, info)` | Igual que `dba.createconnection(qn, info, @false, "")` | | `dba.createschema(qn, info, predeterminada, sqldic)` | Registra la conexión **y crea la base de datos** `DefaultSchema` en el servidor | | `dba.createdb(qn, info)` | Igual que `dba.createschema(qn, info, @false, "")` | | `dba.delconnection(qn)` | Elimina el registro de la conexión (no borra la base de datos) | | `dba.createrepo(repo, base)` | **(2.0.2)** Crea las tablas de un repositorio de conexiones en base de datos (`AppDB`, `CnnDB`, `DicDB`) en la base de la conexión local `repo`, o en la base nueva `base` si no es `""`. Vea [Repositorios de conexiones en base de datos](/es/devkron/2.0/instalacion/repositorio-conexiones.md) | | `dba.repoinfo()` | **(2.0.2)** Registro con el estado de la caché de repositorios del proceso: `cached`, `open`, `max`, `idle_sec`, `sqldic`, `local_reads`, `local_generation` | | `dba.getconnectionset(qn)` | Referencia al objeto del repositorio (local, o en base de datos si `qn` lleva `/`). Para extensiones .NET; en DKL casi no se usa | Los campos de `info` son los mismos de la tabla [Datos de conexión por motor](/es/devkron/2.0/bibliotecas/motor/dbr/): `Engine` (`MY_SQL`, `SQL_SERVER`, `POSTGRE_SQL`, `FB_SQL`), `Host`, `Port`, `UserName`, `Password`, `DefaultSchema`, `SSLMode`, `WindowsAuthMode`, `NameSpaceSchema`, `Parameters`. ## Ejemplo Primer programa: crea la aplicación `ventas`, una base nueva con su conexión y dos conexiones más (una predeterminada): ```dkl #include "dkli.dkh" #! program "dba" { #include "functions.dkh" #include "serialize.dkh" #include "dbr.dkh" do print(to.json(dba.apps(""))) do dba.addapp("ventas") do print(to.json(dba.apps("*"))) new info { @"Engine": "MY_SQL" @"Host": "127.0.0.1" @"Port": 3307 @"UserName": "bib_doc" @"Password": "MiClave#2026" @"DefaultSchema": "ventas_demo" @"SSLMode": 0 } do dba.createdb("sucursal1@ventas", info) do print(dba.cnnexists("sucursal1@ventas")) do print(to.json(dba.cnns("ventas"))) ref ci = dba.getconnection("sucursal1@ventas") do print(field.str(ci, "Engine") + " " + field.str(ci, "Host") + " " + field.str(ci, "DefaultSchema")) ref db = dbr.open("sucursal1@ventas") do print(dbr.str(db, "SELECT DATABASE()", @null)) do dbr.close(db) info<"DefaultSchema">: "tienda" do dba.newconnection("matriz@ventas", info) do dba.createconnection("respaldo@ventas", info, @true, "") do print(to.json(dba.cnns("ventas"))) do print(dba.cnnexists("nada@ventas")) } ``` ```text ["tienda"] ["tienda","ventas"] 1 ["sucursal1"] MY_SQL 127.0.0.1 ventas_demo ventas_demo ["sucursal1","matriz","respaldo"] 0 ``` Segundo programa (otra ejecución): usa la conexión predeterminada y limpia lo creado: ```dkl #include "dkli.dkh" #! program "dba2" { #include "functions.dkh" #include "serialize.dkh" #include "dbr.dkh" ref db = dbr.open("@ventas") do print(dbr.full_qname(db) + " -> " + dbr.str(db, "SELECT DATABASE()", @null)) do dbr.close(db) do dba.delconnection("respaldo@ventas") do print(dba.cnnexists("respaldo@ventas")) ref cs = dba.getconnectionset("@ventas") do print(isnull(cs)) do dba.delconnection("sucursal1@ventas") do dba.delconnection("matriz@ventas") do dba.delapp("ventas") do print(to.json(dba.apps(""))) } ``` ```text @ventas -> tienda 0 0 ["tienda"] ``` - El repositorio local se carga **una vez por proceso**: las conexiones creadas aparecen de inmediato en `dba.cnns`, pero `dbr.open("@ventas")` encontró la nueva predeterminada en la ejecución siguiente. Desde 2.0.2, `dbr.open` de un nombre local que **no existía** vuelve a leer `connections.xml` si cambió y la encuentra sin reiniciar; lo que no provoca una falla (otra predeterminada, una conexión modificada que sigue abriendo) requiere reiniciar el servidor FastCGI ([detalle](/es/devkron/2.0/instalacion/conexiones.md)). - `dba.getconnection` devuelve la contraseña en claro: no la imprima ni la mande en una respuesta. - `dba.delconnection` y `dba.delapp` no borran bases de datos. ## Repositorio de conexiones en una base de datos Además del archivo local, el repositorio puede vivir en una base de datos (tablas `AppDB`, `CnnDB` y `DicDB`), con el diccionario de consultas de su motor que trae la distribución en `SQLDic/` (desde 2.0.2; antes había que indicar `mysql_connections_repo.sqldic` en la conexión del repositorio). Se crea con `dba.createrepo` o con la herramienta `tools/dbrepo/dbrepo.dkl`: vea [Repositorios de conexiones en base de datos](/es/devkron/2.0/instalacion/repositorio-conexiones.md). Las funciones lo usan cuando el nombre cualificado lleva la forma `repositorio@app/conexión@app2`: `dbr.open("conexiones@miempresa/sucursal1@ventas")` abre `sucursal1@ventas` leyendo sus datos de la base a la que apunta `conexiones@miempresa`, y `dba.apps("conexiones@miempresa")` lista sus aplicaciones. Es el mecanismo que usan los servicios multiempresa para no tener un `connections.xml` por cliente. ## Errores típicos | Mensaje | Causa | Solución | |---|---|---| | `Debe indicar el atributo 'Engine'` | `info` sin `Engine` | Agregue `@"Engine": "MY_SQL"` (u otro) | | `Nombre cualificado incorrecto o mal formado` | `qn` sin `conexión@aplicación` | Use `nombre@app` | | `No se pudo eliminar la conexión` / `No se pudo eliminar la aplicación` | No existe | Compruebe con `dba.cnnexists` / `dba.apps` | | `Access to the path '…connections.xml' is denied.` | Sin permiso de escritura | Ajuste permisos del archivo para el usuario del proceso | | `Imposible continuar, no ha definido el diccionario de consultas necesario` | Repositorio en base de datos sin diccionario SQL | Desde 2.0.2, revise que la carpeta `SQLDic/` de la distribución esté junto a `dkl`; en 2.0.1 y anteriores, configure `mysql_connections_repo.sqldic` en la conexión del repositorio | [Regresar a dbr.dkh](/es/devkron/2.0/bibliotecas/motor/dbr/)