nfxcsr.ec

封装了数据库的基本操作

/*****************************************************************************/
/*                   Database Public Function For Informix                   */
/* ------------------------------------------------------------------------- */
/*  Author : Shih Ho                                                         */
/*  Date   : March 27, 1998                                                  */
/*****************************************************************************/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <memory.h>
$include sqlca.h;
$include "dblib.h";
$include "nfxprv.h";

/*===========================================================================*/
/* Data Type Definition                                                      */
/*---------------------------------------------------------------------------*/
EXEC SQL BEGIN DECLARE SECTION;
typedef struct{
  int Type;
  char *Table;
  char *CntCmd;
  char *ExeCmd;
  long Order;
  long FldCnt;
} DBCSR;
EXEC SQL END DECLARE SECTION;

/*===========================================================================*/
/* Data Area                                                                 */
/*---------------------------------------------------------------------------*/
EXEC SQL BEGIN DECLARE SECTION;
static char CntName[16];
static char DatName[16];
static char ExeName[16];
static char CsrName[16];
static char OprName[16];
EXEC SQL END DECLARE SECTION;

/*===========================================================================*/
/* Local Funciton - SetDatName                                               */
/*---------------------------------------------------------------------------*/
static void SetDatName( DBCSR *TmpCsr )
{
  sprintf( DatName, "DAT%08ld", TmpCsr->Order );
}

/*===========================================================================*/
/* Local Funciton - SetCntName                                               */
/*---------------------------------------------------------------------------*/
static void SetCntName( DBCSR *TmpCsr )
{
  sprintf( CntName, "CNT%08ld", TmpCsr->Order );
}

/*===========================================================================*/
/* Local Funciton - SetExeName                                               */
/*---------------------------------------------------------------------------*/
static void SetExeName( DBCSR *TmpCsr )
{
  sprintf( ExeName, "EXE%08ld", TmpCsr->Order );
}

/*===========================================================================*/
/* Local Funciton - SetCsrName                                               */
/*---------------------------------------------------------------------------*/
static void SetCsrName( DBCSR *TmpCsr )
{
  sprintf( CsrName, "CSR%08ld", TmpCsr->Order );
}

/*===========================================================================*/
/* Local Funciton - SetOprName                                               */
/*---------------------------------------------------------------------------*/
static void SetOprName( DBCSR *TmpCsr )
{
  sprintf( OprName, "OPR%08ld", TmpCsr->Order );
}

