db.pc

一本介绍oracle的书籍

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <math.h>
#include <time.h>

#include "sqlca.h"
#include "sqlda.h"

#include "const.h"

static char *connect="dbuser/oracle";


int random_int(int min_val, int max_val)
{
    struct timeval uTime;
    int  delta_val;
    int  ret_val;

    gettimeofday(&uTime, NULL);
    srand(uTime.tv_usec);
    delta_val=max_val-min_val+1;
    ret_val=(rand())%delta_val+min_val;

    return ret_val;
}


int trim_space(char *str)
{
    int stringlen, i;

    if(str!=NULL)
    {
        stringlen=strlen(str);
        for(i=stringlen-1; i>=0; i--)
            if(str[i]!=' ')  break;
        str[i+1]='\0';
        if(str[0]=='\0')  strcpy(str, " ");
        return 0;
    }
    return -1;
}


int DbsConnect()
{
    EXEC SQL connect :connect;
    return(sqlca.sqlcode);
}


int DbsCHARGE_FEE_CUR_BBJoin(int func, charge_fee_t *pChargeFee,
    charge_fee_dtl_t *pChargeFeeDtl)
{
    switch(func)
    {
      case DBS_OPEN:
        EXEC SQL declare cf_bbjoin_cur cursor for
          select a.fee_id,
                 b.fee_type,
                 b.fee_at
            from charge_fee a, charge_fee_dtl b
            where a.status=:pChargeFee->status
              and a.user_nm=:pChargeFee->user_nm
              and a.fee_id=b.fee_id
            order by a.fee_id asc, b.fee_type asc
            ;
        EXEC SQL open cf_bbjoin_cur;
        SQL_CODE_PROCESS("CHARGE_FEE", "OPN");

      case DBS_FETCH:
        EXEC SQL fetch cf_bbjoin_cur
                   into :pChargeFeeDtl->fee_id,
                        :pChargeFeeDtl->fee_type,
                        :pChargeFeeDtl->fee_at
                   ;
        SQL_CODE_PROCESS("CHARGE_FEE", "FET");

      case DBS_CLOSE:
        EXEC SQL close cf_bbjoin_cur;
        SQL_CODE_PROCESS("CHARGE_FEE", "CLS");

      default:
        return(DB_DBSFUNCERR);
    }
}


int DbsCHARGE_FEE_CUR_BBNoJoin(int func, charge_fee_t *pChargeFee)
{
    switch(func)
    {
      case DBS_OPEN:
        EXEC SQL declare cf_bbnojoin_cur cursor for
          select fee_id
            from charge_fee
            where status=:pChargeFee->status
              and user_nm=:pChargeFee->user_nm
            order by fee_id asc
            ;
        EXEC SQL open cf_bbnojoin_cur;
        SQL_CODE_PROCESS("CHARGE_FEE", "OPN");

      case DBS_FETCH:
        EXEC SQL fetch cf_bbnojoin_cur
                   into :pChargeFee->fee_id
                   ;
        SQL_CODE_PROCESS("CHARGE_FEE", "FET");

      case DBS_CLOSE:
        EXEC SQL close cf_bbnojoin_cur;
        SQL_CODE_PROCESS("CHARGE_FEE", "CLS");

      default:
        return(DB_DBSFUNCERR);
    }
}


int DbsCHARGE_FEE_DTL_CUR_BBNoJoin(int func,
    charge_fee_dtl_t *pChargeFeeDtl)
{
    switch(func)
    {
      case DBS_OPEN:
        EXEC SQL declare cfd_bbnojoin_cur cursor for
          select *
            from charge_fee_dtl
            where fee_id=:pChargeFeeDtl->fee_id
            order by fee_type asc
            ;
        EXEC SQL open cfd_bbnojoin_cur;
        SQL_CODE_PROCESS("CHARGE_FEE_DTL", "OPN");

      case DBS_FETCH:
        EXEC SQL fetch cfd_bbnojoin_cur
                   into :pChargeFeeDtl
                   ;
        SQL_CODE_PROCESS("CHARGE_FEE_DTL", "FET");

      case DBS_CLOSE:
        EXEC SQL close cfd_bbnojoin_cur;
        SQL_CODE_PROCESS("CHARGE_FEE_DTL", "CLS");

      default:
        return(DB_DBSFUNCERR);
    }
}


