Beispiel #1
0
func (def *defFloat32) value() (value interface{}, err error) {
	if def.isNullable {
		oraFloat32Value := Float32{IsNull: def.null < C.sb2(0)}
		if !oraFloat32Value.IsNull {
			var float32Value float32
			r := C.OCINumberToReal(
				def.rset.stmt.ses.srv.env.ocierr,       //OCIError              *err,
				&def.ociNumber,                         //const OCINumber     *number,
				C.uword(4),                             //uword               rsl_length,
				unsafe.Pointer(&oraFloat32Value.Value)) //void                *rsl );
			if r == C.OCI_ERROR {
				err = def.rset.stmt.ses.srv.env.ociError()
			}
			value = float32Value
		}
		value = oraFloat32Value
	} else {
		if def.null > C.sb2(-1) {
			var float32Value float32
			r := C.OCINumberToReal(
				def.rset.stmt.ses.srv.env.ocierr, //OCIError              *err,
				&def.ociNumber,                   //const OCINumber     *number,
				C.uword(4),                       //uword               rsl_length,
				unsafe.Pointer(&float32Value))    //void                *rsl );
			if r == C.OCI_ERROR {
				err = def.rset.stmt.ses.srv.env.ociError()
			}
			value = float32Value
		}
	}
	return value, err
}
Beispiel #2
0
func (def *defUint64) value() (value interface{}, err error) {
	if def.isNullable {
		oraUint64Value := Uint64{IsNull: def.null < C.sb2(0)}
		if !oraUint64Value.IsNull {
			r := C.OCINumberToInt(
				def.rset.stmt.ses.srv.env.ocierr,      //OCIError              *err,
				&def.ociNumber,                        //const OCINumber       *number,
				C.uword(8),                            //uword                 rsl_length,
				C.OCI_NUMBER_UNSIGNED,                 //uword                 rsl_flag,
				unsafe.Pointer(&oraUint64Value.Value)) //void                  *rsl );
			if r == C.OCI_ERROR {
				err = def.rset.stmt.ses.srv.env.ociError()
			}
		}
		value = oraUint64Value
	} else {
		if def.null > C.sb2(-1) {
			var uint64Value uint64
			r := C.OCINumberToInt(
				def.rset.stmt.ses.srv.env.ocierr, //OCIError              *err,
				&def.ociNumber,                   //const OCINumber       *number,
				C.uword(8),                       //uword                 rsl_length,
				C.OCI_NUMBER_UNSIGNED,            //uword                 rsl_flag,
				unsafe.Pointer(&uint64Value))     //void                  *rsl );
			if r == C.OCI_ERROR {
				err = def.rset.stmt.ses.srv.env.ociError()
			}
			value = uint64Value
		}
	}
	return value, err
}
Beispiel #3
0
func (bnd *bndTimePtr) bind(value *time.Time, position int, stmt *Stmt) error {
	bnd.stmt = stmt
	bnd.value = value
	r := C.OCIDescriptorAlloc(
		unsafe.Pointer(bnd.stmt.ses.srv.env.ocienv),         //CONST dvoid   *parenth,
		(*unsafe.Pointer)(unsafe.Pointer(&bnd.ociDateTime)), //dvoid         **descpp,
		C.OCI_DTYPE_TIMESTAMP_TZ,                            //ub4           type,
		0,   //size_t        xtramem_sz,
		nil) //dvoid         **usrmempp);
	if r == C.OCI_ERROR {
		return bnd.stmt.ses.srv.env.ociError()
	} else if r == C.OCI_INVALID_HANDLE {
		return errNew("unable to allocate oci timestamp handle during bind")
	}
	if value == nil {
		bnd.isNull = C.sb2(-1)
	} else {
		zone := zoneOffset(*value, &bnd.zoneBuf)
		bnd.cZone = C.CString(zone)
		r = C.OCIDateTimeConstruct(
			unsafe.Pointer(bnd.stmt.ses.srv.env.ocienv), //dvoid         *hndl,
			bnd.stmt.ses.srv.env.ocierr,                 //OCIError      *err,
			bnd.ociDateTime,                             //OCIDateTime   *datetime,
			C.sb2(value.Year()),                         //sb2           year,
			C.ub1(int32(value.Month())),                 //ub1           month,
			C.ub1(value.Day()),                          //ub1           day,
			C.ub1(value.Hour()),                         //ub1           hour,
			C.ub1(value.Minute()),                       //ub1           min,
			C.ub1(value.Second()),                       //ub1           sec,
			C.ub4(value.Nanosecond()),                   //ub4           fsec,
			(*C.OraText)(unsafe.Pointer(bnd.cZone)),     //OraText       *timezone,
			C.size_t(len(zone)))                         //size_t        timezone_length );
		if r == C.OCI_ERROR {
			return bnd.stmt.ses.srv.env.ociError()
		}
	}
	r = C.OCIBINDBYPOS(
		bnd.stmt.ocistmt,                              //OCIStmt      *stmtp,
		(**C.OCIBind)(&bnd.ocibnd),                    //OCIBind      **bindpp,
		bnd.stmt.ses.srv.env.ocierr,                   //OCIError     *errhp,
		C.ub4(position),                               //ub4          position,
		unsafe.Pointer(&bnd.ociDateTime),              //void         *valuep,
		C.LENGTH_TYPE(unsafe.Sizeof(bnd.ociDateTime)), //sb8          value_sz,
		C.SQLT_TIMESTAMP_TZ,                           //ub2          dty,
		unsafe.Pointer(&bnd.isNull),                   //void         *indp,
		nil,           //ub2          *alenp,
		nil,           //ub2          *rcodep,
		0,             //ub4          maxarr_len,
		nil,           //ub4          *curelep,
		C.OCI_DEFAULT) //ub4          mode );
	if r == C.OCI_ERROR {
		return bnd.stmt.ses.srv.env.ociError()
	}
	return nil
}
Beispiel #4
0
func (def *defString) value() (value interface{}, err error) {
	if def.isNullable {
		oraStringValue := String{IsNull: def.null < C.sb2(0)}
		if !oraStringValue.IsNull {
			oraStringValue.Value = string(def.buf[:int(def.rlen)])
		}
		return oraStringValue, nil
	}
	if def.null < C.sb2(0) {
		return "", nil
	}
	return string(def.buf[:int(def.rlen)]), nil
}
Beispiel #5
0
func dateTimeVarSetValue(v *Variable, pos uint, value interface{}) error {
	x, ok := value.(time.Time)
	if !ok {
		a, ok := value.([]time.Time)
		if !ok {
			return fmt.Errorf("awaited time.Time or []time.Time, got %T", value)
		}
		var err error
		for i, x := range a {
			if err = dateTimeVarSetValue(v, pos+uint(i), x); err != nil {
				return err
			}
		}
		return nil
	}
	/*
		if err := v.environment.CheckStatus(
			C.OCIDateSetDate(unsafe.Pointer(&v.dataBytes[pos*sizeof_OCIDate]),
				x.Year(), x.Month(), x.Date()),
			"OCIDateSetDate"); err != nil {
			return err
		}
		return v.environment.CheckStatus(
			C.OCIDateSetTime(unsafe.Pointer(&v.dataBytes[pos*sizeof_OCIDate]),
				x.Hour(), x.Minute(), x.Second()),
			"OCIDateSetTime")
	*/
	C.setDateTime((*C.OCIDate)(v.getHandle(pos)),
		C.sb2(x.Year()), C.ub1(x.Month()), C.ub1(x.Day()),
		C.ub1(x.Hour()), C.ub1(x.Minute()), C.ub1(x.Second()))
	return nil
}
Beispiel #6
0
func (bnd *bndStringPtr) setPtr() error {
	if bnd.isNull > C.sb2(-1) {
		// Buffer is padded with Space char (32)
		*bnd.value = stringTrimmed(bnd.buf, 32)
	}
	return nil
}
Beispiel #7
0
func (def *defIntervalDS) value() (value interface{}, err error) {
	intervalDS := IntervalDS{IsNull: def.null < C.sb2(0)}
	if !intervalDS.IsNull {
		var day C.sb4
		var hour C.sb4
		var minute C.sb4
		var second C.sb4
		var nanosecond C.sb4
		r := C.OCIIntervalGetDaySecond(
			unsafe.Pointer(def.rset.stmt.ses.srv.env.ocienv), //void               *hndl,
			def.rset.stmt.ses.srv.env.ocierr,                 //OCIError           *err,
			&day,            //sb4                *dy,
			&hour,           //sb4                *hr,
			&minute,         //sb4                *mm,
			&second,         //sb4                *ss,
			&nanosecond,     //sb4                *fsec,
			def.ociInterval) //const OCIInterval  *interval );
		if r == C.OCI_ERROR {
			err = def.rset.stmt.ses.srv.env.ociError()
		}
		intervalDS.Day = int32(day)
		intervalDS.Hour = int32(hour)
		intervalDS.Minute = int32(minute)
		intervalDS.Second = int32(second)
		intervalDS.Nanosecond = int32(nanosecond)
	}
	return intervalDS, err
}
Beispiel #8
0
func (def *defLongRaw) value() (value interface{}, err error) {
	if def.isNullable {
		bytesValue := Raw{IsNull: def.null < C.sb2(0)}
		if !bytesValue.IsNull {
			// Make a slice of length equal to the return length
			bytesValue.Value = make([]byte, def.returnLength)
			// Copy returned data
			copyLength := copy(bytesValue.Value, def.buf)
			if C.ACTUAL_LENGTH_TYPE(copyLength) != def.returnLength {
				return nil, errNew("unable to copy LONG RAW result data from buffer")
			}
		}
		value = bytesValue
	} else {
		// Make a slice of length equal to the return length
		result := make([]byte, def.returnLength)
		// Copy returned data
		copyLength := copy(result, def.buf)
		if C.ACTUAL_LENGTH_TYPE(copyLength) != def.returnLength {
			return nil, errNew("unable to copy LONG RAW result data from buffer")
		}
		value = result
	}
	return value, err
}
Beispiel #9
0
func (bnd *bndUint16Ptr) bind(value *uint16, position int, stmt *Stmt) error {
	bnd.stmt = stmt
	bnd.value = value
	if value == nil {
		bnd.isNull = C.sb2(-1)
	} else {
		r := C.OCINumberFromInt(
			bnd.stmt.ses.srv.env.ocierr, //OCIError            *err,
			unsafe.Pointer(value),       //const void          *inum,
			2, //uword               inum_length,
			C.OCI_NUMBER_UNSIGNED, //uword               inum_s_flag,
			&bnd.ociNumber)        //OCINumber           *number );
		if r == C.OCI_ERROR {
			return bnd.stmt.ses.srv.env.ociError()
		}
	}
	r := C.OCIBINDBYPOS(
		bnd.stmt.ocistmt,                  //OCIStmt      *stmtp,
		(**C.OCIBind)(&bnd.ocibnd),        //OCIBind      **bindpp,
		bnd.stmt.ses.srv.env.ocierr,       //OCIError     *errhp,
		C.ub4(position),                   //ub4          position,
		unsafe.Pointer(&bnd.ociNumber),    //void         *valuep,
		C.LENGTH_TYPE(C.sizeof_OCINumber), //sb8          value_sz,
		C.SQLT_VNU,                        //ub2          dty,
		unsafe.Pointer(&bnd.isNull),       //void         *indp,
		nil,           //ub2          *alenp,
		nil,           //ub2          *rcodep,
		0,             //ub4          maxarr_len,
		nil,           //ub4          *curelep,
		C.OCI_DEFAULT) //ub4          mode );
	if r == C.OCI_ERROR {
		return bnd.stmt.ses.srv.env.ociError()
	}
	return nil
}
Beispiel #10
0
func (def *defString) value() (value interface{}, err error) {
	// Buffer is padded with Space char (32)
	if def.isNullable {
		oraStringValue := String{IsNull: def.null < C.sb2(0)}
		if !oraStringValue.IsNull {
			oraStringValue.Value = stringTrimmed(def.buf, 32)
		}
		value = oraStringValue
	} else {
		if def.null < C.sb2(0) {
			value = ""
		} else {
			value = stringTrimmed(def.buf, 32)
		}
	}
	return value, err
}
Beispiel #11
0
func (bnd *bndStringPtr) setPtr() error {
	bnd.stmt.logF(_drv.cfg.Log.Stmt.Bind,
		"StringPtr.setPtr isNull=%d alen=%d", bnd.isNull, bnd.alen[0])
	if bnd.isNull > C.sb2(-1) {
		*bnd.value = string(bnd.buf[:bnd.alen[0]])
	}
	return nil
}
Beispiel #12
0
func (def *defBool) value() (value interface{}, err error) {
	//Log.Infof("%v.value", def)
	if def.isNullable {
		oraBoolValue := Bool{IsNull: def.null < C.sb2(0)}
		if !oraBoolValue.IsNull {
			r, _ := utf8.DecodeRune(def.buf)
			oraBoolValue.Value = r == def.rset.stmt.cfg.Rset.TrueRune
		}
		return oraBoolValue, nil
	}
	if def.null > C.sb2(-1) {
		r, _ := utf8.DecodeRune(def.buf)
		return r == def.rset.stmt.cfg.Rset.TrueRune, nil
	}
	// NULL is false, too
	return false, nil
}
Beispiel #13
0
func (def *defLob) value() (value interface{}, err error) {
	//lob := def.ociLobLocator
	//Log.Infof("value %p null=%d", lob, def.null)
	if def.gct == Bin {
		if def.null > C.sb2(-1) {
			return def.Reader()
		}
		return value, err
	}
	if def.null < C.sb2(0) {
		return Lob{}, nil
	}
	var r io.Reader
	r, err = def.Reader()
	binValue := Lob{Reader: r}
	//Log.Infof("value %p returns %#v (%v)", lob, binValue, err)
	return binValue, err
}
Beispiel #14
0
func (bnd *bndBoolPtr) setPtr() error {
	//Log.Infof("%s.setPtr()", bnd)
	if bnd.isNull > C.sb2(-1) {
		r, _ := utf8.DecodeRune(bnd.buf)
		*bnd.value = r == bnd.trueRune
	} else {
		bnd.value = nil
	}
	return nil
}
Beispiel #15
0
func (bnd *bndUint64Slice) bindOra(values []Uint64, position int, stmt *Stmt) error {
	uint64Values := make([]uint64, len(values))
	nullInds := make([]C.sb2, len(values))
	for n := range values {
		if values[n].IsNull {
			nullInds[n] = C.sb2(-1)
		} else {
			uint64Values[n] = values[n].Value
		}
	}
	return bnd.bind(uint64Values, nullInds, position, stmt)
}
Beispiel #16
0
func (def *defTime) value() (value interface{}, err error) {
	if def.isNullable {
		oraTimeValue := Time{IsNull: def.null < C.sb2(0)}
		if !oraTimeValue.IsNull {
			oraTimeValue.Value, err = getTime(def.rset.stmt.ses.srv.env, def.ociDateTime)
		}
		value = oraTimeValue
	} else {
		value, err = getTime(def.rset.stmt.ses.srv.env, def.ociDateTime)
	}
	return value, err
}
Beispiel #17
0
func (bnd *bndStringSlice) bindOra(values []String, position int, stmt *Stmt) error {
	stringValues := make([]string, len(values))
	nullInds := make([]C.sb2, len(values))
	for n, _ := range values {
		if values[n].IsNull {
			nullInds[n] = C.sb2(-1)
		} else {
			stringValues[n] = values[n].Value
		}
	}
	return bnd.bind(stringValues, nullInds, position, stmt)
}
Beispiel #18
0
func (bnd *bndTimeSlice) bindOra(values []Time, position int, stmt *Stmt) error {
	timeValues := make([]time.Time, len(values))
	nullInds := make([]C.sb2, len(values))
	for n, _ := range values {
		if values[n].IsNull {
			nullInds[n] = C.sb2(-1)
		} else {
			timeValues[n] = values[n].Value
		}
	}
	return bnd.bind(timeValues, nullInds, position, stmt)
}
Beispiel #19
0
func (bnd *bndBinSlice) bindOra(values []Raw, position int, lobBufferSize int, stmt *Stmt) error {
	binValues := make([][]byte, len(values))
	nullInds := make([]C.sb2, len(values))
	for i := range values {
		if values[i].IsNull {
			nullInds[i] = C.sb2(-1)
		} else {
			binValues[i] = values[i].Value
		}
	}
	return bnd.bind(binValues, nullInds, position, lobBufferSize, stmt)
}
Beispiel #20
0
func (bnd *bndBoolSlice) bindOra(values []Bool, position int, falseRune rune, trueRune rune, stmt *Stmt) error {
	boolValues := make([]bool, len(values))
	nullInds := make([]C.sb2, len(values))
	for n, _ := range values {
		if values[n].IsNull {
			nullInds[n] = C.sb2(-1)
		} else {
			boolValues[n] = values[n].Value
		}
	}
	return bnd.bind(boolValues, nullInds, position, falseRune, trueRune, stmt)
}
Beispiel #21
0
func (bnd *bndLobSlice) bindOra(values []Lob, position int, lobBufferSize int, stmt *Stmt) error {
	binValues := make([]io.Reader, len(values))
	nullInds := make([]C.sb2, len(values))
	for n, _ := range values {
		if values[n].Reader == nil {
			nullInds[n] = C.sb2(-1)
		} else {
			binValues[n] = values[n].Reader
		}
	}
	return bnd.bindReaders(binValues, nullInds, position, lobBufferSize, stmt)
}
Beispiel #22
0
func (bnd *bndFloat32Slice) bindOra(values []Float32, position int, stmt *Stmt) error {
	float32Values := make([]float32, len(values))
	nullInds := make([]C.sb2, len(values))
	for n := range values {
		if values[n].IsNull {
			nullInds[n] = C.sb2(-1)
		} else {
			float32Values[n] = values[n].Value
		}
	}
	return bnd.bind(float32Values, nullInds, position, stmt)
}
Beispiel #23
0
func (bnd *bndInt16Slice) bindOra(values []Int16, position int, stmt *Stmt) error {
	int16Values := make([]int16, len(values))
	nullInds := make([]C.sb2, len(values))
	for n := range values {
		if values[n].IsNull {
			nullInds[n] = C.sb2(-1)
		} else {
			int16Values[n] = values[n].Value
		}
	}
	return bnd.bind(int16Values, nullInds, position, stmt)
}
Beispiel #24
0
func (bnd *bndFloat64Ptr) setPtr() error {
	if bnd.isNull > C.sb2(-1) {
		r := C.OCINumberToReal(
			bnd.stmt.ses.srv.env.ocierr, //OCIError              *err,
			&bnd.ociNumber,              //const OCINumber     *number,
			C.uword(8),                  //uword               rsl_length,
			unsafe.Pointer(bnd.value))   //void                *rsl );
		if r == C.OCI_ERROR {
			return bnd.stmt.ses.srv.env.ociError()
		}
	}
	return nil
}
Beispiel #25
0
func (bnd *bndUint16Ptr) setPtr() error {
	if bnd.isNull > C.sb2(-1) {
		r := C.OCINumberToInt(
			bnd.stmt.ses.srv.env.ocierr, //OCIError              *err,
			&bnd.ociNumber,              //const OCINumber       *number,
			C.uword(2),                  //uword                 rsl_length,
			C.OCI_NUMBER_UNSIGNED,       //uword                 rsl_flag,
			unsafe.Pointer(bnd.value))   //void                  *rsl );
		if r == C.OCI_ERROR {
			return bnd.stmt.ses.srv.env.ociError()
		}
	}
	return nil
}
Beispiel #26
0
func (bnd *bndInt32Ptr) setPtr() error {
	if bnd.isNull > C.sb2(-1) {
		r := C.OCINumberToInt(
			bnd.stmt.ses.srv.env.ocierr, //OCIError              *err,
			&bnd.ociNumber,              //const OCINumber       *number,
			C.uword(4),                  //uword                 rsl_length,
			C.OCI_NUMBER_SIGNED,         //uword                 rsl_flag,
			unsafe.Pointer(bnd.value))   //void                  *rsl );
		if r == C.OCI_ERROR {
			return bnd.stmt.ses.srv.env.ociError()
		}
		bnd.stmt.logF(_drv.cfg.Log.Stmt.Bind,
			"Int32Ptr.setPtr number=%#v => value=%d", bnd.ociNumber, *bnd.value)
	}
	return nil
}
Beispiel #27
0
func (bnd *bndStringPtr) bind(value *string, position int, stringPtrBufferSize int, stmt *Stmt) error {
	bnd.stmt = stmt
	bnd.value = value
	var length int
	if cap(bnd.buf) < stringPtrBufferSize {
		bnd.buf = make([]byte, 1, stringPtrBufferSize)
	}
	if value == nil {
		bnd.isNull = C.sb2(-1)
	} else {
		length = len(*value)
	}
	if length == 0 {
		bnd.buf = bnd.buf[:1] // to be able to address bnd.buf[0]
		bnd.buf[0] = 0
	} else {
		bnd.buf = bnd.buf[:length]
		copy(bnd.buf, []byte(*value))
	}
	if cap(bnd.alen) < 1 {
		bnd.alen = []C.ACTUAL_LENGTH_TYPE{C.ACTUAL_LENGTH_TYPE(length)}
	} else {
		bnd.alen = bnd.alen[:1]
		bnd.alen[0] = C.ACTUAL_LENGTH_TYPE(length)
	}
	bnd.stmt.logF(_drv.cfg.Log.Stmt.Bind,
		"StringPtr.bind(%d) cap=%d len=%d alen=%d", position, cap(bnd.buf), len(bnd.buf), bnd.alen[0])
	r := C.OCIBINDBYPOS(
		bnd.stmt.ocistmt,            //OCIStmt      *stmtp,
		(**C.OCIBind)(&bnd.ocibnd),  //OCIBind      **bindpp,
		bnd.stmt.ses.srv.env.ocierr, //OCIError     *errhp,
		C.ub4(position),             //ub4          position,
		unsafe.Pointer(&bnd.buf[0]), //void         *valuep,
		C.LENGTH_TYPE(cap(bnd.buf)), //sb8          value_sz,
		C.SQLT_CHR,                  //ub2          dty,
		unsafe.Pointer(&bnd.isNull), //void         *indp,
		&bnd.alen[0],                //ub2          *alenp,
		nil,                         //ub2          *rcodep,
		0,                           //ub4          maxarr_len,
		nil,                         //ub4          *curelep,
		C.OCI_DEFAULT)               //ub4          mode );
	if r == C.OCI_ERROR {
		return bnd.stmt.ses.srv.env.ociError()
	}
	return nil
}
Beispiel #28
0
func (def *defIntervalYM) value() (value interface{}, err error) {
	intervalYM := IntervalYM{IsNull: def.null < C.sb2(0)}
	if !intervalYM.IsNull {
		var year C.sb4
		var month C.sb4
		r := C.OCIIntervalGetYearMonth(
			unsafe.Pointer(def.rset.stmt.ses.srv.env.ocienv), //void               *hndl,
			def.rset.stmt.ses.srv.env.ocierr,                 //OCIError           *err,
			&year,           //sb4                *yr,
			&month,          //sb4                *mnth,
			def.ociInterval) //const OCIInterval  *interval );
		if r == C.OCI_ERROR {
			err = def.rset.stmt.ses.srv.env.ociError()
		}
		intervalYM.Year = int32(year)
		intervalYM.Month = int32(month)
	}
	return intervalYM, err
}
Beispiel #29
0
func (bnd *bndNil) bind(position int, sqlt C.ub2, stmt *Stmt) error {
	bnd.stmt = stmt
	indp := C.sb2(-1)
	r := C.OCIBINDBYPOS(
		bnd.stmt.ocistmt,            //OCIStmt      *stmtp,
		(**C.OCIBind)(&bnd.ocibnd),  //OCIBind      **bindpp,
		bnd.stmt.ses.srv.env.ocierr, //OCIError     *errhp,
		C.ub4(position),             //ub4          position,
		nil,                         //void         *valuep,
		0,                           //sb8          value_sz,
		sqlt,                        //C.SQLT_CHR,                                          //ub2          dty,
		unsafe.Pointer(&indp), //void         *indp,
		nil,           //ub2          *alenp,
		nil,           //ub2          *rcodep,
		0,             //ub4          maxarr_len,
		nil,           //ub4          *curelep,
		C.OCI_DEFAULT) //ub4          mode );
	if r == C.OCI_ERROR {
		return bnd.stmt.ses.srv.env.ociError()
	}

	return nil
}
Beispiel #30
0
func (def *defBfile) value() (value interface{}, err error) {
	var bfileValue Bfile
	bfileValue.IsNull = def.null < C.sb2(0)
	if !bfileValue.IsNull {
		// Get directory alias and filename
		dLength := C.ub2(len(def.directoryAlias))
		fLength := C.ub2(len(def.filename))
		r := C.OCILobFileGetName(
			def.rset.stmt.ses.srv.env.ocienv,                     //OCIEnv                   *envhp,
			def.rset.stmt.ses.srv.env.ocierr,                     //OCIError                 *errhp,
			def.ociLobLocator,                                    //const OCILobLocator      *filep,
			(*C.OraText)(unsafe.Pointer(&def.directoryAlias[0])), //OraText                  *dir_alias,
			&dLength, //ub2                      *d_length,
			(*C.OraText)(unsafe.Pointer(&def.filename[0])), //OraText                  *filename,
			&fLength) //ub2                      *f_length );
		if r == C.OCI_ERROR {
			return value, def.rset.stmt.ses.srv.env.ociError()
		}
		bfileValue.DirectoryAlias = string(def.directoryAlias[:int(dLength)])
		bfileValue.Filename = string(def.filename[:int(fLength)])
	}
	value = bfileValue
	return value, err
}