def time_microseconds(self):
        """target dialect supports representation of Python
        datetime.time() with microsecond objects."""

        return skip_if(
            ["mssql", "mysql", "firebird", "+zxjdbc", "oracle", "sybase"]
        )

    def schemas(self):
        """Target database must support external schemas, and have one
        named 'test_schema'."""

        return skip_if([
                    "firebird"
                ], "no schema support")

    def two_phase_transactions(self):
        """Target database must support two-phase transactions."""

        return skip_if(
            [
                no_support("firebird", "no SA implementation"),
                no_support("mssql", "two-phase xact not supported by drivers"),
                no_support(
                    "oracle", "two-phase xact not implemented in SQLA/oracle"
                ),
                no_support(
                    "drizzle", "two-phase xact not supported by database"
                ),
                no_support(
                    "sqlite", "two-phase xact not supported by database"
                ),
                no_support(
                    "sybase", "two-phase xact not supported by drivers/SQLA"
                ),
                no_support(
                    "postgresql+zxjdbc",
                    "FIXME: JDBC driver confuses the transaction state, "
                    "may need separate XA implementation",
                ),
                no_support(
                    "mysql",
                    "recent MySQL communiity editions have too many issues "
                    "(late 2016), disabling for now",
                ),
            ]
        )

    def non_updating_cascade(self):
        """target database must *not* support ON UPDATE..CASCADE behavior in
        foreign keys."""

        return fails_on_everything_except(
            "sqlite", "oracle", "+zxjdbc"
        ) + skip_if("mssql")

    def unbounded_varchar(self):
        """Target database must support VARCHAR with no length"""

        return skip_if([
                "firebird", "oracle", "mysql"
            ], "not supported by database"
            )

 def two_phase_recovery(self):
     return self.two_phase_transactions + (
         skip_if(
            "mysql",
            "crashes on most mariadb and mysql versions"
         )
     )

    def savepoints(self):
        """Target database must support savepoints."""

        return skip_if(
            ["sqlite", "sybase", ("mysql", "<", (5, 0, 3))],
            "savepoints not supported",
        )

 def postgresql_test_dblink(self):
     return skip_if(
         lambda config: not config.file_config.has_option(
             "sqla_testing", "postgres_test_db_link"
         ),
         "postgres_test_db_link option not specified in config",
     )

 def binary_comparisons(self):
     """target database/driver can allow BLOB/BINARY fields to be compared
     against a bound parameter value.
     """
     return skip_if(["oracle", "mssql"],
             "not supported by database/driver"
         )

    def standalone_binds(self):
        """target database/driver supports bound parameters as column expressions
        without being in the context of a typed column.

        """
        return skip_if(["firebird", "mssql+mxodbc"],
                "not supported by driver")

    def on_update_cascade(self):
        """target database must support ON UPDATE..CASCADE behavior in
        foreign keys."""

        return skip_if(
            ["sqlite", "oracle"],
            "target backend %(doesnt_support)s ON UPDATE CASCADE",
        )

 def boolean_col_expressions(self):
     """Target database must support boolean expressions as columns"""
     return skip_if([
         no_support('firebird', 'not supported by database'),
         no_support('oracle', 'not supported by database'),
         no_support('mssql', 'not supported by database'),
         no_support('sybase', 'not supported by database'),
     ])

    def precision_numerics_enotation_large(self):
        """target backend supports Decimal() objects using E notation
        to represent very large values."""

        return skip_if(
            [("sybase+pyodbc", None, None,
              "Don't know how do get these values through FreeTDS + Sybase"),
             ("firebird", None, None, "Precision must be from 1 to 18")])

    def deferrable_or_no_constraints(self):
        """Target database must support derferable constraints."""

        return skip_if([
            no_support('firebird', 'not supported by database'),
            no_support('mysql', 'not supported by database'),
            no_support('mssql', 'not supported by database'),
            ])

    def on_update_cascade(self):
        """target database must support ON UPDATE..CASCADE behavior in
        foreign keys."""

        return skip_if(
                    ['sqlite', 'oracle'],
                    'target backend does not support ON UPDATE CASCADE'
                )

    def dbapi_lastrowid(self):
        """"target backend includes a 'lastrowid' accessor on the DBAPI
        cursor object.

        """
        return skip_if('mssql+pymssql', 'crashes on pymssql') + \
                    fails_on_everything_except('mysql',
                                       'sqlite+pysqlite', 'sqlite+pysqlcipher')

 def percent_schema_names(self):
     return skip_if(
             [
                 ("+psycopg2", None, None,
                         "psycopg2 2.4 no longer accepts % in bind placeholders"),
                 ("mysql", None, None, "executemany() doesn't work here")
             ]
         )

 def unicode_connections(self):
     """
     Target driver must support some encoding of Unicode across the wire.
     """
     # TODO: expand to exclude MySQLdb versions w/ broken unicode
     return skip_if([
         exclude('mysql', '<', (4, 1, 1), 'no unicode connection support'),
         ])

    def correlated_outer_joins(self):
        """Target must support an outer join to a subquery which
        correlates to the parent."""

        return skip_if(
            "oracle",
            'Raises "ORA-01799: a column may not be '
            'outer-joined to a subquery"',
        )

 def unicode_ddl(self):
     """Target driver must support some degree of non-ascii symbol names."""
     # TODO: expand to exclude MySQLdb versions w/ broken unicode
     return skip_if([
         no_support('oracle', 'FIXME: no support in database?'),
         no_support('sybase', 'FIXME: guessing, needs confirmation'),
         no_support('mssql+pymssql', 'no FreeTDS support'),
         exclude('mysql', '<', (4, 1, 1), 'no unicode connection support'),
         ])