int DbsCHARGE_FEE_DTL_CUR_BSJoin(int func,
    charge_fee_dtl_t *pChargeFeeDtl, charge_fee_cfg_t *pChargeFeeCfg)
{
    switch(func)
    {
      case DBS_OPEN:
        EXEC SQL declare cfd_bsjoin_cur cursor for
          select a.fee_type, a.fee_at, b.fee_nm 
            from charge_fee_dtl a, charge_fee_cfg b
            where fee_id=:pChargeFeeDtl->fee_id
              and a.fee_type=b.fee_type
            order by a.fee_type asc
            ;
        EXEC SQL open cfd_bsjoin_cur;
        SQL_CODE_PROCESS("CHARGE_FEE_DTL", "OPN");

      case DBS_FETCH:
        EXEC SQL fetch cfd_bsjoin_cur
                   into :pChargeFeeDtl->fee_type,
                        :pChargeFeeDtl->fee_at,
                        :pChargeFeeCfg->fee_nm
                   ;
        SQL_CODE_PROCESS("CHARGE_FEE_DTL", "FET");

      case DBS_CLOSE:
        EXEC SQL close cfd_bsjoin_cur;
        SQL_CODE_PROCESS("CHARGE_FEE_DTL", "CLS");

      default:
        return(DB_DBSFUNCERR);
    }
}


int DbsCHARGE_FEE_DTL_CUR_BSNoJoin(int func,
    charge_fee_dtl_t *pChargeFeeDtl)
{
    switch(func)
    {
      case DBS_OPEN:
        EXEC SQL declare cfd_bsnojoin_cur cursor for
          select fee_type,
                 fee_at
            from charge_fee_dtl
            where fee_id=:pChargeFeeDtl->fee_id
            order by fee_type asc
            ;
        EXEC SQL open cfd_bsnojoin_cur;
        SQL_CODE_PROCESS("CHARGE_FEE_DTL", "OPN");

      case DBS_FETCH:
        EXEC SQL fetch cfd_bsnojoin_cur
                   into :pChargeFeeDtl->fee_type,
                        :pChargeFeeDtl->fee_at
                   ;
        SQL_CODE_PROCESS("CHARGE_FEE_DTL", "FET");

      case DBS_CLOSE:
        EXEC SQL close cfd_bsnojoin_cur;
        SQL_CODE_PROCESS("CHARGE_FEE_DTL", "CLS");

      default:
        return(DB_DBSFUNCERR);
    }
}


int DbsCHARGE_FEE_DTL_CUR_BSNoJoinDyna(int func,
    charge_fee_dtl_t *pChargeFeeDtl, char *sql)
{
    switch(func)
    {
      case DBS_OPEN:
        EXEC SQL prepare cfd_bsnjdyna_stmt from :sql;
        if(sqlca.sqlcode)
        {   SQL_CODE_PROCESS("CHARGE_FEE_DTL", "PRE");   }
        EXEC SQL declare cfd_bsnjdyna_cur cursor for
                   cfd_bsnjdyna_stmt;
        EXEC SQL open cfd_bsnjdyna_cur;
        SQL_CODE_PROCESS("CHARGE_FEE_DTL", "OPN");

      case DBS_FETCH:
        EXEC SQL fetch cfd_bsnjdyna_cur
                   into :pChargeFeeDtl->fee_type,
                        :pChargeFeeDtl->fee_at
                   ;
        SQL_CODE_PROCESS("CHARGE_FEE_DTL", "FET");

      case DBS_CLOSE:
        EXEC SQL close cfd_bsnjdyna_cur;
        SQL_CODE_PROCESS("CHARGE_FEE_DTL", "CLS");

      default:
        return(DB_DBSFUNCERR);
    }
}


int DbsCHARGE_FEE_CFG_CUR_List(int func,
    charge_fee_cfg_t *pChargeFeeCfg)
{
    switch(func)
    {
      case DBS_OPEN:
        EXEC SQL declare cfc_list_cur cursor for
          select *
            from charge_fee_cfg
            order by fee_type asc
            ;
        EXEC SQL open cfc_list_cur;
        SQL_CODE_PROCESS("CHARGE_FEE_CFG", "OPN");

      case DBS_FETCH:
        EXEC SQL fetch cfc_list_cur
                   into :pChargeFeeCfg
                   ;
        SQL_CODE_PROCESS("CHARGE_FEE_CFG", "FET");

      case DBS_CLOSE:
        EXEC SQL close cfc_list_cur;
        SQL_CODE_PROCESS("CHARGE_FEE_CFG", "CLS");

      default:
        return(DB_DBSFUNCERR);
    }
}