refactor(table-api): unify exception type for all backends to TableNotFound when a table does not exist

ibis/backends/clickhouse/__init__.py

@@ -3,6 +3,7 @@
 import ast
 import contextlib
 import glob
+import re
 from contextlib import closing
 from functools import partial
 from typing import TYPE_CHECKING, Any, Literal
@@ -14,6 +15,7 @@
 import sqlglot as sg
 import sqlglot.expressions as sge
 import toolz
+from clickhouse_connect.driver.exceptions import DatabaseError
 from clickhouse_connect.driver.external import ExternalData
 
 import ibis
@@ -501,8 +503,13 @@ def get_schema(
                 "`catalog` namespaces are not supported by clickhouse"
             )
         query = sge.Describe(this=sg.table(table_name, db=database))
-        with self._safe_raw_sql(query) as results:
-            names, types, *_ = results.result_columns
+        try:
+            with self._safe_raw_sql(query) as results:
+                names, types, *_ = results.result_columns
+        except DatabaseError as e:
+            if re.search(r"\bUNKNOWN_TABLE\b", str(e)):
+                raise com.TableNotFound(table_name) from e
+
         return sch.Schema(
             dict(zip(names, map(self.compiler.type_mapper.from_string, types)))
         )

ibis/backends/dask/__init__.py