/*===========================================================================*/
/* Public Funciton - DBCopen                                                 */
/*---------------------------------------------------------------------------*/
int DBCopen( Cursor, Type, Table, Condition )
DBCURSOR *Cursor;
int Type;
char *Table;
char *Condition;
{
  int r = -1;
  int lt;
  int lc;
  int ls;
  EXEC SQL BEGIN DECLARE SECTION;
  long fc;
  DBCSR *TmpCsr;
  EXEC SQL END DECLARE SECTION;

  if( Table != NULL ){
    lt = strlen( Table );
    if( ( TmpCsr = ( DBCSR * ) malloc( sizeof( DBCSR ) ) ) == NULL )
      r = -2;
    else{
      TmpCsr->Type = Type;
      TmpCsr->Order = GetSequence();
      if( ( TmpCsr->Table = strdup( Table ) ) != NULL ){
        if( ( TmpCsr->CntCmd = ( char * ) malloc( 180 ) ) != NULL ){
          sprintf( TmpCsr->CntCmd, "SELECT * FROM %s", Table );
          SetCntName( TmpCsr );
          if( ( fc = GetFieldCount( TmpCsr->CntCmd, CntName ) ) > 0 ){
            TmpCsr->FldCnt = fc;
            ls = 2 * TmpCsr->FldCnt - 1;
            if( Condition == NULL )
              lc = 0;
            else
              lc = strlen( Condition ) + 7;
            switch( Type ){
            case DBCT_INPUT:
              if( ( TmpCsr->ExeCmd = ( char * ) malloc( 180 ) )
                  != NULL ){
                if( lc == 0 )
                  sprintf( TmpCsr->ExeCmd, "SELECT * FROM %s", Table );
                else
                  sprintf( TmpCsr->ExeCmd, "SELECT * FROM %s WHERE %s",
                      Table, Condition );
              }
              break;
            case DBCT_OUTPUT:
              if( ( TmpCsr->ExeCmd = ( char * ) malloc( 180 ) )
                  != NULL ){
                sprintf( TmpCsr->ExeCmd, "INSERT INTO %s VALUES (%*s)",
                    Table, ls, "" );
                SetFieldList( TmpCsr->ExeCmd + lt + 21, TmpCsr->FldCnt );
              }
              break;
            case DBCT_INOUT:
              if( ( TmpCsr->ExeCmd = ( char * ) malloc( 180 ) )
                  != NULL ){
                if( lc == 0 )
                  sprintf( TmpCsr->ExeCmd,
                      "SELECT * FROM %s FOR UPDATE", Table );
                else
                  sprintf( TmpCsr->ExeCmd,
                      "SELECT * FROM %s WHERE %s FOR UPDATE",
                      Table, Condition );
              }
              break;
            default:
              TmpCsr->ExeCmd = NULL;
            }
            if( TmpCsr->ExeCmd != NULL ){
              SetDatName( TmpCsr );
              EXEC SQL ALLOCATE DESCRIPTOR :DatName WITH MAX :fc;
              if( ( r = sqlca.sqlcode ) == SQLOK ){
                EXEC SQL DESCRIBE :CntName USING SQL DESCRIPTOR :DatName;
                if( ( r = sqlca.sqlcode ) == SQLOK ){
                  SetExeName( TmpCsr );
                  EXEC SQL PREPARE :ExeName FROM :TmpCsr->ExeCmd;
                  if( ( r = sqlca.sqlcode ) == SQLOK ){
                    SetCsrName( TmpCsr );
                    EXEC SQL DECLARE :CsrName CURSOR FOR :ExeName;
                    if( ( r = sqlca.sqlcode ) == SQLOK ){
                      EXEC SQL OPEN :CsrName;
                      if( ( r = sqlca.sqlcode ) == SQLOK ){
                        *Cursor = ( DBCURSOR ) TmpCsr;
                        return( 0 );
                      }
                      EXEC SQL FREE :CsrName;
                    }
                    EXEC SQL FREE :ExeName;
                  }
                }
                EXEC SQL DEALLOCATE DESCRIPTOR :DatName;
              }
              free( TmpCsr->ExeCmd );
            }
            EXEC SQL FREE :CntName;
          }
          free( TmpCsr->CntCmd );
        }
        free( TmpCsr->Table );
      }
      free( TmpCsr );
    }
  }
  return( r );
}

/*===========================================================================*/
/* Public Funciton - DBCclose                                                */
/*---------------------------------------------------------------------------*/
int DBCclose( Cursor )
DBCURSOR Cursor;
{
  DBCSR *TmpCsr;

  if( Cursor == NULL )
    return( -1 );
  TmpCsr = ( DBCSR * ) Cursor;
  SetCsrName( TmpCsr );
  EXEC SQL CLOSE :CsrName;
  EXEC SQL FREE :CsrName;
  SetExeName( TmpCsr );
  EXEC SQL FREE :ExeName;
  SetDatName( TmpCsr );
  EXEC SQL DEALLOCATE DESCRIPTOR :DatName;
  free( TmpCsr->ExeCmd );
  SetCntName( TmpCsr );
  EXEC SQL FREE :CntName;
  free( TmpCsr->CntCmd );
  free( TmpCsr->Table );
  free( TmpCsr );
  return( 0 );
}

