inf_cli.c

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

    if(ret !=SQL_SUCCESS && ret !=SQL_SUCCESS_WITH_INFO)
    {
      printf("SQLBindCol failed!, i=%d\n", i);
printf("%s\n", psel_data->sqlstm);
      db_err(psel_data->hstmt, "sel:SQLBindCol");
      SQLFreeStmt(psel_data->hstmt, SQL_CLOSE);
      return -7;
    }
    strcpy(psel_data->col_defs[i-1].name, name);
    psel_data->col_defs[i-1].type =type;
    psel_data->col_defs[i-1].size =size;
  }
  return 0;
}

void db_sel_free(DB_SEL_DATA *psel_data)
{
  int i;

  if(psel_data->hstmt !=NULL) SQLFreeStmt(psel_data->hstmt, SQL_DROP);
  if(psel_data->pbufs)
    for(i =0; i<psel_data->col_count; i++)
    {
      if(psel_data->pbufs[i]) free(psel_data->pbufs[i]);
    }
  psel_data->hstmt =NULL;
  psel_data->pbufs =NULL;
}

int db_sel_fetch(DB_SEL_DATA *psel_data)
{
  int ret;

  ret =SQLFetch(psel_data->hstmt);
  if(ret !=SQL_SUCCESS && ret !=SQL_SUCCESS_WITH_INFO)
  {
    if(ret ==SQL_NO_DATA_FOUND) return 0;
printf("db_sel_fetch failed! ret =%d\n", ret);
    db_err(psel_data->hstmt, "db_sel_fetch");
    return -1;
  }
  return 1;
}

int db_bind_init(DB_BIND_DATA *pbind_data)
{
  return db_bind_alloc(pbind_data);
}

int db_bind_alloc(DB_BIND_DATA *pbind_data)
{
  int i, j;

  if(pbind_data ==NULL || pbind_data->col_count <1 || pbind_data->row_count <1) return -1;
  pbind_data->hstmt =NULL;
  if((pbind_data->rows =(DB_ROW_DATA *)malloc(sizeof(DB_ROW_DATA)*(pbind_data->row_count+1))) ==NULL)
  {
#ifndef NO_LOG
    log_err_no_warning("db_bind_alloc: malloc rows failed!\n");
#endif
    return -1;
  }
  memset(pbind_data->rows, 0, sizeof(DB_ROW_DATA)*(pbind_data->row_count+1));
  for(i =0; i<pbind_data->row_count+1; i++)
  {
    if((pbind_data->rows[i].cols =(DB_COL_DATA *)malloc(sizeof(DB_COL_DATA)*pbind_data->col_count)) ==NULL)
    {
#ifndef NO_LOG
      log_err_no_warning("db_bind_alloc: malloc cols failed!\n");
#endif
      return -1;
    }
    memset(pbind_data->rows[i].cols, 0, sizeof(DB_COL_DATA)*pbind_data->col_count);
    for(j =0; j<pbind_data->col_count; j++)
    {
      if((pbind_data->rows[i].cols[j].pvalue =(char *)malloc(pbind_data->col_defs[j].size+1)) ==NULL)
      {
#ifndef NO_LOG
        log_err_no_warning("db_bind_alloc: malloc col pvalue failed!\n");
#endif
        db_bind_free(pbind_data);
        return -1;
      }
      memset(pbind_data->rows[i].cols[j].pvalue, 0, pbind_data->col_defs[j].size+1);
    }
  }
  if(db_bind_params(pbind_data) <0)
  {
    db_bind_free(pbind_data);
    return -1;
  }

  return 0;
}

