Oracle FAQ Your Portal to the Oracle Knowledge Grid
HOME | ASK QUESTION | ADD INFO | SEARCH | E-MAIL US
 

Home -> Community -> Usenet -> c.d.o.misc -> Re: OCI Object Programming question

Re: OCI Object Programming question

From: DriftWood <drift_wood_at_my-deja.com>
Date: Wed, 15 Mar 2000 14:36:45 GMT
Message-ID: <8ao75t$lpu$1@nnrp1.deja.com> 





--sql script to create objects/tables/etc...
DROP TABLE TestClass;


DROP TYPE  TestClass_t;


DROP TYPE  IntValue_arr;


DROP TYPE  FloatValue_arr;


DROP TYPE  ShortValue_arr;


DROP TYPE  DoubleValue_arr;


DROP TYPE  TestSubClass_t_arr;


DROP TYPE  TestSubClass_t;



CREATE TYPE TestSubClass_t


(



    subClassIntValue    NUMBER,
    subClassFloatValue  NUMBER,
    subClassShortValue  NUMBER,
    subClassDoubleValue NUMBER,




    subClassDateValue   DATE,


    subClassCharValue   VARCHAR2(10)


);



CREATE TYPE IntValue_arr AS VARRAY(5) OF NUMBER;
CREATE TYPE FloatValue_arr AS VARRAY(6) OF NUMBER;
CREATE TYPE ShortValue_arr AS VARRAY(7) OF NUMBER;
CREATE TYPE DoubleValue_arr AS VARRAY(8) OF NUMBER;
CREATE TYPE TestSubClass_t_arr AS VARRAY(2) OF TestSubClass_t;



CREATE TYPE TestClass_t


(



    intValue          NUMBER,
    floatValue        NUMBER,
    shortValue        NUMBER,
    doubleValue       NUMBER,
    dateValue         DATE,
    charValue         VARCHAR2(10),
    intValueArray     IntValue_arr,




    floatValueArray   FloatValue_arr,


    shortValueArray   ShortValue_arr,


    doubleValueArray  DoubleValue_arr,


    subClassValue     TestSubClass_t_arr
);



CREATE TABLE TestClass of TestClass_t;



INSERT INTO TestClass VALUES


(




    1,


    2.1,


    3,


    4.11,


    '5-MAY-97',



    'Hello',

    IntValue_arr(1,2,3,4,5),
    FloatValue_arr(1.1,2.1,3.1,4.1,5.1,6.1),
    ShortValue_arr(2,3,4,5,6,7,8),
    DoubleValue_arr(1.11,2.11,3.11,4.11,5.11,6.11,7.11,8.11),
    TestSubClass_t_arr(TestSubClass_t(2,3.1,4,5.11,'6-MAY-97','Hello2'),
                       TestSubClass_t(3,4.1,5,6.11,'7-MAY-97','Hello3'))


);



INSERT INTO TestClass VALUES


(




    2,


    3.1,


    4,


    5.11,


    '6-MAY-97',



    'Hello1',

    IntValue_arr(2,3,4,5,6),
    FloatValue_arr(2.1,3.1,4.1,5.1,6.1,7.1),
    ShortValue_arr(3,4,5,6,7,8,9),
    DoubleValue_arr(2.11,3.11,4.11,5.11,6.11,7.11,8.11,9.11),
    TestSubClass_t_arr(TestSubClass_t(3,4.1,5,6.11,'7-MAY-97','Hello3'),
                       TestSubClass_t(4,5.1,6,7.11,'8-MAY-97','Hello4'))


);



select * from TestClass;


--End sql script



/*test prog.h*/


#ifndef TESTCLASSTYPE_ORACLE


# define TESTCLASSTYPE_ORACLE


#ifndef OCI_ORACLE
# include <oci.h>
#endif





typedef OCIArray IntValue_arr;


typedef OCIArray FloatValue_arr;


typedef OCIArray ShortValue_arr;


typedef OCIArray DoubleValue_arr;


typedef OCIArray TestSubClass_t_arr;


typedef OCIRef TestSubClass_t_ref;


typedef OCIRef TestClass_t_ref;



struct TestSubClass_t


{


   OCINumber SUBCLASSINTVALUE;


   OCINumber SUBCLASSFLOATVALUE;


   OCINumber SUBCLASSSHORTVALUE;


   OCINumber SUBCLASSDOUBLEVALUE;


   OCIDate SUBCLASSDATEVALUE;


