def array_type(self):
     return only_on(
         [
             lambda config: against(config, "postgresql")
             and not against(config, "+pg8000")
             and not against(config, "+zxjdbc")
         ]
     )

 def mssql_freetds(self):
     return only_on(
         LambdaPredicate(
             lambda config: (
                 (against(config, 'mssql+pyodbc') and
                  config.db.dialect.freetds)
                 or against(config, 'mssql+pymssql')
             )
         )
     )

        def check(config):
            if against(config, "mysql+mysqldb"):
                # can remove once post 1.3.13 is released
                try:
                    from MySQLdb import converters
                    from decimal import Decimal

                    return Decimal not in converters.conversions
                except:
                    return True

            return against(
                config, "mysql+mysqldb"
            ) and config.db.dialect._mysql_dbapi_version <= (1, 3, 13)

 def json_type(self):
     return only_on([
         lambda config:
             against(config, "mysql") and (
                 (
                     not config.db.dialect._is_mariadb and
                     against(config, "mysql >= 5.7")
                 )
                 or (
                     config.db.dialect._mariadb_normalized_version_info >=
                     (10, 2, 7)
                 )
             ),
         "postgresql >= 9.3"
     ])

 def reflects_json_type(self):
     return only_on([
         lambda config: against(config, "mysql >= 5.7") and
         not config.db.dialect._is_mariadb,
         "postgresql >= 9.3",
         "sqlite >= 3.9"
     ])

 def broken_cx_oracle6_numerics(config):
     return exclusions.LambdaPredicate(
         lambda config: against(config, 'oracle+cx_oracle') and
         config.db.dialect.cx_oracle_ver <= (6, 0, 2) and
         config.db.dialect.cx_oracle_ver > (6, ),
         "cx_Oracle github issue #77"
     )

 def check(config):
     if not against(config, "postgresql"):
         return False
     count = config.db.scalar(
         "SELECT count(*) FROM pg_extension "
         "WHERE extname='%s'" % name)
     return bool(count)

 def check_hstore(config):
     if not against(config, "postgresql"):
         return False
     try:
         config.db.execute("SELECT 'a=>1,a=>2'::hstore;")
         return True
     except:
         return False

 def check_hstore():
     if not against("postgresql"):
         return False
     try:
         self.db.execute("SELECT 'a=>1,a=>2'::hstore;")
         return True
     except:
         return False

 def json_type(self):
     return only_on([
         lambda config: against(config, "mysql >= 5.7") and
         not config.db.dialect._is_mariadb and
         # workaround for:
         # https://github.com/PyMySQL/PyMySQL/issues/488
         not (config.db.dialect.driver == 'pymysql'),
         "postgresql >= 9.3"
     ])

 def check_range_types(config):
     if not against(
             config,
             ["postgresql+psycopg2", "postgresql+psycopg2cffi"]):
         return False
     try:
         config.db.scalar("select '[1,2)'::int4range;")
         return True
     except:
         return False

 def check_range_types():
     if not against("postgresql+psycopg2"):
         return False
     try:
         self.db.execute("select '[1,2)'::int4range;")
         # only supported in psycopg 2.5+
         from psycopg2.extras import NumericRange
         return True
     except:
         return False

 def has_fastexecutemany(config):
     if not against(config, "mssql+pyodbc"):
         return False
     if config.db.dialect._dbapi_version() < (4, 0, 19):
         return False
     with config.db.connect() as conn:
         drivername = conn.connection.connection.getinfo(
             config.db.dialect.dbapi.SQL_DRIVER_NAME)
         # on linux this is 'libmsodbcsql-13.1.so.9.2'.
         # don't know what it is on windows
         return "msodbc" in drivername

def _prep_testing_database(options, file_config):
    from sqlalchemy.testing import config, util
    from sqlalchemy.testing.exclusions import against
    from sqlalchemy import schema, inspect

    if options.dropfirst:
        for cfg in config.Config.all_configs():
            e = cfg.db
            inspector = inspect(e)
            try:
                view_names = inspector.get_view_names()
            except NotImplementedError:
                pass
            else:
                for vname in view_names:
                    e.execute(
                        schema._DropView(
                            schema.Table(vname, schema.MetaData())
                        )
                    )

            if config.requirements.schemas.enabled_for_config(cfg):
                try:
                    view_names = inspector.get_view_names(schema="test_schema")
                except NotImplementedError:
                    pass
                else:
                    for vname in view_names:
                        e.execute(
                            schema._DropView(
                                schema.Table(
                                    vname,
                                    schema.MetaData(),
                                    schema="test_schema",
                                )
                            )
                        )

            util.drop_all_tables(e, inspector)

            if config.requirements.schemas.enabled_for_config(cfg):
                util.drop_all_tables(e, inspector, schema=cfg.test_schema)

            if against(cfg, "postgresql"):
                from sqlalchemy.dialects import postgresql

                for enum in inspector.get_enums("*"):
                    e.execute(
                        postgresql.DropEnumType(
                            postgresql.ENUM(
                                name=enum["name"], schema=enum["schema"]
                            )
                        )
                    )