int db_bind_params(DB_BIND_DATA *pbind_data)
{
  int i, ret, len;
  int col_count, row_count;
  char sqlstm[500]; 
  static long ind =SQL_NTS;

  if(pbind_data ==NULL || pbind_data->col_count <1 || pbind_data->row_count <1 || pbind_data->table_name[0] ==0) return -1;
  col_count =pbind_data->col_count;
  row_count =pbind_data->row_count;

  switch(pbind_data->type)
  {
  case BIND_TYPE_INSERT:
    sprintf(sqlstm, "insert into %s values(", pbind_data->table_name);
    for(i =0; i<col_count; i++)
    {
      if(i) strcat(sqlstm, ",");
      strcat(sqlstm, "?");
    }
    strcat(sqlstm, ")");
    break;
  case BIND_TYPE_UPDATE:
    sprintf(sqlstm, "update %s set ", pbind_data->table_name);
    for(i =0; i<col_count-1; i++)
    {
      if(i) strcat(sqlstm, ",");
      strcat(sqlstm, pbind_data->col_defs[i].name);
      strcat(sqlstm, "=");
      strcat(sqlstm, "?");
    }
    strcat(sqlstm, " where rowid=?");
/*printf("inf_cli.c:sqlstm =%s\n", sqlstm);*/
    break;
  case BIND_TYPE_SQLSTM:
    strcpy(sqlstm, pbind_data->table_name);
    break;
  default:
     printf("bind type invalid\n");
     return -1;
  }

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

  for(i =1; i <=col_count; i++)
  {
    len =pbind_data->col_defs[i-1].size;
    switch(pbind_data->col_defs[i-1].type)
    {
    case SQLT_DATETIME:
    case SQLT_STR:
      ret =SQLBindParameter(pbind_data->hstmt, i, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, len+1, 0, pbind_data->rows[row_count].cols[i-1].pvalue, 0, &ind);
      break;
    case SQLT_FLT: /* 00000 */
      ret =SQLBindParameter(pbind_data->hstmt, i, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, len, 0, pbind_data->rows[row_count].cols[i-1].pvalue, 0, 0);
      break;
    case SQLT_INT:
      ret =SQLBindParameter(pbind_data->hstmt, i, SQL_PARAM_INPUT, SQL_C_LONG, SQL_DECIMAL, len, 0, pbind_data->rows[row_count].cols[i-1].pvalue, 0, 0);
      break;
    default:
      return -1;
    }
    if(ret !=SQL_SUCCESS && ret !=SQL_SUCCESS_WITH_INFO)
    {
/*printf("SQLBindCol failed! i=%d\n", i);*/
      db_err(pbind_data->hstmt, "SQLBindCol");
      pbind_data->rows[i].rc = g_db_rc;
      return -1;
    }
    else pbind_data->rows[i].rc =0;
  }
  return 0;
}

void db_bind_free(DB_BIND_DATA *pbind_data)
{
  int i, j;


  if(pbind_data ==NULL || pbind_data->rows ==NULL) return;

  for(i =0; i<pbind_data->row_count+1; i++)
  {
    if(pbind_data->rows[i].cols ==NULL) break;
    for(j =0; j<pbind_data->col_count; j++)
    {
      if(pbind_data->rows[i].cols[j].pvalue !=NULL)
      {
        free(pbind_data->rows[i].cols[j].pvalue);
        pbind_data->rows[i].cols[j].pvalue =NULL;
      }
    }
    free(pbind_data->rows[i].cols);
    pbind_data->rows[i].cols =NULL;
  }
  free(pbind_data->rows);
  pbind_data->rows =NULL;
  if(pbind_data->hstmt) SQLFreeStmt(pbind_data->hstmt, SQL_DROP);
  pbind_data->hstmt =NULL;
}

int db_bind_exec(DB_BIND_DATA *pbind_data, int count, int f_err_continue)
{
  int i, j, success_count =0, ret, col_count, row_count;

  if(pbind_data ==NULL) return -1;
  if(count > pbind_data->row_count) count =pbind_data->row_count;
  col_count =pbind_data->col_count;
  row_count =pbind_data->row_count;
  for(i =0; i<count; i++)
  {
    for(j =0; j<col_count; j++)
    {
      memcpy(pbind_data->rows[row_count].cols[j].pvalue, pbind_data->rows[i].cols[j].pvalue, pbind_data->col_defs[j].size);
    }
    ret =SQLExecute(pbind_data->hstmt);
    if(ret !=SQL_SUCCESS && ret !=SQL_SUCCESS_WITH_INFO)
    {
      db_err(pbind_data->hstmt, "SQLExecute");
      pbind_data->rows[i].rc = g_db_rc;
printf("i =%d, rc=%d, col_count =%d\n", i, g_db_rc, col_count);
      if(g_db_rc ==DB_ERR_LOCK)
         return DB_ERR_LOCK;
      if(!f_err_continue) break;
    } 
    else
    {
      success_count++;
      pbind_data->rows[i].rc =0;
    }
  }

  return success_count;
}

