def __init__(self, initval=None):
# initval can be either a length, or a string
# [most likely packed by struct/npstruct]
if type(initval) == type(0):
self.mb = calldll.membuf(initval)
elif type(initval) == type(''):
self.mb = calldll.membuf(len(initval))
self.mb.write(initval)
def __init__ (self, initval=None):
# initval can be either a length, or a string
# [most likely packed by struct/npstruct]
if type(initval) == type(0):
self.mb = calldll.membuf (initval)
elif type(initval) == type (''):
self.mb = calldll.membuf (len (initval))
self.mb.write (initval)
def sql_error(env, dbc, stmt):
error_msg = cstring('', 511)
sql_state = cstring('', 63)
native_error = calldll.membuf(2) # c->w
errlen = calldll.membuf(2) # c->w
result = odbc.SQLError(env, dbc, stmt, sql_state, native_error.address(),
error_msg, len(error_msg), errlen.address())
print sql_state.trunc()
print error_msg.trunc()
print 'native error ', struct.unpack('h', native_error.read())[0]
def describe_col(self, col):
col_name = cstring('', 255)
col_name_len = calldll.membuf(2) # c->w
sql_type = calldll.membuf(2) # c->w
col_def = calldll.membuf(2) # c->w
scale = calldll.membuf(2) # c->w
nullable = calldll.membuf(2) # c->w
retval = odbc.SQLDescribeCol(self, col, col_name, len(col_name),
col_name_len.address(),
sql_type.address(), col_def.address(),
scale.address(), nullable.address())
return (col_name.trunc(), struct.unpack('h', sql_type.read())[0],
struct.unpack('h', col_def.read())[0],
struct.unpack('h', scale.read())[0],
struct.unpack('h', nullable.read())[0])
def row_count(self):
countbuff = calldll.membuf(4)
rc = odbc.SQLRowCount(self, countbuff.address())
if rc:
sql_error(self.connection.environment, self.connection, self)
raise error, 'SQLRowCount: %d' % rc
(count, ) = struct.unpack('l', countbuff.read())
return count
def drivers(self):
driver = cstring('', 1023)
driverlen = calldll.membuf(4) # c->w
attr = cstring('', 1023)
attrlen = calldll.membuf(4) # c->w
result = []
while 1:
retval = odbc.SQLDrivers(self, SQL_FETCH_NEXT, driver, len(driver),
driverlen.address(), attr, len(attr),
attrlen.address())
if retval == SQL_NO_DATA_FOUND:
break
elif retval == SQL_SUCCESS:
result.append(driver.trunc(), attr.trunc())
else:
raise error, 'SQLDrivers: %d' % retval
return result
def get_info_low(self, type, buffer=None, size=511):
if buffer is None:
buffer = cstring('\000' * size)
retval_len = calldll.membuf(2) # c->w
retval = odbc.SQLGetInfo(self, type, buffer, len(buffer),
retval_len.address())
if retval:
raise error, 'SQLGetInfo: %d' % retval
return buffer
def __init__ (self, s, length=0, remember=0): # make sure to zero-terminate the string if length > len(s): s = s + '\000' * (length - len(s)) elif not s: s = '\000' elif s[-1] != '\000': s = s + '\000' self.mb = calldll.membuf (len(s)) self.mb.write (s) if remember: cstring.immortal[self.mb] = 1
def __init__(self, s, length=0, remember=0):
# make sure to zero-terminate the string
if length > len(s):
s = s + '\000' * (length - len(s))
elif not s:
s = '\000'
elif s[-1] != '\000':
s = s + '\000'
self.mb = calldll.membuf(len(s))
self.mb.write(s)
if remember:
cstring.immortal[self.mb] = 1
def __init__(self, param_type, length=None):
self.length_capture = calldll.membuf(4) # c->w
self.length_capture_address = self.length_capture.address()
if param_type == types.IntType:
self.mb = calldll.membuf(self.int_len) # c->w
self.set_actual_length(self.int_len)
self.set = self.set_integer
self.get = self.get_integer
self.sql_type = SQL_INTEGER
elif param_type == types.FloatType:
self.mb = calldll.membuf(self.float_len) # c->w
self.set_actual_length(self.float_len)
self.set = self.set_float
self.get = self.get_float
self.SQL_TYPE = SQL_DOUBLE
elif param_type == types.StringType:
self.mb = calldll.membuf(length) # c->w
self.set = self.set_string
self.get = self.get_string
self.sql_type = SQL_CHAR
else:
raise ValueError, "Unsupported parameter type %s" % param_type
self.param_type = param_type
def data_sources(self):
dsn = cstring('', 255)
dsnlen = calldll.membuf(4) # c->w
desc = cstring('', 511)
desclen = calldll.membuf(4) # c->w
result = []
while 1:
retval = odbc.SQLDataSources(
self,
SQL_FETCH_NEXT,
dsn,
len(dsn),
dsnlen.address(),
desc,
len(desc),
desclen.address(),
)
if retval == SQL_NO_DATA_FOUND:
break
elif retval == SQL_SUCCESS:
result.append(dsn.trunc(), desc.trunc())
else:
raise error, 'SQLDataSources: %d' % retval
return result
def grow(self, new_length):
data = self.mb.read()
self.mb = calldll.membuf(new_length) # c->w
self.mb.write(data[:new_length])
def num_result_cols(self):
cols = calldll.membuf(2) # c->w
retval = odbc.SQLNumResultCols(self, cols.address())
return struct.unpack('h', cols.read())[0]
class statement(opaque_handle):
closed = 0
def __init__(self, connection):
self.connection = connection
opaque_handle.__init__(self)
retval = odbc.SQLAllocStmt(connection, self.ptr())
if retval:
raise error, 'SQLAllocStmt Failed: %d' % retval
def close(self):
#print 'closing %s' % repr(self)
self.free()
self.closed = 1
def free(self, option=SQL_DROP):
result = odbc.SQLFreeStmt(self, option)
if result:
sql_error(self.connection.environment, self.connection, self)
raise error, 'SQLFreeStmt Failed: %d' % retval
def __del__(self):
if not self.closed:
self.close()
# Access can't do this?
def tables(self, qualifier=0, owner=0, name=0, type='TABLE'):
def maybe_cstring(s):
if s != 0:
return cstring(s), len(s)
else:
return 0, 0
q, ql = maybe_cstring(qualifier)
o, ol = maybe_cstring(owner)
n, nl = maybe_cstring(name)
t, tl = maybe_cstring(type)
retval = odbc.SQLTables(self, q, ql, o, ol, n, nl, t, tl)
if retval:
raise error, 'SQLTables: %d' % retval
def columns(self, table_name, column_name=0, qualifier=0, owner=0):
def maybe_cstring(s):
if s != 0:
return cstring(s), len(s)
else:
return 0, 0
q, ql = maybe_cstring(qualifier)
o, ol = maybe_cstring(owner)
t, tl = maybe_cstring(table_name)
c, cl = maybe_cstring(column_name)
retval = odbc.SQLColumns(self, q, ql, o, ol, t, tl, c, cl)
if retval:
raise error, 'SQLColumns: %d' % retval
def num_result_cols(self):
cols = calldll.membuf(2) # c->w
retval = odbc.SQLNumResultCols(self, cols.address())
return struct.unpack('h', cols.read())[0]
def describe_col(self, col):
col_name = cstring('', 255)
col_name_len = calldll.membuf(2) # c->w
sql_type = calldll.membuf(2) # c->w
col_def = calldll.membuf(2) # c->w
scale = calldll.membuf(2) # c->w
nullable = calldll.membuf(2) # c->w
retval = odbc.SQLDescribeCol(self, col, col_name, len(col_name),
col_name_len.address(),
sql_type.address(), col_def.address(),
scale.address(), nullable.address())
return (col_name.trunc(), struct.unpack('h', sql_type.read())[0],
struct.unpack('h', col_def.read())[0],
struct.unpack('h', scale.read())[0],
struct.unpack('h', nullable.read())[0])
def exec_direct(self, sql_str):
sql_str = cstring(sql_str)
retval = odbc.SQLExecDirect(self, sql_str, len(sql_str))
if retval:
sql_error(self.connection.environment, self.connection, self)
raise error, 'SQLExecDirect: %d' % retval
def fetch(self):
return odbc.SQLFetch(self)
buflen = calldll.membuf(4) # c->w
# need to do fancy type handling here
def get_data(self, col, type=SQL_CHAR, buffer=None):
if buffer is None:
buffer = cstring('\000' * 1023)
retval = odbc.SQLGetData(self, col, type, buffer, len(buffer),
self.buflen.address())
(real_len, ) = struct.unpack('l', self.buflen.read())
if real_len == SQL_NULL_DATA:
return retval, None
return retval, buffer.trunc()
# Thanks to Gordon McMillan ([email protected]) !
def row_count(self):
countbuff = calldll.membuf(4)
rc = odbc.SQLRowCount(self, countbuff.address())
if rc:
sql_error(self.connection.environment, self.connection, self)
raise error, 'SQLRowCount: %d' % rc
(count, ) = struct.unpack('l', countbuff.read())
return count
def get_result(self, buffer=None):
num_cols = self.num_result_cols()
result = [
map(lambda x, s=self: s.describe_col(x + 1), range(num_cols))
]
if buffer is None:
buffer = cstring('\000' * 8192)
while not self.fetch():
row = []
for i in range(num_cols):
retval, data = self.get_data(i + 1, SQL_CHAR, buffer)
row.append(data)
result.append(row)
return result
# apply a function to each row of the result
def iterate_result(self, function, buffer=None):
num_cols = self.num_result_cols()
if buffer is None:
buffer = cstring('\000' * 511)
while not self.fetch():
row = []
for i in range(num_cols):
retval, data = self.get_data(i + 1, SQL_CHAR, buffer)
row.append(data)
function(row)
def prepare(self, sql_str):
sql_str = cstring(sql_str)
result = odbc.SQLPrepare(self, sql_str, len(sql_str))
if result:
sql_error(self.connection.environment, self.connection, self)
raise error, 'SQLPrepare: %d' % result
def bind_parameter(
self,
# index of the parameter
num,
# buffer for input/output
buffer,
# choose [input, input/output, or output]
param_type=SQL_PARAM_INPUT,
c_type=SQL_C_DEFAULT,
col_def=0,
scale=0):
result = odbc.SQLBindParameter(self, num,
param_type, c_type, buffer.sql_type,
buffer.col_def(), scale, buffer,
len(buffer),
buffer.length_capture_address)
if result:
sql_error(self.connection.environment, self.connection, self)
raise error, 'SQLBindParameter: %d' % result
def execute(self):
result = odbc.SQLExecute(self)
if result:
sql_error(self.connection.environment, self.connection, self)
raise error, 'SQLExecute: %d' % result
def get_info_word(self, type):
buffer = calldll.membuf(2) # c->w
self.get_info_low(type, buffer)
struct.unpack('h', buffer.read())
def __init__(self):
self.buffer = calldll.membuf(4) # c->w
self.known = 0
a = calldll.read_string(vVar.address())
print a, len(a)
def mySetLong(vMemBuf, vValueToSet):
''' set to an unsigned long the value of a membuf with len == 4 '''
vMemBuf.write(struct.pack('L', vValueToSet))
def mySetString(vMemBuf, vValueToSet):
''' set to a string (with \0 terminator) the value of a membuf '''
pack_format = "%ds" % 1+len(vValueToSet) # +1 for the \0
string_packed = struct.pack(pack_format, vValueToSet) # pack() adds the \0
vMemBuf.write(string_packed)
# load 'Ehllapi.dll' (from current dir), and function 'hllapi' from the DLL
dll_handle = calldll.load_library ('.\\Ehllapi')
function_address = calldll.get_proc_address (dll_handle, 'HLLAPI')
# allocate and init three membufs with the size to hold an unsigned long
Lsize = struct.calcsize('L')
vFunction = calldll.membuf(Lsize)
mySetLong(vFunction, 1)
vTextLen = calldll.membuf(Lsize)
vResult = calldll.membuf(Lsize)
mySetLong(vResult, 1)
# allocate a membuf as large as the DLL requires; in this case, space
# for 24 x 80 characters + 1 for a \0 terminator
vText = calldll.membuf(1921)
# init the text and text-length variables based on string of interest
string_value_to_write = 'A'
mySetString(vText, string_value_to_write)
mySetLong(vTextLen, len(string_value_to_write))
# call the function, print the results, and clean up
calldll.call_foreign_function(function_address, 'llll', 'l',
(vFunction.address(), vText.address(), vTextLen.address(), vResult.address()))
myPrintLong(vResult)
def get_info_long(self, type):
buffer = calldll.membuf(4) # c->w
self.get_info_low(type, buffer)
struct.unpack('l', buffer.read())
