DE NOVIEMBRE DE 2013

INSTITUTO TECNOLGICO DE LA PAZ

Lenguajes y Autmatas I
M.S.C Martn Agndez Amador

CREACIN DE UN
TRADUCTOR DE
SENTENCIAS DDL Y DML

ndice
Resumen...............................................................................................................................2
Introduccin........................................................................................................................2
Metodologa utilizada........................................................................................................3
Mdulo de entrada.........................................................................................................3
Mdulo de anlisis.........................................................................................................4
Mdulo de sntesis.........................................................................................................7
Mdulo de errores..........................................................................................................7
Mdulo de resultados...................................................................................................8
Discusin o reflexin crtica...........................................................................................8
Referencias bibliogrficas...............................................................................................8
Anexos..................................................................................................................................9

ndice de Figuras
Figura 1 .............................................................................................................4
Figura 2..4
Figura 3..6
Figura 4..7
Figura 5..8
Figura 6..8

ndice de Anexos
Anexo 1..............................................................................................................9
Anexo 2...10

ndice de Tablas
Tabla 1..............................................................................................................3

CREACIN DE UN TRADUCTOR DE SENTENCIAS DEL TIPO DDL Y DML

Anbal Moiss Rosas Silva1, Jessicka Nickole Bauelos Snchez2, Tania Soto
Pineda3
1
Instituto Tecnolgico de La Paz La Paz, B.C.S. Mxico
arsmoises@hotmail.com
2
Instituto Tecnolgico de La Paz La Paz, B.C.S. Mxico
jesynikgoldsmith47@gmail.com
3
Instituto Tecnolgico de La Paz La Paz, B.C.S. Mxico
tanytoon_monkey@hotmail.com

Resumen
Para la traduccin de una sentencia de tipo DDL o DML los gestores de bases de
datos pasan por distintas fases como: entrada, anlisis, sntesis, errores y
resultados; dnde, en cada fase, se analiza la consulta ingresada por el usuario
para verificar si es correcta lxica, sintctica y semnticamente, y en caso
contrario se muestra el error cometido al usuario; si la consulta es correcta pasa
por un proceso de optimizacin antes de solicitar los datos a los registros de la
base de datos para que el gestor de la base de datos realice un trabajo ms
rpido.
Palabras clave: Traductor, DDL, DML, AFD, primeros, siguientes, tokens

Introduccin
Un lenguaje de definicin de datos (DDL por sus siglas en ingls) es un lenguaje
para definir y describir los objetos de una base de datos, y lo conforman las
sentencias CREATE, ALTER, DROP, etc. El lenguaje de control de datos (DML por
sus siglas en ingls) permite el manejo y procesamiento del contenido de la base
de datos, y lo conforman las sentencias: SELECT, INSERT, DELETE, etc.
Un traductor de secuencias SQL comienza con la especificacin de reglas que
deber de seguir, el anlisis y la verificacin de que cumpla con las reglas que
siguen los tipos de sentencias DDL y DML. Posteriormente comprobar la
existencia de la optimizacin de la sentencia proporcionada y, conforme a la
generada, har la conexin al sistema manejador de base de datos y desplegar
los resultados.
En el artculo siguiente se expondr al lector la metodologa realizada para
generar un traductor de sentencias DML y DDL pasando por cada una de las fases
por las que transcurre para llegar al resultado.

Metodologa utilizada
Mdulo de entrada
El proceso comienza cuando el usuario selecciona y carga al sistema un archivo
de tipo texto, el cual tiene definidas las reglas y sus producciones por renglones, y
sigue el formato:

Regla -> producciones

Dnde:
Regla es la regla nica que representa los caminos posibles a seguir.
->Son los caracteres con el cual el programa separa la regla y las
producciones de un rengln.
Producciones son los caminos posibles que sigue la regla.

Las reglas se muestran en el anexo 1 y se basan en la tabla de smbolos

siguiente:
Terminal
#
s
f
w
a
r
m
i
n
v
u
o
l
c
e
b
t
g
x
p

Valor
0
1
2
3
4
5
6
8
9
10
11
12
13
14
15
16
17
18
19
20

