---

ODBCPreparedStatement Class Reference

#include <ODBCPreparedStatement.h>

Inheritance diagram for ODBCPreparedStatement:

[legend]Collaboration diagram for ODBCPreparedStatement:

[legend]List of all members.

Public Methods
virtual	~ODBCPreparedStatement ()
void	SetNull (Int_t parameterIndex, Int_t sqlType)
void	SetBoolean (Int_t parameterIndex, Bool_t x)
void	SetByte (Int_t parameterIndex, Char_t x)
void	SetShort (Int_t parameterIndex, Short_t x)
void	SetInt (Int_t parameterIndex, Int_t x)
void	SetLong (Int_t parameterIndex, Long_t x)
void	SetFloat (Int_t parameterIndex, Float_t x)
void	SetDouble (Int_t parameterIndex, Double_t x)
void	SetString (Int_t parameterIndex, const TString &x)
void	SetBytes (Int_t parameterIndex, const TArrayC &x)
void	SetDate (Int_t parameterIndex, const TSQLDate &x)
void	SetTime (Int_t parameterIndex, const TSQLTime &x)
void	SetTimestamp (Int_t parameterIndex, const TSQLTimestamp &x)
void	SetAsciiStream (Int_t parameterIndex, TBuffer *x, Int_t length)
void	SetBinaryStream (Int_t parameterIndex, TBuffer *x, Int_t length)
void	SetObject (Int_t parameterIndex, TObject *x)
void	ClearParameters ()
virtual Bool_t	Execute (const TString &sql="")
virtual TSQLResultSet *	ExecuteQuery (const TString &sql="")
virtual Int_t	ExecuteUpdate (const TString &sql="")
TSQLResultSet *	GetResultSet ()
Bool_t	GetMoreResults ()
void	Close ()
void	Cancel ()
Int_t	GetMaxFieldSize ()
void	SetMaxFieldSize (Int_t max)
Int_t	GetMaxRows ()
void	SetMaxRows (Int_t max)
Bool_t	GetEscapeProcessing ()
void	SetEscapeProcessing (Bool_t enable=kTRUE)
Int_t	GetQueryTimeout ()
void	SetQueryTimeout (Int_t seconds)
Int_t	GetUpdateCount ()
void	SetCursorName (const TString &name)
void	AddBatch (const TString &sql)
void	ClearBatch ()
Int_t *	ExecuteBatch ()
Int_t	GetFetchDirection ()
void	SetFetchDirection (Int_t direction)
Int_t	GetFetchSize ()
void	SetFetchSize (Int_t rows)
Int_t	GetResultSetConcurrency ()
Int_t	GetResultSetType ()
Protected Methods
	ODBCPreparedStatement (TSQLConnection *con, void *imp=0)
Friends
class	ODBCConnection

---

Constructor & Destructor Documentation

ODBCPreparedStatement::ODBCPreparedStatement (  TSQLConnection *    con, void *    imp = 0 )  [protected]

ODBCPreparedStatement::~ODBCPreparedStatement (    )  [virtual]

