cdemodp.c

用Oracle OCI进行Direct path insert的示例代码

#ifdef RCSID
static char *RCSid =
   "$Header: cdemodp.c 14-jul-99.13:06:13 mjaeger Exp $ ";
#endif /* RCSID */

/* Copyright (c) 1998, 1999, Oracle Corporation.  All rights reserved.
*/

/*
 *      -- 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 near
 * the top of cdemodp_lip.c.
 *
 */

/*
   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.

   MODIFIED   (MM/DD/YY)
   mjaeger     07/14/99 - bug 808870: OCCS: convert tabs, no long lines
   cmlim       06/07/99 - same as tkpidrv.c@@/main/15 minus operation mode
                        - (mode_tbl) & query_stats()
   cmlim       03/25/99 - make same as tkpidrv.c minus op mode (mode_tbl)
   abrumm      03/01/99 - OCI_ATTR_ROW_COUNT change
   abrumm      02/10/99 - field_set: trim trailing whitespace bug
   cmlim       02/02/99 - set OCI_DIRPATH_COL_NULL correctly
                        - use O_BINARY open mode for WIN32COMMON, WIN32, _WIN32
                        - do not use non-public functions (ie. ktsgnospc)
                        - removed "include <unistd.h>" - not needed
                        - write out number of records LOADED
   abrumm      12/22/98 - fix LOAD_NO_DATA, CONVERT_CONTINUE case
   abrumm      10/13/98 - fix field_set
   cmlim       11/17/98 - add attributes & session options; increase clen to ub
   cmlim       10/07/98 - change stderr to stdout where appropriate
   cmlim       10/02/98 - remove sn.h & deliberate error cases; fix field_set
   cmlim       09/16/98 - data-loading driver to demo direct path api
   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 */
  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 which is not in use */
  ub4                *otor_ctl;                  /* Offset to Recnum mapping */
  ub1                *inbuf_ctl;                 /* buffer for input records */
  struct pctx         pctx_ctl;                     /* partial field context */
};

/* Forward references: */
STATICF void  field_flush(/*_ struct loadctl *ctlp, ub4 rowoff _*/);
STATICF sword field_set(/*_ struct loadctl *ctlp, struct tbl *tblp,
                            text *recp, ub4 rowoff _*/);

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[] _*/);


/* 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 */


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 */
}

/* init_load:
 *   Function which prepares for a direct path load using the direct
 *   path API on the table described by 'tblp'.  The loadctl
 *   structure given by 'ctlp' has appropriately initialized
 *   environment, and service context handles (alredy connected to
 *   the server) prior to calling this function.
 */
STATICF void
init_load(ctlp, tblp, sessp)
struct loadctl *ctlp;
struct tbl     *tblp;
struct sess    *sessp;
{
  struct  col   *colp;
  struct  fld   *fldp;
  sword         ociret;                        /* return code from OCI calls */
  OCIDirPathCtx *dpctx;                               /* direct path context */
  OCIParam      *colDesc;                     /* column parameter descriptor */
  ub1            parmtyp;
  ub1           *timestamp = (ub1 *)0;
  ub4            size;
  ub2            i;
  ub4            pos;

  /* allocate and initialize a direct path context */
  OCI_CHECK(ctlp->envhp_ctl, OCI_HTYPE_ENV, ociret, ctlp,
            OCIHandleAlloc((dvoid *)ctlp->envhp_ctl,
                           (dvoid **)&ctlp->dpctx_ctl,
                           (ub4)OCI_HTYPE_DIRPATH_CTX,
                           (size_t)0, (dvoid **)0));

  dpctx = ctlp->dpctx_ctl;                                      /* shorthand */

  OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
            OCIAttrSet((dvoid *)dpctx, (ub4)OCI_HTYPE_DIRPATH_CTX,
                       (dvoid *)tblp->name_tbl,
                       (ub4)strlen((const char *)tblp->name_tbl),
                       (ub4)OCI_ATTR_NAME, ctlp->errhp_ctl));


  if (tblp->subname_tbl && *tblp->subname_tbl)    /* set (sub)partition name */
  {
    OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
              OCIAttrSet((dvoid *)dpctx, (ub4)OCI_HTYPE_DIRPATH_CTX,
                         (dvoid *)tblp->subname_tbl,
                         (ub4)strlen((const char *)tblp->subname_tbl),
                         (ub4)OCI_ATTR_SUB_NAME, ctlp->errhp_ctl));
  }

  if (tblp->owner_tbl)                            /* set schema (owner) name */
  {
    OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
              OCIAttrSet((dvoid *)dpctx, (ub4)OCI_HTYPE_DIRPATH_CTX,
                         (dvoid *)tblp->owner_tbl,
                         (ub4)strlen((const char *)tblp->owner_tbl),
                         (ub4)OCI_ATTR_SCHEMA_NAME, ctlp->errhp_ctl));
  }

  /* Note: setting tbl default datemask will not trigger client library
   * to check strings for dates - only setting column datemask will.
   */
  if (tblp->dfltdatemask_tbl)
  {
    OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
              OCIAttrSet((dvoid *)dpctx, (ub4)OCI_HTYPE_DIRPATH_CTX,
                         (dvoid *)tblp->dfltdatemask_tbl,
                         (ub4)strlen((const char *)tblp->dfltdatemask_tbl),
                         (ub4)OCI_ATTR_DATEFORMAT, ctlp->errhp_ctl));
  }

  if (tblp->parallel_tbl)                 /* set table level parallel option */
  {
    OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
              OCIAttrSet((dvoid *)dpctx, (ub4)OCI_HTYPE_DIRPATH_CTX,
                         (dvoid *)&tblp->parallel_tbl,
                         (ub4)0, (ub4)OCI_ATTR_DIRPATH_PARALLEL,
                         ctlp->errhp_ctl));
  }

  if (tblp->nolog_tbl)                       /* set table level nolog option */
  {
    OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
              OCIAttrSet((dvoid *)dpctx, (ub4)OCI_HTYPE_DIRPATH_CTX,
                         (dvoid *)&tblp->nolog_tbl, (ub4)0,
                         (ub4)OCI_ATTR_DIRPATH_NOLOG, ctlp->errhp_ctl));
  }

  /* set number of columns to be loaded */
  OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
            OCIAttrSet((dvoid *)dpctx, (ub4)OCI_HTYPE_DIRPATH_CTX,
                       (dvoid *)&tblp->ncol_tbl,
                       (ub4)0, (ub4)OCI_ATTR_NUM_COLS, ctlp->errhp_ctl));


  /* get the column parameter list */
  OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
            OCIAttrGet((dvoid *)dpctx,
                       OCI_HTYPE_DIRPATH_CTX,
                       (dvoid *)&ctlp->colLstDesc_ctl, (ub4 *)0,
                       OCI_ATTR_LIST_COLUMNS, ctlp->errhp_ctl));

  /* get attributes of the column parameter list */
  OCI_CHECK(ctlp->errhp_ctl, OCI_HTYPE_ERROR, ociret, ctlp,
            OCIAttrGet((CONST dvoid *)ctlp->colLstDesc_ctl,