2fdc9ac8-ccff-4e89-aebb-f7eb50cc437b

Committed 21 Sep 2023 05:23PM UTC coverage: 93.203% (+0.5%) from 92.73%

Build # 2fdc9ac8-ccff-4e89-aebb-f7eb50cc437b

Build Type

push

circle-ci

Committed by

web-flow

Commit Message

Merge branch 'georgia-tech-db:master' into master

Run Details

462 of 462 new or added lines in 53 files covered. (100.0%)

11176 of 11991 relevant lines covered (93.2%)

0.93 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.5

/evadb/parser/utils.py

# coding=utf-8
# Copyright 2018-2023 EvaDB
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from evadb.parser.create_function_statement import CreateFunctionStatement
from evadb.parser.create_statement import CreateDatabaseStatement, CreateTableStatement
from evadb.parser.drop_object_statement import DropObjectStatement
from evadb.parser.explain_statement import ExplainStatement
from evadb.parser.insert_statement import InsertTableStatement
from evadb.parser.load_statement import LoadDataStatement
from evadb.parser.parser import Parser
from evadb.parser.rename_statement import RenameTableStatement
from evadb.parser.select_statement import SelectStatement
from evadb.parser.show_statement import ShowStatement
from evadb.parser.types import ObjectType
from evadb.parser.use_statement import UseStatement

# List of statements for which we omit binder and optimizer and pass the statement
# directly to the executor.
SKIP_BINDER_AND_OPTIMIZER_STATEMENTS = (CreateDatabaseStatement, UseStatement)


def parse_expression(expr: str):
    mock_query = f"SELECT {expr} FROM DUMMY;"
    stmt = Parser().parse(mock_query)[0]
    assert isinstance(stmt, SelectStatement), "Expected a select statement"
    return stmt.target_list


def parse_predicate_expression(expr: str):
    mock_query = f"SELECT * FROM DUMMY WHERE {expr};"
    stmt = Parser().parse(mock_query)[0]
    assert isinstance(stmt, SelectStatement), "Expected a select statement"
    return stmt.where_clause


def parse_table_clause(expr: str, chunk_size: int = None, chunk_overlap: int = None):
    mock_query_parts = [f"SELECT * FROM {expr}"]
    if chunk_size:
        mock_query_parts.append(f"CHUNK_SIZE {chunk_size}")
    if chunk_overlap:
        mock_query_parts.append(f"CHUNK_OVERLAP {chunk_overlap}")
    mock_query_parts.append(";")
    mock_query = " ".join(mock_query_parts)
    stmt = Parser().parse(mock_query)[0]
    assert isinstance(stmt, SelectStatement), "Expected a select statement"
    assert stmt.from_table.is_table_atom
    return stmt.from_table


def parse_create_function(
    function_name: str,
    if_not_exists: bool,
    function_file_path: str,
    type: str,
    **kwargs,
):
    mock_query = (
        f"CREATE FUNCTION IF NOT EXISTS {function_name}"
        if if_not_exists
        else f"CREATE FUNCTION {function_name}"
    )
    if type is not None:
        mock_query += f" TYPE {type}"
        task, model = kwargs["task"], kwargs["model"]
        if task is not None and model is not None:
            mock_query += f" TASK '{task}' MODEL '{model}'"
    else:
        mock_query += f" IMPL '{function_file_path}'"
    mock_query += ";"

    stmt = Parser().parse(mock_query)[0]
    assert isinstance(
        stmt, CreateFunctionStatement
    ), "Expected a create function statement"
    return stmt


def parse_create_table(table_name: str, if_not_exists: bool, columns: str, **kwargs):
    mock_query = (
        f"CREATE TABLE IF NOT EXISTS {table_name} ({columns});"
        if if_not_exists
        else f"CREATE TABLE {table_name} ({columns});"
    )
    stmt = Parser().parse(mock_query)[0]
    assert isinstance(stmt, CreateTableStatement), "Expected a create table statement"
    return stmt


def parse_show(show_type: str, **kwargs):
    mock_query = f"SHOW {show_type};"
    stmt = Parser().parse(mock_query)[0]
    assert isinstance(stmt, ShowStatement), "Expected a show statement"
    return stmt


