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 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 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 _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 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 Exception:
                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 something like 'libmsodbcsql-13.1.so.9.2'.
                # on Windows this is something like 'msodbcsql17.dll'.
                return "msodbc" in drivername

        return only_if(has_fastexecutemany,
                       "only on pyodbc > 4.0.19 w/ msodbc driver")
    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 sql_expressions_inserted_as_primary_key(self):
     return only_if([self.returning, self.sqlite])
    def autocommit(self):
        """target dialect supports 'AUTOCOMMIT' as an isolation_level"""

        return self.isolation_level + only_if(
            lambda config: "AUTOCOMMIT" in self.get_isolation_levels(config)[
                "supported"])
 def supports_for_update_of(self):
     return only_if(lambda config: config.db.dialect.supports_for_update_of)
 def computed_columns_default_persisted(self):
     return self.computed_columns + only_if("postgresql")
 def oracle5x(self):
     return only_if(lambda config: against(config, "oracle+cx_oracle") and
                    config.db.dialect.cx_oracle_ver < (6, ))
 def postgresql_utf8_server_encoding(self):
     return only_if(lambda config: against(config, "postgresql") and config.
                    db.scalar("show server_encoding").lower() == "utf8")
 def mysql_fully_case_sensitive(self):
     return only_if(self._has_mysql_fully_case_sensitive)
 def mysql_fsp(self):
     return only_if("mysql >= 5.6.4")
    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 window_functions(self):
     return only_if(
         ["postgresql>=8.4", "mssql", "oracle", "sqlite>=3.25.0"],
         "Backend does not support window functions",
     )
 def cxoracle6_or_greater(self):
     return only_if(lambda config: against(config, "oracle+cx_oracle") and
                    config.db.dialect.cx_oracle_ver >= (6, ))