def test_multiple_join_with_multiple_ON(self):
select_query = '''SELECT table1.a FROM table1 JOIN table2
ON table1.a = table2.a JOIN table3
ON table3.a = table1.a WHERE table1.a <= 5'''
parser = Parser()
select_stmt = parser.parse(select_query)[0]
table1_col_a = TupleValueExpression('a', 'table1')
table2_col_a = TupleValueExpression('a', 'table2')
table3_col_a = TupleValueExpression('a', 'table3')
select_list = [table1_col_a]
child_join = TableRef(
JoinNode(TableRef(TableInfo('table1')),
TableRef(TableInfo('table2')),
predicate=ComparisonExpression(
ExpressionType.COMPARE_EQUAL, table1_col_a,
table2_col_a),
join_type=JoinType.INNER_JOIN))
from_table = TableRef(
JoinNode(child_join,
TableRef(TableInfo('table3')),
predicate=ComparisonExpression(
ExpressionType.COMPARE_EQUAL, table3_col_a,
table1_col_a),
join_type=JoinType.INNER_JOIN))
where_clause = ComparisonExpression(ExpressionType.COMPARE_LEQ,
table1_col_a,
ConstantValueExpression(5))
expected_stmt = SelectStatement(select_list, from_table, where_clause)
self.assertEqual(select_stmt, expected_stmt)
def test_rename_plan(self):
dummy_info = TableInfo("old")
dummy_old = TableRef(dummy_info)
dummy_new = TableInfo("new")
CatalogManager().reset()
dummy_plan_node = RenamePlan(dummy_old, dummy_new)
self.assertEqual(dummy_plan_node.opr_type, PlanOprType.RENAME)
self.assertEqual(dummy_plan_node.old_table.table.table_name, "old")
self.assertEqual(dummy_plan_node.new_name.table_name, "new")
def test_rename_statement(self):
parser = Parser()
rename_queries = "RENAME TABLE student TO student_info"
expected_stmt = RenameTableStatement(TableRef(TableInfo('student')),
TableInfo('student_info'))
eva_statement_list = parser.parse(rename_queries)
self.assertIsInstance(eva_statement_list, list)
self.assertEqual(len(eva_statement_list), 1)
self.assertEqual(eva_statement_list[0].stmt_type, StatementType.RENAME)
rename_stmt = eva_statement_list[0]
self.assertEqual(rename_stmt, expected_stmt)
def test_should_return_false_for_unequal_plans_and_true_for_equal_plans(
self, ):
plans = []
create_plan = LogicalCreate(TableRef(TableInfo("video")),
[MagicMock()])
create_udf_plan = LogicalCreateUDF("udf", False, None, None, None)
insert_plan = LogicalInsert(MagicMock(), 0, [MagicMock()],
[MagicMock()])
query_derived_plan = LogicalQueryDerivedGet(alias="T")
load_plan = LogicalLoadData(MagicMock(), MagicMock(), MagicMock(),
MagicMock())
rename_plan = LogicalRename(TableRef(TableInfo("old")),
TableInfo("new"))
show_plan = LogicalShow(MagicMock())
drop_plan = LogicalDrop([MagicMock()], True)
get_plan = LogicalGet(MagicMock(), MagicMock(), MagicMock())
sample_plan = LogicalSample(MagicMock())
filter_plan = LogicalFilter(MagicMock())
order_by_plan = LogicalOrderBy(MagicMock())
union_plan = LogicalUnion(MagicMock())
function_scan_plan = LogicalFunctionScan(MagicMock())
join_plan = LogicalJoin(MagicMock(), MagicMock(), MagicMock(),
MagicMock())
create_plan.append_child(create_udf_plan)
plans.append(create_plan)
plans.append(create_udf_plan)
plans.append(insert_plan)
plans.append(query_derived_plan)
plans.append(load_plan)
plans.append(rename_plan)
plans.append(drop_plan)
plans.append(get_plan)
plans.append(sample_plan)
plans.append(filter_plan)
plans.append(order_by_plan)
plans.append(union_plan)
plans.append(function_scan_plan)
plans.append(join_plan)
plans.append(show_plan)
length = len(plans)
for i in range(length):
self.assertEqual(plans[i], plans[i])
if i >= 1: # compare against next plan
self.assertNotEqual(plans[i - 1], plans[i])
def test_create_materialized_view_plan(self):
dummy_view = TableRef(TableInfo('dummy'))
columns = ['id', 'id2']
plan = CreateMaterializedViewPlan(dummy_view, columns)
self.assertEqual(plan.opr_type, PlanOprType.CREATE_MATERIALIZED_VIEW)
self.assertEqual(plan.view, dummy_view)
self.assertEqual(plan.columns, columns)
def visitTableName(self, ctx: evaql_parser.TableNameContext):
table_name = self.visit(ctx.fullId())
if table_name is not None:
table_info = TableInfo(table_name=table_name)
return table_info
else:
error = 'Invalid Table Name'
logger.error(error)
def test_join(self):
select_query = '''SELECT table1.a FROM table1 JOIN table2
ON table1.a = table2.a; '''
parser = Parser()
select_stmt = parser.parse(select_query)[0]
table1_col_a = TupleValueExpression('a', 'table1')
table2_col_a = TupleValueExpression('a', 'table2')
select_list = [table1_col_a]
from_table = TableRef(
JoinNode(TableRef(TableInfo('table1')),
TableRef(TableInfo('table2')),
predicate=ComparisonExpression(
ExpressionType.COMPARE_EQUAL, table1_col_a,
table2_col_a),
join_type=JoinType.INNER_JOIN))
expected_stmt = SelectStatement(select_list, from_table)
self.assertEqual(select_stmt, expected_stmt)
def test_drop_plan(self):
dummy_info = TableInfo('dummy')
dummy_table = TableRef(dummy_info)
CatalogManager().reset()
dummy_plan_node = DropPlan([dummy_table], False)
self.assertEqual(dummy_plan_node.opr_type, PlanOprType.DROP)
self.assertEqual(dummy_plan_node.table_refs[0].table.table_name,
"dummy")
def test_drop_statement(self):
parser = Parser()
drop_queries = "DROP TABLE student_info"
expected_stmt = DropTableStatement(
[TableRef(TableInfo('student_info'))], False)
eva_statement_list = parser.parse(drop_queries)
self.assertIsInstance(eva_statement_list, list)
self.assertEqual(len(eva_statement_list), 1)
self.assertEqual(eva_statement_list[0].stmt_type, StatementType.DROP)
drop_stmt = eva_statement_list[0]
self.assertEqual(drop_stmt, expected_stmt)
def test_raises_mismatch_columns(self, mock_check):
mock_check.return_value = False
dummy_view = TableRef(TableInfo('dummy'))
columns = ['id', 'id2']
plan = CreateMaterializedViewPlan(dummy_view, columns)
child = MagicMock()
child.node.opr_type = PlanOprType.SEQUENTIAL_SCAN
child.project_expr.__len__.return_value = 3
with self.assertRaises(RuntimeError):
create_udf_executor = CreateMaterializedViewExecutor(plan)
create_udf_executor.append_child(child)
create_udf_executor.exec()
def test_table_ref(self):
''' Testing table info in TableRef
Class: TableInfo
'''
table_info = TableInfo('TAIPAI', 'Schema', 'Database')
table_ref_obj = TableRef(table_info)
select_stmt_new = SelectStatement()
select_stmt_new.from_table = table_ref_obj
self.assertEqual(select_stmt_new.from_table.table.table_name, 'TAIPAI')
self.assertEqual(select_stmt_new.from_table.table.schema_name,
'Schema')
self.assertEqual(select_stmt_new.from_table.table.database_name,
'Database')
def test_support_only_seq_scan(self, mock_check):
mock_check.return_value = False
dummy_view = TableRef(TableInfo('dummy'))
columns = ['id', 'id2']
plan = CreateMaterializedViewPlan(dummy_view, columns)
for child_opr_type in PlanOprType:
if child_opr_type is PlanOprType.SEQUENTIAL_SCAN:
continue
child = MagicMock()
child.node.opr_type = child_opr_type
with self.assertRaises(RuntimeError):
create_udf_executor = CreateMaterializedViewExecutor(plan)
create_udf_executor.append_child(child)
create_udf_executor.exec()
def test_materialized_view(self):
select_query = '''SELECT id, FastRCNNObjectDetector(frame).labels FROM MyVideo
WHERE id<5; '''
query = 'CREATE MATERIALIZED VIEW uadtrac_fastRCNN (id, labels) AS {}'\
.format(select_query)
parser = Parser()
mat_view_stmt = parser.parse(query)
select_stmt = parser.parse(select_query)
expected_stmt = CreateMaterializedViewStatement(
TableRef(TableInfo('uadtrac_fastRCNN')), [
ColumnDefinition('id', None, None, None),
ColumnDefinition('labels', None, None, None)
], False, select_stmt[0])
self.assertEqual(mat_view_stmt[0], expected_stmt)
def test_create_plan(self):
dummy_info = TableInfo('dummy')
dummy_table = TableRef(dummy_info)
CatalogManager().reset()
columns = [
DataFrameColumn('id', ColumnType.INTEGER),
DataFrameColumn('name', ColumnType.TEXT, array_dimensions=[50])
]
dummy_plan_node = CreatePlan(dummy_table, columns, False)
self.assertEqual(dummy_plan_node.opr_type, PlanOprType.CREATE)
self.assertEqual(dummy_plan_node.if_not_exists, False)
self.assertEqual(dummy_plan_node.table_ref.table.table_name, "dummy")
self.assertEqual(dummy_plan_node.column_list[0].name, "id")
self.assertEqual(dummy_plan_node.column_list[1].name, "name")
def test_lateral_join_with_where(self):
select_query = '''SELECT frame FROM MyVideo JOIN LATERAL
ObjectDet(frame);'''
parser = Parser()
select_stmt = parser.parse(select_query)[0]
tuple_frame = TupleValueExpression('frame')
func_expr = FunctionExpression(func=None,
name='ObjectDet',
children=[tuple_frame])
from_table = TableRef(
JoinNode(TableRef(TableInfo('MyVideo')),
TableRef(func_expr),
join_type=JoinType.LATERAL_JOIN))
expected_stmt = SelectStatement([tuple_frame], from_table)
self.assertEqual(select_stmt, expected_stmt)
def test_should_return_false_for_unequal_expression(self):
table = TableRef(TableInfo('MyVideo'))
load_stmt = LoadDataStatement(table, Path('data/video.mp4'),
FileFormatType.VIDEO)
insert_stmt = InsertTableStatement(table)
create_udf = CreateUDFStatement('udf', False, [
ColumnDefinition('frame', ColumnType.NDARRAY, NdArrayType.UINT8,
[3, 256, 256])
], [
ColumnDefinition('labels', ColumnType.NDARRAY, NdArrayType.STR,
[10])
], Path('data/fastrcnn.py'), 'Classification')
select_stmt = SelectStatement()
self.assertNotEqual(load_stmt, insert_stmt)
self.assertNotEqual(insert_stmt, load_stmt)
self.assertNotEqual(create_udf, insert_stmt)
self.assertNotEqual(select_stmt, create_udf)
def test_load_video_data_statement(self):
parser = Parser()
load_data_query = """LOAD DATA INFILE 'data/video.mp4'
INTO MyVideo WITH FORMAT VIDEO;"""
file_options = {}
file_options['file_format'] = FileFormatType.VIDEO
column_list = None
expected_stmt = LoadDataStatement(TableRef(TableInfo('MyVideo')),
Path('data/video.mp4'), column_list,
file_options)
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_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', ColumnType.TEXT)
])
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 bind_table_info(table_info: TableInfo) -> DataFrameMetadata:
"""
Uses catalog to bind the dataset information for given video string.
Arguments:
video_info (TableInfo): video information obtained in SQL query
Returns:
DataFrameMetadata - corresponding metadata for the input table info
"""
catalog = CatalogManager()
obj = catalog.get_dataset_metadata(table_info.database_name,
table_info.table_name)
if obj:
table_info.table_obj = obj
else:
error = '{} does not exists. Create the table using \
CREATE TABLE.'.format(table_info.table_name)
logger.error(error)
raise RuntimeError(error)
def test_load_csv_data_statement(self):
parser = Parser()
load_data_query = """LOAD DATA INFILE 'data/meta.csv'
INTO
MyMeta (id, frame_id, video_id, label)
WITH FORMAT CSV;"""
file_options = {}
file_options['file_format'] = FileFormatType.CSV
expected_stmt = LoadDataStatement(TableRef(TableInfo('MyMeta')),
Path('data/meta.csv'), [
TupleValueExpression('id'),
TupleValueExpression('frame_id'),
TupleValueExpression('video_id'),
TupleValueExpression('label')
], file_options)
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)
