statement.cpp

絲路server源碼 Silk Road server source

			(ODBCXX_SQLCHAR*) ODBCXX_STRING_DATA(types),
			ODBCXX_STRING_LEN(types));

  this->_checkStmtError(hstmt_,r,ODBCXX_STRING_CONST("Error fetching table information"));

  this->_afterExecute();

  ResultSet* rs=this->_getResultSet(true);


  return rs;
}


ResultSet* Statement::_getTablePrivileges(const ODBCXX_STRING& catalog,
					  const ODBCXX_STRING& schema,
					  const ODBCXX_STRING& tableName)
{
  this->_beforeExecute();
  SQLRETURN r=SQLTablePrivileges(hstmt_,
				 valueOrNull(catalog),
				 ODBCXX_STRING_LEN(catalog),
				 valueOrNull(schema),
				 ODBCXX_STRING_LEN(schema),
				 (ODBCXX_SQLCHAR*) ODBCXX_STRING_DATA(tableName),
				 ODBCXX_STRING_LEN(tableName));

  this->_checkStmtError(hstmt_,r,ODBCXX_STRING_CONST("Error fetching table privileges information"));

  this->_afterExecute();

  ResultSet* rs=this->_getResultSet(true);


  return rs;
}

ResultSet* Statement::_getColumnPrivileges(const ODBCXX_STRING& catalog,
					   const ODBCXX_STRING& schema,
					   const ODBCXX_STRING& tableName,
					   const ODBCXX_STRING& columnName)
{
  this->_beforeExecute();
  SQLRETURN r=SQLColumnPrivileges(hstmt_,
				  valueOrNull(catalog),
				  ODBCXX_STRING_LEN(catalog),
				  valueOrNull(schema),
				  ODBCXX_STRING_LEN(schema),
				  (ODBCXX_SQLCHAR*) ODBCXX_STRING_DATA(tableName),
				  ODBCXX_STRING_LEN(tableName),
				  (ODBCXX_SQLCHAR*) ODBCXX_STRING_DATA(columnName),
				  ODBCXX_STRING_LEN(columnName));

  this->_checkStmtError(hstmt_,r,ODBCXX_STRING_CONST("Error fetching column privileges information"));

  this->_afterExecute();

  ResultSet* rs=this->_getResultSet(true);


  return rs;
}



ResultSet* Statement::_getPrimaryKeys(const ODBCXX_STRING& catalog,
				      const ODBCXX_STRING& schema,
				      const ODBCXX_STRING& tableName)
{
  this->_beforeExecute();
  SQLRETURN r=SQLPrimaryKeys(hstmt_,
			     valueOrNull(catalog),
			     ODBCXX_STRING_LEN(catalog),
			     valueOrNull(schema),
			     ODBCXX_STRING_LEN(schema),
			     (ODBCXX_SQLCHAR*) ODBCXX_STRING_DATA(tableName),
			     ODBCXX_STRING_LEN(tableName));

  this->_checkStmtError(hstmt_,r,ODBCXX_STRING_CONST("Error fetching primary keys information"));

  this->_afterExecute();

  ResultSet* rs=this->_getResultSet(true);


  return rs;
}


ResultSet* Statement::_getCrossReference(const ODBCXX_STRING& pc,
					 const ODBCXX_STRING& ps,
					 const ODBCXX_STRING& pt,
					 const ODBCXX_STRING& fc,
					 const ODBCXX_STRING& fs,
					 const ODBCXX_STRING& ft)
{
  this->_beforeExecute();

  SQLRETURN r=SQLForeignKeys(hstmt_,
			     valueOrNull(pc),
			     ODBCXX_STRING_LEN(pc),
			     valueOrNull(ps),
			     ODBCXX_STRING_LEN(ps),
			     (ODBCXX_SQLCHAR*) ODBCXX_STRING_DATA(pt),
			     ODBCXX_STRING_LEN(pt),
			     valueOrNull(fc),
			     ODBCXX_STRING_LEN(fc),
			     valueOrNull(fs),
			     ODBCXX_STRING_LEN(fs),
			     (ODBCXX_SQLCHAR*) ODBCXX_STRING_DATA(ft),
			     ODBCXX_STRING_LEN(ft));

  this->_checkStmtError(hstmt_,r,ODBCXX_STRING_CONST("Error fetching foreign keys information"));

  this->_afterExecute();

  ResultSet* rs=this->_getResultSet(true);

  return rs;
}



