cdemodp.c

调用OCI的C++类

#ifdef RCSID
static char *RCSid =
   "$Header: /home/cvs/cvsroot/TIBS_HOME/src/liboci/cdemodp.c,v 1.1.1.1 2006/05/21 19:27:38 cvs Exp $ ";
#endif /* RCSID */

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* Copyright (c) 1998, 2001, Oracle Corporation.  All rights reserved.  */
/*                                                                         */
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/*
**   NAME:
**     cdemodp.c - C Demo program for Direct Path api
**
**
**   DESCRIPTION:
**     - Direct Path Api driver program to demonstrate loading.
**
**   NOTES:
**     Demonstrates usage of the direct path API.
**
**      -- cdemodp.c --
**     This is one of two C files needed to create a demo that loads
**     data through direct path api.
**
**     To build and run the demo, please read directions located in
**     the header section of the cdemdp*.c modules.
**
**
**
**   MODIFIED   (MM/DD/YY)
**   msakayed    11/02/01 - Bug #2094292: add/set OCI_ATTR_DIRPATH_INPUT
**   eegolf      03/04/01 - Updated for 9i
**   cmlim       09/16/98 - Creation (abrumm 04/07/98)
*/

#include <sys/types.h>
#include <sys/stat.h>
#include <ctype.h>
#include <fcntl.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <oratypes.h>
#include <oci.h>
#include <cdemodp0.h>
#include <cdemodp.h>

#ifndef bit
# define bit(x, y) ((x) & (y))
#endif

#ifndef OER
# define OER(x) (x)
#endif

struct loadctl
{
  ub4                 nrow_ctl;            /* number of rows in column array */
  ub2                 ncol_ctl;         /* number of columns in column array */
  OCIEnv             *envhp_ctl;                       /* environment handle */
  OCIServer          *srvhp_ctl;                            /* server handle */
  OCIError           *errhp_ctl;                             /* error handle */
  OCIError           *errhp2_ctl;                /* yet another error handle */
  OCISvcCtx          *svchp_ctl;                          /* service context */
  OCISession         *authp_ctl;                   /* authentication context */
  OCIParam           *colLstDesc_ctl;        /* column list parameter handle */
  OCIDirPathCtx      *dpctx_ctl;                      /* direct path context */
  OCIDirPathColArray *dpca_ctl;           /* direct path column array handle */
  OCIDirPathColArray *dpobjca_ctl;          /* dp column array handle for obj*/
  OCIDirPathColArray *dpnestedobjca_ctl;  /* dp col array hndl for nested obj*/
  OCIDirPathStream   *dpstr_ctl;                /* direct path stream handle */
  ub1                *buf_ctl;    /* pre-alloc'd buffer for out-of-line data */
  ub4                 bufsz_ctl;                 /* size of buf_ctl in bytes */
  ub4                 bufoff_ctl;                     /* offset into buf_ctl */
  ub4                *otor_ctl;                  /* Offset to Recnum mapping */
  ub1                *inbuf_ctl;                 /* buffer for input records */
  struct pctx         pctx_ctl;                     /* partial field context */
  boolean             loadobjcol_ctl;             /* load to obj col(s)? T/F */
};

/* Forward references: */

STATICF void  field_flush(/*_ struct loadctl *ctlp, ub4 rowoff _*/);

STATICF sword field_set(/*_ struct loadctl *ctlp, struct tbl *tblp,
                     struct obj *objp, text *recp, ub4 rowoff, ub1 bufflg _*/);

STATICF void init_obj_load(/*_ struct loadctl *ctlp, struct tbl *tblp,
                              struct obj *objp _*/);
STATICF void alloc_obj_ca(/*_ struct loadctl *ctlp, struct tbl *tblp,
                              struct obj *objp _*/);
STATICF void  init_load(/*_ struct loadctl *ctl, struct tbl *table,
                            struct sess *session _*/);

STATICF void simple_load(/*_ struct loadctl *ctlp, struct tbl *tblp,
                              struct sess *session, FILE *inputfp _*/);

STATICF void  finish_load(/*_ struct loadctl *ctl _*/);

STATICF void  errprint(/*_ dvoid *errhp, ub4 htype, sb4 *errcodep _*/);

STATICF void  checkerr(/*_ dvoid *errhp, ub4 htype, sword status,
                           text *note, sb4 state, text *file, sb4 line _*/);
STATICF void  cleanup(/*_ struct loadctl *ctlp, sb4 ex_status _*/);
STATICF sword do_convert(/*_ struct loadctl *ctlp, ub4 startoff, ub4 rowcnt, 
                             ub4 *cvtCntp, ub2 *badcoffp _*/);
STATICF sword do_load(/*_ struct loadctl *ctlp, ub4 *loadCntp _*/);
STATICF int           main(/*_ int argc, char *argv[] _*/);
STATICF void  free_obj_hndls(struct loadctl *ctlp, struct obj *objp);


