727 lines
25 KiB
Python
727 lines
25 KiB
Python
|
# $Id: dbexts.py 6638 2009-08-10 17:05:49Z fwierzbicki $
|
||
|
|
|
||
|
|
"""
|
||
|
|
This script provides platform independence by wrapping Python
|
||
|
|
Database API 2.0 compatible drivers to allow seamless database
|
||
|
|
usage across implementations.
|
||
|
|
|
||
|
|
In order to use the C version, you need mxODBC and mxDateTime.
|
||
|
|
In order to use the Java version, you need zxJDBC.
|
||
|
|
|
||
|
|
>>> import dbexts
|
||
|
|
>>> d = dbexts.dbexts() # use the default db
|
||
|
|
>>> d.isql('select count(*) count from player')
|
||
|
|
|
||
|
|
count
|
||
|
|
-------
|
||
|
|
13569.0
|
||
|
|
|
||
|
|
1 row affected
|
||
|
|
|
||
|
|
>>> r = d.raw('select count(*) count from player')
|
||
|
|
>>> r
|
||
|
|
([('count', 3, 17, None, 15, 0, 1)], [(13569.0,)])
|
||
|
|
>>>
|
||
|
|
|
||
|
|
The configuration file follows the following format in a file name dbexts.ini:
|
||
|
|
|
||
|
|
[default]
|
||
|
|
name=mysql
|
||
|
|
|
||
|
|
[jdbc]
|
||
|
|
name=mysql
|
||
|
|
url=jdbc:mysql://localhost/ziclix
|
||
|
|
user=
|
||
|
|
pwd=
|
||
|
|
driver=org.gjt.mm.mysql.Driver
|
||
|
|
datahandler=com.ziclix.python.sql.handler.MySQLDataHandler
|
||
|
|
|
||
|
|
[jdbc]
|
||
|
|
name=pg
|
||
|
|
url=jdbc:postgresql://localhost:5432/ziclix
|
||
|
|
user=bzimmer
|
||
|
|
pwd=
|
||
|
|
driver=org.postgresql.Driver
|
||
|
|
datahandler=com.ziclix.python.sql.handler.PostgresqlDataHandler
|
||
|
|
"""
|
||
|
|
|
||
|
|
import os, re
|
||
|
|
from types import StringType
|
||
|
|
|
||
|
|
__author__ = "brian zimmer (bzimmer@ziclix.com)"
|
||
|
|
__version__ = "$Revision: 6638 $"[11:-2]
|
||
|
|
|
||
|
|
__OS__ = os.name
|
||
|
|
|
||
|
|
choose = lambda bool, a, b: (bool and [a] or [b])[0]
|
||
|
|
|
||
|
|
def console(rows, headers=()):
|
||
|
|
"""Format the results into a list of strings (one for each row):
|
||
|
|
|
||
|
|
<header>
|
||
|
|
<headersep>
|
||
|
|
<row1>
|
||
|
|
<row2>
|
||
|
|
...
|
||
|
|
|
||
|
|
headers may be given as list of strings.
|
||
|
|
|
||
|
|
Columns are separated by colsep; the header is separated from
|
||
|
|
the result set by a line of headersep characters.
|
||
|
|
|
||
|
|
The function calls stringify to format the value data into a string.
|
||
|
|
It defaults to calling str() and striping leading and trailing whitespace.
|
||
|
|
|
||
|
|
- copied and modified from mxODBC
|
||
|
|
"""
|
||
|
|
|
||
|
|
# Check row entry lengths
|
||
|
|
output = []
|
||
|
|
headers = map(lambda header: header.upper(), list(map(lambda x: x or "", headers)))
|
||
|
|
collen = map(len,headers)
|
||
|
|
output.append(headers)
|
||
|
|
if rows and len(rows) > 0:
|
||
|
|
for row in rows:
|
||
|
|
row = map(lambda x: str(x), row)
|
||
|
|
for i in range(len(row)):
|
||
|
|
entry = row[i]
|
||
|
|
if collen[i] < len(entry):
|
||
|
|
collen[i] = len(entry)
|
||
|
|
output.append(row)
|
||
|
|
if len(output) == 1:
|
||
|
|
affected = "0 rows affected"
|
||
|
|
elif len(output) == 2:
|
||
|
|
affected = "1 row affected"
|
||
|
|
else:
|
||
|
|
affected = "%d rows affected" % (len(output) - 1)
|
||
|
|
|
||
|
|
# Format output
|
||
|
|
for i in range(len(output)):
|
||
|
|
row = output[i]
|
||
|
|
l = []
|
||
|
|
for j in range(len(row)):
|
||
|
|
l.append('%-*s' % (collen[j],row[j]))
|
||
|
|
output[i] = " | ".join(l)
|
||
|
|
|
||
|
|
# Insert header separator
|
||
|
|
totallen = len(output[0])
|
||
|
|
output[1:1] = ["-"*(totallen/len("-"))]
|
||
|
|
output.append("\n" + affected)
|
||
|
|
return output
|
||
|
|
|
||
|
|
def html(rows, headers=()):
|
||
|
|
output = []
|
||
|
|
output.append('<table class="results">')
|
||
|
|
output.append('<tr class="headers">')
|
||
|
|
headers = map(lambda x: '<td class="header">%s</td>' % (x.upper()), list(headers))
|
||
|
|
map(output.append, headers)
|
||
|
|
output.append('</tr>')
|
||
|
|
if rows and len(rows) > 0:
|
||
|
|
for row in rows:
|
||
|
|
output.append('<tr class="row">')
|
||
|
|
row = map(lambda x: '<td class="value">%s</td>' % (x), row)
|
||
|
|
map(output.append, row)
|
||
|
|
output.append('</tr>')
|
||
|
|
output.append('</table>')
|
||
|
|
return output
|
||
|
|
|
||
|
|
comments = lambda x: re.compile("{.*?}", re.S).sub("", x, 0)
|
||
|
|
|
||
|
|
class mxODBCProxy:
|
||
|
|
"""Wraps mxODBC to provide proxy support for zxJDBC's additional parameters."""
|
||
|
|
def __init__(self, c):
|
||
|
|
self.c = c
|
||
|
|
def __getattr__(self, name):
|
||
|
|
if name == "execute":
|
||
|
|
return self.execute
|
||
|
|
elif name == "gettypeinfo":
|
||
|
|
return self.gettypeinfo
|
||
|
|
else:
|
||
|
|
return getattr(self.c, name)
|
||
|
|
def execute(self, sql, params=None, bindings=None, maxrows=None):
|
||
|
|
if params:
|
||
|
|
self.c.execute(sql, params)
|
||
|
|
else:
|
||
|
|
self.c.execute(sql)
|
||
|
|
def gettypeinfo(self, typeid=None):
|
||
|
|
if typeid:
|
||
|
|
self.c.gettypeinfo(typeid)
|
||
|
|
|
||
|
|
class executor:
|
||
|
|
"""Handles the insertion of values given dynamic data."""
|
||
|
|
def __init__(self, table, cols):
|
||
|
|
self.cols = cols
|
||
|
|
self.table = table
|
||
|
|
if self.cols:
|
||
|
|
self.sql = "insert into %s (%s) values (%s)" % (table, ",".join(self.cols), ",".join(("?",) * len(self.cols)))
|
||
|
|
else:
|
||
|
|
self.sql = "insert into %s values (%%s)" % (table)
|
||
|
|
def execute(self, db, rows, bindings):
|
||
|
|
assert rows and len(rows) > 0, "must have at least one row"
|
||
|
|
if self.cols:
|
||
|
|
sql = self.sql
|
||
|
|
else:
|
||
|
|
sql = self.sql % (",".join(("?",) * len(rows[0])))
|
||
|
|
db.raw(sql, rows, bindings)
|
||
|
|
|
||
|
|
def connect(dbname):
|
||
|
|
return dbexts(dbname)
|
||
|
|
|
||
|
|
def lookup(dbname):
|
||
|
|
return dbexts(jndiname=dbname)
|
||
|
|
|
||
|
|
class dbexts:
|
||
|
|
def __init__(self, dbname=None, cfg=None, formatter=console, autocommit=0, jndiname=None, out=None):
|
||
|
|
self.verbose = 1
|
||
|
|
self.results = []
|
||
|
|
self.headers = []
|
||
|
|
self.autocommit = autocommit
|
||
|
|
self.formatter = formatter
|
||
|
|
self.out = out
|
||
|
|
self.lastrowid = None
|
||
|
|
self.updatecount = None
|
||
|
|
|
||
|
|
if not jndiname:
|
||
|
|
if cfg == None:
|
||
|
|
fn = os.path.join(os.path.split(__file__)[0], "dbexts.ini")
|
||
|
|
if not os.path.exists(fn):
|
||
|
|
fn = os.path.join(os.environ['HOME'], ".dbexts")
|
||
|
|
self.dbs = IniParser(fn)
|
||
|
|
elif isinstance(cfg, IniParser):
|
||
|
|
self.dbs = cfg
|
||
|
|
else:
|
||
|
|
self.dbs = IniParser(cfg)
|
||
|
|
if dbname == None: dbname = self.dbs[("default", "name")]
|
||
|
|
|
||
|
|
if __OS__ == 'java':
|
||
|
|
|
||
|
|
from com.ziclix.python.sql import zxJDBC
|
||
|
|
database = zxJDBC
|
||
|
|
if not jndiname:
|
||
|
|
t = self.dbs[("jdbc", dbname)]
|
||
|
|
self.dburl, dbuser, dbpwd, jdbcdriver = t['url'], t['user'], t['pwd'], t['driver']
|
||
|
|
if t.has_key('datahandler'):
|
||
|
|
self.datahandler = []
|
||
|
|
for dh in t['datahandler'].split(','):
|
||
|
|
classname = dh.split(".")[-1]
|
||
|
|
datahandlerclass = __import__(dh, globals(), locals(), classname)
|
||
|
|
self.datahandler.append(datahandlerclass)
|
||
|
|
keys = [x for x in t.keys() if x not in ['url', 'user', 'pwd', 'driver', 'datahandler', 'name']]
|
||
|
|
props = {}
|
||
|
|
for a in keys:
|
||
|
|
props[a] = t[a]
|
||
|
|
self.db = apply(database.connect, (self.dburl, dbuser, dbpwd, jdbcdriver), props)
|
||
|
|
else:
|
||
|
|
self.db = database.lookup(jndiname)
|
||
|
|
self.db.autocommit = self.autocommit
|
||
|
|
|
||
|
|
elif __OS__ == 'nt':
|
||
|
|
|
||
|
|
for modname in ["mx.ODBC.Windows", "ODBC.Windows"]:
|
||
|
|
try:
|
||
|
|
database = __import__(modname, globals(), locals(), "Windows")
|
||
|
|
break
|
||
|
|
except:
|
||
|
|
continue
|
||
|
|
else:
|
||
|
|
raise ImportError("unable to find appropriate mxODBC module")
|
||
|
|
|
||
|
|
t = self.dbs[("odbc", dbname)]
|
||
|
|
self.dburl, dbuser, dbpwd = t['url'], t['user'], t['pwd']
|
||
|
|
self.db = database.Connect(self.dburl, dbuser, dbpwd, clear_auto_commit=1)
|
||
|
|
|
||
|
|
self.dbname = dbname
|
||
|
|
for a in database.sqltype.keys():
|
||
|
|
setattr(self, database.sqltype[a], a)
|
||
|
|
for a in dir(database):
|
||
|
|
try:
|
||
|
|
p = getattr(database, a)
|
||
|
|
if issubclass(p, Exception):
|
||
|
|
setattr(self, a, p)
|
||
|
|
except:
|
||
|
|
continue
|
||
|
|
del database
|
||
|
|
|
||
|
|
def __str__(self):
|
||
|
|
return self.dburl
|
||
|
|
|
||
|
|
def __repr__(self):
|
||
|
|
return self.dburl
|
||
|
|
|
||
|
|
def __getattr__(self, name):
|
||
|
|
if "cfg" == name:
|
||
|
|
return self.dbs.cfg
|
||
|
|
raise AttributeError("'dbexts' object has no attribute '%s'" % (name))
|
||
|
|
|
||
|
|
def close(self):
|
||
|
|
""" close the connection to the database """
|
||
|
|
self.db.close()
|
||
|
|
|
||
|
|
def begin(self, style=None):
|
||
|
|
""" reset ivars and return a new cursor, possibly binding an auxiliary datahandler """
|
||
|
|
self.headers, self.results = [], []
|
||
|
|
if style:
|
||
|
|
c = self.db.cursor(style)
|
||
|
|
else:
|
||
|
|
c = self.db.cursor()
|
||
|
|
if __OS__ == 'java':
|
||
|
|
if hasattr(self, 'datahandler'):
|
||
|
|
for dh in self.datahandler:
|
||
|
|
c.datahandler = dh(c.datahandler)
|
||
|
|
else:
|
||
|
|
c = mxODBCProxy(c)
|
||
|
|
return c
|
||
|
|
|
||
|
|
def commit(self, cursor=None, close=1):
|
||
|
|
""" commit the cursor and create the result set """
|
||
|
|
if cursor and cursor.description:
|
||
|
|
self.headers = cursor.description
|
||
|
|
self.results = cursor.fetchall()
|
||
|
|
if hasattr(cursor, "nextset"):
|
||
|
|
s = cursor.nextset()
|
||
|
|
while s:
|
||
|
|
self.results += cursor.fetchall()
|
||
|
|
s = cursor.nextset()
|
||
|
|
if hasattr(cursor, "lastrowid"):
|
||
|
|
self.lastrowid = cursor.lastrowid
|
||
|
|
if hasattr(cursor, "updatecount"):
|
||
|
|
self.updatecount = cursor.updatecount
|
||
|
|
if not self.autocommit or cursor is None:
|
||
|
|
if not self.db.autocommit:
|
||
|
|
self.db.commit()
|
||
|
|
if cursor and close: cursor.close()
|
||
|
|
|
||
|
|
def rollback(self):
|
||
|
|
""" rollback the cursor """
|
||
|
|
self.db.rollback()
|
||
|
|
|
||
|
|
def prepare(self, sql):
|
||
|
|
""" prepare the sql statement """
|
||
|
|
cur = self.begin()
|
||
|
|
try:
|
||
|
|
return cur.prepare(sql)
|
||
|
|
finally:
|
||
|
|
self.commit(cur)
|
||
|
|
|
||
|
|
def display(self):
|
||
|
|
""" using the formatter, display the results """
|
||
|
|
if self.formatter and self.verbose > 0:
|
||
|
|
res = self.results
|
||
|
|
if res:
|
||
|
|
print >> self.out, ""
|
||
|
|
for a in self.formatter(res, map(lambda x: x[0], self.headers)):
|
||
|
|
print >> self.out, a
|
||
|
|
print >> self.out, ""
|
||
|
|
|
||
|
|
def __execute__(self, sql, params=None, bindings=None, maxrows=None):
|
||
|
|
""" the primary execution method """
|
||
|
|
cur = self.begin()
|
||
|
|
try:
|
||
|
|
if bindings:
|
||
|
|
cur.execute(sql, params, bindings, maxrows=maxrows)
|
||
|
|
elif params:
|
||
|
|
cur.execute(sql, params, maxrows=maxrows)
|
||
|
|
else:
|
||
|
|
cur.execute(sql, maxrows=maxrows)
|
||
|
|
finally:
|
||
|
|
self.commit(cur, close=isinstance(sql, StringType))
|
||
|
|
|
||
|
|
def isql(self, sql, params=None, bindings=None, maxrows=None):
|
||
|
|
""" execute and display the sql """
|
||
|
|
self.raw(sql, params, bindings, maxrows=maxrows)
|
||
|
|
self.display()
|
||
|
|
|
||
|
|
def raw(self, sql, params=None, bindings=None, delim=None, comments=comments, maxrows=None):
|
||
|
|
""" execute the sql and return a tuple of (headers, results) """
|
||
|
|
if delim:
|
||
|
|
headers = []
|
||
|
|
results = []
|
||
|
|
if type(sql) == type(StringType):
|
||
|
|
if comments: sql = comments(sql)
|
||
|
|
statements = filter(lambda x: len(x) > 0,
|
||
|
|
map(lambda statement: statement.strip(), sql.split(delim)))
|
||
|
|
else:
|
||
|
|
statements = [sql]
|
||
|
|
for a in statements:
|
||
|
|
self.__execute__(a, params, bindings, maxrows=maxrows)
|
||
|
|
headers.append(self.headers)
|
||
|
|
results.append(self.results)
|
||
|
|
self.headers = headers
|
||
|
|
self.results = results
|
||
|
|
else:
|
||
|
|
self.__execute__(sql, params, bindings, maxrows=maxrows)
|
||
|
|
return (self.headers, self.results)
|
||
|
|
|
||
|
|
def callproc(self, procname, params=None, bindings=None, maxrows=None):
|
||
|
|
""" execute a stored procedure """
|
||
|
|
cur = self.begin()
|
||
|
|
try:
|
||
|
|
cur.callproc(procname, params=params, bindings=bindings, maxrows=maxrows)
|
||
|
|
finally:
|
||
|
|
self.commit(cur)
|
||
|
|
self.display()
|
||
|
|
|
||
|
|
def pk(self, table, owner=None, schema=None):
|
||
|
|
""" display the table's primary keys """
|
||
|
|
cur = self.begin()
|
||
|
|
cur.primarykeys(schema, owner, table)
|
||
|
|
self.commit(cur)
|
||
|
|
self.display()
|
||
|
|
|
||
|
|
def fk(self, primary_table=None, foreign_table=None, owner=None, schema=None):
|
||
|
|
""" display the table's foreign keys """
|
||
|
|
cur = self.begin()
|
||
|
|
if primary_table and foreign_table:
|
||
|
|
cur.foreignkeys(schema, owner, primary_table, schema, owner, foreign_table)
|
||
|
|
elif primary_table:
|
||
|
|
cur.foreignkeys(schema, owner, primary_table, schema, owner, None)
|
||
|
|
elif foreign_table:
|
||
|
|
cur.foreignkeys(schema, owner, None, schema, owner, foreign_table)
|
||
|
|
self.commit(cur)
|
||
|
|
self.display()
|
||
|
|
|
||
|
|
def table(self, table=None, types=("TABLE",), owner=None, schema=None):
|
||
|
|
"""If no table argument, displays a list of all tables. If a table argument,
|
||
|
|
displays the columns of the given table."""
|
||
|
|
cur = self.begin()
|
||
|
|
if table:
|
||
|
|
cur.columns(schema, owner, table, None)
|
||
|
|
else:
|
||
|
|
cur.tables(schema, owner, None, types)
|
||
|
|
self.commit(cur)
|
||
|
|
self.display()
|
||
|
|
|
||
|
|
def proc(self, proc=None, owner=None, schema=None):
|
||
|
|
"""If no proc argument, displays a list of all procedures. If a proc argument,
|
||
|
|
displays the parameters of the given procedure."""
|
||
|
|
cur = self.begin()
|
||
|
|
if proc:
|
||
|
|
cur.procedurecolumns(schema, owner, proc, None)
|
||
|
|
else:
|
||
|
|
cur.procedures(schema, owner, None)
|
||
|
|
self.commit(cur)
|
||
|
|
self.display()
|
||
|
|
|
||
|
|
def stat(self, table, qualifier=None, owner=None, unique=0, accuracy=0):
|
||
|
|
""" display the table's indicies """
|
||
|
|
cur = self.begin()
|
||
|
|
cur.statistics(qualifier, owner, table, unique, accuracy)
|
||
|
|
self.commit(cur)
|
||
|
|
self.display()
|
||
|
|
|
||
|
|
def typeinfo(self, sqltype=None):
|
||
|
|
""" display the types available for the database """
|
||
|
|
cur = self.begin()
|
||
|
|
cur.gettypeinfo(sqltype)
|
||
|
|
self.commit(cur)
|
||
|
|
self.display()
|
||
|
|
|
||
|
|
def tabletypeinfo(self):
|
||
|
|
""" display the table types available for the database """
|
||
|
|
cur = self.begin()
|
||
|
|
cur.gettabletypeinfo()
|
||
|
|
self.commit(cur)
|
||
|
|
self.display()
|
||
|
|
|
||
|
|
def schema(self, table, full=0, sort=1, owner=None):
|
||
|
|
"""Displays a Schema object for the table. If full is true, then generates
|
||
|
|
references to the table in addition to the standard fields. If sort is true,
|
||
|
|
sort all the items in the schema, else leave them in db dependent order."""
|
||
|
|
print >> self.out, str(Schema(self, table, owner, full, sort))
|
||
|
|
|
||
|
|
def bulkcopy(self, dst, table, include=[], exclude=[], autobatch=0, executor=executor):
|
||
|
|
"""Returns a Bulkcopy object using the given table."""
|
||
|
|
if type(dst) == type(""):
|
||
|
|
dst = dbexts(dst, cfg=self.dbs)
|
||
|
|
bcp = Bulkcopy(dst, table, include=include, exclude=exclude, autobatch=autobatch, executor=executor)
|
||
|
|
return bcp
|
||
|
|
|
||
|
|
def bcp(self, src, table, where='(1=1)', params=[], include=[], exclude=[], autobatch=0, executor=executor):
|
||
|
|
"""Bulkcopy of rows from a src database to the current database for a given table and where clause."""
|
||
|
|
if type(src) == type(""):
|
||
|
|
src = dbexts(src, cfg=self.dbs)
|
||
|
|
bcp = self.bulkcopy(self, table, include, exclude, autobatch, executor)
|
||
|
|
num = bcp.transfer(src, where, params)
|
||
|
|
return num
|
||
|
|
|
||
|
|
def unload(self, filename, sql, delimiter=",", includeheaders=1):
|
||
|
|
""" Unloads the delimited results of the query to the file specified, optionally including headers. """
|
||
|
|
u = Unload(self, filename, delimiter, includeheaders)
|
||
|
|
u.unload(sql)
|
||
|
|
|
||
|
|
class Bulkcopy:
|
||
|
|
"""The idea for a bcp class came from http://object-craft.com.au/projects/sybase"""
|
||
|
|
def __init__(self, dst, table, include=[], exclude=[], autobatch=0, executor=executor):
|
||
|
|
self.dst = dst
|
||
|
|
self.table = table
|
||
|
|
self.total = 0
|
||
|
|
self.rows = []
|
||
|
|
self.autobatch = autobatch
|
||
|
|
self.bindings = {}
|
||
|
|
|
||
|
|
include = map(lambda x: x.lower(), include)
|
||
|
|
exclude = map(lambda x: x.lower(), exclude)
|
||
|
|
|
||
|
|
_verbose = self.dst.verbose
|
||
|
|
self.dst.verbose = 0
|
||
|
|
try:
|
||
|
|
self.dst.table(self.table)
|
||
|
|
if self.dst.results:
|
||
|
|
colmap = {}
|
||
|
|
for a in self.dst.results:
|
||
|
|
colmap[a[3].lower()] = a[4]
|
||
|
|
cols = self.__filter__(colmap.keys(), include, exclude)
|
||
|
|
for a in zip(range(len(cols)), cols):
|
||
|
|
self.bindings[a[0]] = colmap[a[1]]
|
||
|
|
colmap = None
|
||
|
|
else:
|
||
|
|
cols = self.__filter__(include, include, exclude)
|
||
|
|
finally:
|
||
|
|
self.dst.verbose = _verbose
|
||
|
|
|
||
|
|
self.executor = executor(table, cols)
|
||
|
|
|
||
|
|
def __str__(self):
|
||
|
|
return "[%s].[%s]" % (self.dst, self.table)
|
||
|
|
|
||
|
|
def __repr__(self):
|
||
|
|
return "[%s].[%s]" % (self.dst, self.table)
|
||
|
|
|
||
|
|
def __getattr__(self, name):
|
||
|
|
if name == 'columns':
|
||
|
|
return self.executor.cols
|
||
|
|
|
||
|
|
def __filter__(self, values, include, exclude):
|
||
|
|
cols = map(lambda col: col.lower(), values)
|
||
|
|
if exclude:
|
||
|
|
cols = filter(lambda x, ex=exclude: x not in ex, cols)
|
||
|
|
if include:
|
||
|
|
cols = filter(lambda x, inc=include: x in inc, cols)
|
||
|
|
return cols
|
||
|
|
|
||
|
|
def format(self, column, type):
|
||
|
|
self.bindings[column] = type
|
||
|
|
|
||
|
|
def done(self):
|
||
|
|
if len(self.rows) > 0:
|
||
|
|
return self.batch()
|
||
|
|
return 0
|
||
|
|
|
||
|
|
def batch(self):
|
||
|
|
self.executor.execute(self.dst, self.rows, self.bindings)
|
||
|
|
cnt = len(self.rows)
|
||
|
|
self.total += cnt
|
||
|
|
self.rows = []
|
||
|
|
return cnt
|
||
|
|
|
||
|
|
def rowxfer(self, line):
|
||
|
|
self.rows.append(line)
|
||
|
|
if self.autobatch: self.batch()
|
||
|
|
|
||
|
|
def transfer(self, src, where="(1=1)", params=[]):
|
||
|
|
sql = "select %s from %s where %s" % (", ".join(self.columns), self.table, where)
|
||
|
|
h, d = src.raw(sql, params)
|
||
|
|
if d:
|
||
|
|
map(self.rowxfer, d)
|
||
|
|
return self.done()
|
||
|
|
return 0
|
||
|
|
|
||
|
|
class Unload:
|
||
|
|
"""Unloads a sql statement to a file with optional formatting of each value."""
|
||
|
|
def __init__(self, db, filename, delimiter=",", includeheaders=1):
|
||
|
|
self.db = db
|
||
|
|
self.filename = filename
|
||
|
|
self.delimiter = delimiter
|
||
|
|
self.includeheaders = includeheaders
|
||
|
|
self.formatters = {}
|
||
|
|
|
||
|
|
def format(self, o):
|
||
|
|
if not o:
|
||
|
|
return ""
|
||
|
|
o = str(o)
|
||
|
|
if o.find(",") != -1:
|
||
|
|
o = "\"\"%s\"\"" % (o)
|
||
|
|
return o
|
||
|
|
|
||
|
|
def unload(self, sql, mode="w"):
|
||
|
|
headers, results = self.db.raw(sql)
|
||
|
|
w = open(self.filename, mode)
|
||
|
|
if self.includeheaders:
|
||
|
|
w.write("%s\n" % (self.delimiter.join(map(lambda x: x[0], headers))))
|
||
|
|
if results:
|
||
|
|
for a in results:
|
||
|
|
w.write("%s\n" % (self.delimiter.join(map(self.format, a))))
|
||
|
|
w.flush()
|
||
|
|
w.close()
|
||
|
|
|
||
|
|
class Schema:
|
||
|
|
"""Produces a Schema object which represents the database schema for a table"""
|
||
|
|
def __init__(self, db, table, owner=None, full=0, sort=1):
|
||
|
|
self.db = db
|
||
|
|
self.table = table
|
||
|
|
self.owner = owner
|
||
|
|
self.full = full
|
||
|
|
self.sort = sort
|
||
|
|
_verbose = self.db.verbose
|
||
|
|
self.db.verbose = 0
|
||
|
|
try:
|
||
|
|
if table: self.computeschema()
|
||
|
|
finally:
|
||
|
|
self.db.verbose = _verbose
|
||
|
|
|
||
|
|
def computeschema(self):
|
||
|
|
self.db.table(self.table, owner=self.owner)
|
||
|
|
self.columns = []
|
||
|
|
# (column name, type_name, size, nullable)
|
||
|
|
if self.db.results:
|
||
|
|
self.columns = map(lambda x: (x[3], x[5], x[6], x[10]), self.db.results)
|
||
|
|
if self.sort: self.columns.sort(lambda x, y: cmp(x[0], y[0]))
|
||
|
|
|
||
|
|
self.db.fk(None, self.table)
|
||
|
|
# (pk table name, pk column name, fk column name, fk name, pk name)
|
||
|
|
self.imported = []
|
||
|
|
if self.db.results:
|
||
|
|
self.imported = map(lambda x: (x[2], x[3], x[7], x[11], x[12]), self.db.results)
|
||
|
|
if self.sort: self.imported.sort(lambda x, y: cmp(x[2], y[2]))
|
||
|
|
|
||
|
|
self.exported = []
|
||
|
|
if self.full:
|
||
|
|
self.db.fk(self.table, None)
|
||
|
|
# (pk column name, fk table name, fk column name, fk name, pk name)
|
||
|
|
if self.db.results:
|
||
|
|
self.exported = map(lambda x: (x[3], x[6], x[7], x[11], x[12]), self.db.results)
|
||
|
|
if self.sort: self.exported.sort(lambda x, y: cmp(x[1], y[1]))
|
||
|
|
|
||
|
|
self.db.pk(self.table)
|
||
|
|
self.primarykeys = []
|
||
|
|
if self.db.results:
|
||
|
|
# (column name, key_seq, pk name)
|
||
|
|
self.primarykeys = map(lambda x: (x[3], x[4], x[5]), self.db.results)
|
||
|
|
if self.sort: self.primarykeys.sort(lambda x, y: cmp(x[1], y[1]))
|
||
|
|
|
||
|
|
try:
|
||
|
|
self.indices = None
|
||
|
|
self.db.stat(self.table)
|
||
|
|
self.indices = []
|
||
|
|
# (non-unique, name, type, pos, column name, asc)
|
||
|
|
if self.db.results:
|
||
|
|
idxdict = {}
|
||
|
|
# mxODBC returns a row of None's, so filter it out
|
||
|
|
idx = map(lambda x: (x[3], x[5].strip(), x[6], x[7], x[8]), filter(lambda x: x[5], self.db.results))
|
||
|
|
def cckmp(x, y):
|
||
|
|
c = cmp(x[1], y[1])
|
||
|
|
if c == 0: c = cmp(x[3], y[3])
|
||
|
|
return c
|
||
|
|
# sort this regardless, this gets the indicies lined up
|
||
|
|
idx.sort(cckmp)
|
||
|
|
for a in idx:
|
||
|
|
if not idxdict.has_key(a[1]):
|
||
|
|
idxdict[a[1]] = []
|
||
|
|
idxdict[a[1]].append(a)
|
||
|
|
self.indices = idxdict.values()
|
||
|
|
if self.sort: self.indices.sort(lambda x, y: cmp(x[0][1], y[0][1]))
|
||
|
|
except:
|
||
|
|
pass
|
||
|
|
|
||
|
|
def __str__(self):
|
||
|
|
d = []
|
||
|
|
d.append("Table")
|
||
|
|
d.append(" " + self.table)
|
||
|
|
d.append("\nPrimary Keys")
|
||
|
|
for a in self.primarykeys:
|
||
|
|
d.append(" %s {%s}" % (a[0], a[2]))
|
||
|
|
d.append("\nImported (Foreign) Keys")
|
||
|
|
for a in self.imported:
|
||
|
|
d.append(" %s (%s.%s) {%s}" % (a[2], a[0], a[1], a[3]))
|
||
|
|
if self.full:
|
||
|
|
d.append("\nExported (Referenced) Keys")
|
||
|
|
for a in self.exported:
|
||
|
|
d.append(" %s (%s.%s) {%s}" % (a[0], a[1], a[2], a[3]))
|
||
|
|
d.append("\nColumns")
|
||
|
|
for a in self.columns:
|
||
|
|
nullable = choose(a[3], "nullable", "non-nullable")
|
||
|
|
d.append(" %-20s %s(%s), %s" % (a[0], a[1], a[2], nullable))
|
||
|
|
d.append("\nIndices")
|
||
|
|
if self.indices is None:
|
||
|
|
d.append(" (failed)")
|
||
|
|
else:
|
||
|
|
for a in self.indices:
|
||
|
|
unique = choose(a[0][0], "non-unique", "unique")
|
||
|
|
cname = ", ".join(map(lambda x: x[4], a))
|
||
|
|
d.append(" %s index {%s} on (%s)" % (unique, a[0][1], cname))
|
||
|
|
return "\n".join(d)
|
||
|
|
|
||
|
|
class IniParser:
|
||
|
|
def __init__(self, cfg, key='name'):
|
||
|
|
self.key = key
|
||
|
|
self.records = {}
|
||
|
|
self.ctypeRE = re.compile("\[(jdbc|odbc|default)\]")
|
||
|
|
self.entryRE = re.compile("([a-zA-Z]+)[ \t]*=[ \t]*(.*)")
|
||
|
|
self.cfg = cfg
|
||
|
|
self.parse()
|
||
|
|
|
||
|
|
def parse(self):
|
||
|
|
fp = open(self.cfg, "r")
|
||
|
|
data = fp.readlines()
|
||
|
|
fp.close()
|
||
|
|
lines = filter(lambda x: len(x) > 0 and x[0] not in ['#', ';'], map(lambda x: x.strip(), data))
|
||
|
|
current = None
|
||
|
|
for i in range(len(lines)):
|
||
|
|
line = lines[i]
|
||
|
|
g = self.ctypeRE.match(line)
|
||
|
|
if g: # a section header
|
||
|
|
current = {}
|
||
|
|
if not self.records.has_key(g.group(1)):
|
||
|
|
self.records[g.group(1)] = []
|
||
|
|
self.records[g.group(1)].append(current)
|
||
|
|
else:
|
||
|
|
g = self.entryRE.match(line)
|
||
|
|
if g:
|
||
|
|
current[g.group(1)] = g.group(2)
|
||
|
|
|
||
|
|
def __getitem__(self, (ctype, skey)):
|
||
|
|
if skey == self.key: return self.records[ctype][0][skey]
|
||
|
|
t = filter(lambda x, p=self.key, s=skey: x[p] == s, self.records[ctype])
|
||
|
|
if not t or len(t) > 1:
|
||
|
|
raise KeyError, "invalid key ('%s', '%s')" % (ctype, skey)
|
||
|
|
return t[0]
|
||
|
|
|
||
|
|
def random_table_name(prefix, num_chars):
|
||
|
|
import random
|
||
|
|
d = [prefix, '_']
|
||
|
|
i = 0
|
||
|
|
while i < num_chars:
|
||
|
|
d.append(chr(int(100 * random.random()) % 26 + ord('A')))
|
||
|
|
i += 1
|
||
|
|
return "".join(d)
|
||
|
|
|
||
|
|
class ResultSetRow:
|
||
|
|
def __init__(self, rs, row):
|
||
|
|
self.row = row
|
||
|
|
self.rs = rs
|
||
|
|
def __getitem__(self, i):
|
||
|
|
if type(i) == type(""):
|
||
|
|
i = self.rs.index(i)
|
||
|
|
return self.row[i]
|
||
|
|
def __getslice__(self, i, j):
|
||
|
|
if type(i) == type(""): i = self.rs.index(i)
|
||
|
|
if type(j) == type(""): j = self.rs.index(j)
|
||
|
|
return self.row[i:j]
|
||
|
|
def __len__(self):
|
||
|
|
return len(self.row)
|
||
|
|
def __repr__(self):
|
||
|
|
return str(self.row)
|
||
|
|
|
||
|
|
class ResultSet:
|
||
|
|
def __init__(self, headers, results=[]):
|
||
|
|
self.headers = map(lambda x: x.upper(), headers)
|
||
|
|
self.results = results
|
||
|
|
def index(self, i):
|
||
|
|
return self.headers.index(i.upper())
|
||
|
|
def __getitem__(self, i):
|
||
|
|
return ResultSetRow(self, self.results[i])
|
||
|
|
def __getslice__(self, i, j):
|
||
|
|
return map(lambda x, rs=self: ResultSetRow(rs, x), self.results[i:j])
|
||
|
|
def __repr__(self):
|
||
|
|
return "<%s instance {cols [%d], rows [%d]} at %s>" % (self.__class__, len(self.headers), len(self.results), id(self))
|