weixin_34206899

Linux下使用C/C++访问数据库——Oracle之OCI篇

一、什么是OCI？

开发基于Oracle数据库的应用程序，我们可以选择多种工具，不仅可以用一般的数据库开发技术，诸如ADO（ActiveX Data Objects）、ODBC（Open DataBase Connectivity）等等，同时，也可以用Oracle公司提供的专门的开发工具，诸如Pro C_C++，OCI（Oracle Call Intedace）等等。比较这几种方式，前者因为是通用技术，开发起来比较容易，但是有一个致命的弱点就是诸如ADO之类的通用技术的速度太慢，如果我们要开发管理海量数据的数据库，比如影像数据库，那么，这种速度我们是不能忍受的。而OCI虽然开发起来难度大一些，但是它的速度极快，而且是一种底层接口，几乎可以操纵Oracle数据库的任何对象。

二、OCI简介

OCI(Oracle Call Intedace，即0racle调用层接口)是Oracle公司提供的由头文件和库函数等组成的一个访问Oracle数据库的应用程序编程接口（application programming interface API），它允许开发人员在第三代编程语言（包括C, C++, COBOL 与 FORTRAN）中通过SQL（Structure Query Language）来操纵Oracle数据库，而且OCI在一定程度上支持第三代编程语言（诸如C, C++, COBOL 与 FORTRAN）的数据类型、语法等等。OCI的显著特点是全面支持Oracle的面向对象技术，同时OCI还具有如下的一些特点：

1)非常有利于应用程序的设计；

2)高度控制应用程序的执行；

3)允许开发人员应用已熟悉的第三代程序设计语言来应用OCI；

4)支持动态SQL；

5)几乎所有的Oracle的开发工具都支持OCI；

6)通过回调技术（callbacks）来实现动态绑定与定义；

7)通过OCI的描述函数可以获取Oracle数据库的各种参数；

8)增强了数组在DML(data manipulation language)语言中的应用；

OCI接口支持Windows NT和Windows 95／98/2000/XP操作系统，它所支持的C语言编译器包括Borland C++和MiroSoft VisualC++等。在使用0CI开发Oralce数据库应用程序之前，应首先安装这些操作系统和C语言编译工具。在选择安装OCI开发工具包后，Oracle安装程序将0CI文件拷贝到oracle主目录内的以下子目录中：

..BIN\：执行文件和帮助文件：

..\OCIINCLUDE头文件；

三、开发前的注意事项

首先，为了防止某些动态链接库出问题，建议在安装了Oracle客户端的机器上进行开发、运行。

其次，使用OCI开发的程序，需要使用Oracle客户端的tnsnames.ora这个配置文件，所以在开发前需要使用netca来配置好相关内容。

第三，Linux下的系统环境变量需要设置好。需要设置的环境变量包括ORACLE_HOME、ORACLE_SID、TNS_ADMIN，其中TNS_ADMIN指定到tnsnames.ora所在的文件夹。

四、程序开发：

还是直接用代码说话吧

/*
* Common.h
*
*    Created .: Mar 1, 2009
*            Author: Steven Wee
*/

#ifndef COMMON_H_
#define COMMON_H_

#include
#include
#include

#include
#include
#include

#include

using namespace std;

#endif /* COMMON_H_ */

/*
* Exception.h
*
*    Created .: Mar 1, 2009
*            Author: Steven Wee
*/

#ifndef EXCEPTION_H_
#define EXCEPTION_H_

class Exception
{
public:
  Exception(int errno);
  virtual char * GetErrMsg() = 0;
  virtual char * GetErrFunc() = 0;
  virtual int GetErrNo() = 0;
protected:
  int m_iErrNo;
  char m_sErrBuff[512];
  char m_sErrFunc[128];
};

#endif /* EXCEPTION_H_ */

/*
* Exception.cpp
*
*    Created .: Mar 1, 2009
*            Author: Steven Wee
*/
#include "Exception.h"

Exception::Exception(int errno)
{
  this ->m_iErrNo = errno;
  this ->m_sErrBuff[0] = 0;
  this ->m_sErrFunc[0] = 0;
}

/*
* OCIException.h
*
*    Created .: Mar 1, 2009
*            Author: Steven Wee
*/

#ifndef OCIEXCEPTION_H_
#define OCIEXCEPTION_H_

#include "Common.h"
#include "Exception.h"

class OCIException : public Exception
{
public:
  OCIException(sb4 errno);
  OCIException(sb4 errno, char * errfunc);
  OCIException(sb4 errno, dvoid * erroci);
  OCIException(sb4 errno, dvoid * erroci, char * errfunc);

  char * GetErrMsg();
  char * GetErrFunc();
  int GetErrNo();
private:
  void CheckError(sb4 errno);
  void CheckError(sb4 errno, dvoid * erroci);
};

#endif /* OCIEXCEPTION_H_ */

/*
* OCIException.cpp
*
*    Created .: Mar 1, 2009
*            Author: Steven Wee
*/
#include "OCIException.h"

void OCIException::CheckError(sb4 errno)
{
  text errBuff[512];
  switch ( errno )
  {
  case OCI_SUCCESS:
    break;
  case OCI_SUCCESS_WITH_INFO:
    sprintf( this ->m_sErrBuff, "OCI_SUCCESS_WITH_INFO" );
    break;
  case OCI_NEED_DATA:
    sprintf( this ->m_sErrBuff, "OCI_NEED_DATA" );
    break;
  case OCI_NO_DATA:
    sprintf( this ->m_sErrBuff, "OCI_NO_DATA" );
    break;
  case OCI_ERROR:
    sprintf( this ->m_sErrBuff, "OCI_ERROR" );
    break;
  case OCI_INVALID_HANDLE:
    sprintf( this ->m_sErrBuff, "OCI_INVALID_HANDLE" );
    break;
  case OCI_STILL_EXECUTING:
    sprintf( this ->m_sErrBuff, "OCI_STILL_EXCUTING" );
    break;
  case OCI_CONTINUE:
    sprintf( this ->m_sErrBuff, "OCI_CONTINUE" );
    break;
  default:
    break;
  }
}

void OCIException::CheckError(sb4 errno, dvoid * erroci)
{
  text errBuff[512];
  switch ( errno )
  {
  case OCI_SUCCESS:
    break;
  case OCI_SUCCESS_WITH_INFO:
    sprintf( this ->m_sErrBuff, "OCI_SUCCESS_WITH_INFO" );
    break;
  case OCI_NEED_DATA:
    sprintf( this ->m_sErrBuff, "OCI_NEED_DATA" );
    break;
  case OCI_NO_DATA:
    sprintf( this ->m_sErrBuff, "OCI_NO_DATA" );
    break;
  case OCI_ERROR:
    OCIErrorGet( (dvoid*)erroci, (ub4)1, (text*)NULL, &this ->m_iErrNo, errBuff, (ub4)sizeof(errBuff), OCI_HTYPE_ERROR);
    sprintf( this ->m_sErrBuff, "%.*s", strlen((char*) errBuff) - 1, errBuff);
    break;
  case OCI_INVALID_HANDLE:
    sprintf( this ->m_sErrBuff, "OCI_INVALID_HANDLE" );
    break;
  case OCI_STILL_EXECUTING:
    sprintf( this ->m_sErrBuff, "OCI_STILL_EXCUTING" );
    break;
  case OCI_CONTINUE:
    sprintf( this ->m_sErrBuff, "OCI_CONTINUE" );
    break;
  default:
    break;
  }
}

OCIException::OCIException(sb4 errno) : Exception( (int)errno )
{
  this ->CheckError(errno);
}

OCIException::OCIException(sb4 errno, char * errfunc) : Exception( (int)errno )
{
  strcpy( this ->m_sErrBuff, errfunc);
  this ->CheckError(errno);
}

OCIException::OCIException(sb4 errno, dvoid * erroci) : Exception( (int)errno )
{
  this ->CheckError(errno, erroci);
}

OCIException::OCIException(sb4 errno, dvoid * erroci, char * errfunc) : Exception( (int)errno )
{
  strcpy( this ->m_sErrBuff, errfunc);
  this ->CheckError(errno, erroci);
}

char * OCIException::GetErrMsg()
{
  return this ->m_sErrBuff;
}

