/*
* I am not sure here, OCILobAssign or just simple pointer assign?
*/
void ConvertorForRead::Fire(const BindParClob &BP, SqlClob &CL)
{
CL._ind = BP.indp[_row];
if(CL.is_not_null())
{
if(BP.isTemporary(_row))
{
sword res = OCICALL(OCILobLocatorAssign(BP._stmt._conn._svc_ctx, BP._env._errh, ((OCILobLocator**)BP.valuep)[_row], &CL._loc));
oci_check_error(__TROTL_HERE__, BP._env._errh, res);
}
else
{
sword res = OCICALL(OCILobAssign(BP._env, BP._env._errh, ((OCILobLocator**)BP.valuep)[_row], &CL._loc));
oci_check_error(__TROTL_HERE__, BP._env._errh, res);
}
//CL._loc = ((OCILobLocator**)BP.valuep)[_row];
//((OCILobLocator**)BP.valuep)[_row] = NULL;
//CL._ind = BP.indp[_row];
//#if ORACLE_MAJOR_VERSION>=8 && ORACLE_MINOR_VERSION>=1
// res = OCICALL(OCILobLocatorAssign(_conn._svc_ctx, _conn._env._errh, other._loc, &_loc));
//#else
// res = OCICALL(OCILobAssign(_conn._env, _conn._env._errh, other._loc, &_loc)); // no support for temporary LOBs
//#endif
}
};
static VALUE oci8_make_lob(VALUE klass, oci8_svcctx_t *svcctx, OCILobLocator *s)
{
oci8_lob_t *lob;
VALUE lob_obj;
lob_obj = rb_funcall(klass, oci8_id_new, 1, svcctx->base.self);
lob = DATA_PTR(lob_obj);
/* If 's' is a temporary lob, use OCILobLocatorAssign instead. */
oci_lc(OCILobAssign(oci8_envhp, oci8_errhp, s, &lob->base.hp.lob));
return lob_obj;
}
static VALUE oci8_make_lob(VALUE klass, oci8_svcctx_t *svcctx, OCILobLocator *s)
{
oci8_lob_t *lob;
boolean is_temp;
VALUE lob_obj;
lob_obj = rb_class_new_instance(1, &svcctx->base.self, klass);
lob = TO_LOB(lob_obj);
/* If 's' is a temporary lob, use OCILobLocatorAssign instead. */
chker2(OCILobIsTemporary(oci8_envhp, oci8_errhp, s, &is_temp), &svcctx->base);
if (is_temp)
chker2(OCILobLocatorAssign_nb(svcctx, svcctx->base.hp.svc, oci8_errhp, s, &lob->base.hp.lob),
&svcctx->base);
else
chker2(OCILobAssign(oci8_envhp, oci8_errhp, s, &lob->base.hp.lob),
&svcctx->base);
return lob_obj;
}
static VALUE oci8_lob_clone(VALUE self)
{
oci8_lob_t *lob = TO_LOB(self);
oci8_lob_t *newlob;
VALUE newobj = lob->svcctx ? lob->svcctx->base.self : Qnil;
boolean is_temporary;
newobj = rb_class_new_instance(1, &newobj, CLASS_OF(self));
newlob = DATA_PTR(newobj);
if (OCILobIsTemporary(oci8_envhp, oci8_errhp, lob->base.hp.lob, &is_temporary) == OCI_SUCCESS
&& is_temporary) {
oci8_svcctx_t *svcctx = check_svcctx(lob);
chker2(OCILobLocatorAssign_nb(svcctx, svcctx->base.hp.svc, oci8_errhp, lob->base.hp.lob, &newlob->base.hp.lob),
&svcctx->base);
} else {
chker2(OCILobAssign(oci8_envhp, oci8_errhp, lob->base.hp.lob, &newlob->base.hp.lob), &lob->base);
}
return newobj;
}
void ConvertorForRead::Fire(const BindParCFile &BP, SqlClob &CL)
{
CL._ind = BP.indp[_row];
if(CL.is_not_null())
{
sword res = OCICALL(OCILobAssign(BP._env, BP._env._errh, ((OCILobLocator**)BP.valuep)[_row], &CL._loc));
oci_check_error(__TROTL_HERE__, BP._env._errh, res);
char dirname[33], filename[256];
ub2 dirnamelen = sizeof(dirname);
ub2 filenamelen = sizeof(filename);
res = OCICALL(OCILobFileGetName(BP._env, BP._env._errh, ((OCILobLocator**)BP.valuep)[_row],
(OraText*)dirname, &dirnamelen,
(OraText*)filename, &filenamelen
));
oci_check_error(__TROTL_HERE__, BP._env._errh, res);
CL._dirname = tstring(dirname, dirnamelen);
CL._filename = tstring(filename, filenamelen);
}
};
void ConvertorForWrite::Fire(const SqlClob &CL, BindParClob &BP)
{
std::cerr << "void ConvertorForWrite::Fire(const SqlClob &CL, BindParClob &BP), row: " << _row << std::endl;
/* TODO:
* - whose errh should I use? BP's or SqlValue's (race)
* - no support for temporary lobs here
* - should I call OCILobLocatorIsInit here ??
*/
sword res = OCICALL(OCILobAssign(BP._env, BP._env._errh, CL._loc, &((OCILobLocator**)BP.valuep)[_row]));
oci_check_error(__TROTL_HERE__, BP._env._errh, res);
// ((OCILobLocator**)BP.valuep)[_row] = CL._loc;
// CL._loc = NULL;
//#if ORACLE_MAJOR_VERSION>=8 && ORACLE_MINOR_VERSION>=1
// res = OCICALL(OCILobLocatorAssign(_conn._svc_ctx, _conn._env._errh, other._loc, &_loc));
//#else
// res = OCICALL(OCILobAssign(_conn._env, _conn._env._errh, other._loc, &_loc)); // no support for temporary LOBs
//#endif
BP.indp[_row] = CL._ind;
};
static VALUE oci8_lob_clone(VALUE self)
{
oci8_lob_t *lob = DATA_PTR(self);
oci8_lob_t *newlob;
VALUE newobj;
sword rv;
boolean is_temporary;
newobj = rb_funcall(CLASS_OF(self), oci8_id_new, 1, lob->svc);
newlob = DATA_PTR(newobj);
if (have_OCILobLocatorAssign_nb && have_OCILobIsTemporary
&& OCILobIsTemporary(oci8_envhp, oci8_errhp, lob->base.hp.lob, &is_temporary) == OCI_SUCCESS
&& is_temporary) {
oci8_svcctx_t *svcctx = oci8_get_svcctx(lob->svc);
rv = OCILobLocatorAssign_nb(svcctx, svcctx->base.hp.svc, oci8_errhp, lob->base.hp.lob, &newlob->base.hp.lob);
} else {
rv = OCILobAssign(oci8_envhp, oci8_errhp, lob->base.hp.lob, &newlob->base.hp.lob);
}
if (rv != OCI_SUCCESS) {
oci8_raise(oci8_errhp, rv, NULL);
}
return newobj;
}
void
_gda_oracle_set_value (GValue *value,
GdaOracleValue *ora_value,
GdaConnection *cnc)
{
GdaTime gtime;
GdaTimestamp timestamp;
sb2 year;
ub1 month;
ub1 day;
ub1 hour;
ub1 min;
ub1 sec;
if (ora_value->indicator == -1) {
gda_value_set_null (value);
return;
}
gda_value_reset_with_type (value, ora_value->g_type);
switch (ora_value->s_type) {
case GDA_STYPE_INT:
g_value_set_int (value, *((gint *) ora_value->value));
break;
case GDA_STYPE_STRING: {
gchar *string_buffer, *tmp;
string_buffer = (gchar *) ora_value->value;
string_buffer [ora_value->rlen] = '\0';
g_strchomp (string_buffer);
//tmp = g_locale_to_utf8 (string_buffer, -1, NULL, NULL, NULL);
//g_value_take_string (value, tmp);
g_value_set_string (value, string_buffer);
if (ora_value->use_callback) {
g_free (string_buffer);
ora_value->value = NULL;
}
break;
}
case GDA_STYPE_BOOLEAN:
g_value_set_boolean (value, (*((gint *) ora_value->value)) ? TRUE: FALSE);
break;
case GDA_STYPE_DATE: {
GDate *date;
OCIDateGetDate ((CONST OCIDate *) ora_value->value,
(sb2 *) &year,
(ub1 *) &month,
(ub1 *) &day);
date = g_date_new_dmy (day, month, year);
g_value_take_boxed (value, date);
break;
}
case GDA_STYPE_TIME: {
OCIDateGetTime ((CONST OCIDate *) ora_value->value,
(ub1 *) &hour,
(ub1 *) &min,
(ub1 *) &sec);
gtime.hour = hour;
gtime.minute = min;
gtime.second = sec;
gda_value_set_time (value, >ime);
break;
}
case GDA_STYPE_TIMESTAMP: {
OCIDateGetDate ((CONST OCIDate *) ora_value->value,
(sb2 *) &year,
(ub1 *) &month,
(ub1 *) &day);
OCIDateGetTime ((CONST OCIDate *) ora_value->value,
(ub1 *) &hour,
(ub1 *) &min,
(ub1 *) &sec);
timestamp.year = year;
timestamp.month = month;
timestamp.day = day;
timestamp.hour = hour;
timestamp.minute = min;
timestamp.second = sec;
timestamp.fraction = 0;
timestamp.timezone = 0;
gda_value_set_timestamp(value, ×tamp);
break;
}
case GDA_STYPE_INT64:
TO_IMPLEMENT; /* test that value fits in */
g_value_set_int64 (value, atoll (ora_value->value));
break;
case GDA_STYPE_UINT64:
TO_IMPLEMENT; /* test that value fits in */
g_value_set_uint64 (value, atoll (ora_value->value));
break;
case GDA_STYPE_UINT:
TO_IMPLEMENT; /* test that value fits in */
g_value_set_uint (value, *((guint*) ora_value->value));
break;
case GDA_STYPE_FLOAT:
g_value_set_float (value, *((gfloat*) ora_value->value));
break;
case GDA_STYPE_DOUBLE:
g_value_set_double (value, *((gdouble*) ora_value->value));
break;
case GDA_STYPE_LONG:
TO_IMPLEMENT;
break;
case GDA_STYPE_ULONG:
TO_IMPLEMENT;
break;
case GDA_STYPE_NUMERIC: {
GdaNumeric *numeric;
gchar *tmp;
g_assert (!ora_value->use_callback);
tmp = g_malloc0 (ora_value->defined_size);
memcpy (tmp, ora_value->value, ora_value->defined_size);
tmp [ora_value->rlen] = '\0';
g_strchomp (tmp);
numeric = gda_numeric_new ();
gda_numeric_set_from_string (numeric, tmp);
g_free (tmp);
gda_numeric_set_precision (numeric, ora_value->precision);
gda_numeric_set_width (numeric, ora_value->scale);
g_value_take_boxed (value, numeric);
break;
}
case GDA_STYPE_BINARY: {
GdaBinary *bin;
bin = g_new0 (GdaBinary, 1);
if (ora_value->use_callback) {
bin->data = ora_value->value;
ora_value->value = NULL;
}
else {
bin->data = g_new (guchar, ora_value->rlen);
memcpy (bin->data, ora_value->value, ora_value->rlen);
}
bin->binary_length = ora_value->rlen;
gda_value_take_binary (value, bin);
break;
}
case GDA_STYPE_BLOB: {
GdaBlob *blob;
GdaBlobOp *op;
OCILobLocator *lobloc;
OracleConnectionData *cdata;
gint result;
/* REM: we need to make a "copy" of the lob locator to give to the GdaOracleblobOp object */
cdata = (OracleConnectionData*) gda_connection_internal_get_provider_data_error (cnc, NULL);
if (!cdata) {
gda_connection_add_event_string (cnc, _("Invalid Oracle handle"));
gda_value_set_null (value);
return;
}
result = OCIDescriptorAlloc ((dvoid *) cdata->henv, (dvoid **) &lobloc,
(ub4) gda_oracle_blob_type (ora_value->sql_type), (size_t) 0, (dvoid **) 0);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not allocate Lob locator"))) {
gda_value_set_null (value);
return;
}
result = OCILobAssign ((dvoid *) cdata->henv, (dvoid *) cdata->herr, ora_value->value, &lobloc);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not copy Lob locator"))) {
gda_value_set_null (value);
return;
}
blob = g_new0 (GdaBlob, 1);
op = gda_oracle_blob_op_new (cnc, lobloc);
gda_blob_set_op (blob, op);
g_object_unref (op);
gda_value_take_blob (value, blob);
break;
}
case GDA_STYPE_CHAR: {
TO_IMPLEMENT; /* test that value fits in */
g_value_set_schar (value, *((gint8*) ora_value->value));
break;
}
case GDA_STYPE_SHORT: {
TO_IMPLEMENT; /* test that value fits in */
gda_value_set_short (value, *((gint*) ora_value->value));
break;
}
case GDA_STYPE_GTYPE:
TO_IMPLEMENT;
break;
case GDA_STYPE_GEOMETRIC_POINT:
TO_IMPLEMENT;
break;
case GDA_STYPE_NULL:
gda_value_set_null (value);
break;
default:
g_assert_not_reached ();
}
}