def parse_explain(query: str, **kwargs):
    mock_query = f"EXPLAIN {query};"
    stmt = Parser().parse(mock_query)[0]
    assert isinstance(stmt, ExplainStatement), "Expected a explain statement"
    return stmt


def parse_insert(table_name: str, columns: str, values: str, **kwargs):
    mock_query = f"INSERT INTO {table_name} {columns} VALUES {values};"
    stmt = Parser().parse(mock_query)[0]
    assert isinstance(stmt, InsertTableStatement), "Expected a insert statement"
    return stmt


def parse_load(table_name: str, file_regex: str, format: str, **kwargs):
    mock_query = f"LOAD {format.upper()} '{file_regex}' INTO {table_name};"
    stmt = Parser().parse(mock_query)[0]
    assert isinstance(stmt, LoadDataStatement), "Expected a load statement"
    return stmt


def parse_drop(object_type: ObjectType, name: str, if_exists: bool):
    mock_query = f"DROP {object_type}"
    mock_query = (
        f" {mock_query} IF EXISTS {name} " if if_exists else f"{mock_query} {name}"
    )
    mock_query += ";"

    stmt = Parser().parse(mock_query)[0]
    assert isinstance(stmt, DropObjectStatement), "Expected a drop object statement"
    return stmt


def parse_drop_table(table_name: str, if_exists: bool):
    return parse_drop(ObjectType.TABLE, table_name, if_exists)


def parse_drop_function(function_name: str, if_exists: bool):
    return parse_drop(ObjectType.FUNCTION, function_name, if_exists)


def parse_drop_index(index_name: str, if_exists: bool):
    return parse_drop(ObjectType.INDEX, index_name, if_exists)


def parse_drop_database(database_name: str, if_exists: bool):
    return parse_drop(ObjectType.DATABASE, database_name, if_exists)


def parse_query(query):
    stmt = Parser().parse(query)
    assert len(stmt) == 1
    return stmt[0]


def parse_lateral_join(expr: str, alias: str):
    mock_query = f"SELECT * FROM DUMMY JOIN LATERAL {expr} AS {alias};"
    stmt = Parser().parse(mock_query)[0]
    assert isinstance(stmt, SelectStatement), "Expected a select statement"
    assert stmt.from_table.is_join()
    return stmt.from_table.join_node.right


def parse_create_vector_index(index_name: str, table_name: str, expr: str, using: str):
    mock_query = f"CREATE INDEX {index_name} ON {table_name} ({expr}) USING {using};"
    stmt = Parser().parse(mock_query)[0]
    return stmt


def parse_sql_orderby_expr(expr: str):
    mock_query = f"SELECT * FROM DUMMY ORDER BY {expr};"
    stmt = Parser().parse(mock_query)[0]
    assert isinstance(stmt, SelectStatement), "Expected a select statement"
    return stmt.orderby_list


def parse_rename(old_name: str, new_name: str):
    mock_query = f"RENAME TABLE {old_name} TO {new_name};"
    stmt = Parser().parse(mock_query)[0]
    assert isinstance(stmt, RenameTableStatement), "Expected a rename statement"
    return stmt