char * OCIException::GetErrFunc()
{
  return this ->m_sErrFunc;
}

int OCIException::GetErrNo()
{
  return this ->m_iErrNo;
}

/*
* OCIError.h
*
*    Created .: Mar 1, 2009
*            Author: Steven Wee
*/

#ifndef OCIERROR_H_
#define OCIERROR_H_

#include "Common.h"

class OCIError
{
public:
  static void PrintError(int errno);
  static void PrintError(int errno, char * errfunc);
private:
  static void CheckError();
  static int m_iErrNo;
  static char m_sErrBuff[512];
  static char m_sErrFunc[128];
};

#endif /* OCIERROR_H_ */

/*
* OCIError.cpp
*
*    Created .: Mar 1, 2009
*            Author: Steven Wee
*/
#include "OCIError.h"

int OCIError::m_iErrNo = 0;
char OCIError::m_sErrBuff[512] = {0};
char OCIError::m_sErrFunc[128] = {0};

void OCIError::CheckError()
{
  switch ( OCIError::m_iErrNo )
  {
  case OCI_SUCCESS:
    break;
  case OCI_SUCCESS_WITH_INFO:
    sprintf( OCIError::m_sErrBuff, "OCI_SUCCESS_WITH_INFO" );
    break;
  case OCI_NEED_DATA:
    sprintf( OCIError::m_sErrBuff, "OCI_NEED_DATA" );
    break;
  case OCI_NO_DATA:
    sprintf( OCIError::m_sErrBuff, "OCI_NO_DATA" );
    break;
  case OCI_ERROR:
    sprintf( OCIError::m_sErrBuff, "OCI_ERROR" );
    break;
  case OCI_INVALID_HANDLE:
    sprintf( OCIError::m_sErrBuff, "OCI_INVALID_HANDLE" );
    break;
  case OCI_STILL_EXECUTING:
    sprintf( OCIError::m_sErrBuff, "OCI_STILL_EXCUTING" );
    break;
  case OCI_CONTINUE:
    sprintf( OCIError::m_sErrBuff, "OCI_CONTINUE" );
    break;
  default:
    break;
  }
}

void OCIError::PrintError(int errno)
{
  OCIError::m_iErrNo = errno;
  OCIError::CheckError();
  std::cout << OCIError::m_sErrBuff << std::endl;
}

void OCIError::PrintError(int errno, char * errfunc )
{
  OCIError::m_iErrNo = errno;
  strcpy(OCIError::m_sErrFunc, errfunc);
  OCIError::CheckError();
  std::cout << OCIError::m_sErrFunc << OCIError::m_sErrBuff << std::endl;
}

/*
* OCIDB.h
*
*    Created .: Mar 1, 2009
*            Author: Steven Wee
*/

#ifndef OCIDB_H_
#define OCIDB_H_

#include "Common.h"
#include "../Common/CheckStringTools.h"

#define MAX_VAR_LEN 10
#define MAX_BUFFER_SIZE 32767

typedef struct {
  ub2    VarType;
  char *  VarName;
  int    VarLen;
  union {
    char * ValueChar;
    float * ValueFloat;
    int * ValueInt;
    OCILobLocator *lobLocator;
  };
} TBindVar;

typedef struct{
  char VarName[MAX_VAR_LEN];
  unsigned char VarType;
  unsigned char VarSize;
  unsigned char VarPrecision;
  unsigned char VarScale;
  unsigned char VarIsNull;
  union {
    char * ValueChar;
    float * ValueFloat;
    int * ValueInt;
    OCILobLocator *lobLocator;
  };
} TSelectVar;

#define MAX_BINDVAR_COUNT 10
#define MAX_SELECTVAR_COUNT 10

#define TYPE_INT 0
#define TYPE_FLOAT 1
#define TYPE_STRING 2
#define TYPE_BLOB 3

class OCIDB
{
private:
  dvoid * indp;
  OCIEnv * m_pOCIEnv;
  OCIError * m_pOCIError;

  OCISvcCtx * m_pOCISvcCtx;
  OCIServer * m_pOCIServer;
  OCISession * m_pOCISession;

  OCIStmt * m_pOCIStmt;
  OCIBind * m_pOCIBind;
  OCIDefine * m_pOCIDefine;
  OCIParam * m_pOCIParam;

  TBindVar m_BindVars[MAX_BINDVAR_COUNT];
  TSelectVar m_SelectVars[MAX_SELECTVAR_COUNT];

  int m_iBindVarsCount;
  int m_iSelectVarsCount;

  char m_sUser[10];
  char m_sPwd[10];
  char m_sDBName[10];

  int UserFetch();
  int UserGetInt(int index);
  int UserGetInt(char * name);
  char * UserGetString(int index);
  char * UserGetString(char * name);
  char * UserGetBlob(int index);
  char * UserGetBlob(char * name);
  float UserGetFloat(int index);
  float UserGetFloat(char * name);
  void inline StrUpper(char *str);
  bool inline StrCmp(const char *ori, const char *des);
  vector< vector > resultList;
protected:
  char * getBlobValue();
public:
  OCIDB();
  ~OCIDB();

  /* Single User, Single Connection */
  int Single_Conn();
  void Single_Disc();

  /* Multiple Sessions or Connections */
  int Multiple_Conn();
  void Multiple_Disc();

  /* Execute SQL with none query */
  int ExcuteSQL(char * sql);

  /* Execute SQL with bind vars */
  void BindInitVars();
  void BindClearVars();
  void BindAddVar(char * name, char * value);
  void BindAddVar(char * name, int * value);
  int BindSQL(char * sql);

  /* Prepare SQL*/
  int UserPrepare(char * sql);
  int UserFree();
  int UserBind(char * name, char * value);
  int UserBind(char * name, int value);
  int UserExecute();
  int UserCommit();
  int UserRollback();

  int UserSelect(char * sql);
  int UserSelectFree();

  vector< vector > getResult();
};

#endif /* OCIDB_H_ */

/*
* OCIDB.cpp
*
*    Created .: Mar 1, 2009
*            Author: Steven Wee
*/
#include "OCIDB.h"
#include "OCIException.h"
#include "OCIError.h"

OCIDB::OCIDB()
{
  strcpy(this ->m_sUser, "webtest");
  strcpy(this ->m_sPwd, "ns0528AO");
  strcpy(this ->m_sDBName, "NSTEST");

  this ->BindInitVars();
}

OCIDB::~OCIDB()
{

}

int OCIDB::Single_Conn()
{
  try
  {
    sword errno;
    /*
     * OCIEnvCreate(&envhp, mode, (const dvoid *)0, 0, 0, 0, (size_t)0, (dvoid **)0 );
     */
    errno = OCIEnvCreate( &this ->m_pOCIEnv, OCI_OBJECT, (dvoid *)0, (dvoid *(*)(dvoid *, size_t))0, (dvoid *(*)(dvoid *, dvoid *, size_t))0, (void (*)(dvoid *, dvoid *))0, (size_t)0, (dvoid **)0);
    if(errno)
    {
      throw OCIException(errno, (char *)"OCIDB::Single_Conn OCIEnvCreate");
    }

    /* Create Error Handle */
    errno = OCIHandleAlloc( (dvoid *)this ->m_pOCIEnv, (dvoid **)&this ->m_pOCIError, OCI_HTYPE_ERROR, (size_t)0, (dvoid **)0);
    if(errno)
    {
      throw OCIException(errno, (char *)"OCIDB::Single_Conn OCIHandleAlloc");
    }

    /* Login */
    errno = OCILogon(this ->m_pOCIEnv, this ->m_pOCIError, &this ->m_pOCISvcCtx, (const OraText*)this ->m_sUser,
        strlen(this ->m_sUser), (const OraText*)this ->m_sPwd, strlen(this ->m_sPwd), (const OraText*)this ->m_sDBName,
        strlen(this ->m_sDBName));
    if(errno)
    {
      throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::Single_Conn OCILogin2");
    }

    return 0;
  }
  catch ( OCIException &ex)
  {
    std::cout << ex.GetErrFunc() << ex.GetErrMsg() << std::endl;
    return -1;
  }
}