   OCIString * SUBCLASSCHARVALUE;


};


typedef struct TestSubClass_t TestSubClass_t;



struct TestSubClass_t_ind


{


   OCIInd _atomic;


   OCIInd SUBCLASSINTVALUE;


   OCIInd SUBCLASSFLOATVALUE;


   OCIInd SUBCLASSSHORTVALUE;


   OCIInd SUBCLASSDOUBLEVALUE;


   OCIInd SUBCLASSDATEVALUE;


   OCIInd SUBCLASSCHARVALUE;


};


typedef struct TestSubClass_t_ind TestSubClass_t_ind;



struct TestClass_t


{


   OCINumber INTVALUE;


   OCINumber FLOATVALUE;


   OCINumber SHORTVALUE;


   OCINumber DOUBLEVALUE;


   OCIDate DATEVALUE;


   OCIString * CHARVALUE;


   IntValue_arr * INTVALUEARRAY;


   FloatValue_arr * FLOATVALUEARRAY;


   ShortValue_arr * SHORTVALUEARRAY;


   DoubleValue_arr * DOUBLEVALUEARRAY;


   TestSubClass_t_arr * SUBCLASSVALUE;


};


typedef struct TestClass_t TestClass_t;



struct TestClass_t_ind


{


   OCIInd _atomic;


   OCIInd INTVALUE;


   OCIInd FLOATVALUE;


   OCIInd SHORTVALUE;


   OCIInd DOUBLEVALUE;


   OCIInd DATEVALUE;


   OCIInd CHARVALUE;


   OCIInd INTVALUEARRAY;


   OCIInd FLOATVALUEARRAY;


   OCIInd SHORTVALUEARRAY;


   OCIInd DOUBLEVALUEARRAY;


   OCIInd SUBCLASSVALUE;


};


typedef struct TestClass_t_ind TestClass_t_ind;



#endif



/*end testprog.h*/



/*testprog.c*/


#include <testprog.h>



static void checkerr(/*_ OCIError *errhp, sword status _*/);



static void checkerr(errhp, status)


OCIError *errhp;


sword status;


{


  text errbuf[512];


  ub4 buflen;


  ub4 errcode;



  switch (status)


  {


  case OCI_SUCCESS:


    break;


  case OCI_SUCCESS_WITH_INFO:


    printf("Error - OCI_SUCCESS_WITH_INFO\n");
    break;


  case OCI_NEED_DATA:


    printf("Error - OCI_NEED_DATA\n");


    break;


  case OCI_NO_DATA:


    printf("Error - OCI_NO_DATA\n");


    break;


  case OCI_ERROR:


    OCIErrorGet ((dvoid *) errhp, (ub4) 1, (text *) NULL, &errcode,


            errbuf, (ub4) sizeof(errbuf), (ub4) OCI_HTYPE_ERROR);
    printf("Error - %25s\n", errbuf);


    break;


  case OCI_INVALID_HANDLE:


    printf("Error - OCI_INVALID_HANDLE\n");
    break;


  case OCI_STILL_EXECUTING:


    printf("Error - OCI_STILL_EXECUTE\n");
    break;


  case OCI_CONTINUE:


    printf("Error - OCI_CONTINUE\n");


    break;


  default:


    break;


  }


}



int main()


{


    OCIEnv *envhp;


    OCIServer *srvhp;


    OCIError *errhp;


    OCISvcCtx *svchp;


    OCIStmt *stmthp;


    OCISession *usrhp;


    dvoid *tmp;



    OCIType *test_tdo;


    TestClass_t   *testClassObj;


    long   intValue                 = 1;
    float  floatValue               = 2.1;
    short  shortValue               = 3;
    double doubleValue              = 4.11;
    char   *dateValue               = "12/12/1997 13:14:15";
    char   charValue[10]            =
{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'};
    long   intValueArray[5]         = {1,2,3,4,5};
    float  floatValueArray[6]       = {1.1,2.1,3.1,4.1,5.1,6.1};
    short  shortValueArray[7]       = {2,3,4,5,6,7,8};
    double doubleValueArray[8]      =
{1.11,2.11,3.11,4.11,5.11,6.11,7.11,8.11};
    long   subClassIntValue[2]      = {1,2};
    float  subClassFloatValue[2]    = {1.1, 2.1};
    short  subClassShortValue[2]    = {2, 3};


    double subClassDoubleValue[2]   = {1.11, 2.11};
    char   subClassCharValue[2][20] =


{{'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k'},
{'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l'}};


    char   *subClassDateValue[2]    = {"13/12/1997
13:14:15", "14/12/1997 13:14:15"};



    boolean dirty;



    text *insertStmt = (text*) "INSERT into TESTCLASS values


(:testClassObj)";




    OCIBind *bnd1p;
    OCIBind *bnd2p;
    OCIBind *bnd3p;
    OCIBind *bnd4p;
    OCIBind *bnd5p;
    OCIBind *bnd6p;




    OCIRef* testRef;


    ub4 testRefSize;


    OCIDefine *def1p;


    sword status;



    short i;


    OCINumber* ociNumber1;


    boolean    elementExists;


    sb4 collSize;


    sb4 collMax;


    OCINumber ociNumber;



    OCIType *testSubClass_tdo;

    TestSubClass_t *testSubClassObj;
    TestSubClass_t *testSubClassObj1;
    TestSubClass_t_ind *objInd;
    long           subClassIntValue1[2];

    OCIInitialize((ub4) OCI_OBJECT, (dvoid *)0,  (dvoid * (*)()) 0,
                  (dvoid * (*)()) 0,  (void (*)()) 0 );





    OCIHandleAlloc( (dvoid *) NULL, (dvoid **) &envhp, (ub4)
OCI_HTYPE_ENV,


                   52, (dvoid **) &tmp);





    OCIEnvInit( &envhp, (ub4) OCI_DEFAULT, 21, (dvoid **) &tmp  );



    OCIHandleAlloc( (dvoid *) envhp, (dvoid **) &errhp, (ub4)
OCI_HTYPE_ERROR,


                   52, (dvoid **) &tmp);


    OCIHandleAlloc( (dvoid *) envhp, (dvoid **) &srvhp, (ub4)
OCI_HTYPE_SERVER,


                   52, (dvoid **) &tmp);





    OCIServerAttach( srvhp, errhp, (text *) 0, (sb4) 0, (ub4)
OCI_DEFAULT);


    OCIHandleAlloc( (dvoid *) envhp, (dvoid **) &svchp, (ub4)
OCI_HTYPE_SVCCTX,


                   52, (dvoid **) &tmp);

    OCIAttrSet( (dvoid *) svchp, (ub4) OCI_HTYPE_SVCCTX,
               (dvoid *) srvhp, (ub4) 0,
               (ub4) OCI_ATTR_SERVER, (OCIError *) errhp);





    OCIHandleAlloc((dvoid *)envhp, (dvoid **)&usrhp, (ub4)
OCI_HTYPE_SESSION,


                   (size_t) 0, (dvoid **) 0);

    OCIAttrSet((dvoid *)usrhp, (ub4)OCI_HTYPE_SESSION,
               (dvoid *)"scott", (ub4)strlen("scott"),
               OCI_ATTR_USERNAME, errhp);

    OCIAttrSet((dvoid *)usrhp, (ub4)OCI_HTYPE_SESSION,
               (dvoid *)"tiger", (ub4)strlen("tiger"),
               OCI_ATTR_PASSWORD, errhp);





    checkerr(errhp, OCISessionBegin (svchp, errhp, usrhp,
OCI_CRED_RDBMS, OCI_DEFAULT));


    OCIAttrSet((dvoid *)svchp, (ub4)OCI_HTYPE_SVCCTX,

               (dvoid *)usrhp, (ub4)0,
               OCI_ATTR_SESSION, errhp);

    checkerr(errhp, OCIHandleAlloc( (dvoid *) envhp, (dvoid **) &stmthp,
             (ub4) OCI_HTYPE_STMT, 50, (dvoid **) &tmp));





    /* creating TestClass object */


    checkerr(errhp, OCITypeByName(envhp, errhp, svchp, (CONST text*)0,
0,

          (CONST text*)"TESTCLASS_T", 11,
          (CONST text*)0, 0, OCI_DURATION_SESSION, OCI_TYPEGET_HEADER,
          &test_tdo));





    checkerr(errhp, OCIObjectNew(envhp, errhp, svchp,
OCI_TYPECODE_OBJECT, test_tdo, NULL,


            OCI_DURATION_SESSION, (ub1)TRUE, (dvoid **)&testClassObj));



    /* inserting values into TestClass object */
    OCINumberFromInt(errhp, (CONST dvoid*)&intValue, sizeof(intValue),
OCI_NUMBER_SIGNED, &testClassObj->INTVALUE);


    OCINumberFromReal(errhp, (CONST dvoid*)&floatValue, sizeof


(floatValue), &testClassObj->FLOATVALUE);




    OCINumberFromInt(errhp, (CONST dvoid*)&shortValue, sizeof


(shortValue), OCI_NUMBER_SIGNED, &testClassObj->SHORTVALUE);




    OCINumberFromReal(errhp, (CONST dvoid*)&doubleValue, sizeof


(doubleValue), &testClassObj->DOUBLEVALUE);




    OCIDateFromText(errhp, (CONST text*)dateValue, 19, (CONST
text*)"DD/MM/YYYY HH24:MI:SS", (ub1)21,

                    (CONST text*)"American", (ub4)8, &testClassObj-


>DATEVALUE);



    OCIStringAssignText(envhp, errhp, (CONST text*)charValue, 10,
&testClassObj->CHARVALUE);



    for (i=0; i<4; i++)


    {


        OCINumberFromInt(errhp, (CONST dvoid*)&intValueArray[i], sizeof


(intValueArray[i]), OCI_NUMBER_SIGNED, &ociNumber);




        OCICollAppend(envhp, errhp, (CONST dvoid*)&ociNumber, (CONST
dvoid*)0, testClassObj->INTVALUEARRAY);


    }



    for (i=0; i<5; i++)


    {


        OCINumberFromReal(errhp, (CONST dvoid*)&floatValueArray[i],
sizeof(floatValueArray[i]), &ociNumber);


        OCICollAppend(envhp, errhp, (CONST dvoid*)&ociNumber, (CONST
dvoid*)0, testClassObj->FLOATVALUEARRAY);


    }



    for (i=0; i<6; i++)


    {


        OCINumberFromInt(errhp, (CONST dvoid*)&shortValueArray[i],
sizeof(shortValueArray[i]), OCI_NUMBER_SIGNED, &ociNumber);


        OCICollAppend(envhp, errhp, (CONST dvoid*)&ociNumber, (CONST
dvoid*)0, testClassObj->SHORTVALUEARRAY);


    }



    for (i=0; i<7; i++)


    {


        OCINumberFromReal(errhp, (CONST dvoid*)&doubleValueArray[i],
sizeof(doubleValueArray[i]), &ociNumber);


        OCICollAppend(envhp, errhp, (CONST dvoid*)&ociNumber, (CONST
dvoid*)0, testClassObj->DOUBLEVALUEARRAY);


    }



    checkerr(errhp, OCITypeByName(envhp, errhp, svchp, (CONST text*)0,
0,

          (CONST text*)"TESTSUBCLASS_T", strlen("TESTSUBCLASS_T"),
          (CONST text*)0, 0, OCI_DURATION_SESSION, OCI_TYPEGET_HEADER,
          &testSubClass_tdo));





    checkerr(errhp, OCIObjectNew(envhp, errhp, svchp,
OCI_TYPECODE_OBJECT, testSubClass_tdo, NULL,


            OCI_DURATION_SESSION, (ub1)TRUE, (dvoid **)
&testSubClassObj));



    /* get pointer to the null indicator structure */
    checkerr(errhp, OCIObjectGetInd(envhp, errhp, testSubClassObj,


             (dvoid **)&objInd));


    /* mark all attributes of testSubClassObj not null */

    objInd->_atomic = OCI_IND_NOTNULL;
    objInd->SUBCLASSINTVALUE = OCI_IND_NOTNULL;
    objInd->SUBCLASSFLOATVALUE = OCI_IND_NOTNULL;
    objInd->SUBCLASSSHORTVALUE = OCI_IND_NOTNULL;
    objInd->SUBCLASSDOUBLEVALUE = OCI_IND_NOTNULL;
    objInd->SUBCLASSDATEVALUE = OCI_IND_NOTNULL;
    objInd->SUBCLASSCHARVALUE = OCI_IND_NOTNULL;





    for (i=0; i<1; i++)


    {


        checkerr(errhp, OCINumberFromInt(errhp, (CONST dvoid*)
&subClassIntValue[i], sizeof(subClassIntValue[i]), OCI_NUMBER_SIGNED,
&testSubClassObj->SUBCLASSINTVALUE));


        checkerr(errhp, OCINumberFromReal(errhp, (CONST dvoid*)
&subClassFloatValue[i], sizeof(subClassFloatValue[i]), &testSubClassObj-
>SUBCLASSFLOATVALUE));



        checkerr(errhp, OCINumberFromInt(errhp, (CONST dvoid*)
&subClassShortValue[i], sizeof(subClassShortValue[i]),
OCI_NUMBER_SIGNED, &testSubClassObj->SUBCLASSSHORTVALUE));


        checkerr(errhp, OCINumberFromReal(errhp, (CONST dvoid*)
&subClassDoubleValue[i], sizeof(subClassDoubleValue[i]),
&testSubClassObj->SUBCLASSDOUBLEVALUE));


        checkerr(errhp, OCIDateFromText(errhp, (CONST text*)
subClassDateValue[i], 19, (CONST text*)"DD/MM/YYYY HH24:MI:SS", (ub1)21,

                    (CONST text*)"American", (ub4)8, &testSubClassObj-
>SUBCLASSDATEVALUE));
        checkerr(errhp, OCIStringAssignText(envhp, errhp, (CONST text*)


subClassCharValue[i], 10, &testSubClassObj-
>SUBCLASSCHARVALUE));



	/* value seem to be correct before appending into array */
        printf("** check input value **\n");
        checkerr(errhp, OCINumberToInt(errhp, &testSubClassObj-


>SUBCLASSINTVALUE, sizeof(subClassIntValue1[i]), OCI_NUMBER_SIGNED,
&subClassIntValue1[i]));


        printf("int value: %25d\n", subClassIntValue1[i]);



        checkerr(errhp, OCICollAppend(envhp, errhp, (CONST dvoid*)
testSubClassObj, (CONST dvoid*)objInd, testClassObj->SUBCLASSVALUE));



        /* when the subclass is extracted out of the array after being
inserted, and when

	   we check the intvalue, it returns an error. Therefore, the
	   appending operation has failed, but no error was given */
        printf("** check output value **\n");
        checkerr(errhp, OCICollGetElem(envhp, errhp, testClassObj-


>SUBCLASSVALUE, i, &elementExists, (void**)&testSubClassObj1, (dvoid**)
0));


        checkerr(errhp, OCINumberToInt(errhp, &testSubClassObj1-
>SUBCLASSINTVALUE, sizeof(subClassIntValue1[i]), OCI_NUMBER_SIGNED,
&subClassIntValue1[i]));


        printf("int value: %25d\n", subClassIntValue1[i]);
    }



    /* execute insert statement */


    checkerr(errhp, OCIStmtPrepare(stmthp, errhp, (text*) insertStmt,


             (ub4)strlen((char*)insertStmt), (ub4) OCI_NTV_SYNTAX,


(ub4) OCI_DEFAULT));





    checkerr(errhp, OCIBindByName(stmthp, &bnd1p, errhp,


(text*) ":testClassObj",



             (sb4) -1, (dvoid *) 0, (sb4) 0, SQLT_NTY, (dvoid *) 0,
             (ub2 *)0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, (ub4)


OCI_DEFAULT));


    checkerr(errhp, OCIBindObject(bnd1p, errhp, test_tdo, (dvoid **)
&testClassObj,


             (ub4 *)0, (dvoid **) 0, (ub4 *) 0));



    checkerr(errhp, OCIStmtExecute(svchp, stmthp, errhp, (ub4) 1,

             (ub4) 0, (OCISnapshot *) NULL, (OCISnapshot *) NULL,
             (ub4) OCI_DEFAULT));





    checkerr(errhp, OCITransCommit(svchp, errhp, (ub4) 0));



    checkerr(errhp, OCIObjectUnpin(envhp, errhp, test_tdo));



    checkerr(errhp, OCIHandleFree((dvoid *) stmthp, (ub4)
OCI_HTYPE_STMT));


    OCISessionEnd(svchp, errhp, usrhp, (ub4)OCI_DEFAULT);
    OCIServerDetach( srvhp, errhp, (ub4) OCI_DEFAULT );
    checkerr(errhp, OCIHandleFree((dvoid *) srvhp, (ub4)
OCI_HTYPE_SERVER));



    checkerr(errhp, OCIHandleFree((dvoid *) svchp, (ub4)
OCI_HTYPE_SVCCTX));



    checkerr(errhp, OCIHandleFree((dvoid *) errhp, (ub4)
OCI_HTYPE_ERROR));



}







/*end testprog.c*/





Sent via Deja.com http://www.deja.com/



Before you buy.
Received on Wed Mar 15 2000 - 08:36:45 CST












Original text of this message













  HOME |
  ASK QUESTION |
  ADD INFO |
  SEARCH |
  E-MAIL US