source: tol/doc/general/guiatol.lyx

#LyX 1.3 created this file. For more info see http://www.lyx.org/
\lyxformat 221
\textclass book
\language spanish
\inputencoding auto
\fontscheme default
\graphics default
\paperfontsize default
\spacing single 
\papersize Default
\paperpackage a4
\use_geometry 0
\use_amsmath 0
\use_natbib 0
\use_numerical_citations 0
\paperorientation portrait
\secnumdepth 3
\tocdepth 3
\paragraph_separation indent
\defskip medskip
\quotes_language english
\quotes_times 2
\papercolumns 1
\papersides 1
\paperpagestyle default

\layout Standard


\begin_inset LatexCommand \tableofcontents{}

\end_inset 


\layout Chapter

Introducción
\layout Section

Definición y Objetivos
\layout Standard

Time Oriented Language, en adelante 
\family typewriter 
\series bold 
TOL
\family default 
\series default 
, es un lenguaje de programación diseñado para el análisis de series temporales
 y procesos estocásticos basado en la representación algebraica del tiempo
 y las series temporales que permite: 
\layout Itemize

Estructurar los datos procedentes de los sistemas operacionales, dándoles
 un soporte temporal y clasificador que los convierte en una información
 útil para comprender su comportamiento.
\layout Itemize

Analizar la información dinámica, generar modelos estadísticos, identificar
 los factores que influyen en el comportamiento temporal y extraer conocimiento
\layout Itemize

Facilitar la toma de decisiones a partir del conocimiento, de los modelos
 estadísticos, de las previsiones del comportamiento y de las funciones
 y opciones de decisión.
\layout Standard

El tiempo es una magnitud continua representable como la recta real pero
 al tratar con series temporales de naturaleza social como ventas, llamadas
 telefónicas, movimientos bancarios, asistencia a eventos, tráfico, etc.,
 se observan comportamientos ligados a diferentes características temporales
 como son los ciclos dentro de un periodo (que puede ser el día, la semana,
 el mes, el año ...); o la proximidad a festivos y cualesquiera otros eventos
 identificables con el momento en que ocurren.
\layout Standard

Tradicionalmente estos fenómenos se han representado por extensión, es decir,
 como una enumeración de eventos fabricada más o menos artesanalmente; lo
 cual no supone un problema muy grave para series anuales o mensuales como
 máximo.
 Pero la explosión de la información ha traído series diarias, horarias
 o de frecuencias aún más altas, para las que se hace necesario un tratamiento
 algebraico de este tiempo social que, a partir de una base de conjuntos
 temporales primarios y una colección de funciones, permitan construir analítica
mente conjuntos temporales complejos que representen los comportamientos
 sociales más intrincados.
\layout Standard

Por otro lado el lenguaje ha de ofrecer mecanismos de análisis estadístico
 de los datos, desde la lectura de los mismos en archivos o bases de datos
 a la producción de modelos predictivos pasando por los métodos de representació
n visual de la información que se hagan necesarios.
\layout Standard

Dentro de este contexto nace TOL para intentar dar respuesta a todas estas
 necesidades y a otras que han ido surgiendo durante el proceso de implementació
n y maduración del lenguaje.
\layout Section

Diseño
\layout Standard

Estas son algunas de las características técnicas más importantes del lenguaje
 y que más han influido en el diseño y la implementación de TOL .
\layout Itemize

El lenguaje TOL ha sido esarrollado en C++ por ser uno de los lenguajes
 más rápidos, potentes y versátiles que existen.
 Desde luego, también es uno de los más complicados y de los que más tiempo
 de formación requieren.
\layout Itemize

Se ha desarrollado con vocación multiplaforma y se ha compilado el código
 bajo Windows y bajo diferentes sistemas UNIX (LINUX, HPUX, AIX, IRIX y
 SOLARIS); intentando siempre que el código sea lo más compatible posible.
 No obstante, para algunas rutinas de bajo nivel no ha habido más remedio
 que hacer implementaciones ad hoc para cada sistema operativo.
\layout Itemize

El lenguaje dispone, prácticamente desde su inicio, de un entorno gráfico
 llamado TOLBASE que ha facilitado la labor del analista permitiéndole obtener
 representaciones gráficas de los objetos programados, como series temporales,
 conjuntos temporales, matrices, funciones, conjuntos, etc.
 Esta particularidad ha influido en la estructura del lenguaje pues los
 objetos definidos deben sobrevivir en memoria después del tiempo de ejecución
 del programa, al contrario de lo que ocurre con muchos otros lenguajes
 de programación.
