Merge branch 'sqla2' into sqla2

Author: chalmerlowe

samples/snippets/requirements.txt

@@ -28,6 +28,6 @@ requests==2.31.0
 rsa==4.9
 shapely==2.0.2
 six==1.16.0
-sqlalchemy===1.4.27
+sqlalchemy===2.0.22
 typing-extensions==4.7.1
 urllib3==1.26.18

setup.py

@@ -101,7 +101,7 @@ def readme():
         "google-auth>=1.25.0,<3.0.0dev",  # Work around pip wack.
         "google-cloud-bigquery>=3.3.6,<4.0.0dev",
         "packaging",
-        "sqlalchemy>=1.4",
+        "sqlalchemy>=2.0,<2.0.23",
     ],
     extras_require=extras,
     python_requires=">=3.8, <3.13",

sqlalchemy_bigquery/_struct.py

@@ -103,6 +103,8 @@ def _setup_getitem(self, name):
         def __getattr__(self, name):
             if name.lower() in self.expr.type._STRUCT_byname:
                 return self[name]
+            else:
+                raise AttributeError(name)
 
     comparator_factory = Comparator
 

sqlalchemy_bigquery/base.py

@@ -972,8 +972,19 @@ def _get_table(self, connection, table_name, schema=None):
         return table
 
     def has_table(self, connection, table_name, schema=None, **kw):
-        """
-        No kw are supported
+        """Checks whether a table exists in BigQuery.
+
+        Args:
+            connection (google.cloud.bigquery.client.Client): The client
+                object used to interact with BigQuery.
+            table_name (str): The name of the table to check for.
+            schema (str, optional): The name of the schema to which the table
+                belongs. Defaults to the default schema.
+            **kw (dict): Any extra keyword arguments will be ignored.
+
+        Returns:
+            bool: True if the table exists, False otherwise.
+
         """
         try:
             self._get_table(connection, table_name, schema)
@@ -1070,8 +1081,10 @@ def __init__(self, *args, **kwargs):
         if isinstance(arg, sqlalchemy.sql.expression.ColumnElement):
             if not (
                 isinstance(arg.type, sqlalchemy.sql.sqltypes.ARRAY)
-                or (hasattr(arg.type, "impl")
-                    and isinstance(arg.type.impl, sqlalchemy.sql.sqltypes.ARRAY))
+                or (
+                    hasattr(arg.type, "impl")
+                    and isinstance(arg.type.impl, sqlalchemy.sql.sqltypes.ARRAY)
+                )
             ):
                 raise TypeError("The argument to unnest must have an ARRAY type.")
             self.type = arg.type.item_type

sqlalchemy_bigquery/requirements.py

@@ -135,13 +135,12 @@ def schemas(self):
         named 'test_schema'."""
 
         return unsupported()
-    
+
     @property
     def array_type(self):
         """Target database must support array_type"""
         return supported()
 
