refactor(oracle): more test fixups

ibis/backends/base/sqlglot/datatypes.py

@@ -568,11 +568,7 @@ class OracleType(SqlglotType):
 
     default_temporal_scale = 9
 
-    unknown_type_strings = FrozenDict(
-        {
-            "raw": dt.binary,
-        }
-    )
+    unknown_type_strings = FrozenDict({"raw": dt.binary})
 
     @classmethod
     def _from_sqlglot_FLOAT(cls) -> dt.Float64:

ibis/backends/oracle/compiler.py

@@ -158,6 +158,15 @@ def visit_Literal(self, op, *, value, dtype):
             )
         elif dtype.is_uuid():
             return sge.convert(str(value))
+        elif dtype.is_interval():
+            if dtype.unit.short in ("Y", "M"):
+                return self.f.numtoyminterval(value, dtype.unit.name)
+            elif dtype.unit.short in ("D", "h", "m", "s"):
+                return self.f.numtodsinterval(value, dtype.unit.name)
+            else:
+                raise com.UnsupportedOperationError(
+                    f"Intervals with precision {dtype.unit.name} not supported in Oracle."
+                )
 
         return super().visit_Literal(op, value=value, dtype=dtype)
 
@@ -224,6 +233,50 @@ def visit_Limit(self, op, *, parent, n, offset):
     def visit_Date(self, op, *, arg):
         return sg.cast(arg, to="date")
 
+    # @visit_node.register(ops.TimestampFromYMDHMS)
+    # def visit_TimestampFromYMDHMS(
+    #     self, op, *, year, month, day, hours, minutes, seconds
+    # ):
+    #     date_str = self.f.concat(
+    #         self.f.lpad(self.cast(year, dt.string), 4, "0"),
+    #         self.f.concat(
+    #             "-",
+    #             self.f.concat(
+    #                 self.f.lpad(self.cast(month, dt.string), 2, "0"),
+    #                 self.f.concat(
+    #                     "-",
+    #                     self.f.concat(
+    #                         self.f.lpad(self.cast(day, dt.string), 2, "0"),
+    #                         self.f.concat(
+    #                             "T",
+    #                             self.f.concat(
+    #                                 self.f.lpad(self.cast(hours, dt.string), 2, "0"),
+    #                                 self.f.concat(
+    #                                     ":",
+    #                                     self.f.concat(
+    #                                         self.f.lpad(
+    #                                             self.cast(minutes, dt.string), 2, "0"
+    #                                         ),
+    #                                         self.f.concat(
+    #                                             ":",
+    #                                             self.f.lpad(
+    #                                                 self.cast(seconds, dt.string),
+    #                                                 2,
+    #                                                 "0",
+    #                                             ),
+    #                                         ),
+    #                                     ),
+    #                                 ),
+    #                             ),
+    #                         ),
+    #                     ),
+    #                 ),
+    #             ),
+    #         ),
+    #     )
+    #     expr = self.f.to_timestamp(date_str, 'YYYY-MM-DD"T"HH24:MI:SS')
+    #     return expr
+
     @visit_node.register(ops.IsNan)
     def visit_IsNan(self, op, *, arg):
         return arg.eq(self.NAN)
@@ -503,6 +556,8 @@ def visit_Window(self, op, *, how, func, start, end, group_by, order_by):
     @visit_node.register(ops.DateDelta)
     @visit_node.register(ops.TimestampDelta)
     @visit_node.register(ops.TimestampNow)
+    @visit_node.register(ops.TimestampFromYMDHMS)
+    @visit_node.register(ops.TimeFromHMS)
     @visit_node.register(ops.IntervalFromInteger)
     @visit_node.register(ops.DayOfWeekIndex)
     @visit_node.register(ops.DayOfWeekName)

ibis/backends/tests/errors.py

@@ -111,3 +111,8 @@
     from pydruid.db.exceptions import ProgrammingError as PyDruidProgrammingError
 except ImportError:
     PyDruidProgrammingError = None
+
+try:
+    from oracledb.exceptions import DatabaseError as OracleDatabaseError
+except ImportError:
+    OracleDatabaseError = None

ibis/backends/tests/test_aggregation.py

@@ -1144,6 +1144,11 @@ def test_median(alltypes, df):
     raises=ClickHouseDatabaseError,
     reason="doesn't support median of strings",
 )
+@pytest.mark.notyet(
+    ["oracle"],
+    raises=OracleDatabaseError,
+    reason="doesn't support median of strings",
+)
 @pytest.mark.broken(
     ["pyspark"], raises=AssertionError, reason="pyspark returns null for string median"
 )

ibis/backends/tests/test_asof_join.py

@@ -91,6 +91,7 @@ def time_keyed_right(time_keyed_df2):
         "druid",
         "impala",
         "bigquery",
+        "oracle",
     ]
 )
 def test_asof_join(con, time_left, time_right, time_df1, time_df2, direction, op):
@@ -127,6 +128,7 @@ def test_asof_join(con, time_left, time_right, time_df1, time_df2, direction, op
         "druid",
         "impala",
         "bigquery",
+        "oracle",
     ]
 )
 def test_keyed_asof_join_with_tolerance(

ibis/backends/tests/test_binary.py

@@ -21,7 +21,7 @@
 
 
 @pytest.mark.notimpl(
-    ["clickhouse", "impala", "druid"],
+    ["clickhouse", "impala", "druid", "oracle"],
     "Unsupported type: Binary(nullable=True)",
     raises=NotImplementedError,
 )

ibis/backends/tests/test_generic.py

@@ -25,6 +25,7 @@
     GoogleBadRequest,
     ImpalaHiveServer2Error,
     MySQLProgrammingError,
+    OracleDatabaseError,
     PyDruidProgrammingError,
     SnowflakeProgrammingError,
     TrinoUserError,
@@ -415,11 +416,7 @@ def test_table_fillna_invalid(alltypes):
     "replacements",
     [
         param({"int_col": 20}, id="int"),
-        param(
-            {"double_col": -1, "string_col": "missing"},
-            id="double-int-str",
-            marks=[pytest.mark.notimpl(["oracle"])],
-        ),
+        param({"double_col": -1, "string_col": "missing"}, id="double-int-str"),
         param({"double_col": -1.5, "string_col": "missing"}, id="double-str"),
     ],
 )
@@ -437,7 +434,6 @@ def test_table_fillna_mapping(backend, alltypes, replacements):
     backend.assert_frame_equal(result, expected, check_dtype=False)
 
 
-@pytest.mark.notimpl(["oracle"])
 def test_table_fillna_scalar(backend, alltypes):
     table = alltypes.mutate(
         int_col=alltypes.int_col.nullif(1),

ibis/backends/tests/test_numeric.py

@@ -352,6 +352,7 @@ def test_numeric_literal(con, backend, expr, expected_types):
                 pytest.mark.notimpl(["exasol"], raises=ExaQueryError),
                 pytest.mark.notimpl(["mysql"], raises=MySQLOperationalError),
                 pytest.mark.notyet(["snowflake"], raises=SnowflakeProgrammingError),
+                pytest.mark.notyet(["oracle"], raises=OracleDatabaseError),
                 pytest.mark.notyet(["impala"], raises=ImpalaHiveServer2Error),
                 pytest.mark.broken(
                     ["duckdb"],
@@ -696,7 +697,7 @@ def test_decimal_literal(con, backend, expr, expected_types, expected_result):
     ],
 )
 @pytest.mark.notimpl(
-    ["sqlite", "mssql", "oracle", "flink", "druid"], raises=com.OperationNotDefinedError
+    ["sqlite", "mssql", "flink", "druid"], raises=com.OperationNotDefinedError
 )
 @pytest.mark.notimpl(["mysql"], raises=(MySQLOperationalError, NotImplementedError))
 def test_isnan_isinf(
@@ -1556,7 +1557,25 @@ def test_bitwise_shift(backend, alltypes, df, op, left_fn, right_fn):
 
 @pytest.mark.parametrize(
     "op",
-    [and_, or_, xor, lshift, rshift],
+    [
+        and_,
+        param(
+            or_,
+            marks=pytest.mark.notimpl(["oracle"], raises=OracleDatabaseError),
+        ),
+        param(
+            xor,
+            marks=pytest.mark.notimpl(["oracle"], raises=OracleDatabaseError),
+        ),
+        param(
+            lshift,
+            marks=[pytest.mark.notimpl(["oracle"], raises=OracleDatabaseError)],
+        ),
+        param(
+            rshift,
+            marks=[pytest.mark.notimpl(["oracle"], raises=OracleDatabaseError)],
+        ),
+    ],
 )
 @pytest.mark.parametrize(
     ("left", "right"),

ibis/backends/tests/test_param.py

@@ -11,7 +11,7 @@
 import ibis
 import ibis.expr.datatypes as dt
 from ibis import _
-from ibis.backends.tests.errors import Py4JJavaError
+from ibis.backends.tests.errors import OracleDatabaseError, Py4JJavaError
 
 
 @pytest.mark.parametrize(

ibis/backends/tests/test_string.py

@@ -11,7 +11,11 @@
 import ibis
 import ibis.common.exceptions as com
 import ibis.expr.datatypes as dt
-from ibis.backends.tests.errors import ClickHouseDatabaseError, PyDruidProgrammingError
+from ibis.backends.tests.errors import (
+    ClickHouseDatabaseError,
+    OracleDatabaseError,
+    PyDruidProgrammingError,
+)
 from ibis.common.annotations import ValidationError
 
 
@@ -185,7 +189,7 @@ def uses_java_re(t):
             id="rlike",
             marks=[
                 pytest.mark.notimpl(
-                    ["mssql", "oracle", "exasol"], raises=com.OperationNotDefinedError
+                    ["mssql", "exasol"], raises=com.OperationNotDefinedError
                 ),
             ],
         ),
@@ -195,7 +199,7 @@ def uses_java_re(t):
             id="re_search_substring",
             marks=[
                 pytest.mark.notimpl(
-                    ["mssql", "oracle", "exasol"], raises=com.OperationNotDefinedError
+                    ["mssql", "exasol"], raises=com.OperationNotDefinedError
                 ),
             ],
         ),
@@ -205,7 +209,7 @@ def uses_java_re(t):
             id="re_search",
             marks=[
                 pytest.mark.notimpl(
-                    ["mssql", "oracle", "exasol"], raises=com.OperationNotDefinedError
+                    ["mssql", "exasol"], raises=com.OperationNotDefinedError
                 ),
             ],
         ),

ibis/backends/tests/test_temporal.py

@@ -1048,11 +1048,6 @@ def test_temporal_binop(backend, con, alltypes, df, expr_fn, expected_fn):
                     raises=AssertionError,
                     reason="DateTime column overflows, should use DateTime64",
                 ),
-                pytest.mark.broken(
-                    ["clickhouse"],
-                    raises=AssertionError,
-                    reason="DateTime column overflows, should use DateTime64",
-                ),
                 pytest.mark.notimpl(
                     ["flink"],
                     # Note (mehmet): Following cannot be imported for backends other than Flink.
@@ -1137,11 +1132,6 @@ def test_temporal_binop(backend, con, alltypes, df, expr_fn, expected_fn):
                     raises=AssertionError,
                     reason="DateTime column overflows, should use DateTime64",
                 ),
-                pytest.mark.broken(
-                    ["clickhouse"],
-                    raises=AssertionError,
-                    reason="DateTime column overflows, should use DateTime64",
-                ),
                 pytest.mark.broken(
                     ["flink"],
                     # Note (mehmet): Following cannot be imported for backends other than Flink.
@@ -1843,9 +1833,6 @@ def test_date_literal(con, backend):
     ["pandas", "dask", "pyspark", "mysql", "oracle"],
     raises=com.OperationNotDefinedError,
 )
-@pytest.mark.notimpl(
-    ["oracle"], raises=sa.exc.DatabaseError, reason="ORA-00904: MAKE TIMESTAMP invalid"
-)
 @pytest.mark.notyet(["impala"], raises=com.OperationNotDefinedError)
 @pytest.mark.notimpl(["exasol"], raises=ExaQueryError)
 def test_timestamp_literal(con, backend):
@@ -1924,11 +1911,10 @@ def test_timestamp_with_timezone_literal(con, timezone, expected):
 
 
 @pytest.mark.notimpl(
-    ["pandas", "datafusion", "dask", "pyspark", "polars", "mysql"],
+    ["pandas", "datafusion", "dask", "pyspark", "polars", "mysql", "oracle"],
     raises=com.OperationNotDefinedError,
 )
 @pytest.mark.notyet(["clickhouse", "impala"], raises=com.OperationNotDefinedError)