\layout Itemize

TOL es un lenguaje de programación interpretado, lo cual facilita el uso
 y el aprendizaje de los analistas.
 En dos o tres meses se puede alcanzar un nivel de programación aceptable
 partiendo de personas sin formación informática específica y con poca o
 ninguna experiencia en programación.
\layout Itemize

Es un lenguaje fuertemente tipado aunque existe un tipo comodín llamado
 
\family typewriter 
Anything
\family default 
 que permite construir funciones que traten objetos de diferentes tipos,
 característica ésta de la que no conviene abusar.
\layout Itemize

TOL permite crear estructuras de datos y funciones de usuario con lo que
 el analista puede ampliar el lenguaje y adaptarlo a sus necesidades guardando
 en ficheros el código y organizándolo en librerías.
 El sistema TOL, de hecho, no sólo consta de código C++ sino que se complementa
 con una serie de librerías básicas.
 Sólo por razones de eficiencia conviene a veces crear algunas nuevas funciones
 en C++.
 
\layout Itemize

TOL admie recursividad en las funciones (monocíclica y policíclica); esto
 es, una función se puede llamarse a sí misma o a otras que a su vez llamen
 a otras y así sucesivamente hasta que alguna vuelva a llamar a la inicial.
 Esto ofrece grandes ventajas en cuanto a potencia y claridad del código
 pero no se debe abusar porque se carga demasiado la pila de llamadas y
 puede dar lugar a errores del tipo stack overflow.
\layout Itemize

Es un lenguaje autoevaluable, es decir, se puede usar el lenguaje para construir
 código TOL y evluarlo en tiempo de ejecución.
 Esta es una de las características más productivas de TOL a la hora de
 enfrentar problemas masivos en los que un código ha de ejecutarse muchas
 veces con variaciones derivadas de una cierta estructura de datos.
\layout Itemize

TOL es básicamente declarativo pues como ya se ha dicho, los objetos no
 son el medio sino el fin del lenguaje.
 Incluso las funciones son objetos de tipo Code y pueden ser argumentos
 de otras funciones y almacenarse en estructuras permitiendo la construcción
 de algoritmos complicados de forma estructural y no secuencial.A pesar de
 ello se han ido introduciendo algunas capacidades de control del flujo
 propias de los lenguajes secuenciales para dotar al programador de mayor
 potencia de implementación algorítmica.
 Por ser un lenguaje interpretado, el control de flujo es necesariamente
 más lento que en los lenguajes compilados.
 
\layout Itemize

Una de las tareas más complicadas de la programación es el manejo eficiente
 de la memoria por ser éste uno de los recursos más caros y limitados de
 la computadora.
 El manejo de memoria en TOL es dinámico y transparente al usuario, los
 objetos existen mientras son necesarios y desaparecen cuando nadie los
 usa, todo ello merced a un sistema de referencias.
\layout Itemize

Implementa una representación algebraica del tiempo que permite manipular
 conjuntos temporales y series temporales como objetos virtualmente infinitos,
 que no son representables por extensión como tipos de datos en el sentido
 clásico de la programación, sino que más bien son clases definidas por
 funciones que determinan su comportamientorequiriéndose un lenguaje de
 programación orientado al objeto como lo es C++.
 
\layout Itemize

Esto obliga a plantear un mecanismo de evaluación de tipo lazy, es decir,
 la evaluación del objeto se retrasa al momento en que es requerido por
 otro objeto, puesto que la información que lo constituye no puede ser enumerada
 sino que se construye la información necesaria cada vez que hace falta
 a partir de ciertos métodos intrínsecos.
 Este tipo de evaluación se ha extendido incluso a los tipos de datos que
 no lo precisarían, como los números, los textos y las fechas que si son
 almacenables en memoria de forma extensa.
 
\layout Chapter

Conceptos Básicos
\layout Section

Forma de un programa TOL
\layout Section

Palabras reservadas
\layout Section

Tipos de datos en TOL
\layout Chapter

Tipos de Datos en Tol
\layout Section

Números Reales
\layout Section

Cadenas
\layout Section

Polinomios
\layout Section

Matrices
\layout Section

Números Complejos
\layout Section

El tipo especial Code
\layout Section