/* OCI_CHECK(errhp, ub4 errhptype, sb4 status, struct loadctl *ctlp,
 *          OCIfunction());
 * errhp is typically a (OCIError *), and errhptype is OCI_HTYPE_ERROR.
 * errhp in some cases may be an (OCIEnv *), and errhptype is OCI_HTYPE_ENV.
 */
#define OCI_CHECK(errhp, htype, status, ctlp, OCIfunc) \
if (OCI_SUCCESS != ((status) = (OCIfunc))) \
{ \
  checkerr((dvoid *)(errhp), (ub4)(htype), (sword)(status), (text *)0, \
           (sb4)0, (text *)__FILE__, (sb4)__LINE__); \
  if ((status) != OCI_SUCCESS_WITH_INFO) \
    cleanup((struct loadctl *)ctlp, (sb4)1); \
} else

#define CHECKERR(errhp, htype, status) \
  checkerr((dvoid *)errhp, (ub4)(htype), (sword)(status), (text *)0, \
           (sb4)0, (text *)__FILE__, (sb4)__LINE__);

#define FATAL(note, state) \
do \
{ \
  checkerr((dvoid *)0, (ub4)OCI_HTYPE_ERROR, (sword)OCI_SUCCESS,           \
           (text *)(note), (sb4)(state), (text *)__FILE__, (sb4)__LINE__); \
  cleanup((ctlp), (sb4)2); \
} while (0)

/* External references: */
externref struct tbl    table;
externref struct sess    session;

/* External definitions: */
externdef FILE         *output_fp;                         /* for error msgs */



/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/*                               main                                      */
/*                                                                         */
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/


int main(argc, argv)
int argc;
char *argv[];
{
  sword   ociret;
  struct  loadctl  ctl;
  struct  loadctl *ctlp = &ctl;

  output_fp = (session.outfn_sess) ? fopen((char *)session.outfn_sess, "w")
                                   : stderr;

  memset((dvoid *)ctlp, 0, sizeof(struct loadctl));

  /* set up OCI environment and connect to the ORACLE server */

  OCI_CHECK((dvoid *)0, (ub4)0, ociret, ctlp,
            OCIInitialize((ub4) OCI_DEFAULT, (dvoid *)0,
                          (dvoid * (*)(dvoid *, size_t)) 0,
                          (dvoid * (*)(dvoid *, dvoid *, size_t))0,
                          (void (*)(dvoid *, dvoid *)) 0 ));

  OCI_CHECK(ctlp->envhp_ctl, OCI_HTYPE_ENV, ociret, ctlp,
            OCIEnvInit((OCIEnv **)&ctlp->envhp_ctl, OCI_DEFAULT, (size_t)0,
                       (dvoid **)0));

  /* allocate error handles */
  OCI_CHECK(ctlp->envhp_ctl, OCI_HTYPE_ENV, ociret, ctlp,
            OCIHandleAlloc((dvoid *)ctlp->envhp_ctl,
                           (dvoid **)&ctlp->errhp_ctl, OCI_HTYPE_ERROR,
                           (size_t)0, (dvoid **)0));
  OCI_CHECK(ctlp->envhp_ctl, OCI_HTYPE_ENV, ociret, ctlp,
            OCIHandleAlloc((dvoid *)ctlp->envhp_ctl,
                           (dvoid **)&ctlp->errhp2_ctl, OCI_HTYPE_ERROR,
                           (size_t)0, (dvoid **)0));

  /* server contexts */
  OCI_CHECK(ctlp->envhp_ctl, OCI_HTYPE_ENV, ociret, ctlp,
            OCIHandleAlloc((dvoid *)ctlp->envhp_ctl,
                           (dvoid **)&ctlp->srvhp_ctl, OCI_HTYPE_SERVER,
                           (size_t)0, (dvoid **)0));

  OCI_CHECK(ctlp->envhp_ctl, OCI_HTYPE_ENV, ociret, ctlp,
            OCIHandleAlloc((dvoid *)ctlp->envhp_ctl,
                           (dvoid **)&ctlp->svchp_ctl, OCI_HTYPE_SVCCTX,
                           (size_t)0, (dvoid **)0));

  OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
            OCIServerAttach(ctlp->srvhp_ctl, ctlp->errhp_ctl,
                            session.inst_sess,
                            (sb4)strlen((const char *)session.inst_sess),
                            OCI_DEFAULT));

  /* set attribute server context in the service context */
  OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
            OCIAttrSet((dvoid *)ctlp->svchp_ctl, OCI_HTYPE_SVCCTX,
                       (dvoid *)ctlp->srvhp_ctl, (ub4)0, OCI_ATTR_SERVER,
                       ctlp->errhp_ctl));

  OCI_CHECK(ctlp->envhp_ctl, OCI_HTYPE_ENV, ociret, ctlp,
            OCIHandleAlloc((dvoid *)ctlp->envhp_ctl,
                           (dvoid **)&ctlp->authp_ctl, (ub4)OCI_HTYPE_SESSION,
                           (size_t)0, (dvoid **)0));

  OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
            OCIAttrSet((dvoid *)ctlp->authp_ctl, (ub4)OCI_HTYPE_SESSION,
                       (dvoid *)session.username_sess,
                       (ub4)strlen((char *)session.username_sess),
                       (ub4)OCI_ATTR_USERNAME, ctlp->errhp_ctl));

  OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
            OCIAttrSet((dvoid *)ctlp->authp_ctl, (ub4)OCI_HTYPE_SESSION,
                       (dvoid *)session.password_sess,
                       (ub4)strlen((char *)session.password_sess),
                       (ub4)OCI_ATTR_PASSWORD, ctlp->errhp_ctl));

  /* begin a session */
  OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
            OCISessionBegin(ctlp->svchp_ctl, ctlp->errhp_ctl, ctlp->authp_ctl,
                            OCI_CRED_RDBMS, (ub4)OCI_DEFAULT));

  /* set authentication context into service context */
  OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
            OCIAttrSet((dvoid *)ctlp->svchp_ctl, (ub4)OCI_HTYPE_SVCCTX,
                       (dvoid *)ctlp->authp_ctl, (ub4)0, (ub4)OCI_ATTR_SESSION,
                       ctlp->errhp_ctl));

  init_load(ctlp, &table, &session);                  /* initialize the load */
  simple_load(ctlp, &table, &session, stdin);                   /* load data */
  finish_load(ctlp);                                      /* finish the load */

  cleanup(ctlp, (sb4)0);
  /* NOTREACHED */

return 1;
}


/*
**++++++++++++++++++++++++++++++ alloc_obj_ca +++++++++++++++++++++++++++++++++
**
**  Description:
**
** Function allocates the column arrays for any objects or nested object columns.
**
**  Assumptions:
**
**  Parameters:
**
**  ctlp                           load control structure pointer 
**  tblp                           table pointer  
**  objp                           object pointer 
**
**  Returns:
**
**-------------------------------------------------------------------------
*/

STATICF void alloc_obj_ca(ctlp, tblp, objp)
struct loadctl *ctlp;               /* load control structure pointer */
struct tbl     *tblp;               /* table pointer   */ 
struct obj     *objp;               /* object pointer */
{
  struct col   *colp;
  sword         ociret;             /* return code from OCI calls*/
  ub2 i;

  /*
   * Allocate a separate column array for the column object
   */
  OCI_CHECK(ctlp->envhp_ctl, OCI_HTYPE_ENV, ociret, ctlp,
            OCIHandleAlloc((dvoid *)(objp->ctx_obj),
                           (dvoid **)&(objp->ca_obj),
                           (ub4)OCI_HTYPE_DIRPATH_FN_COL_ARRAY,
                           (size_t)0, (dvoid **)0));

  /* get number of rows in the column array just allocated */
  OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
            OCIAttrGet((CONST dvoid *)(objp->ca_obj),
                       OCI_HTYPE_DIRPATH_FN_COL_ARRAY,
                       (dvoid *)(&objp->nrows_obj), (ub4 *)0,
                       OCI_ATTR_NUM_ROWS, ctlp->errhp_ctl));

  /* get number of columns in the column array just allocated */
  OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
            OCIAttrGet((CONST dvoid *)(objp->ca_obj),
                       OCI_HTYPE_DIRPATH_FN_COL_ARRAY,
                       (dvoid *)(&objp->ncol_obj), (ub4 *)0,
                       OCI_ATTR_NUM_COLS, ctlp->errhp_ctl));

  /*
   * If there are fewer rows in the object column array than in them top-level,
   * one, only use as many rows in the other column array. This will happen
   * when the object requires more space than all of the other columns inits
   * parent table. This simplifies the loop for loading the column arrays
   * so that we only have to worry about when we've filled the top-level
   * column array.
   */
  if (objp->nrows_obj < ctlp->nrow_ctl)
  {
    ctlp->nrow_ctl = objp->nrows_obj;
  }

  /* check each column to see if it is an object, opaque or ref */
  /* and if so, recurse */
  for (i = 0, colp = objp->col_obj; i < objp->ncol_obj; i++, colp++)
  {
    if (colp->exttyp_col == SQLT_NTY || colp->exttyp_col == SQLT_REF)
    {
      alloc_obj_ca(ctlp, tblp, colp->obj_col);
    }
  }

}


/*
**++++++++++++++++++++++++++++++ init_obj_load +++++++++++++++++++++++++++++++++
**
**  Description:
**
**   Function which prepares the load of an object column. This should only
**   be called from init_load or recursively.
**
**  Assumptions:
**
**  Parameters:
**
**  ctlp                           load control structure pointer 
**  tblp                           table pointer   
**  objp                           object pointer 
**
**  Returns:
**
**-------------------------------------------------------------------------
*/