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