El tipo especial Anything
\layout Section

Conjuntos
\layout Section

Estructuras
\layout Subsection

Formato de una estructura
\layout Subsection

Paso de estructuras a funciones
\layout Subsection

Conjuntos estructurados
\layout Chapter

Constantes, Operadores y Expresiones
\layout Section

Constantes
\layout Section

Operadores
\layout Section

Expresiones TOL
\layout Subsection

Expresiones simples
\layout Subsection

Declaraciones de variable
\layout Subsection

Expresiones compuestas
\layout Subsection

Expresiones anidadas
\layout Chapter

Sentencias de control de flujo
\layout Section

Sentencias booleanas
\layout Section

Sentencias de iteración
\layout Section

Sentencias de inclusión
\layout Chapter

Funciones
\layout Section

Funciones internas del lenguaje
\layout Section

Funciones especiales
\layout Subsection

Funciones de aplicación de métodos
\layout Section

Funciones de usuario
\layout Subsection

Forma general de una función
\layout Subsection

Reglas de ámbito de las funciones
\layout Subsection

Reglas de ámbito de las funciones
\layout Subsection

Retorno de una función
\layout Subsection

Recursividad
\layout Chapter

Series temporales
\layout Section

El Tiempo
\layout Section

Series temporales
\layout Chapter

Acceso a Bases de Datos
\layout Standard

TOl tiene una interfaz que permite efectuar múltiples operaciones sobre
 bases de datos.
\layout Standard

Para efectuar una operación sobre una base de datos determinada, en primero
 lugar debe abrirse; Después se ejecuta la operación para terminar cerrándola.
 El proceso es sencillo y se especifica detalladamente a continuación.
\layout Section


\begin_inset LatexCommand \label{sec:Apertura:-DBopen}

\end_inset 

Apertura: DBopen
\layout Standard

La función de TOL que abre una base de datos es 
\emph on 
DBOpen
\emph default 
.
 Su prototipo es como sigue:
\layout LyX-Code

Real DBopen (Text alias, Text usuario, Text clave [, Set estructuraDB]);
\layout Itemize

Argumentos:
\layout Description

alias: Especifica el nombre del alias a través del cual se van a controlar
 las operaciones efectuadas en las bases de datos abiertas.
 Debe ser único para cada base de datos, de forma que no se confundan las
 bases de datos usadas posteriormente.
 En el caso de acceso ODBC este alias coincide con el alias especificado
 en el sistema ODBC.
\layout Description

usuario: Especifica el nombre del usuario con el que se accede a la base
 de datos.
\layout Description

clave: La clave que acompaña al usuario en el acceso.
\layout Description

estructuraDB: Argumento opcional que permite el acceso a bases de datos
 de forma nativa.
 Su declaración puede depender del gestor al cual se accede, si bien en
 la mayoría de los casos se limitará al nombre del servidor y de la base
 de datos.
\layout Itemize

Valor devuelto:
\layout Standard


\emph on 
DBopen
\emph default 
 devuelve un 1 (Verdadero) en caso de éxito, y un 0 (Falso) en caso de error.
 En caso de error, un mensaje por pantalla ayudará a identificar el problema
 (Acceso denegado, alias ya existente, servidor no accesible, etc.).
\layout Subsection

ODBC
\layout Standard

La apertura de bases de datos ODBC bajo TOL es muy sencilla, ya que únicamente
 se hace necesario especificar el alias ODBC, un usuario y su clave de acceso.
 Por supuesto, la base de datos debe haber sido especificada previamente
 en el sistema ODBC.
\layout Itemize

Estructura:
\layout LyX-Code

Struct DBStructODBC
\layout LyX-Code

{
\layout LyX-Code

  Text driver
\layout LyX-Code

};
\layout Standard

Por compatibilidad con versiones anteriores de TOL, si el gestor no es especific
ado mediante el uso de esta estructura, se utilizará ODBC como gestor por
 defecto a la hora de abrir una base de datos, pero TOL avisará del uso
 erróneo mediante un mensaje.
\layout Itemize

Ejemplo de uso:
\layout LyX-Code

Struct DBStructODBC
\layout LyX-Code

{
\layout LyX-Code

  Text driver
\layout LyX-Code

};
\layout LyX-Code

Set db = DBStructODBC("odbc");
\layout LyX-Code

