def test_create_udf_statement(self):
parser = Parser()
create_udf_query = """CREATE UDF FastRCNN
INPUT (Frame_Array NDARRAY (3, 256, 256))
OUTPUT (Labels NDARRAY (10), Bbox NDARRAY (10, 4))
TYPE Classification
IMPL 'data/fastrcnn.py';
"""
eva_statement_list = parser.parse(create_udf_query)
self.assertIsInstance(eva_statement_list, list)
self.assertEqual(len(eva_statement_list), 1)
self.assertEqual(eva_statement_list[0].stmt_type,
StatementType.CREATE_UDF)
create_udf_stmt = eva_statement_list[0]
self.assertEqual(create_udf_stmt.name, 'FastRCNN')
self.assertEqual(create_udf_stmt.if_not_exists, False)
self.assertEqual(
create_udf_stmt.inputs[0],
ColumnDefinition('Frame_Array', ParserColumnDataType.NDARRAY,
[3, 256, 256]))
self.assertEqual(
create_udf_stmt.outputs[0],
ColumnDefinition('Labels', ParserColumnDataType.NDARRAY, [10]))
self.assertEqual(
create_udf_stmt.outputs[1],
ColumnDefinition('Bbox', ParserColumnDataType.NDARRAY, [10, 4]))
self.assertEqual(create_udf_stmt.impl_path, Path('data/fastrcnn.py'))
self.assertEqual(create_udf_stmt.udf_type, 'Classification')
def test_insert_statement(self):
parser = Parser()
insert_query = """INSERT INTO MyVideo (Frame_ID, Frame_Path)
VALUES (1, '/mnt/frames/1.png');
"""
eva_statement_list = parser.parse(insert_query)
self.assertIsInstance(eva_statement_list, list)
self.assertEqual(len(eva_statement_list), 1)
self.assertEqual(eva_statement_list[0].stmt_type, StatementType.INSERT)
insert_stmt = eva_statement_list[0]
# into_table
self.assertIsNotNone(insert_stmt.table)
self.assertIsInstance(insert_stmt.table, TableRef)
self.assertEqual(insert_stmt.table.table_info.table_name, 'MyVideo')
# Column
self.assertIsNotNone(insert_stmt.column_list)
self.assertIsInstance(insert_stmt.column_list, list)
self.assertEqual(len(insert_stmt.column_list), 2)
self.assertEqual(insert_stmt.column_list[0].col_name, 'Frame_ID')
self.assertEqual(insert_stmt.column_list[1].col_name, 'Frame_Path')
# Values
self.assertIsNotNone(insert_stmt.value_list)
self.assertIsInstance(insert_stmt.value_list, list)
self.assertEqual(len(insert_stmt.value_list), 2)
self.assertEqual(insert_stmt.value_list[0].value, 1)
def test_select_statement(self):
parser = Parser()
select_query = "SELECT CLASS, REDNESS FROM TAIPAI \
WHERE (CLASS = 'VAN' AND REDNESS < 300 ) OR REDNESS > 500;"
eva_statement_list = parser.parse(select_query)
self.assertIsInstance(eva_statement_list, list)
self.assertEqual(len(eva_statement_list), 1)
self.assertEqual(eva_statement_list[0].stmt_type, StatementType.SELECT)
select_stmt = eva_statement_list[0]
# target List
self.assertIsNotNone(select_stmt.target_list)
self.assertEqual(len(select_stmt.target_list), 2)
self.assertEqual(select_stmt.target_list[0].etype,
ExpressionType.TUPLE_VALUE)
self.assertEqual(select_stmt.target_list[1].etype,
ExpressionType.TUPLE_VALUE)
# from_table
self.assertIsNotNone(select_stmt.from_table)
self.assertIsInstance(select_stmt.from_table, TableRef)
self.assertEqual(select_stmt.from_table.table_info.table_name,
'TAIPAI')
# where_clause
self.assertIsNotNone(select_stmt.where_clause)
def __init__(self):
"""
Initializes interpreter
"""
self.environment = Environment()
self.parser = Parser(self.environment)
self.executor = Executor(self.environment)
def test_select_statement_sample_class(self):
'''Testing sample frequency '''
parser = Parser()
select_query = "SELECT CLASS, REDNESS FROM TAIPAI SAMPLE 5;"
eva_statement_list = parser.parse(select_query)
self.assertIsInstance(eva_statement_list, list)
self.assertEqual(len(eva_statement_list), 1)
self.assertEqual(eva_statement_list[0].stmt_type, StatementType.SELECT)
select_stmt = eva_statement_list[0]
# target List
self.assertIsNotNone(select_stmt.target_list)
self.assertEqual(len(select_stmt.target_list), 2)
self.assertEqual(
select_stmt.target_list[0].etype, ExpressionType.TUPLE_VALUE)
self.assertEqual(
select_stmt.target_list[1].etype, ExpressionType.TUPLE_VALUE)
# from_table
self.assertIsNotNone(select_stmt.from_table)
self.assertIsInstance(select_stmt.from_table, TableRef)
self.assertEqual(
select_stmt.from_table.table.table_name, 'TAIPAI')
# sample_freq
self.assertEqual(select_stmt.from_table.sample_freq,
ConstantValueExpression(5))
def test_should_insert_row_in_table(self):
dummy_info = TableInfo('MyVideo')
dummy_table = TableRef(dummy_info)
columns = [
DataFrameColumn('Frame_ID', ColumnType.INTEGER),
DataFrameColumn('Frame_Path', ColumnType.TEXT, array_dimensions=50)
]
plan_node = CreatePlan(dummy_table, columns, False)
createExec = CreateExecutor(plan_node)
url = createExec.exec()
parser = Parser()
insert_query = """INSERT INTO MyVideo (Frame_ID, Frame_Path)
VALUES (1, '/mnt/frames/1.png');
"""
eva_statement_list = parser.parse(insert_query)
insert_stmt = eva_statement_list[0]
convertor = StatementToPlanConvertor()
convertor.visit(insert_stmt)
logical_plan_node = convertor.plan
print("logical", logical_plan_node)
phy_plan_node = InsertPlan(logical_plan_node.video_catalog_id,
logical_plan_node.column_list,
logical_plan_node.value_list)
insertExec = InsertExecutor(phy_plan_node)
insertExec.exec()
# test if we have a added the in our storage
df = load_dataframe(url)
self.assertEqual(df.collect()[0][0], 1)
self.assertEqual(df.collect()[0][1], "'/mnt/frames/1.png'")
def test_create_udf_statement(self):
parser = Parser()
create_udf_query = """CREATE UDF FastRCNN
INPUT (Frame_Array NDARRAY (3, 256, 256))
OUTPUT (Labels NDARRAY (10), Bbox NDARRAY (10, 4))
TYPE Classification
IMPL 'data/fastrcnn.py';
"""
expected_stmt = CreateUDFStatement('FastRCNN', False, [
ColumnDefinition('Frame_Array', ParserColumnDataType.NDARRAY,
[3, 256, 256])
], [
ColumnDefinition('Labels', ParserColumnDataType.NDARRAY, [10]),
ColumnDefinition('Bbox', ParserColumnDataType.NDARRAY, [10, 4])
], Path('data/fastrcnn.py'), 'Classification')
eva_statement_list = parser.parse(create_udf_query)
self.assertIsInstance(eva_statement_list, list)
self.assertEqual(len(eva_statement_list), 1)
self.assertEqual(eva_statement_list[0].stmt_type,
StatementType.CREATE_UDF)
create_udf_stmt = eva_statement_list[0]
self.assertEqual(create_udf_stmt, expected_stmt)
def test_parse(self):
parser = Parser(Environment({'a': 'b'}))
self.assertEqual([['a', 'b', 'c'], ['d', 'e', 'f']],
parser.parse("a b c | d e f"))
self.assertEqual([['a', 'b | b', 'c'], ['d', 'e', 'f']],
parser.parse("a \"b | b\" c | \"d\" e f"))
self.assertEqual([['a', 'b | b', 'c'], ['d', 'e', 'b', 'b']],
parser.parse("a \"b | b\" c | \"d\" e $a \"$a\""))
def parseCode(self):
p = Parser()
p.parseCode(self.__uc, self.__user_code_edited_path)
ec = UserCode(self.__user_code_edited_path)
self.checkCode(
ec
) # Check if there was no malicious code added to the edited file
self.__parsedModule = self.__importModule(
self.__user_code_edited_path) # Import parsed module
def test_select_union_statement(self):
parser = Parser()
select_union_query = "SELECT CLASS, REDNESS FROM TAIPAI \
UNION ALL SELECT CLASS, REDNESS FROM SHANGHAI;"
eva_statement_list = parser.parse(select_union_query)
select_stmt = eva_statement_list[0]
self.assertIsNotNone(select_stmt.union_link)
self.assertEqual(select_stmt.union_all, True)
second_select_stmt = select_stmt.union_link
self.assertIsNone(second_select_stmt.union_link)
class ParserTests(unittest.TestCase):
TEST_FILE = '../data/test_data'
def setUp(self):
self.parser = Parser()
def tearDown(self):
parser = None
def test_iterative(self):
i = 0
with open(self.TEST_FILE, 'r') as fp:
while True:
try:
value = next(fp) + next(fp) + next(fp)
value = value[:-1]
next(fp)
expected = next(fp)[3:-1]
if i <= 13:
actual = self.parser.parse(value, validate_checksum_iterative=True, guess_possible_number=False)
else:
actual = self.parser.parse(value, validate_checksum_iterative=True, guess_possible_number=True)
if expected == actual:
print(expected + ' == ' + actual)
else:
print(expected + ' != ' + actual)
i += 1
# self.assertEqual(expected, actual)
except StopIteration:
break
def test_recursive(self):
i = 0
with open(self.TEST_FILE, 'r') as fp:
while True:
try:
value = next(fp) + next(fp) + next(fp)
value = value[:-1]
next(fp)
expected = next(fp)[3:-1]
if i <= 13:
actual = self.parser.parse(value, validate_checksum_iterative=False, guess_possible_number=False)
else:
actual = self.parser.parse(value, validate_checksum_iterative=False, guess_possible_number=True)
if expected == actual:
print(expected + ' == ' + actual)
else:
print(expected + ' != ' + actual)
i += 1
# self.assertEqual(expected, actual)
except StopIteration:
break
def test_load_data_statement(self):
parser = Parser()
load_data_query = """LOAD DATA INFILE 'data/video.mp4' INTO MyVideo;"""
expected_stmt = LoadDataStatement(TableRef(TableInfo('MyVideo')),
Path('data/video.mp4'))
eva_statement_list = parser.parse(load_data_query)
self.assertIsInstance(eva_statement_list, list)
self.assertEqual(len(eva_statement_list), 1)
self.assertEqual(eva_statement_list[0].stmt_type,
StatementType.LOAD_DATA)
load_data_stmt = eva_statement_list[0]
self.assertEqual(load_data_stmt, expected_stmt)
def test_multiple_statement_queries(self):
parser = Parser()
multiple_queries = []
multiple_queries.append("SELECT CLASS FROM TAIPAI \
WHERE CLASS = 'VAN' AND REDNESS < 300 OR REDNESS > 500; \
SELECT REDNESS FROM TAIPAI \
WHERE (CLASS = 'VAN' AND REDNESS = 300)")
for query in multiple_queries:
eva_statement_list = parser.parse(query)
self.assertIsInstance(eva_statement_list, list)
self.assertEqual(len(eva_statement_list), 2)
self.assertIsInstance(eva_statement_list[0], AbstractStatement)
self.assertIsInstance(eva_statement_list[1], AbstractStatement)
def handle_request(transport, request_message):
"""
Reads a request from a client and processes it
If user inputs 'quit' stops the event loop
otherwise just echoes user input
"""
LoggingManager().log('Receive request: --|' + str(request_message) + '|--')
output_batch = None
response = None
try:
stmt = Parser().parse(request_message)[0]
l_plan = StatementToPlanConvertor().visit(stmt)
p_plan = PlanGenerator().build(l_plan)
output_batch = PlanExecutor(p_plan).execute_plan()
except Exception as e:
LoggingManager().log(e, LoggingLevel.WARNING)
response = Response(status=ResponseStatus.FAIL, batch=None)
if response is None:
response = Response(status=ResponseStatus.SUCCESS, batch=output_batch)
responseData = response.to_json()
# Send data length, because response can be very large
data = (str(len(responseData)) + '|' + responseData).encode('ascii')
LoggingManager().log('Response to client: --|' + str(response) + '|--\n' +
'Length: ' + str(len(responseData)))
transport.write(data)
return response
def test_should_visit_select_if_nested_query(self, mock_p, mock_c, mock_d):
m = MagicMock()
mock_p.return_value = mock_c.return_value = mock_d.return_value = m
stmt = Parser().parse(""" SELECT id FROM (SELECT data, id FROM video \
WHERE data > 2) WHERE id>3;""")[0]
converter = StatementToPlanConvertor()
actual_plan = converter.visit(stmt)
plans = [LogicalProject([TupleValueExpression('id')])]
plans.append(
LogicalFilter(
ComparisonExpression(ExpressionType.COMPARE_GREATER,
TupleValueExpression('id'),
ConstantValueExpression(3))))
plans.append(LogicalQueryDerivedGet())
plans.append(
LogicalProject(
[TupleValueExpression('data'),
TupleValueExpression('id')]))
plans.append(
LogicalFilter(
ComparisonExpression(ExpressionType.COMPARE_GREATER,
TupleValueExpression('data'),
ConstantValueExpression(2))))
plans.append(LogicalGet(TableRef(TableInfo('video')), m))
expected_plan = None
for plan in reversed(plans):
if expected_plan:
plan.append_child(expected_plan)
expected_plan = plan
self.assertEqual(expected_plan, actual_plan)
wrong_plan = plans[0]
for plan in plans[1:]:
wrong_plan.append_child(plan)
self.assertNotEqual(wrong_plan, actual_plan)
def test_create_statement(self):
parser = Parser()
single_queries = []
single_queries.append("""CREATE TABLE IF NOT EXISTS Persons (
Frame_ID INTEGER UNIQUE,
Frame_Data TEXT(10),
Frame_Value FLOAT(1000, 201),
Frame_Array NDARRAY (5, 100, 2432, 4324, 100)
);""")
for query in single_queries:
eva_statement_list = parser.parse(query)
self.assertIsInstance(eva_statement_list, list)
self.assertEqual(len(eva_statement_list), 1)
self.assertIsInstance(eva_statement_list[0], AbstractStatement)
def test_load_data_statement(self):
parser = Parser()
load_data_query = """LOAD DATA INFILE 'data/video.mp4' INTO MyVideo;"""
eva_statement_list = parser.parse(load_data_query)
self.assertIsInstance(eva_statement_list, list)
self.assertEqual(len(eva_statement_list), 1)
self.assertEqual(eva_statement_list[0].stmt_type,
StatementType.LOAD_DATA)
load_data_stmt = eva_statement_list[0]
# into table
self.assertIsNotNone(load_data_stmt.table)
self.assertIsInstance(load_data_stmt.table, TableRef)
self.assertEqual(load_data_stmt.table.table_info.table_name, 'MyVideo')
self.assertEqual(load_data_stmt.path, Path('data/video.mp4'))
class Interpreter(object):
"""
Main class, interacting with user
"""
def __init__(self):
"""
Initializes interpreter
"""
self.environment = Environment()
self.parser = Parser(self.environment)
self.executor = Executor(self.environment)
def interpret(self):
"""
Emulates bash shell
Reads lines, parses them into commands and tokens and executes commands
"""
while True:
try:
sys.stdout.write(f'{self._get_current_directory()}$ ')
sys.stdout.flush()
stdout = self.executor.execute(
self.parser.parse(sys.stdin.readline()))
sys.stdout.write(stdout)
except KeyboardInterrupt:
sys.stdout.write('\n')
def _get_current_directory(self):
home = self.environment.get_variable('HOME')
working_dir = self.environment.get_variable('PWD')
if working_dir.find(home) == 0 and (len(home) == len(working_dir)
or working_dir[len(home)] == '/'):
working_dir = working_dir.replace(home, '~')
return working_dir
def test_select_statement_limit_class(self):
'''Testing limit clause in select statement
Class: SelectStatement'''
parser = Parser()
select_query = "SELECT CLASS, REDNESS FROM TAIPAI \
WHERE (CLASS = 'VAN' AND REDNESS < 400 ) OR REDNESS > 700 \
ORDER BY CLASS, REDNESS DESC LIMIT 3;"
eva_statement_list = parser.parse(select_query)
self.assertIsInstance(eva_statement_list, list)
self.assertEqual(len(eva_statement_list), 1)
self.assertEqual(eva_statement_list[0].stmt_type, StatementType.SELECT)
select_stmt = eva_statement_list[0]
# target List
self.assertIsNotNone(select_stmt.target_list)
self.assertEqual(len(select_stmt.target_list), 2)
self.assertEqual(select_stmt.target_list[0].etype,
ExpressionType.TUPLE_VALUE)
self.assertEqual(select_stmt.target_list[1].etype,
ExpressionType.TUPLE_VALUE)
# from_table
self.assertIsNotNone(select_stmt.from_table)
self.assertIsInstance(select_stmt.from_table, TableRef)
self.assertEqual(select_stmt.from_table.table_info.table_name,
'TAIPAI')
# where_clause
self.assertIsNotNone(select_stmt.where_clause)
# orderby_clause
self.assertIsNotNone(select_stmt.orderby_list)
self.assertEqual(len(select_stmt.orderby_list), 2)
self.assertEqual(select_stmt.orderby_list[0][0].col_name, 'CLASS')
self.assertEqual(select_stmt.orderby_list[0][1],
ParserOrderBySortType.ASC)
self.assertEqual(select_stmt.orderby_list[1][0].col_name, 'REDNESS')
self.assertEqual(select_stmt.orderby_list[1][1],
ParserOrderBySortType.DESC)
# limit_count
self.assertIsNotNone(select_stmt.limit_count)
self.assertEqual(select_stmt.limit_count, ConstantValueExpression(3))
def __init__(self):
lexer = Lexer()
parser = Parser()
solutionFactory = SolutionFactory()
self.__calculus_types = [
basic.Basic(lexer, parser, solutionFactory),
equation.Equation(lexer, parser, solutionFactory),
]
def execute_query(query) -> Iterator[Batch]:
"""
Execute the query and return a result generator.
"""
stmt = Parser().parse(query)[0]
l_plan = StatementToPlanConvertor().visit(stmt)
p_plan = PlanGenerator().build(l_plan)
return PlanExecutor(p_plan).execute_plan()
def test_parse_errors(self) -> None:
source: str = 'var x 5;'
lexer: Lexer = Lexer(source)
parser: Parser = Parser(lexer)
parser.parse_program()
self.assertEqual(len(parser.errors), 1)
def test_nested_select_statement(self):
parser = Parser()
sub_query = """SELECT CLASS FROM TAIPAI WHERE CLASS = 'VAN'"""
nested_query = """SELECT ID FROM ({});""".format(sub_query)
parsed_sub_query = parser.parse(sub_query)[0]
actual_stmt = parser.parse(nested_query)[0]
self.assertEqual(actual_stmt.stmt_type, StatementType.SELECT)
self.assertEqual(actual_stmt.target_list[0].col_name, 'ID')
self.assertEqual(actual_stmt.from_table, parsed_sub_query)
sub_query = """SELECT Yolo(frame).bbox FROM autonomous_vehicle_1
WHERE Yolo(frame).label = 'vehicle'"""
nested_query = """SELECT Licence_plate(bbox) FROM
({})
WHERE Is_suspicious(bbox) = 1 AND
Licence_plate(bbox) = '12345';
""".format(sub_query)
query = """SELECT Licence_plate(bbox) FROM TAIPAI
WHERE Is_suspicious(bbox) = 1 AND
Licence_plate(bbox) = '12345';
"""
query_stmt = parser.parse(query)[0]
actual_stmt = parser.parse(nested_query)[0]
sub_query_stmt = parser.parse(sub_query)[0]
self.assertEqual(actual_stmt.from_table, sub_query_stmt)
self.assertEqual(actual_stmt.where_clause, query_stmt.where_clause)
self.assertEqual(actual_stmt.target_list, query_stmt.target_list)
def test_parse_program(self) -> None:
source: str = 'var x = 5;'
lexer: Lexer = Lexer(source)
parser: Parser = Parser(lexer)
program: Program = parser.parse_program()
self.assertIsNotNone(program)
self.assertIsInstance(program, Program)
def do_query(self, query):
"""Takes in SQL query and generates the output"""
# Type exit to stop program
if (query == "exit" or query == "EXIT"):
raise SystemExit
if len(query) == 0:
print("Empty query")
else:
try:
# Connect and Query from Eva
parser = Parser()
eva_statement = parser.parse(query)
select_stmt = eva_statement[0]
print("Result from the parser:")
print(select_stmt)
print('\n')
# Read Input Videos
# Replace with Input Pipeline once finished
input_video = []
for filename in glob.glob('data/sample_video/*.jpg'):
im = Image.open(filename)
# to handle 'too many open files' error
im_copy = im.copy()
input_video.append(im_copy)
im.close()
# Write Output to final folder
# Replace with output pipeline once finished
ouput_frames = random.sample(input_video, 50)
output_folder = "data/sample_output/"
for i in range(len(ouput_frames)):
frame_name = output_folder + "output" + str(i) + ".jpg"
ouput_frames[i].save(frame_name)
print("Refer pop-up for a sample of the output")
ouput_frames[0].show()
except TypeError:
print("SQL Statement improperly formatted. Try again.")
def test_select_statement_orderby_class(self):
'''Testing order by clause in select statement
Class: SelectStatement'''
parser = Parser()
select_query = "SELECT CLASS, REDNESS FROM TAIPAI \
WHERE (CLASS = 'VAN' AND REDNESS < 400 ) OR REDNESS > 700 \
ORDER BY CLASS, REDNESS DESC;"
# if orderby sort_type (ASC/DESC) not provided, should default to ASC
eva_statement_list = parser.parse(select_query)
self.assertIsInstance(eva_statement_list, list)
self.assertEqual(len(eva_statement_list), 1)
self.assertEqual(eva_statement_list[0].stmt_type, StatementType.SELECT)
select_stmt = eva_statement_list[0]
# target List
self.assertIsNotNone(select_stmt.target_list)
self.assertEqual(len(select_stmt.target_list), 2)
self.assertEqual(
select_stmt.target_list[0].etype, ExpressionType.TUPLE_VALUE)
self.assertEqual(
select_stmt.target_list[1].etype, ExpressionType.TUPLE_VALUE)
# from_table
self.assertIsNotNone(select_stmt.from_table)
self.assertIsInstance(select_stmt.from_table, TableRef)
self.assertEqual(
select_stmt.from_table.table.table_name, 'TAIPAI')
# where_clause
self.assertIsNotNone(select_stmt.where_clause)
# orderby_clause
self.assertIsNotNone(select_stmt.orderby_list)
self.assertEqual(len(select_stmt.orderby_list), 2)
self.assertEqual(select_stmt.orderby_list[0][0].col_name, 'CLASS')
self.assertEqual(
select_stmt.orderby_list[0][1], ParserOrderBySortType.ASC)
self.assertEqual(select_stmt.orderby_list[1][0].col_name, 'REDNESS')
self.assertEqual(
select_stmt.orderby_list[1][1], ParserOrderBySortType.DESC)
def test_insert_statement(self):
parser = Parser()
insert_query = """INSERT INTO MyVideo (Frame_ID, Frame_Path)
VALUES (1, '/mnt/frames/1.png');
"""
expected_stmt = InsertTableStatement(TableRef(TableInfo('MyVideo')), [
TupleValueExpression('Frame_ID'),
TupleValueExpression('Frame_Path')
], [
ConstantValueExpression(1),
ConstantValueExpression('/mnt/frames/1.png')
])
eva_statement_list = parser.parse(insert_query)
self.assertIsInstance(eva_statement_list, list)
self.assertEqual(len(eva_statement_list), 1)
self.assertEqual(eva_statement_list[0].stmt_type, StatementType.INSERT)
insert_stmt = eva_statement_list[0]
self.assertEqual(insert_stmt, expected_stmt)
def test_single_statement_queries(self):
parser = Parser()
single_queries = []
single_queries.append("SELECT CLASS FROM TAIPAI;")
single_queries.append("SELECT CLASS FROM TAIPAI WHERE CLASS = 'VAN';")
single_queries.append("SELECT CLASS,REDNESS FROM TAIPAI \
WHERE CLASS = 'VAN' AND REDNESS > 20;")
single_queries.append("SELECT CLASS FROM TAIPAI \
WHERE (CLASS = 'VAN' AND REDNESS < 300 ) OR REDNESS > 500;")
single_queries.append("SELECT CLASS FROM TAIPAI \
WHERE (CLASS = 'VAN' AND REDNESS < 300 ) OR REDNESS > 500;")
for query in single_queries:
eva_statement_list = parser.parse(query)
self.assertIsInstance(eva_statement_list, list)
self.assertEqual(len(eva_statement_list), 1)
self.assertIsInstance(eva_statement_list[0], AbstractStatement)
def test_integer_expressions(self) -> None:
source: str = '5;'
lexer: Lexer = Lexer(source)
parser: Parser = Parser(lexer)
program: Program = parser.parse_program()
self._test_program_statements(parser, program)
expression_statement = cast(ExpressionStatement, program.statements[0])
assert expression_statement.expression
self._test_literal_expression(expression_statement.expression, 5)
def handle_request(transport, query):
"""
Reads a request from a client and processes it
If user inputs 'quit' stops the event loop
otherwise just echoes user input
"""
parser = Parser()
eva_statement = parser.parse(query)
insert_statement = eva_statement[0]
LoggingManager().log("Result from the parser: " + str(insert_statement))
convertor = StatementToPlanConvertor()
convertor.visit(insert_statement)
convertor.plan
eva_statement = parser.parse(query)
response_message = ""
for i in range(len(eva_statement)):
LoggingManager().log("Parse Tree: " + str(eva_statement[i]))
logical_plan = StatementToPlanConvertor().visit(eva_statement[i])
physical_plan = PlanGenerator().build(logical_plan)
df = PlanExecutor(physical_plan).execute_plan()
statement_response_message = ','.join(map(str, df.collect()))
response_message += statement_response_message
LoggingManager().log('Response to client: --|' +
str(response_message) +
'|--')
data = response_message.encode('ascii')
transport.write(data)
return response_message
