inf_cli.c

站长以前写的informix通用开发包源码

/* informix.ec
 * last update: 1999.02.27
 * by lgd/Paladin/蟑螂:[e-mail]
 */
#include <stdio.h>
#include <stdlib.h>

#include "informix.h"

#ifndef NO_LOG
void log_err_no_warning(char *);
#endif

int g_db_rc =0;  /* informix 返回的sql错误码 */
int db_bind_params(DB_BIND_DATA *pbind_data);

#ifndef GDB
#define GFB
HENV henv =NULL;
HDBC hdbc =NULL;
short collen[255];
short coltype[255];
#endif
/* db_login: 登录informix */
int db_login(char *dbname, char *user, char *pass)
{
   int ret;
   ret=SQLAllocEnv(&henv);
   if(ret!=SQL_SUCCESS&&ret !=SQL_SUCCESS_WITH_INFO)
   {
     db_err(NULL, "SQLAllocEnv");
     return -1;
   }
   ret=SQLAllocConnect(henv, &hdbc);
   if(ret!=SQL_SUCCESS&&ret !=SQL_SUCCESS_WITH_INFO)
   {
     db_err(NULL, "SQLAllocConnect");
     return -2;
   }
   ret = SQLConnect(hdbc, (UCHAR *)dbname, SQL_NTS, (UCHAR *)user, SQL_NTS, (UCHAR*)pass, SQL_NTS);
   if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO)
   {
     db_err(NULL, "SQLConnect");
     return -3;
   }
   set_lock(-1);
   return 0;
}

int set_lock(int timeout)
{
  char sqlstm[100];

  if(timeout <0)
    strcpy(sqlstm, "set lock mode to wait");
  /*else if(timeout ==0)
    strcpy(sqlstm, "set lock mode to no wait");*/
  else sprintf(sqlstm, "set lock mode to wait %d", timeout);
  
  if(db_exec_sql(sqlstm) <0)
  {
    printf(" !: db_exec_sql: set_lock failed! sqlstm:%s\n", sqlstm);
    return -1;
  }
  return 0;
}

/* db_logout:退出informix */
void db_logout()
{
  static int f_ok =0;

  if(f_ok ==1) return;
  if(hdbc)
  {
    SQLDisconnect(hdbc);
    SQLFreeConnect(hdbc);
  }
  if(henv) SQLFreeEnv(henv);
  f_ok =1;
}

int g_trans =0;
/* db_begin_trans: */
void db_begin_trans()
{
  if(g_trans ==1) return;
  g_trans =1;
  SQLSetConnectOption(hdbc,SQL_AUTOCOMMIT,SQL_AUTOCOMMIT_OFF);
}

void db_commit()
{
  if(g_trans ==0) return;
  g_trans =0;
  SQLTransact(henv,hdbc,SQL_COMMIT);
}

void db_rollback()
{
  if(g_trans ==0) return;
  g_trans =0;
  SQLTransact(henv,hdbc,SQL_ROLLBACK);
}

int db_exec_sql(char *stm)
{
  int ret =0;
  SDWORD num;
  HSTMT hstmt;

  ret=SQLAllocStmt(hdbc,&hstmt);
  if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO)
     return -1;
  ret=SQLExecDirect(hstmt,(UCHAR *)stm,SQL_NTS);
  if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO)
  {
    db_err(hstmt, "SQLExecDirect");
    SQLFreeStmt(hstmt,SQL_DROP);
printf("stm:%s\n", stm);
    return -1;
  }
  SQLRowCount(hstmt,&num);
  SQLFreeStmt(hstmt,SQL_DROP);
  return num;
}

int db_exec_sql_opt(char *stm, int opt)
{
  int ret =0;
  SDWORD num;
  HSTMT hstmt;

  if(opt ==SQL_OPT_GET_ROWID)
    opt =SQL_GET_ROWID;
  else if(opt ==SQL_OPT_GET_SERIAL)
    opt =SQL_GET_SERIAL_VALUE;
  else return -1;

  ret=SQLAllocStmt(hdbc,&hstmt);
  if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO)
     return -1;
  ret=SQLExecDirect(hstmt,(UCHAR *)stm,SQL_NTS);
  if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO)
  {
    db_err(hstmt, "SQLExecDirect");
    SQLFreeStmt(hstmt,SQL_DROP);
    return -1;
  }
  if((ret =SQLGetStmtOption(hstmt, opt, &num)) !=SQL_SUCCESS 
      && ret !=SQL_SUCCESS_WITH_INFO)
  {
    db_err(hstmt, "SQLGetStmtOption");
    SQLFreeStmt(hstmt, SQL_DROP);
    return -1;
  }
  SQLFreeStmt(hstmt,SQL_DROP);
  return num;
}

int db_get_count(char *sqlstm)
{
  int count;
  DB_SEL_DATA sel_data;
  
  memset(&sel_data, 0, sizeof(sel_data));
  strcpy(sel_data.sqlstm, sqlstm);
  if(db_sel_run(&sel_data) <0){db_sel_free(&sel_data); return -1;}
  if(db_sel_fetch(&sel_data) <=0){db_sel_free(&sel_data); return -2;}
  count =*(int *)sel_data.pbufs[0];
  db_sel_free(&sel_data);

  return count;
}

