Revert "chore: cleanup compliance tests for sqlalchemy migration" (#1015)

Author: kiraksi

sqlalchemy_bigquery/_struct.py

@@ -17,14 +17,20 @@
 # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+import packaging.version
 import sqlalchemy.sql.default_comparator
 import sqlalchemy.sql.sqltypes
 import sqlalchemy.types
 
 from . import base
 
-import sqlalchemy.sql.coercions
-import sqlalchemy.sql.roles
+sqlalchemy_1_4_or_more = packaging.version.parse(
+    sqlalchemy.__version__
+) >= packaging.version.parse("1.4")
+
+if sqlalchemy_1_4_or_more:
+    import sqlalchemy.sql.coercions
+    import sqlalchemy.sql.roles
 
 
 def _get_subtype_col_spec(type_):
@@ -103,14 +109,30 @@ def __getattr__(self, name):
     comparator_factory = Comparator
 
 
-def _field_index(self, name, operator):
-    return sqlalchemy.sql.coercions.expect(
-        sqlalchemy.sql.roles.BinaryElementRole,
-        name,
-        expr=self.expr,
-        operator=operator,
-        bindparam_type=sqlalchemy.types.String(),
-    )
+# In the implementations of _field_index below, we're stealing from
+# the JSON type implementation, but the code to steal changed in
+# 1.4. :/
+
+if sqlalchemy_1_4_or_more:
+
+    def _field_index(self, name, operator):
+        return sqlalchemy.sql.coercions.expect(
+            sqlalchemy.sql.roles.BinaryElementRole,
+            name,
+            expr=self.expr,
+            operator=operator,
+            bindparam_type=sqlalchemy.types.String(),
+        )
+
+else:
+
+    def _field_index(self, name, operator):
+        return sqlalchemy.sql.default_comparator._check_literal(
+            self.expr,
+            operator,
+            name,
+            bindparam_type=sqlalchemy.types.String(),
+        )
 
 
 def struct_getitem_op(a, b):

sqlalchemy_bigquery/base.py

@@ -163,7 +163,7 @@ def get_insert_default(self, column):  # pragma: NO COVER
         """,
         flags=re.IGNORECASE | re.VERBOSE,
     )
-    def __distribute_types_to_expanded_placeholders(self, m):  # pragma: NO COVER
+    def __distribute_types_to_expanded_placeholders(self, m):
         # If we have an in parameter, it sometimes gets expaned to 0 or more
         # parameters and we need to move the type marker to each
         # parameter.
@@ -174,8 +174,6 @@ def __distribute_types_to_expanded_placeholders(self, m):  # pragma: NO COVER
         # suffixes refect that when an array parameter is expanded,
         # numeric suffixes are added.  For example, a placeholder like
         # `%(foo)s` gets expaneded to `%(foo_0)s, `%(foo_1)s, ...`.
-
-        # Coverage: despite our best efforts, never recognized this segment of code as being tested.
         placeholders, type_ = m.groups()
         if placeholders:
             placeholders = placeholders.replace(")", f":{type_})")
@@ -358,7 +356,11 @@ def group_by_clause(self, select, **kw):
 
     __sqlalchemy_version_info = packaging.version.parse(sqlalchemy.__version__)
 
-    __expanding_text = "POSTCOMPILE"
+    __expanding_text = (
+        "EXPANDING"
+        if __sqlalchemy_version_info < packaging.version.parse("1.4")
+        else "POSTCOMPILE"
+    )
 
     # https://github.com/sqlalchemy/sqlalchemy/commit/f79df12bd6d99b8f6f09d4bf07722638c4b4c159
     __expanding_conflict = (
@@ -386,6 +388,9 @@ def visit_in_op_binary(self, binary, operator_, **kw):
             self._generate_generic_binary(binary, " IN ", **kw)
         )
 
+    def visit_empty_set_expr(self, element_types, **kw):
+        return ""
+
     def visit_not_in_op_binary(self, binary, operator, **kw):
         return (
             "("
@@ -419,16 +424,31 @@ def visit_contains_op_binary(self, binary, operator, **kw):
             self._maybe_reescape(binary), operator, **kw
         )
 
+    def visit_notcontains_op_binary(self, binary, operator, **kw):
+        return super(BigQueryCompiler, self).visit_notcontains_op_binary(
+            self._maybe_reescape(binary), operator, **kw
+        )
+
     def visit_startswith_op_binary(self, binary, operator, **kw):
         return super(BigQueryCompiler, self).visit_startswith_op_binary(
             self._maybe_reescape(binary), operator, **kw
         )
 
+    def visit_notstartswith_op_binary(self, binary, operator, **kw):
+        return super(BigQueryCompiler, self).visit_notstartswith_op_binary(
+            self._maybe_reescape(binary), operator, **kw
+        )
+
     def visit_endswith_op_binary(self, binary, operator, **kw):
         return super(BigQueryCompiler, self).visit_endswith_op_binary(
             self._maybe_reescape(binary), operator, **kw
         )
 
+    def visit_notendswith_op_binary(self, binary, operator, **kw):
+        return super(BigQueryCompiler, self).visit_notendswith_op_binary(
+            self._maybe_reescape(binary), operator, **kw
+        )
+
     ############################################################################
 
     __placeholder = re.compile(r"%\(([^\]:]+)(:[^\]:]+)?\)s$").match
@@ -490,8 +510,7 @@ def visit_bindparam(
             # here, because then we can't do a recompile later (e.g., first
             # print the statment, then execute it).  See issue #357.
             #
-            # Coverage: despite our best efforts, never recognized this segment of code as being tested.
-            if getattr(bindparam, "expand_op", None) is not None:  # pragma: NO COVER
+            if getattr(bindparam, "expand_op", None) is not None:
                 assert bindparam.expand_op.__name__.endswith("in_op")  # in in
                 bindparam = bindparam._clone(maintain_key=True)
                 bindparam.expanding = False
@@ -1259,6 +1278,10 @@ def do_rollback(self, dbapi_connection):
         # BigQuery has no support for transactions.
         pass
 
+    def _check_unicode_returns(self, connection, additional_tests=None):
+        # requests gives back Unicode strings
+        return True
+
     def get_view_definition(self, connection, view_name, schema=None, **kw):
         if isinstance(connection, Engine):
             connection = connection.connect()

sqlalchemy_bigquery/requirements.py

@@ -24,6 +24,7 @@
 
 import sqlalchemy.testing.requirements
 import sqlalchemy.testing.exclusions
+from sqlalchemy.testing.exclusions import against, only_on
 
 supported = sqlalchemy.testing.exclusions.open
 unsupported = sqlalchemy.testing.exclusions.closed