void OCIDB::Single_Disc()
{
  sword errno;
  /* Log off */
  errno = OCILogoff(m_pOCISvcCtx, this ->m_pOCIError);
  if ( errno )
  {
    OCIError::PrintError(errno, (char *)"OCIDB::Single_Disc OCILogoff");
  }

  /* Free errno */
  errno = OCIHandleFree((dvoid *)this ->m_pOCIError, (ub4)OCI_HTYPE_ERROR);
  if ( errno )
  {
    OCIError::PrintError(errno, (char *)"OCIDB::Single_Disc OCIHandleFree");
  }

  /* Free Env Handle */
  errno = OCIHandleFree((dvoid *)this ->m_pOCIEnv, (ub4)OCI_HTYPE_ENV);
  if ( errno )
  {
    OCIError::PrintError(errno, (char *)"OCIDB::Single_Disc OCIHandleFree");
  }
}

int OCIDB::Multiple_Conn()
{
  try
  {
    sword errno;

    errno = OCIInitialize( (ub4)OCI_DEFAULT, (dvoid *)0, (dvoid *(*)(dvoid *, size_t))0, (dvoid *(*)(dvoid *, dvoid *, size_t))0, (void (*)(dvoid *, dvoid *))0 );
    if ( errno )
    {
      throw OCIException(errno, (char *)"OCIDB::Multiple_Conn OCIInitialize");
    }
    errno = OCIEnvInit( (OCIEnv **)&this ->m_pOCIEnv, OCI_DEFAULT, (size_t)0, (dvoid **)0);
    if ( errno )
    {
      throw OCIException(errno, (char *)"OCIDB::Multiple_Conn OCIEnvInit");
    }

    /* Allocate Error Handle */
    errno = OCIHandleAlloc( (dvoid *)this ->m_pOCIEnv, (dvoid **)&this ->m_pOCIError, OCI_HTYPE_ERROR, (size_t)0, (dvoid **)0);
    if ( errno )
    {
      throw OCIException(errno, (char *)"OCIDB::Multiple_Conn OCIHandleAlloc Error");
    }

    /* Allocate Server Context Handle */
    errno = OCIHandleAlloc( (dvoid *)this ->m_pOCIEnv, (dvoid **)&this ->m_pOCISvcCtx, OCI_HTYPE_SVCCTX, (size_t)0, (dvoid **)0);
    if ( errno )
    {
      throw OCIException(errno, (char *)"OCIDB::Multiple_Conn OCIHandleAlloc SvcCtx");
    }

    /* Allocate Server Handle */
    errno = OCIHandleAlloc( (dvoid *)this ->m_pOCIEnv, (dvoid **)&this ->m_pOCIServer, OCI_HTYPE_SERVER, (size_t)0, (dvoid **)0);
    if ( errno )
    {
      throw OCIException(errno, (char *)"OCIDB::Multiple_Conn OCIHandleAlloc Server");
    }

    /* Set Server into ServerContext */
    errno = OCIAttrSet( (dvoid *)this ->m_pOCISvcCtx, OCI_HTYPE_SVCCTX, (dvoid *)this ->m_pOCIServer, 0, OCI_ATTR_SERVER, (OCIError *)this ->m_pOCIError);
    if ( errno )
    {
      throw OCIException(errno, (char *)"OCIDB::Multiple_Conn OCIAttrSet Server");
    }

    /* Attach Server */
    errno = OCIServerAttach(this ->m_pOCIServer, this ->m_pOCIError, (text *)this ->m_sDBName, strlen(this ->m_sDBName), OCI_DEFAULT);
    if ( errno )
    {
      throw OCIException(errno, (char *)"OCIDB::Multiple_Conn OCIServerAttach");
    }

    /* Allocate Session Handle */
    errno = OCIHandleAlloc( (dvoid *)this ->m_pOCIEnv, (dvoid **)&this ->m_pOCISession, (ub4)OCI_HTYPE_SESSION, (size_t)0, (dvoid **)0);
    if ( errno )
    {
      throw OCIException(errno, (char *)"OCIDB::Multiple_Conn OCIHandleAlloc Session");
    }

    /* Set Session into ServerContext */
    errno = OCIAttrSet( (dvoid *)this ->m_pOCISvcCtx, (ub4)OCI_HTYPE_SVCCTX, (dvoid *)this ->m_pOCISession, (ub4)0, (ub4)OCI_ATTR_SESSION, (OCIError *)this ->m_pOCIError);
    if ( errno )
    {
      throw OCIException(errno, (char *)"OCIDB::Multiple_Conn OCIAttrSet Session");
    }

    /* Set Session UserName */
    errno = OCIAttrSet( (dvoid *)this ->m_pOCISession, OCI_HTYPE_SESSION, (dvoid *)this ->m_sUser, strlen(this ->m_sUser), OCI_ATTR_USERNAME, (OCIError *)this ->m_pOCIError);
    if ( errno )
    {
      throw OCIException(errno, (char *)"OCIDB::Multiple_Conn OCIAttrSet UserName");
    }

    /* Set Session Password */
    errno = OCIAttrSet( (dvoid *)this ->m_pOCISession, OCI_HTYPE_SESSION, (dvoid *)this ->m_sPwd, (ub4)strlen(this ->m_sPwd), (ub4)OCI_ATTR_PASSWORD, (OCIError *)this ->m_pOCIError);
    if ( errno )
    {
      throw OCIException(errno, (char *)"OCIDB::Multiple_Conn OCIAttrSet Password");
    }

    /* Session Begin */
    errno = OCISessionBegin(this ->m_pOCISvcCtx, this ->m_pOCIError, this ->m_pOCISession, OCI_CRED_RDBMS, OCI_DEFAULT);
    if ( errno )
    {
      throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::Multiple_Conn OCISessionBegin");
    }
    return 0;
  }
  catch (OCIException &ex)
  {
    std::cout << ex.GetErrFunc() << ex.GetErrMsg() << std::endl;
    return -1;
  }
}

void OCIDB::Multiple_Disc()
{
  sword errno;

  /* End Session */
  errno = OCISessionEnd(this ->m_pOCISvcCtx, this ->m_pOCIError, this ->m_pOCISession, (ub4)OCI_DEFAULT);
  if ( errno )
  {
    OCIError::PrintError(errno, (char *)"OCIDB::Multiple_Disc OCISessionEnd");
  }

  /* Free Session */
  errno = OCIHandleFree( (dvoid *)this ->m_pOCISession, (ub4)OCI_HTYPE_SESSION );
  if ( errno )
  {
    OCIError::PrintError(errno, (char *)"OCIDB::Multiple_Disc OCIHandleFree Session");
  }

  /* Detach Server */
  errno = OCIServerDetach(this ->m_pOCIServer, this ->m_pOCIError, OCI_DEFAULT);
  if ( errno )
  {
    OCIError::PrintError(errno, (char *)"OCIDB::Multiple_Disc OCIServerDetach");
  }

  /* Free Server */
  errno = OCIHandleFree( (dvoid *)this ->m_pOCIServer, (ub4)OCI_HTYPE_SERVER );
  if ( errno )
  {
    OCIError::PrintError(errno, (char *)"OCIDB::Multiple_Disc OCIHandleFree Server");
  }

  /* Free ServerContext */
  errno = OCIHandleFree( (dvoid *)this ->m_pOCISvcCtx, (ub4)OCI_HTYPE_SVCCTX );
  if ( errno )
  {
    OCIError::PrintError(errno, (char *)"OCIDB::Multiple_Disc OCIHandleFree ServerContext");
  }

  /* Free Error */
  errno = OCIHandleFree( (dvoid *)this ->m_pOCIError, (ub4)OCI_HTYPE_ERROR );
  if ( errno )
  {
    OCIError::PrintError(errno, (char *)"OCIDB::Multiple_Disc OCIHandleFree Error");
  }

  /* Free Env */
  errno = OCIHandleFree( (dvoid *)this ->m_pOCIEnv, (ub4)OCI_HTYPE_ENV );
  if ( errno )
  {
    OCIError::PrintError(errno, (char *)"OCIDB::Multiple_Disc OCIHandleFree Env");
  }
}

