#852

Committed 16 Nov 2023 08:34AM UTC coverage: 0.0%. Remained the same

Build # #852

Build Type

push

circleci

Committed by Andy Xu

Commit Message

Skip neuralforecast testcases

Run Details

0 of 12596 relevant lines covered (0.0%)

0.0 hits per line

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

0.0

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

georgia-tech-db / eva / #852

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