ResultSet* Statement::_getIndexInfo(const ODBCXX_STRING& catalog,
				    const ODBCXX_STRING& schema,
				    const ODBCXX_STRING& tableName,
				    bool unique, bool approximate)
{
  this->_beforeExecute();
  SQLRETURN r=SQLStatistics(hstmt_,
			    valueOrNull(catalog),
			    ODBCXX_STRING_LEN(catalog),
			    valueOrNull(schema),
			    ODBCXX_STRING_LEN(schema),
			    (ODBCXX_SQLCHAR*) ODBCXX_STRING_DATA(tableName),
			    ODBCXX_STRING_LEN(tableName),
			    unique?SQL_INDEX_UNIQUE:SQL_INDEX_ALL,
			    approximate?SQL_QUICK:SQL_ENSURE);

  this->_checkStmtError(hstmt_,r,ODBCXX_STRING_CONST("Error fetching index information"));

  this->_afterExecute();

  ResultSet* rs=this->_getResultSet(true);

  return rs;
}


ResultSet* Statement::_getProcedures(const ODBCXX_STRING& catalog,
				     const ODBCXX_STRING& schema,
				     const ODBCXX_STRING& procName)
{
  this->_beforeExecute();
  SQLRETURN r=SQLProcedures(hstmt_,
			    valueOrNull(catalog),
			    ODBCXX_STRING_LEN(catalog),
			    valueOrNull(schema),
			    ODBCXX_STRING_LEN(schema),
			    (ODBCXX_SQLCHAR*) ODBCXX_STRING_DATA(procName),
			    ODBCXX_STRING_LEN(procName));

  this->_checkStmtError(hstmt_,r,ODBCXX_STRING_CONST("Error fetching procedures information"));

  ResultSet* rs=this->_getResultSet(true);

  return rs;
}


ResultSet* Statement::_getProcedureColumns(const ODBCXX_STRING& catalog,
					   const ODBCXX_STRING& schema,
					   const ODBCXX_STRING& procName,
					   const ODBCXX_STRING& colName)
{
  this->_beforeExecute();
  SQLRETURN r=SQLProcedureColumns(hstmt_,
				  valueOrNull(catalog),
				  ODBCXX_STRING_LEN(catalog),
				  valueOrNull(schema),
				  ODBCXX_STRING_LEN(schema),
				  (ODBCXX_SQLCHAR*) ODBCXX_STRING_DATA(procName),
				  ODBCXX_STRING_LEN(procName),
				  (ODBCXX_SQLCHAR*) ODBCXX_STRING_DATA(colName),
				  ODBCXX_STRING_LEN(colName));

  this->_checkStmtError(hstmt_,r,ODBCXX_STRING_CONST("Error fetching procedures information"));

  ResultSet* rs=this->_getResultSet(true);

  return rs;
}

ResultSet* Statement::_getSpecialColumns(const ODBCXX_STRING& catalog,
					 const ODBCXX_STRING& schema,
					 const ODBCXX_STRING& table,
					 int what, int scope,
					 int nullable)
{
  this->_beforeExecute();
  SQLRETURN r=SQLSpecialColumns(hstmt_,what,
				valueOrNull(catalog),
				ODBCXX_STRING_LEN(catalog),
				valueOrNull(schema),
				ODBCXX_STRING_LEN(schema),
				(ODBCXX_SQLCHAR*) ODBCXX_STRING_DATA(table),
				ODBCXX_STRING_LEN(table),
				scope,nullable);
  this->_checkStmtError(hstmt_,r,ODBCXX_STRING_CONST("Error fetching special columns"));

  ResultSet* rs=this->_getResultSet(true);

  return rs;
}



Connection* Statement::getConnection()
{
  return connection_;
}


int Statement::getQueryTimeout()
{
  return this->_getNumericOption
    (ODBC3_C(SQL_ATTR_QUERY_TIMEOUT,SQL_QUERY_TIMEOUT));
}


void Statement::setQueryTimeout(int seconds)
{
  this->_setNumericOption
    (ODBC3_C(SQL_ATTR_QUERY_TIMEOUT,SQL_QUERY_TIMEOUT),seconds);
}


int Statement::getMaxRows()
{
  return this->_getNumericOption
    (ODBC3_C(SQL_ATTR_MAX_ROWS,SQL_MAX_ROWS));
}


void Statement::setMaxRows(int maxRows)
{
  this->_setNumericOption
    (ODBC3_C(SQL_ATTR_MAX_ROWS,SQL_MAX_ROWS),maxRows);
}