Real resultado = DBOpen(
\begin_inset Quotes eld
\end_inset 

Alias
\begin_inset Quotes erd
\end_inset 

,
\begin_inset Quotes erd
\end_inset 

usuario
\begin_inset Quotes erd
\end_inset 

,
\begin_inset Quotes erd
\end_inset 

passwd
\begin_inset Quotes erd
\end_inset 

,db);
\layout Standard

Como se ha explicado con anterioridad, por compatibilidad con versiones
 anteriores de TOL, también se permite el uso siguiente, que sería equivalente
 al anterior:
\layout LyX-Code

Real resultado = DBOpen(
\begin_inset Quotes eld
\end_inset 

Alias
\begin_inset Quotes erd
\end_inset 

,
\begin_inset Quotes erd
\end_inset 

usuario
\begin_inset Quotes erd
\end_inset 

,
\begin_inset Quotes erd
\end_inset 

passwd
\begin_inset Quotes erd
\end_inset 

);
\layout Standard

Este uso se considera erróneo y debe evitarse.
\layout Subsection

Acceso nativo
\layout Standard

Además de ODBC, TOL permite el acceso de forma nativa a múltiples gestores
 de bases de datos, consiguiendo de esta forma un acceso mas rápido y fiable.
\layout Standard

Si bien cada uno de estos gestores tiene un comportamiento completamente
 distinto, la interfaz de acceso a bases de datos de TOL ayuda a hacerlo
 de forma transparente.
\layout Standard

A continuación se especifica el comportamiento de cada uno de los gestores
 existentes.
\layout Subsubsection

mySQL
\layout Standard

La interfaz mySQL de TOL requiere tan sólo especificar el gestor, servidor
 y base de datos en la estructura detallada en la sección 
\begin_inset LatexCommand \ref{sec:Apertura:-DBopen}

\end_inset 

.
\layout Itemize

Estructura:
\layout LyX-Code

Struct DBStructMySQL {
\layout LyX-Code

  Text driver,
\layout LyX-Code

  Text database,
\layout LyX-Code

  Text host 
\layout LyX-Code

};
\layout Description

driver: Especifica el gestor a utilizar.
 En este caso concreto, su valor será 
\begin_inset Quotes eld
\end_inset 

mysql
\begin_inset Quotes erd
\end_inset 

.
\layout Description

host: Especifica el nombre o dirección IP del servidor de la base de datos.
 Ejemplos válidos son 
\begin_inset Quotes eld
\end_inset 

localhost
\begin_inset Quotes erd
\end_inset 

, 
\begin_inset Quotes eld
\end_inset 

server.domain.es
\begin_inset Quotes erd
\end_inset 

 y 
\begin_inset Quotes eld
\end_inset 

127.0.0.1
\begin_inset Quotes erd
\end_inset 

.
\layout Description

database: Especifica el nombre de la base de datos.
 Ejemplo: 
\begin_inset Quotes eld
\end_inset 

test
\begin_inset Quotes erd
\end_inset 

.
\layout Itemize

Ejemplo:
\layout LyX-Code

Struct DBStruct {
\layout LyX-Code

  Text driver,
\layout LyX-Code

  Text database,
\layout LyX-Code

  Text host 
\layout LyX-Code

};
\layout LyX-Code

Set db1 = DBStruct("mysql", "test", "localhost");
\layout LyX-Code

Real DBOpen("alias","root","",db1);
\layout Standard

Una vez abierta la base de datos, su comportamiento no varía con respecto
 al resto de gestores.
\layout Subsubsection

HuffmanByFields
\layout Standard

(En desarrollo y documentación)
\layout Subsubsection

Otros gestores
\layout Standard

La implementación de otros gestores de bases de datos está siendo llevada
 a cabo en estos momentos, y según sean considerados estables serán incorporados
 al lenguaje.
 Además, la interfaz permite el uso de cualquier tipo de soporte de almacenamien
to en el acceso, que no tiene por qué ser una base de datos, como pueda
 ser un fichero con un determinado formato.
\layout Section

Cierre: DBClose
\layout Standard

Una vez se haya terminado de usar una base de datos, ésta debe ser cerrada
 para liberar todos los recursos que TOL reserva para su utilización.
 Para hacer esto se cuenta con la función 
\emph on 
DBClose:
\layout LyX-Code

Real DBClose(Text aliasName);
\layout Standard