int db_rpc(DB_RPC_DATA *prpc_data)
{
  char sqlstm[256];
  int i, ret, len;
  long is_null;
  SWORD btype;

  sprintf(sqlstm, "execute procedure %s(", prpc_data->name);
  for(i =0; i<prpc_data->param_count; i++)
  {
    if(i)
      strcat(sqlstm, ",?");
    else strcat(sqlstm, "?");
  }
  strcat(sqlstm, ")");
  ret=SQLAllocStmt(hdbc,&prpc_data->hstmt);
  if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO)
    return -1;
  ret=SQLPrepare(prpc_data->hstmt, (UCHAR *)sqlstm,SQL_NTS);
  if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO)
  {
printf(sqlstm);
    db_err(prpc_data->hstmt, "db_rpc:SQLPrepare");
    SQLFreeStmt(prpc_data->hstmt, SQL_DROP);
    return -1;
  }

  for(i =1; i <=prpc_data->param_count; i++)
  {
    len =prpc_data->col_defs[i-1].size;
    if(prpc_data->col_defs[i-1].f_output)
      btype =SQL_PARAM_OUTPUT;
    else btype =SQL_PARAM_INPUT;
    switch(prpc_data->col_defs[i-1].type)
    {
    case SQLT_DATETIME:
    case SQLT_STR:
        ret =SQLBindParameter(prpc_data->hstmt, i, btype, SQL_C_CHAR, SQL_CHAR, len+1, 0, prpc_data->params[i-1], 0, 0);
      break;
    case SQLT_FLT:
      ret =SQLBindParameter(prpc_data->hstmt, i, btype, SQL_C_DOUBLE, SQL_DOUBLE, len, 0, prpc_data->params[i-1], 0, 0);
      break;
    case SQLT_INT:
      ret =SQLBindParameter(prpc_data->hstmt, i, btype, SQL_C_LONG, SQL_DECIMAL, len, 0, prpc_data->params[i-1], 0, 0);
      break;
    default:
      SQLFreeStmt(prpc_data->hstmt, SQL_DROP);
      return -1;
    }
    if(ret !=SQL_SUCCESS && ret !=SQL_SUCCESS_WITH_INFO)
    {
      db_err(prpc_data->hstmt, "db_rpc:SQLBindParameter");
      SQLFreeStmt(prpc_data->hstmt, SQL_DROP);
      return g_db_rc;
    }
  }
  ret =SQLExecute(prpc_data->hstmt);
  if(ret !=SQL_SUCCESS && ret !=SQL_SUCCESS_WITH_INFO)
  {
    db_err(prpc_data->hstmt, "db_rpc: SQLExecute failed!");
    SQLFreeStmt(prpc_data->hstmt, SQL_DROP);
    return -1;
  }
  if(SQLBindCol(prpc_data->hstmt, 1, SQL_C_LONG, &prpc_data->ret, sizeof(int), &is_null) <0)
  {
    db_err(prpc_data->hstmt, "db_rpc: SQLBindCol failed!");
    SQLFreeStmt(prpc_data->hstmt, SQL_DROP);
    return -1;
  }
  prpc_data->ret =0;
  ret =SQLFetch(prpc_data->hstmt);
  if(ret !=SQL_SUCCESS && ret !=SQL_SUCCESS_WITH_INFO)
  {
    if(ret ==SQL_NO_DATA_FOUND) return 0;
    db_err(prpc_data->hstmt, "db_rpc: SQLFetch failed!");
    SQLFreeStmt(prpc_data->hstmt, SQL_DROP);
    return -1;
  }
  SQLFreeStmt(prpc_data->hstmt, SQL_DROP);
  
  return 0;
}

void db_err(HSTMT hstmt, char *pre)
{
  SWORD pcbErrMsgLen =0;
  SDWORD sqlcode =0;
  char SqlState[6];
  char ErrMsg[200], temp[256];

  SQLError(henv, hdbc, hstmt, (UCHAR *)SqlState, &sqlcode, (UCHAR *)ErrMsg, sizeof(ErrMsg), &pcbErrMsgLen);
  sprintf(temp, "db_err-%s:%d,%s, %s\n", pre, sqlcode, SqlState, ErrMsg);
#ifndef NO_LOG
  log_err_no_warning(temp);
#endif
  g_db_rc =sqlcode;
}