# Tablas en memoria: table, row, cell y col Una **tabla** es una tabla de datos en memoria (`System.Data.DataTable` de .NET) con columnas con nombre y tipo, y filas. La devuelven `dbr.table` (resultado de una consulta SQL), `table.create`, `table.new`, `table.from` y `table.pivot`. Sirve para recorrer resultados de una consulta por fila y columna, armar reportes y hacer tablas cruzadas. - Filas y columnas tienen **índice base cero**. - Las funciones con sufijo `c` (`cell.strc`, `cell.numc`…) reciben el **nombre** de la columna; las demás, su índice. - Una celda puede ser nula (`DBNull`), por ejemplo un `NULL` de la base de datos o una columna que no se llenó al agregar la fila. ## Estructura y filas | Función | Devuelve | Qué hace | |---|---|---| | `table.create(registro)` | Tabla nueva | Una columna por cada campo **no nulo** del registro, con el tipo de su valor (cadena, número, fecha) | | `table.new()` | Tabla nueva | Tabla vacía, sin columnas | | `table.rows(tabla)` | Número | Cantidad de filas; -1 si la tabla es `@null` | | `table.cols(tabla)` | Número | Cantidad de columnas; -1 si la tabla es `@null` | | `row.add(tabla, registro)` | Índice de la fila nueva | Agrega una fila al final con los campos del registro que coinciden con columnas; los demás campos se ignoran y las columnas sin dato quedan nulas | | `row.ins(tabla, fila, registro)` | Índice de la última fila | Inserta una fila en la posición `fila` | | `row.upd(tabla, fila, registro)` | `fila` | Actualiza la fila con los campos del registro que coinciden con columnas | | `row.del(tabla, fila)` | 1 | Elimina la fila | | `row.get(tabla, fila)` | Registro | Todos los valores de la fila; las celdas nulas quedan como campo nulo | ## Leer celdas | Función | Columna por | Si la celda es nula | |---|---|---| | `cell.str(tabla, fila, columna)` / `cell.strc(…)` | índice / nombre | Devuelve nulo (concatenarlo con texto da `Tipos no coinciden`) | | `cell.num(tabla, fila, columna)` / `cell.numc(…)` | índice / nombre | Excepción `Object cannot be cast from DBNull to other types.` | | `cell.dstr(tabla, fila, columna, default)` / `cell.dstrc(…)` | índice / nombre | Devuelve `default` | | `cell.dnum(tabla, fila, columna, default)` / `cell.dnumc(…)` | índice / nombre | Devuelve `default` | | `cell.obj(tabla, fila, columna)` / `cell.objc(…)` | índice / nombre | Devuelve `@null`; si no, una referencia al valor (útil para fechas) | Use `cell.dstrc` y `cell.dnumc` siempre que la columna admita `NULL` en la base de datos. ## Escribir celdas y columnas | Función | Qué hace | |---|---| | `cell.set(tabla, fila, columna, valor)` / `cell.setc(…)` | Asigna una celda; devuelve `@true`. El valor se recibe **como objeto**: funciona con cadenas no numéricas y con referencias, pero un número (o una cadena numérica entera) se toma como índice de objeto y falla. Para números use `row.upd` con un registro | | `col.caption(tabla, columna, título)` / `col.captionc(tabla, nombre, título)` | Asigna el título de la columna (lo usa `table.to`) | | `col.get(tabla, columna)` / `col.getc(tabla, nombre)` | Referencia al objeto `DataColumn`; se leen sus propiedades con `_get` (`ColumnName`, `Caption`, `DataType`) | ## Ejemplo completo ```dkl #include "dkli.dkh" #! program "tablas" { #include "functions.dkh" #include "serialize.dkh" new modelo { @"sku": "" @"descripcion": "" @"existencia": 0 } ref t = table.create(modelo) do print(str(table.rows(t)) + " filas, " + str(table.cols(t)) + " columnas") new a { @"sku": "P-01" @"descripcion": "Café 1 kg" @"existencia": 12 } new b { @"sku": "P-02" @"descripcion": "Azúcar 1 kg" @"existencia": 0 } new c { @"sku": "P-00" @"descripcion": "Sal" @"otra": "se ignora" } do print(row.add(t, a)) do print(row.add(t, b)) do print(row.ins(t, 0, c)) do print(table.rows(t)) do print(cell.str(t, 1, 0) + " | " + cell.strc(t, 1, "descripcion")) do print(cell.num(t, 1, 2) + cell.numc(t, 2, "existencia")) do print(cell.dnumc(t, 0, "existencia", -1)) do print(cell.dnum(t, 0, 2, -1)) do print(cell.dstrc(t, 0, "existencia", "(nulo)") + " " + cell.dstr(t, 0, 2, "(nulo)")) do print(isnull(cell.objc(t, 0, "existencia"))) do print(cell.numc(t, 0, "existencia")) exception { do print(last_error()) do clear_exceptions() } do cell.setc(t, 0, "descripcion", "Sal de mar") do cell.set(t, 2, 1, "Azúcar morena 1 kg") new cambio { @"existencia": 5 } do print(row.upd(t, 0, cambio)) ref fila = row.get(t, 0) do print(to.json(fila)) do col.caption(t, 0, "Clave") do col.captionc(t, "existencia", "Existencia") ref col = col.getc(t, "existencia") do print(_get(col, "Caption") + " " + _get(col, "ColumnName")) ref col0 = col.get(t, 0) do print(_get(col0, "Caption")) do print(row.del(t, 1)) do print(to.json(t)) ref vacia = table.new() do print(table.cols(vacia)) do print(@count(t)) ref f = @item(t, 0) do print(field.str(f, "sku")) } ``` ```text 0 filas, 3 columnas 0 1 2 3 P-01 | Café 1 kg 12 -1 -1 (nulo) (nulo) 1 {1} Error en 'cell.numc. (Object cannot be cast from DBNull to other types.Exception has been thrown by the target of an invocation.) [tablas.dkl][Ln= 43] 0 {"sku":"P-00","descripcion":"Sal de mar","existencia":5} Existencia existencia Clave 1 {"Table":[["P-00","Sal de mar",5],["P-02","Azúcar morena 1 kg",0]]} 0 2 P-00 ``` La fila `P-00` se insertó sin `existencia` (su registro no tenía ese campo), por eso esa celda es nula hasta el `row.upd`. `to.json` de una tabla produce `{"NombreTabla": [[fila], [fila]]}`; `@count` y `@item` de `functions.dkh` también funcionan con tablas. ## Tabla cruzada: table.pivot `table.pivot(tabla, x, y, z, valor_nulo, sumar)` devuelve una tabla nueva que "gira" la original: - `x`: columna cuyos **valores distintos** se convierten en columnas (si es `""` se usa la primera columna); - `y`: columna cuyos valores distintos forman las **filas** (será la primera columna del resultado); - `z`: columna con los **valores** de las celdas; - `valor_nulo`: texto para las celdas sin dato (`""` las deja nulas); - `sumar`: con `@true`, los valores que caen en la misma celda **se suman**; con `@false` queda el último. `y` y `z` son obligatorios (si falta alguno: `The columns to perform inversion are not provided`). Todas las columnas del resultado son de texto. ```dkl #include "dkli.dkh" #! program "pivot" { #include "functions.dkh" #include "serialize.dkh" new m { @"mes": "" @"sucursal": "" @"venta": 0 } ref t = table.create(m) ref datos = from.json("[{\"mes\":\"ene\",\"sucursal\":\"Centro\",\"venta\":100},{\"mes\":\"ene\",\"sucursal\":\"Norte\",\"venta\":50},{\"mes\":\"feb\",\"sucursal\":\"Centro\",\"venta\":70},{\"mes\":\"ene\",\"sucursal\":\"Centro\",\"venta\":30}]") go foreach.lobj(value:r) with(datos) { do row.add(t, r) } ref p = table.pivot(t, "mes", "sucursal", "venta", "0", @true) do print(str(table.rows(p)) + " x " + str(table.cols(p))) for i=0; i La documentación 1.x decía que `sumar` agregaba "una fila adicional con las sumatorias". No es así (tampoco en 1.x): suma los valores repetidos de la misma celda, como el `130` de Centro en enero (100 + 30). ## Guardar y leer una tabla como texto: table.to y table.from - `table.to(tabla)` devuelve la tabla serializada como código DKL (estructura de columnas con tipo y título, y filas). Los tipos que admite son cadena, número, booleano y fecha; los nombres de columna deben ser identificadores válidos (sin espacios ni símbolos). - `table.from(cadena)` hace lo contrario: devuelve una tabla nueva a partir de ese texto. Sirve para guardar una tabla en un archivo (`file.wtext(ruta, table.to(t))`) y recuperarla después sin base de datos. Un texto que no tiene la forma de `table.to` da un error de sintaxis `{109}`. ## Errores típicos | Mensaje | Causa | Solución | |---|---|---| | `Object cannot be cast from DBNull to other types.` | `cell.num`/`cell.numc` sobre una celda nula | `cell.dnum`/`cell.dnumc` con valor predeterminado | | `Error en expresión: Tipos no coinciden` | Se concatenó el nulo que devuelve `cell.str` de una celda nula | `cell.dstr`/`cell.dstrc` | | `Couldn't store in X Column. Expected type is Decimal.` | `cell.set` con un número | `row.upd(t, fila, registro)` | | `Column 'x' does not belong to table Table.` | Nombre de columna inexistente en `cell.*c` | Revise los nombres (no distinguen mayúsculas) | | `There is no row at position n.` | Fila fuera de rango | Compare con `table.rows` | | `table.rows` devuelve -1 | La tabla es `@null`, por ejemplo `dbr.table` de una consulta sin filas | Compruebe `isnull(t)` | [Regresar a functions.dkh](/es/devkron/2.0/bibliotecas/motor/functions/)