def dbapi_lastrowid(fn):
    if util.pypy:
        return _chain_decorators_on(
            fn,
            fails_if(lambda:True)
        )
    else:
        return _chain_decorators_on(
            fn,
            fails_on_everything_except('mysql+mysqldb', 'mysql+oursql',
                                       'sqlite+pysqlite', 'mysql+pymysql'),
        )

def updateable_autoincrement_pks(fn):
    """Target must support UPDATE on autoincrement/integer primary key."""
    return _chain_decorators_on(
        fn,
        no_support('mssql', "IDENTITY cols can't be updated"),
        no_support('sybase', "IDENTITY cols can't be updated"),
    )

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

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

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

def cpython(fn):
    return _chain_decorators_on(
         fn,
         skip_if(lambda: util.jython or util.pypy, 
           "cPython interpreter needed"
         )
    )

def update_from(fn):
    """Target must support UPDATE..FROM syntax"""
    return _chain_decorators_on(
        fn,
        only_on(('postgresql', 'mssql', 'mysql'),
            "Backend does not support UPDATE..FROM")
    )

def isolation_level(fn):
    return _chain_decorators_on(
        fn,
        only_on(('postgresql', 'sqlite'), "DBAPI has no isolation level support"),
        fails_on('postgresql+pypostgresql',
                      'pypostgresql bombs on multiple isolation level calls')
    )

def boolean_col_expressions(fn):
    """Target database must support boolean expressions as columns"""
    return _chain_decorators_on(
        fn,
        no_support("firebird", "not supported by database"),
        no_support("oracle", "not supported by database"),
        no_support("mssql", "not supported by database"),
    )

def unbounded_varchar(fn):
    """Target database must support VARCHAR with no length"""
    return _chain_decorators_on(
        fn,
        no_support("firebird", "not supported by database"),
        no_support("oracle", "not supported by database"),
        no_support("mysql", "not supported by database"),
    )

def independent_cursors(fn):
    """Target must support simultaneous, independent database cursors on a single connection."""

    return _chain_decorators_on(
        fn,
        no_support('mssql+pyodbc', 'no driver support'),
        no_support('mssql+mxodbc', 'no driver support'),
        )

def python25(fn):
    return _chain_decorators_on(
        fn,
        skip_if(
            lambda: sys.version_info < (2, 5),
            "Python version 2.5 or greater is required"
        )
    )

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

    return _chain_decorators_on(
        fn,
        no_support('sqlite', 'no schema support'),
        no_support('firebird', 'no schema support')
    )

def deferrable_constraints(fn):
    """Target database must support derferable constraints."""
    return _chain_decorators_on(
        fn,
        no_support("firebird", "not supported by database"),
        no_support("mysql", "not supported by database"),
        no_support("mssql", "not supported by database"),
    )

def except_(fn):
    """Target database must support EXCEPT or equivlaent (i.e. MINUS)."""
    return _chain_decorators_on(
        fn,
        fails_on('firebird', 'no support for EXCEPT'),
        fails_on('mysql', 'no support for EXCEPT'),
        fails_on('sybase', 'no support for EXCEPT'),
    )

def intersect(fn):
    """Target database must support INTERSECT or equivlaent."""
    return _chain_decorators_on(
        fn,
        fails_on('firebird', 'no support for INTERSECT'),
        fails_on('mysql', 'no support for INTERSECT'),
        fails_on('sybase', 'no support for INTERSECT'),
    )

def python2(fn):
    return _chain_decorators_on(
        fn,
        skip_if(
            lambda: sys.version_info >= (3,),
            "Python version 2.xx is required."
            )
    )

def deferrable_constraints(fn):
    """Target database must support derferable constraints."""
    return _chain_decorators_on(
        fn,
        no_support('firebird', 'not supported by database'),
        no_support('mysql', 'not supported by database'),
        no_support('mssql', 'not supported by database'),
        )

def independent_connections(fn):
    """Target must support simultaneous, independent database connections."""

    # This is also true of some configurations of UnixODBC and probably win32
    # ODBC as well.
    return _chain_decorators_on(
        fn,
        no_support('sqlite', 'no driver support')
        )

def row_triggers(fn):
    """Target must support standard statement-running EACH ROW triggers."""
    return _chain_decorators_on(
        fn,
        # no access to same table
        no_support('mysql', 'requires SUPER priv'),
        exclude('mysql', '<', (5, 0, 10), 'not supported by database'),
        no_support('postgres', 'not supported by database: no statements'),
        )

def skip_mysql_on_windows(fn):
    """Catchall for a large variety of MySQL on Windows failures"""

    return _chain_decorators_on(
        fn,
        skip_if(_has_mysql_on_windows,
            "Not supported on MySQL + Windows"
        )
    )