Definition at line 85 of file ODBCPreparedStatement.cxx. References TSQLStatement::fCurrentResult, TSQL::fImp, ODBCXX_STRING_CSTR, and TSQL::Throw(). { // dtor odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { if(imp) delete imp; } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } // implementation part of fCurrentResult is deleted with statement if(fCurrentResult) ((ODBCResultSet*)fCurrentResult)->fImp = 0; fImp = 0; }

---

Member Function Documentation

void ODBCPreparedStatement::AddBatch (  const TString &    sql )  [virtual]

Implements TSQLStatement. Definition at line 1292 of file ODBCPreparedStatement.cxx. { // Adds a SQL command to the current batch of commmands for // the statement. This method is optional. // // Parameters: // sql - typically this is a static SQL INSERT or UPDATE // statement // Throws: // TSQLException - if a database access error occurs, or // the driver does not support batch statements }

void ODBCPreparedStatement::Cancel (    )  [virtual]

Implements TSQLStatement. Definition at line 1058 of file ODBCPreparedStatement.cxx. References odbc::Statement::cancel(), TSQL::fImp, ODBCXX_STRING_CSTR, and TSQL::Throw(). { // Cancels this statement object if both the DBMS and driver // support aborting an SQL statement. This method can be used by // one thread to cancel a statement that is being executed by // another thread. // // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::Statement* stmt = (odbc::Statement*)fImp; try { stmt->cancel(); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::ClearBatch (    )  [virtual]

Implements TSQLStatement. Definition at line 1307 of file ODBCPreparedStatement.cxx. Referenced by Close(). { // Makes the set of commands in the current batch empty. This // method is optional. // // Throws: // TSQLException - if a database access error occurs or // the driver does not support batch statements }

void ODBCPreparedStatement::ClearParameters (    )  [virtual]

Implements TSQLPreparedStatement. Definition at line 574 of file ODBCPreparedStatement.cxx. References odbc::PreparedStatement::clearParameters(), TSQL::fImp, ODBCXX_STRING_CSTR, and TSQL::Throw(). { // Clears the current parameter values immediately. // // In general, parameter values remain in force for repeated // use of a TSQLStatement. Setting a parameter value // automatically clears its previous value. However, in some // cases it is useful to immediately release the resources used // by the current parameter values; this can be done by calling // ClearParameters(). // // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { imp->clearParameters(); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::Close (    )  [virtual]

Implements TSQLStatement. Definition at line 1081 of file ODBCPreparedStatement.cxx. References ClearBatch(), TSQLStatement::fBatches, TSQLStatement::fCurrentResult, TSQL::fImp, ODBCXX_STRING_CSTR, and TSQL::Throw(). { // Avoid using this method. Use delete ODBCStatement instead. // // Note: When a ODBCStatement is closed, its current // TSQLResultSet, if one exists, is also closed. // // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } try { if(fCurrentResult) { delete fCurrentResult; fCurrentResult = 0; } ClearBatch(); SafeDelete(fBatches); odbc::Statement* imp = (odbc::Statement*)fImp; if(imp) delete imp; } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } fImp = 0; Destroyed(); }

Bool_t ODBCPreparedStatement::Execute (  const TString &    sql = "" )  [virtual]

Implements TSQLStatement. Definition at line 642 of file ODBCPreparedStatement.cxx. References TSQL::ClearWarnings(), odbc::PreparedStatement::execute(), odbc::Statement::execute(), TSQL::fImp, ODBCXX_STRING_C, ODBCXX_STRING_CSTR, and TSQL::Throw(). { // Executes a SQL statement that may return multiple results. // Under some (uncommon) situations a single SQL statement may // return multiple result sets and/or update counts. Normally you // can ignore this unless you are (1) executing a stored // procedure that you know may return multiple results or (2) you // are dynamically executing an unknown SQL string. The methods // execute, GetMoreResults(), GetResultSet(), and GetUpdateCount() // let you navigate through multiple results. // The execute method executes a SQL statement and indicates the // form of the first result. You can then use GetResultSet() or // GetUpdateCount() to retrieve the result, and GetMoreResults() // to move to any subsequent result(s). // // Parameters: // sql - any SQL statement // Returns: // kTRUE if the next result is a TSQLResultSet; // kFALSE if it is an update count or there are no more // results // Throws: // TSQLException - if a database access error occurs // See Also: // GetResultSet(), GetUpdateCount(), GetMoreResults() if(!fImp) { Destroyed(); return kFALSE; } Bool_t return_value = kFALSE; ClearWarnings(); odbc::Statement* stmt = (odbc::Statement*)fImp; odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { if(!sql.IsNull()) { return_value = (Bool_t)stmt->execute(ODBCXX_STRING_C(sql.Data())); } else { return_value = imp->execute(); } } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); return_value = kFALSE; } return return_value; }

Int_t * ODBCPreparedStatement::ExecuteBatch (    )  [virtual]

Implements TSQLStatement. Definition at line 1319 of file ODBCPreparedStatement.cxx. { // Submits a batch of commands to the database for execution. // This method is optional. // // Returns: // an array of update counts containing one element for // each command in the batch. The array is ordered // according to the order in which commands were inserted // into the batch. // // Throws: // TSQLException - if a database access error occurs or // the driver does not support batch statements return 0; }

TSQLResultSet * ODBCPreparedStatement::ExecuteQuery (  const TString &    sql = "" )  [virtual]

Implements TSQLStatement. Definition at line 602 of file ODBCPreparedStatement.cxx. References TSQL::ClearWarnings(), odbc::PreparedStatement::executeQuery(), odbc::Statement::executeQuery(), TSQLStatement::fCurrentResult, TSQL::fImp, ODBCXX_STRING_C, ODBCXX_STRING_CSTR, and TSQL::Throw(). { // Executes a SQL statement that returns a single TSQLResultSet // // This method also implicitly closes current TSQLResultSet // // Returns: // a TSLResultSet that contains the data produced by the query; // NULL - in case of error // // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return 0; } odbc::Statement* stmt = (odbc::Statement*)fImp; odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; odbc::ResultSet* rs = 0; ClearWarnings(); if(fCurrentResult) delete fCurrentResult; try { if(!sql.IsNull()) { rs = stmt->executeQuery(ODBCXX_STRING_C(sql.Data())); } else { rs = imp->executeQuery(); } } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); if(rs) delete rs; fCurrentResult = 0; return 0; } return fCurrentResult = new ODBCResultSet(this,(void*)rs);; }

Int_t ODBCPreparedStatement::ExecuteUpdate (  const TString &    sql = "" )  [virtual]

Implements TSQLStatement. Definition at line 691 of file ODBCPreparedStatement.cxx. References TSQL::ClearWarnings(), odbc::PreparedStatement::executeUpdate(), odbc::Statement::executeUpdate(), TSQL::fImp, ODBCXX_STRING_C, ODBCXX_STRING_CSTR, and TSQL::Throw(). { // Executes an SQL INSERT, UPDATE or DELETE statement. // In addition, SQL statements that return nothing, // such as SQL DDL statements, can be executed. // // Parameters: // sql - a SQL INSERT, UPDATE or DELETE statement or // a SQL statement that returns nothing // // Returns: // either the row count for INSERT, UPDATE or DELETE or // 0 for SQL statements that return nothing // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return 0; } Int_t return_value = 0; ClearWarnings(); odbc::Statement* stmt = (odbc::Statement*)fImp; odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { if(!sql.IsNull()) { return_value = stmt->executeUpdate(ODBCXX_STRING_C(sql.Data())); } else { return_value = imp->executeUpdate(); } } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); return_value = 0; } return return_value; }

Bool_t ODBCPreparedStatement::GetEscapeProcessing (    )  [virtual]

Implements TSQLStatement. Definition at line 971 of file ODBCPreparedStatement.cxx. References TSQL::fImp, odbc::Statement::getEscapeProcessing(), ODBCXX_STRING_CSTR, and TSQL::Throw(). { // Returns if escape processing is on or off. // If escape scanning is on (the default), the driver will do escape // substitution before sending the SQL to the database. // // Note: // Since prepared statements have usually been parsed prior to // making this call, disabling escape processing for prepared // statements will have no effect. // // Parameters: // enable - kTRUE to enable; kFALSE to disable // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return kFALSE; } Bool_t return_value = kFALSE; odbc::Statement* stmt = (odbc::Statement*)fImp; try { return_value = stmt->getEscapeProcessing(); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); return kFALSE; } return return_value; }

Int_t ODBCPreparedStatement::GetFetchDirection (    )  [virtual]

Implements TSQLStatement. Definition at line 1171 of file ODBCPreparedStatement.cxx. { // Retrieves the direction for fetching rows from database // tables that is the default for result sets generated from this // statement object. If this statement object has not set // a fetch direction by calling the method SetFetchDirection(), // the return value is implementation-specific. // // Returns: // the default fetch direction for result sets generated // from this statement object // Throws: // TSQLException - if a database access error occurs return 0; }

Int_t ODBCPreparedStatement::GetFetchSize (    )  [virtual]

Implements TSQLStatement. Definition at line 1207 of file ODBCPreparedStatement.cxx. References TSQL::fImp, odbc::Statement::getFetchSize(), ODBCXX_STRING_CSTR, and TSQL::Throw(). { // Retrieves the number of result set rows that is the default // fetch size for result sets generated from this ODBCStatement // object. If this statement object has not set a fetch size // by calling the method SetFetchSize(), the return value is // implementation-specific. // // Returns: // the default fetch size for result sets generated from // this statement object // Throws: // TSQLException - if a database access error occurs Int_t return_value = 0; if(!fImp) { Destroyed(); return return_value; } odbc::Statement* stmt = (odbc::Statement*)fImp; try { return_value = stmt->getFetchSize(); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); return 0; } return return_value; }

Int_t ODBCPreparedStatement::GetMaxFieldSize (    )  [virtual]

Implements TSQLStatement. Definition at line 831 of file ODBCPreparedStatement.cxx. References TSQL::fImp, odbc::Statement::getMaxFieldSize(), ODBCXX_STRING_CSTR, and TSQL::Throw(). { // Returns the maximum number of bytes allowed for any column // value. This limit is the maximum number of bytes that can be // returned for any column value. The limit applies only to // kBINARY, kVARBINARY, kLONGVARBINARY, kCHAR, kVARCHAR, and // kLONGVARCHAR columns (see TSQLTypes.h). If the limit is exceeded, // the excess data is silently discarded. // // Returns: // the current max column size limit; zero means unlimited // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return 0; } Int_t return_value = 0; odbc::Statement* stmt = (odbc::Statement*)fImp; try { return_value = stmt->getMaxFieldSize(); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); return 0; } return return_value; }

Int_t ODBCPreparedStatement::GetMaxRows (    )  [virtual]

Implements TSQLStatement. Definition at line 890 of file ODBCPreparedStatement.cxx. References TSQL::fImp, odbc::Statement::getMaxRows(), ODBCXX_STRING_CSTR, and TSQL::Throw(). { // Retrieves the maximum number of rows that a TSQLResultSet can // contain. If the limit is exceeded, the excess rows are silently // dropped. // // Returns: // the current max row limit; zero means unlimited // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return 0; } Int_t return_value = 0; odbc::Statement* stmt = (odbc::Statement*)fImp; try { return_value = stmt->getMaxRows(); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); return 0; } return return_value; }

Bool_t ODBCPreparedStatement::GetMoreResults (    )  [virtual]

Implements TSQLStatement. Definition at line 797 of file ODBCPreparedStatement.cxx. References TSQL::fImp, odbc::Statement::getMoreResults(), ODBCXX_STRING_CSTR, and TSQL::Throw(). { // Moves to a ODBCStatement's next result. It returns kTRUE if // this result is a TSQLResultSet. // // There are no more results when // (!GetMoreResults() && (GetUpdateCount() == -1) // // Returns: // kTRUE if the next result is a TSQLResultSet; // kFALSE if it is an update count or there are no more results // // Throws: // TSQLException - if a database access error occurs // See Also: // Execute(const TString&) Bool_t return_value = kFALSE; if(!fImp) { Destroyed(); return return_value; } odbc::Statement* stmt = (odbc::Statement*)fImp; try { return_value = (Bool_t)stmt->getMoreResults(); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); return kFALSE; } return return_value; }

Int_t ODBCPreparedStatement::GetQueryTimeout (    )  [virtual]

Implements TSQLStatement. Definition at line 1004 of file ODBCPreparedStatement.cxx. References TSQL::fImp, odbc::Statement::getQueryTimeout(), ODBCXX_STRING_CSTR, and TSQL::Throw(). { // Retrieves the number of seconds the driver will wait for a // ODBCStatement to execute. If the limit is exceeded, a // TSQLException is thrown. // // Returns: // the current query timeout limit in seconds; zero means // unlimited // Throws: // TSQLException - if a database access error occurs Int_t return_value = 0; if(!fImp) { Destroyed(); return return_value; } odbc::Statement* stmt = (odbc::Statement*)fImp; try { return_value = stmt->getQueryTimeout(); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); return 0; } return return_value; }

TSQLResultSet * ODBCPreparedStatement::GetResultSet (    )  [virtual]

Implements TSQLStatement. Definition at line 730 of file ODBCPreparedStatement.cxx. References TSQLStatement::fCurrentResult, TSQL::fImp, odbc::Statement::getResultSet(), ODBCXX_STRING_CSTR, and TSQL::Throw(). { // Returns the current result as a TSQLResultSet object. // This method should be called only once per result. // // This method also implicitly closes any current TSQLResultSet // // Returns: // the current result as a TSQLResultSet; null if the result // is an update count or there are no more results // Throws: // TSQLException - if a database access error occurs // See Also: // Execute(const TString&) if(!fImp) { Destroyed(); return 0; } odbc::ResultSet* rs; odbc::Statement* stmt = (odbc::Statement*)fImp; if(fCurrentResult) delete fCurrentResult; try { rs = stmt->getResultSet(); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); if(rs) delete rs; fCurrentResult = 0; return 0; } return fCurrentResult = new ODBCResultSet(this,(void*)rs); }

Int_t ODBCPreparedStatement::GetResultSetConcurrency (    )  [virtual]

Implements TSQLStatement. Definition at line 1238 of file ODBCPreparedStatement.cxx. References TSQL::fImp, odbc::Statement::getResultSetConcurrency(), ODBCXX_STRING_CSTR, and TSQL::Throw(). { // Retrieves the result set concurrency. // // enum EResultSetConcurrency{ // kCONCUR_READ_ONLY, // kCONCUR_UPDATABLE // }; Int_t return_value = 0; if(!fImp) { Destroyed(); return return_value; } odbc::Statement* stmt = (odbc::Statement*)fImp; try { return_value = stmt->getResultSetConcurrency(); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); return 0; } return return_value; }

Int_t ODBCPreparedStatement::GetResultSetType (    )  [virtual]

Implements TSQLStatement. Definition at line 1264 of file ODBCPreparedStatement.cxx. References TSQL::fImp, odbc::Statement::getResultSetType(), ODBCXX_STRING_CSTR, and TSQL::Throw(). { // Determine the result set type. // // enum EResultSetType{ // kTYPE_FORWARD_ONLY, // kTYPE_SCROLL_INSENSITIVE, // kTYPE_SCROLL_SENSITIVE // }; // Int_t return_value = 0; if(!fImp) { Destroyed(); return return_value; } odbc::Statement* stmt = (odbc::Statement*)fImp; try { return_value = stmt->getResultSetType(); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); return 0; } return return_value; }

Int_t ODBCPreparedStatement::GetUpdateCount (    )  [virtual]

Implements TSQLStatement. Definition at line 766 of file ODBCPreparedStatement.cxx. References TSQL::fImp, odbc::Statement::getUpdateCount(), ODBCXX_STRING_CSTR, and TSQL::Throw(). { // Returns the current result as an update count; // if there are no more results, -1 is returned. // This method should be called only once per result. // // Returns: // the current result as an update count; -1 if it is a // TSQLResultSet or there are no more results // Throws: // TSQLException - if a database access error occurs // See Also: // Execute(const TString&) if(!fImp) { Destroyed(); return 0; } Int_t return_value = 0; odbc::Statement* stmt = (odbc::Statement*)fImp; try { return_value = stmt->getUpdateCount(); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); return 0; } return return_value; }

void ODBCPreparedStatement::SetAsciiStream (  Int_t    parameterIndex, TBuffer *    x, Int_t    length )  [virtual]

Implements TSQLPreparedStatement. Definition at line 480 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_STRING_CSTR, odbc::PreparedStatement::setAsciiStream(), and TSQL::Throw(). { // Sets the designated parameter to the given input stream, // which will have the specified number of bytes. When a very // large ASCII value is input to a LONGVARCHAR parameter, it // may be more practical to send it via a TBuffer // will read the data from the stream as needed, until it // reaches end-of-file. The driver will do any necessary // conversion from ASCII to the database char format. // // Parameters: // parameterIndex - the first parameter is 1, // the second is 2, ... // x - the input stream that contains the ASCII // parameter value // length - the number of bytes in the stream, // total size of buffer is by default. // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { Int_t xl = x->BufferSize()>length ? length : x->BufferSize(); istrstream* s = new istrstream(x->Buffer(),xl); // imp->setAsciiStream( parameterIndex,(std::istream*)s,xl ); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetBinaryStream (  Int_t    parameterIndex, TBuffer *    x, Int_t    length )  [virtual]

Implements TSQLPreparedStatement. Definition at line 518 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_STRING_CSTR, odbc::PreparedStatement::setBinaryStream(), and TSQL::Throw(). Referenced by SetObject(). { // Sets the designated parameter to the given input stream, // which will have the specified number of bytes. When a very // large binary value is input to a LONGVARBINARY parameter, it // may be more practical to send it via a TBuffer. // will read the data from the stream as needed, until it // reaches end-of-file. // // Parameters: // parameterIndex - the first parameter is 1, // the second is 2, ... // x - the input tream which contains the binary // parameter value // length - the number of bytes in the stream // total size of buffer is by default. // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { Int_t xl = x->BufferSize()>length ? length : x->BufferSize(); istrstream* s = new istrstream(x->Buffer(),xl); // imp->setBinaryStream( parameterIndex,(std::istream*)s,xl ); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetBoolean (  Int_t    parameterIndex, Bool_t    x )  [virtual]

Implements TSQLPreparedStatement. Definition at line 132 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_STRING_CSTR, odbc::PreparedStatement::setBoolean(), and TSQL::Throw(). { // Sets the designated parameter to a Bool_t value. The // driver converts this to an SQL BIT value when it sends it to // the database. // // Parameters: // parameterIndex - the first parameter is 1, // the second is 2, ... // x - the parameter value // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { imp->setBoolean(parameterIndex,x); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetByte (  Int_t    parameterIndex, Char_t    x )  [virtual]

Implements TSQLPreparedStatement. Definition at line 159 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_STRING_CSTR, odbc::PreparedStatement::setByte(), and TSQL::Throw(). { // Sets the designated parameter to a byte value. The // driver converts this to an SQL TINYINT value when it sends // it to the database. // // Parameters: // parameterIndex - the first parameter is 1, // the second is 2, ... // x - the parameter value // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { imp->setByte(parameterIndex,x); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetBytes (  Int_t    parameterIndex, const TArrayC &    x )  [virtual]

Implements TSQLPreparedStatement. Definition at line 350 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_BYTES_C, ODBCXX_STRING_CSTR, odbc::PreparedStatement::setBytes(), and TSQL::Throw(). { // Sets the designated parameter to a array of bytes. The // driver converts this to an SQL VARBINARY or LONGVARBINARY // (depending on the argument's size relative to the driver's // limits on VARBINARYs) when it sends it to the database. // // Parameters: // parameterIndex - the first parameter is 1, // the second is 2, ... // x - the parameter value // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { imp->setBytes( parameterIndex, ODBCXX_BYTES_C(x.GetArray(),x.GetSize()) ); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetCursorName (  const TString &    name )  [virtual]

Implements TSQLStatement. Definition at line 1113 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_STRING_C, ODBCXX_STRING_CSTR, odbc::Statement::setCursorName(), and TSQL::Throw(). { // Defines the SQL cursor name that will be used by subsequent // ODBCStatement execute methods. This name can then be used in // SQL positioned update/delete statements to identify the // current row in the TSQLResultSet generated by this statement. // If the database doesn't support positioned update/delete, // this method is a noop. To insure that a cursor has the proper // isolation level to support updates, the cursor's SELECT // statement should be of the form 'SELECT FOR UPDATE ...'. If // the 'FOR UPDATE' phrase is omitted, positioned updates may // fail. // // Note: By definition, positioned update/delete execution must // be done by a different ODBCStatement than the one which // generated the TSQLResultSet being used for positioning. // Also, cursor names must be unique within a connection. // // Parameters: // name - the new cursor name, which must be unique within // a connection // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::Statement* stmt = (odbc::Statement*)fImp; try { stmt->setCursorName(ODBCXX_STRING_C(name.Data())); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetDate (  Int_t    parameterIndex, const TSQLDate &    x )  [virtual]

Implements TSQLPreparedStatement. Definition at line 380 of file ODBCPreparedStatement.cxx. References TSQL::fImp, TSQLDate::GetDay(), TSQLDate::GetMonth(), TSQLDate::GetYear(), ODBCXX_STRING_CSTR, odbc::PreparedStatement::setDate(), and TSQL::Throw(). { // Sets the designated parameter to a TSQLDate value. The // driver converts this to an SQL DATE value when it sends it // to the database. // // Parameters: // parameterIndex - the first parameter is 1, // the second is 2, ... // x - the parameter value // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { odbc::Date dt( x.GetYear(), x.GetMonth(), x.GetDay() ); imp->setDate(parameterIndex,dt); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetDouble (  Int_t    parameterIndex, Double_t    x )  [virtual]

Implements TSQLPreparedStatement. Definition at line 294 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_STRING_CSTR, odbc::PreparedStatement::setDouble(), and TSQL::Throw(). { // Sets the designated parameter to a double value. The // driver converts this to an SQL DOUBLE value when it sends it // to the database. // // Parameters: // parameterIndex - the first parameter is 1, // the second is 2, ... // x - the parameter value // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { imp->setDouble(parameterIndex,x); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetEscapeProcessing (  Bool_t    enable = kTRUE )  [virtual]

Implements TSQLStatement. Definition at line 942 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_STRING_CSTR, odbc::Statement::setEscapeProcessing(), and TSQL::Throw(). { // Sets escape processing on or off. If escape scanning is on // (the default), the driver will do escape substitution before // sending the SQL to the database. // // Note: // Since prepared statements have usually been parsed prior to // making this call, disabling escape processing for prepared // statements will have no effect. // // Parameters: // enable - kTRUE to enable; kFALSE to disable // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::Statement* stmt = (odbc::Statement*)fImp; try { stmt->setEscapeProcessing(enable); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetFetchDirection (  Int_t    direction )  [virtual]

Implements TSQLStatement. Definition at line 1150 of file ODBCPreparedStatement.cxx. References TSQL::fImp. { // Gives the driver a hint as to the direction in which the // rows in a result set will be processed. The hint applies only // to result sets created using this statement object. // The default value is TSQLResultSet::kTYPE_FORWARD_ONLY // // Note that this method sets the default fetch direction for // result sets generated by this statement object. // // Parameters: // direction - the initial direction for processing rows // Throws: // TSQLException - if a database access error occurs or the // given direction is not one of // if(!fImp) { Destroyed(); return; } }

void ODBCPreparedStatement::SetFetchSize (  Int_t    rows )  [virtual]

Implements TSQLStatement. Definition at line 1189 of file ODBCPreparedStatement.cxx. References TSQL::fImp. { // Gives the driver a hint as to the number of rows that // should be fetched from the database when more rows are needed. // The number of rows specified affects only result sets created // using this statement. If the value specified is zero, then the // hint is ignored. The default value is zero. // // Parameters: // rows - the number of rows to fetch // Throws: // TSQLException - if a database access error occurs, or // the condition 0 <= rows <= GetMaxRows() is not satisfied. if(!fImp) { Destroyed(); return; } }

void ODBCPreparedStatement::SetFloat (  Int_t    parameterIndex, Float_t    x )  [virtual]

Implements TSQLPreparedStatement. Definition at line 267 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_STRING_CSTR, odbc::PreparedStatement::setFloat(), and TSQL::Throw(). { // Sets the designated parameter to a float value. The // driver converts this to an SQL FLOAT value when it sends it // to the database. // // Parameters: // parameterIndex - the first parameter is 1, // the second is 2, ... // x - the parameter value // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { imp->setFloat(parameterIndex,x); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetInt (  Int_t    parameterIndex, Int_t    x )  [virtual]

Implements TSQLPreparedStatement. Definition at line 213 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_STRING_CSTR, odbc::PreparedStatement::setInt(), and TSQL::Throw(). { // Sets the designated parameter to a int value. The // driver converts this to an SQL INTEGER value when it sends // it to the database. // // Parameters: // parameterIndex - the first parameter is 1, // the second is 2, ... // x - the parameter value // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { imp->setInt(parameterIndex,x); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetLong (  Int_t    parameterIndex, Long_t    x )  [virtual]

Implements TSQLPreparedStatement. Definition at line 240 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_STRING_CSTR, odbc::PreparedStatement::setLong(), and TSQL::Throw(). { // Sets the designated parameter to a long value. The // driver converts this to an SQL BIGINT value when it sends it // to the database. // // Parameters: // parameterIndex - the first parameter is 1, // the second is 2, ... // x - the parameter value // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { imp->setLong(parameterIndex,x); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetMaxFieldSize (  Int_t    max )  [virtual]

Implements TSQLStatement. Definition at line 862 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_STRING_CSTR, odbc::Statement::setMaxFieldSize(), and TSQL::Throw(). { // Sets the limit for the maximum number of bytes in a column to // the given number of bytes. This is the maximum number of bytes // that can be returned for any column value. This limit applies // only to kBINARY, kVARBINARY, kLONGVARBINARY, kCHAR, kVARCHAR, // and kLONGVARCHAR fields (see TSQLTypes.h) . If the limit is exceeded, // the excess data is silently discarded. For maximum portability, // use values greater than 256. // // Parameters: // max - the new max column size limit; zero means unlimited // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::Statement* stmt = (odbc::Statement*)fImp; try { stmt->setMaxFieldSize(max); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetMaxRows (  Int_t    max )  [virtual]

Implements TSQLStatement. Definition at line 918 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_STRING_CSTR, odbc::Statement::setMaxRows(), and TSQL::Throw(). { // Sets the limit for the maximum number of rows that any // TSQLResultSet can contain to the given number. If the limit is // exceeded, the excess rows are silently dropped. // // Parameters: // max - the new max rows limit; zero means unlimited // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::Statement* stmt = (odbc::Statement*)fImp; try { stmt->setMaxRows(max); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetNull (  Int_t    parameterIndex, Int_t    sqlType )  [virtual]

Implements TSQLPreparedStatement. Definition at line 105 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_STRING_CSTR, odbc::PreparedStatement::setNull(), and TSQL::Throw(). { // Sets the designated parameter to SQL NULL. // // Note: You must specify the parameter's SQL type. // // Parameters: // parameterIndex - the first parameter is 1, // the second is 2, ... // sqlType - the SQL type code defined in TSQLTypes // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { imp->setNull(parameterIndex,sqlType); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetObject (  Int_t    parameterIndex, TObject *    x )  [virtual]

Implements TSQLPreparedStatement. Definition at line 555 of file ODBCPreparedStatement.cxx. References b, and SetBinaryStream(). { // Sets the designated parameter to the given ROOT object // // Parameters: // parameterIndex - the first parameter is 1, // the second is 2, ... // x - the ROOT object // Throws: // TSQLException - if a database access error occurs TBuffer *b = new TBuffer(TBuffer::kWrite); b->WriteObject(x); SetBinaryStream(parameterIndex,b,b->BufferSize()); b->DetachBuffer(); delete b; }

void ODBCPreparedStatement::SetQueryTimeout (  Int_t    seconds )  [virtual]

Implements TSQLStatement. Definition at line 1033 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_STRING_CSTR, odbc::Statement::setQueryTimeout(), and TSQL::Throw(). { // Sets the number of seconds the driver will wait for a // ODBCStatement to execute to the given number of seconds. // If the limit is exceeded, a TSQLException is thrown. // // Parameters: // seconds - the new query timeout limit in seconds; // zero means unlimited // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::Statement* stmt = (odbc::Statement*)fImp; try { stmt->setQueryTimeout(seconds); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetShort (  Int_t    parameterIndex, Short_t    x )  [virtual]

Implements TSQLPreparedStatement. Definition at line 186 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_STRING_CSTR, odbc::PreparedStatement::setShort(), and TSQL::Throw(). { // Sets the designated parameter to a short value. The // driver converts this to an SQL SMALLINT value when it sends // it to the database. // // Parameters: // parameterIndex - the first parameter is 1, // the second is 2, ... // x - the parameter value // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { imp->setShort(parameterIndex,x); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetString (  Int_t    parameterIndex, const TString &    x )  [virtual]

Implements TSQLPreparedStatement. Definition at line 321 of file ODBCPreparedStatement.cxx. References TSQL::fImp, ODBCXX_STRING_C, ODBCXX_STRING_CSTR, odbc::PreparedStatement::setString(), and TSQL::Throw(). { // Sets the designated parameter to a TString value. The // driver converts this to an SQL VARCHAR or LONGVARCHAR value // (depending on the argument's size relative to the driver's // limits on VARCHARs) when it sends it to the database. // // Parameters: // parameterIndex - the first parameter is 1, // the second is 2, ... // x - the parameter value // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { imp->setString( parameterIndex, ODBCXX_STRING_C(x.Data()) ); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetTime (  Int_t    parameterIndex, const TSQLTime &    x )  [virtual]

Implements TSQLPreparedStatement. Definition at line 412 of file ODBCPreparedStatement.cxx. References TSQL::fImp, TSQLTime::GetHour(), TSQLTime::GetMinute(), TSQLTime::GetSecond(), ODBCXX_STRING_CSTR, odbc::PreparedStatement::setTime(), and TSQL::Throw(). { // Sets the designated parameter to a TSQLTime value. The // driver converts this to an SQL TIME value when it sends it // to the database. // // Parameters: // parameterIndex - the first parameter is 1, // the second is 2, ... // x - the parameter value // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { odbc::Time tm( x.GetHour(), x.GetMinute(), x.GetSecond() ); imp->setTime(parameterIndex,tm); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

void ODBCPreparedStatement::SetTimestamp (  Int_t    parameterIndex, const TSQLTimestamp &    x )  [virtual]

Implements TSQLPreparedStatement. Definition at line 444 of file ODBCPreparedStatement.cxx. References TSQL::fImp, TSQLTimestamp::GetDay(), TSQLTimestamp::GetHour(), TSQLTimestamp::GetMinute(), TSQLTimestamp::GetMonth(), TSQLTimestamp::GetNanos(), TSQLTimestamp::GetSecond(), TSQLTimestamp::GetYear(), ODBCXX_STRING_CSTR, odbc::PreparedStatement::setTimestamp(), and TSQL::Throw(). { // Sets the designated parameter to a TSQLTimestamp value. // The driver converts this to an SQL TIMESTAMP value when it // sends it to the database. // // Parameters: // parameterIndex - the first parameter is 1, // the second is 2, ... // x - the parameter value // Throws: // TSQLException - if a database access error occurs if(!fImp) { Destroyed(); return; } odbc::PreparedStatement* imp = (odbc::PreparedStatement*)fImp; try { odbc::Timestamp tmstmp( x.GetYear(), x.GetMonth(), x.GetDay(), x.GetHour(), x.GetMinute(), x.GetSecond(), x.GetNanos() ); imp->setTimestamp(parameterIndex,tmstmp); } catch(odbc::SQLException& e) { Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()), ODBCXX_STRING_CSTR(e.getSQLState()), e.getErrorCode()) ); } }

---

Friends And Related Function Documentation

friend class ODBCConnection [friend]

Definition at line 17 of file ODBCPreparedStatement.h.

---

The documentation for this class was generated from the following files:

• ODBCPreparedStatement.h
• ODBCPreparedStatement.cxx

---