Significado
Cadena Vaca
select
from
where
and
or
in
insert
into
values
numeric
not
null
distinct
order
by
create
tables
constrain
primary

Terminal
j
k
q
h
,
.

Valor
21
22
23
24
29
30

Significado
foreign
key
references
char
DELIMITADOR
DELIMITADOR
3

(
)

;
+
*
/
<
>
=
|
d

31
32
38
39
40
41
42
43
44
45
46
50
60

80

DELIMITADOR
DELIMITADOR
DELIMITADOR
DELIMITADOR
OPERADOR
OPERADOR
OPERADOR
OPERADOR
OPERADOR
OPERADOR
OPERADOR
Otra produccin
IDENTIFICADO
R
NMEROS

Tabla 1. Tabla de smbolos.

Una vez cargado el archivo texto se revisa rengln por rengln y las reglas y
producciones se traducen a nmeros, segn la tabla de smbolos, haciendo uso de
un AFD. S un smbolo no existe en la tabla de smbolos se manda un mensaje de
error lxico.
Las reglas toman un valor de nmero consecutivo. El usuario tiene la flexibilidad
de hacer cambios en las reglas cargadas ya que estas son desplegadas en el
programa y se pueden editar, de igual manera si se captura un smbolo que no
existe manda un mensaje de error lxico.

Figura 1. Reglas cargadas.

Para generar la tabla sintctica se obtienen los primeros y siguientes de cada
regla dnde los primeros son la primer terminal de los posibles caminos de la
regla. Los siguientes son otros caminos que puede seguir una regla aparte de los
primeros. Con los terminales obtenidos en los primeros y siguientes de cada regla
se va generando la tabla sintctica, dnde las terminales son las columnas y las
4

reglas, los renglones. Adicionalmente se agrega la columna de la cadena vaca.

Cada casilla que contiene producciones establece un posible camino a seguir, las
casillas vacas representan un error sintctico.
Para generar los primeros, siguientes y la tabla sintctica se utiliz un algoritmo
visto en clase el cual se encuentra en el anexo 2.
Una vez obtenida la tabla sintctica el usuario es capaz de capturar sentencias de
tipo DDL y DML para la creacin, insercin y consultas en tablas.

Figura 2. Campo para capturar las sentencias.

Mdulo de anlisis
El primer anlisis que se realiza es el anlisis lxico, el cual separa por tokens
(unidades de una consulta) una sentencia ingresada por un usuario, certificado
que todos los caracteres sean vlidos. A estos tokens se les asigna un cdigo
(donde se definen: palabras reservadas que comprenden el rango de 1-20,
delimitadores que le corresponden del 29-39, los operadores que se encuentran
de 40-50, los identificadores entre 60-79, las constantes del 80-99 y todas las
reglas posteriormente del 100), y se agregan a una matriz dicho nmero, junto su
token correspondiente, el nmero de lnea en donde se encuentra dicho token y a
qu tipo corresponden (Palabras reservadas, Operadores, Delimitadores,
Identificadores o Constantes). Para este proceso se utiliz un AFD.
El siguiente anlisis es el sintctico, el cual se encarga de validar que la consulta
ingresada cumple con las reglas establecidas en el mdulo de entrada. Se
agregan las reglas a una pila y se analiza cada uno de los cdigos de los tokens
en orden, verificando que corresponden con las reglas que se estn analizando.
Este proceso se realiz con un algoritmo visto en clase el semestre pasado.
El ltimo anlisis es el semntico, en ste se verifica que los elementos de las
sentencias son correctos, utilizando las clases de Tabla, Columna y Consulta (sta
en el caso nico de sentencias de seleccin). Esto se verifica de modo que: en las
sentencias de creacin, al ir analizando los tokens y encontrarse con el nombre
de una tabla (despus de un CREATE TABLE) se crea una nueva tabla, y al
campo nombre se le asigna el token, en seguida, al llegar la parte definicin de
columnas, se va creando una nueva columna por cada identificador encontrado,
donde tambin se llenan los campos de: nombre con el identificador, tipo con el
tipo de columna y longitud con el tamao establecido para dicha columna, una vez
definida se va agregando a la lista de columnas de la tabla que se est creando, y
5

