OCINumber *oci8_dbl_to_onum(OCINumber *result, double dbl, OCIError *errhp)
{
if (isnan(dbl)) {
rb_raise(rb_eFloatDomainError, "NaN");
/* never reach here */
} else if (isinf(dbl)) {
if (dbl > 0.0) {
oranumber_from_str(result, "~", 1);
} else {
oranumber_from_str(result, "-~", 2);
}
return result;
}
if (oci8_float_conversion_type_is_ruby) {
VALUE str;
sword rv;
str = rb_obj_as_string(rb_float_new(dbl));
rv = oranumber_from_str(result, RSTRING_PTR(str), RSTRING_LEN(str));
if (rv != 0) {
oci8_raise_by_msgno(rv, NULL);
}
} else {
chkerr(OCINumberFromReal(errhp, &dbl, sizeof(dbl), result));
}
return result;
}
ORAEXT OCINumber * oraConfigGetFloat (OCIExtProcContext *ctx, int context_id,
char *key_name, short key_name_indicator,
short *return_indicator)
{
OCINumber *result = NULL;
ORABLOCK_BEGIN
{
*return_indicator = OCI_IND_NULL;
OracleEnv env(ctx, logger);
if (key_name_indicator != OCI_IND_NOTNULL)
throw BingoError("Null key is given");
float value;
BingoOracleContext &context = BingoOracleContext::get(env, context_id, false, 0);
if (!context.configGetFloat(env, key_name, value))
throw BingoError("Key wasn't found");
result = (OCINumber *)OCIExtProcAllocCallMemory(ctx, sizeof(OCINumber));
if (result == NULL)
throw BingoError("can't allocate memory for number");
double value_double = value;
env.callOCI(OCINumberFromReal(env.errhp(), &value_double, sizeof(value_double), result));
*return_indicator = OCI_IND_NOTNULL;
}
ORABLOCK_END
return result;
}
//-----------------------------------------------------------------------------
// NumberVar_SetValueFromFloat()
// Set the value of the variable from a Python float.
//-----------------------------------------------------------------------------
static int NumberVar_SetValueFromFloat(
udt_NumberVar *var, // variable to set value for
unsigned pos, // array position to set
PyObject *value) // value to set
{
double doubleValue;
sword status;
doubleValue = PyFloat_AS_DOUBLE(value);
status = OCINumberFromReal(var->environment->errorHandle, &doubleValue,
sizeof(double), &var->data[pos]);
return Environment_CheckForError(var->environment, status,
"NumberVar_SetValueFromFloat()");
}
void OWStatement::AddElement( OCIArray* poData,
double dfValue )
{
OCINumber oci_number;
CheckError(OCINumberFromReal(hError,
(dvoid*) &dfValue,
(uword) sizeof(double),
(OCINumber*) &oci_number), hError);
CheckError(OCICollAppend(poConnection->hEnv,
hError,
(OCINumber*) &oci_number,
(dvoid*) 0,
(OCIColl*) poData), hError);
}
sword
numberFromFloatSlice(
OCIError *err,
void *inum,
uword inum_length,
OCINumber *numbers,
ub4 arr_length
) {
sword rc;
int i;
for(i=0; i < arr_length; i++) {
rc = OCINumberFromReal(err, inum + (i * inum_length), inum_length, &(numbers[i]));
if(rc == OCI_ERROR) {
return rc;
}
}
return OCI_SUCCESS;
}
static OCIAnyData *
to_return_value(plruby_context_t *ctx, VALUE val)
{
OCIAnyData *sdata = NULL;
OCIInd ind = OCI_IND_NOTNULL;
if (NIL_P(val)) {
return NULL;
}
switch (ctx->rettype) {
case OCI_TYPECODE_VARCHAR2:
{
OCIString *str = NULL;
VALUE sval = rb_String(val);
sval = rb_str_export_to_enc(sval, oracle_encoding);
chk(OCIStringAssignText(ctx->envhp, ctx->errhp, (text*)RSTRING_PTR(sval), RSTRING_LEN(sval), &str));
chk(OCIAnyDataConvert(ctx->svchp, ctx->errhp, ctx->rettype, NULL, OCI_DURATION_SESSION, &ind, str, 0, &sdata));
chk(OCIStringResize(ctx->envhp, ctx->errhp, 0, &str));
return sdata;
}
case OCI_TYPECODE_NUMBER:
{
OCINumber num;
double dval = rb_num2dbl(val);
chk(OCINumberFromReal(ctx->errhp, &dval, sizeof(dval), &num));
chk(OCIAnyDataConvert(ctx->svchp, ctx->errhp, ctx->rettype, NULL, OCI_DURATION_SESSION, &ind, &num, 0, &sdata));
return sdata;
}
case OCI_TYPECODE_BDOUBLE:
{
double dval = rb_num2dbl(val);
chk(OCIAnyDataConvert(ctx->svchp, ctx->errhp, ctx->rettype, NULL, OCI_DURATION_SESSION, &ind, &dval, 0, &sdata));
return sdata;
}
}
rb_raise(rb_eRuntimeError, "Unsupported Typecode %d", ctx->rettype);
}
ORAEXT OCINumber * oraProfilingGetTime (OCIExtProcContext *ctx, char *key_name, short key_name_indicator,
short *return_indicator)
{
OCINumber *result = NULL;
ORABLOCK_BEGIN
{
*return_indicator = OCI_IND_NULL;
OracleEnv env(ctx, logger);
if (key_name_indicator != OCI_IND_NOTNULL)
throw BingoError("Null key is given");
float value;
// Try to find in profiling data
ProfilingSystem &inst = ProfilingSystem::getInstance();
if (inst.hasLabel(key_name))
//throw BingoError("Key wasn't found");
value = inst.getLabelExecTime(key_name);
else
value = 0;
result = (OCINumber *)OCIExtProcAllocCallMemory(ctx, sizeof(OCINumber));
if (result == NULL)
throw BingoError("can't allocate memory for number");
double value_double = value;
env.callOCI(OCINumberFromReal(env.errhp(), &value_double, sizeof(value_double), result));
*return_indicator = OCI_IND_NOTNULL;
}
ORABLOCK_END
return result;
}
int main()
{
OGROCISession oSession;
if( !oSession.EstablishSession( "warmerda", "LetoKing",
"gdal800.dreadfest.com" ) )
{
exit( 1 );
}
printf( "Session established.\n" );
OGROCIStatement oStatement( &oSession );
oStatement.Execute( "DROP TABLE fasttest" );
oStatement.Execute( "CREATE TABLE fasttest (ifld INTEGER, cfld VARCHAR(4000), shape mdsys.sdo_geometry)" );
// oStatement.Execute( "CREATE TABLE fasttest (ifld INTEGER, cfld VARCHAR(4000))" );
/* -------------------------------------------------------------------- */
/* Prepare insert statement. */
/* -------------------------------------------------------------------- */
oStatement.Prepare( "INSERT INTO fasttest VALUES "
"(:field_1, :field_2, :field_3)" );
// oStatement.Prepare( "INSERT INTO fasttest VALUES "
// "(:field_1, :field_2)" );
/* -------------------------------------------------------------------- */
/* Do a conventional bind. */
/* -------------------------------------------------------------------- */
int anField1[100];
char szField2[100*4];
int anGType[100];
int anSRID[100];
OCIArray *aphElemInfos[100];
OCIArray *aphOrdinates[100];
SDO_GEOMETRY_TYPE aoGeometries[100];
SDO_GEOMETRY_ind aoGeometryIndicators[100];
SDO_GEOMETRY_TYPE *apoGeomMap[100];
SDO_GEOMETRY_ind *apoGeomIndMap[100];
double adfX[100], adfY[100];
memset( aphElemInfos, 0, sizeof(OCIArray*) * 100 );
memset( aphOrdinates, 0, sizeof(OCIArray*) * 100 );
memset( aoGeometries, 0, sizeof(SDO_GEOMETRY) * 100 );
memset( aoGeometryIndicators, 0, sizeof(SDO_GEOMETRY_ind) * 100 );
if( oStatement.BindScalar( ":field_1", anField1,
sizeof(int), SQLT_INT ) != CE_None )
exit( 1 );
if( oStatement.BindScalar( ":field_2", szField2, 4, SQLT_STR ) != CE_None )
exit( 1 );
if( oStatement.BindObject( ":field_3", apoGeomMap, oSession.hGeometryTDO,
(void**)apoGeomIndMap ) != CE_None )
exit( 1 );
/* -------------------------------------------------------------------- */
/* Create array of arrays for elem_info and ordinates. */
/* -------------------------------------------------------------------- */
int iBindRow;
for( iBindRow = 0; iBindRow < 100; iBindRow++ )
{
if( oSession.Failed(
OCIObjectNew( oSession.hEnv, oSession.hError,
oSession.hSvcCtx, OCI_TYPECODE_VARRAY,
oSession.hElemInfoTDO, (dvoid *)NULL,
OCI_DURATION_SESSION,
FALSE, (dvoid **) (aphElemInfos + iBindRow)),
"OCIObjectNew()") )
exit( 1 );
if( oSession.Failed(
OCIObjectNew( oSession.hEnv, oSession.hError,
oSession.hSvcCtx, OCI_TYPECODE_VARRAY,
oSession.hOrdinatesTDO, (dvoid *)NULL,
OCI_DURATION_SESSION,
FALSE, (dvoid **) (aphOrdinates + iBindRow)),
"OCIObjectNew()") )
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Populate VARRAYs */
/* -------------------------------------------------------------------- */
int iRow;
for( iRow = 0; iRow < 100; iRow++ )
{
anField1[iRow] = iRow;
sprintf( szField2 + iRow*4, "%3d", iRow );
anGType[iRow] = 3001;
anSRID[iRow] = -1;
adfX[iRow] = 100.0 + iRow;
adfY[iRow] = 100.0 - iRow;
//---------------------------------------------------------------
int anElemInfo[3], nElemInfoCount;
OCINumber oci_number;
int i;
nElemInfoCount = 3;
anElemInfo[0] = 1;
anElemInfo[1] = 1;
anElemInfo[2] = 1;
// Prepare the VARRAY of ordinate values.
for (i = 0; i < nElemInfoCount; i++)
{
if( oSession.Failed(
OCINumberFromInt( oSession.hError,
(dvoid *) (anElemInfo + i),
(uword)sizeof(int),
OCI_NUMBER_SIGNED,
&oci_number),
"OCINumberFromInt") )
exit( 1 );
if( oSession.Failed(
OCICollAppend( oSession.hEnv, oSession.hError,
(dvoid *) &oci_number,
(dvoid *)0, aphElemInfos[iRow]),
"OCICollAppend") )
exit( 1 );
}
//---------------------------------------------------------------
double adfOrdinates[6];
int nOrdCount;
nOrdCount = 3;
adfOrdinates[0] = iRow + 100;
adfOrdinates[1] = iRow - 100;
adfOrdinates[2] = 0.0;
adfOrdinates[3] = iRow + 100;
adfOrdinates[4] = iRow - 100;
adfOrdinates[5] = 0.0;
// Prepare the VARRAY of ordinate values.
for (i = 0; i < nOrdCount; i++)
{
if( oSession.Failed(
OCINumberFromReal( oSession.hError,
(dvoid *) (adfOrdinates + i),
(uword)sizeof(double),
&oci_number),
"OCINumberFromReal") )
exit( 1 );
if( oSession.Failed(
OCICollAppend( oSession.hEnv, oSession.hError,
(dvoid *) &oci_number,
(dvoid *)0, aphOrdinates[iRow]),
"OCICollAppend") )
exit( 1 );
}
// -------------------------------------------------------------
SDO_GEOMETRY_TYPE *poGeom = aoGeometries + iRow;
SDO_GEOMETRY_ind *poInd = aoGeometryIndicators + iRow;
poInd->sdo_point._atomic = OCI_IND_NULL;
if( oSession.Failed(
OCINumberFromInt( oSession.hError,
(dvoid *) (anGType + iRow),
(uword)sizeof(int),
OCI_NUMBER_SIGNED,
&(poGeom->sdo_gtype)),
"OCINumberFromInt" ) )
exit( 1 );
if( oSession.Failed(
OCINumberFromInt( oSession.hError,
(dvoid *) (anSRID + iRow),
(uword)sizeof(int),
OCI_NUMBER_SIGNED,
&(poGeom->sdo_srid)),
"OCINumberFromInt" ) )
exit( 1 );
poGeom->sdo_elem_info = aphElemInfos[iRow];
poGeom->sdo_ordinates = aphOrdinates[iRow];
apoGeomMap[iRow] = poGeom;
apoGeomIndMap[iRow] = poInd;
}
/* -------------------------------------------------------------------- */
/* Execute the statement. */
/* -------------------------------------------------------------------- */
int iGroup;
for( iGroup = 0; iGroup < 2; iGroup++ )
{
if( oSession.Failed(
OCIStmtExecute( oSession.hSvcCtx, oStatement.GetStatement(),
oSession.hError, (ub4) 100, (ub4)0,
(OCISnapshot *)NULL, (OCISnapshot *)NULL,
(ub4) OCI_COMMIT_ON_SUCCESS ),
"OCIStmtExecute" ) )
exit( 1 );
}
printf( "Successful completion\n" );
exit( 0 );
}
/* 1 - success, 0 - error */
static int set_oci_number_from_num(OCINumber *result, VALUE num, int force, OCIError *errhp)
{
signed long sl;
double dbl;
if (!RTEST(rb_obj_is_kind_of(num, rb_cNumeric)))
rb_raise(rb_eTypeError, "expect Numeric but %s", rb_class2name(CLASS_OF(num)));
if (rb_respond_to(num, id_finite_p) && !RTEST(rb_funcall(num, id_finite_p, 0))) {
rb_raise(rb_eTypeError, "cannot accept number which isn't finite.");
}
switch (rb_type(num)) {
case T_FIXNUM:
/* set from long. */
sl = NUM2LONG(num);
oci_lc(OCINumberFromInt(errhp, &sl, sizeof(sl), OCI_NUMBER_SIGNED, result));
return 1;
case T_FLOAT:
/* set from double. */
dbl = NUM2DBL(num);
oci_lc(OCINumberFromReal(errhp, &dbl, sizeof(dbl), result));
return 1;
case T_BIGNUM:
/* change via string. */
num = rb_big2str(num, 10);
set_oci_number_from_str(result, num, Qnil, Qnil, errhp);
return 1;
}
if (RTEST(rb_obj_is_instance_of(num, cOCINumber))) {
/* OCI::Number */
oci_lc(OCINumberAssign(errhp, DATA_PTR(num), result));
return 1;
}
if (rb_respond_to(num, id_split)) {
/* BigDecimal */
VALUE split = rb_funcall(num, id_split, 0);
if (TYPE(split) == T_ARRAY && RARRAY_LEN(split) == 4) {
/*
* sign, significant_digits, base, exponent = num.split
* onum = sign * "0.#{significant_digits}".to_f * (base ** exponent)
*/
VALUE *ary = RARRAY_PTR(split);
int sign;
OCINumber digits;
int exponent;
int digits_len;
OCINumber work;
/* check sign */
if (TYPE(ary[0]) != T_FIXNUM) {
goto is_not_big_decimal;
}
sign = FIX2INT(ary[0]);
/* check digits */
StringValue(ary[1]);
digits_len = RSTRING_LEN(ary[1]);
set_oci_number_from_str(&digits, ary[1], Qnil, Qnil, errhp);
/* check base */
if (TYPE(ary[2]) != T_FIXNUM || FIX2LONG(ary[2]) != 10) {
goto is_not_big_decimal;
}
/* check exponent */
if (TYPE(ary[3]) != T_FIXNUM) {
goto is_not_big_decimal;
}
exponent = FIX2INT(ary[3]);
if (have_OCINumberShift) {
/* Oracle 8.1 or upper */
oci_lc(OCINumberShift(errhp, &digits, exponent - digits_len, &work));
} else {
/* Oracle 8.0 */
int n = 10;
OCINumber base;
OCINumber exp;
oci_lc(OCINumberFromInt(errhp, &n, sizeof(n), OCI_NUMBER_SIGNED, &base));
oci_lc(OCINumberIntPower(errhp, &base, exponent - digits_len, &exp));
oci_lc(OCINumberMul(errhp, &digits, &exp, &work));
}
if (sign >= 0) {
oci_lc(OCINumberAssign(errhp, &work, result));
} else {
oci_lc(OCINumberNeg(errhp, &work, result));
}
return 1;
}
}
is_not_big_decimal:
if (rb_respond_to(num, id_numerator) && rb_respond_to(num, id_denominator)) {
/* Rational */
OCINumber numerator;
OCINumber denominator;
if (set_oci_number_from_num(&numerator, rb_funcall(num, id_numerator, 0), 0, errhp) &&
set_oci_number_from_num(&denominator, rb_funcall(num, id_denominator, 0), 0, errhp)) {
oci_lc(OCINumberDiv(errhp, &numerator, &denominator, result));
return 1;
}
}
if (force) {
/* change via string as a last resort. */
/* TODO: if error, raise TypeError instead of OCI::Error */
set_oci_number_from_str(result, num, Qnil, Qnil, errhp);
return 1;
}
return 0;
}