El único parámetro de DBClose especifica el alias con el cual la base de
 datos fué abierta con anterioridad.
 Un ejemplo correcto de apertura y cierre de dos bases de datos mysql y
 una ODBC con TOL sería:
\layout LyX-Code

//Especificacion de las estructuras necesarias:
\layout LyX-Code

Struct DBStructMySQL {
\layout LyX-Code

  Text driver,
\layout LyX-Code

  Text database,
\layout LyX-Code

  Text host 
\layout LyX-Code

};
\layout LyX-Code

Struct DBStructODBC {
\layout LyX-Code

  Text driver
\layout LyX-Code

};
\layout LyX-Code

//Apertura:
\layout LyX-Code

Set db1 = DBStructMySQL("mysql", "test", "localhost");
\layout LyX-Code

Real DBOpen("aliasTest","user","passwd",db1);
\layout LyX-Code

Set db2 = DBStructMySQL("mysql", "empresa", "myserver");
\layout LyX-Code

Real DBOpen("aliasEmpresa","user","passwd",db2);
\layout LyX-Code

Set db3 = DBStructODBC("odbc");
\layout LyX-Code

Real DBOpen("aliasName","user","passwd",db3);
\layout LyX-Code

//Cierre de las bases de datos abiertas:
\layout LyX-Code

Real DBClose(
\begin_inset Quotes eld
\end_inset 

aliasEmpresa
\begin_inset Quotes erd
\end_inset 

);
\layout LyX-Code

Real DBClose(
\begin_inset Quotes eld
\end_inset 

aliasTest
\begin_inset Quotes erd
\end_inset 

);
\layout LyX-Code

Real DBClose(
\begin_inset Quotes eld
\end_inset 

aliasName
\begin_inset Quotes erd
\end_inset 

);
\layout Section

Operaciones sobre bases de datos
\layout Standard

Existen varias funciones en TOL para efectuar operaciones sobre bases de
 datos.
 Los prototipos son:
\layout LyX-Code

Real DBExecQuery(Text consulta);
\layout LyX-Code

Set DBTable (Text consulta [, Text nombreEstructura]);
\layout LyX-Code

Matrix DBMatrix(Text consulta);
\layout LyX-Code

Set DBSeries(Text consulta, timeSet fechado, Set nombres 
\layout LyX-Code

  [, Set Set descripciones, Real valorDefecto=0]);
\layout LyX-Code

Set DBSeriesTable (Text consulta , TimeSet fechado, Set nombres
\layout LyX-Code

  [, Set descripciones, Real valorDefecto=0]);
\layout LyX-Code

Set DBSeriesColumn (Text consulta , TimeSet fechado 
\layout LyX-Code

  [, Real valorDefecto=0]);
\layout LyX-Code

Real DBSpool (Text consulta, Text fichero 
\layout LyX-Code

  [, Text cabecera="",Text separadorColumnas=";",
\layout LyX-Code

  Text separadorFilas=";",Real formateo=CIERTO ]);
\layout LyX-Code

Real DBCreateSeriesTable (Text nombreTabla, Set series 
\layout LyX-Code

  [, Text nombreFecha , Text tipoFecha, Text formatoFechas, 
\layout LyX-Code

  Set nombres]);
\layout Subsection

DBExecQuery
\layout Itemize

Qué hace: Ejecuta un comando en la base de datos activa.
 En el caso de comandos de extracción de datos no es posible acceder al
 contenido devuelto, por lo que se recomienda limitar esta función al uso
 de comandos de inserción, creación y borrado.
\layout Itemize

Valor devuelto: Devuelve el número de filas afectadas o (-1) en caso de
 error.
 Nótese que existen comandos SQL, como son 
\emph on 
drop
\emph default 
, 
\emph on 
create
\emph default 
 o similares, en los que el valor devuelto será cero aunque la consulta
 se haya efectuado correctamente.
 Además de estos casos, una consulta puede devolver cero filas y aún así
 tratarse de una llamada correcta.
 DBExecQuery devuelve un error (-1) únicamente en caso de imposibilidad
 de ejecución del comando.
\layout Itemize

Ejemplo de uso:
\layout LyX-Code

Real DBExecQuery(
\begin_inset Quotes eld
\end_inset 

create table prueba ( campo1 VARCHAR(5),
\layout LyX-Code

                                         campo2 INT,
\layout LyX-Code

                                         fechado DATE)
\begin_inset Quotes erd
\end_inset 

);
\layout Subsection