int Statement::getMaxFieldSize()
{
  return this->_getNumericOption
    (ODBC3_C(SQL_ATTR_MAX_LENGTH,SQL_MAX_LENGTH));
}

void Statement::setMaxFieldSize(int maxFieldSize)
{
  this->_setNumericOption
    (ODBC3_C(SQL_ATTR_MAX_LENGTH,SQL_MAX_LENGTH),maxFieldSize);
}


void Statement::cancel()
{
  SQLRETURN r=SQLCancel(hstmt_);
  this->_checkStmtError(hstmt_,r,ODBCXX_STRING_CONST("Error canceling statement"));
}


int Statement::getUpdateCount()
{
  // For ODBC3, if the last call to SQLExecute or SQLExecDirect
  // returned SQL_NO_DATA, a call to SQLRowCount can cause a
  // function sequence error. Therefore, if the last result is
  // SQL_NO_DATA, we simply return 0

  // Since an ODBC2 driver manager might be using

  if(lastExecute_!=ODBC3_C(SQL_NO_DATA,SQL_NO_DATA_FOUND)) {

    SQLINTEGER res;
    SQLRETURN r=SQLRowCount(hstmt_,&res);
    this->_checkStmtError(hstmt_,r,ODBCXX_STRING_CONST("Error fetching update count"));
    return res;

  } else {
    return -1;
  }
}


void Statement::setCursorName(const ODBCXX_STRING& name)
{
  SQLRETURN r=SQLSetCursorName(hstmt_,
			       (ODBCXX_SQLCHAR*) ODBCXX_STRING_DATA(name),
			       ODBCXX_STRING_LEN(name));
  this->_checkStmtError(hstmt_,r,ODBCXX_STRING_CONST("Error setting cursor name"));
}


bool Statement::execute(const ODBCXX_STRING& sql)
{

  this->_beforeExecute();

  SQLRETURN r=SQLExecDirect(hstmt_,
			    (ODBCXX_SQLCHAR*) ODBCXX_STRING_DATA(sql),
			    ODBCXX_STRING_LEN(sql));

  lastExecute_=r;

  ODBCXX_STRING msg=ODBCXX_STRING_CONST("Error executing \"")+sql+ODBCXX_STRING_CONST("\"");

  this->_checkStmtError(hstmt_,r,ODBCXX_STRING_CSTR(msg));

  this->_afterExecute();

  return this->_checkForResults();
}

ResultSet* Statement::executeQuery(const ODBCXX_STRING& sql)
{
  this->execute(sql);
  return this->_getResultSet();
}


int Statement::executeUpdate(const ODBCXX_STRING& sql)
{
  this->execute(sql);
  return this->getUpdateCount();
}

ResultSet* Statement::getResultSet()
{
  if(this->_checkForResults()) {
    return this->_getResultSet();
  }
  return NULL;
}


bool Statement::getMoreResults()
{
  if(this->_getDriverInfo()->supportsFunction(SQL_API_SQLMORERESULTS)) {
    SQLRETURN r=SQLMoreResults(hstmt_);
    this->_checkStmtError(hstmt_,r,ODBCXX_STRING_CONST("Error checking for more results"));
    // needed for getUpdateCount() to correctly
    // support the traversal of multiple results
    lastExecute_=r;

    return (r==SQL_SUCCESS ||
	    r==SQL_SUCCESS_WITH_INFO);
  }
  return false;
}


void Statement::setFetchSize(int fs)
{
  if(fs>0) {
    fetchSize_=fs;
  } else if (fs==0) {
    fetchSize_=SQL_ROWSET_SIZE_DEFAULT;
  } else {
    throw SQLException(ODBCXX_STRING_CONST("Invalid fetch size"));
  }
}


void Statement::setEscapeProcessing(bool on)
{
  this->_setNumericOption
    (ODBC3_C(SQL_ATTR_NOSCAN,SQL_NOSCAN),on?SQL_NOSCAN_OFF:SQL_NOSCAN_ON);
}

bool Statement::getEscapeProcessing()
{
  return this->_getNumericOption
    (ODBC3_C(SQL_ATTR_NOSCAN,SQL_NOSCAN))==SQL_NOSCAN_OFF;
}

void Statement::close()
{
  if(state_==STATE_OPEN) {
    SQLRETURN r=SQLFreeStmt(hstmt_,SQL_CLOSE);
    this->_checkStmtError(hstmt_,r,ODBCXX_STRING_CONST("Error closing all results for statement"));

    state_=STATE_CLOSED;
  }
}