/*===========================================================================*/
/* Public Funciton - DBCget                                                  */
/*---------------------------------------------------------------------------*/
int DBCget( Cursor, Buffer )
DBCURSOR Cursor;
char *Buffer;
{
  int r = -1;
  DBCSR *TmpCsr = ( DBCSR * ) Cursor;

  if( Buffer != NULL && Cursor != NULL
      && ( TmpCsr->Type == DBCT_INPUT || TmpCsr->Type == DBCT_INOUT ) ){
    SetCsrName( TmpCsr );
    SetDatName( TmpCsr );
    EXEC SQL FETCH :CsrName USING SQL DESCRIPTOR :DatName;
    if( ( r = sqlca.sqlcode ) == SQLOK ){
      r = GetDataBuffer( DatName, Buffer );
    }
  }
  return( r );
}

/*===========================================================================*/
/* Public Funciton - DBCput                                                  */
/*---------------------------------------------------------------------------*/
int DBCput( Cursor, Buffer )
DBCURSOR Cursor;
char *Buffer;
{
  int r = -1;
  DBCSR *TmpCsr = ( DBCSR * ) Cursor;
  EXEC SQL BEGIN DECLARE SECTION;
  char *TmpCmd;
  EXEC SQL END DECLARE SECTION;

  if( Buffer == NULL && Cursor != NULL && TmpCsr->Type == DBCT_INOUT ){
    SetCsrName( TmpCsr );
    if( ( TmpCmd = ( char * ) malloc( 180 ) ) == NULL )
      r = -2;
    else{
      sprintf( TmpCmd, "DELETE FROM %s WHERE CURRENT OF %s",
          TmpCsr->Table, CsrName );
      SetOprName( TmpCsr );
      EXEC SQL PREPARE :OprName FROM :TmpCmd;
      if( ( r = sqlca.sqlcode ) == SQLOK ){
        EXEC SQL EXECUTE :OprName;
        r = sqlca.sqlcode;
        EXEC SQL FREE :OprName;
      }
      free( TmpCmd );
    }
  }
  else if( Buffer != NULL && Cursor != NULL && TmpCsr->Type == DBCT_INOUT ){
    SetCsrName( TmpCsr );
    if( ( TmpCmd = ( char * ) malloc( 180 ) ) == NULL )
      r = -2;
    else{
      sprintf( TmpCmd, "UPDATE %s SET *=(%*s) WHERE CURRENT OF %s",
          TmpCsr->Table, 2 * TmpCsr->FldCnt - 1, "", CsrName );
      SetFieldList( TmpCmd + strlen( TmpCsr->Table ) + 15, TmpCsr->FldCnt );
      SetOprName( TmpCsr );
      EXEC SQL PREPARE :OprName FROM :TmpCmd;
      if( ( r = sqlca.sqlcode ) == SQLOK ){
        SetDatName( TmpCsr );
        if( ( r = PutDataBuffer( DatName, Buffer ) ) == 0 ){
          EXEC SQL EXECUTE :OprName USING SQL DESCRIPTOR :DatName;
          r = sqlca.sqlcode;
        }
        EXEC SQL FREE :OprName;
      }
      free( TmpCmd );
    }
  }
  else if( Buffer != NULL && Cursor != NULL && TmpCsr->Type == DBCT_OUTPUT ){
    SetDatName( TmpCsr );
    if( ( r = PutDataBuffer( DatName, Buffer ) ) == 0 ){
      SetCsrName( TmpCsr );
      EXEC SQL PUT :CsrName USING SQL DESCRIPTOR :DatName;
      r = sqlca.sqlcode;
    }
  }
  return( r );
}

/*===========================================================================*/
/* Public Funciton - DBCflush                                                */
/*---------------------------------------------------------------------------*/
int DBCflush( Cursor )
DBCURSOR Cursor;
{
  int r=SQLOK;
  DBCSR *TmpCsr = ( DBCSR * ) Cursor;

  if( Cursor != NULL && TmpCsr->Type == DBCT_OUTPUT ){
    SetCsrName( TmpCsr );
    EXEC SQL FLUSH :CsrName;
    r = sqlca.sqlcode;
  }
  return( r );
}

/*****************************************************************************/