def bulletproof_pickle(self):
     from sqlalchemy.util import pickle
     return only_if(
         lambda: pickle.__name__ == 'cPickle' and \
             sys.version_info < (3, 0) and not util.pypy,
         "Needs Python 2.x cPickle"
     )

    def mod_operator_as_percent_sign(self):
        """target database must use a plain percent '%' as the 'modulus'
        operator."""

        return only_if(
                    ['mysql', 'sqlite', 'postgresql+psycopg2', 'mssql']
                )

 def non_broken_pickle(self):
     from sqlalchemy.util import pickle
     return only_if(
         lambda: not util.pypy and pickle.__name__ == 'cPickle'
             or sys.version_info >= (3, 2),
         "Needs cPickle+cPython or newer Python 3 pickle"
     )

    def ctes_on_dml(self):
        """target database supports CTES which consist of INSERT, UPDATE
        or DELETE *within* the CTE, e.g. WITH x AS (UPDATE....)"""

        return only_if(
            ['postgresql']
        )

    def ctes_on_dml(self):
        """target database supports CTES which consist of INSERT, UPDATE
        or DELETE"""

        return only_if(
            ['postgresql']
        )

    def mysql_ngram_fulltext(self):
        def check(config):
            return (
                against(config, "mysql")
                and not config.db.dialect._is_mariadb
                and config.db.dialect.server_version_info >= (5, 7)
            )

        return only_if(check)

 def _has_pg_extension(self, name):
     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)
     return only_if(check, "needs %s extension" % name)

    def mysql_non_strict(self):
        def check(config):
            if not against(config, 'mysql'):
                return False

            row = config.db.execute("show variables like 'sql_mode'").first()
            return not row or "STRICT_TRANS_TABLES" not in row[1]

        return only_if(check)

    def mysql_zero_date(self):
        def check(config):
            if not against(config, 'mysql'):
                return False

            row = config.db.execute("show variables like 'sql_mode'").first()
            return not row or "NO_ZERO_DATE" not in row[1]

        return only_if(check)

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

        return only_if(check_hstore)

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

        return only_if(check_hstore)

    def range_types(self):
        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

        return only_if(check_range_types)

    def range_types(self):
        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

        return only_if(check_range_types)

 def pyodbc_fast_executemany(self):
     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
     return only_if(
         has_fastexecutemany,
         "only on pyodbc > 4.0.19 w/ msodbc driver")

    def mysql_non_strict(self):
        def check(config):
             row = config.db.execute("show variables like 'sql_mode'").first()
             return not row or "STRICT" not in row[1]

        return only_if(check)

 def oracle5x(self):
     return only_if(
         lambda config: against(config, "oracle+cx_oracle") and
         config.db.dialect.cx_oracle_ver < (6, )
     )

 def cxoracle6_or_greater(self):
     return only_if(
         lambda config: against(config, "oracle+cx_oracle")
         and config.db.dialect.cx_oracle_ver >= (6,)
     )

 def cpython(self):
     return only_if(lambda: util.cpython,
            "cPython interpreter needed"
          )

 def window_functions(self):
     return only_if([
                 "postgresql", "mssql", "oracle"
             ], "Backend does not support window functions")

 def sql_expressions_inserted_as_primary_key(self):
     return only_if([self.returning, self.sqlite])