def _prep_testing_database(options, file_config):
    from sqlalchemy.testing import config
    from sqlalchemy.testing.exclusions import against
    from sqlalchemy import schema, inspect

    if options.dropfirst:
        for cfg in config.Config.all_configs():
            e = cfg.db
            inspector = inspect(e)
            try:
                view_names = inspector.get_view_names()
            except NotImplementedError:
                pass
            else:
                for vname in view_names:
                    e.execute(schema._DropView(
                        schema.Table(vname, schema.MetaData())
                    ))

            if config.requirements.schemas.enabled_for_config(cfg):
                try:
                    view_names = inspector.get_view_names(
                        schema="test_schema")
                except NotImplementedError:
                    pass
                else:
                    for vname in view_names:
                        e.execute(schema._DropView(
                            schema.Table(vname, schema.MetaData(),
                                         schema="test_schema")
                        ))

            for tname in reversed(inspector.get_table_names(
                    order_by="foreign_key")):
                e.execute(schema.DropTable(
                    schema.Table(tname, schema.MetaData())
                ))

            if config.requirements.schemas.enabled_for_config(cfg):
                for tname in reversed(inspector.get_table_names(
                        order_by="foreign_key", schema="test_schema")):
                    e.execute(schema.DropTable(
                        schema.Table(tname, schema.MetaData(),
                                     schema="test_schema")
                    ))

            if against(cfg, "postgresql"):
                from sqlalchemy.dialects import postgresql
                for enum in inspector.get_enums("*"):
                    e.execute(postgresql.DropEnumType(
                        postgresql.ENUM(
                            name=enum['name'],
                            schema=enum['schema'])))

    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'),
            LambdaPredicate(
                lambda config: against(config, "mysql+mysqlconnector") and
                config.db.dialect._mysqlconnector_version_info > (2, 0) and
                util.py2k,
                "bug in mysqlconnector 2.0"
            ),
            LambdaPredicate(
                lambda config: against(config, 'mssql+pyodbc') and
                config.db.dialect.freetds and
                config.db.dialect.freetds_driver_version < "0.91",
                "older freetds doesn't support unicode DDL"
            ),
            exclude('mysql', '<', (4, 1, 1), 'no unicode connection support'),
        ])

    def ctes(self):
        """Target database supports CTEs"""

        return only_on([
            lambda config: against(config, "mysql") and (
                config.db.dialect._is_mariadb and
                config.db.dialect._mariadb_normalized_version_info >=
                (10, 2)
            ),
            "postgresql",
            "mssql",
            "oracle"
        ])

 def _mysql_and_check_constraints_exist(self, config):
     # 1. we have mysql / mariadb and
     # 2. it enforces check constraints
     if exclusions.against(config, "mysql"):
         if config.db.dialect._is_mariadb:
             norm_version_info = (
                 config.db.dialect._mariadb_normalized_version_info
             )
             return norm_version_info >= (10, 2)
         else:
             norm_version_info = config.db.dialect.server_version_info
             return norm_version_info >= (8, 0, 16)
     else:
         return False

    def non_native_boolean_unconstrained(self):
        """target database is not native boolean and allows arbitrary integers
        in it's "bool" column"""

        return skip_if([
            LambdaPredicate(
                lambda config: against(config, "mssql"),
                "SQL Server drivers / odbc seem to change their mind on this"
            ),
            LambdaPredicate(
                lambda config: config.db.dialect.supports_native_boolean,
                "native boolean dialect"
            )
        ])

    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"),
                LambdaPredicate(
                    lambda config: against(config, "mysql+mysqlconnector")
                    and config.db.dialect._mysqlconnector_version_info > (2, 0)
                    and util.py2k,
                    "bug in mysqlconnector 2.0",
                ),
                exclude(
                    "mysql", "<", (4, 1, 1), "no unicode connection support"
                ),
            ]
        )