77c80145-a015-4dd2-b3e6-f861e45e9bae

Committed 06 Sep 2023 09:34PM UTC coverage: 69.779% (-10.8%) from 80.573%

Build # 77c80145-a015-4dd2-b3e6-f861e45e9bae

Build Type

push

circle-ci

Committed by

gaurav274

Commit Message

Merge branch 'staging' of github.com:georgia-tech-db/evadb into build-fix

Run Details

8139 of 11664 relevant lines covered (69.78%)

0.7 hits per line

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

0.0

/evadb/third_party/databases/sqlite/sqlite_handler.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 sqlite3

import pandas as pd

from evadb.third_party.databases.types import (
    DBHandler,
    DBHandlerResponse,
    DBHandlerStatus,
)


class SQLiteHandler(DBHandler):
    def __init__(self, name: str, **kwargs):
        """
        Initialize the handler.
        Args:
            name (str): name of the DB handler instance
            **kwargs: arbitrary keyword arguments for establishing the connection.
        """
        super().__init__(name)
        self.database = kwargs.get("database")
        self.connection = None

    def connect(self):
        """
        Set up the connection required by the handler.
        Returns:
            DBHandlerStatus
        """
        try:
            self.connection = sqlite3.connect(
                database=self.database, isolation_level=None  # Autocommit mode.
            )
            return DBHandlerStatus(status=True)
        except sqlite3.Error as e:
            return DBHandlerStatus(status=False, error=str(e))

    def disconnect(self):
        """
        Close any existing connections.
        """
        if self.connection:
            self.connection.close()

    def check_connection(self) -> DBHandlerStatus:
        """
        Check connection to the handler.
        Returns:
            DBHandlerStatus
        """
        if self.connection:
            return DBHandlerStatus(status=True)
        else:
            return DBHandlerStatus(status=False, error="Not connected to the database.")

    def get_tables(self) -> DBHandlerResponse:
        """
        Return the list of tables in the database.
        Returns:
            DBHandlerResponse
        """
        if not self.connection:
            return DBHandlerResponse(data=None, error="Not connected to the database.")

        try:
            query = "SELECT name AS table_name FROM sqlite_master WHERE type = 'table'"
            tables_df = pd.read_sql_query(query, self.connection)
            return DBHandlerResponse(data=tables_df)
        except sqlite3.Error as e:
            return DBHandlerResponse(data=None, error=str(e))

    def get_columns(self, table_name: str) -> DBHandlerResponse:
        """
        Returns the list of columns for the given table.
        Args:
            table_name (str): name of the table whose columns are to be retrieved.
        Returns:
            DBHandlerResponse
        """
        if not self.connection:
            return DBHandlerResponse(data=None, error="Not connected to the database.")
        """
        SQLite does not provide an in-built way to get the column names using a SELECT statement.
        Hence we have to use the PRAGMA command and filter the required columns.
        """
        try:
            query = f"PRAGMA table_info('{table_name}')"
            pragma_df = pd.read_sql_query(query, self.connection)
            columns_df = pragma_df[["name", "type"]].copy()
            columns_df.rename(columns={"type": "dtype"}, inplace=True)
            return DBHandlerResponse(data=columns_df)
        except sqlite3.Error as e:
            return DBHandlerResponse(data=None, error=str(e))

    def _fetch_results_as_df(self, cursor):
        try:
            res = cursor.fetchall()
            res_df = pd.DataFrame(
                res,
                columns=[desc[0] for desc in cursor.description]
                if cursor.description
                else [],
            )
            return res_df
        except sqlite3.ProgrammingError as e:
            if str(e) == "no results to fetch":
                return pd.DataFrame({"status": ["success"]})
            raise e

    def execute_native_query(self, query_string: str) -> DBHandlerResponse:
        """
        Executes the native query on the database.
        Args:
            query_string (str): query in native format
        Returns:
            DBHandlerResponse
        """
        if not self.connection:
            return DBHandlerResponse(data=None, error="Not connected to the database.")
        try:
            cursor = self.connection.cursor()
            cursor.execute(query_string)
            return DBHandlerResponse(data=self._fetch_results_as_df(cursor))
        except sqlite3.Error as e:
            return DBHandlerResponse(data=None, error=str(e))

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	import sqlite3	×
16
17	import pandas as pd	×
18
19	from evadb.third_party.databases.types import (	×
20	DBHandler,
21	DBHandlerResponse,
22	DBHandlerStatus,
23	)
24
25
26	class SQLiteHandler(DBHandler):	×
27	def __init__(self, name: str, **kwargs):	×
28	"""
29	Initialize the handler.
30	Args:
31	name (str): name of the DB handler instance
32	**kwargs: arbitrary keyword arguments for establishing the connection.
33	"""
34	super().__init__(name)	×
35	self.database = kwargs.get("database")	×
36	self.connection = None	×
37
38	def connect(self):	×
39	"""
40	Set up the connection required by the handler.
41	Returns:
42	DBHandlerStatus
43	"""
44	try:	×
45	self.connection = sqlite3.connect(	×
46	database=self.database, isolation_level=None # Autocommit mode.
47	)
48	return DBHandlerStatus(status=True)	×
49	except sqlite3.Error as e:
50	return DBHandlerStatus(status=False, error=str(e))
51
52	def disconnect(self):	×
53	"""
54	Close any existing connections.
55	"""
56	if self.connection:	×
57	self.connection.close()	×
58
59	def check_connection(self) -> DBHandlerStatus:	×
60	"""
61	Check connection to the handler.
62	Returns:
63	DBHandlerStatus
64	"""
65	if self.connection:	×
66	return DBHandlerStatus(status=True)	×
67	else:
68	return DBHandlerStatus(status=False, error="Not connected to the database.")	×
69
70	def get_tables(self) -> DBHandlerResponse:	×
71	"""
72	Return the list of tables in the database.
73	Returns:
74	DBHandlerResponse
75	"""
76	if not self.connection:	×
77	return DBHandlerResponse(data=None, error="Not connected to the database.")	×
78
79	try:	×
80	query = "SELECT name AS table_name FROM sqlite_master WHERE type = 'table'"	×
81	tables_df = pd.read_sql_query(query, self.connection)	×
82	return DBHandlerResponse(data=tables_df)	×
83	except sqlite3.Error as e:
84	return DBHandlerResponse(data=None, error=str(e))
85
86	def get_columns(self, table_name: str) -> DBHandlerResponse:	×
87	"""
88	Returns the list of columns for the given table.
89	Args:
90	table_name (str): name of the table whose columns are to be retrieved.
91	Returns:
92	DBHandlerResponse
93	"""
94	if not self.connection:	×
95	return DBHandlerResponse(data=None, error="Not connected to the database.")	×
96	"""	×
97	SQLite does not provide an in-built way to get the column names using a SELECT statement.
98	Hence we have to use the PRAGMA command and filter the required columns.
99	"""
100	try:	×
101	query = f"PRAGMA table_info('{table_name}')"	×
102	pragma_df = pd.read_sql_query(query, self.connection)	×
103	columns_df = pragma_df[["name", "type"]].copy()	×
104	columns_df.rename(columns={"type": "dtype"}, inplace=True)	×
105	return DBHandlerResponse(data=columns_df)	×
106	except sqlite3.Error as e:
107	return DBHandlerResponse(data=None, error=str(e))
108
109	def _fetch_results_as_df(self, cursor):	×
110	try:	×
111	res = cursor.fetchall()	×
112	res_df = pd.DataFrame(	×
113	res,
114	columns=[desc[0] for desc in cursor.description]
115	if cursor.description
116	else [],
117	)
118	return res_df	×
119	except sqlite3.ProgrammingError as e:
120	if str(e) == "no results to fetch":
121	return pd.DataFrame({"status": ["success"]})
122	raise e
123
124	def execute_native_query(self, query_string: str) -> DBHandlerResponse:	×
125	"""
126	Executes the native query on the database.
127	Args:
128	query_string (str): query in native format
129	Returns:
130	DBHandlerResponse
131	"""
132	if not self.connection:	×
133	return DBHandlerResponse(data=None, error="Not connected to the database.")	×
134	try:	×
135	cursor = self.connection.cursor()	×
136	cursor.execute(query_string)	×
137	return DBHandlerResponse(data=self._fetch_results_as_df(cursor))	×
138	except sqlite3.Error as e:
139	return DBHandlerResponse(data=None, error=str(e))

georgia-tech-db / eva / 77c80145-a015-4dd2-b3e6-f861e45e9bae

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