DBTable
\layout Itemize

Qué hace: Ejecuta un comando en la base de datos activa.
 Al contrario que 
\emph on 
DBExecQuery
\emph default 
, 
\emph on 
DBTable
\emph default 
 devuelve un conjunto con los datos leídos.
 Estos datos deben ser de tipo numérico, texto o fecha.
\layout Itemize

Valor devuelto: Devuelve un conjunto con los datos leídos o un conjunto
 vacío en caso de error.
\layout Itemize

Ejemplo de uso:
\layout LyX-Code

Set conjunto = DBTable(
\begin_inset Quotes eld
\end_inset 

select dni, nombre, apellido from empleados
\begin_inset Quotes erd
\end_inset 

);
\layout Subsection

DBMatrix
\layout Itemize

Qué hace: Ejecuta un comando en la base de datos activa.
 Su funcionamiento es similar a 
\emph on 
DBTable
\emph default 
, si bien 
\emph on 
DBMatrix
\emph default 
 devuelve los datos leídos en una matriz en vez de un conjunto, y además
 los datos de ese conjunto se encuentran limitados a campos de tipo numérico.
\layout Itemize

Valor devuelto: Devuelve una matriz con los datos leídos o una matriz de
 tamaño cero en caso de error.
\layout Itemize

Ejemplo de uso:
\layout LyX-Code

Matrix matriz = DBMatrix(
\begin_inset Quotes eld
\end_inset 

select * from tabla
\begin_inset Quotes erd
\end_inset 

);
\layout Subsection

DBSeries
\layout Itemize

Qué hace: Ejecuta una consulta en la base de datos activa y devuelve un
 conjunto de series con los nombres dados y haciendo uso del fechado indicado.
 La consulta obligatoriamente debe devolver en el primer campo una fecha
 y a continuación un dato numérico, y las filas deben estar ordenadas por
 fecha.
\layout Itemize

Valor devuelto: El conjunto de las series temporales generadas por la consulta.
\layout Itemize

Ejemplo de uso:
\layout LyX-Code

// Devuelve las series de ingresos y gastos de los 
\layout LyX-Code

// movimientos de una cuenta bancaria, tomando como 
\layout LyX-Code

// valor por defecto cero:
\layout LyX-Code

Set seriesMovimientos = DBseries(
\begin_inset Quotes eld
\end_inset 

select fecha, ingresos, gastos 
\layout LyX-Code

                                   from movimientos 
\layout LyX-Code

                                     where id_cuenta = 12345
\layout LyX-Code

                                     order by fecha
\begin_inset Quotes erd
\end_inset 

,
\layout LyX-Code

                      Diario,
\layout LyX-Code

                      [[ingresos, gastos]],
\layout LyX-Code

                      [[ing, gast]],0);
\layout Subsection

DBSeriesTable
\layout Itemize

Qué hace: De forma similar a la función DBSeries, ejecuta una consulta en
 la base de datos activa y devuelve un conjunto de conjuntos de series con
 los nombres dados y haciendo uso del fechado indicado.
 La consulta obligatoriamente debe devolver en el primer campo un prefijo
 para la serie, una fecha y a continuación un dato numérico.
 La consulta debe estar ordenada por los campos prefijo y fecha.
\layout Itemize

Valor devuelto: Un conjunto bidimensional consistente en los conjuntos de
 series temporales generadas por la consulta a a base de datos.
\layout Itemize

Ejemplo de uso:
\layout LyX-Code

// Devuelve el conjunto bidimensional de las series generadas por 
\layout LyX-Code

//los ingresos y gastos de cada cuenta bancaria existente:
\layout LyX-Code

Set seriesMov = DBSeriesTable(
\begin_inset Quotes eld
\end_inset 

select fecha, id_cuenta, ingresos, gastos 
\layout LyX-Code

                               from movimientos 
\layout LyX-Code

                               order by id_cuenta, fecha
\begin_inset Quotes erd
\end_inset 

,
\layout LyX-Code

                              Diario,
\layout LyX-Code

                              [[ingresos, gastos]]);
\layout Subsection

DBSeriesColumn
\layout Itemize

Qué hace: De forma similar a la función DBSeries, ejecuta una consulta en
 la base de datos activa, pero únicamente devuelve un conjunto de series
 con los nombres dados y haciendo uso del fechado indicado.
 La consulta obligatoriamente debe devolver en el primer campo el nombre
 de la serie, seguido por una fecha y a continuación un dato numérico.
 La consulta debe estar ordenada por los campos serie y fecha.