-
     @property
     def implicit_default_schema(self):
         """target system has a strong concept of 'default' schema that can

tests/sqlalchemy_dialect_compliance/test_dialect_compliance.py

@@ -44,9 +44,6 @@
     QuotedNameArgumentTest,
     SimpleUpdateDeleteTest as _SimpleUpdateDeleteTest,
     TimestampMicrosecondsTest as _TimestampMicrosecondsTest,
-    TrueDivTest as _TrueDivTest,
-    IntegerTest as _IntegerTest,
-    NumericTest as _NumericTest,
 )
 
 from sqlalchemy.testing.suite.test_types import (
@@ -63,15 +60,17 @@
 
 if packaging.version.parse(sqlalchemy.__version__) >= packaging.version.parse("2.0"):
     from sqlalchemy.sql import type_coerce
+    from sqlalchemy.testing.suite import (
+        TrueDivTest as _TrueDivTest,
+        IntegerTest as _IntegerTest,
+        NumericTest as _NumericTest,
+        DifficultParametersTest as _DifficultParametersTest,
+        FetchLimitOffsetTest as _FetchLimitOffsetTest,
+    )
 
     class TimestampMicrosecondsTest(_TimestampMicrosecondsTest):
         data = datetime.datetime(2012, 10, 15, 12, 57, 18, 396, tzinfo=pytz.UTC)
 
-        # TimestampMicrosecondsTest literal() no literal_execute parameter? Go back and add to literal()"
-        @pytest.mark.skip("")
-        def test_literal(self, literal_round_trip):
-            pass
-
         def test_select_direct(self, connection):
             # This func added because this test was failing when passed the
             # UTC timezone.
@@ -106,14 +105,12 @@ def test_round_trip_executemany(self, connection):
         test_round_trip_executemany
     )
 
-    # TrueDivTest issue because 1.4 always rounded down, but 2.0 rounds based on the data types. The assertion cannot reconcile 1.5==1 thusly
     class TrueDivTest(_TrueDivTest):
-        @pytest.mark.skip("SQLAlchemy 2.0 rounds based on datatype")
+        @pytest.mark.skip("BQ rounds based on datatype")
         def test_floordiv_integer(self):
-            # TODO: possibly compare rounded result instead?
             pass
 
-        @pytest.mark.skip("SQLAlchemy 2.0 rounds based on datatype")
+        @pytest.mark.skip("BQ rounds based on datatype")
         def test_floordiv_integer_bound(self):
             pass
 
@@ -151,8 +148,9 @@ class InsertBehaviorTest(_InsertBehaviorTest):
         def test_insert_from_select_autoinc(cls):
             pass
 
-        # TODO: Find cause of error
-        @pytest.mark.skip("")
+        @pytest.mark.skip(
+            "BQ has no autoinc and client-side defaults can't work for select."
+        )
         def test_no_results_for_non_returning_insert(cls):
             pass
 
@@ -178,7 +176,7 @@ def run(type_, input_, output, filter_=None, check_scale=False):
 
                 where_expr = True
 
-                # Adding where clause
+                # Adding where clause for 2.0 compatibility
                 connection.execute(t.delete().where(where_expr))
 
                 # test that this is actually a number!
@@ -203,6 +201,142 @@ def run(type_, input_, output, filter_=None, check_scale=False):
 
             return run
 
+    class DifficultParametersTest(_DifficultParametersTest):
+        # removed parameters that dont work with bigquery
+        tough_parameters = testing.combinations(
+            ("boring",),
+            ("per cent",),
+            ("per % cent",),
+            ("%percent",),
+            ("col:ons",),
+            ("_starts_with_underscore",),
+            ("more :: %colons%",),
+            ("_name",),
+            ("___name",),
+            ("42numbers",),
+            ("percent%signs",),
+            ("has spaces",),
+            ("1param",),
+            ("1col:on",),
+            argnames="paramname",
+        )
+
+        @tough_parameters
+        @config.requirements.unusual_column_name_characters
+        def test_round_trip_same_named_column(self, paramname, connection, metadata):
+            name = paramname
+
+            t = Table(
+                "t",
+                metadata,
+                Column("id", Integer, primary_key=True),
+                Column(name, String(50), nullable=False),
+            )
+
+            # table is created
+            t.create(connection)
+
+            # automatic param generated by insert
+            connection.execute(t.insert().values({"id": 1, name: "some name"}))
+
+            # automatic param generated by criteria, plus selecting the column
+            stmt = select(t.c[name]).where(t.c[name] == "some name")
+
+            eq_(connection.scalar(stmt), "some name")
+
+            # use the name in a param explicitly
+            stmt = select(t.c[name]).where(t.c[name] == bindparam(name))
+
+            row = connection.execute(stmt, {name: "some name"}).first()
+
+            # name works as the key from cursor.description
+            eq_(row._mapping[name], "some name")
+
+            # use expanding IN
+            stmt = select(t.c[name]).where(
+                t.c[name].in_(["some name", "some other_name"])
+            )
+
+            row = connection.execute(stmt).first()
+
+        @testing.fixture
+        def multirow_fixture(self, metadata, connection):
+            mytable = Table(
+                "mytable",
+                metadata,
+                Column("myid", Integer),
+                Column("name", String(50)),
+                Column("desc", String(50)),
+            )
+
+            mytable.create(connection)
+
+            connection.execute(
+                mytable.insert(),
+                [
+                    {"myid": 1, "name": "a", "desc": "a_desc"},
+                    {"myid": 2, "name": "b", "desc": "b_desc"},
+                    {"myid": 3, "name": "c", "desc": "c_desc"},
+                    {"myid": 4, "name": "d", "desc": "d_desc"},
+                ],
+            )
+            yield mytable
+
+        @tough_parameters
+        def test_standalone_bindparam_escape(
+            self, paramname, connection, multirow_fixture
+        ):
+            tbl1 = multirow_fixture
+            stmt = select(tbl1.c.myid).where(
+                tbl1.c.name == bindparam(paramname, value="x")
+            )
+            res = connection.scalar(stmt, {paramname: "c"})
+            eq_(res, 3)
+
+        @tough_parameters
+        def test_standalone_bindparam_escape_expanding(
+            self, paramname, connection, multirow_fixture
+        ):
+            tbl1 = multirow_fixture
+            stmt = (
+                select(tbl1.c.myid)
+                .where(tbl1.c.name.in_(bindparam(paramname, value=["a", "b"])))
+                .order_by(tbl1.c.myid)
+            )
+
+            res = connection.scalars(stmt, {paramname: ["d", "a"]}).all()
+            eq_(res, [1, 4])
+
+    class FetchLimitOffsetTest(_FetchLimitOffsetTest):
+        @pytest.mark.skip("BigQuery doesn't allow an offset without a limit.")
+        def test_simple_offset(self):
+            pass
+
+        test_bound_offset = test_simple_offset
+        test_expr_offset = test_simple_offset_zero = test_simple_offset
+
+        # The original test is missing an order by.
+
+        # Also, note that sqlalchemy union is a union distinct, not a
+        # union all. This test caught that were were getting that wrong.
+        def test_limit_render_multiple_times(self, connection):
+            table = self.tables.some_table
+            stmt = select(table.c.id).order_by(table.c.id).limit(1).scalar_subquery()
+
+            u = sqlalchemy.union(select(stmt), select(stmt)).subquery().select()
+
+            self._assert_result(
+                connection,
+                u,
+                [(1,)],
+            )
+
+    # from else statement ....
+    del DistinctOnTest  # expects unquoted table names.
+    del HasIndexTest  # BQ doesn't do the indexes that SQLA is loooking for.
+    del IdentityAutoincrementTest  # BQ doesn't do autoincrement
+
+
 elif packaging.version.parse(sqlalchemy.__version__) < packaging.version.parse("1.4"):
     from sqlalchemy.testing.suite import LimitOffsetTest as _LimitOffsetTest
 

tests/system/test_geography.py

@@ -128,7 +128,9 @@ def test_geoalchemy2_core(bigquery_dataset):
         int(
             list(
                 conn.execute(
-                    select(lake_table.c.geog.st_area(), lake_table.c.name == "test2")
+                    select(lake_table.c.geog.st_area()).where(
+                        lake_table.c.name == "test2"
+                    )
                 )
             )[0][0]
         )