#811

Committed 25 Sep 2023 03:38AM UTC coverage: 92.737% (-0.1%) from 92.866%

Build # #811

Build Type

push

circle-ci

Committed by Jiashen Cao

Commit Message

make code more modular

Run Details

11390 of 12282 relevant lines covered (92.74%)

0.93 hits per line

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

95.54

/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.set_statement import SetStatement
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,
    SetStatement,
)


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.set_statement import SetStatement	1✔
25	from evadb.parser.show_statement import ShowStatement	1✔
26	from evadb.parser.types import ObjectType	1✔
27	from evadb.parser.use_statement import UseStatement	1✔
28
29	# List of statements for which we omit binder and optimizer and pass the statement
30	# directly to the executor.
31	SKIP_BINDER_AND_OPTIMIZER_STATEMENTS = (	1✔
32	CreateDatabaseStatement,
33	UseStatement,
34	SetStatement,
35	)
36
37
38	def parse_expression(expr: str):	1✔
39	mock_query = f"SELECT {expr} FROM DUMMY;"	1✔
40	stmt = Parser().parse(mock_query)[0]	1✔
41	assert isinstance(stmt, SelectStatement), "Expected a select statement"	1✔
42	return stmt.target_list	1✔
43
44
45	def parse_predicate_expression(expr: str):	1✔
46	mock_query = f"SELECT * FROM DUMMY WHERE {expr};"	1✔
47	stmt = Parser().parse(mock_query)[0]	1✔
48	assert isinstance(stmt, SelectStatement), "Expected a select statement"	1✔
49	return stmt.where_clause	1✔
50
51
52	def parse_table_clause(expr: str, chunk_size: int = None, chunk_overlap: int = None):	1✔
53	mock_query_parts = [f"SELECT * FROM {expr}"]	1✔
54	if chunk_size:	1✔
55	mock_query_parts.append(f"CHUNK_SIZE {chunk_size}")	1✔
56	if chunk_overlap:	1✔
57	mock_query_parts.append(f"CHUNK_OVERLAP {chunk_overlap}")	1✔
58	mock_query_parts.append(";")	1✔
59	mock_query = " ".join(mock_query_parts)	1✔
60	stmt = Parser().parse(mock_query)[0]	1✔
61	assert isinstance(stmt, SelectStatement), "Expected a select statement"	1✔
62	assert stmt.from_table.is_table_atom	1✔
63	return stmt.from_table	1✔
64
65
66	def parse_create_function(	1✔
67	function_name: str,
68	if_not_exists: bool,
69	function_file_path: str,
70	type: str,
71	**kwargs,
72	):
73	mock_query = (	1✔
74	f"CREATE FUNCTION IF NOT EXISTS {function_name}"
75	if if_not_exists
76	else f"CREATE FUNCTION {function_name}"
77	)
78	if type is not None:	1✔
79	mock_query += f" TYPE {type}"	1✔
80	task, model = kwargs["task"], kwargs["model"]	1✔
81	if task is not None and model is not None:	1✔
82	mock_query += f" TASK '{task}' MODEL '{model}'"	1✔
83	else:
84	mock_query += f" IMPL '{function_file_path}'"	1✔
85	mock_query += ";"	1✔
86
87	stmt = Parser().parse(mock_query)[0]	1✔
88	assert isinstance(	1✔
89	stmt, CreateFunctionStatement
90	), "Expected a create function statement"
91	return stmt	1✔
92
93
94	def parse_create_table(table_name: str, if_not_exists: bool, columns: str, **kwargs):	1✔
95	mock_query = (	1✔
96	f"CREATE TABLE IF NOT EXISTS {table_name} ({columns});"
97	if if_not_exists
98	else f"CREATE TABLE {table_name} ({columns});"
99	)
100	stmt = Parser().parse(mock_query)[0]	1✔
101	assert isinstance(stmt, CreateTableStatement), "Expected a create table statement"	1✔
102	return stmt	1✔
103
104
105	def parse_show(show_type: str, **kwargs):	1✔
106	mock_query = f"SHOW {show_type};"	1✔
107	stmt = Parser().parse(mock_query)[0]	1✔
108	assert isinstance(stmt, ShowStatement), "Expected a show statement"	1✔
109	return stmt	1✔
110
111
112	def parse_explain(query: str, **kwargs):	1✔
113	mock_query = f"EXPLAIN {query};"	1✔
114	stmt = Parser().parse(mock_query)[0]	1✔
115	assert isinstance(stmt, ExplainStatement), "Expected a explain statement"	1✔
116	return stmt	1✔
117
118
119	def parse_insert(table_name: str, columns: str, values: str, **kwargs):	1✔
120	mock_query = f"INSERT INTO {table_name} {columns} VALUES {values};"	×
121	stmt = Parser().parse(mock_query)[0]	×
122	assert isinstance(stmt, InsertTableStatement), "Expected a insert statement"	×
123	return stmt	×
124
125
126	def parse_load(table_name: str, file_regex: str, format: str, **kwargs):	1✔
127	mock_query = f"LOAD {format.upper()} '{file_regex}' INTO {table_name};"	1✔
128	stmt = Parser().parse(mock_query)[0]	1✔
129	assert isinstance(stmt, LoadDataStatement), "Expected a load statement"	1✔
130	return stmt	1✔
131
132
133	def parse_drop(object_type: ObjectType, name: str, if_exists: bool):	1✔
134	mock_query = f"DROP {object_type}"	1✔
135	mock_query = (	1✔
136	f" {mock_query} IF EXISTS {name} " if if_exists else f"{mock_query} {name}"
137	)
138	mock_query += ";"	1✔
139
140	stmt = Parser().parse(mock_query)[0]	1✔
141	assert isinstance(stmt, DropObjectStatement), "Expected a drop object statement"	1✔
142	return stmt	1✔
143
144
145	def parse_drop_table(table_name: str, if_exists: bool):	1✔
146	return parse_drop(ObjectType.TABLE, table_name, if_exists)	1✔
147
148
149	def parse_drop_function(function_name: str, if_exists: bool):	1✔
150	return parse_drop(ObjectType.FUNCTION, function_name, if_exists)	1✔
151
152
153	def parse_drop_index(index_name: str, if_exists: bool):	1✔
154	return parse_drop(ObjectType.INDEX, index_name, if_exists)	1✔
155
156
157	def parse_drop_database(database_name: str, if_exists: bool):	1✔
158	return parse_drop(ObjectType.DATABASE, database_name, if_exists)	×
159
160
161	def parse_query(query):	1✔
162	stmt = Parser().parse(query)	1✔
163	assert len(stmt) == 1	1✔
164	return stmt[0]	1✔
165
166
167	def parse_lateral_join(expr: str, alias: str):	1✔
168	mock_query = f"SELECT * FROM DUMMY JOIN LATERAL {expr} AS {alias};"	1✔
169	stmt = Parser().parse(mock_query)[0]	1✔
170	assert isinstance(stmt, SelectStatement), "Expected a select statement"	1✔
171	assert stmt.from_table.is_join()	1✔
172	return stmt.from_table.join_node.right	1✔
173
174
175	def parse_create_vector_index(index_name: str, table_name: str, expr: str, using: str):	1✔
176	mock_query = f"CREATE INDEX {index_name} ON {table_name} ({expr}) USING {using};"	1✔
177	stmt = Parser().parse(mock_query)[0]	1✔
178	return stmt	1✔
179
180
181	def parse_sql_orderby_expr(expr: str):	1✔
182	mock_query = f"SELECT * FROM DUMMY ORDER BY {expr};"	1✔
183	stmt = Parser().parse(mock_query)[0]	1✔
184	assert isinstance(stmt, SelectStatement), "Expected a select statement"	1✔
185	return stmt.orderby_list	1✔
186
187
188	def parse_rename(old_name: str, new_name: str):	1✔
189	mock_query = f"RENAME TABLE {old_name} TO {new_name};"	1✔
190	stmt = Parser().parse(mock_query)[0]	1✔
191	assert isinstance(stmt, RenameTableStatement), "Expected a rename statement"	1✔
192	return stmt	1✔

georgia-tech-db / eva / #811

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