+++ /dev/null
-///////////////////////////////////////////////////////////////////////////////\r
-//\r
-// File : $Id: statement.cpp,v 1.2 2009/03/19 20:00:28 faust Exp $\r
-// Subject : IBPP, Service class implementation\r
-//\r
-///////////////////////////////////////////////////////////////////////////////\r
-//\r
-// (C) Copyright 2000-2006 T.I.P. Group S.A. and the IBPP Team (www.ibpp.org)\r
-//\r
-// The contents of this file are subject to the IBPP License (the "License");\r
-// you may not use this file except in compliance with the License. You may\r
-// obtain a copy of the License at http://www.ibpp.org or in the 'license.txt'\r
-// file which must have been distributed along with this file.\r
-//\r
-// This software, distributed under the License, is distributed on an "AS IS"\r
-// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the\r
-// License for the specific language governing rights and limitations\r
-// under the License.\r
-//\r
-///////////////////////////////////////////////////////////////////////////////\r
-//\r
-// COMMENTS\r
-// * Tabulations should be set every four characters when editing this file.\r
-//\r
-///////////////////////////////////////////////////////////////////////////////\r
-\r
-#ifdef _MSC_VER\r
-#pragma warning(disable: 4786 4996)\r
-#ifndef _DEBUG\r
-#pragma warning(disable: 4702)\r
-#endif\r
-#endif\r
-\r
-#include "_ibpp.h"\r
-\r
-#ifdef HAS_HDRSTOP\r
-#pragma hdrstop\r
-#endif\r
-\r
-#include <cstring>\r
-\r
-using namespace ibpp_internals;\r
-\r
-// (((((((( OBJECT INTERFACE IMPLEMENTATION ))))))))\r
-\r
-void StatementImpl::Prepare(const std::string& sql)\r
-{\r
- if (mDatabase == 0)\r
- throw LogicExceptionImpl("Statement::Prepare", _("An IDatabase must be attached."));\r
- if (mDatabase->GetHandle() == 0)\r
- throw LogicExceptionImpl("Statement::Prepare", _("IDatabase must be connected."));\r
- if (mTransaction == 0)\r
- throw LogicExceptionImpl("Statement::Prepare", _("An ITransaction must be attached."));\r
- if (mTransaction->GetHandle() == 0)\r
- throw LogicExceptionImpl("Statement::Prepare", _("ITransaction must be started."));\r
- if (sql.empty())\r
- throw LogicExceptionImpl("Statement::Prepare", _("SQL statement can't be 0."));\r
-\r
- // Saves the SQL sentence, only for reporting reasons in case of errors\r
- mSql = sql;\r
-\r
- IBS status;\r
-\r
- // Free all resources currently attached to this Statement, then allocate\r
- // a new statement descriptor.\r
- Close();\r
- (*gds.Call()->m_dsql_allocate_statement)(status.Self(), mDatabase->GetHandlePtr(), &mHandle);\r
- if (status.Errors())\r
- throw SQLExceptionImpl(status, "Statement::Prepare",\r
- _("isc_dsql_allocate_statement failed"));\r
-\r
- // Empirical estimate of parameters count and output columns count.\r
- // This is by far not an exact estimation, which would require parsing the\r
- // SQL statement. If the SQL statement contains '?' and ',' in string\r
- // constants, this count will obviously be wrong, but it will be exagerated.\r
- // It won't hurt. We just try to not have to re-allocate those descriptors later.\r
- // So we prefer to get them a little bit larger than needed than the other way.\r
- int16_t inEstimate = 0;\r
- int16_t outEstimate = 1;\r
- for (size_t i = 0; i < strlen(sql.c_str()); i++)\r
- {\r
- if (sql[i] == '?') ++inEstimate;\r
- if (sql[i] == ',') ++outEstimate;\r
- }\r
-\r
- /*\r
- DebugStream()<< "Prepare(\""<< sql<< "\")"<< fds;\r
- DebugStream()<< _("Estimation: ")<< inEstimate<< _(" IN parameters and ")\r
- << outEstimate<< _(" OUT columns")<< fds;\r
- */\r
-\r
- // Allocates output descriptor and prepares the statement\r
- mOutRow = new RowImpl(mDatabase->Dialect(), outEstimate, mDatabase, mTransaction);\r
- mOutRow->AddRef();\r
-\r
- status.Reset();\r
- (*gds.Call()->m_dsql_prepare)(status.Self(), mTransaction->GetHandlePtr(),\r
- &mHandle, (short)sql.length(), const_cast<char*>(sql.c_str()),\r
- short(mDatabase->Dialect()), mOutRow->Self());\r
- if (status.Errors())\r
- {\r
- Close();\r
- std::string context = "Statement::Prepare( ";\r
- context.append(mSql).append(" )");\r
- throw SQLExceptionImpl(status, context.c_str(),\r
- _("isc_dsql_prepare failed"));\r
- }\r
-\r
- // Read what kind of statement was prepared\r
- status.Reset();\r
- char itemsReq[] = {isc_info_sql_stmt_type};\r
- char itemsRes[8];\r
- (*gds.Call()->m_dsql_sql_info)(status.Self(), &mHandle, 1, itemsReq,\r
- sizeof(itemsRes), itemsRes);\r
- if (status.Errors())\r
- {\r
- Close();\r
- throw SQLExceptionImpl(status, "Statement::Prepare",\r
- _("isc_dsql_sql_info failed"));\r
- }\r
- if (itemsRes[0] == isc_info_sql_stmt_type)\r
- {\r
- switch (itemsRes[3])\r
- {\r
- case isc_info_sql_stmt_select : mType = IBPP::stSelect; break;\r
- case isc_info_sql_stmt_insert : mType = IBPP::stInsert; break;\r
- case isc_info_sql_stmt_update : mType = IBPP::stUpdate; break;\r
- case isc_info_sql_stmt_delete : mType = IBPP::stDelete; break;\r
- case isc_info_sql_stmt_ddl : mType = IBPP::stDDL; break;\r
- case isc_info_sql_stmt_exec_procedure : mType = IBPP::stExecProcedure; break;\r
- case isc_info_sql_stmt_select_for_upd : mType = IBPP::stSelectUpdate; break;\r
- case isc_info_sql_stmt_set_generator : mType = IBPP::stSetGenerator; break;\r
- case isc_info_sql_stmt_savepoint : mType = IBPP::stSavePoint; break;\r
- default : mType = IBPP::stUnsupported;\r
- }\r
- }\r
- if (mType == IBPP::stUnknown || mType == IBPP::stUnsupported)\r
- {\r
- Close();\r
- throw LogicExceptionImpl("Statement::Prepare",\r
- _("Unknown or unsupported statement type"));\r
- }\r
-\r
- if (mOutRow->Columns() == 0)\r
- {\r
- // Get rid of the output descriptor, if it wasn't required (no output)\r
- mOutRow->Release();\r
- mOutRow = 0;\r
- /*\r
- DebugStream()<< _("Dropped output descriptor which was not required")<< fds;\r
- */\r
- }\r
- else if (mOutRow->Columns() > mOutRow->AllocatedSize())\r
- {\r
- // Resize the output descriptor (which is too small).\r
- // The statement does not need to be prepared again, though the\r
- // output columns must be described again.\r
-\r
- /*\r
- DebugStream()<< _("Resize output descriptor from ")\r
- << mOutRow->AllocatedSize()<< _(" to ")<< mOutRow->Columns()<< fds;\r
- */\r
-\r
- mOutRow->Resize(mOutRow->Columns());\r
- status.Reset();\r
- (*gds.Call()->m_dsql_describe)(status.Self(), &mHandle, 1, mOutRow->Self());\r
- if (status.Errors())\r
- {\r
- Close();\r
- throw SQLExceptionImpl(status, "Statement::Prepare",\r
- _("isc_dsql_describe failed"));\r
- }\r
- }\r
-\r
- if (inEstimate > 0)\r
- {\r
- // Ready an input descriptor\r
- mInRow = new RowImpl(mDatabase->Dialect(), inEstimate, mDatabase, mTransaction);\r
- mInRow->AddRef();\r
-\r
- status.Reset();\r
- (*gds.Call()->m_dsql_describe_bind)(status.Self(), &mHandle, 1, mInRow->Self());\r
- if (status.Errors())\r
- {\r
- Close();\r
- throw SQLExceptionImpl(status, "Statement::Prepare",\r
- _("isc_dsql_describe_bind failed"));\r
- }\r
-\r
- if (mInRow->Columns() == 0)\r
- {\r
- // Get rid of the input descriptor, if it wasn't required (no parameters)\r
- mInRow->Release();\r
- mInRow = 0;\r
- /*\r
- DebugStream()<< _("Dropped input descriptor which was not required")<< fds;\r
- */\r
- }\r
- else if (mInRow->Columns() > mInRow->AllocatedSize())\r
- {\r
- // Resize the input descriptor (which is too small).\r
- // The statement does not need to be prepared again, though the\r
- // parameters must be described again.\r
-\r
- /*\r
- DebugStream()<< _("Resize input descriptor from ")\r
- << mInRow->AllocatedSize()<< _(" to ")\r
- << mInRow->Columns()<< fds;\r
- */\r
-\r
- mInRow->Resize(mInRow->Columns());\r
- status.Reset();\r
- (*gds.Call()->m_dsql_describe_bind)(status.Self(), &mHandle, 1, mInRow->Self());\r
- if (status.Errors())\r
- {\r
- Close();\r
- throw SQLExceptionImpl(status, "Statement::Prepare",\r
- _("isc_dsql_describe_bind failed"));\r
- }\r
- }\r
- }\r
-\r
- // Allocates variables of the input descriptor\r
- if (mInRow != 0)\r
- {\r
- // Turn on 'can be NULL' on each input parameter\r
- for (int i = 0; i < mInRow->Columns(); i++)\r
- {\r
- XSQLVAR* var = &(mInRow->Self()->sqlvar[i]);\r
- if (! (var->sqltype & 1)) var->sqltype += short(1);\r
- }\r
- mInRow->AllocVariables();\r
- }\r
-\r
- // Allocates variables of the output descriptor\r
- if (mOutRow != 0) mOutRow->AllocVariables();\r
-}\r
-\r
-void StatementImpl::Plan(std::string& plan)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Plan", _("No statement has been prepared."));\r
- if (mDatabase == 0)\r
- throw LogicExceptionImpl("Statement::Plan", _("A Database must be attached."));\r
- if (mDatabase->GetHandle() == 0)\r
- throw LogicExceptionImpl("Statement::Plan", _("Database must be connected."));\r
-\r
- IBS status;\r
- RB result(4096);\r
- char itemsReq[] = {isc_info_sql_get_plan};\r
-\r
- (*gds.Call()->m_dsql_sql_info)(status.Self(), &mHandle, 1, itemsReq,\r
- result.Size(), result.Self());\r
- if (status.Errors()) throw SQLExceptionImpl(status,\r
- "Statement::Plan", _("isc_dsql_sql_info failed."));\r
-\r
- result.GetString(isc_info_sql_get_plan, plan);\r
- if (plan[0] == '\n') plan.erase(0, 1);\r
-}\r
-\r
-void StatementImpl::Execute(const std::string& sql)\r
-{\r
- if (! sql.empty()) Prepare(sql);\r
-\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Execute",\r
- _("No statement has been prepared."));\r
-\r
- // Check that a value has been set for each input parameter\r
- if (mInRow != 0 && mInRow->MissingValues())\r
- throw LogicExceptionImpl("Statement::Execute",\r
- _("All parameters must be specified."));\r
-\r
- CursorFree(); // Free a previous 'cursor' if any\r
-\r
- IBS status;\r
- if (mType == IBPP::stSelect)\r
- {\r
- // Could return a result set (none, single or multi rows)\r
- (*gds.Call()->m_dsql_execute)(status.Self(), mTransaction->GetHandlePtr(),\r
- &mHandle, 1, mInRow == 0 ? 0 : mInRow->Self());\r
- if (status.Errors())\r
- {\r
- //Close(); Commented because Execute error should not free the statement\r
- std::string context = "Statement::Execute( ";\r
- context.append(mSql).append(" )");\r
- throw SQLExceptionImpl(status, context.c_str(),\r
- _("isc_dsql_execute failed"));\r
- }\r
- if (mOutRow != 0)\r
- {\r
- mResultSetAvailable = true;\r
- mCursorOpened = true;\r
- }\r
- }\r
- else\r
- {\r
- // Should return at most a single row\r
- (*gds.Call()->m_dsql_execute2)(status.Self(), mTransaction->GetHandlePtr(),\r
- &mHandle, 1, mInRow == 0 ? 0 : mInRow->Self(),\r
- mOutRow == 0 ? 0 : mOutRow->Self());\r
- if (status.Errors())\r
- {\r
- //Close(); Commented because Execute error should not free the statement\r
- std::string context = "Statement::Execute( ";\r
- context.append(mSql).append(" )");\r
- throw SQLExceptionImpl(status, context.c_str(),\r
- _("isc_dsql_execute2 failed"));\r
- }\r
- }\r
-}\r
-\r
-void StatementImpl::CursorExecute(const std::string& cursor, const std::string& sql)\r
-{\r
- if (cursor.empty())\r
- throw LogicExceptionImpl("Statement::CursorExecute", _("Cursor name can't be 0."));\r
-\r
- if (! sql.empty()) Prepare(sql);\r
-\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::CursorExecute", _("No statement has been prepared."));\r
- if (mType != IBPP::stSelectUpdate)\r
- throw LogicExceptionImpl("Statement::CursorExecute", _("Statement must be a SELECT FOR UPDATE."));\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::CursorExecute", _("Statement would return no rows."));\r
-\r
- // Check that a value has been set for each input parameter\r
- if (mInRow != 0 && mInRow->MissingValues())\r
- throw LogicExceptionImpl("Statement::CursorExecute",\r
- _("All parameters must be specified."));\r
-\r
- CursorFree(); // Free a previous 'cursor' if any\r
-\r
- IBS status;\r
- (*gds.Call()->m_dsql_execute)(status.Self(), mTransaction->GetHandlePtr(),\r
- &mHandle, 1, mInRow == 0 ? 0 : mInRow->Self());\r
- if (status.Errors())\r
- {\r
- //Close(); Commented because Execute error should not free the statement\r
- std::string context = "Statement::CursorExecute( ";\r
- context.append(mSql).append(" )");\r
- throw SQLExceptionImpl(status, context.c_str(),\r
- _("isc_dsql_execute failed"));\r
- }\r
-\r
- status.Reset();\r
- (*gds.Call()->m_dsql_set_cursor_name)(status.Self(), &mHandle, const_cast<char*>(cursor.c_str()), 0);\r
- if (status.Errors())\r
- {\r
- //Close(); Commented because Execute error should not free the statement\r
- throw SQLExceptionImpl(status, "Statement::CursorExecute",\r
- _("isc_dsql_set_cursor_name failed"));\r
- }\r
-\r
- mResultSetAvailable = true;\r
- mCursorOpened = true;\r
-}\r
-\r
-void StatementImpl::ExecuteImmediate(const std::string& sql)\r
-{\r
- if (mDatabase == 0)\r
- throw LogicExceptionImpl("Statement::ExecuteImmediate", _("An IDatabase must be attached."));\r
- if (mDatabase->GetHandle() == 0)\r
- throw LogicExceptionImpl("Statement::ExecuteImmediate", _("IDatabase must be connected."));\r
- if (mTransaction == 0)\r
- throw LogicExceptionImpl("Statement::ExecuteImmediate", _("An ITransaction must be attached."));\r
- if (mTransaction->GetHandle() == 0)\r
- throw LogicExceptionImpl("Statement::ExecuteImmediate", _("ITransaction must be started."));\r
- if (sql.empty())\r
- throw LogicExceptionImpl("Statement::ExecuteImmediate", _("SQL statement can't be 0."));\r
-\r
- IBS status;\r
- Close();\r
- (*gds.Call()->m_dsql_execute_immediate)(status.Self(), mDatabase->GetHandlePtr(),\r
- mTransaction->GetHandlePtr(), 0, const_cast<char*>(sql.c_str()),\r
- short(mDatabase->Dialect()), 0);\r
- if (status.Errors())\r
- {\r
- std::string context = "Statement::ExecuteImmediate( ";\r
- context.append(sql).append(" )");\r
- throw SQLExceptionImpl(status, context.c_str(),\r
- _("isc_dsql_execute_immediate failed"));\r
- }\r
-}\r
-\r
-int StatementImpl::AffectedRows()\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::AffectedRows", _("No statement has been prepared."));\r
- if (mDatabase == 0)\r
- throw LogicExceptionImpl("Statement::AffectedRows", _("A Database must be attached."));\r
- if (mDatabase->GetHandle() == 0)\r
- throw LogicExceptionImpl("Statement::AffectedRows", _("Database must be connected."));\r
-\r
- int count;\r
- IBS status;\r
- RB result;\r
- char itemsReq[] = {isc_info_sql_records};\r
-\r
- (*gds.Call()->m_dsql_sql_info)(status.Self(), &mHandle, 1, itemsReq,\r
- result.Size(), result.Self());\r
- if (status.Errors()) throw SQLExceptionImpl(status,\r
- "Statement::AffectedRows", _("isc_dsql_sql_info failed."));\r
-\r
- if (mType == IBPP::stInsert)\r
- count = result.GetValue(isc_info_sql_records, isc_info_req_insert_count);\r
- else if (mType == IBPP::stUpdate)\r
- count = result.GetValue(isc_info_sql_records, isc_info_req_update_count);\r
- else if (mType == IBPP::stDelete)\r
- count = result.GetValue(isc_info_sql_records, isc_info_req_delete_count);\r
- else if (mType == IBPP::stSelect)\r
- count = result.GetValue(isc_info_sql_records, isc_info_req_select_count);\r
- else count = 0; // Returns zero count for unknown cases\r
-\r
- return count;\r
-}\r
-\r
-bool StatementImpl::Fetch()\r
-{\r
- if (! mResultSetAvailable)\r
- throw LogicExceptionImpl("Statement::Fetch",\r
- _("No statement has been executed or no result set available."));\r
-\r
- IBS status;\r
- ISC_STATUS code = (*gds.Call()->m_dsql_fetch)(status.Self(), &mHandle, 1, mOutRow->Self());\r
- if (code == 100) // This special code means "no more rows"\r
- {\r
- mResultSetAvailable = false;\r
- // Oddly enough, fetching rows up to the last one seems to open\r
- // an 'implicit' cursor that needs to be closed.\r
- mCursorOpened = true;\r
- CursorFree(); // Free the explicit or implicit cursor/result-set\r
- return false;\r
- }\r
- if (status.Errors())\r
- {\r
- Close();\r
- throw SQLExceptionImpl(status, "Statement::Fetch",\r
- _("isc_dsql_fetch failed."));\r
- }\r
-\r
- return true;\r
-}\r
-\r
-bool StatementImpl::Fetch(IBPP::Row& row)\r
-{\r
- if (! mResultSetAvailable)\r
- throw LogicExceptionImpl("Statement::Fetch(row)",\r
- _("No statement has been executed or no result set available."));\r
-\r
- RowImpl* rowimpl = new RowImpl(*mOutRow);\r
- row = rowimpl;\r
-\r
- IBS status;\r
- ISC_STATUS code = (*gds.Call()->m_dsql_fetch)(status.Self(), &mHandle, 1,\r
- rowimpl->Self());\r
- if (code == 100) // This special code means "no more rows"\r
- {\r
- mResultSetAvailable = false;\r
- // Oddly enough, fetching rows up to the last one seems to open\r
- // an 'implicit' cursor that needs to be closed.\r
- mCursorOpened = true;\r
- CursorFree(); // Free the explicit or implicit cursor/result-set\r
- row.clear();\r
- return false;\r
- }\r
- if (status.Errors())\r
- {\r
- Close();\r
- row.clear();\r
- throw SQLExceptionImpl(status, "Statement::Fetch(row)",\r
- _("isc_dsql_fetch failed."));\r
- }\r
-\r
- return true;\r
-}\r
-\r
-void StatementImpl::Close()\r
-{\r
- // Free all statement resources.\r
- // Used before preparing a new statement or from destructor.\r
-\r
- if (mInRow != 0) { mInRow->Release(); mInRow = 0; }\r
- if (mOutRow != 0) { mOutRow->Release(); mOutRow = 0; }\r
-\r
- mResultSetAvailable = false;\r
- mCursorOpened = false;\r
- mType = IBPP::stUnknown;\r
-\r
- if (mHandle != 0)\r
- {\r
- IBS status;\r
- (*gds.Call()->m_dsql_free_statement)(status.Self(), &mHandle, DSQL_drop);\r
- mHandle = 0;\r
- if (status.Errors())\r
- throw SQLExceptionImpl(status, "Statement::Close(DSQL_drop)",\r
- _("isc_dsql_free_statement failed."));\r
- }\r
-}\r
-\r
-void StatementImpl::SetNull(int param)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::SetNull", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::SetNull", _("The statement does not take parameters."));\r
-\r
- mInRow->SetNull(param);\r
-}\r
-\r
-void StatementImpl::Set(int param, bool value)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Set[bool]", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Set[bool]", _("The statement does not take parameters."));\r
-\r
- mInRow->Set(param, value);\r
-}\r
-\r
-void StatementImpl::Set(int param, const char* cstring)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Set[char*]", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Set[char*]", _("The statement does not take parameters."));\r
-\r
- mInRow->Set(param, cstring);\r
-}\r
-\r
-void StatementImpl::Set(int param, const void* bindata, int len)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Set[void*]", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Set[void*]", _("The statement does not take parameters."));\r
-\r
- mInRow->Set(param, bindata, len);\r
-}\r
-\r
-void StatementImpl::Set(int param, const std::string& s)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Set[string]", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Set[string]", _("The statement does not take parameters."));\r
-\r
- mInRow->Set(param, s);\r
-}\r
-\r
-void StatementImpl::Set(int param, int16_t value)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Set[int16_t]", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Set[int16_t]", _("The statement does not take parameters."));\r
-\r
- mInRow->Set(param, value);\r
-}\r
-\r
-void StatementImpl::Set(int param, int32_t value)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Set[int32_t]", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Set[int32_t]", _("The statement does not take parameters."));\r
-\r
- mInRow->Set(param, value);\r
-}\r
-\r
-void StatementImpl::Set(int param, int64_t value)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Set[int64_t]", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Set[int64_t]", _("The statement does not take parameters."));\r
-\r
- mInRow->Set(param, value);\r
-}\r
-\r
-void StatementImpl::Set(int param, float value)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Set[float]", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Set[float]", _("The statement does not take parameters."));\r
-\r
- mInRow->Set(param, value);\r
-}\r
-\r
-void StatementImpl::Set(int param, double value)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Set[double]", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Set[double]", _("The statement does not take parameters."));\r
-\r
- mInRow->Set(param, value);\r
-}\r
-\r
-void StatementImpl::Set(int param, const IBPP::Timestamp& value)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Set[Timestamp]", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Set[Timestamp]", _("The statement does not take parameters."));\r
-\r
- mInRow->Set(param, value);\r
-}\r
-\r
-void StatementImpl::Set(int param, const IBPP::Date& value)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Set[Date]", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Set[Date]", _("The statement does not take parameters."));\r
-\r
- mInRow->Set(param, value);\r
-}\r
-\r
-void StatementImpl::Set(int param, const IBPP::Time& value)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Set[Time]", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Set[Time]", _("The statement does not take parameters."));\r
-\r
- mInRow->Set(param, value);\r
-}\r
-\r
-void StatementImpl::Set(int param, const IBPP::Blob& blob)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Set[Blob]", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Set[Blob]", _("The statement does not take parameters."));\r
-\r
- mInRow->Set(param, blob);\r
-}\r
-\r
-void StatementImpl::Set(int param, const IBPP::Array& array)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Set[Array]", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Set[Array]", _("The statement does not take parameters."));\r
-\r
- mInRow->Set(param, array);\r
-}\r
-\r
-void StatementImpl::Set(int param, const IBPP::DBKey& key)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Set[DBKey]", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Set[DBKey]", _("The statement does not take parameters."));\r
-\r
- mInRow->Set(param, key);\r
-}\r
-\r
-/*\r
-void StatementImpl::Set(int param, const IBPP::Value& value)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Set[Value]", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Set[Value]", _("The statement does not take parameters."));\r
-\r
- mInRow->Set(param, value);\r
-}\r
-*/\r
-\r
-bool StatementImpl::IsNull(int column)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::IsNull", _("The row is not initialized."));\r
-\r
- return mOutRow->IsNull(column);\r
-}\r
-\r
-bool StatementImpl::Get(int column, bool* retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
- if (retvalue == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("Null pointer detected"));\r
-\r
- return mOutRow->Get(column, *retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(int column, bool& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(column, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(int column, char* retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(column, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(int column, void* bindata, int& userlen)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(column, bindata, userlen);\r
-}\r
-\r
-bool StatementImpl::Get(int column, std::string& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(column, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(int column, int16_t* retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
- if (retvalue == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("Null pointer detected"));\r
-\r
- return mOutRow->Get(column, *retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(int column, int16_t& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(column, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(int column, int32_t* retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
- if (retvalue == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("Null pointer detected"));\r
-\r
- return mOutRow->Get(column, *retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(int column, int32_t& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(column, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(int column, int64_t* retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
- if (retvalue == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("Null pointer detected"));\r
-\r
- return mOutRow->Get(column, *retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(int column, int64_t& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(column, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(int column, float* retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
- if (retvalue == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("Null pointer detected"));\r
-\r
- return mOutRow->Get(column, *retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(int column, float& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(column, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(int column, double* retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
- if (retvalue == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("Null pointer detected"));\r
-\r
- return mOutRow->Get(column, *retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(int column, double& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(column, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(int column, IBPP::Timestamp& timestamp)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(column, timestamp);\r
-}\r
-\r
-bool StatementImpl::Get(int column, IBPP::Date& date)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(column, date);\r
-}\r
-\r
-bool StatementImpl::Get(int column, IBPP::Time& time)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(column, time);\r
-}\r
-\r
-bool StatementImpl::Get(int column, IBPP::Blob& blob)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(column, blob);\r
-}\r
-\r
-bool StatementImpl::Get(int column, IBPP::DBKey& key)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(column, key);\r
-}\r
-\r
-bool StatementImpl::Get(int column, IBPP::Array& array)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(column, array);\r
-}\r
-\r
-/*\r
-const IBPP::Value StatementImpl::Get(int column)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(column);\r
-}\r
-*/\r
-\r
-bool StatementImpl::IsNull(const std::string& name)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::IsNull", _("The row is not initialized."));\r
-\r
- return mOutRow->IsNull(name);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, bool* retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
- if (retvalue == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("Null pointer detected"));\r
-\r
- return mOutRow->Get(name, *retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, bool& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(name, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, char* retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get[char*]", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(name, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, void* retvalue, int& count)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get[void*,int]", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(name, retvalue, count);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, std::string& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::GetString", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(name, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, int16_t* retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
- if (retvalue == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("Null pointer detected"));\r
-\r
- return mOutRow->Get(name, *retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, int16_t& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(name, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, int32_t* retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
- if (retvalue == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("Null pointer detected"));\r
-\r
- return mOutRow->Get(name, *retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, int32_t& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(name, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, int64_t* retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
- if (retvalue == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("Null pointer detected"));\r
-\r
- return mOutRow->Get(name, *retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, int64_t& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(name, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, float* retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
- if (retvalue == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("Null pointer detected"));\r
-\r
- return mOutRow->Get(name, *retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, float& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(name, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, double* retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
- if (retvalue == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("Null pointer detected"));\r
-\r
- return mOutRow->Get(name, *retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, double& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(name, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, IBPP::Timestamp& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(name, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, IBPP::Date& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(name, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, IBPP::Time& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(name, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string&name, IBPP::Blob& retblob)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(name, retblob);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, IBPP::DBKey& retvalue)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(name, retvalue);\r
-}\r
-\r
-bool StatementImpl::Get(const std::string& name, IBPP::Array& retarray)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(name, retarray);\r
-}\r
-\r
-/*\r
-const IBPP::Value StatementImpl::Get(const std::string& name)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Get", _("The row is not initialized."));\r
-\r
- return mOutRow->Get(name);\r
-}\r
-*/\r
-\r
-int StatementImpl::Columns()\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Columns", _("The row is not initialized."));\r
-\r
- return mOutRow->Columns();\r
-}\r
-\r
-int StatementImpl::ColumnNum(const std::string& name)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::ColumnNum", _("The row is not initialized."));\r
-\r
- return mOutRow->ColumnNum(name);\r
-}\r
-\r
-const char* StatementImpl::ColumnName(int varnum)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Columns", _("The row is not initialized."));\r
-\r
- return mOutRow->ColumnName(varnum);\r
-}\r
-\r
-const char* StatementImpl::ColumnAlias(int varnum)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Columns", _("The row is not initialized."));\r
-\r
- return mOutRow->ColumnAlias(varnum);\r
-}\r
-\r
-const char* StatementImpl::ColumnTable(int varnum)\r
-{\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::Columns", _("The row is not initialized."));\r
-\r
- return mOutRow->ColumnTable(varnum);\r
-}\r
-\r
-IBPP::SDT StatementImpl::ColumnType(int varnum)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::ColumnType", _("No statement has been prepared."));\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::ColumnType", _("The statement does not return results."));\r
-\r
- return mOutRow->ColumnType(varnum);\r
-}\r
-\r
-int StatementImpl::ColumnSubtype(int varnum)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::ColumnSubtype", _("No statement has been prepared."));\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::ColumnSubtype", _("The statement does not return results."));\r
-\r
- return mOutRow->ColumnSubtype(varnum);\r
-}\r
-\r
-int StatementImpl::ColumnSize(int varnum)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::ColumnSize", _("No statement has been prepared."));\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::ColumnSize", _("The row is not initialized."));\r
-\r
- return mOutRow->ColumnSize(varnum);\r
-}\r
-\r
-int StatementImpl::ColumnScale(int varnum)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::ColumnScale", _("No statement has been prepared."));\r
- if (mOutRow == 0)\r
- throw LogicExceptionImpl("Statement::ColumnScale", _("The row is not initialized."));\r
-\r
- return mOutRow->ColumnScale(varnum);\r
-}\r
-\r
-int StatementImpl::Parameters()\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::Parameters", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::Parameters", _("The statement uses no parameters."));\r
-\r
- return mInRow->Columns();\r
-}\r
-\r
-IBPP::SDT StatementImpl::ParameterType(int varnum)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::ParameterType", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::ParameterType", _("The statement uses no parameters."));\r
-\r
- return mInRow->ColumnType(varnum);\r
-}\r
-\r
-int StatementImpl::ParameterSubtype(int varnum)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::ParameterSubtype", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::ParameterSubtype", _("The statement uses no parameters."));\r
-\r
- return mInRow->ColumnSubtype(varnum);\r
-}\r
-\r
-int StatementImpl::ParameterSize(int varnum)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::ParameterSize", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::ParameterSize", _("The statement uses no parameters."));\r
-\r
- return mInRow->ColumnSize(varnum);\r
-}\r
-\r
-int StatementImpl::ParameterScale(int varnum)\r
-{\r
- if (mHandle == 0)\r
- throw LogicExceptionImpl("Statement::ParameterScale", _("No statement has been prepared."));\r
- if (mInRow == 0)\r
- throw LogicExceptionImpl("Statement::ParameterScale", _("The statement uses no parameters."));\r
-\r
- return mInRow->ColumnScale(varnum);\r
-}\r
-\r
-IBPP::Database StatementImpl::DatabasePtr() const\r
-{\r
- return mDatabase;\r
-}\r
-\r
-IBPP::Transaction StatementImpl::TransactionPtr() const\r
-{\r
- return mTransaction;\r
-}\r
-\r
-IBPP::IStatement* StatementImpl::AddRef()\r
-{\r
- ASSERTION(mRefCount >= 0);\r
- ++mRefCount;\r
-\r
- return this;\r
-}\r
-\r
-void StatementImpl::Release()\r
-{\r
- // Release cannot throw, except in DEBUG builds on assertion\r
- ASSERTION(mRefCount >= 0);\r
- --mRefCount;\r
- try { if (mRefCount <= 0) delete this; }\r
- catch (...) { }\r
-}\r
-\r
-// (((((((( OBJECT INTERNAL METHODS ))))))))\r
-\r
-void StatementImpl::AttachDatabaseImpl(DatabaseImpl* database)\r
-{\r
- if (database == 0)\r
- throw LogicExceptionImpl("Statement::AttachDatabase",\r
- _("Can't attach a 0 IDatabase object."));\r
-\r
- if (mDatabase != 0) mDatabase->DetachStatementImpl(this);\r
- mDatabase = database;\r
- mDatabase->AttachStatementImpl(this);\r
-}\r
-\r
-void StatementImpl::DetachDatabaseImpl()\r
-{\r
- if (mDatabase == 0) return;\r
-\r
- Close();\r
- mDatabase->DetachStatementImpl(this);\r
- mDatabase = 0;\r
-}\r
-\r
-void StatementImpl::AttachTransactionImpl(TransactionImpl* transaction)\r
-{\r
- if (transaction == 0)\r
- throw LogicExceptionImpl("Statement::AttachTransaction",\r
- _("Can't attach a 0 ITransaction object."));\r
-\r
- if (mTransaction != 0) mTransaction->DetachStatementImpl(this);\r
- mTransaction = transaction;\r
- mTransaction->AttachStatementImpl(this);\r
-}\r
-\r
-void StatementImpl::DetachTransactionImpl()\r
-{\r
- if (mTransaction == 0) return;\r
-\r
- Close();\r
- mTransaction->DetachStatementImpl(this);\r
- mTransaction = 0;\r
-}\r
-\r
-void StatementImpl::CursorFree()\r
-{\r
- if (mCursorOpened)\r
- {\r
- mCursorOpened = false;\r
- if (mHandle != 0)\r
- {\r
- IBS status;\r
- (*gds.Call()->m_dsql_free_statement)(status.Self(), &mHandle, DSQL_close);\r
- if (status.Errors())\r
- throw SQLExceptionImpl(status, "StatementImpl::CursorFree(DSQL_close)",\r
- _("isc_dsql_free_statement failed."));\r
- }\r
- }\r
-}\r
-\r
-StatementImpl::StatementImpl(DatabaseImpl* database, TransactionImpl* transaction,\r
- const std::string& sql)\r
- : mRefCount(0), mHandle(0), mDatabase(0), mTransaction(0),\r
- mInRow(0), mOutRow(0),\r
- mResultSetAvailable(false), mCursorOpened(false), mType(IBPP::stUnknown)\r
-{\r
- AttachDatabaseImpl(database);\r
- if (transaction != 0) AttachTransactionImpl(transaction);\r
- if (! sql.empty()) Prepare(sql);\r
-}\r
-\r
-StatementImpl::~StatementImpl()\r
-{\r
- try { Close(); }\r
- catch (...) { }\r
- try { if (mTransaction != 0) mTransaction->DetachStatementImpl(this); }\r
- catch (...) { }\r
- try { if (mDatabase != 0) mDatabase->DetachStatementImpl(this); }\r
- catch (...) { }\r
-}\r
-\r
-//\r
-// EOF\r
-//\r
git.stg.codes / stg.git / blobdiff