ansicursor.py

python web programming 部分

#
# ansiCursor.py: base class for database adaptation layer
#
class ansiCursor:

    def __init__(self, cursor):
        self.cursor = cursor
        
    def fldalias(self, f):
        if len(f) != 2:
            raise ValueError, "Field alias should be exactly two elements"
        else:
            return " AS ".join(f)

    def tables(self, FROM):
        if type(FROM[0]) == type(""):
            FROM = [FROM]
        result = []
        for t in FROM:
            if type(t) == type(""):
                result.append(t)
            else:
                result.append(self.tblalias(t))
        return ", ".join(result)

    def tblalias(self, t):
        if len(t) != 2:
            raise ValueError, "Table alias should be exactly two elements"
        else:
            return " AS ".join(t)

#
# Data Manipulation language SQL statement generators
#
    def DELETE(self, tname, WHERE=None):
        result = "DELETE FROM %s" % tname
        if WHERE:
            result += " WHERE %s" % WHERE
        return result

    def INSERT(self, tname, fnames=None, VALUES=None):
        #print "tname:", tname
        #print "fnames:", fnames
        #print "VALUES:", VALUES
        if VALUES is None:
            raise ValueError, "Value list not provided for INSERT"
        if fnames is not None:
            if type(fnames) == type(""):
                fnames = [fnames]
            flist = "(%s) " % ", ".join(fnames)
        else:
            flist = ""
        if type(VALUES) == type(""):
            values = VALUES
        else:
            values = ", ".join(VALUES)
        return "INSERT INTO %s %sVALUES(%s)" % (tname, flist, values)

    def SELECT(self, fields, FROM=None, WHERE=None, REST=None):
        if type(fields) == type(""):
            result = "SELECT " + fields
        else:
            ff = []
            for f in fields:
                if type(f) == type(""):
                    ff.append(f)
                else:
                    ff.append(self.fldalias(f))
            result = "SELECT " + ", ".join(ff)
        if FROM:
            result += "\n    FROM %s" % self.tables(FROM)
        if WHERE:
            result += "\n    WHERE %s" % WHERE
        if REST:
            result += "\n     %s" % REST
        return result

    def UNION(self, *stmts, **kywds):
        union = "UNION"
        if kywds.has_key("DISTINCT") and kywds["DISTINCT"]:
            union += " DISTINCT"
        union = "\n    %s\n" % union
        result = union.join(stmts)
        if kywds.has_key("REST"):
            result = "%s\n    %s" % (result, kywds["REST"])
        return result

#
# Data definition language SQL statement generators
#
    def CREATE_INDEX(self, ixname, tbl, fields, UNIQUE=0):
        if type(fields) == type(""):
            fields = [fields]
        if UNIQUE:
            unique = "UNIQUE "
        else:
            unique = ""
        return "CREATE %sINDEX %s ON %s(%s)" % (unique, ixname, tbl, ", ".join(fields))

    def CREATE_TABLE(self, tname, *fields):
        ff = []
        for f in fields:
            ff.append("%s %s" % (f[0], f[1]))
        return "CREATE TABLE %s (\n    %s)" % (tname, ",\n    ".join(ff))

    def CREATE_VIEW(self, vname, fields, select):
        return "CREATE VIEW %s (%s) AS\n    %s" % (vname, ", ".join(fields), select)

    def DROP_INDEX(self, i, t):
        return "DROP INDEX %s" % i

    def DROP_TABLE(self, t):
        return "DROP TABLE %s" % t

    def DROP_VIEW(self, v):
        return "DROP VIEW %s" % v

#
# Datatype generation statements and constants
#
    def VARCHAR(self, n):
        return "VARCHAR(%d)" % n
            
    INTEGER = "INTEGER"
    FLOAT = "FLOAT"

#
# Cursor operations are delegated to the cursor supplied as an argument
#
    def __getattr__(self, attrname):
        "Delegate unrecognised methods/attributes to the cursor object."
        return getattr(self.cursor, attrname)