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_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_select_statement_class(self):
''' Testing setting different clauses for Select
Statement class
Class: SelectStatement'''
select_stmt_new = SelectStatement()
parser = Parser()
select_query_new = "SELECT CLASS, REDNESS FROM TAIPAI \
WHERE (CLASS = 'VAN' AND REDNESS < 400 ) OR REDNESS > 700;"
eva_statement_list = parser.parse(select_query_new)
select_stmt = eva_statement_list[0]
select_stmt_new.where_clause = select_stmt.where_clause
select_stmt_new.target_list = select_stmt.target_list
select_stmt_new.from_table = select_stmt.from_table
self.assertEqual(select_stmt_new.where_clause,
select_stmt.where_clause)
self.assertEqual(select_stmt_new.target_list, select_stmt.target_list)
self.assertEqual(select_stmt_new.from_table, select_stmt.from_table)
self.assertEqual(str(select_stmt_new), str(select_stmt))
def test_visit_select_should_not_call_visits_for_null_values(self):
converter = StatementToPlanConvertor()
converter.visit_table_ref = MagicMock()
converter._visit_projection = MagicMock()
converter._visit_select_predicate = MagicMock()
converter._visit_union = MagicMock()
statement = SelectStatement()
converter.visit_select(statement)
converter.visit_table_ref.assert_not_called()
converter._visit_projection.assert_not_called()
converter._visit_select_predicate.assert_not_called()
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_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 _bind_select_statement(self, node: SelectStatement):
self.bind(node.from_table)
if node.where_clause:
self.bind(node.where_clause)
if node.target_list:
# SELECT * support
if len(node.target_list) == 1 and \
isinstance(node.target_list[0], TupleValueExpression) and \
node.target_list[0].col_name == '*':
node.target_list = extend_star(self._binder_context)
for expr in node.target_list:
self.bind(expr)
if node.orderby_list:
for expr in node.orderby_list:
self.bind(expr[0])
if node.union_link:
current_context = self._binder_context
self._binder_context = StatementBinderContext()
self.bind(node.union_link)
self._binder_context = current_context
def visitQuerySpecification(self,
ctx: evaql_parser.QuerySpecificationContext):
target_list = None
from_clause = None
where_clause = None
orderby_clause = None
limit_count = None
# first child will be a SELECT terminal token
for child in ctx.children[1:]:
try:
rule_idx = child.getRuleIndex()
if rule_idx == evaql_parser.RULE_selectElements:
target_list = self.visit(child)
elif rule_idx == evaql_parser.RULE_fromClause:
clause = self.visit(child)
from_clause = clause.get('from', None)
where_clause = clause.get('where', None)
elif rule_idx == evaql_parser.RULE_orderByClause:
orderby_clause = self.visit(ctx.orderByClause())
elif rule_idx == evaql_parser.RULE_limitClause:
limit_count = self.visit(ctx.limitClause())
except BaseException as e:
# stop parsing something bad happened
logger.error('Error while parsing \
visitQuerySpecification')
raise e
select_stmt = SelectStatement(target_list,
from_clause,
where_clause,
orderby_clause_list=orderby_clause,
limit_count=limit_count)
return select_stmt