From bc0367c670cc1376b90ab2309085bd660ec317c9 Mon Sep 17 00:00:00 2001 From: Mike Bayer Date: Fri, 10 Jun 2022 12:57:53 -0400 Subject: [PATCH] resolve large ints to BigInteger The in-place type detection for Python integers, as occurs with an expression such as ``literal(25)``, will now apply value-based adaption as well to accommodate Python large integers, where the datatype determined will be :class:`.BigInteger` rather than :class:`.Integer`. This accommodates for dialects such as that of asyncpg which both sends implicit typing information to the driver as well as is sensitive to numeric scale. Fixes: #7909 Change-Id: I1cd3ec2676c9bb03ffedb600695252bd0037ba02 --- doc/build/changelog/unreleased_20/7909.rst | 10 +++++++ lib/sqlalchemy/sql/sqltypes.py | 7 +++++ lib/sqlalchemy/testing/suite/test_types.py | 33 ++++++++++++++++++++-- 3 files changed, 48 insertions(+), 2 deletions(-) create mode 100644 doc/build/changelog/unreleased_20/7909.rst diff --git a/doc/build/changelog/unreleased_20/7909.rst b/doc/build/changelog/unreleased_20/7909.rst new file mode 100644 index 0000000000..e003b85887 --- /dev/null +++ b/doc/build/changelog/unreleased_20/7909.rst @@ -0,0 +1,10 @@ +.. change:: + :tags: bug, sql + :tickets: 7909 + + The in-place type detection for Python integers, as occurs with an + expression such as ``literal(25)``, will now apply value-based adaption as + well to accommodate Python large integers, where the datatype determined + will be :class:`.BigInteger` rather than :class:`.Integer`. This + accommodates for dialects such as that of asyncpg which both sends implicit + typing information to the driver as well as is sensitive to numeric scale. diff --git a/lib/sqlalchemy/sql/sqltypes.py b/lib/sqlalchemy/sql/sqltypes.py index 50cb325033..2cc46107b0 100644 --- a/lib/sqlalchemy/sql/sqltypes.py +++ b/lib/sqlalchemy/sql/sqltypes.py @@ -366,6 +366,12 @@ class Integer(HasExpressionLookup, TypeEngine[int]): def python_type(self): return int + def _resolve_for_literal(self, value): + if value.bit_length() >= 32: + return _BIGINTEGER + else: + return self + def literal_processor(self, dialect): def process(value): return str(int(value)) @@ -3556,6 +3562,7 @@ MATCHTYPE = MatchType() TABLEVALUE = TableValueType() DATETIME_TIMEZONE = DateTime(timezone=True) TIME_TIMEZONE = Time(timezone=True) +_BIGINTEGER = BigInteger() _DATETIME = DateTime() _TIME = Time() _STRING = String() diff --git a/lib/sqlalchemy/testing/suite/test_types.py b/lib/sqlalchemy/testing/suite/test_types.py index f1e3768377..3913799569 100644 --- a/lib/sqlalchemy/testing/suite/test_types.py +++ b/lib/sqlalchemy/testing/suite/test_types.py @@ -565,8 +565,37 @@ class IntegerTest(_LiteralRoundTripFixture, fixtures.TestBase): def test_literal(self, literal_round_trip): literal_round_trip(Integer, [5], [5]) - def test_huge_int(self, integer_round_trip): - integer_round_trip(BigInteger, 1376537018368127) + def _huge_ints(): + + return testing.combinations( + 2147483649, # 32 bits + 2147483648, # 32 bits + 2147483647, # 31 bits + 2147483646, # 31 bits + -2147483649, # 32 bits + -2147483648, # 32 interestingly, asyncpg accepts this one as int32 + -2147483647, # 31 + -2147483646, # 31 + 0, + 1376537018368127, + -1376537018368127, + argnames="intvalue", + ) + + @_huge_ints() + def test_huge_int_auto_accommodation(self, connection, intvalue): + """test #7909""" + + eq_( + connection.scalar( + select(intvalue).where(literal(intvalue) == intvalue) + ), + intvalue, + ) + + @_huge_ints() + def test_huge_int(self, integer_round_trip, intvalue): + integer_round_trip(BigInteger, intvalue) @testing.fixture def integer_round_trip(self, metadata, connection): -- 2.47.2