1	# coding=utf-8
2	# Copyright 2018-2023 EvaDB
3	#
4	# Licensed under the Apache License, Version 2.0 (the "License");
5	# you may not use this file except in compliance with the License.
6	# You may obtain a copy of the License at
7	#
8	# http://www.apache.org/licenses/LICENSE-2.0
9	#
10	# Unless required by applicable law or agreed to in writing, software
11	# distributed under the License is distributed on an "AS IS" BASIS,
12	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	# See the License for the specific language governing permissions and
14	# limitations under the License.
15	from evadb.parser.create_function_statement import CreateFunctionStatement	1✔
16	from evadb.parser.create_statement import CreateDatabaseStatement, CreateTableStatement	1✔
17	from evadb.parser.drop_object_statement import DropObjectStatement	1✔
18	from evadb.parser.explain_statement import ExplainStatement	1✔
19	from evadb.parser.insert_statement import InsertTableStatement	1✔
20	from evadb.parser.load_statement import LoadDataStatement	1✔
21	from evadb.parser.parser import Parser	1✔
22	from evadb.parser.rename_statement import RenameTableStatement	1✔
23	from evadb.parser.select_statement import SelectStatement	1✔
24	from evadb.parser.show_statement import ShowStatement	1✔
25	from evadb.parser.types import ObjectType	1✔
26	from evadb.parser.use_statement import UseStatement	1✔
27
28	# List of statements for which we omit binder and optimizer and pass the statement
29	# directly to the executor.
30	SKIP_BINDER_AND_OPTIMIZER_STATEMENTS = (CreateDatabaseStatement, UseStatement)	1✔
31
32
33	def parse_expression(expr: str):	1✔
34	mock_query = f"SELECT {expr} FROM DUMMY;"	1✔
35	stmt = Parser().parse(mock_query)[0]	1✔
36	assert isinstance(stmt, SelectStatement), "Expected a select statement"	1✔
37	return stmt.target_list	1✔
38
39
40	def parse_predicate_expression(expr: str):	1✔
41	mock_query = f"SELECT * FROM DUMMY WHERE {expr};"	1✔
42	stmt = Parser().parse(mock_query)[0]	1✔
43	assert isinstance(stmt, SelectStatement), "Expected a select statement"	1✔
44	return stmt.where_clause	1✔
45
46
47	def parse_table_clause(expr: str, chunk_size: int = None, chunk_overlap: int = None):	1✔
48	mock_query_parts = [f"SELECT * FROM {expr}"]	1✔
49	if chunk_size:	1✔
50	mock_query_parts.append(f"CHUNK_SIZE {chunk_size}")	1✔
51	if chunk_overlap:	1✔
52	mock_query_parts.append(f"CHUNK_OVERLAP {chunk_overlap}")	1✔
53	mock_query_parts.append(";")	1✔
54	mock_query = " ".join(mock_query_parts)	1✔
55	stmt = Parser().parse(mock_query)[0]	1✔
56	assert isinstance(stmt, SelectStatement), "Expected a select statement"	1✔
57	assert stmt.from_table.is_table_atom	1✔
58	return stmt.from_table	1✔
59
60
61	def parse_create_function(	1✔
62	function_name: str,
63	if_not_exists: bool,
64	function_file_path: str,
65	type: str,
66	**kwargs,
67	):
68	mock_query = (	1✔
69	f"CREATE FUNCTION IF NOT EXISTS {function_name}"
70	if if_not_exists
71	else f"CREATE FUNCTION {function_name}"
72	)
73	if type is not None:	1✔
74	mock_query += f" TYPE {type}"	1✔
75	task, model = kwargs["task"], kwargs["model"]	1✔
76	if task is not None and model is not None:	1✔
77	mock_query += f" TASK '{task}' MODEL '{model}'"	1✔
78	else:
79	mock_query += f" IMPL '{function_file_path}'"	1✔
80	mock_query += ";"	1✔
81
82	stmt = Parser().parse(mock_query)[0]	1✔
83	assert isinstance(	1✔
84	stmt, CreateFunctionStatement
85	), "Expected a create function statement"
86	return stmt	1✔
87
88
89	def parse_create_table(table_name: str, if_not_exists: bool, columns: str, **kwargs):	1✔
90	mock_query = (	1✔
91	f"CREATE TABLE IF NOT EXISTS {table_name} ({columns});"
92	if if_not_exists
93	else f"CREATE TABLE {table_name} ({columns});"
94	)
95	stmt = Parser().parse(mock_query)[0]	1✔
96	assert isinstance(stmt, CreateTableStatement), "Expected a create table statement"	1✔
97	return stmt	1✔
98
99
100	def parse_show(show_type: str, **kwargs):	1✔
101	mock_query = f"SHOW {show_type};"	1✔
102	stmt = Parser().parse(mock_query)[0]	1✔
103	assert isinstance(stmt, ShowStatement), "Expected a show statement"	1✔
104	return stmt	1✔
105
106
107	def parse_explain(query: str, **kwargs):	1✔
108	mock_query = f"EXPLAIN {query};"	1✔
109	stmt = Parser().parse(mock_query)[0]	1✔
110	assert isinstance(stmt, ExplainStatement), "Expected a explain statement"	1✔
111	return stmt	1✔
112
113
114	def parse_insert(table_name: str, columns: str, values: str, **kwargs):	1✔
115	mock_query = f"INSERT INTO {table_name} {columns} VALUES {values};"	×
116	stmt = Parser().parse(mock_query)[0]	×
117	assert isinstance(stmt, InsertTableStatement), "Expected a insert statement"	×
118	return stmt	×
119
120
121	def parse_load(table_name: str, file_regex: str, format: str, **kwargs):	1✔
122	mock_query = f"LOAD {format.upper()} '{file_regex}' INTO {table_name};"	1✔
123	stmt = Parser().parse(mock_query)[0]	1✔
124	assert isinstance(stmt, LoadDataStatement), "Expected a load statement"	1✔
125	return stmt	1✔
126
127
128	def parse_drop(object_type: ObjectType, name: str, if_exists: bool):	1✔
129	mock_query = f"DROP {object_type}"	1✔
130	mock_query = (	1✔
131	f" {mock_query} IF EXISTS {name} " if if_exists else f"{mock_query} {name}"
132	)
133	mock_query += ";"	1✔
134
135	stmt = Parser().parse(mock_query)[0]	1✔
136	assert isinstance(stmt, DropObjectStatement), "Expected a drop object statement"	1✔
137	return stmt	1✔
138
139
140	def parse_drop_table(table_name: str, if_exists: bool):	1✔
141	return parse_drop(ObjectType.TABLE, table_name, if_exists)	1✔
142
143
144	def parse_drop_function(function_name: str, if_exists: bool):	1✔
145	return parse_drop(ObjectType.FUNCTION, function_name, if_exists)	1✔
146
147
148	def parse_drop_index(index_name: str, if_exists: bool):	1✔
149	return parse_drop(ObjectType.INDEX, index_name, if_exists)	1✔
150
151
152	def parse_drop_database(database_name: str, if_exists: bool):	1✔
153	return parse_drop(ObjectType.DATABASE, database_name, if_exists)	×
154
155
156	def parse_query(query):	1✔
157	stmt = Parser().parse(query)	1✔
158	assert len(stmt) == 1	1✔
159	return stmt[0]	1✔
160
161
162	def parse_lateral_join(expr: str, alias: str):	1✔
163	mock_query = f"SELECT * FROM DUMMY JOIN LATERAL {expr} AS {alias};"	1✔
164	stmt = Parser().parse(mock_query)[0]	1✔
165	assert isinstance(stmt, SelectStatement), "Expected a select statement"	1✔
166	assert stmt.from_table.is_join()	1✔
167	return stmt.from_table.join_node.right	1✔
168
169
170	def parse_create_vector_index(index_name: str, table_name: str, expr: str, using: str):	1✔
171	mock_query = f"CREATE INDEX {index_name} ON {table_name} ({expr}) USING {using};"	1✔
172	stmt = Parser().parse(mock_query)[0]	1✔
173	return stmt	1✔
174
175
176	def parse_sql_orderby_expr(expr: str):	1✔
177	mock_query = f"SELECT * FROM DUMMY ORDER BY {expr};"	1✔
178	stmt = Parser().parse(mock_query)[0]	1✔
179	assert isinstance(stmt, SelectStatement), "Expected a select statement"	1✔
180	return stmt.orderby_list	1✔
181
182
183	def parse_rename(old_name: str, new_name: str):	1✔
184	mock_query = f"RENAME TABLE {old_name} TO {new_name};"	1✔
185	stmt = Parser().parse(mock_query)[0]	1✔
186	assert isinstance(stmt, RenameTableStatement), "Expected a rename statement"	1✔
187	return stmt	1✔

georgia-tech-db / eva / 2fdc9ac8-ccff-4e89-aebb-f7eb50cc437b

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous