Implement generic Double and related fixed types

Added :class:`.Double`, :class:`.DOUBLE`, :class:`.DOUBLE_PRECISION`
datatypes to the base ``sqlalchemy.`` module namespace, for explicit use of
double/double precision as well as generic "double" datatypes. Use
:class:`.Double` for generic support that will resolve to DOUBLE/DOUBLE
PRECISION/FLOAT as needed for different backends.

Implemented DDL and reflection support for ``FLOAT`` datatypes which
include an explicit "binary_precision" value. Using the Oracle-specific
:class:`_oracle.FLOAT` datatype, the new parameter
:paramref:`_oracle.FLOAT.binary_precision` may be specified which will
render Oracle's precision for floating point types directly. This value is
interpreted during reflection. Upon reflecting back a ``FLOAT`` datatype,
the datatype returned is one of :class:`_types.DOUBLE_PRECISION` for a
``FLOAT`` for a precision of 126 (this is also Oracle's default precision
for ``FLOAT``), :class:`_types.REAL` for a precision of 63, and
:class:`_oracle.FLOAT` for a custom precision, as per Oracle documentation.

As part of this change, the generic :paramref:`_sqltypes.Float.precision`
value is explicitly rejected when generating DDL for Oracle, as this
precision cannot be accurately converted to "binary precision"; instead, an
error message encourages the use of
:meth:`_sqltypes.TypeEngine.with_variant` so that Oracle's specific form of
precision may be chosen exactly. This is a backwards-incompatible change in
behavior, as the previous "precision" value was silently ignored for
Oracle.

Fixes: #5465
Closes: #7674
Pull-request: https://github.com/sqlalchemy/sqlalchemy/pull/7674
Pull-request-sha: 5c68419e5aee2e27bf21a8ac9eb5950d196c77e5

Change-Id: I831f4af3ee3b23fde02e8f6393c83e23dd7cd34d

1 files changed, 20 insertions, 9 deletions

diff --git a/test/dialect/oracle/test_reflection.py b/test/dialect/oracle/test_reflection.py
index df8dff30f..215f4ecd5 100644
--- a/test/dialect/oracle/test_reflection.py
+++ b/test/dialect/oracle/test_reflection.py
@@ -1,8 +1,10 @@
 # coding: utf-8
 
 
+from sqlalchemy import Double
 from sqlalchemy import exc
 from sqlalchemy import FLOAT
+from sqlalchemy import Float
 from sqlalchemy import ForeignKey
 from sqlalchemy import ForeignKeyConstraint
 from sqlalchemy import func
@@ -19,10 +21,12 @@ from sqlalchemy import testing
 from sqlalchemy import text
 from sqlalchemy import Unicode
 from sqlalchemy import UniqueConstraint
+from sqlalchemy.dialects import oracle
 from sqlalchemy.dialects.oracle.base import BINARY_DOUBLE
 from sqlalchemy.dialects.oracle.base import BINARY_FLOAT
 from sqlalchemy.dialects.oracle.base import DOUBLE_PRECISION
 from sqlalchemy.dialects.oracle.base import NUMBER
+from sqlalchemy.dialects.oracle.base import REAL
 from sqlalchemy.testing import assert_warns
 from sqlalchemy.testing import AssertsCompiledSQL
 from sqlalchemy.testing import eq_
@@ -803,17 +807,24 @@ class TypeReflectionTest(fixtures.TestBase):
         connection,
     ):
         specs = [
-            (DOUBLE_PRECISION(), FLOAT()),
-            # when binary_precision is supported
-            # (DOUBLE_PRECISION(), oracle.FLOAT(binary_precision=126)),
+            (DOUBLE_PRECISION(), DOUBLE_PRECISION()),
+            (Double(), DOUBLE_PRECISION()),
+            (REAL(), REAL()),
             (BINARY_DOUBLE(), BINARY_DOUBLE()),
             (BINARY_FLOAT(), BINARY_FLOAT()),
-            (FLOAT(5), FLOAT()),
-            # when binary_precision is supported
-            # (FLOAT(5), oracle.FLOAT(binary_precision=5),),
-            (FLOAT(), FLOAT()),
-            # when binary_precision is supported
-            # (FLOAT(5), oracle.FLOAT(binary_precision=126),),
+            (oracle.FLOAT(5), oracle.FLOAT(5)),
+            (
+                Float(5).with_variant(
+                    oracle.FLOAT(binary_precision=16), "oracle"
+                ),
+                oracle.FLOAT(16),
+            ),  # using conversion
+            (FLOAT(), DOUBLE_PRECISION()),
+            # from https://docs.oracle.com/cd/B14117_01/server.101/b10758/sqlqr06.htm  # noqa E501
+            # DOUBLE PRECISION == precision 126
+            # REAL == precision 63
+            (oracle.FLOAT(126), DOUBLE_PRECISION()),
+            (oracle.FLOAT(63), REAL()),
         ]
         self._run_test(metadata, connection, specs, ["precision"])