cuando termina la definicin de columnas, se agrega la tabla a una lista de tablas

global.
En las sentencias de insercin se evala que la tabla en la cual se insertarn los
datos (que es el identificador que aparece despus de INSERT INTO) existe en
la lista de tablas global, y despus se analizar que los datos a insertar en las
columnas (lo cuales estn separados por comas despus de VALUES ()
coinciden con el tipo de columna que corresponde.
En las sentencias de seleccin se requerir del uso de una lista de Consultas
donde se almacenarn los datos de todos los SELECT implicados en esa
consulta, al encontrarse un seleccin (despus de un SELECT) se crea una
nueva consulta, al llegar a la parte de las columnas que se desplegarn por la
consulta, se agregarn las columnas de la consulta previamente creada, se toman
ciertas consideraciones cuando se est analizando los tokens que corresponden a
la definicin de columnas: el primer caso es que solamente se tengan el nombre
de la(s) columna(s) a desplegar, en este caso se agregan despus de una , o
despus del FROM la columna a la consulta previamente creada; el segundo
caso es que las columnas a mostrar se les asigne un alias, particularmente aqu
se agrega la columna despus de la identificacin de un identificador o despus
del FROM pero la columna que se agrega le corresponde el nombre del token
anteriormente analizado, ya que se cre la columna se le agrega el alias que le
corresponde del token actual a la columna previamente creada; y el tercer y ltimo
caso es que la columna que va a ser desplegada se le est asignando la tabla a la
que pertenece, en este caso particularmente se analiza cuando se encuentra con
un identificador despus de haberse encontrado un . dentro de la definicin de
columnas, entonces se crea la columna del token actual, adems de indicarle que
la tabla que le corresponde a la columna se encuentra en el token anterior.
El analizador contina hasta encontrar un FROM, lo que significa que contina la
definicin de tablas. En la definicin de tablas solo se consideran 2 casos: el
primero es que se encuentre el nombre de la tabla, en este caso hasta que se
encuentra con el token , o con un WHERE verifica que la tabla ya ha sido
registrada anteriormente y la agrega; y el segundo es que las tablas donde se
sacar la informacin contengan alias, este caso se atiende cuando encuentra 2
tokens de tipo identificador seguidos o con un WHERE, entonces se verifica que
la tabla ya ha sido registrada primeramente y entonces la agrega.
Ahora, como ya contamos con las tablas involucradas para la ejecucin de la
consulta, se verifica que las columnas especificadas existen dentro de estas
tablas; adems, se verifica que las columnas no contengan ambigedad entre las
tablas de la condicin especificada.
Igualmente, para las condiciones del WHERE, se realizan ciertas validaciones,
como que existan las tablas que se indican, existan las columnas que se indican e
las tablas especificadas, y que no exista ambigedad en las columnas que se
especifican. Se guarda el tipo de dato de la columna que se encuentra a la
6

izquierda del operador para posteriormente, pasando el operador, se verifique que

el tipo de dato corresponda al que especifica la columna de la condicin de la
izquierda.
Para el caso de las subconsultas, se verifica que el analizador se encuentre en el
IN, entonces verifica que la columna del token anterior, exista dentro de las
tablas y que se encuentre libre de ambigedad, para posteriormente esperar la
llegada del token de ( donde se incrementa el contador de consultas que se tiene
creado y comienza el AFD a analizar como si fuera una nueva seleccin
(SELECT). Para finalizar las subconsultas el AFD debe esperar a pasar por un )
para que elimine la actual Consulta creada, debido a que no se requerir de su
uso posteriormente.
Si el AFD termina satisfactoriamente, indica que la consulta se encuentra libre de
errores semnticos y se encuentra lista para el siguiente proceso.

Figura 3. Ejemplo de una consulta correcta.

Mdulo de sntesis
Para la realizacin de la optimizacin de las consultas que estn correctas se hizo
uso de un AFD el cual recorre a todos los tokens encontrados en la consulta
capturada. Se volvi a emplear el uso de una lista de consultas, cada una con sus
listas de columnas, de tablas y de condiciones.
Cuando encontraba un SELECT, agregaba una consulta a la lista de consultas;
cuando se encontraba en el AFD una columna, se agregaba a la lista de columnas
de la consulta actual; as mismo, cuando encontraba una tabla, se agregaba a la
lista de tablas; y cuando encontraba una condicin, la agregaba a la lista de
condiciones de la consulta actual. Al encontrar un parntesis que cierra se
indicaba que terminaba una consulta anidada, por lo que se mandaba al mtodo
Natural de la clase Columna, dnde se regresaba el producto natural resultante de
la consulta anidada.
El mtodo Natural, de manera resumida, funciona as: convierte la ltima condicin
de la consulta exterior (que debe ser el in) en la condicin de igualacin de las
columnas de las dos consultas, se agregan las tablas y condiciones de la consulta

interna a la externa y regresa la consulta externa, la cual se modific y se

convierte en el producto natural, la consulta interna es eliminada.
Al finalizar el AFD se ordenan las tablas y consultas segn un orden ascendente
de tamao de columnas de las tablas; en el caso de las columnas, si era un *
agregaba todas las columnas de las tablas, o si las tablas tenan alias lo asignaba
a las columnas.

Figura 4. Ejemplo de una consulta optimizada.

Mdulo de errores
Para el despliegue de los distintos errores se cre una clase Error.cs, la cual tiene
los atributos de un error (como su nombre, cdigo y mensaje a desplegar), y se
creaban al inicio del programa todos los tipos de errores con sus datos. Cada que
se encontraba un error se creaba una instancia de la clase con el cdigo de este, y
se desplegaba el error en color blanco en la parte inferior del programa,
adicionalmente se lanza una excepcin la cual detiene la ejecucin del programa.

Figura 5. Ejemplo del desplegado de errores.

Mdulo de resultados
Una vez que una sentencia es correcta y se ha verificado que exista una
optimizacin, el usuario procede a conectarse con el gestor de base de datos,
dnde ya se han capturado los datos de conexin a la base de datos, para obtener
los resultados de la consulta solicitada y estos se muestran en forma de tabla.

Figura 6. Ejemplo del desplegado de resultados

Discusin o reflexin crtica

Para la construccin de ste programa slo se utiliz el algoritmo ya existente de
primeros y siguientes para generar la tabla sintctica. Las clases, procedimientos
y, especialmente, los AFD empleados fueron generados por el ingenio de los
autores, lo que nos muestra la gran flexibilidad como herramienta hacer uso de un
AFD.

Referencias bibliogrficas
http://www.ub.edu.ar/catedras/ingenieria/Datos/capitulo4/cap42.htm

Anexos
Anexo 1 Reglas empleadas en el programa.
A1->AA1|I1;A1|Q1;A1|#
A->sEBfHwKW1N5
E->#|c
B->*|C
C->FD
D->,C|#
F->dG
G->#|.d|d
H->ZI
I->#|,H
Z->dJ
J->d|#
K->L|(L)
L->NM
M->RL|#
N->FO
O->=P|m(Q)|>@|<@
P->F|S
Q->A|S
R->a|r
S->Y|@
U->,T|#
Y->'T
T->dV'X|@'U
V->#|d
W1->ebW2|#
W2->@W3
W3->#|,W2
X->,Y|#

N5->#|;
I1->indv(V1)
V1->T1R1
R1->#|,V1
T1->@|'M2M1
M2->d|@
M1->'|d'
C1->tgd(N1)A1
N1->B1N2
N2->J1|,J1
B1->D1B2
B2->#|,B1
D1->dE1(@)ol
E1->h|u
J1->G1J2
J2->#|,J1
G1->xdH1
H1->pk(d)|jk(d)qd(d)
Q1->tgd(C2)
C2->D2X2
X2->#|,I2|R2
D2->dT2(@)ol
T2->h|u
R2->S2Y2
Y2->#|,R2
S2->xdH2
H2->pk(d)|jk(d)qd(d)
I2->C2|R2

10

Anexo 2 Algoritmo de la obtencin de los primeros y siguientes.

10