@@ -166,11 +166,13 @@ def read_parquet(
         return self.table(table_name)
 
     def get_schema(self, table_name, *, database=None):
-        try:
-            schema = self.schemas[table_name]
-        except KeyError:
-            df = self.dictionary[table_name]
-            self.schemas[table_name] = schema = PandasData.infer_table(df.head(1))
+        df = self.dictionary.get(table_name)
+        if df is None:
+            raise com.TableNotFound(table_name)
+        else:
+            schema = self.schemas.get(table_name)
+            if schema is None:
+                self.schemas[table_name] = schema = PandasData.infer_table(df.head(1))
 
         return schema
 

ibis/backends/datafusion/__init__.py

@@ -320,6 +320,9 @@ def get_schema(
         else:
             database = catalog.database()
 
+        if table_name not in database.names():
+            raise com.TableNotFound(table_name)
+
         table = database.table(table_name)
         return sch.schema(table.schema)
 

ibis/backends/druid/__init__.py

@@ -4,19 +4,22 @@
 
 import contextlib
 import json
+import re
 from typing import TYPE_CHECKING, Any
 from urllib.parse import unquote_plus
 
 import pydruid.db
 import sqlglot as sg
 
+import ibis.common.exceptions as com
 import ibis.expr.datatypes as dt
 import ibis.expr.schema as sch
 from ibis import util
 from ibis.backends.sql import SQLBackend
 from ibis.backends.sql.compilers import DruidCompiler
 from ibis.backends.sql.compilers.base import STAR
 from ibis.backends.sql.datatypes import DruidType
+from ibis.backends.tests.errors import PyDruidProgrammingError
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Mapping
@@ -130,11 +133,17 @@ def get_schema(
         catalog: str | None = None,
         database: str | None = None,
     ) -> sch.Schema:
-        return self._get_schema_using_query(
-            sg.select(STAR)
-            .from_(sg.table(table_name, db=database, catalog=catalog))
-            .sql(self.dialect)
-        )
+        try:
+            schema = self._get_schema_using_query(
+                sg.select(STAR)
+                .from_(sg.table(table_name, db=database, catalog=catalog))
+                .sql(self.dialect)
+            )
+        except PyDruidProgrammingError as e:
+            if re.search(r"\bINVALID_INPUT\b", str(e)):
+                raise com.TableNotFound(table_name) from e
+
+        return schema
 
     def _fetch_from_cursor(self, cursor, schema: sch.Schema) -> pd.DataFrame:
         import pandas as pd

ibis/backends/duckdb/__init__.py

@@ -366,7 +366,7 @@ def get_schema(
             meta = cur.fetch_arrow_table()
 
         if not meta:
-            raise exc.IbisError(f"Table not found: {table_name!r}")
+            raise exc.TableNotFound(table_name)
 
         names = meta["column_name"].to_pylist()
         types = meta["data_type"].to_pylist()

ibis/backends/flink/__init__.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import itertools
+import re
 from typing import TYPE_CHECKING, Any
 
 import sqlglot as sg
@@ -303,7 +304,16 @@
         qualified_name = sg.table(table_name, db=catalog, catalog=database).sql(
             self.name
         )
-        table = self._table_env.from_path(qualified_name)
+        try:
+            table = self._table_env.from_path(qualified_name)
+        except Py4JJavaError as e:
+            # This seems to msg specific but not sure what a good work around is
+            if re.search(
+                rf"Table `{re.escape(table_name)}` was not found",
+                str(e.java_exception.toString()),
+            ):
+                raise exc.TableNotFound(table_name) from e
+
         pyflink_schema = table.get_schema()
 
         return sch.Schema.from_pyarrow(

ibis/backends/mssql/__init__.py

@@ -208,7 +208,7 @@ def get_schema(
 
         if not meta:
             fqn = sg.table(name, db=database, catalog=catalog).sql(self.dialect)
-            raise com.IbisError(f"Table not found: {fqn}")
+            raise com.TableNotFound(fqn)
 
         mapping = {}
         for (

ibis/backends/mysql/__init__.py

@@ -14,6 +14,8 @@
 import pymysql
 import sqlglot as sg
 import sqlglot.expressions as sge
+from pymysql.constants.ER import NO_SUCH_TABLE
+from pymysql.err import ProgrammingError
 
 import ibis
 import ibis.common.exceptions as com
@@ -211,7 +213,6 @@ def _get_schema_using_query(self, query: str) -> sch.Schema:
                 .limit(0)
                 .sql(self.dialect)
             )
-
             return sch.Schema(
                 {
                     field.name: _type_from_cursor_info(descr, field)
@@ -227,8 +228,12 @@ def get_schema(
         ).sql(self.dialect)
 
         with self.begin() as cur:
-            cur.execute(sge.Describe(this=table).sql(self.dialect))
-            result = cur.fetchall()
+            try:
+                cur.execute(sge.Describe(this=table).sql(self.dialect))
+                result = cur.fetchall()
+            except ProgrammingError as e:
+                if e.args[0] == NO_SUCH_TABLE:
+                    raise com.TableNotFound(name) from e
 
         type_mapper = self.compiler.type_mapper
         fields = {

ibis/backends/oracle/__init__.py

@@ -349,7 +349,7 @@ def get_schema(
             results = cur.fetchall()
 
         if not results:
-            raise exc.IbisError(f"Table not found: {name!r}")
+            raise exc.TableNotFound(name)
 
         type_mapper = self.compiler.type_mapper
         fields = {

ibis/backends/pandas/__init__.py

@@ -171,11 +171,13 @@ def table(self, name: str, schema: sch.Schema | None = None):
         return ops.DatabaseTable(name, overridden_schema, self).to_expr()
 
     def get_schema(self, table_name, *, database=None):
-        try:
-            schema = self.schemas[table_name]
-        except KeyError:
-            df = self.dictionary[table_name]
-            self.schemas[table_name] = schema = PandasData.infer_table(df)
+        df = self.dictionary.get(table_name)
+        if df is None:
+            raise com.TableNotFound(table_name)
+        else:
+            schema = self.schemas.get(table_name)
+            if schema is None:
+                self.schemas[table_name] = schema = PandasData.infer_table(df)
 
         return schema
 

ibis/backends/polars/__init__.py

@@ -72,7 +72,11 @@ def list_tables(self, like=None, database=None):
         return self._filter_with_like(list(self._tables.keys()), like)
 
     def table(self, name: str) -> ir.Table:
-        schema = sch.infer(self._tables[name])
+        table = self._tables.get(name)
+        if table is None:
+            raise com.TableNotFound(name)
+
+        schema = sch.infer(table)
         return ops.DatabaseTable(name, schema, self).to_expr()
 
     @deprecated(

ibis/backends/postgres/__init__.py

@@ -603,7 +603,7 @@ def get_schema(
             rows = cur.fetchall()
 
         if not rows:
-            raise com.IbisError(f"Table not found: {name!r}")
+            raise com.TableNotFound(name)
 
         return sch.Schema(
             {

ibis/backends/postgres/tests/test_client.py

@@ -137,7 +137,7 @@ def test_create_and_drop_table(con, temp_table, params):
 
     con.drop_table(temp_table, **params)
 
-    with pytest.raises(com.IbisError):
+    with pytest.raises(com.TableNotFound, match=temp_table):
         con.table(temp_table, **params)
 
 

ibis/backends/pyspark/__init__.py

@@ -11,6 +11,7 @@
 import sqlglot.expressions as sge
 from packaging.version import parse as vparse
 from pyspark import SparkConf
+from pyspark.errors.exceptions.base import AnalysisException
 from pyspark.sql import SparkSession
 from pyspark.sql.types import BooleanType, DoubleType, LongType, StringType
 
@@ -514,7 +515,14 @@ def get_schema(
         table_loc = self._to_sqlglot_table((catalog, database))
         catalog, db = self._to_catalog_db_tuple(table_loc)
         with self._active_catalog_database(catalog, db):
-            df = self._session.table(table_name)
+            try:
+                df = self._session.table(table_name)
+            except AnalysisException as e:
+                # we can alternative check for e.getErrorClass == 'TABLE_OR_VIEW_NOT_FOUND'
+                if e.getSqlState() == "42P01":
+                    # spark sqlerror state for undefined_table see https://spark.apache.org/docs/3.4.1/sql-error-conditions-sqlstates.html
+                    raise com.TableNotFound(table_name)
+
             struct = PySparkType.to_ibis(df.schema)
 
         return sch.Schema(struct)

ibis/backends/sqlite/__init__.py

@@ -224,7 +224,7 @@ def _inspect_schema(
         cur.execute(sql)
         rows = cur.fetchall()
         if not rows:
-            raise com.IbisError(f"Table not found: {table_name!r}")
+            raise com.TableNotFound(table_name)
 
         table_info = {name: (typ, not notnull) for name, typ, notnull in rows}
 

ibis/backends/tests/test_client.py

@@ -1629,3 +1629,8 @@ def test_from_connection(con, top_level):
     new_con = backend.from_connection(getattr(con, CON_ATTR.get(con.name, "con")))
     result = int(new_con.execute(ibis.literal(1, type="int")))
     assert result == 1
+
+
+def test_table_not_found(con):
+    with pytest.raises(com.TableNotFound, match="Table not found"):
+        con.table("foo")

ibis/backends/tests/test_join.py

@@ -11,7 +11,6 @@
 import ibis
 import ibis.common.exceptions as com
 import ibis.expr.schema as sch
-from ibis.backends.tests.errors import PyDruidProgrammingError
 
 sqlite_right_or_full_mark = pytest.mark.notyet(
     ["sqlite"],
@@ -292,7 +291,7 @@ def test_join_with_trivial_predicate(awards_players, predicate, how, pandas_valu
     assert len(result) == len(expected)
 
 
-@pytest.mark.notimpl(["druid"], raises=PyDruidProgrammingError)
+@pytest.mark.notimpl(["druid"], raises=com.TableNotFound)
 @pytest.mark.parametrize(
     ("how", "nrows", "gen_right", "keys"),
     [

ibis/backends/tests/test_window.py

@@ -27,7 +27,12 @@
 
 pytestmark = [
     pytest.mark.notimpl(
-        ["druid"], raises=(com.OperationNotDefinedError, PyDruidProgrammingError)
+        ["druid"],
+        raises=(
+            com.OperationNotDefinedError,
+            com.TableNotFound,
+            PyDruidProgrammingError,
+        ),
     )
 ]
 

ibis/backends/trino/__init__.py

@@ -160,7 +160,7 @@ def get_schema(
 
         if not meta:
             fqn = sg.table(table_name, db=database, catalog=catalog).sql(self.name)
-            raise com.IbisError(f"Table not found: {fqn}")
+            raise com.TableNotFound(fqn)
 
         return sch.Schema(
             {

ibis/backends/trino/tests/test_client.py

@@ -164,7 +164,7 @@ def test_table_access_database_schema(con):
     t = con.table("region", database=("tpch", "sf1"))
     assert t.count().execute()
 
-    with pytest.raises(exc.IbisError, match='Table not found: tpch."tpch.sf1".region'):
+    with pytest.raises(exc.TableNotFound, match=r"Table not found: .*region"):
         con.table("region", database=("tpch", "tpch.sf1"))
 
     with pytest.raises(exc.IbisError, match="Overspecified table hierarchy provided"):

ibis/common/exceptions.py

@@ -21,6 +21,12 @@
     from collections.abc import Callable
 
 
+class TableNotFound(Exception):
+    def __init__(self, table_name, message="Table not found"):
+        self.message = f"{message}: {table_name!r}"
+        super().__init__(self.message)
+
+
 class IbisError(Exception):
     """IbisError."""