def freeHandle(self, space, raiseError=True):
if not self.handle:
return
if self.isOwned:
roci.OCIHandleFree(self.handle, roci.OCI_HTYPE_STMT)
elif self.connection.handle:
tagBuffer = StringBuffer()
tagBuffer.fill(space, self.w_statementTag)
try:
status = roci.OCIStmtRelease(self.handle,
self.environment.errorHandle,
tagBuffer.ptr, tagBuffer.size,
roci.OCI_DEFAULT)
self.environment.checkForError(status, "Cursor_FreeHandle()")
finally:
tagBuffer.clear()
def close(self, space):
# make sure we are actually connnected
self._checkConnected(space)
# perform a rollback
status = roci.OCITransRollback(self.handle,
self.environment.errorHandle,
roci.OCI_DEFAULT)
self.environment.checkForError(status, "Connection_Close(): rollback")
# logoff of the server
if self.sessionHandle:
status = roci.OCISessionEnd(self.handle,
self.environment.errorHandle,
self.sessionHandle, roci.OCI_DEFAULT)
self.environment.checkForError(status,
"Connection_Close(): end session")
roci.OCIHandleFree(self.handle, roci.OCI_HTYPE_SVCCTX)
self.handle = lltype.nullptr(roci.OCISvcCtx.TO)
def create(space, threaded, events):
"Create a new environment object from scratch"
mode = roci.OCI_OBJECT
if threaded:
mode |= roci.OCI_THREADED
if events:
mode |= roci.OCI_EVENTS
handleptr = lltype.malloc(rffi.CArrayPtr(roci.OCIEnv).TO,
1, flavor='raw')
try:
status = roci.OCIEnvNlsCreate(
handleptr, mode,
None,
None, None, None,
0, lltype.nullptr(rffi.CArray(roci.dvoidp)),
config.CHARSETID, config.CHARSETID)
if not handleptr[0] or status not in (roci.OCI_SUCCESS,
roci.OCI_SUCCESS_WITH_INFO):
raise OperationError(
get(space).w_InterfaceError,
space.wrap(
"Unable to acquire Oracle environment handle"))
handle = handleptr[0]
finally:
lltype.free(handleptr, flavor='raw')
try:
newenv = Environment(space, handle)
except:
roci.OCIHandleFree(handle, roci.OCI_HTYPE_ENV)
raise
newenv.maxBytesPerCharacter = config.BYTES_PER_CHAR
newenv.maxStringBytes = config.BYTES_PER_CHAR * config.MAX_STRING_CHARS
return newenv
def getConnection(self, space, pool, w_cclass, purity):
"""Get a connection using the OCISessionGet() interface
rather than using the low level interface for connecting."""
proxyCredentials = False
authInfo = lltype.nullptr(roci.OCIAuthInfo.TO)
if pool:
w_dbname = pool.w_name
mode = roci.OCI_SESSGET_SPOOL
if not pool.homogeneous and pool.w_username and self.w_username:
proxyCredentials = space.is_true(
space.ne(pool.w_username, self.w_username))
mode |= roci.OCI_SESSGET_CREDPROXY
else:
w_dbname = self.w_tnsentry
mode = roci.OCI_SESSGET_STMTCACHE
stringBuffer = StringBuffer()
# set up authorization handle, if needed
if not pool or w_cclass or proxyCredentials:
# create authorization handle
handleptr = lltype.malloc(rffi.CArrayPtr(roci.OCIAuthInfo).TO,
1,
flavor='raw')
try:
status = roci.OCIHandleAlloc(
self.environment.handle, handleptr,
roci.OCI_HTYPE_AUTHINFO, 0,
lltype.nullptr(rffi.CArray(roci.dvoidp)))
self.environment.checkForError(
status, "Connection_GetConnection(): allocate handle")
authInfo = handleptr[0]
finally:
lltype.free(handleptr, flavor='raw')
externalCredentials = True
# set the user name, if applicable
stringBuffer.fill(space, self.w_username)
try:
if stringBuffer.size > 0:
externalCredentials = False
status = roci.OCIAttrSet(authInfo, roci.OCI_HTYPE_AUTHINFO,
stringBuffer.ptr,
stringBuffer.size,
roci.OCI_ATTR_USERNAME,
self.environment.errorHandle)
self.environment.checkForError(
status, "Connection_GetConnection(): set user name")
finally:
stringBuffer.clear()
# set the password, if applicable
stringBuffer.fill(space, self.w_password)
try:
if stringBuffer.size > 0:
externalCredentials = False
status = roci.OCIAttrSet(authInfo, roci.OCI_HTYPE_AUTHINFO,
stringBuffer.ptr,
stringBuffer.size,
roci.OCI_ATTR_PASSWORD,
self.environment.errorHandle)
self.environment.checkForError(
status, "Connection_GetConnection(): set password")
finally:
stringBuffer.clear()
# if no user name or password are set, using external credentials
if not pool and externalCredentials:
mode |= roci.OCI_SESSGET_CREDEXT
# set the connection class, if applicable
if roci.OCI_ATTR_CONNECTION_CLASS is not None:
stringBuffer.fill(space, w_cclass)
try:
if stringBuffer.size > 0:
externalCredentials = False
status = roci.OCIAttrSet(
authInfo, roci.OCI_HTYPE_AUTHINFO,
stringBuffer.ptr, stringBuffer.size,
roci.OCI_ATTR_CONNECTION_CLASS,
self.environment.errorHandle)
self.environment.checkForError(
status,
"Connection_GetConnection(): set connection class")
finally:
stringBuffer.clear()
# set the purity, if applicable
if (roci.OCI_ATTR_PURITY is not None
and purity != roci.OCI_ATTR_PURITY_DEFAULT):
purityptr = lltype.malloc(rffi.CArrayPtr(roci.ub4).TO,
1,
flavor='raw')
purityptr[0] = rffi.cast(roci.ub4, purity)
try:
status = roci.OCIAttrSet(authInfo, roci.OCI_HTYPE_AUTHINFO,
rffi.cast(roci.dvoidp, purityptr),
rffi.sizeof(roci.ub4),
roci.OCI_ATTR_PURITY,
self.environment.errorHandle)
self.environment.checkForError(
status, "Connection_GetConnection(): set purity")
finally:
lltype.free(purityptr, flavor='raw')
# acquire the new session
stringBuffer.fill(space, w_dbname)
foundptr = lltype.malloc(rffi.CArrayPtr(roci.boolean).TO,
1,
flavor='raw')
handleptr = lltype.malloc(rffi.CArrayPtr(roci.OCISvcCtx).TO,
1,
flavor='raw')
try:
status = roci.OCISessionGet(
self.environment.handle, self.environment.errorHandle,
handleptr, authInfo, stringBuffer.ptr, stringBuffer.size, None,
0, lltype.nullptr(roci.Ptr(roci.oratext).TO),
lltype.nullptr(roci.Ptr(roci.ub4).TO), foundptr, mode)
self.environment.checkForError(
status, "Connection_GetConnection(): get connection")
self.handle = handleptr[0]
finally:
stringBuffer.clear()
lltype.free(foundptr, flavor='raw')
lltype.free(handleptr, flavor='raw')
# eliminate the authorization handle immediately, if applicable
if authInfo:
roci.OCIHandleFree(authInfo, roci.OCI_HTYPE_AUTHINFO)
# copy members in the case where a pool is being used
if pool:
if not proxyCredentials:
self.w_username = pool.w_username
self.w_password = pool.w_password
self.w_tnsentry = pool.w_tnsentry
self.sessionPool = pool
self.release = True
def initialize(self, connection, param):
nameptr = lltype.malloc(rffi.CArrayPtr(roci.oratext).TO, 1,
flavor='raw')
lenptr = lltype.malloc(rffi.CArrayPtr(roci.ub4).TO, 1,
flavor='raw')
try:
# determine the schema of the type
status = roci.OCIAttrGet(
param, roci.OCI_HTYPE_DESCRIBE,
rffi.cast(roci.dvoidp, nameptr),
lenptr,
roci.OCI_ATTR_SCHEMA_NAME,
self.environment.errorHandle)
self.environment.checkForError(
status,
"ObjectType_Initialize(): get schema name")
self.schema = rffi.charpsize2str(nameptr[0], lenptr[0])
# determine the name of the type
status = roci.OCIAttrGet(
param, roci.OCI_HTYPE_DESCRIBE,
rffi.cast(roci.dvoidp, nameptr),
lenptr,
roci.OCI_ATTR_TYPE_NAME,
self.environment.errorHandle)
self.environment.checkForError(
status,
"ObjectType_Initialize(): get schema name")
self.name = rffi.charpsize2str(nameptr[0], lenptr[0])
finally:
lltype.free(nameptr, flavor='raw')
lltype.free(lenptr, flavor='raw')
# retrieve TDO (type descriptor object) of the parameter
tdorefptr = lltype.malloc(rffi.CArrayPtr(roci.OCIRef).TO, 1,
flavor='raw')
try:
status = roci.OCIAttrGet(
param, roci.OCI_HTYPE_DESCRIBE,
rffi.cast(roci.dvoidp, tdorefptr),
lltype.nullptr(roci.Ptr(roci.ub4).TO),
roci.OCI_ATTR_REF_TDO,
self.environment.errorHandle)
self.environment.checkForError(
status,
"ObjectType_Initialize(): get TDO reference")
tdoref = tdorefptr[0]
finally:
lltype.free(tdorefptr, flavor='raw')
tdoptr = lltype.malloc(rffi.CArrayPtr(roci.dvoidp).TO, 1,
flavor='raw')
try:
status = roci.OCIObjectPin(
self.environment.handle,
self.environment.errorHandle,
tdoref,
None, roci.OCI_PIN_ANY,
roci.OCI_DURATION_SESSION, roci.OCI_LOCK_NONE,
tdoptr)
self.environment.checkForError(
status,
"ObjectType_Initialize(): pin TDO reference")
self.tdo = tdoptr[0]
finally:
lltype.free(tdoptr, flavor='raw')
# acquire a describe handle
handleptr = lltype.malloc(rffi.CArrayPtr(roci.OCIDescribe).TO,
1, flavor='raw')
try:
status = roci.OCIHandleAlloc(
self.environment.handle,
handleptr, roci.OCI_HTYPE_DESCRIBE, 0,
lltype.nullptr(rffi.CArray(roci.dvoidp)))
self.environment.checkForError(
status, "ObjectType_Initialize(): allocate describe handle")
describeHandle = handleptr[0]
finally:
lltype.free(handleptr, flavor='raw')
# describe the type
try:
self.describe(connection, describeHandle)
finally:
roci.OCIHandleFree(describeHandle, roci.OCI_HTYPE_DESCRIBE)