-@pytest.mark.notimpl(["oracle"], raises=sa.exc.DatabaseError)
 @pytest.mark.notimpl(["druid"], raises=com.OperationNotDefinedError)
 @pytest.mark.notimpl(["exasol"], raises=ExaQueryError)
 def test_time_literal(con, backend):
@@ -1957,7 +1943,7 @@ def test_time_literal(con, backend):
     ["sqlite"], raises=AssertionError, reason="SQLite returns Timedelta from execution"
 )
 @pytest.mark.notimpl(["dask"], raises=com.OperationNotDefinedError)
-@pytest.mark.notyet(["oracle"], raises=sa.exc.DatabaseError)
+@pytest.mark.notyet(["oracle"], raises=OracleDatabaseError)
 @pytest.mark.parametrize(
     "microsecond",
     [
@@ -2108,7 +2094,7 @@ def test_timestamp_column_from_ymdhms(backend, con, alltypes, df):
 
 
 @pytest.mark.notimpl(
-    ["oracle"], raises=sa.exc.DatabaseError, reason="ORA-01861 literal does not match"
+    ["oracle"], raises=OracleDatabaseError, reason="ORA-01861 literal does not match"
 )
 def test_date_scalar_from_iso(con):
     expr = ibis.literal("2022-02-24")
@@ -2169,7 +2155,7 @@ def test_integer_cast_to_timestamp_column(backend, alltypes, df):
     backend.assert_series_equal(result, expected.astype(result.dtype))
 
 
-@pytest.mark.notimpl(["oracle"], raises=sa.exc.DatabaseError)
+@pytest.mark.notimpl(["oracle"], raises=OracleDatabaseError)
 @pytest.mark.notimpl(["exasol"], raises=sa.exc.DBAPIError)
 def test_integer_cast_to_timestamp_scalar(alltypes, df):
     expr = alltypes.int_col.min().cast("timestamp")
@@ -2217,7 +2203,7 @@ def build_date_col(t):
 
 @pytest.mark.notimpl(["mssql"], raises=com.OperationNotDefinedError)
 @pytest.mark.notimpl(["druid"], raises=PyDruidProgrammingError)
-@pytest.mark.notimpl(["oracle"], raises=sa.exc.DatabaseError)
+@pytest.mark.notimpl(["oracle"], raises=OracleDatabaseError)
 @pytest.mark.parametrize(
     ("left_fn", "right_fn"),
     [
@@ -2435,7 +2421,6 @@ def test_delta(con, start, end, unit, expected):
         "flink",
         "impala",
         "mysql",
-        "oracle",
         "pandas",
         "pyspark",
         "sqlite",
@@ -2470,6 +2455,11 @@ def test_delta(con, start, end, unit, expected):
                     raises=com.UnsupportedOperationError,
                     reason="backend doesn't support sub-second interval precision",
                 ),
+                pytest.mark.notimpl(
+                    ["oracle"],
+                    raises=com.UnsupportedOperationError,
+                    reason="backend doesn't support sub-second interval precision",
+                ),
             ],
             id="milliseconds",
         ),
@@ -2478,7 +2468,7 @@ def test_delta(con, start, end, unit, expected):
             "2s",
             marks=[
                 pytest.mark.notimpl(
-                    ["datafusion"],
+                    ["datafusion", "oracle"],
                     raises=com.OperationNotDefinedError,
                 ),
             ],
@@ -2489,7 +2479,7 @@ def test_delta(con, start, end, unit, expected):
             "300s",
             marks=[
                 pytest.mark.notimpl(
-                    ["datafusion"],
+                    ["datafusion", "oracle"],
                     raises=com.OperationNotDefinedError,
                 ),
             ],
@@ -2500,7 +2490,7 @@ def test_delta(con, start, end, unit, expected):
             "2h",
             marks=[
                 pytest.mark.notimpl(
-                    ["datafusion"],
+                    ["datafusion", "oracle"],
                     raises=com.OperationNotDefinedError,
                 ),
             ],
@@ -2511,7 +2501,7 @@ def test_delta(con, start, end, unit, expected):
             "2D",
             marks=[
                 pytest.mark.notimpl(
-                    ["datafusion"],
+                    ["datafusion", "oracle"],
                     raises=com.OperationNotDefinedError,
                 ),
             ],