def p_expression_entero(t):
'''expression : ENTERO'''
global num_nodo
n_entero = t[1]
if n_entero in range(-32768, 32768):
t[0] = primitivo(t.lineno(1), t.lexpos(1), t[1], tipo_primitivo.SMALLINT, num_nodo)
elif n_entero in range(-2147483648, 2147483647):
t[0] = primitivo(t.lineno(1), t.lexpos(1), t[1], tipo_primitivo.INTEGER, num_nodo)
elif n_entero in range(-9223372036854775808, 9223372036854775807):
t[0] = primitivo(t.lineno(1), t.lexpos(1), t[1], tipo_primitivo.BIGINT, num_nodo)
num_nodo += 2
def p_expression_cadena(t):
'''expression : CADENA'''
global num_nodo
n_tiempo = str(t[1])
patron_tiempo = re.compile(r'\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d')
m_tiempo = patron_tiempo.match(n_tiempo)
patron_fecha = re.compile(r'\d\d\d\d-\d\d-\d\d')
m_fecha = patron_fecha.match(n_tiempo)
if m_tiempo != None:
t[0] = primitivo(t.lineno(1), t.lexpos(1), t[1], tipo_primitivo.TIME, num_nodo)
elif m_fecha != None:
t[0] = primitivo(t.lineno(1), t.lexpos(1), t[1], tipo_primitivo.DATE, num_nodo)
else:
t[0] = primitivo(t.lineno(1), t.lexpos(1), t[1], tipo_primitivo.CHAR, num_nodo)
num_nodo += 2
def p_expression_decimal(t):
'''expression : DECIMAL_NUM'''
global num_nodo
texto_decimal = str(t[1])
patron_real = re.compile(r'-?\d+\.\d\d\d\d\d\d+')
m_real = patron_real.match(texto_decimal)
patron_presicion = re.compile(r'-?\d+\.\d\d\d\d\d\d\d\d\d\d\d\d\d\d\d+')
m_presicion = patron_presicion.match(texto_decimal)
n_decimal = t[1]
n_decimal = int(n_decimal)
if m_presicion != None:
t[0] = primitivo(t.lineno(1), t.lexpos(1), t[1], tipo_primitivo.DOUBLE_PRECISION, num_nodo)
elif m_real != None:
t[0] = primitivo(t.lineno(1), t.lexpos(1), t[1], tipo_primitivo.REAL, num_nodo)
elif n_decimal in range(-131072, 131073):
t[0] = primitivo(t.lineno(1), t.lexpos(1), t[1], tipo_primitivo.DECIMAL, num_nodo)
elif n_decimal in range(-92233720368547758, 92233720368547759):
t[0] = primitivo(t.lineno(1), t.lexpos(1), t[1], tipo_primitivo.MONEY, num_nodo)
num_nodo += 2
def p_expression_agrupar_f(t):
'''expression_f : SUM PAR_ABRE expression PAR_CIERRA
| COUNT PAR_ABRE expression PAR_CIERRA
| AVG PAR_ABRE expression PAR_CIERRA
| MAX PAR_ABRE expression PAR_CIERRA
| MIN PAR_ABRE expression PAR_CIERRA
| ABS PAR_ABRE expression PAR_CIERRA
| CBRT PAR_ABRE expression PAR_CIERRA
| CEIL PAR_ABRE expression PAR_CIERRA
| CEILING PAR_ABRE expression PAR_CIERRA
| DEGREES PAR_ABRE expression PAR_CIERRA
| DIV PAR_ABRE expression COMA expression PAR_CIERRA
| EXP PAR_ABRE expression PAR_CIERRA
| FACTORIAL PAR_ABRE expression PAR_CIERRA
| FLOOR PAR_ABRE expression PAR_CIERRA
| GCD PAR_ABRE expression COMA expression PAR_CIERRA
| LN PAR_ABRE expression PAR_CIERRA
| LOG PAR_ABRE expression PAR_CIERRA
| MOD PAR_ABRE expression COMA expression PAR_CIERRA
| PI PAR_ABRE PAR_CIERRA
| POWER PAR_ABRE expression COMA expression PAR_CIERRA
| RADIANS PAR_ABRE expression PAR_CIERRA
| ROUND PAR_ABRE expression PAR_CIERRA
| SIGN PAR_ABRE expression PAR_CIERRA
| SQRT PAR_ABRE expression PAR_CIERRA
| WIDTH_BUCKET PAR_ABRE expression COMA expression COMA expression COMA expression PAR_CIERRA
| TRUNC PAR_ABRE expression PAR_CIERRA
| RANDOM PAR_ABRE PAR_CIERRA '''
global num_nodo
try:
if str(t[1]).lower() == "div" or str(t[1]).lower() == "gcd" or str(t[1]).lower() == "mod" or str(t[1]).lower() == "power":
t[0] = agrupar(t[1], t[3], t[5], t.lineno(1), t.lexpos(1), num_nodo)
elif str(t[1]).lower() == "pi" or str(t[1]).lower() == "random":
auxiliar = primitivo(t.lineno(1), t.lexpos(1), 0, tipo_primitivo.INTEGER, num_nodo)
t[0] = agrupar(t[1], auxiliar, None, t.lineno(1), t.lexpos(1), num_nodo)
else:
t[0] = agrupar(t[1], t[3], None, t.lineno(1), t.lexpos(1), num_nodo)
num_nodo += 3
except:
print('No funciona la parte de agrupar')
def p_expression_time_f(t):
'''expression_f : NOW PAR_ABRE PAR_CIERRA
| TIMESTAMP CADENA
| CURRENT_TIME
| CURRENT_DATE
| DATE_PART PAR_ABRE expression COMA INTERVAL expression PAR_CIERRA
| EXTRACT PAR_ABRE YEAR FROM TIMESTAMP expression PAR_CIERRA
| EXTRACT PAR_ABRE MONTH FROM TIMESTAMP expression PAR_CIERRA
| EXTRACT PAR_ABRE DAY FROM TIMESTAMP expression PAR_CIERRA
| EXTRACT PAR_ABRE HOUR FROM TIMESTAMP expression PAR_CIERRA
| EXTRACT PAR_ABRE MINUTE FROM TIMESTAMP expression PAR_CIERRA
| EXTRACT PAR_ABRE SECOND FROM TIMESTAMP expression PAR_CIERRA'''
global num_nodo
try:
if str(t[1]).lower() == "date_part" or str(t[1]).lower() == "extract":
if str(t[3]) == "YEAR":
t[3] = primitivo(t.lineno(1), t.lexpos(1), "year", tipo_primitivo.CHAR, num_nodo)
elif str(t[3]) == "MONTH":
t[3] = primitivo(t.lineno(1), t.lexpos(1), "month", tipo_primitivo.CHAR, num_nodo)
elif str(t[3]) == "DAY":
t[3] = primitivo(t.lineno(1), t.lexpos(1), "day", tipo_primitivo.CHAR, num_nodo)
elif str(t[3]) == "HOUR":
t[3] = primitivo(t.lineno(1), t.lexpos(1), "hour", tipo_primitivo.CHAR, num_nodo)
elif str(t[3]) == "MINUTE":
t[3] = primitivo(t.lineno(1), t.lexpos(1), "minute", tipo_primitivo.CHAR, num_nodo)
elif str(t[3]) == "SECOND":
t[3] = primitivo(t.lineno(1), t.lexpos(1), "second", tipo_primitivo.CHAR, num_nodo)
t[0] = agrupar(t[1], t[3], t[6], t.lineno(1), t.lexpos(1), num_nodo)
elif str(t[1]).lower() == "now" or str(t[1]).lower() == "timestamp" or str(t[1]).lower() == "current_date" or str(t[1]).lower() == "current_time":
auxiliar = primitivo(t.lineno(1), t.lexpos(1), 0, tipo_primitivo.INTEGER, num_nodo)
t[0] = agrupar(t[1], auxiliar, None, t.lineno(1), t.lexpos(1), num_nodo)
else:
t[0] = agrupar(t[1], t[3], None, t.lineno(1), t.lexpos(1), num_nodo)
num_nodo += 3
except:
print('No funciona la parte de agrupar')
def p_expression_nulo(t):
'''expression : NULL'''
global num_nodo
t[0] = primitivo(t.lineno, t.lexpos, t[1], tipo_primitivo.NULL, num_nodo)
num_nodo += 2
def ejecutar(self):
#try:
actual_db = get_actual_use()
valores_iniciales = []
lista_aux = []
for item in self.lista:
valores_iniciales.append(item.ejecutar([]))
retornos = []
index_id = 0
if self.cols_id != None:
#Extraer colummas de la tabla
columnas_table = ts.get_cols(actual_db, self.dato)
if columnas_table != None:
for item_columna in columnas_table:
if index_id < len(self.cols_id):
if self.cols_id[index_id] == item_columna.id_:
lista_aux.append(self.lista[index_id])
retornos.append(valores_iniciales[index_id])
index_id += 1
else:
lista_aux.append(
primitivo(self.line, self.column, 'NULL',
tipo_primitivo.NULL,
self.num_nodo + 1000000000))
retornos.append(
retorno('NULL', tipo_primitivo.NULL))
else:
lista_aux.append(
primitivo(self.line, self.column, 'NULL',
tipo_primitivo.NULL,
self.num_nodo + 1000000000))
retornos.append(retorno('NULL', tipo_primitivo.NULL))
else:
errores.append(
nodo_error(
self.line, self.column,
'E-42P10 invalid column reference: Cannot extract columns to insert data',
'Semántico'))
add_text(
'E-42P10 invalid column reference: Cannot extract columns to insert data.\n'
)
else:
retornos = valores_iniciales
valores = []
for item in retornos:
valores.append(item.valor)
tipo_dominante = 17
#Validar tipos de dato de insert en columna y dato
if len(retornos) == ts.count_columns(actual_db, self.dato):
count_pos = 0
for value in retornos:
if value.tipo != tipo_primitivo.NULL:
columna = ts.get_col_by_pos(actual_db, self.dato,
count_pos)
tipo_dominante = tipos_tabla[value.tipo.value][
columna.tipo.value]
if tipo_dominante != columna.tipo:
errores.append(
nodo_error(
self.line, self.column,
'E-42809 wrong object type: You cannot insert a data type '
+ self.get_str_tipo(value.tipo) +
' in a column of type ' +
self.get_str_tipo(columna.tipo), 'Semántico'))
add_text(
'E-42809 wrong object type: You cannot insert a data type '
+ self.get_str_tipo(value.tipo) +
' in a column of type ' +
self.get_str_tipo(columna.tipo) + '\n')
return
count_pos += 1
#Validar el tamaño correcto
if tipo_dominante == tipo_primitivo.CHAR or tipo_dominante == tipo_primitivo.VARCHAR:
if columna.size < len(value.valor):
errores.append(
nodo_error(
self.line, self.column,
'E-22015 interval field overflow: Data size exceeded '
+ value.valor, 'Semántico'))
add_text(
'E-22015 interval field overflow: Data size exceeded '
+ value.valor + '\n')
return
else:
#Omitir NULL, para validar despues las restricciones de columnas
count_pos += 1
else:
errores.append(
nodo_error(
self.line, self.column,
'E-22005 error in assignment: Columns out of bounds',
'Semántico'))
add_text('E-22005 error in assignment: Columns out of bounds\n')
return
#Validar restricciones de columnas
index_col = 0
for value in valores:
col_actual = ts.get_col_by_pos(actual_db, self.dato, index_col)
if col_actual.condiciones != None:
for restriccion in col_actual.condiciones:
valido = None
if isinstance(restriccion, unique_simple):
pos_col = ts.get_pos_col(actual_db, self.dato,
col_actual.id_)
valido = restriccion.ejecutar(self.dato, value,
pos_col)
elif isinstance(restriccion, condicion_simple):
pos_col = ts.get_pos_col(actual_db, self.dato,
col_actual.id_)
valido = restriccion.ejecutar(value, pos_col)
if isinstance(valido, nodo_error):
errores.append(valido)
salida_consola = valido.valor + '\n'
add_text(salida_consola)
return
elif valido != None:
#Encontramos un cambio para el dato en el default
valores[index_col] = valido
index_col += 1
aux_insert = funciones.insert(actual_db, self.dato, valores)
# Valor de retorno: 0 operación exitosa, 1 error en la operación, 2 database no existente, 3 table no existente, 4 llave primaria duplicada, 5 columnas fuera de límites.
if aux_insert == 0:
add_text("M-00000 successful completion: Row inserted correctly\n")
elif aux_insert == 1:
errores.append(
nodo_error(
self.line, self.column,
'E-22005 error in assignment: Could not insert row',
'Semántico'))
add_text('E-22005 error in assignment: Could not insert row\n')
elif aux_insert == 2:
errores.append(
nodo_error(
self.line, self.column,
'E-22005 error in assignment: There is no database with the following ID -> '
+ actual_db, 'Sémantico'))
add_text(
'E-22005 error in assignment:\nThere is no database with the following ID ->'
+ actual_db + '\n')
elif aux_insert == 3:
errores.append(
nodo_error(
self.line, self.column,
'E-22005 error in assignment: The table with the following ID does not exist -> '
+ self.dato, 'Semántico'))
add_text(
'E-22005 error in assignment: The table with the following ID does not exist -> '
+ self.dato + '\n')
elif aux_insert == 4:
errores.append(
nodo_error(
self.line, self.column,
'E-22005 error in assignment: Duplicate primary key',
'Semántico'))
add_text('E-22005 error in assignment: Duplicate primary key\n')
elif aux_insert == 5:
errores.append(
nodo_error(
self.line, self.column,
'E-22005 error in assignment: Columns out of bounds',
'Semántico'))
add_text('E-22005 error in assignment: Columns out of bounds\n')
