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())