func (bnd *bndBfile) close() (err error) {
defer func() {
if value := recover(); value != nil {
err = errR(value)
}
}()
if bnd.cDirectoryAlias != nil {
C.free(unsafe.Pointer(bnd.cDirectoryAlias))
}
if bnd.cFilename != nil {
C.free(unsafe.Pointer(bnd.cFilename))
}
if bnd.ociLobLocator != nil {
C.OCIDescriptorFree(
unsafe.Pointer(bnd.ociLobLocator), //void *descp,
C.OCI_DTYPE_FILE) //ub4 type );
}
stmt := bnd.stmt
bnd.stmt = nil
bnd.ocibnd = nil
bnd.ociLobLocator = nil
bnd.cDirectoryAlias = nil
bnd.cFilename = nil
stmt.putBnd(bndIdxBfile, bnd)
return nil
}
// Allocate a variable and define it for the given statement.
func (cur *Cursor) varDefine(numElements, position uint) (*Variable, error) {
var param *C.OCIParam
// retrieve parameter descriptor
if cur.handle == nil {
log.Printf("WARN: nil cursor handle in varDefine!")
}
// log.Printf("retrieve parameter descriptor cur.handle=%s pos=%d", cur.handle, position)
if CTrace {
ctrace("OCIParamGet(cur=%p, HTYPE_STMT, env=%p, param=%p, position=%d)",
cur.handle, "HTYPE_STMT", cur.environment.errorHandle,
¶m, position)
}
if err := cur.environment.CheckStatus(
C.OCIParamGet(unsafe.Pointer(cur.handle), C.OCI_HTYPE_STMT,
cur.environment.errorHandle,
(*unsafe.Pointer)(unsafe.Pointer(¶m)), C.ub4(position)),
"parameter"); err != nil {
log.Printf("NO PARAM! %s", err)
return nil, err
}
// log.Printf("got param handle")
// call the helper to do the actual work
v, err := cur.variableDefineHelper(param, position, numElements)
// log.Printf("variable defined err=%s nil?%s", err, err == nil)
if CTrace {
ctrace("OCIDescriptorFree(%p, DTYPE_PARAM)", param)
}
C.OCIDescriptorFree(unsafe.Pointer(param), C.OCI_DTYPE_PARAM)
return v, err
}
func (bnd *bndLobPtr) close() (err error) {
defer func() {
if value := recover(); value != nil {
err = errR(value)
}
}()
// no need to clear bnd.buf
// free temporary lob
C.OCILobFreeTemporary(
bnd.stmt.ses.srv.ocisvcctx, //OCISvcCtx *svchp,
bnd.stmt.ses.srv.env.ocierr, //OCIError *errhp,
bnd.ociLobLocator) //OCILobLocator *locp,
// free lob locator handle
C.OCIDescriptorFree(
unsafe.Pointer(bnd.ociLobLocator), //void *descp,
C.OCI_DTYPE_LOB) //ub4 type );
stmt := bnd.stmt
bnd.stmt = nil
bnd.value = nil
bnd.ocibnd = nil
bnd.ociLobLocator = nil
stmt.putBnd(bndIdxLobPtr, bnd)
return nil
}
func (bnd *bndLobSlice) close() (err error) {
defer func() {
if value := recover(); value != nil {
err = errR(value)
}
}()
for n := 0; n < len(bnd.ociLobLocators); n++ {
// free temporary lob
C.OCILobFreeTemporary(
bnd.stmt.ses.ocisvcctx, //OCISvcCtx *svchp,
bnd.stmt.ses.srv.env.ocierr, //OCIError *errhp,
bnd.ociLobLocators[n]) //OCILobLocator *locp,
// free lob locator handle
C.OCIDescriptorFree(
unsafe.Pointer(bnd.ociLobLocators[n]), //void *descp,
C.OCI_DTYPE_LOB) //ub4 type );
}
stmt := bnd.stmt
bnd.stmt = nil
bnd.ocibnd = nil
bnd.ociLobLocators = nil
stmt.putBnd(bndIdxBinSlice, bnd)
return nil
}
func allocTempLob(stmt *Stmt) (
ociLobLocator *C.OCILobLocator,
finish func(),
err error,
) {
// Allocate lob locator handle
r := C.OCIDescriptorAlloc(
unsafe.Pointer(stmt.ses.srv.env.ocienv), //CONST dvoid *parenth,
(*unsafe.Pointer)(unsafe.Pointer(&ociLobLocator)), //dvoid **descpp,
C.OCI_DTYPE_LOB, //ub4 type,
0, //size_t xtramem_sz,
nil) //dvoid **usrmempp);
if r == C.OCI_ERROR {
return nil, nil, stmt.ses.srv.env.ociError()
} else if r == C.OCI_INVALID_HANDLE {
return nil, nil, errNew("unable to allocate oci lob handle during bind")
}
// Create temporary lob
r = C.OCILobCreateTemporary(
stmt.ses.srv.ocisvcctx, //OCISvcCtx *svchp,
stmt.ses.srv.env.ocierr, //OCIError *errhp,
ociLobLocator, //OCILobLocator *locp,
C.OCI_DEFAULT, //ub2 csid,
C.SQLCS_IMPLICIT, //ub1 csfrm,
C.OCI_TEMP_BLOB, //ub1 lobtype,
C.TRUE, //boolean cache,
C.OCI_DURATION_SESSION) //OCIDuration duration);
if r == C.OCI_ERROR {
// free lob locator handle
C.OCIDescriptorFree(
unsafe.Pointer(ociLobLocator), //void *descp,
C.OCI_DTYPE_LOB) //ub4 type );
return nil, nil, stmt.ses.srv.env.ociError()
}
return ociLobLocator, func() {
C.OCILobFreeTemporary(
stmt.ses.srv.ocisvcctx, //OCISvcCtx *svchp,
stmt.ses.srv.env.ocierr, //OCIError *errhp,
ociLobLocator) //OCILobLocator *locp,
// free lob locator handle
C.OCIDescriptorFree(
unsafe.Pointer(ociLobLocator), //void *descp,
C.OCI_DTYPE_LOB) //ub4 type );
}, nil
}
func (bnd *bndIntervalYMSlice) free(n int) {
defer func() {
recover()
}()
C.OCIDescriptorFree(
unsafe.Pointer(bnd.ociIntervals[n]), //void *descp,
C.OCI_DTYPE_INTERVAL_YM) //ub4 type );
}
func (def *defTime) free() {
defer func() {
recover()
}()
C.OCIDescriptorFree(
unsafe.Pointer(def.ociDateTime), //void *descp,
C.OCI_DTYPE_TIMESTAMP_TZ) //ub4 type );
}
func (bnd *bndTimeSlice) free(n int) {
defer func() {
recover()
}()
C.OCIDescriptorFree(
unsafe.Pointer(bnd.ociDateTimes[n]), //void *descp,
C.OCI_DTYPE_TIMESTAMP_TZ) //ub4 type );
}
func (def *defBfile) free() {
defer func() {
recover()
}()
C.OCIDescriptorFree(
unsafe.Pointer(def.ociLobLocator), //void *descp,
C.OCI_DTYPE_FILE) //ub4 type );
}
// Prepare for variable destruction.
func lobVar_Finalize(v *Variable) error {
for i := uint(0); i < v.allocatedElements; i++ {
if v.dataBytes != nil && uint(len(v.dataBytes)) > i && v.dataBytes[i] != 0 {
C.OCIDescriptorFree(unsafe.Pointer(&v.dataBytes[i]), C.OCI_DTYPE_LOB)
}
}
return nil
}
func (def *defIntervalDS) free() {
defer func() {
recover()
}()
C.OCIDescriptorFree(
unsafe.Pointer(def.ociInterval), //void *descp,
C.OCI_DTYPE_INTERVAL_DS) //timeDefine.descTypeCode) //ub4 type );
}
func (def *defLob) free() {
if def.ociLobLocator == nil { // dissociated or already freed
return
}
C.OCIDescriptorFree(
unsafe.Pointer(def.ociLobLocator), //void *descp,
C.OCI_DTYPE_LOB) //ub4 type );
def.ociLobLocator = nil
}
// Prepare for variable destruction.
func lobVarFinalize(v *Variable) error {
var j int
for i := uint(0); i < v.allocatedElements; i++ {
j = int(i * v.typ.size)
if v.dataBytes != nil && len(v.dataBytes) > j && v.dataBytes[j] != 0 {
C.OCIDescriptorFree(unsafe.Pointer(&v.dataBytes[j]), C.OCI_DTYPE_LOB)
}
}
return nil
}
func (rc *OCI8Rows) Close() error {
for _, col := range rc.cols {
if col.kind == C.SQLT_CLOB || col.kind == C.SQLT_BLOB {
C.OCIDescriptorFree(
col.pbuf,
C.OCI_DTYPE_LOB)
} else {
C.free(col.pbuf)
}
}
return rc.s.Close()
}
// Prepare for variable destruction.
func lobVarFinalize(v *Variable) error {
if v == nil || v.dataBytes == nil {
return nil
}
for i := uint(0); i < v.allocatedElements; i++ {
if CTrace {
ctrace("lobVarFinalize(lob=%x)", v.getHandle(i))
}
C.OCIDescriptorFree(v.getHandle(i), C.OCI_DTYPE_LOB)
}
return nil
}
// intervalVarFinalize prepares for variable destruction.
func intervalVarFinalize(v *Variable) error {
var status C.sword
var handle unsafe.Pointer
for i := uint(0); i < v.allocatedElements; i++ {
if handle = unsafe.Pointer(getIntervalHandle(v, i)); handle != nil {
if status = C.OCIDescriptorFree(handle, C.OCI_DTYPE_INTERVAL_DS); status != C.OCI_SUCCESS {
return fmt.Errorf("error freeing Interval %d. handle %p: %d",
i, handle, status)
}
}
}
return nil
}
func (bnd *bndIntervalYM) close() (err error) {
defer func() {
if value := recover(); value != nil {
err = errR(value)
}
}()
C.OCIDescriptorFree(
unsafe.Pointer(bnd.ociInterval), //void *descp,
C.OCI_DTYPE_INTERVAL_YM) //timeDefine.descTypeCode) //ub4 type );
stmt := bnd.stmt
bnd.stmt = nil
bnd.ocibnd = nil
bnd.ociInterval = nil
stmt.putBnd(bndIdxIntervalYM, bnd)
return nil
}
func lobClose(ses *Ses, lob *C.OCILobLocator) error {
if lob == nil {
return nil
}
//Log.Infof("OCILobClose %p\n%s", lob, getStack(1))
r := C.OCILobClose(
ses.ocisvcctx, //OCISvcCtx *svchp,
ses.srv.env.ocierr, //OCIError *errhp,
lob, //OCILobLocator *locp,
)
C.OCIDescriptorFree(unsafe.Pointer(lob), //void *descp,
C.OCI_DTYPE_LOB) //ub4 type );
if r == C.OCI_ERROR {
return ses.srv.env.ociError()
}
return nil
}
// Prepare for variable destruction.
func lobVarFinalize(v *Variable) error {
if v == nil || v.dataBytes == nil {
return nil
}
var err error
for i := uint(0); i < v.allocatedElements; i++ {
hndl, e := v.getLobLoc(i)
if CTrace {
ctrace("lobVarFinalize(lob=%x) err=%v", hndl, e)
}
if e == nil {
C.OCIDescriptorFree(unsafe.Pointer(hndl), C.OCI_DTYPE_LOB)
} else if err == nil {
err = e
}
}
return err
}
func (bnd *bndIntervalDSSlice) close() (err error) {
defer func() {
if value := recover(); value != nil {
err = errR(value)
}
}()
for n := 0; n < len(bnd.ociIntervals); n++ {
C.OCIDescriptorFree(
unsafe.Pointer(bnd.ociIntervals[n]), //void *descp,
C.OCI_DTYPE_INTERVAL_DS) //ub4 type );
}
stmt := bnd.stmt
bnd.stmt = nil
bnd.ocibnd = nil
bnd.ociIntervals = nil
stmt.putBnd(bndIdxIntervalDSSlice, bnd)
return nil
}
func (bnd *bndTimePtr) close() (err error) {
defer func() {
if value := recover(); value != nil {
err = errR(value)
}
}()
if bnd.cZone != nil {
C.free(unsafe.Pointer(bnd.cZone))
bnd.cZone = nil
C.OCIDescriptorFree(
unsafe.Pointer(bnd.ociDateTime), //void *descp,
C.OCI_DTYPE_TIMESTAMP_TZ) //ub4 type );
}
stmt := bnd.stmt
bnd.stmt = nil
bnd.ocibnd = nil
bnd.ociDateTime = nil
bnd.value = nil
stmt.putBnd(bndIdxTimePtr, bnd)
return nil
}
// Return a tuple describing the item at the given position.
func (cur *Cursor) itemDescription(pos uint) (desc VariableDescription, err error) {
var param *C.OCIParam
// acquire parameter descriptor
if CTrace {
ctrace("OCIParamGet", cur.handle, "HTYPE_STMT", cur.environment.errorHandle,
¶m, pos)
}
if err = cur.environment.CheckStatus(
C.OCIParamGet(unsafe.Pointer(cur.handle), C.OCI_HTYPE_STMT,
cur.environment.errorHandle,
(*unsafe.Pointer)(unsafe.Pointer(¶m)), C.ub4(pos)),
"itemDescription(): parameter"); err != nil {
return
}
// use helper routine to get tuple
desc, err = cur.itemDescriptionHelper(pos, param)
if CTrace {
ctrace("OCIDescriptorFree", param, "DTYPE_PARAM")
}
C.OCIDescriptorFree(unsafe.Pointer(param), C.OCI_DTYPE_PARAM)
return
}
func freeDecriptor(p unsafe.Pointer, dtype C.ub4) {
tptr := *(*unsafe.Pointer)(p)
C.OCIDescriptorFree(unsafe.Pointer(tptr), dtype)
}
func (s *OCI8Stmt) bind(args []driver.Value) (freeBoundParameters func(), err error) {
if args == nil {
return func() {}, nil
}
var (
bp *C.OCIBind
dty C.ub2
data []byte
cdata *C.char
boundParameters []oci8bind
)
freeBoundParameters = func() {
for _, col := range boundParameters {
if col.pbuf != nil {
if col.kind == C.SQLT_CLOB || col.kind == C.SQLT_BLOB {
C.OCIDescriptorFree(
col.pbuf,
C.OCI_DTYPE_LOB)
} else {
C.free(col.pbuf)
}
}
}
}
for i, v := range args {
data = []byte{}
switch v.(type) {
case nil:
dty = C.SQLT_STR
boundParameters = append(boundParameters, oci8bind{dty, nil})
rv := C.OCIBindByPos(
(*C.OCIStmt)(s.s),
&bp,
(*C.OCIError)(s.c.err),
C.ub4(i+1),
nil,
0,
dty,
nil,
nil,
nil,
0,
nil,
C.OCI_DEFAULT)
if rv == C.OCI_ERROR {
defer freeBoundParameters()
return nil, ociGetError(s.c.err)
}
case []byte:
// FIXME: Currently, CLOB not supported
dty = C.SQLT_BLOB
data = v.([]byte)
var bamt C.ub4
var pbuf unsafe.Pointer
rv := C.OCIDescriptorAlloc(
s.c.env,
&pbuf,
C.OCI_DTYPE_LOB,
0,
nil)
if rv == C.OCI_ERROR {
defer freeBoundParameters()
return nil, ociGetError(s.c.err)
}
rv = C.OCILobCreateTemporary(
(*C.OCISvcCtx)(s.c.svc),
(*C.OCIError)(s.c.err),
(*C.OCILobLocator)(pbuf),
0,
C.SQLCS_IMPLICIT,
C.OCI_TEMP_BLOB,
C.OCI_ATTR_NOCACHE,
C.OCI_DURATION_SESSION)
if rv == C.OCI_ERROR {
defer freeBoundParameters()
return nil, ociGetError(s.c.err)
}
bamt = C.ub4(len(data))
rv = C.OCILobWrite(
(*C.OCISvcCtx)(s.c.svc),
(*C.OCIError)(s.c.err),
(*C.OCILobLocator)(pbuf),
&bamt,
1,
unsafe.Pointer(&data[0]),
C.ub4(len(data)),
C.OCI_ONE_PIECE,
nil,
nil,
0,
C.SQLCS_IMPLICIT)
if rv == C.OCI_ERROR {
defer freeBoundParameters()
return nil, ociGetError(s.c.err)
}
boundParameters = append(boundParameters, oci8bind{dty, pbuf})
rv = C.OCIBindByPos(
(*C.OCIStmt)(s.s),
&bp,
(*C.OCIError)(s.c.err),
C.ub4(i+1),
unsafe.Pointer(&pbuf),
0,
dty,
nil,
nil,
nil,
0,
nil,
C.OCI_DEFAULT)
if rv == C.OCI_ERROR {
defer freeBoundParameters()
return nil, ociGetError(s.c.err)
}
case time.Time:
dty = C.SQLT_DAT
now := v.(time.Time).In(s.c.location)
//TODO Handle BCE dates (http://docs.oracle.com/cd/B12037_01/appdev.101/b10779/oci03typ.htm#438305)
//TODO Handle timezones (http://docs.oracle.com/cd/B12037_01/appdev.101/b10779/oci03typ.htm#443601)
data = []byte{
byte(now.Year()/100 + 100),
byte(now.Year()%100 + 100),
byte(now.Month()),
byte(now.Day()),
byte(now.Hour() + 1),
byte(now.Minute() + 1),
byte(now.Second() + 1),
}
cdata = C.CString(string(data))
boundParameters = append(boundParameters, oci8bind{dty, unsafe.Pointer(cdata)})
rv := C.OCIBindByPos(
(*C.OCIStmt)(s.s),
&bp,
(*C.OCIError)(s.c.err),
C.ub4(i+1),
unsafe.Pointer(cdata),
C.sb4(len(data)),
dty,
nil,
nil,
nil,
0,
nil,
C.OCI_DEFAULT)
if rv == C.OCI_ERROR {
defer freeBoundParameters()
return nil, ociGetError(s.c.err)
}
default:
dty = C.SQLT_STR
data = []byte(fmt.Sprintf("%v", v))
data = append(data, 0)
cdata = C.CString(string(data))
boundParameters = append(boundParameters, oci8bind{dty, unsafe.Pointer(cdata)})
rv := C.OCIBindByPos(
(*C.OCIStmt)(s.s),
&bp,
(*C.OCIError)(s.c.err),
C.ub4(i+1),
unsafe.Pointer(cdata),
C.sb4(len(data)),
dty,
nil,
nil,
nil,
0,
nil,
C.OCI_DEFAULT)
if rv == C.OCI_ERROR {
defer freeBoundParameters()
return nil, ociGetError(s.c.err)
}
}
}
return freeBoundParameters, nil
}