\layout Itemize

Valor devuelto: El conjunto de las series temporales consultadas.
\layout Itemize

Ejemplo de uso:
\layout LyX-Code

// Devuelve el conjunto de las series generadas por los 
\layout LyX-Code

// ingresos y los gastos de cada cuenta bancaria existente:
\layout LyX-Code

Set seriesCol = DBSeriescolumn(
\begin_inset Quotes eld
\end_inset 

select fecha, id_cuenta, ingresos, gastos 
\layout LyX-Code

                               from movimientos 
\layout LyX-Code

                               order by id_cuenta, fecha
\begin_inset Quotes erd
\end_inset 

,
\layout LyX-Code

                               Diario,
\layout LyX-Code

                               [[ingresos, gastos]]);
\layout Subsection

DBCreateSeriesTable
\layout Itemize

Qué hace: Crea una tabla en la base de datos activa con las series indicadas
 como contenido.
 La existencia de dicha tabla es independiente del funcionamiento de TOL,
 por lo que, si no se desea conservarla al terminar un programa, hay que
 borrarla explícitamente mediante la orden: 
\begin_inset Quotes eld
\end_inset 

drop table tablaSeries
\begin_inset Quotes erd
\end_inset 

.
\layout Itemize

Valor devuelto:
\layout Itemize

Ejemplo de uso:
\layout LyX-Code

// Guardamos las series devueltas por DBSeriesTable:
\layout LyX-Code

DBCreateSeriesTable(tablaSeries, seriesMov, 
\begin_inset Quotes eld
\end_inset 

fecha
\begin_inset Quotes erd
\end_inset 

,
\begin_inset Quotes erd
\end_inset 


\begin_inset Quotes erd
\end_inset 

,
\begin_inset Quotes erd
\end_inset 


\begin_inset Quotes erd
\end_inset 

,[[,,]]);
\layout Section

Manejo simultáneo de múltiples bases de datos
\layout Standard

TOL permite el uso simultáneo de varias bases de datos de forma que es posible
 alternar su uso sin tener que abrirlas y cerrarlas entre operaciones.
\layout Subsection

DBActivate
\layout Standard

Mediante el uso de la función 
\emph on 
DBActivate
\emph default 
 se puede hacer uso de una determinada base de datos mientras el resto siguen
 abiertas.
\layout Standard

El prototipo de DBActivate es:
\layout LyX-Code

Real DBActivate (Text alias);
\layout Itemize

Comportamiento de activación de las bases de datos:
\layout Standard

Es importante conocer el comportamiento de estado de activación de las bases
 de datos abiertas, puesto que no siempre puede parecer evidente.
 Básicamente existen dos reglas básicas:
\layout Enumerate

Después de abrir una base de datos ésta se activa automáticamente.
\layout Enumerate

En caso de cierre de una base de datos activa, la primera de la lista de
 bases de datos abiertas será activada.
\layout Itemize

Valor devuelto:
\layout Standard

DBActivate devuelve 1 (Verdadero) en caso de éxito y 0 (Falso) en caso de
 error.
\layout Itemize

Ejemplo de uso:
\layout LyX-Code

// Abrimos dos bases de datos:
\layout LyX-Code

Real DBopen(
\begin_inset Quotes eld
\end_inset 

alias1
\begin_inset Quotes erd
\end_inset 

, 
\begin_inset Quotes eld
\end_inset 

usuario
\begin_inset Quotes erd
\end_inset 

,
\begin_inset Quotes erd
\end_inset 

clave
\begin_inset Quotes erd
\end_inset 

,db1);
\layout LyX-Code

Real DBopen(
\begin_inset Quotes eld
\end_inset 

alias2
\begin_inset Quotes erd
\end_inset 

, 
\begin_inset Quotes eld
\end_inset 

usuario
\begin_inset Quotes erd
\end_inset 

,
\begin_inset Quotes erd
\end_inset 

clave
\begin_inset Quotes erd
\end_inset 

,db2);
\layout LyX-Code

// Operamos sobre la última abierta:
\layout LyX-Code

Set tabla2 = DBTable(
\begin_inset Quotes eld
\end_inset 

select * from tabla
\begin_inset Quotes erd
\end_inset 

);
\layout LyX-Code

