#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/executor/drop_object_executor.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.


import pandas as pd

from evadb.database import EvaDBDatabase
from evadb.executor.abstract_executor import AbstractExecutor
from evadb.executor.executor_utils import ExecutorError, handle_vector_store_params
from evadb.models.storage.batch import Batch
from evadb.parser.types import ObjectType
from evadb.plan_nodes.drop_object_plan import DropObjectPlan
from evadb.storage.storage_engine import StorageEngine
from evadb.third_party.vector_stores.utils import VectorStoreFactory
from evadb.utils.logging_manager import logger


class DropObjectExecutor(AbstractExecutor):
    def __init__(self, db: EvaDBDatabase, node: DropObjectPlan):
        super().__init__(db, node)

    def exec(self, *args, **kwargs):
        """Drop Object executor"""

        if self.node.object_type == ObjectType.TABLE:
            yield self._handle_drop_table(self.node.name, self.node.if_exists)

        elif self.node.object_type == ObjectType.INDEX:
            yield self._handle_drop_index(self.node.name, self.node.if_exists)

        elif self.node.object_type == ObjectType.FUNCTION:
            yield self._handle_drop_function(self.node.name, self.node.if_exists)

        elif self.node.object_type == ObjectType.DATABASE:
            yield self._handle_drop_database(self.node.name, self.node.if_exists)

        elif self.node.object_type == ObjectType.JOB:
            yield self._handle_drop_job(self.node.name, self.node.if_exists)

    def _handle_drop_table(self, table_name: str, if_exists: bool):
        if not self.catalog().check_table_exists(table_name):
            err_msg = "Table: {} does not exist".format(table_name)
            if if_exists:
                return Batch(pd.DataFrame([err_msg]))
            else:
                raise ExecutorError(err_msg)

        table_obj = self.catalog().get_table_catalog_entry(table_name)
        storage_engine = StorageEngine.factory(self.db, table_obj)

        logger.debug(f"Dropping table {table_name}")
        storage_engine.drop(table=table_obj)

        for col_obj in table_obj.columns:
            for cache in col_obj.dep_caches:
                self.catalog().drop_function_cache_catalog_entry(cache)

        # todo also delete the indexes associated with the table
        assert self.catalog().delete_table_catalog_entry(
            table_obj
        ), "Failed to drop {}".format(table_name)

        return Batch(
            pd.DataFrame(
                {"Table Successfully dropped: {}".format(table_name)},
                index=[0],
            )
        )

    def _handle_drop_function(self, function_name: str, if_exists: bool):
        # check catalog if it already has this function entry
        if not self.catalog().get_function_catalog_entry_by_name(function_name):
            err_msg = (
                f"Function {function_name} does not exist, therefore cannot be dropped."
            )
            if if_exists:
                logger.warning(err_msg)
                return Batch(pd.DataFrame([err_msg]))
            else:
                raise RuntimeError(err_msg)
        else:
            function_entry = self.catalog().get_function_catalog_entry_by_name(
                function_name
            )
            for cache in function_entry.dep_caches:
                self.catalog().drop_function_cache_catalog_entry(cache)

            # todo also delete the indexes associated with the table

            self.catalog().delete_function_catalog_entry_by_name(function_name)

            return Batch(
                pd.DataFrame(
                    {f"Function {function_name} successfully dropped"},
                    index=[0],
                )
            )

    def _handle_drop_index(self, index_name: str, if_exists: bool):
        index_obj = self.catalog().get_index_catalog_entry_by_name(index_name)
        if not index_obj:
            err_msg = f"Index {index_name} does not exist, therefore cannot be dropped."
            if if_exists:
                logger.warning(err_msg)
                return Batch(pd.DataFrame([err_msg]))
            else:
                raise RuntimeError(err_msg)
        else:
            index = VectorStoreFactory.init_vector_store(
                index_obj.type,
                index_obj.name,
                **handle_vector_store_params(
                    index_obj.type, index_obj.save_file_path, self.catalog
                ),
            )
            assert (
                index is not None
            ), f"Failed to initialize the vector store handler for {index_obj.type}"

            if index:
                index.delete()

            self.catalog().drop_index_catalog_entry(index_name)

            return Batch(
                pd.DataFrame(
                    {f"Index {index_name} successfully dropped"},
                    index=[0],
                )
            )

    def _handle_drop_database(self, database_name: str, if_exists: bool):
        db_catalog_entry = self.catalog().get_database_catalog_entry(database_name)
        if not db_catalog_entry:
            err_msg = (
                f"Database {database_name} does not exist, therefore cannot be dropped."
            )
            if if_exists:
                logger.warning(err_msg)
                return Batch(pd.DataFrame([err_msg]))
            else:
                raise RuntimeError(err_msg)

        logger.debug(f"Dropping database {database_name}")

        self.catalog().drop_database_catalog_entry(db_catalog_entry)

        return Batch(
            pd.DataFrame(
                {f"Database {database_name} successfully dropped"},
                index=[0],
            )
        )

    def _handle_drop_job(self, job_name: str, if_exists: bool):
        job_catalog_entry = self.catalog().get_job_catalog_entry(job_name)
        if not job_catalog_entry:
            err_msg = f"Job {job_name} does not exist, therefore cannot be dropped."
            if if_exists:
                logger.warning(err_msg)
                return Batch(pd.DataFrame([err_msg]))
            else:
                raise RuntimeError(err_msg)

        logger.debug(f"Dropping Job {job_name}")

        self.catalog().drop_job_catalog_entry(job_catalog_entry)

        return Batch(
            pd.DataFrame(
                {f"Job {job_name} successfully dropped"},
                index=[0],
            )
        )

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
16
17	import pandas as pd	×
18
19	from evadb.database import EvaDBDatabase	×
20	from evadb.executor.abstract_executor import AbstractExecutor	×
21	from evadb.executor.executor_utils import ExecutorError, handle_vector_store_params	×
22	from evadb.models.storage.batch import Batch	×
23	from evadb.parser.types import ObjectType	×
24	from evadb.plan_nodes.drop_object_plan import DropObjectPlan	×
25	from evadb.storage.storage_engine import StorageEngine	×
26	from evadb.third_party.vector_stores.utils import VectorStoreFactory	×
27	from evadb.utils.logging_manager import logger	×
28
29
30	class DropObjectExecutor(AbstractExecutor):	×
31	def __init__(self, db: EvaDBDatabase, node: DropObjectPlan):	×
32	super().__init__(db, node)	×
33
34	def exec(self, args, *kwargs):	×
35	"""Drop Object executor"""
36
37	if self.node.object_type == ObjectType.TABLE:	×
38	yield self._handle_drop_table(self.node.name, self.node.if_exists)	×
39
40	elif self.node.object_type == ObjectType.INDEX:	×
41	yield self._handle_drop_index(self.node.name, self.node.if_exists)	×
42
43	elif self.node.object_type == ObjectType.FUNCTION:	×
44	yield self._handle_drop_function(self.node.name, self.node.if_exists)	×
45
46	elif self.node.object_type == ObjectType.DATABASE:	×
47	yield self._handle_drop_database(self.node.name, self.node.if_exists)	×
48
49	elif self.node.object_type == ObjectType.JOB:	×
50	yield self._handle_drop_job(self.node.name, self.node.if_exists)	×
51
52	def _handle_drop_table(self, table_name: str, if_exists: bool):	×
53	if not self.catalog().check_table_exists(table_name):	×
54	err_msg = "Table: {} does not exist".format(table_name)	×
55	if if_exists:	×
56	return Batch(pd.DataFrame([err_msg]))	×
57	else:
58	raise ExecutorError(err_msg)
59
60	table_obj = self.catalog().get_table_catalog_entry(table_name)	×
61	storage_engine = StorageEngine.factory(self.db, table_obj)	×
62
63	logger.debug(f"Dropping table {table_name}")	×
64	storage_engine.drop(table=table_obj)	×
65
66	for col_obj in table_obj.columns:	×
67	for cache in col_obj.dep_caches:	×
68	self.catalog().drop_function_cache_catalog_entry(cache)	×
69
70	# todo also delete the indexes associated with the table
71	assert self.catalog().delete_table_catalog_entry(	×
72	table_obj
73	), "Failed to drop {}".format(table_name)
74
75	return Batch(	×
76	pd.DataFrame(
77	{"Table Successfully dropped: {}".format(table_name)},
78	index=[0],
79	)
80	)
81
82	def _handle_drop_function(self, function_name: str, if_exists: bool):	×
83	# check catalog if it already has this function entry
84	if not self.catalog().get_function_catalog_entry_by_name(function_name):	×
85	err_msg = (	×
86	f"Function {function_name} does not exist, therefore cannot be dropped."
87	)
88	if if_exists:	×
89	logger.warning(err_msg)	×
90	return Batch(pd.DataFrame([err_msg]))	×
91	else:
92	raise RuntimeError(err_msg)
93	else:
94	function_entry = self.catalog().get_function_catalog_entry_by_name(	×
95	function_name
96	)
97	for cache in function_entry.dep_caches:	×
98	self.catalog().drop_function_cache_catalog_entry(cache)	×
99
100	# todo also delete the indexes associated with the table
101
102	self.catalog().delete_function_catalog_entry_by_name(function_name)	×
103
104	return Batch(	×
105	pd.DataFrame(
106	{f"Function {function_name} successfully dropped"},
107	index=[0],
108	)
109	)
110
111	def _handle_drop_index(self, index_name: str, if_exists: bool):	×
112	index_obj = self.catalog().get_index_catalog_entry_by_name(index_name)	×
113	if not index_obj:	×
114	err_msg = f"Index {index_name} does not exist, therefore cannot be dropped."	×
115	if if_exists:	×
116	logger.warning(err_msg)	×
117	return Batch(pd.DataFrame([err_msg]))	×
118	else:
119	raise RuntimeError(err_msg)
120	else:
121	index = VectorStoreFactory.init_vector_store(	×
122	index_obj.type,
123	index_obj.name,
124	**handle_vector_store_params(
125	index_obj.type, index_obj.save_file_path, self.catalog
126	),
127	)
128	assert (	×
129	index is not None
130	), f"Failed to initialize the vector store handler for {index_obj.type}"
131
132	if index:	×
133	index.delete()	×
134
135	self.catalog().drop_index_catalog_entry(index_name)	×
136
137	return Batch(	×
138	pd.DataFrame(
139	{f"Index {index_name} successfully dropped"},
140	index=[0],
141	)
142	)
143
144	def _handle_drop_database(self, database_name: str, if_exists: bool):	×
145	db_catalog_entry = self.catalog().get_database_catalog_entry(database_name)	×
146	if not db_catalog_entry:	×
147	err_msg = (	×
148	f"Database {database_name} does not exist, therefore cannot be dropped."
149	)
150	if if_exists:	×
151	logger.warning(err_msg)	×
152	return Batch(pd.DataFrame([err_msg]))	×
153	else:
154	raise RuntimeError(err_msg)
155
156	logger.debug(f"Dropping database {database_name}")	×
157
158	self.catalog().drop_database_catalog_entry(db_catalog_entry)	×
159
160	return Batch(	×
161	pd.DataFrame(
162	{f"Database {database_name} successfully dropped"},
163	index=[0],
164	)
165	)
166
167	def _handle_drop_job(self, job_name: str, if_exists: bool):	×
168	job_catalog_entry = self.catalog().get_job_catalog_entry(job_name)	×
169	if not job_catalog_entry:	×
170	err_msg = f"Job {job_name} does not exist, therefore cannot be dropped."	×
171	if if_exists:	×
172	logger.warning(err_msg)	×
173	return Batch(pd.DataFrame([err_msg]))	×
174	else:
175	raise RuntimeError(err_msg)
176
177	logger.debug(f"Dropping Job {job_name}")	×
178
179	self.catalog().drop_job_catalog_entry(job_catalog_entry)	×
180
181	return Batch(	×
182	pd.DataFrame(
183	{f"Job {job_name} successfully dropped"},
184	index=[0],
185	)
186	)

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