b2a86723-af10-419d-b39f-db980c001926

Committed 25 Aug 2023 08:22PM UTC coverage: 93.727% (-3.0%) from 96.702%

Build # b2a86723-af10-419d-b39f-db980c001926

Build Type

push

circle-ci

Committed by

gaurav274

Commit Message

fix user reference

Run Details

10474 of 11175 relevant lines covered (93.73%)

0.94 hits per line

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

96.55

/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.UDF:
            yield self._handle_drop_udf(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_udf_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_udf(self, udf_name: str, if_exists: bool):
        # check catalog if it already has this udf entry
        if not self.catalog().get_udf_catalog_entry_by_name(udf_name):
            err_msg = f"UDF {udf_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:
            udf_entry = self.catalog().get_udf_catalog_entry_by_name(udf_name)
            for cache in udf_entry.dep_caches:
                self.catalog().drop_udf_cache_catalog_entry(cache)

            # todo also delete the indexes associated with the table

            self.catalog().delete_udf_catalog_entry_by_name(udf_name)

            return Batch(
                pd.DataFrame(
                    {f"UDF {udf_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),
            )
            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],
                )
            )

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	1✔
18
19	from evadb.database import EvaDBDatabase	1✔
20	from evadb.executor.abstract_executor import AbstractExecutor	1✔
21	from evadb.executor.executor_utils import ExecutorError, handle_vector_store_params	1✔
22	from evadb.models.storage.batch import Batch	1✔
23	from evadb.parser.types import ObjectType	1✔
24	from evadb.plan_nodes.drop_object_plan import DropObjectPlan	1✔
25	from evadb.storage.storage_engine import StorageEngine	1✔
26	from evadb.third_party.vector_stores.utils import VectorStoreFactory	1✔
27	from evadb.utils.logging_manager import logger	1✔
28
29
30	class DropObjectExecutor(AbstractExecutor):	1✔
31	def __init__(self, db: EvaDBDatabase, node: DropObjectPlan):	1✔
32	super().__init__(db, node)	1✔
33
34	def exec(self, args, *kwargs):	1✔
35	"""Drop Object executor"""
36
37	if self.node.object_type == ObjectType.TABLE:	1✔
38	yield self._handle_drop_table(self.node.name, self.node.if_exists)	1✔
39
40	elif self.node.object_type == ObjectType.INDEX:	1✔
41	yield self._handle_drop_index(self.node.name, self.node.if_exists)	1✔
42
43	elif self.node.object_type == ObjectType.UDF:	1✔
44	yield self._handle_drop_udf(self.node.name, self.node.if_exists)	1✔
45
46	def _handle_drop_table(self, table_name: str, if_exists: bool):	1✔
47	if not self.catalog().check_table_exists(table_name):	1✔
48	err_msg = "Table: {} does not exist".format(table_name)	1✔
49	if if_exists:	1✔
50	return Batch(pd.DataFrame([err_msg]))	1✔
51	else:
52	raise ExecutorError(err_msg)
53
54	table_obj = self.catalog().get_table_catalog_entry(table_name)	1✔
55	storage_engine = StorageEngine.factory(self.db, table_obj)	1✔
56
57	logger.debug(f"Dropping table {table_name}")	1✔
58	storage_engine.drop(table=table_obj)	1✔
59
60	for col_obj in table_obj.columns:	1✔
61	for cache in col_obj.dep_caches:	1✔
62	self.catalog().drop_udf_cache_catalog_entry(cache)	1✔
63
64	# todo also delete the indexes associated with the table
65	assert self.catalog().delete_table_catalog_entry(	1✔
66	table_obj
67	), "Failed to drop {}".format(table_name)
68
69	return Batch(	1✔
70	pd.DataFrame(
71	{"Table Successfully dropped: {}".format(table_name)},
72	index=[0],
73	)
74	)
75
76	def _handle_drop_udf(self, udf_name: str, if_exists: bool):	1✔
77	# check catalog if it already has this udf entry
78	if not self.catalog().get_udf_catalog_entry_by_name(udf_name):	1✔
79	err_msg = f"UDF {udf_name} does not exist, therefore cannot be dropped."	1✔
80	if if_exists:	1✔
81	logger.warning(err_msg)	1✔
82	return Batch(pd.DataFrame([err_msg]))	1✔
83	else:
84	raise RuntimeError(err_msg)
85	else:
86	udf_entry = self.catalog().get_udf_catalog_entry_by_name(udf_name)	1✔
87	for cache in udf_entry.dep_caches:	1✔
88	self.catalog().drop_udf_cache_catalog_entry(cache)	1✔
89
90	# todo also delete the indexes associated with the table
91
92	self.catalog().delete_udf_catalog_entry_by_name(udf_name)	1✔
93
94	return Batch(	1✔
95	pd.DataFrame(
96	{f"UDF {udf_name} successfully dropped"},
97	index=[0],
98	)
99	)
100
101	def _handle_drop_index(self, index_name: str, if_exists: bool):	1✔
102	index_obj = self.catalog().get_index_catalog_entry_by_name(index_name)	1✔
103	if not index_obj:	1✔
104	err_msg = f"Index {index_name} does not exist, therefore cannot be dropped."	1✔
105	if if_exists:	1✔
106	logger.warning(err_msg)	×
107	return Batch(pd.DataFrame([err_msg]))	×
108	else:
109	raise RuntimeError(err_msg)
110	else:
111	index = VectorStoreFactory.init_vector_store(	1✔
112	index_obj.type,
113	index_obj.name,
114	**handle_vector_store_params(index_obj.type, index_obj.save_file_path),
115	)
116	assert (	1✔
117	index is not None
118	), f"Failed to initialize the vector store handler for {index_obj.type}"
119
120	if index:	1✔
121	index.delete()	1✔
122
123	self.catalog().drop_index_catalog_entry(index_name)	1✔
124
125	return Batch(	1✔
126	pd.DataFrame(
127	{f"Index {index_name} successfully dropped"},
128	index=[0],
129	)
130	)

georgia-tech-db / eva / b2a86723-af10-419d-b39f-db980c001926

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