// Activamos la primera:
\layout LyX-Code

Real DBActivate(
\begin_inset Quotes eld
\end_inset 

alias1
\begin_inset Quotes erd
\end_inset 

);
\layout LyX-Code

// Operamos sobre la primera:
\layout LyX-Code

Set tabla1 = DBTable(
\begin_inset Quotes eld
\end_inset 

select * from tabla
\begin_inset Quotes erd
\end_inset 

);
\layout LyX-Code

// Cerramos las dos bases de datos:
\layout LyX-Code

Real DBClose(
\begin_inset Quotes eld
\end_inset 

alias1
\begin_inset Quotes erd
\end_inset 

);
\layout LyX-Code

Real DBClose(
\begin_inset Quotes eld
\end_inset 

alias2
\begin_inset Quotes erd
\end_inset 

);
\layout Subsection

DBGetOpened
\layout Standard

Mediante el uso de la función DBGetOpened es posible examinar el estado
 de todas las bases de datos abiertas, ya que devuelve un conjunto de estructura
s de información sobre cada base de datos abierta, incluyendo alias usado
 en TOL, gestor, servidor y nombre de la base de datos.
\layout Standard

Su prototipo es:
\layout Standard

Set DBGetOpened(Text tipo);
\layout Itemize

Valor devuelto:
\layout Standard

DBGetOpened devuelve un conjunto bidimensional con la información de cada
 base de datos que se encuentre en condiciones de uso.
\layout Standard

El parámetro 
\begin_inset Quotes eld
\end_inset 

tipo
\begin_inset Quotes erd
\end_inset 

 especifica el gestor cuya coincidencia filtrará el conjunto.
 Para consultar la lista completa, basta con dar una cadena vacía como argumento.
\layout Itemize

Ejemplo de uso:
\layout LyX-Code

// Abrimos tres bases de datos:
\layout LyX-Code

Real DBOpen(
\begin_inset Quotes eld
\end_inset 

alias1
\begin_inset Quotes erd
\end_inset 

, 
\begin_inset Quotes eld
\end_inset 

usuario
\begin_inset Quotes erd
\end_inset 

,
\begin_inset Quotes erd
\end_inset 

clave
\begin_inset Quotes erd
\end_inset 

,db1);
\layout LyX-Code

Real DBOpen(
\begin_inset Quotes eld
\end_inset 

alias2
\begin_inset Quotes erd
\end_inset 

, 
\begin_inset Quotes eld
\end_inset 

usuario
\begin_inset Quotes erd
\end_inset 

,
\begin_inset Quotes erd
\end_inset 

clave
\begin_inset Quotes erd
\end_inset 

,db2);
\layout LyX-Code

Real DBOpen(
\begin_inset Quotes eld
\end_inset 

alias3
\begin_inset Quotes erd
\end_inset 

, 
\begin_inset Quotes eld
\end_inset 

usuario
\begin_inset Quotes erd
\end_inset 

,
\begin_inset Quotes erd
\end_inset 

clave
\begin_inset Quotes erd
\end_inset 

,db3);
\layout LyX-Code

// Leemos la información sobre bases de datos abiertas:
\layout LyX-Code

Set dataBases = DBGetOpened(
\begin_inset Quotes eld
\end_inset 


\begin_inset Quotes erd
\end_inset 

);
\layout LyX-Code

// ¿Cuántas bases de datos hay?
\layout LyX-Code

Real numDataBases = Card(dataBases);
\layout LyX-Code

// ¿De qué tipo es la segunda?
\layout LyX-Code

Text type = dataBases[2][2];
\layout LyX-Code

// ¿La primera está activa?
\layout LyX-Code

Real active = dataBases[1][3];
\layout LyX-Code

// ¿Qué alias tiene la tercera?
\layout LyX-Code

Text alias = dataBases[3][1];
\layout LyX-Code

// Cerramos las bases de datos:
\layout LyX-Code

Real DBClose(
\begin_inset Quotes eld
\end_inset 

alias1
\begin_inset Quotes erd
\end_inset 

);
\layout LyX-Code

Real DBClose(
\begin_inset Quotes eld
\end_inset 

alias2
\begin_inset Quotes erd
\end_inset 

);
\layout LyX-Code

Real DBClose(
\begin_inset Quotes eld
\end_inset 

alias3
\begin_inset Quotes erd
\end_inset 

);
\the_end