int db_select(DB_SEL_DATA *psel_data)
{
  int count =0, i;

  if(psel_data->buf_count <=0)
  {
    return -10;
  }
  for(i =0; i<psel_data->buf_count; i++)
    if(psel_data->bufs[i] ==NULL) return -11;

  if(db_sel_run(psel_data) <0)
  {
    db_sel_free(psel_data);
    return -1;
  }
  if(psel_data->col_count !=psel_data->buf_count)
  {
    db_sel_free(psel_data);
    return -12;
  }
  if((count =db_sel_fetch(psel_data)) <0)
  {
    db_sel_free(psel_data);
    return -2;
  }
  if(count ==0)
  {
    db_sel_free(psel_data);
    return 0;
  }
  for(i =0; i<psel_data->buf_count; i++)
    memcpy(psel_data->bufs[i], psel_data->pbufs[i], psel_data->col_defs[i].size+1);
  db_sel_free(psel_data);
  return 1;
}

int db_sel_run(DB_SEL_DATA *psel_data)
{
  if(db_sel_init(psel_data) <0)
    return -1;
  if(db_sel_exec(psel_data) <0)
    return -1;
  return 0;
}

int db_sel_init(DB_SEL_DATA *psel_data)
{
  int ret;
  
  if(psel_data ==NULL) return 0;

  psel_data->row_count =psel_data->col_count =0;
  psel_data->hstmt =NULL;
  ret=SQLAllocStmt(hdbc,&psel_data->hstmt);
  if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO)
     return -1;
  ret=SQLPrepare(psel_data->hstmt, (UCHAR *)psel_data->sqlstm,SQL_NTS);
  if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO)
  {
    db_err(psel_data->hstmt, "SQLPrepare");
printf(psel_data->sqlstm);
    return -2;
  }
  return 0;
}

int db_sel_exec(DB_SEL_DATA *psel_data)
{
  int ret, i, len;
  SWORD type;
  UDWORD size;
  SWORD msglen, namelen, scale, nullabel;
  char name[50], name1[50], temp[50];
  long ind =SQL_NTS;

  for(i =1; i<=psel_data->param_count; i++)
  {
    len =psel_data->param_defs[i-1].size;
    switch(psel_data->param_defs[i-1].type)
    {
    case SQLT_DATETIME:
    case SQLT_STR:
      ret =SQLBindParameter(psel_data->hstmt, i, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, len+1, 0, psel_data->pbufs_param[i-1], 0, &ind);
      break;
    case SQLT_FLT:
      ret =SQLBindParameter(psel_data->hstmt, i, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, len, 0, psel_data->pbufs_param[i-1], 0, 0);
      break;
    case SQLT_INT:
      ret =SQLBindParameter(psel_data->hstmt, i, SQL_PARAM_INPUT, SQL_C_LONG, SQL_DECIMAL, len, 0, psel_data->pbufs_param[i-1], 0, 0);
      break;
    default:
printf("invalid param type:%d\n", psel_data->param_defs[i-1].type);
      return -1;
    }
    if(ret !=SQL_SUCCESS && ret !=SQL_SUCCESS_WITH_INFO)
    {
printf("db_sel_init:SQLBindParameter failed! i=%d\n", i);
      db_err(psel_data->hstmt, "SQLBindParameter");
      return -1;
    }
  }
  SQLFreeStmt(psel_data->hstmt, SQL_CLOSE);
  ret=SQLExecute(psel_data->hstmt);
  if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO)
  {
    db_err(psel_data->hstmt, "SQLExecute");
    SQLFreeStmt(psel_data->hstmt, SQL_CLOSE);
    return -3;
  }
  ret=SQLNumResultCols(psel_data->hstmt,&psel_data->col_count);
  if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO)
  {
    SQLFreeStmt(psel_data->hstmt, SQL_CLOSE);
    return -4;
  }
  if((psel_data->pbufs =(char **)malloc(sizeof(char *)*psel_data->col_count)) ==NULL)
  {
    SQLFreeStmt(psel_data->hstmt, SQL_CLOSE);
#ifndef NO_LOG
    log_err_no_warning("sel: alloc pbufs failed!\n");
#endif
    return -5;
  }
  memset(psel_data->pbufs, 0, sizeof(char *)*psel_data->col_count);
  for(i =1; i<=psel_data->col_count; i++)
  {
    SQLDescribeCol(psel_data->hstmt, i, (PTR)name, sizeof(name), &namelen, (SWORD *)&type, (UDWORD *)&size, &scale, &nullabel);
    switch(type)
    {
    case SQL_DECIMAL:
      if(scale ==0 || scale ==255)
      {
        type =SQL_C_LONG;
        size =4;
      }
      else
      {
        type =SQL_C_DOUBLE;
        size =8;
      }
/*printf("sel_col:name:%s, type:%d, size:%d, scale:%d\n", name, type, size, scale);*/
      break;
    case SQL_CHAR:
    case SQL_VARCHAR:
      type =SQL_C_CHAR;
      size++;
      break;
    case SQL_DATE:
    case SQL_TIME:
    case SQL_TIMESTAMP:
      type =SQL_C_CHAR;
      size =20;
      break;
    default: break;
    }
    if((psel_data->pbufs[i-1] =(char *)malloc(size+1)) ==NULL)
    {
      printf("malloc size failed!\n");
      return -6;
    }
    memset(psel_data->pbufs[i-1], 0, size+1);
    ret =SQLBindCol(psel_data->hstmt, i, type, psel_data->pbufs[i-1], size, &psel_data->is_null[i-1]);