int OCIDB::ExcuteSQL(char * sql)
{
  sword errno;
  try
  {
    /* Allocate Stmt */
    errno = OCIHandleAlloc( (dvoid *)this ->m_pOCIEnv, (dvoid **)&this ->m_pOCIStmt, OCI_HTYPE_STMT, (size_t)0, (dvoid **)0);
    if ( errno )
    {
      OCIError::PrintError(errno, (char *)"OCIDB::ExcuteSQL OCIHandleAlloc");
    }

    errno = OCIStmtPrepare(this ->m_pOCIStmt, this ->m_pOCIError, (const OraText *)sql, (ub4)strlen(sql), (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT);
    if ( errno )
    {
      OCIError::PrintError(errno, (char *)"OCIDB::ExcuteSQL OCIStmtPrepare");
    }

    errno = OCIStmtExecute(this ->m_pOCISvcCtx, this ->m_pOCIStmt, this ->m_pOCIError, (ub4)1, (ub4)0, (const OCISnapshot *)NULL, (OCISnapshot *)NULL, OCI_DEFAULT);
    if ( errno )
    {
      OCIError::PrintError(errno, (char *)"OCIDB::ExcuteSQL OCIStmtExecute");
    }

    errno = OCITransCommit( this ->m_pOCISvcCtx, this ->m_pOCIError, 0);
    if ( errno )
    {
      OCIError::PrintError(errno, (char *)"OCIDB::ExcuteSQL OCITransCommit");
    }

    errno = OCIHandleFree( (dvoid *)this ->m_pOCIStmt, (ub4)OCI_HTYPE_STMT );
    if ( errno )
    {
      OCIError::PrintError(errno, (char *)"OCIDB::ExcuteSQL OCIHandleFree");
    }
    return 0;
  }
  catch (OCIException &ex)
  {
    /* Rollback */
    errno = OCITransRollback( this ->m_pOCISvcCtx, this ->m_pOCIError, 0);
    if ( errno )
    {
      OCIError::PrintError(errno, (char *)"OCIDB::ExcuteSQL OCITransRollback");
    }
    /* Free Stmt */
    errno = OCIHandleFree( (dvoid *)this ->m_pOCIStmt, (ub4)OCI_HTYPE_STMT);
    if ( errno )
    {
      OCIError::PrintError(errno, (char *)"OCIDB::ExcuteSQL OCIHandleFree");
    }
    std::cout << ex.GetErrFunc() << ex.GetErrMsg() << std::endl;
    return -1;
  }
}

void OCIDB::BindInitVars()
{
  int i;
  for( i = 0 ; i < MAX_BINDVAR_COUNT - 1 ; i++ )
  {
    this ->m_BindVars[i].VarType = 0;
    this ->m_BindVars[i].VarName = 0;
    this ->m_BindVars[i].VarLen = 0;
    this ->m_BindVars[i].ValueChar = 0;
  }
  this ->m_iBindVarsCount = 0;
}

void OCIDB::BindClearVars()
{
  int i;
  for( i = 0 ; i < m_iBindVarsCount - 1 ; i++ )
  {
    delete [] this ->m_BindVars[i].VarName;
    if ( this ->m_BindVars[i].VarType == SQLT_STR )
      delete [] this ->m_BindVars[i].ValueChar;
    if ( this ->m_BindVars[i].VarType == SQLT_INT )
      delete [] this ->m_BindVars[i].ValueInt;

    this ->m_BindVars[i].VarType = 0;
    this ->m_BindVars[i].VarName = 0;
    this ->m_BindVars[i].VarLen = 0;
    this ->m_BindVars[i].ValueChar = 0;
  }
  this ->m_iBindVarsCount = 0;
}

void OCIDB::BindAddVar(char * name, char * value)
{
  if ( this ->m_iBindVarsCount >= MAX_BINDVAR_COUNT )
    return;
  this ->m_BindVars[this ->m_iBindVarsCount].VarType = SQLT_STR;
  this ->m_BindVars[this ->m_iBindVarsCount].VarName = new char[strlen(name) + 1];
  strcpy( this ->m_BindVars[this ->m_iBindVarsCount].VarName, name);

  this ->m_BindVars[this ->m_iBindVarsCount].ValueChar = new char[strlen(value) + 1];
  strcpy( this ->m_BindVars[this ->m_iBindVarsCount].ValueChar, value);
  this ->m_BindVars[this ->m_iBindVarsCount].VarLen = strlen(value) + 1;

  this ->m_iBindVarsCount++;
}

void OCIDB::BindAddVar(char * name, int * value)
{
  if ( this ->m_iBindVarsCount >= MAX_BINDVAR_COUNT )
    return;
  this ->m_BindVars[this ->m_iBindVarsCount].VarType = SQLT_INT;
  this ->m_BindVars[this ->m_iBindVarsCount].VarName = new char[strlen(name) + 1];
  strcpy( this ->m_BindVars[this ->m_iBindVarsCount].VarName, name);

  this ->m_BindVars[this ->m_iBindVarsCount].ValueInt = new int;
  this ->m_BindVars[this ->m_iBindVarsCount].ValueInt = value;
  this ->m_BindVars[this ->m_iBindVarsCount].VarLen = sizeof(int);

  this ->m_iBindVarsCount++;
}

int OCIDB::BindSQL(char * sql)
{
  if( this ->m_iBindVarsCount == 0 )
    return -1;
  sword errno;
  try
  {
    /* Allocate Stmt */
    errno = OCIHandleAlloc( (dvoid *)this ->m_pOCIEnv, (dvoid **)&this ->m_pOCIStmt, OCI_HTYPE_STMT, (size_t)0, (dvoid **)0);
    if ( errno )
    {
      throw OCIException(errno, (char *)"OCIDB::BindSQL OCIHandleAlloc Stmt");
    }
    /* Prepare Stmt */
    errno = OCIStmtPrepare( this ->m_pOCIStmt, this ->m_pOCIError, (const OraText *)sql, (ub4)strlen(sql), (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT );
    if ( errno )
    {
      throw OCIException(errno, (char *)"OCIDB::BindSQL OCIStmtPrepare");
    }
    /* Bind Vars */
    int i;
    for ( i = 0 ; i < m_iBindVarsCount - 1 ; i++ )
    {
      /* Bind By Name */
      errno = OCIBindByName( this ->m_pOCIStmt, &this ->m_pOCIBind, this ->m_pOCIError, (text *)this ->m_BindVars[i].VarName, -1,
          (dvoid *)this ->m_BindVars[i].ValueChar, this ->m_BindVars[i].VarLen, this ->m_BindVars[i].VarType, (dvoid *)0, (ub2 *)0, (ub2 *)0, (ub4)0, (ub4 *)0, OCI_DEFAULT);

      if ( errno )
      {
        throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::BindSQL OCIBindByName");
      }
      /*
      errno = OCIBindByPos( this ->m_pOCIStmt, &this ->m_pOCIBind, this ->m_pOCIError, i + 1, (dvoid *)this ->m_BindVars[i].ValueChar,
          this ->m_BindVars[i].VarLen, this ->m_BindVars[i].VarType, (dvoid *)0, (ub2 *)0, (ub2 *)0, (ub4)0, (ub4 *)0, OCI_DEFAULT);

      if ( errno )
      {
        throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::BindSQL OCIBindByPos");
      }
      */
    }
    /* Execute SQL */
    errno = OCIStmtExecute( this ->m_pOCISvcCtx, this ->m_pOCIStmt, this ->m_pOCIError, (ub4)1, (ub4)0, (const OCISnapshot *)NULL, (OCISnapshot *)NULL, OCI_DEFAULT);
    if ( errno )
    {
      throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::BindSQL OCIStmtExecute");
    }
    /*  Commit */
    errno = OCITransCommit( this ->m_pOCISvcCtx, this ->m_pOCIError, 0);
    if ( errno )
    {
      throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::BindSQL OCITransCommit");
    }
    /* Free Stmt */
    errno = OCIHandleFree( (dvoid *)this ->m_pOCIStmt, (ub4)OCI_HTYPE_STMT );
    if ( errno )
    {
      throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::BindSQL OCIHandleFree");
    }
    /* Clear Vars */
    this ->BindClearVars();
    return 0;
  }
  catch ( OCIException &ex )
  {
    /* Rollback */
    errno = OCITransRollback( this ->m_pOCISvcCtx, this ->m_pOCIError, 0);
    if ( errno )
    {
      OCIError::PrintError(errno, (char *)"OCIDB::BindSQL OCITransRollback");
    }
    /* Free Stmt */
    errno = OCIHandleFree( (dvoid *)this ->m_pOCIStmt, (ub4)OCI_HTYPE_STMT);
    if ( errno )
    {
      OCIError::PrintError(errno, (char *)"OCIDB::BindSQL OCIHandleFree");
    }
    this ->BindClearVars();
    std::cout << ex.GetErrFunc() << ex.GetErrMsg() << std::endl;
    return -1;
  }
}

int OCIDB::UserPrepare(char * sql)
{
  sword errno;
  try
  {
    /* Allocate Stmt */
    errno = OCIHandleAlloc( (dvoid *)this ->m_pOCIEnv, (dvoid **)&this ->m_pOCIStmt, OCI_HTYPE_STMT, (size_t)0, (dvoid **)0 );
    if ( errno )
    {
      throw OCIException(errno, (char *)"OCIDB::UserPrepare OCIHandleAlloc");
    }
    /* Prepare Stmt */
    errno = OCIStmtPrepare( this ->m_pOCIStmt, this ->m_pOCIError, (const OraText *)sql, (ub4)strlen(sql), (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT );
    if ( errno )
    {
      throw OCIException(errno, (char *)"OCIDB::UserPrepare OCIStmtPrepare");
    }
    return 0;
  }
  catch ( OCIException &ex )
  {
    /* Free Stmt */
    errno = OCIHandleFree( (dvoid *)this ->m_pOCIStmt, (ub4)OCI_HTYPE_STMT );
    if ( errno )
    {
      OCIError::PrintError(errno, (char *)"OCIDB::UserPrepare Ex OCIHandleFree");
    }
    std::cout << ex.GetErrFunc() << ex.GetErrMsg() << std::endl;
    return -1;
  }
}

int OCIDB::UserFree()
{
  sword errno;
  /* Free Stmt */
  errno = OCIHandleFree( (dvoid *)this ->m_pOCIStmt, (ub4)OCI_HTYPE_STMT );
  if ( errno )
  {
    OCIError::PrintError(errno, (char *)"OCIDB::UserFree OCIHandleFree");
    return -1;
  }
  return 0;
}

int OCIDB::UserBind(char * name, char * value)
{
  sword errno;
  try
  {
    errno = OCIBindByName( this ->m_pOCIStmt, &this ->m_pOCIBind, this ->m_pOCIError, (text *)name, -1,
        (dvoid *)value, strlen(value) + 1, SQLT_STR, (dvoid *)0, (ub2 *)0, (ub2 *)0, (ub4)0, (ub4 *)0, OCI_DEFAULT );
    if ( errno )
    {
      throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserBind OCIBindByName");
    }
    return 0;
  }
  catch ( OCIException &ex )
  {
    /* Free Stmt */
    errno = OCIHandleFree( (dvoid *)this ->m_pOCIStmt, (ub4)OCI_HTYPE_STMT );
    if ( errno )
    {
      OCIError::PrintError(errno, (char *)"OCIDB::UserBind Ex OCIHandleFree");
    }
    std::cout << ex.GetErrFunc() << ex.GetErrMsg() << std::endl;
    return -1;
  }
}

int OCIDB::UserBind(char * name, int value)
{
  sword errno;
  try
  {
    int val = value;
    errno = OCIBindByName( this ->m_pOCIStmt, &this ->m_pOCIBind, this ->m_pOCIError, (text *)name, -1,
        (dvoid *)&val, sizeof(int), SQLT_INT, (dvoid *)0, (ub2 *)0, (ub2 *)0, (ub4)0, (ub4 *)0, OCI_DEFAULT );
    if ( errno )
    {
      throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserBind OCIBindByName");
    }
    return 0;
  }
  catch ( OCIException &ex )
  {
    /* Free Stmt */
    errno = OCIHandleFree( (dvoid *)this ->m_pOCIStmt, (ub4)OCI_HTYPE_STMT );
    if ( errno )
    {
      OCIError::PrintError(errno, (char *)"OCIDB::UserBind Ex OCIHandleFree");
    }
    std::cout << ex.GetErrFunc() << ex.GetErrMsg() << std::endl;
    return -1;
  }
}

int OCIDB::UserExecute()
{
  sword errno;
  try
  {
    errno = OCIStmtExecute( this ->m_pOCISvcCtx, this ->m_pOCIStmt, this ->m_pOCIError, (ub4)1, (ub4)0,
        (const OCISnapshot *)NULL, (OCISnapshot *)NULL, OCI_DEFAULT );
    if ( errno )
    {
      throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserExecute OCIBindByName");
    }
    return 0;
  }
  catch ( OCIException &ex )
  {
    /* Free Stmt */
    errno = OCIHandleFree( (dvoid *)this ->m_pOCIStmt, (ub4)OCI_HTYPE_STMT );
    if ( errno )
    {
      OCIError::PrintError(errno, (char *)"OCIDB::UserExecute Ex OCIHandleFree");
    }
    std::cout << ex.GetErrFunc() << ex.GetErrMsg() << std::endl;
    return -1;
  }
}

int OCIDB::UserCommit()
{
  sword errno;
  errno = OCITransCommit( this ->m_pOCISvcCtx, this ->m_pOCIError, 0);
  if ( errno )
  {
    OCIError::PrintError(errno, (char *)"OCIDB::UserCommit OCITransCommit");
    return -1;
  }
  return 0;
}

int OCIDB::UserSelect(char * sql)
{
  sword errno;
  try
  {
    /* Allocate Stmt */
    errno = OCIHandleAlloc( (dvoid *)this ->m_pOCIEnv, (dvoid **)&this ->m_pOCIStmt, OCI_HTYPE_STMT, (size_t)0, (dvoid **)0 );
    if ( errno )
    {
      throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIHandleAlloc");
    }
    /* Prepare Stmt */
    errno = OCIStmtPrepare( this ->m_pOCIStmt, this ->m_pOCIError, (const OraText *)sql, (ub4)strlen(sql), (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT );
    if ( errno )
    {
      throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIStmtPrepare");
    }
    /* Execute Stmt */
    errno = OCIStmtExecute( this ->m_pOCISvcCtx, this ->m_pOCIStmt, this ->m_pOCIError, (ub4)0, (ub4)0, (OCISnapshot *)NULL, (OCISnapshot *)NULL, OCI_DEFAULT );
    if ( errno )
    {
      throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIStmtExecute");
    }

    errno = OCIAttrGet( this ->m_pOCIStmt, (ub4)OCI_HTYPE_STMT, (dvoid *)&this ->m_iSelectVarsCount, (ub4 *)0, (ub4)OCI_ATTR_PARAM_COUNT, this ->m_pOCIError );
    if ( errno )
    {
      throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIAttrGet");
    }
    int iLen;
    char * sName;
    ub2 iSize, iPrecision, iType;
    ub1 iScale, iIsNull;

    int i;
    for ( i = 0 ; i < this ->m_iSelectVarsCount ; i++ )
    {
      sName = 0;
      errno = OCIParamGet( this ->m_pOCIStmt, OCI_HTYPE_STMT, this ->m_pOCIError, (dvoid **)&this ->m_pOCIParam, i+ 1 );
      if ( errno )
      {
        throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIParamGet");
      }
      //  Column Name
      errno = OCIAttrGet( (dvoid *)this ->m_pOCIParam, OCI_DTYPE_PARAM, (dvoid **)&sName, (ub4 *)&iLen, OCI_ATTR_NAME, this ->m_pOCIError );
      if ( errno )
      {
        throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIAttrGet Column Name");
      }
      strncpy( this ->m_SelectVars[i].VarName, sName, iLen );
      this ->m_SelectVars[i].VarName[iLen] = 0;
      //  Data Size;
      errno = OCIAttrGet( (dvoid *)this ->m_pOCIParam, OCI_DTYPE_PARAM, (dvoid *)&iSize, (ub4 *)0, OCI_ATTR_DATA_SIZE, this ->m_pOCIError );
      if ( errno )
      {
        throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIAttrGet Data Size");
      }
      this ->m_SelectVars[i].VarSize = iSize;
      //  Data Precision
      errno = OCIAttrGet( (dvoid *)this ->m_pOCIParam, OCI_DTYPE_PARAM, (dvoid *)&iPrecision, (ub4 *)0, OCI_ATTR_PRECISION, this ->m_pOCIError );
      if ( errno )
      {
        throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIAttrGet Data Precision");
      }
      this ->m_SelectVars[i].VarPrecision = iPrecision;
      //  Data Scale
      errno = OCIAttrGet( (dvoid *)this ->m_pOCIParam, OCI_DTYPE_PARAM, (dvoid *)&iScale, (ub4 *)0, OCI_ATTR_SCALE, this ->m_pOCIError );
      if ( errno )
      {
        throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIAttrGet Data Scale");
      }
      this ->m_SelectVars[i].VarScale = iScale;
      //  Data Is Null
      errno = OCIAttrGet( (dvoid *)this ->m_pOCIParam, OCI_DTYPE_PARAM, (dvoid *)&iIsNull, (ub4 *)0, OCI_ATTR_IS_NULL, this ->m_pOCIError );
      if ( errno )
      {
        throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIAttrGet Data Is Null");
      }
      this ->m_SelectVars[i].VarIsNull = iIsNull;
      //  Data Type
      errno = OCIAttrGet( (dvoid *)this ->m_pOCIParam, OCI_DTYPE_PARAM, (dvoid *)&iType, (ub4 *)0, OCI_ATTR_DATA_TYPE, this ->m_pOCIError );
      if ( errno )
      {
        throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIAttrGet Data Type");
      }
      this ->m_SelectVars[i].VarType = iType;

      switch ( this ->m_SelectVars[i].VarType )
      {
      case SQLT_NUM:
        if ( this ->m_SelectVars[i].VarScale == 0 )
        {
          this ->m_SelectVars[i].ValueInt = new int;
          this ->m_SelectVars[i].VarType = TYPE_INT;
          errno = OCIDefineByPos( this ->m_pOCIStmt, &this ->m_pOCIDefine, this ->m_pOCIError, i + 1,
              (dvoid *)this ->m_SelectVars[i].ValueInt,  sizeof(int), SQLT_INT, this ->indp, (ub2 *)0, (ub2 *)0, OCI_DEFAULT );
          if ( errno )
          {
            throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIDefineByPos");
          }
        }
        else
        {
          this ->m_SelectVars[i].ValueFloat = new float;
          this ->m_SelectVars[i].VarType = TYPE_FLOAT;
          errno = OCIDefineByPos( this ->m_pOCIStmt, &this ->m_pOCIDefine, this ->m_pOCIError, i + 1,
              (dvoid *)this ->m_SelectVars[i].ValueFloat,  sizeof(float), SQLT_FLT, this ->indp, (ub2 *)0, (ub2 *)0, OCI_DEFAULT );
          if ( errno )
          {
            throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIDefineByPos");
          }
        }
        break;
      case SQLT_CHR:
        this ->m_SelectVars[i].ValueChar = new char[this ->m_SelectVars[i].VarSize + 1];
        this ->m_SelectVars[i].VarType = TYPE_STRING;
        errno = OCIDefineByPos( this ->m_pOCIStmt, &this ->m_pOCIDefine, this ->m_pOCIError, i + 1,
            (dvoid *)this ->m_SelectVars[i].ValueChar,  this ->m_SelectVars[i].VarSize + 1, SQLT_STR, this ->indp, (ub2 *)0, (ub2 *)0, OCI_DEFAULT );
        if ( errno )
        {
          throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIDefineByPos");
        }
        break;
      case SQLT_BLOB:
        /* Allocate lobLocator */
        errno = OCIDe.orAlloc( (dvoid *)this ->m_pOCIEnv, (dvoid **)&this ->m_SelectVars[i].lobLocator, (ub4)OCI_DTYPE_LOB, (size_t)0, (dvoid **)0 );
        if ( errno )
        {
          throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIDe.orAlloc");
        }
        this ->m_SelectVars[i].VarType = TYPE_BLOB;
        errno = OCIDefineByPos( this ->m_pOCIStmt, &this ->m_pOCIDefine, this ->m_pOCIError, (ub4)i + 1, (dvoid *)&this ->m_SelectVars[i].lobLocator, (sb4)0,
            (ub2)SQLT_BLOB, this ->indp, (ub2 *)0, (ub2 *)0, (ub4)OCI_DEFAULT);
        if ( errno )
        {
          throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIDefineByPos");
        }
        break;
      case SQLT_CLOB:
        /* Allocate lobLocator */
        errno = OCIDe.orAlloc( (dvoid *)this ->m_pOCIEnv, (dvoid **)&this ->m_SelectVars[i].lobLocator, (ub4)OCI_DTYPE_LOB, (size_t)0, (dvoid **)0 );
        if ( errno )
        {
          throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIDe.orAlloc");
        }
        this ->m_SelectVars[i].VarType = TYPE_BLOB;
        errno = OCIDefineByPos( this ->m_pOCIStmt, &this ->m_pOCIDefine, this ->m_pOCIError, (ub4)i + 1, (dvoid *)&this ->m_SelectVars[i].lobLocator, (sb4)0,
            (ub2)SQLT_BLOB, this ->indp, (ub2 *)0, (ub2 *)0, (ub4)OCI_DEFAULT);
        if ( errno )
        {
          throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserSelect OCIDefineByPos");
        }
        break;
      }
    }
    return 0;
  }
  catch ( OCIException &ex )
  {
    /* Free Stmt */
    errno = OCIHandleFree( (dvoid *)this ->m_pOCIStmt, (ub4)OCI_HTYPE_STMT );
    if ( errno )
    {
      OCIError::PrintError(errno, (char *)"OCIDB::UserExecute Ex OCIHandleFree");
    }
    std::cout << ex.GetErrFunc() << ex.GetErrMsg() << std::endl;
    return -1;
  }
}

int OCIDB::UserFetch()
{
  sword errno;
  try
  {
    errno = OCIStmtFetch( this ->m_pOCIStmt, this ->m_pOCIError, 1, OCI_FETCH_NEXT, OCI_DEFAULT );
    if ( errno && errno != OCI_NO_DATA )
    {
      throw OCIException(errno, this ->m_pOCIError, (char *)"OCIDB::UserFetch OCIStmtFetch");
    }
    if ( errno == OCI_NO_DATA )
      return 1;
    return 0;
  }
  catch ( OCIException &ex )
  {
    std::cout << ex.GetErrFunc() << ex.GetErrMsg() << std::endl;
    return -1;
  }
}

int OCIDB::UserSelectFree()
{
  int i;
  for ( i = 0 ; i < this ->m_iSelectVarsCount ; i++ )
  {
    switch ( this ->m_SelectVars[i].VarType )
    {
    case TYPE_STRING:
      delete [] this ->m_SelectVars[i].ValueChar;
      break;
    case TYPE_FLOAT:
      delete this ->m_SelectVars[i].ValueFloat;
      break;
    case TYPE_INT:
      delete this ->m_SelectVars[i].ValueInt;
      break;
    }
  }
  return this ->UserFree();
}

int OCIDB::UserGetInt(int index)
{
  switch ( this ->m_SelectVars[index].VarType )
  {
  case TYPE_FLOAT:
    return (int)*m_SelectVars[index].ValueFloat;
    break;
  case TYPE_INT:
    return *m_SelectVars[index].ValueInt;
    break;
  default:
    return 0;
  }
}

int OCIDB::UserGetInt(char * name)
{
  int i;
  for ( i = 0 ; i < this ->m_iSelectVarsCount ; i++ )
  {
    if ( this ->StrCmp(m_SelectVars[i].VarName, name) )
    {
      switch ( this ->m_SelectVars[i].VarType )
      {
      case TYPE_FLOAT:
        return (int)*m_SelectVars[i].ValueFloat;
        break;
      case TYPE_INT:
        return *m_SelectVars[i].ValueInt;
        break;
      default:
        return 0;
      }
    }
  }
  return 0;
}

float OCIDB::UserGetFloat(int index)
{
  switch ( this ->m_SelectVars[index].VarType )
  {
  case TYPE_FLOAT:
    return *m_SelectVars[index].ValueFloat;
    break;
  case TYPE_INT:
    return (float)*m_SelectVars[index].ValueInt;
    break;
  default:
    return 0;
  }
}

float OCIDB::UserGetFloat(char * name)
{
  int i;
  for ( i = 0 ; i < this ->m_iSelectVarsCount ; i++ )
  {
    if ( this ->StrCmp(m_SelectVars[i].VarName, name) )
    {
      switch ( this ->m_SelectVars[i].VarType )
      {
      case TYPE_FLOAT:
        return *m_SelectVars[i].ValueFloat;
        break;
      case TYPE_INT:
        return (float)*m_SelectVars[i].ValueInt;
        break;
      default:
        return 0;
      }
    }
  }
  return 0;
}

char * OCIDB::UserGetString(int index)
{
  if ( this ->m_SelectVars[index].VarType == TYPE_STRING )
  {
    return this ->m_SelectVars[index].ValueChar;
  }
  else
  {
    return 0;
  }
}

char * OCIDB::UserGetString(char * name)
{
  int i;
  for ( i = 0 ; i < this ->m_iSelectVarsCount ; i++ )
  {
    if ( this ->StrCmp(m_SelectVars[i].VarName, name) )
    {
      if ( this ->m_SelectVars[i].VarType == TYPE_STRING )
      {
        return this ->m_SelectVars[i].ValueChar;
      }
    }
  }
  return 0;
}

char * OCIDB::UserGetBlob(int index)
{
  if ( this ->m_SelectVars[index].VarType == TYPE_BLOB )
  {
    return this ->m_SelectVars[index].ValueChar;
  }
  else
  {
    return 0;
  }
}

char * OCIDB::UserGetBlob(char * name)
{
  int i;
  for ( i = 0 ; i < this ->m_iSelectVarsCount ; i++ )
  {
    if ( this ->StrCmp(m_SelectVars[i].VarName, name) )
    {
      if ( this ->m_SelectVars[i].VarType == TYPE_BLOB )
      {
        return this ->m_SelectVars[i].ValueChar;
      }
    }
  }
  return 0;
}

vector< vector > OCIDB::getResult()
{
  int i;
  vector objectValue;
  StringTools stringTools;
  while ( this ->UserFetch() == 0 )
  {
    objectValue.clear();
    for ( i = 0 ; i < this ->m_iSelectVarsCount ; i++ )
    {
      switch ( this ->m_SelectVars[i].VarType )
      {
      case TYPE_STRING:
        objectValue.push_back(this ->UserGetString(i));
        break;
      case TYPE_FLOAT:
        objectValue.push_back(stringTools.ToString(this ->UserGetFloat(i)));
        break;
      case TYPE_INT:
        objectValue.push_back(stringTools.ToString(this ->UserGetInt(i)));
        break;
      case TYPE_BLOB:
        break;
      }
    }
    resultList.push_back(objectValue);
  }

  return resultList;
}

void inline OCIDB::StrUpper(char * str)
{
  int i;
  int sLen = strlen(str);
  for ( i = 0 ; i < sLen ; i++ )
  {
    str[i] = toupper(str[i]);
  }
}

bool inline OCIDB::StrCmp(const char * ori, const char * des)
{
  int iLenOri, iLenDes;
  int j;

  iLenOri = strlen(ori);
  iLenDes = strlen(des);

  if ( iLenOri != iLenDes )
    return false;

  for ( j = 0 ; j < iLenOri ; j++ )
  {
    if ( toupper(ori[j]) != toupper(des[j]) )
    {
      return false;
    }
  }
  return true;
}

五、修改建议

本套代码只是处理了LOB类型的绑定，没有处理LOB类型数据的读取。

本人在以后的完善中，打算把runSQLCommand(char * sql)函数分解成两个或者三个函数，分别执行select和insert等语句。

在程序中，我并没有强制要求参数必须为const，可能会出现一些安全问题。

本文仅起抛砖引玉的作用，希望有高手可以指点我程序中的问题。

转载于:https://blog.51cto.com/commandos/139545

你可能感兴趣的:(Linux下使用C/C++访问数据库——Oracle之OCI篇)

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
android系统selinux中添加新属性property 辉色投像
1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
【iOS】MVC设计模式 Magnetic_h ios mvc 设计模式 objective-c 学习 ui
MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
OC语言多界面传值五大方式 Magnetic_h ios ui 学习 objective-c 开发语言
前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
UI学习——cell的复用和自定义cell Magnetic_h ui 学习
目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
element实现动态路由+面包屑软件技术NINI vue案例 vue.js 前端
el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
C语言宏函数南林yan C语言 c语言
一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
C语言如何定义宏函数？小九格物 c语言
在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务 java 架构
在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断尐尐呅
结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
swagger访问路径 igotyback swagger
Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
mysql禁用远程登录 igotyback mysql
去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
扫地机类清洁产品之直流无刷电机控制悟空胆好小清洁服务机器人单片机人工智能
扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码说私域人工智能小程序
摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
消息中间件有哪些常见类型 xmh-sxh-1314 java
消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
html 中如何使用 uniapp 的部分方法某公司摸鱼前端 html uni-app 前端
示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）研学随笔 arcgis 经验分享
我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
高级编程--XML+socket练习题 masa010 java 开发语言
1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
那个抄袭的大张伟猫小努
最近一直在追《即刻电音》这个综艺，除了觉得出场节目的音乐制作人有意思之外，也觉得有两个导师挺有趣的（另外一个就忽略了吧）。孙艺兴在上一篇文章里面已经说过了，那么这篇就说说我们的大老师，大张伟吧。其实在节目刚开始大张伟出来的时候，我以为他是属于导师里面来活跃气氛负责搞笑的，毕竟孙艺兴属于卖萌卖傻卖老实的，尚雯婕一般负责装逼耍狠的，而大张伟一贯以来上综艺的形象基本上都是蹦蹦跳跳带动气氛的。谁知道，两期
2018-07-23-催眠日作业-#不一样的31天#-66小鹿小鹿_33
预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
水平垂直居中的几种方法（总结） LJ小番茄 CSS_玄学语言 html javascript 前端 css css3
1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
《大清方方案》| 第二话谁佐清欢
和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录 leetcode 算法职场和发展
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
每日一题——第八十九题互联网打工人no1 C语言程序设计每日一练 c语言
题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
html 周华华 html
js 1，数组的排列 var arr=[1,4,234,43,52,]; for(var x=0;x<arr.length;x++){ for(var y=x-1;y<arr.length;y++){ if(arr[x]<arr[y]){ &
【Struts2 四】Struts2拦截器 bit1129 struts2拦截器
Struts2框架是基于拦截器实现的，可以对某个Action进行拦截，然后某些逻辑处理，拦截器相当于AOP里面的环绕通知，即在Action方法的执行之前和之后根据需要添加相应的逻辑。事实上，即使struts.xml没有任何关于拦截器的配置，Struts2也会为我们添加一组默认的拦截器，最常见的是，请求参数自动绑定到Action对应的字段上。 Struts2中自定义拦截器的步骤是：
make:cc 命令未找到解决方法 daizj linux 命令未知 make cc
安装rz sz程序时，报下面错误： [root@slave2 src]# make posix cc -O -DPOSIX -DMD=2 rz.c -o rz make: cc：命令未找到 make: *** [posix] 错误 127 系统：centos 6.6 环境：虚拟机错误原因：系统未安装gcc，这个是由于在安
Oracle之Job应用周凡杨 oracle job
最近写服务，服务上线后，需要写一个定时执行的SQL脚本，清理并更新数据库表里的数据，应用到了Oracle 的 Job的相关知识。在此总结一下。一：查看相关job信息 1、相关视图 dba_jobs all_jobs user_jobs dba_jobs_running 包含正在运行
多线程机制朱辉辉33 多线程
转至http://blog.csdn.net/lj70024/archive/2010/04/06/5455790.aspx 程序、进程和线程：程序是一段静态的代码，它是应用程序执行的蓝本。进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的单位，一个进程执行过程中可以产生多个线程，每个线程有自身的
web报表工具FineReport使用中遇到的常见报错及解决办法（一）老A不折腾 web报表 finereport java报表报表工具
FineReport使用中遇到的常见报错及解决办法（一）这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 1、address pool is full：含义：地址池满，连接数超过并发数上
mysql rpm安装后没有my.cnf 林鹤霄没有my.cnf
Linux下用rpm包安装的MySQL是不会安装/etc/my.cnf文件的，至于为什么没有这个文件而MySQL却也能正常启动和作用，在这儿有两个说法，第一种说法，my.cnf只是MySQL启动时的一个参数文件，可以没有它，这时MySQL会用内置的默认参数启动，第二种说法，MySQL在启动时自动使用/usr/share/mysql目录下的my-medium.cnf文件，这种说法仅限于r
Kindle Fire HDX root并安装谷歌服务框架之后仍无法登陆谷歌账号的问题 aigo root
原文：http://kindlefireforkid.com/how-to-setup-a-google-account-on-amazon-fire-tablet/ Step 4: Run ADB command from your PC On the PC, you need install Amazon Fire ADB driver and instal
javascript 中var提升的典型实例 alxw4616 JavaScript
// 刚刚在书上看到的一个小问题,很有意思.大家一起思考下吧 myname = 'global'; var fn = function () { console.log(myname); // undefined var myname = 'local'; console.log(myname); // local }; fn() // 上述代码实际上等同于以下代码 m
定时器和获取时间的使用百合不是茶时间的转换定时器
定时器:定时创建任务在游戏设计的时候用的比较多 Timer();定时器 TImerTask();Timer的子类由 Timer 安排为一次执行或重复执行的任务。定时器类Timer在java.util包中。使用时，先实例化，然后使用实例的schedule(TimerTask task, long delay)方法，设定
JDK1.5 Queue bijian1013 java thread java多线程 Queue
JDK1.5 Queue LinkedList： LinkedList不是同步的。如果多个线程同时访问列表，而其中至少一个线程从结构上修改了该列表，则它必须保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方
http认证原理和https bijian1013 http https
一.基础介绍在URL前加https://前缀表明是用SSL加密的。你的电脑与服务器之间收发的信息传输将更加安全。 Web服务器启用SSL需要获得一个服务器证书并将该证书与要使用SSL的服务器绑定。 http和https使用的是完全不同的连接方式，用的端口也不一样,前者是80，后
【Java范型五】范型继承 bit1129 java
定义如下一个抽象的范型类，其中定义了两个范型参数，T1，T2 package com.tom.lang.generics; public abstract class SuperGenerics<T1, T2> { private T1 t1; private T2 t2; public abstract void doIt(T
【Nginx六】nginx.conf常用指令(Directive) bit1129 Directive
1. worker_processes 8; 表示Nginx将启动8个工作者进程，通过ps -ef|grep nginx,会发现有8个Nginx Worker Process在运行 nobody 53879 118449 0 Apr22 ? 00:26:15 nginx: worker process
lua 遍历Header头部 ronin47 lua header 遍历　
local headers = ngx.req.get_headers() ngx.say("headers begin", "<br/>") ngx.say("Host : ", he
java-32.通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小(两数组的差最小)。 bylijinnan java
import java.util.Arrays; public class MinSumASumB { /** * Q32.有两个序列a,b，大小都为n,序列元素的值任意整数，无序. * * 要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。 * 例如: * int[] a = {100,99,98,1,2,3
redis 开窍的石头 redis
在redis的redis.conf配置文件中找到# requirepass foobared 把它替换成requirepass 12356789 后边的12356789就是你的密码打开redis客户端输入config get requirepass 返回 redis 127.0.0.1:6379> config get requirepass 1) "require
[JAVA图像与图形]现有的GPU架构支持JAVA语言吗？ comsci java语言
无论是opengl还是cuda，都是建立在C语言体系架构基础上的，在未来，图像图形处理业务快速发展，相关领域市场不断扩大的情况下，我们JAVA语言系统怎么从这么庞大，且还在不断扩大的市场上分到一块蛋糕，是值得每个JAVAER认真思考和行动的事情
安装ubuntu14.04登录后花屏了怎么办 cuiyadll ubuntu
这个情况，一般属于显卡驱动问题。可以先尝试安装显卡的官方闭源驱动。按键盘三个键：CTRL + ALT + F1 进入终端，输入用户名和密码登录终端：安装amd的显卡驱动 sudo apt-get install fglrx 安装nvidia显卡驱动 sudo ap
SSL 与数字证书的基本概念和工作原理 darrenzhu 加密 ssl 证书密钥签名
SSL 与数字证书的基本概念和工作原理 http://www.linuxde.net/2012/03/8301.html SSL握手协议的目的是或最终结果是让客户端和服务器拥有一个共同的密钥，握手协议本身是基于非对称加密机制的，之后就使用共同的密钥基于对称加密机制进行信息交换。 http://www.ibm.com/developerworks/cn/webspher
Ubuntu设置ip的步骤 dcj3sjt126com ubuntu
在单位的一台机器完全装了Ubuntu Server，但回家只能在XP上VM一个，装的时候网卡是DHCP的，用ifconfig查了一下ip是192.168.92.128,可以ping通。转载不是错： Ubuntu命令行修改网络配置方法 /etc/network/interfaces打开后里面可设置DHCP或手动设置静态ip。前面auto eth0，让网卡开机自动挂载. 1. 以D
php包管理工具推荐 dcj3sjt126com PHP Composer
http://www.phpcomposer.com/ Composer是 PHP 用来管理依赖（dependency）关系的工具。你可以在自己的项目中声明所依赖的外部工具库（libraries），Composer 会帮你安装这些依赖的库文件。中文文档入门指南下载安装包列表 Composer 中国镜像
Gson使用四（TypeAdapter） eksliang json gson Gson自定义转换器 gsonTypeAdapter
转载请出自出处：http://eksliang.iteye.com/blog/2175595 一.概述 Gson的TypeAapter可以理解成自定义序列化和返序列化二、应用场景举例例如我们通常去注册时（那些外国网站），会让我们输入firstName，lastName,但是转到我们都
JQM控件之Navbar和Tabs gundumw100 html xml css
在JQM中使用导航栏Navbar是简单的。只需要将data-role="navbar"赋给div即可： <div data-role="navbar"> <ul> <li><a href="#" class="ui-btn-active&qu
利用归并排序算法对大文件进行排序 iwindyforest java 归并排序大文件分治法 Merge sort
归并排序算法介绍，请参照Wikipeida zh.wikipedia.org/wiki/%E5%BD%92%E5%B9%B6%E6%8E%92%E5%BA%8F 基本思想：大文件分割成行数相等的两个子文件，递归（归并排序）两个子文件，直到递归到分割成的子文件低于限制行数低于限制行数的子文件直接排序两个排序好的子文件归并到父文件直到最后所有排序好的父文件归并到输入
iOS UIWebView URL拦截啸笑天 UIWebView
本文译者：candeladiao，原文：URL filtering for UIWebView on the iPhone说明：译者在做app开发时，因为页面的javascript文件比较大导致加载速度很慢，所以想把javascript文件打包在app里，当UIWebView需要加载该脚本时就从app本地读取，但UIWebView并不支持加载本地资源。最后从下文中找到了解决方法，第一次翻译，难免有
索引的碎片整理SQL语句 macroli sql
SET NOCOUNT ON DECLARE @tablename VARCHAR (128) DECLARE @execstr VARCHAR (255) DECLARE @objectid INT DECLARE @indexid INT DECLARE @frag DECIMAL DECLARE @maxfrag DECIMAL --设置最大允许的碎片数量,超过则对索引进行碎片
Angularjs同步操作http请求with $promise qiaolevip 每天进步一点点学习永无止境 AngularJS 纵观千象
// Define a factory app.factory('profilePromise', ['$q', 'AccountService', function($q, AccountService) { var deferred = $q.defer(); AccountService.getProfile().then(function(res) {
hibernate联合查询问题 sxj19881213 sql Hibernate HQL 联合查询
最近在用hibernate做项目，遇到了联合查询的问题，以及联合查询中的N+1问题。针对无外键关联的联合查询，我做了HQL和SQL的实验，希望能帮助到大家。（我使用的版本是hibernate3.3.2） 1 几个常识：（1）hql中的几种join查询，只有在外键关联、并且作了相应配置时才能使用。（2）hql的默认查询策略，在进行联合查询时，会产
struts2.xml wuai struts
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache