diff --git a/catalogue/CreateSchemaCmd.cpp b/catalogue/CreateSchemaCmd.cpp
index cdd9e046160ba71f79b6b72524568f27e9899361..0a0aeb68fe26ba6c2be17bb179e0c6303fa13ec0 100644
--- a/catalogue/CreateSchemaCmd.cpp
+++ b/catalogue/CreateSchemaCmd.cpp
@@ -68,13 +68,13 @@ int CreateSchemaCmd::exceptionThrowingMain(const int argc, char *const *const ar
case rdbms::Login::DBTYPE_SQLITE:
{
SqliteCatalogueSchema schema;
- conn.executeNonQueries(schema.sql);
+ conn.executeNonQueries(schema.sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
}
break;
case rdbms::Login::DBTYPE_ORACLE:
{
OracleCatalogueSchema schema;
- conn.executeNonQueries(schema.sql);
+ conn.executeNonQueries(schema.sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
}
break;
case rdbms::Login::DBTYPE_NONE:
diff --git a/catalogue/OracleCatalogue.cpp b/catalogue/OracleCatalogue.cpp
index 87ef8f4fec7fc9c2786d595314ae62b5eb01d084..dcf31f2f7fa48a6e1b7b0925fa71ec2463986b61 100644
--- a/catalogue/OracleCatalogue.cpp
+++ b/catalogue/OracleCatalogue.cpp
@@ -168,8 +168,8 @@ uint64_t OracleCatalogue::getNextArchiveFileId(rdbms::Conn &conn) {
"ARCHIVE_FILE_ID_SEQ.NEXTVAL AS ARCHIVE_FILE_ID "
"FROM "
"DUAL";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
- auto rset = stmt.executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
if (!rset.next()) {
throw exception::Exception(std::string("Result set is unexpectedly empty"));
}
@@ -193,8 +193,8 @@ uint64_t OracleCatalogue::getNextStorageClassId(rdbms::Conn &conn) {
"STORAGE_CLASS_ID_SEQ.NEXTVAL AS STORAGE_CLASS_ID "
"FROM "
"DUAL";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
- auto rset = stmt.executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
if (!rset.next()) {
throw exception::Exception(std::string("Result set is unexpectedly empty"));
}
@@ -249,9 +249,9 @@ common::dataStructures::Tape OracleCatalogue::selectTapeForUpdate(rdbms::Conn &c
"WHERE "
"VID = :VID "
"FOR UPDATE";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":VID", vid);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
if (!rset.next()) {
throw exception::Exception(std::string("The tape with VID " + vid + " does not exist"));
}
@@ -461,7 +461,7 @@ void OracleCatalogue::filesWrittenToTape(const std::set<TapeItemWrittenPointer>
":COPY_NB,"
":CREATION_TIME,"
":ARCHIVE_FILE_ID)";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
rdbms::wrapper::OcciStmt &occiStmt = dynamic_cast<rdbms::wrapper::OcciStmt &>(stmt.getStmt());
occiStmt.setColumn(tapeFileBatch.vid);
occiStmt.setColumn(tapeFileBatch.fSeq);
@@ -590,7 +590,7 @@ void OracleCatalogue::idempotentBatchInsertArchiveFiles(rdbms::Conn &conn,
"WHERE "
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"STORAGE_CLASS_NAME = :STORAGE_CLASS_NAME";
- auto stmt = conn.createStmt(sql, autocommitMode);
+ auto stmt = conn.createStmt(sql);
rdbms::wrapper::OcciStmt &occiStmt = dynamic_cast<rdbms::wrapper::OcciStmt &>(stmt.getStmt());
occiStmt->setBatchErrorMode(true);
@@ -684,9 +684,9 @@ std::map<uint64_t, OracleCatalogue::FileSizeAndChecksum> OracleCatalogue::select
"ARCHIVE_FILE "
"INNER JOIN TEMP_TAPE_FILE_BATCH ON "
"ARCHIVE_FILE.ARCHIVE_FILE_ID = TEMP_TAPE_FILE_BATCH.ARCHIVE_FILE_ID";
- auto stmt = conn.createStmt(sql, autocommitMode);
+ auto stmt = conn.createStmt(sql);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(autocommitMode);
std::map<uint64_t, FileSizeAndChecksum> fileSizesAndChecksums;
while (rset.next()) {
@@ -744,7 +744,7 @@ void OracleCatalogue::insertTapeFileBatchIntoTempTable(rdbms::Conn &conn,
"ARCHIVE_FILE_ID)"
"VALUES("
":ARCHIVE_FILE_ID)";
- auto stmt = conn.createStmt(sql, autocommitMode);
+ auto stmt = conn.createStmt(sql);
rdbms::wrapper::OcciStmt &occiStmt = dynamic_cast<rdbms::wrapper::OcciStmt &>(stmt.getStmt());
occiStmt->setBatchErrorMode(false);
diff --git a/catalogue/RdbmsArchiveFileItorImpl.cpp b/catalogue/RdbmsArchiveFileItorImpl.cpp
index 8f4d7b34d70c0f2e7e322859650ae6333c6051d0..5460e8a5ec892ddee090ce7a02098ca89c6fee78 100644
--- a/catalogue/RdbmsArchiveFileItorImpl.cpp
+++ b/catalogue/RdbmsArchiveFileItorImpl.cpp
@@ -202,7 +202,7 @@ RdbmsArchiveFileItorImpl::RdbmsArchiveFileItorImpl(
}
auto conn = connPool.getConn();
- m_stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ m_stmt = conn.createStmt(sql);
if(searchCriteria.archiveFileId) {
m_stmt.bindUint64(":ARCHIVE_FILE_ID", searchCriteria.archiveFileId.value());
}
@@ -233,7 +233,7 @@ RdbmsArchiveFileItorImpl::RdbmsArchiveFileItorImpl(
if(searchCriteria.tapePool) {
m_stmt.bindString(":TAPE_POOL_NAME", searchCriteria.tapePool.value());
}
- m_rset = m_stmt.executeQuery();
+ m_rset = m_stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
m_rsetIsEmpty = !m_rset.next();
} catch(exception::UserError &) {
diff --git a/catalogue/RdbmsCatalogue.cpp b/catalogue/RdbmsCatalogue.cpp
index 0bc692bc03dff73f9c946e3a55f0bbc7861f1df7..b3493db19748b3ac92d6a0e6f7d7c7634633c59b 100644
--- a/catalogue/RdbmsCatalogue.cpp
+++ b/catalogue/RdbmsCatalogue.cpp
@@ -123,7 +123,7 @@ void RdbmsCatalogue::createAdminUser(
":LAST_UPDATE_USER_NAME,"
":LAST_UPDATE_HOST_NAME,"
":LAST_UPDATE_TIME)";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":ADMIN_USER_NAME", username);
@@ -137,7 +137,7 @@ void RdbmsCatalogue::createAdminUser(
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
} catch(exception::UserError &) {
throw;
} catch(exception::Exception &ex) {
@@ -158,9 +158,9 @@ bool RdbmsCatalogue::adminUserExists(rdbms::Conn &conn, const std::string adminU
"ADMIN_USER "
"WHERE "
"ADMIN_USER_NAME = :ADMIN_USER_NAME";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":ADMIN_USER_NAME", adminUsername);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
return rset.next();
} catch(exception::UserError &) {
throw;
@@ -177,9 +177,9 @@ void RdbmsCatalogue::deleteAdminUser(const std::string &username) {
try {
const char *const sql = "DELETE FROM ADMIN_USER WHERE ADMIN_USER_NAME = :ADMIN_USER_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":ADMIN_USER_NAME", username);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot delete admin-user ") + username + " because they do not exist");
@@ -216,8 +216,8 @@ std::list<common::dataStructures::AdminUser> RdbmsCatalogue::getAdminUsers() con
"ORDER BY "
"ADMIN_USER_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
- auto rset = stmt.executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
while (rset.next()) {
common::dataStructures::AdminUser admin;
@@ -266,13 +266,13 @@ void RdbmsCatalogue::modifyAdminUserComment(const common::dataStructures::Securi
"WHERE "
"ADMIN_USER_NAME = :ADMIN_USER_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":USER_COMMENT", comment);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":ADMIN_USER_NAME", username);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify admin user ") + username + " because they do not exist");
@@ -344,7 +344,7 @@ void RdbmsCatalogue::createStorageClass(
":LAST_UPDATE_USER_NAME,"
":LAST_UPDATE_HOST_NAME,"
":LAST_UPDATE_TIME)";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":STORAGE_CLASS_ID", storageClassId);
stmt.bindString(":DISK_INSTANCE_NAME", storageClass.diskInstance);
@@ -361,7 +361,7 @@ void RdbmsCatalogue::createStorageClass(
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
} catch(exception::UserError &) {
throw;
} catch(exception::Exception &ex) {
@@ -385,10 +385,10 @@ bool RdbmsCatalogue::storageClassExists(rdbms::Conn &conn, const std::string &di
"WHERE "
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"STORAGE_CLASS_NAME = :STORAGE_CLASS_NAME";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":STORAGE_CLASS_NAME", storageClassName);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
return rset.next();
} catch(exception::UserError &) {
throw;
@@ -410,12 +410,12 @@ void RdbmsCatalogue::deleteStorageClass(const std::string &diskInstanceName, con
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"STORAGE_CLASS_NAME = :STORAGE_CLASS_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql,rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":STORAGE_CLASS_NAME", storageClassName);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot delete storage-class ") + diskInstanceName + ":" +
storageClassName + " because it does not exist");
@@ -454,8 +454,8 @@ std::list<common::dataStructures::StorageClass> RdbmsCatalogue::getStorageClasse
"ORDER BY "
"DISK_INSTANCE_NAME, STORAGE_CLASS_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
- auto rset = stmt.executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
while (rset.next()) {
common::dataStructures::StorageClass storageClass;
@@ -499,14 +499,14 @@ void RdbmsCatalogue::modifyStorageClassNbCopies(const common::dataStructures::Se
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"STORAGE_CLASS_NAME = :STORAGE_CLASS_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":NB_COPIES", nbCopies);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":DISK_INSTANCE_NAME", instanceName);
stmt.bindString(":STORAGE_CLASS_NAME", name);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify storage class ") + instanceName + ":" + name +
@@ -537,14 +537,14 @@ void RdbmsCatalogue::modifyStorageClassComment(const common::dataStructures::Sec
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"STORAGE_CLASS_NAME = :STORAGE_CLASS_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":USER_COMMENT", comment);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":DISK_INSTANCE_NAME", instanceName);
stmt.bindString(":STORAGE_CLASS_NAME", name);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify storage class ") + instanceName + ":" + name +
@@ -619,7 +619,7 @@ void RdbmsCatalogue::createTapePool(
":LAST_UPDATE_USER_NAME,"
":LAST_UPDATE_HOST_NAME,"
":LAST_UPDATE_TIME)";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":TAPE_POOL_NAME", name);
stmt.bindString(":VO", vo);
@@ -636,7 +636,7 @@ void RdbmsCatalogue::createTapePool(
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
} catch(exception::UserError &) {
throw;
} catch(exception::Exception &ex) {
@@ -672,9 +672,9 @@ bool RdbmsCatalogue::tapePoolExists(rdbms::Conn &conn, const std::string &tapePo
"TAPE_POOL "
"WHERE "
"TAPE_POOL_NAME = :TAPE_POOL_NAME";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":TAPE_POOL_NAME", tapePoolName);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
return rset.next();
} catch(exception::UserError &) {
throw;
@@ -696,9 +696,9 @@ bool RdbmsCatalogue::archiveFileIdExists(rdbms::Conn &conn, const uint64_t archi
"ARCHIVE_FILE "
"WHERE "
"ARCHIVE_FILE_ID = :ARCHIVE_FILE_ID";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":ARCHIVE_FILE_ID", archiveFileId);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
return rset.next();
} catch(exception::UserError &) {
throw;
@@ -723,10 +723,10 @@ bool RdbmsCatalogue::diskFileIdExists(rdbms::Conn &conn, const std::string &disk
"WHERE "
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"DISK_FILE_ID = :DISK_FILE_ID";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":DISK_FILE_ID", diskFileId);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
return rset.next();
} catch(exception::UserError &) {
throw;
@@ -751,10 +751,10 @@ bool RdbmsCatalogue::diskFilePathExists(rdbms::Conn &conn, const std::string &di
"WHERE "
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"DISK_FILE_PATH = :DISK_FILE_PATH";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":DISK_FILE_PATH", diskFilePath);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
return rset.next();
} catch(exception::UserError &) {
throw;
@@ -779,10 +779,10 @@ bool RdbmsCatalogue::diskFileUserExists(rdbms::Conn &conn, const std::string &di
"WHERE "
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"DISK_FILE_USER = :DISK_FILE_USER";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":DISK_FILE_USER", diskFileUser);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
return rset.next();
} catch(exception::UserError &) {
throw;
@@ -807,10 +807,10 @@ bool RdbmsCatalogue::diskFileGroupExists(rdbms::Conn &conn, const std::string &d
"WHERE "
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"DISK_FILE_GROUP = :DISK_FILE_GROUP";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":DISK_FILE_GROUP", diskFileGroup);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
return rset.next();
} catch(exception::UserError &) {
throw;
@@ -838,11 +838,11 @@ bool RdbmsCatalogue::archiveRouteExists(rdbms::Conn &conn, const std::string &di
"STORAGE_CLASS.DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"STORAGE_CLASS.STORAGE_CLASS_NAME = :STORAGE_CLASS_NAME AND "
"ARCHIVE_ROUTE.COPY_NB = :COPY_NB";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":STORAGE_CLASS_NAME", storageClassName);
stmt.bindUint64(":COPY_NB", copyNb);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
return rset.next();
} catch(exception::UserError &) {
throw;
@@ -859,9 +859,9 @@ void RdbmsCatalogue::deleteTapePool(const std::string &name) {
try {
const char *const sql = "DELETE FROM TAPE_POOL WHERE TAPE_POOL_NAME = :TAPE_POOL_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":TAPE_POOL_NAME", name);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot delete tape-pool ") + name + " because it does not exist");
@@ -921,8 +921,8 @@ std::list<TapePool> RdbmsCatalogue::getTapePools() const {
"TAPE_POOL_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
- auto rset = stmt.executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
while (rset.next()) {
TapePool pool;
@@ -979,13 +979,13 @@ void RdbmsCatalogue::modifyTapePoolVo(const common::dataStructures::SecurityIden
"WHERE "
"TAPE_POOL_NAME = :TAPE_POOL_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":VO", vo);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":TAPE_POOL_NAME", name);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify tape pool ") + name + " because it does not exist");
@@ -1019,13 +1019,13 @@ void RdbmsCatalogue::modifyTapePoolNbPartialTapes(const common::dataStructures::
"WHERE "
"TAPE_POOL_NAME = :TAPE_POOL_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":NB_PARTIAL_TAPES", nbPartialTapes);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":TAPE_POOL_NAME", name);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify tape pool ") + name + " because it does not exist");
@@ -1063,13 +1063,13 @@ void RdbmsCatalogue::modifyTapePoolComment(const common::dataStructures::Securit
"WHERE "
"TAPE_POOL_NAME = :TAPE_POOL_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":USER_COMMENT", comment);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":TAPE_POOL_NAME", name);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify tape pool ") + name + " because it does not exist");
@@ -1098,13 +1098,13 @@ void RdbmsCatalogue::setTapePoolEncryption(const common::dataStructures::Securit
"WHERE "
"TAPE_POOL_NAME = :TAPE_POOL_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindBool(":IS_ENCRYPTED", encryptionValue);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":TAPE_POOL_NAME", name);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify tape pool ") + name + " because it does not exist");
@@ -1203,7 +1203,7 @@ void RdbmsCatalogue::createArchiveRoute(
"WHERE "
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"STORAGE_CLASS_NAME = :STORAGE_CLASS_NAME";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":STORAGE_CLASS_NAME", storageClassName);
@@ -1220,7 +1220,7 @@ void RdbmsCatalogue::createArchiveRoute(
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
} catch(exception::UserError &) {
throw;
} catch(exception::Exception &ex) {
@@ -1249,11 +1249,11 @@ void RdbmsCatalogue::deleteArchiveRoute(const std::string &diskInstanceName, con
"STORAGE_CLASS_NAME = :STORAGE_CLASS_NAME) AND "
"COPY_NB = :COPY_NB";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":STORAGE_CLASS_NAME", storageClassName);
stmt.bindUint64(":COPY_NB", copyNb);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
exception::UserError ue;
@@ -1298,8 +1298,8 @@ std::list<common::dataStructures::ArchiveRoute> RdbmsCatalogue::getArchiveRoutes
"ORDER BY "
"DISK_INSTANCE_NAME, STORAGE_CLASS_NAME, COPY_NB";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
- auto rset = stmt.executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
while (rset.next()) {
common::dataStructures::ArchiveRoute route;
@@ -1352,7 +1352,7 @@ void RdbmsCatalogue::modifyArchiveRouteTapePoolName(const common::dataStructures
"STORAGE_CLASS_NAME = :STORAGE_CLASS_NAME) AND "
"COPY_NB = :COPY_NB";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":TAPE_POOL_NAME", tapePoolName);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
@@ -1360,7 +1360,7 @@ void RdbmsCatalogue::modifyArchiveRouteTapePoolName(const common::dataStructures
stmt.bindString(":DISK_INSTANCE_NAME", instanceName);
stmt.bindString(":STORAGE_CLASS_NAME", storageClassName);
stmt.bindUint64(":COPY_NB", copyNb);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
exception::UserError ue;
@@ -1401,7 +1401,7 @@ void RdbmsCatalogue::modifyArchiveRouteComment(const common::dataStructures::Sec
"STORAGE_CLASS_NAME = :STORAGE_CLASS_NAME) AND "
"COPY_NB = :COPY_NB";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":USER_COMMENT", comment);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
@@ -1409,7 +1409,7 @@ void RdbmsCatalogue::modifyArchiveRouteComment(const common::dataStructures::Sec
stmt.bindString(":DISK_INSTANCE_NAME", instanceName);
stmt.bindString(":STORAGE_CLASS_NAME", storageClassName);
stmt.bindUint64(":COPY_NB", copyNb);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
exception::UserError ue;
@@ -1464,7 +1464,7 @@ void RdbmsCatalogue::createLogicalLibrary(
":LAST_UPDATE_USER_NAME,"
":LAST_UPDATE_HOST_NAME,"
":LAST_UPDATE_TIME)";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":LOGICAL_LIBRARY_NAME", name);
@@ -1478,7 +1478,7 @@ void RdbmsCatalogue::createLogicalLibrary(
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
} catch(exception::UserError &) {
throw;
} catch(exception::Exception &ex) {
@@ -1499,9 +1499,9 @@ bool RdbmsCatalogue::logicalLibraryExists(rdbms::Conn &conn, const std::string &
"LOGICAL_LIBRARY "
"WHERE "
"LOGICAL_LIBRARY_NAME = :LOGICAL_LIBRARY_NAME";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":LOGICAL_LIBRARY_NAME", logicalLibraryName);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
return rset.next();
} catch(exception::UserError &) {
throw;
@@ -1518,9 +1518,9 @@ void RdbmsCatalogue::deleteLogicalLibrary(const std::string &name) {
try {
const char *const sql = "DELETE FROM LOGICAL_LIBRARY WHERE LOGICAL_LIBRARY_NAME = :LOGICAL_LIBRARY_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":LOGICAL_LIBRARY_NAME", name);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot delete logical-library ") + name + " because it does not exist");
@@ -1557,8 +1557,8 @@ std::list<common::dataStructures::LogicalLibrary> RdbmsCatalogue::getLogicalLibr
"ORDER BY "
"LOGICAL_LIBRARY_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
- auto rset = stmt.executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
while (rset.next()) {
common::dataStructures::LogicalLibrary lib;
@@ -1599,13 +1599,13 @@ void RdbmsCatalogue::modifyLogicalLibraryComment(const common::dataStructures::S
"WHERE "
"LOGICAL_LIBRARY_NAME = :LOGICAL_LIBRARY_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":USER_COMMENT", comment);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":LOGICAL_LIBRARY_NAME", name);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify logical library ") + name + " because it does not exist");
@@ -1705,7 +1705,7 @@ void RdbmsCatalogue::createTape(
":LAST_UPDATE_USER_NAME,"
":LAST_UPDATE_HOST_NAME,"
":LAST_UPDATE_TIME)";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":VID", vid);
stmt.bindString(":LOGICAL_LIBRARY_NAME", logicalLibraryName);
@@ -1726,7 +1726,7 @@ void RdbmsCatalogue::createTape(
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
} catch(exception::UserError &) {
throw;
} catch(exception::Exception &ex) {
@@ -1762,9 +1762,9 @@ bool RdbmsCatalogue::tapeExists(rdbms::Conn &conn, const std::string &vid) const
"TAPE "
"WHERE "
"VID = :VID";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":VID", vid);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
return rset.next();
} catch(exception::UserError &) {
throw;
@@ -1787,10 +1787,10 @@ void RdbmsCatalogue::deleteTape(const std::string &vid) {
"VID = :DELETE_VID AND "
"NOT EXISTS (SELECT VID FROM TAPE_FILE WHERE VID = :SELECT_VID)";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(delete_sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(delete_sql);
stmt.bindString(":DELETE_VID", vid);
stmt.bindString(":SELECT_VID", vid);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
// The delete statement will effect no rows and will not raise an error if
// either the tape does not exist or if it still has tape files
@@ -1913,7 +1913,7 @@ std::list<common::dataStructures::Tape> RdbmsCatalogue::getTapes(rdbms::Conn &co
sql += " ORDER BY VID";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
if(searchCriteria.vid) stmt.bindString(":VID", searchCriteria.vid.value());
if(searchCriteria.logicalLibrary) stmt.bindString(":LOGICAL_LIBRARY_NAME", searchCriteria.logicalLibrary.value());
@@ -1923,7 +1923,7 @@ std::list<common::dataStructures::Tape> RdbmsCatalogue::getTapes(rdbms::Conn &co
if(searchCriteria.full) stmt.bindBool(":IS_FULL", searchCriteria.full.value());
if(searchCriteria.lbp) stmt.bindBool(":LBP_IS_ON", searchCriteria.lbp.value());
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
while (rset.next()) {
common::dataStructures::Tape tape;
@@ -2016,7 +2016,7 @@ common::dataStructures::VidToTapeMap RdbmsCatalogue::getTapesByVid(const std::se
}
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
{
uint64_t vidNb = 1;
@@ -2026,7 +2026,7 @@ common::dataStructures::VidToTapeMap RdbmsCatalogue::getTapesByVid(const std::se
}
}
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
while (rset.next()) {
common::dataStructures::Tape tape;
@@ -2110,9 +2110,9 @@ common::dataStructures::VidToTapeMap RdbmsCatalogue::getAllTapes() const {
"TAPE";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
while (rset.next()) {
common::dataStructures::Tape tape;
@@ -2170,13 +2170,13 @@ void RdbmsCatalogue::reclaimTape(const common::dataStructures::SecurityIdentity
"IS_FULL != 0 AND "
"NOT EXISTS (SELECT VID FROM TAPE_FILE WHERE VID = :SELECT_VID)";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":UPDATE_VID", vid);
stmt.bindString(":SELECT_VID", vid);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
// If the update failed due to a user error
if(0 == stmt.getNbAffectedRows()) {
@@ -2262,13 +2262,13 @@ void RdbmsCatalogue::modifyTapeLogicalLibraryName(const common::dataStructures::
"WHERE "
"VID = :VID";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":LOGICAL_LIBRARY_NAME", logicalLibraryName);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":VID", vid);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify tape ") + vid + " because it does not exist");
@@ -2297,13 +2297,13 @@ void RdbmsCatalogue::modifyTapeTapePoolName(const common::dataStructures::Securi
"WHERE "
"VID = :VID";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":TAPE_POOL_NAME", tapePoolName);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":VID", vid);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify tape ") + vid + " because it does not exist");
@@ -2332,13 +2332,13 @@ void RdbmsCatalogue::modifyTapeCapacityInBytes(const common::dataStructures::Sec
"WHERE "
"VID = :VID";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":CAPACITY_IN_BYTES", capacityInBytes);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":VID", vid);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify tape ") + vid + " because it does not exist");
@@ -2367,13 +2367,13 @@ void RdbmsCatalogue::modifyTapeEncryptionKey(const common::dataStructures::Secur
"WHERE "
"VID = :VID";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":ENCRYPTION_KEY", encryptionKey);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":VID", vid);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify tape ") + vid + " because it does not exist");
@@ -2399,11 +2399,11 @@ void RdbmsCatalogue::tapeMountedForArchive(const std::string &vid, const std::st
"WHERE "
"VID = :VID";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":LAST_WRITE_DRIVE", drive);
stmt.bindUint64(":LAST_WRITE_TIME", now);
stmt.bindString(":VID", vid);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if (0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify tape ") + vid + " because it does not exist");
@@ -2429,11 +2429,11 @@ void RdbmsCatalogue::tapeMountedForRetrieve(const std::string &vid, const std::s
"WHERE "
"VID = :VID";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":LAST_READ_DRIVE", drive);
stmt.bindUint64(":LAST_READ_TIME", now);
stmt.bindString(":VID", vid);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify tape ") + vid + " because it does not exist");
@@ -2462,13 +2462,13 @@ void RdbmsCatalogue::setTapeFull(const common::dataStructures::SecurityIdentity
"WHERE "
"VID = :VID";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindBool(":IS_FULL", fullValue);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":VID", vid);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify tape ") + vid + " because it does not exist");
@@ -2492,9 +2492,9 @@ void RdbmsCatalogue::noSpaceLeftOnTape(const std::string &vid) {
"WHERE "
"VID = :VID";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":VID", vid);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if (0 == stmt.getNbAffectedRows()) {
throw exception::Exception(std::string("Tape ") + vid + " does not exist");
@@ -2523,13 +2523,13 @@ void RdbmsCatalogue::setTapeDisabled(const common::dataStructures::SecurityIdent
"WHERE "
"VID = :VID";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindBool(":IS_DISABLED", disabledValue);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":VID", vid);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify tape ") + vid + " because it does not exist");
@@ -2558,13 +2558,13 @@ void RdbmsCatalogue::modifyTapeComment(const common::dataStructures::SecurityIde
"WHERE "
"VID = :VID";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":USER_COMMENT", comment);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":VID", vid);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify tape ") + vid + " because it does not exist");
@@ -2594,14 +2594,14 @@ void RdbmsCatalogue::modifyRequesterMountRulePolicy(const common::dataStructures
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"REQUESTER_NAME = :REQUESTER_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":MOUNT_POLICY_NAME", mountPolicy);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":DISK_INSTANCE_NAME", instanceName);
stmt.bindString(":REQUESTER_NAME", requesterName);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify requester mount rule ") + instanceName + ":" +
@@ -2632,14 +2632,14 @@ void RdbmsCatalogue::modifyRequesteMountRuleComment(const common::dataStructures
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"REQUESTER_NAME = :REQUESTER_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":USER_COMMENT", comment);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":DISK_INSTANCE_NAME", instanceName);
stmt.bindString(":REQUESTER_NAME", requesterName);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify requester mount rule ") + instanceName + ":" +
@@ -2670,14 +2670,14 @@ void RdbmsCatalogue::modifyRequesterGroupMountRulePolicy(const common::dataStruc
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"REQUESTER_GROUP_NAME = :REQUESTER_GROUP_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":MOUNT_POLICY_NAME", mountPolicy);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":DISK_INSTANCE_NAME", instanceName);
stmt.bindString(":REQUESTER_GROUP_NAME", requesterGroupName);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify requester group mount rule ") + instanceName + ":" +
@@ -2708,14 +2708,14 @@ void RdbmsCatalogue::modifyRequesterGroupMountRuleComment(const common::dataStru
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"REQUESTER_GROUP_NAME = :REQUESTER_GROUP_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":USER_COMMENT", comment);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":DISK_INSTANCE_NAME", instanceName);
stmt.bindString(":REQUESTER_GROUP_NAME", requesterGroupName);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify requester group mount rule ") + instanceName + ":" +
@@ -2789,7 +2789,7 @@ void RdbmsCatalogue::createMountPolicy(
":LAST_UPDATE_USER_NAME,"
":LAST_UPDATE_HOST_NAME,"
":LAST_UPDATE_TIME)";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":MOUNT_POLICY_NAME", name);
@@ -2811,7 +2811,7 @@ void RdbmsCatalogue::createMountPolicy(
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
} catch(exception::UserError &) {
throw;
} catch(exception::Exception &ex) {
@@ -2873,7 +2873,7 @@ void RdbmsCatalogue::createRequesterMountRule(
":LAST_UPDATE_USER_NAME,"
":LAST_UPDATE_HOST_NAME,"
":LAST_UPDATE_TIME)";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":REQUESTER_NAME", requesterName);
@@ -2889,7 +2889,7 @@ void RdbmsCatalogue::createRequesterMountRule(
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
} catch(exception::UserError &) {
throw;
} catch(exception::Exception &ex) {
@@ -2924,8 +2924,8 @@ std::list<common::dataStructures::RequesterMountRule> RdbmsCatalogue::getRequest
"ORDER BY "
"DISK_INSTANCE_NAME, REQUESTER_NAME, MOUNT_POLICY_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
- auto rset = stmt.executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
while(rset.next()) {
common::dataStructures::RequesterMountRule rule;
@@ -2964,10 +2964,10 @@ void RdbmsCatalogue::deleteRequesterMountRule(const std::string &diskInstanceNam
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"REQUESTER_NAME = :REQUESTER_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":REQUESTER_NAME", requesterName);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot delete mount rule for requester ") + diskInstanceName + ":" + requesterName +
@@ -3036,7 +3036,7 @@ void RdbmsCatalogue::createRequesterGroupMountRule(
":LAST_UPDATE_USER_NAME,"
":LAST_UPDATE_HOST_NAME,"
":LAST_UPDATE_TIME)";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":REQUESTER_GROUP_NAME", requesterGroupName);
@@ -3052,7 +3052,7 @@ void RdbmsCatalogue::createRequesterGroupMountRule(
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
} catch(exception::UserError &) {
throw;
} catch(exception::Exception &ex) {
@@ -3116,10 +3116,10 @@ optional<common::dataStructures::MountPolicy> RdbmsCatalogue::getRequesterGroupM
"WHERE "
"REQUESTER_GROUP_MOUNT_RULE.DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"REQUESTER_GROUP_MOUNT_RULE.REQUESTER_GROUP_NAME = :REQUESTER_GROUP_NAME";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", group.diskInstanceName);
stmt.bindString(":REQUESTER_GROUP_NAME", group.groupName);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
if(rset.next()) {
common::dataStructures::MountPolicy policy;
@@ -3179,8 +3179,8 @@ std::list<common::dataStructures::RequesterGroupMountRule> RdbmsCatalogue::getRe
"ORDER BY "
"DISK_INSTANCE_NAME, REQUESTER_GROUP_NAME, MOUNT_POLICY_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
- auto rset = stmt.executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
while(rset.next()) {
common::dataStructures::RequesterGroupMountRule rule;
@@ -3221,10 +3221,10 @@ void RdbmsCatalogue::deleteRequesterGroupMountRule(const std::string &diskInstan
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"REQUESTER_GROUP_NAME = :REQUESTER_GROUP_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":REQUESTER_GROUP_NAME", requesterGroupName);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot delete the mount rule for requester group ") + diskInstanceName + ":" +
@@ -3250,9 +3250,9 @@ bool RdbmsCatalogue::mountPolicyExists(rdbms::Conn &conn, const std::string &mou
"MOUNT_POLICY "
"WHERE "
"MOUNT_POLICY_NAME = :MOUNT_POLICY_NAME";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":MOUNT_POLICY_NAME", mountPolicyName);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
return rset.next();
} catch(exception::UserError &) {
throw;
@@ -3276,10 +3276,10 @@ bool RdbmsCatalogue::requesterMountRuleExists(rdbms::Conn &conn, const std::stri
"WHERE "
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"REQUESTER_NAME = :REQUESTER_NAME";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":REQUESTER_NAME", requesterName);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
return rset.next();
} catch(exception::UserError &) {
throw;
@@ -3343,10 +3343,10 @@ optional<common::dataStructures::MountPolicy> RdbmsCatalogue::getRequesterMountP
"WHERE "
"REQUESTER_MOUNT_RULE.DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"REQUESTER_MOUNT_RULE.REQUESTER_NAME = :REQUESTER_NAME";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", user.diskInstanceName);
stmt.bindString(":REQUESTER_NAME", user.username);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
if(rset.next()) {
common::dataStructures::MountPolicy policy;
@@ -3398,10 +3398,10 @@ bool RdbmsCatalogue::requesterGroupMountRuleExists(rdbms::Conn &conn, const std:
"WHERE "
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"REQUESTER_GROUP_NAME = :REQUESTER_GROUP_NAME";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":REQUESTER_GROUP_NAME", requesterGroupName);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
return rset.next();
} catch(exception::UserError &) {
throw;
@@ -3418,9 +3418,9 @@ void RdbmsCatalogue::deleteMountPolicy(const std::string &name) {
try {
const char *const sql = "DELETE FROM MOUNT_POLICY WHERE MOUNT_POLICY_NAME = :MOUNT_POLICY_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":MOUNT_POLICY_NAME", name);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot delete mount policy ") + name + " because it does not exist");
@@ -3465,8 +3465,8 @@ std::list<common::dataStructures::MountPolicy> RdbmsCatalogue::getMountPolicies(
"ORDER BY "
"MOUNT_POLICY_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
- auto rset = stmt.executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
while (rset.next()) {
common::dataStructures::MountPolicy policy;
@@ -3518,13 +3518,13 @@ void RdbmsCatalogue::modifyMountPolicyArchivePriority(const common::dataStructur
"WHERE "
"MOUNT_POLICY_NAME = :MOUNT_POLICY_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":ARCHIVE_PRIORITY", archivePriority);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":MOUNT_POLICY_NAME", name);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify mount policy ") + name + " because they do not exist");
@@ -3553,13 +3553,13 @@ void RdbmsCatalogue::modifyMountPolicyArchiveMinRequestAge(const common::dataStr
"WHERE "
"MOUNT_POLICY_NAME = :MOUNT_POLICY_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":ARCHIVE_MIN_REQUEST_AGE", minArchiveRequestAge);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":MOUNT_POLICY_NAME", name);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify mount policy ") + name + " because they do not exist");
@@ -3588,13 +3588,13 @@ void RdbmsCatalogue::modifyMountPolicyRetrievePriority(const common::dataStructu
"WHERE "
"MOUNT_POLICY_NAME = :MOUNT_POLICY_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":RETRIEVE_PRIORITY", retrievePriority);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":MOUNT_POLICY_NAME", name);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify mount policy ") + name + " because they do not exist");
@@ -3623,13 +3623,13 @@ void RdbmsCatalogue::modifyMountPolicyRetrieveMinRequestAge(const common::dataSt
"WHERE "
"MOUNT_POLICY_NAME = :MOUNT_POLICY_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":RETRIEVE_MIN_REQUEST_AGE", minRetrieveRequestAge);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":MOUNT_POLICY_NAME", name);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify mount policy ") + name + " because they do not exist");
@@ -3658,13 +3658,13 @@ void RdbmsCatalogue::modifyMountPolicyMaxDrivesAllowed(const common::dataStructu
"WHERE "
"MOUNT_POLICY_NAME = :MOUNT_POLICY_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":MAX_DRIVES_ALLOWED", maxDrivesAllowed);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":MOUNT_POLICY_NAME", name);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify mount policy ") + name + " because they do not exist");
@@ -3693,13 +3693,13 @@ void RdbmsCatalogue::modifyMountPolicyComment(const common::dataStructures::Secu
"WHERE "
"MOUNT_POLICY_NAME = :MOUNT_POLICY_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":USER_COMMENT", comment);
stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
stmt.bindUint64(":LAST_UPDATE_TIME", now);
stmt.bindString(":MOUNT_POLICY_NAME", name);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify mount policy ") + name + " because they do not exist");
@@ -3758,7 +3758,7 @@ void RdbmsCatalogue::insertArchiveFile(rdbms::Conn &conn, const rdbms::Autocommi
"WHERE "
"DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"STORAGE_CLASS_NAME = :STORAGE_CLASS_NAME";
- auto stmt = conn.createStmt(sql, autocommitMode);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":ARCHIVE_FILE_ID", row.archiveFileId);
stmt.bindString(":DISK_INSTANCE_NAME", row.diskInstance);
@@ -3774,7 +3774,7 @@ void RdbmsCatalogue::insertArchiveFile(rdbms::Conn &conn, const rdbms::Autocommi
stmt.bindUint64(":CREATION_TIME", now);
stmt.bindUint64(":RECONCILIATION_TIME", now);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(autocommitMode);
} catch (exception::UserError &) {
throw;
} catch (exception::Exception &ex) {
@@ -3974,7 +3974,7 @@ common::dataStructures::ArchiveFileSummary RdbmsCatalogue::getTapeFileSummary(
}
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
if(searchCriteria.archiveFileId) {
stmt.bindUint64(":ARCHIVE_FILE_ID", searchCriteria.archiveFileId.value());
}
@@ -4005,7 +4005,7 @@ common::dataStructures::ArchiveFileSummary RdbmsCatalogue::getTapeFileSummary(
if(searchCriteria.tapePool) {
stmt.bindString(":TAPE_POOL_NAME", searchCriteria.tapePool.value());
}
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
if(!rset.next()) {
throw exception::Exception("SELECT COUNT statement did not returned a row");
}
@@ -4061,12 +4061,12 @@ void RdbmsCatalogue::tapeLabelled(const std::string &vid, const std::string &dri
"WHERE "
"VID = :VID";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":LABEL_DRIVE", drive);
stmt.bindUint64(":LABEL_TIME", now);
stmt.bindBool(":LBP_IS_ON", lbpIsOn);
stmt.bindString(":VID", vid);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
if(0 == stmt.getNbAffectedRows()) {
throw exception::UserError(std::string("Cannot modify tape ") + vid + " because it does not exist");
@@ -4215,10 +4215,10 @@ common::dataStructures::TapeCopyToPoolMap RdbmsCatalogue::getTapeCopyToPoolMap(r
"WHERE "
"STORAGE_CLASS.DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"STORAGE_CLASS.STORAGE_CLASS_NAME = :STORAGE_CLASS_NAME";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", storageClass.diskInstanceName);
stmt.bindString(":STORAGE_CLASS_NAME", storageClass.storageClassName);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
while (rset.next()) {
const uint64_t copyNb = rset.columnUint64("COPY_NB");
const std::string tapePoolName = rset.columnString("TAPE_POOL_NAME");
@@ -4269,10 +4269,10 @@ uint64_t RdbmsCatalogue::getExpectedNbArchiveRoutes(rdbms::Conn &conn, const Sto
"WHERE "
"STORAGE_CLASS.DISK_INSTANCE_NAME = :DISK_INSTANCE_NAME AND "
"STORAGE_CLASS.STORAGE_CLASS_NAME = :STORAGE_CLASS_NAME";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", storageClass.diskInstanceName);
stmt.bindString(":STORAGE_CLASS_NAME", storageClass.storageClassName);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
if(!rset.next()) {
throw exception::Exception("Result set of SELECT COUNT(*) is empty");
}
@@ -4305,13 +4305,13 @@ void RdbmsCatalogue::updateTape(
"LAST_WRITE_TIME = :LAST_WRITE_TIME "
"WHERE "
"VID = :VID";
- auto stmt = conn.createStmt(sql, autocommitMode);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":VID", vid);
stmt.bindUint64(":LAST_FSEQ", lastFSeq);
stmt.bindUint64(":DATA_IN_BYTES", compressedBytesWritten);
stmt.bindString(":LAST_WRITE_DRIVE", tapeDrive);
stmt.bindUint64(":LAST_WRITE_TIME", now);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(autocommitMode);
} catch(exception::UserError &) {
throw;
} catch(exception::Exception &ex) {
@@ -4449,12 +4449,12 @@ RequesterAndGroupMountPolicies RdbmsCatalogue::getMountPolicies(
"REQUESTER_GROUP_MOUNT_RULE.DISK_INSTANCE_NAME = :GROUP_DISK_INSTANCE_NAME AND "
"REQUESTER_GROUP_MOUNT_RULE.REQUESTER_GROUP_NAME = :REQUESTER_GROUP_NAME";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":REQUESTER_DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":GROUP_DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":REQUESTER_NAME", requesterName);
stmt.bindString(":REQUESTER_GROUP_NAME", requesterGroupName);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
RequesterAndGroupMountPolicies policies;
while(rset.next()) {
@@ -4530,11 +4530,11 @@ void RdbmsCatalogue::deleteArchiveFile(const std::string &diskInstanceName, cons
auto conn = m_connPool.getConn();
rdbms::AutoRollback autoRollback(conn);
const auto getConnTime = t.secs(utils::Timer::resetCounter);
- auto selectStmt = conn.createStmt(selectSql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto selectStmt = conn.createStmt(selectSql);
const auto createStmtTime = t.secs();
selectStmt.bindUint64(":ARCHIVE_FILE_ID", archiveFileId);
t.reset();
- rdbms::Rset selectRset = selectStmt.executeQuery();
+ rdbms::Rset selectRset = selectStmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
const auto selectFromArchiveFileTime = t.secs();
std::unique_ptr<common::dataStructures::ArchiveFile> archiveFile;
while(selectRset.next()) {
@@ -4625,17 +4625,17 @@ void RdbmsCatalogue::deleteArchiveFile(const std::string &diskInstanceName, cons
t.reset();
{
const char *const sql = "DELETE FROM TAPE_FILE WHERE ARCHIVE_FILE_ID = :ARCHIVE_FILE_ID";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":ARCHIVE_FILE_ID", archiveFileId);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
}
const auto deleteFromTapeFileTime = t.secs(utils::Timer::resetCounter);
{
const char *const sql = "DELETE FROM ARCHIVE_FILE WHERE ARCHIVE_FILE_ID = :ARCHIVE_FILE_ID";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":ARCHIVE_FILE_ID", archiveFileId);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
}
const auto deleteFromArchiveFileTime = t.secs(utils::Timer::resetCounter);
@@ -4728,9 +4728,9 @@ bool RdbmsCatalogue::isNonCachedAdmin(const common::dataStructures::SecurityIden
"WHERE "
"ADMIN_USER_NAME = :ADMIN_USER_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":ADMIN_USER_NAME", admin.username);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
return rset.next();
} catch(exception::UserError &) {
throw;
@@ -4764,9 +4764,9 @@ std::list<TapeForWriting> RdbmsCatalogue::getTapesForWriting(const std::string &
"LOGICAL_LIBRARY_NAME = :LOGICAL_LIBRARY_NAME";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":LOGICAL_LIBRARY_NAME", logicalLibraryName);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
while (rset.next()) {
TapeForWriting tape;
tape.vid = rset.columnString("VID");
@@ -4813,7 +4813,7 @@ void RdbmsCatalogue::insertTapeFile(
":COPY_NB,"
":CREATION_TIME,"
":ARCHIVE_FILE_ID)";
- auto stmt = conn.createStmt(sql, autocommitMode);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":VID", tapeFile.vid);
stmt.bindUint64(":FSEQ", tapeFile.fSeq);
@@ -4823,7 +4823,7 @@ void RdbmsCatalogue::insertTapeFile(
stmt.bindUint64(":CREATION_TIME", now);
stmt.bindUint64(":ARCHIVE_FILE_ID", archiveFileId);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(autocommitMode);
} catch(exception::UserError &) {
throw;
} catch(exception::Exception &ex) {
@@ -4851,10 +4851,10 @@ void RdbmsCatalogue::setTapeLastFSeq(rdbms::Conn &conn, const std::string &vid,
"LAST_FSEQ = :LAST_FSEQ "
"WHERE "
"VID=:VID";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":VID", vid);
stmt.bindUint64(":LAST_FSEQ", lastFSeq);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
} catch(exception::UserError &) {
throw;
} catch(exception::Exception &ex) {
@@ -4875,9 +4875,9 @@ uint64_t RdbmsCatalogue::getTapeLastFSeq(rdbms::Conn &conn, const std::string &v
"TAPE "
"WHERE "
"VID = :VID";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":VID", vid);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
if(rset.next()) {
return rset.columnUint64("LAST_FSEQ");
} else {
@@ -4929,9 +4929,9 @@ std::unique_ptr<common::dataStructures::ArchiveFile> RdbmsCatalogue::getArchiveF
"ARCHIVE_FILE.ARCHIVE_FILE_ID = :ARCHIVE_FILE_ID "
"ORDER BY "
"TAPE_FILE.CREATION_TIME ASC";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":ARCHIVE_FILE_ID", archiveFileId);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
std::unique_ptr<common::dataStructures::ArchiveFile> archiveFile;
while (rset.next()) {
if(nullptr == archiveFile.get()) {
@@ -5018,9 +5018,9 @@ std::unique_ptr<common::dataStructures::ArchiveFile> RdbmsCatalogue::getArchiveF
"TAPE.IS_DISABLED = 0 "
"ORDER BY "
"TAPE_FILE.CREATION_TIME ASC";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":ARCHIVE_FILE_ID", archiveFileId);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
std::unique_ptr<common::dataStructures::ArchiveFile> archiveFile;
while (rset.next()) {
if(nullptr == archiveFile.get()) {
@@ -5107,10 +5107,10 @@ std::unique_ptr<common::dataStructures::ArchiveFile> RdbmsCatalogue::getArchiveF
"ARCHIVE_FILE.DISK_FILE_ID = :DISK_FILE_ID "
"ORDER BY "
"TAPE_FILE.CREATION_TIME ASC";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":DISK_FILE_ID", diskFileId);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
std::unique_ptr<common::dataStructures::ArchiveFile> archiveFile;
while (rset.next()) {
if(nullptr == archiveFile.get()) {
@@ -5200,10 +5200,10 @@ std::unique_ptr<common::dataStructures::ArchiveFile> RdbmsCatalogue::getArchiveF
"TAPE.IS_DISABLED = 0 "
"ORDER BY "
"TAPE_FILE.CREATION_TIME ASC";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":DISK_INSTANCE_NAME", diskInstanceName);
stmt.bindString(":DISK_FILE_ID", diskFileId);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
std::unique_ptr<common::dataStructures::ArchiveFile> archiveFile;
while (rset.next()) {
if(nullptr == archiveFile.get()) {
@@ -5257,8 +5257,8 @@ void RdbmsCatalogue::ping() {
try {
const char *const sql = "SELECT COUNT(*) FROM CTA_CATALOGUE";
auto conn = m_connPool.getConn();
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
- auto rset = stmt.executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
} catch(exception::UserError &) {
throw;
} catch(exception::Exception &ex) {
diff --git a/catalogue/SchemaCreatingSqliteCatalogue.cpp b/catalogue/SchemaCreatingSqliteCatalogue.cpp
index dd236e42d373c2a62657a325dd3cbe84dc2a291d..3a1e8232a13e1cbc1024d735e799e5b138344e50 100644
--- a/catalogue/SchemaCreatingSqliteCatalogue.cpp
+++ b/catalogue/SchemaCreatingSqliteCatalogue.cpp
@@ -46,7 +46,7 @@ void SchemaCreatingSqliteCatalogue::createCatalogueSchema() {
try {
const SqliteCatalogueSchema schema;
auto conn = m_connPool.getConn();
- conn.executeNonQueries(schema.sql);
+ conn.executeNonQueries(schema.sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
} catch(exception::Exception &ex) {
throw exception::Exception(std::string(__FUNCTION__) + " failed: " + ex.getMessage().str());
}
diff --git a/catalogue/SqliteCatalogue.cpp b/catalogue/SqliteCatalogue.cpp
index bcad8a2167379be8a29d0ef0c70241fe9794298f..0ccaa5836e1df0bc91ca6b07d3005c61f1552cdf 100644
--- a/catalogue/SqliteCatalogue.cpp
+++ b/catalogue/SqliteCatalogue.cpp
@@ -123,17 +123,17 @@ void SqliteCatalogue::deleteArchiveFile(const std::string &diskInstanceName, con
t.reset();
{
const char *const sql = "DELETE FROM TAPE_FILE WHERE ARCHIVE_FILE_ID = :ARCHIVE_FILE_ID;";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":ARCHIVE_FILE_ID", archiveFileId);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
}
const auto deleteFromTapeFileTime = t.secs(utils::Timer::resetCounter);
{
const char *const sql = "DELETE FROM ARCHIVE_FILE WHERE ARCHIVE_FILE_ID = :ARCHIVE_FILE_ID;";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
+ auto stmt = conn.createStmt(sql);
stmt.bindUint64(":ARCHIVE_FILE_ID", archiveFileId);
- stmt.executeNonQuery();
+ stmt.executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
}
const auto deleteFromArchiveFileTime = t.secs(utils::Timer::resetCounter);
@@ -199,8 +199,8 @@ uint64_t SqliteCatalogue::getNextArchiveFileId(rdbms::Conn &conn) {
"ID AS ID "
"FROM "
"ARCHIVE_FILE_ID";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
- auto rset = stmt.executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
if(!rset.next()) {
throw exception::Exception("ARCHIVE_FILE_ID table is empty");
}
@@ -238,8 +238,8 @@ uint64_t SqliteCatalogue::getNextStorageClassId(rdbms::Conn &conn) {
"ID AS ID "
"FROM "
"STORAGE_CLASS_ID";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_OFF);
- auto rset = stmt.executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt.executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
if(!rset.next()) {
throw exception::Exception("STORAGE_CLASS_ID table is empty");
}
@@ -295,9 +295,9 @@ common::dataStructures::Tape SqliteCatalogue::selectTape(const rdbms::Autocommit
"WHERE "
"VID = :VID;";
- auto stmt = conn.createStmt(sql, autocommitMode);
+ auto stmt = conn.createStmt(sql);
stmt.bindString(":VID", vid);
- auto rset = stmt.executeQuery();
+ auto rset = stmt.executeQuery(autocommitMode);
if (!rset.next()) {
throw exception::Exception(std::string("The tape with VID " + vid + " does not exist"));
}
diff --git a/rdbms/Conn.cpp b/rdbms/Conn.cpp
index d80e66aae36c8b5b65cb519b063083b1149e9e43..7e0953a13bc95c52e98b28e54281483358278151 100644
--- a/rdbms/Conn.cpp
+++ b/rdbms/Conn.cpp
@@ -77,9 +77,9 @@ Conn &Conn::operator=(Conn &&rhs) {
//------------------------------------------------------------------------------
// createStmt
//------------------------------------------------------------------------------
-Stmt Conn::createStmt(const std::string &sql, const AutocommitMode autocommitMode) {
+Stmt Conn::createStmt(const std::string &sql) {
if(nullptr != m_connAndStmts && nullptr != m_connAndStmts->conn) {
- return m_connAndStmts->stmtPool->getStmt(*m_connAndStmts->conn, sql, autocommitMode);
+ return m_connAndStmts->stmtPool->getStmt(*m_connAndStmts->conn, sql);
} else {
throw exception::Exception(std::string(__FUNCTION__) + " failed: Conn does not contain a connection");
}
@@ -88,7 +88,7 @@ Stmt Conn::createStmt(const std::string &sql, const AutocommitMode autocommitMod
//------------------------------------------------------------------------------
// executeNonQueries
//------------------------------------------------------------------------------
-void Conn::executeNonQueries(const std::string &sqlStmts) {
+void Conn::executeNonQueries(const std::string &sqlStmts, const AutocommitMode autocommitMode) {
try {
std::string::size_type searchPos = 0;
std::string::size_type findResult = std::string::npos;
@@ -100,7 +100,7 @@ void Conn::executeNonQueries(const std::string &sqlStmts) {
searchPos = findResult + 1;
if(0 < sqlStmt.size()) { // Ignore empty statements
- executeNonQuery(sqlStmt, AutocommitMode::AUTOCOMMIT_ON);
+ executeNonQuery(sqlStmt, autocommitMode);
}
}
@@ -114,8 +114,8 @@ void Conn::executeNonQueries(const std::string &sqlStmts) {
//------------------------------------------------------------------------------
void Conn::executeNonQuery(const std::string &sql, const AutocommitMode autocommitMode) {
try {
- auto stmt = createStmt(sql, autocommitMode);
- stmt.executeNonQuery();
+ auto stmt = createStmt(sql);
+ stmt.executeNonQuery(autocommitMode);
} catch(exception::Exception &ex) {
throw exception::Exception(std::string(__FUNCTION__) + " failed: " + ex.what());
}
diff --git a/rdbms/Conn.hpp b/rdbms/Conn.hpp
index 53947b82616cf841d96311d1214c914597f554ec..5246749c9c1695d0418b81ea7495ee95b5ca69b8 100644
--- a/rdbms/Conn.hpp
+++ b/rdbms/Conn.hpp
@@ -82,10 +82,9 @@ public:
* Creates a prepared statement.
*
* @param sql The SQL statement.
- * @param autocommitMode The autocommit mode of the statement.
* @return The prepared statement.
*/
- Stmt createStmt(const std::string &sql, const AutocommitMode autocommitMode);
+ Stmt createStmt(const std::string &sql);
/**
* Convenience method that parses the specified string of multiple SQL
@@ -96,16 +95,16 @@ public:
* autocommit ON.
*
* @param sqlStmts The SQL statements to be executed.
- * @param autocommitMode The autocommit mode of the statement.
+ * @param autocommitMode The autocommit mode of the statements.
*/
- void executeNonQueries(const std::string &sqlStmts);
+ void executeNonQueries(const std::string &sqlStmts, const AutocommitMode autocommitMode);
/**
* Convenience method that wraps Conn::createStmt() followed by
* Stmt::executeNonQuery().
*
* @param sql The SQL statement.
- * @param autocommitMode The autocommit mode of the statement.
+ * @param autocommitMode The autocommit mode of the statements.
*/
void executeNonQuery(const std::string &sql, const AutocommitMode autocommitMode);
diff --git a/rdbms/ConnTest.cpp b/rdbms/ConnTest.cpp
index 1988d24c7ff1c548bdc37915432d6debea6925ff..bd3b34f1d791ac8176a5d2240e82cd9c46234bc9 100644
--- a/rdbms/ConnTest.cpp
+++ b/rdbms/ConnTest.cpp
@@ -67,7 +67,7 @@ TEST_F(cta_rdbms_ConnTest, createTableInMemoryDatabase_executeNonQueries) {
ASSERT_TRUE(conn.getTableNames().empty());
- conn.executeNonQueries(sql);
+ conn.executeNonQueries(sql, AutocommitMode::AUTOCOMMIT_ON);
ASSERT_EQ(1, conn.getTableNames().size());
}
@@ -121,7 +121,7 @@ TEST_F(cta_rdbms_ConnTest, createSameTableInTwoSeparateInMemoryDatabases_execute
ASSERT_TRUE(conn.getTableNames().empty());
- conn.executeNonQueries(sql);
+ conn.executeNonQueries(sql, AutocommitMode::AUTOCOMMIT_ON);
ASSERT_EQ(1, conn.getTableNames().size());
}
@@ -135,7 +135,7 @@ TEST_F(cta_rdbms_ConnTest, createSameTableInTwoSeparateInMemoryDatabases_execute
ASSERT_TRUE(conn.getTableNames().empty());
- conn.executeNonQueries(sql);
+ conn.executeNonQueries(sql, AutocommitMode::AUTOCOMMIT_ON);
ASSERT_EQ(1, conn.getTableNames().size());
}
diff --git a/rdbms/Stmt.cpp b/rdbms/Stmt.cpp
index 34eac226fb333327990dc6024344896c9c576410..186f9a1a35220728b72e114baf346278fc82eb20 100644
--- a/rdbms/Stmt.cpp
+++ b/rdbms/Stmt.cpp
@@ -175,9 +175,9 @@ void Stmt::bindOptionalString(const std::string ¶mName, const optional<std::
//-----------------------------------------------------------------------------
// executeQuery
//-----------------------------------------------------------------------------
-Rset Stmt::executeQuery() {
+Rset Stmt::executeQuery(const AutocommitMode autocommitMode) {
if(nullptr != m_stmt) {
- return Rset(m_stmt->executeQuery());
+ return Rset(m_stmt->executeQuery(autocommitMode));
} else {
throw exception::Exception(std::string(__FUNCTION__) + " failed: Stmt does not contain a cached statement");
}
@@ -186,9 +186,9 @@ Rset Stmt::executeQuery() {
//-----------------------------------------------------------------------------
// executeNonQuery
//-----------------------------------------------------------------------------
-void Stmt::executeNonQuery() {
+void Stmt::executeNonQuery(const AutocommitMode autocommitMode) {
if(nullptr != m_stmt) {
- return m_stmt->executeNonQuery();
+ return m_stmt->executeNonQuery(autocommitMode);
} else {
throw exception::Exception(std::string(__FUNCTION__) + " failed: Stmt does not contain a cached statement");
}
diff --git a/rdbms/Stmt.hpp b/rdbms/Stmt.hpp
index 899e2f83e6b88ec0df9ca9ec1435a02f73e188c6..ae5c62ca6e52615eb602dd2f05effaa5a09ea26b 100644
--- a/rdbms/Stmt.hpp
+++ b/rdbms/Stmt.hpp
@@ -18,6 +18,7 @@
#pragma once
+#include "rdbms/AutocommitMode.hpp"
#include "rdbms/Rset.hpp"
#include "common/optional.hpp"
@@ -161,14 +162,17 @@ public:
/**
* Executes the statement and returns the result set.
*
+ * @param autocommitMode The autocommit mode of the statement.
* @return The result set.
*/
- Rset executeQuery();
+ Rset executeQuery(const AutocommitMode autocommitMode);
/**
* Executes the statement.
+ *
+ * @param autocommitMode The autocommit mode of the statement.
*/
- void executeNonQuery();
+ void executeNonQuery(const AutocommitMode autocommitMode);
/**
* Returns the number of rows affected by the last execution of this
diff --git a/rdbms/StmtPool.cpp b/rdbms/StmtPool.cpp
index 537efae8d32cadf20ec58c7f8fd24fc640306c6c..5e0795580afbc277897c74fba7cd3bede5d4eb8b 100644
--- a/rdbms/StmtPool.cpp
+++ b/rdbms/StmtPool.cpp
@@ -27,16 +27,14 @@ namespace rdbms {
//------------------------------------------------------------------------------
// getStmt
//------------------------------------------------------------------------------
-Stmt StmtPool::getStmt(wrapper::Conn &conn, const std::string &sql, const AutocommitMode autocommitMode) {
- const CachedStmtKey key(sql, autocommitMode);
-
+Stmt StmtPool::getStmt(wrapper::Conn &conn, const std::string &sql) {
threading::MutexLocker locker(m_stmtsMutex);
- auto itor = m_stmts.find(key);
+ auto itor = m_stmts.find(sql);
// If there is no prepared statement in the cache
if(itor == m_stmts.end()) {
- auto stmt = conn.createStmt(sql, autocommitMode);
+ auto stmt = conn.createStmt(sql);
return Stmt(std::move(stmt), *this);
} else {
auto &stmtList = itor->second;
@@ -75,11 +73,9 @@ uint64_t StmtPool::getNbStmts() const {
void StmtPool::returnStmt(std::unique_ptr<wrapper::Stmt> stmt) {
threading::MutexLocker locker(m_stmtsMutex);
- const CachedStmtKey key(stmt->getSql(), stmt->getAutocommitMode());
-
stmt->clear();
- m_stmts[key].push_back(std::move(stmt));
+ m_stmts[stmt->getSql()].push_back(std::move(stmt));
}
//------------------------------------------------------------------------------
diff --git a/rdbms/StmtPool.hpp b/rdbms/StmtPool.hpp
index 04c8ce6cd53a1226df5f8077e764dc5f96a87d7f..1cdcadf233a3fde7793bc632cb132176f394e3fc 100644
--- a/rdbms/StmtPool.hpp
+++ b/rdbms/StmtPool.hpp
@@ -49,10 +49,9 @@ public:
*
* @param conn The database connection to which the database statements
* @param sql The SQL statement.
- * @param autocommitMode The autocommit mode of the statement.
* @return The prepared statement.
*/
- Stmt getStmt(wrapper::Conn &conn, const std::string &sql, const AutocommitMode autocommitMode);
+ Stmt getStmt(wrapper::Conn &conn, const std::string &sql);
/**
* Returns the number of cached statements currently in the pool.
@@ -83,48 +82,13 @@ private:
*/
mutable threading::Mutex m_stmtsMutex;
- /**
- * Key used to lookup prepares statements within the cache.
- */
- struct CachedStmtKey {
- /**
- * The SQL of the cached statement.
- */
- std::string sql;
-
- /**
- * The autocommit mode of the cached statement.
- */
- const AutocommitMode autocommitMode;
-
- /**
- * Constructor.
- *
- * @param s The SQL of the cached statement.
- * @param a The autocommit mode of the cached statement.
- */
- CachedStmtKey(const std::string &s, const AutocommitMode a): sql(s), autocommitMode(a) {
- }
-
- /**
- * Less than operator.
- */
- bool operator<(const CachedStmtKey &rhs) const {
- if(sql != rhs.sql) {
- return sql < rhs.sql;
- } else {
- return autocommitMode < rhs.autocommitMode;
- }
- }
- };
-
/**
* The cached database statements.
*
* Please note that for a single key there maybe more than one cached
* statement, hence the map to list of statements.
*/
- std::map<CachedStmtKey, std::list< std::unique_ptr<wrapper::Stmt> > > m_stmts;
+ std::map<std::string, std::list< std::unique_ptr<wrapper::Stmt> > > m_stmts;
}; // class StmtPool
diff --git a/rdbms/StmtPoolTest.cpp b/rdbms/StmtPoolTest.cpp
index 3924118b6d0c5b6838a0a8bf97f27f96fbcc13e2..9a0246e3d106c8320f468322852f2fdf78ddc2bf 100644
--- a/rdbms/StmtPoolTest.cpp
+++ b/rdbms/StmtPoolTest.cpp
@@ -45,7 +45,7 @@ TEST_F(cta_rdbms_StmtPoolTest, getStmt) {
StmtPool pool;
ASSERT_EQ(0, pool.getNbStmts());
{
- auto stmt = pool.getStmt(*conn, sql, AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = pool.getStmt(*conn, sql);
ASSERT_EQ(0, pool.getNbStmts());
}
ASSERT_EQ(1, pool.getNbStmts());
@@ -61,7 +61,7 @@ TEST_F(cta_rdbms_StmtPoolTest, moveAssignment) {
StmtPool pool;
ASSERT_EQ(0, pool.getNbStmts());
{
- Stmt stmt1 = pool.getStmt(*conn, sql, AutocommitMode::AUTOCOMMIT_ON);
+ Stmt stmt1 = pool.getStmt(*conn, sql);
Stmt stmt2;
stmt2 = std::move(stmt1);
ASSERT_EQ(0, pool.getNbStmts());
@@ -79,7 +79,7 @@ TEST_F(cta_rdbms_StmtPoolTest, moveConstructor) {
StmtPool pool;
ASSERT_EQ(0, pool.getNbStmts());
{
- Stmt stmt1 = pool.getStmt(*conn, sql, AutocommitMode::AUTOCOMMIT_ON);
+ Stmt stmt1 = pool.getStmt(*conn, sql);
Stmt stmt2(std::move(stmt1));
ASSERT_EQ(0, pool.getNbStmts());
}
@@ -109,8 +109,8 @@ TEST_F(cta_rdbms_StmtPoolTest, createSameTableInTwoSeparateInMemoryDatabases) {
StmtPool pool;
{
- Stmt stmt = pool.getStmt(*conn, selectTableNamesSql, AutocommitMode::AUTOCOMMIT_ON);
- auto rset = stmt.executeQuery();
+ Stmt stmt = pool.getStmt(*conn, selectTableNamesSql);
+ auto rset = stmt.executeQuery(AutocommitMode::AUTOCOMMIT_ON);
std::list<std::string> names;
while(rset.next()) {
names.push_back(rset.columnString("NAME"));
@@ -119,13 +119,13 @@ TEST_F(cta_rdbms_StmtPoolTest, createSameTableInTwoSeparateInMemoryDatabases) {
}
{
- Stmt stmt = pool.getStmt(*conn, createTableSql, AutocommitMode::AUTOCOMMIT_ON);
- stmt.executeNonQuery();
+ Stmt stmt = pool.getStmt(*conn, createTableSql);
+ stmt.executeNonQuery(AutocommitMode::AUTOCOMMIT_ON);
}
{
- Stmt stmt = pool.getStmt(*conn, selectTableNamesSql, AutocommitMode::AUTOCOMMIT_ON);
- auto rset = stmt.executeQuery();
+ Stmt stmt = pool.getStmt(*conn, selectTableNamesSql);
+ auto rset = stmt.executeQuery(AutocommitMode::AUTOCOMMIT_ON);
std::list<std::string> names;
while(rset.next()) {
names.push_back(rset.columnString("NAME"));
@@ -143,8 +143,8 @@ TEST_F(cta_rdbms_StmtPoolTest, createSameTableInTwoSeparateInMemoryDatabases) {
StmtPool pool;
{
- Stmt stmt = pool.getStmt(*conn, selectTableNamesSql, AutocommitMode::AUTOCOMMIT_ON);
- auto rset = stmt.executeQuery();
+ Stmt stmt = pool.getStmt(*conn, selectTableNamesSql);
+ auto rset = stmt.executeQuery(AutocommitMode::AUTOCOMMIT_ON);
std::list<std::string> names;
while(rset.next()) {
names.push_back(rset.columnString("NAME"));
@@ -153,13 +153,13 @@ TEST_F(cta_rdbms_StmtPoolTest, createSameTableInTwoSeparateInMemoryDatabases) {
}
{
- Stmt stmt = pool.getStmt(*conn, createTableSql, AutocommitMode::AUTOCOMMIT_ON);
- stmt.executeNonQuery();
+ Stmt stmt = pool.getStmt(*conn, createTableSql);
+ stmt.executeNonQuery(AutocommitMode::AUTOCOMMIT_ON);
}
{
- Stmt stmt = pool.getStmt(*conn, selectTableNamesSql, AutocommitMode::AUTOCOMMIT_ON);
- auto rset = stmt.executeQuery();
+ Stmt stmt = pool.getStmt(*conn, selectTableNamesSql);
+ auto rset = stmt.executeQuery(AutocommitMode::AUTOCOMMIT_ON);
std::list<std::string> names;
while(rset.next()) {
names.push_back(rset.columnString("NAME"));
@@ -186,8 +186,8 @@ TEST_F(cta_rdbms_StmtPoolTest, createSameTableInTwoSeparateInMemoryDatabases_get
ASSERT_TRUE(conn->getTableNames().empty());
{
- Stmt stmt = pool.getStmt(*conn, createTableSql, AutocommitMode::AUTOCOMMIT_ON);
- stmt.executeNonQuery();
+ Stmt stmt = pool.getStmt(*conn, createTableSql);
+ stmt.executeNonQuery(AutocommitMode::AUTOCOMMIT_ON);
}
ASSERT_EQ(1, conn->getTableNames().size());
@@ -204,8 +204,8 @@ TEST_F(cta_rdbms_StmtPoolTest, createSameTableInTwoSeparateInMemoryDatabases_get
ASSERT_TRUE(conn->getTableNames().empty());
{
- Stmt stmt = pool.getStmt(*conn, createTableSql, AutocommitMode::AUTOCOMMIT_ON);
- stmt.executeNonQuery();
+ Stmt stmt = pool.getStmt(*conn, createTableSql);
+ stmt.executeNonQuery(AutocommitMode::AUTOCOMMIT_ON);
}
ASSERT_EQ(1, conn->getTableNames().size());
@@ -222,8 +222,8 @@ TEST_F(cta_rdbms_StmtPoolTest, sameSqlTwoCachedStmts) {
StmtPool pool;
ASSERT_EQ(0, pool.getNbStmts());
{
- Stmt stmt1 = pool.getStmt(*conn, sql, AutocommitMode::AUTOCOMMIT_ON);
- Stmt stmt2 = pool.getStmt(*conn, sql, AutocommitMode::AUTOCOMMIT_ON);
+ Stmt stmt1 = pool.getStmt(*conn, sql);
+ Stmt stmt2 = pool.getStmt(*conn, sql);
ASSERT_EQ(0, pool.getNbStmts());
}
ASSERT_EQ(2, pool.getNbStmts());
diff --git a/rdbms/wrapper/Conn.hpp b/rdbms/wrapper/Conn.hpp
index 8b90734f59aae71a27f9ee5115d078aadf342cd3..05c7b2aec811728d8bcf9a366384d0276d0c56d9 100644
--- a/rdbms/wrapper/Conn.hpp
+++ b/rdbms/wrapper/Conn.hpp
@@ -49,10 +49,9 @@ public:
* Creates a prepared statement.
*
* @param sql The SQL statement.
- * @param autocommitMode The autocommit mode of the statement.
* @return The prepared statement.
*/
- virtual std::unique_ptr<Stmt> createStmt(const std::string &sql, const AutocommitMode autocommitMode) = 0;
+ virtual std::unique_ptr<Stmt> createStmt(const std::string &sql) = 0;
/**
* Commits the current transaction.
diff --git a/rdbms/wrapper/ConnTest.cpp b/rdbms/wrapper/ConnTest.cpp
index cfea5c20d85d646dc7dbe145a6883e21c129c5d4..2b7758be52540a74e6ef54509ba04466eb3af29f 100644
--- a/rdbms/wrapper/ConnTest.cpp
+++ b/rdbms/wrapper/ConnTest.cpp
@@ -48,8 +48,8 @@ TEST_F(cta_rdbms_wrapper_ConnTest, createSameTableInTwoSeparateInMemoryDatabases
ASSERT_TRUE(conn->getTableNames().empty());
- auto stmt = conn->createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- stmt->executeNonQuery();
+ auto stmt = conn->createStmt(sql);
+ stmt->executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
ASSERT_EQ(1, conn->getTableNames().size());
}
@@ -62,8 +62,8 @@ TEST_F(cta_rdbms_wrapper_ConnTest, createSameTableInTwoSeparateInMemoryDatabases
ASSERT_TRUE(conn->getTableNames().empty());
- auto stmt = conn->createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- stmt->executeNonQuery();
+ auto stmt = conn->createStmt(sql);
+ stmt->executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
ASSERT_EQ(1, conn->getTableNames().size());
}
diff --git a/rdbms/wrapper/OcciConn.cpp b/rdbms/wrapper/OcciConn.cpp
index dacb83e309c771ecaaf4d427f64e783752d0cc97..916449dd3b732e5130f5dfee46a6f42fa7d4cb8c 100644
--- a/rdbms/wrapper/OcciConn.cpp
+++ b/rdbms/wrapper/OcciConn.cpp
@@ -68,7 +68,7 @@ void OcciConn::close() {
//------------------------------------------------------------------------------
// createStmt
//------------------------------------------------------------------------------
-std::unique_ptr<Stmt> OcciConn::createStmt(const std::string &sql, AutocommitMode autocommitMode) {
+std::unique_ptr<Stmt> OcciConn::createStmt(const std::string &sql) {
try {
threading::MutexLocker locker(m_mutex);
@@ -80,7 +80,7 @@ std::unique_ptr<Stmt> OcciConn::createStmt(const std::string &sql, AutocommitMod
if (nullptr == stmt) {
throw exception::Exception("oracle::occi::createStatement() returned a nullptr pointer");
}
- return cta::make_unique<OcciStmt>(autocommitMode, sql, *this, stmt);
+ return cta::make_unique<OcciStmt>(sql, *this, stmt);
} catch(exception::Exception &ex) {
throw exception::Exception(std::string(__FUNCTION__) + " failed for SQL statement " + sql + ": " +
ex.getMessage().str());
@@ -140,8 +140,8 @@ std::list<std::string> OcciConn::getTableNames() {
"USER_TABLES "
"ORDER BY "
"TABLE_NAME";
- auto stmt = createStmt(sql, AutocommitMode::AUTOCOMMIT_OFF);
- auto rset = stmt->executeQuery();
+ auto stmt = createStmt(sql);
+ auto rset = stmt->executeQuery(AutocommitMode::AUTOCOMMIT_OFF);
while (rset->next()) {
auto name = rset->columnOptionalString("TABLE_NAME");
if(name) {
@@ -168,8 +168,8 @@ std::list<std::string> OcciConn::getSequenceNames() {
"USER_SEQUENCES "
"ORDER BY "
"SEQUENCE_NAME";
- auto stmt = createStmt(sql, AutocommitMode::AUTOCOMMIT_OFF);
- auto rset = stmt->executeQuery();
+ auto stmt = createStmt(sql);
+ auto rset = stmt->executeQuery(AutocommitMode::AUTOCOMMIT_OFF);
while (rset->next()) {
auto name = rset->columnOptionalString("SEQUENCE_NAME");
names.push_back(name.value());
diff --git a/rdbms/wrapper/OcciConn.hpp b/rdbms/wrapper/OcciConn.hpp
index dff34745b27d6082b87ecddede74241b2bef1b7b..f814868db6032724e3d2889129e62012ec513810 100644
--- a/rdbms/wrapper/OcciConn.hpp
+++ b/rdbms/wrapper/OcciConn.hpp
@@ -64,10 +64,9 @@ public:
* Creates a prepared statement.
*
* @param sql The SQL statement.
- * @param autocommitMode The autocommit mode of the statement.
* @return The prepared statement.
*/
- std::unique_ptr<Stmt> createStmt(const std::string &sql, const AutocommitMode autocommitMode) override;
+ std::unique_ptr<Stmt> createStmt(const std::string &sql) override;
/**
* Commits the current transaction.
diff --git a/rdbms/wrapper/OcciStmt.cpp b/rdbms/wrapper/OcciStmt.cpp
index 38059fd503c1e837f65b5b1a0aa9075c8b8d7eaf..30ed9c6ce5243b015ada3eeae051abfaab0ae985 100644
--- a/rdbms/wrapper/OcciStmt.cpp
+++ b/rdbms/wrapper/OcciStmt.cpp
@@ -38,36 +38,12 @@ namespace wrapper {
// constructor
//------------------------------------------------------------------------------
OcciStmt::OcciStmt(
- const AutocommitMode autocommitMode,
const std::string &sql,
OcciConn &conn,
oracle::occi::Statement *const stmt) :
- Stmt(sql, autocommitMode),
+ Stmt(sql),
m_conn(conn),
m_stmt(stmt) {
-
- // m_occiConn and m_stmt have been set and m_stmt is not nullptr so it is safe to
- // call close() from now on
- try {
- switch(autocommitMode) {
- case AutocommitMode::AUTOCOMMIT_ON:
- m_stmt->setAutoCommit(true);
- break;
- case AutocommitMode::AUTOCOMMIT_OFF:
- // Do nothing because an occi::Statement has autocommit turned off by default
- break;
- default:
- throw exception::Exception("Unknown autocommit mode");
- }
- } catch(exception::Exception &ex) {
- close();
- throw exception::Exception(std::string(__FUNCTION__) + " failed for SQL statement " +
- getSqlForException() + ": " + ex.getMessage().str());
- } catch(std::exception &se) {
- close();
- throw exception::Exception(std::string(__FUNCTION__) + " failed for SQL statement " +
- getSqlForException() + ": " + se.what());
- }
}
//------------------------------------------------------------------------------
@@ -178,10 +154,21 @@ void OcciStmt::bindOptionalString(const std::string ¶mName, const optional<s
//------------------------------------------------------------------------------
// executeQuery
//------------------------------------------------------------------------------
-std::unique_ptr<Rset> OcciStmt::executeQuery() {
+std::unique_ptr<Rset> OcciStmt::executeQuery(const AutocommitMode autocommitMode) {
using namespace oracle;
try {
+ switch(autocommitMode) {
+ case AutocommitMode::AUTOCOMMIT_ON:
+ m_stmt->setAutoCommit(true);
+ break;
+ case AutocommitMode::AUTOCOMMIT_OFF:
+ m_stmt->setAutoCommit(false);
+ break;
+ default:
+ throw exception::Exception("Unknown autocommit mode");
+ }
+
return cta::make_unique<OcciRset>(*this, m_stmt->executeQuery());
} catch(occi::SQLException &ex) {
std::ostringstream msg;
@@ -207,10 +194,21 @@ std::unique_ptr<Rset> OcciStmt::executeQuery() {
//------------------------------------------------------------------------------
// executeNonQuery
//------------------------------------------------------------------------------
-void OcciStmt::executeNonQuery() {
+void OcciStmt::executeNonQuery(const AutocommitMode autocommitMode) {
using namespace oracle;
try {
+ switch(autocommitMode) {
+ case AutocommitMode::AUTOCOMMIT_ON:
+ m_stmt->setAutoCommit(true);
+ break;
+ case AutocommitMode::AUTOCOMMIT_OFF:
+ m_stmt->setAutoCommit(false);
+ break;
+ default:
+ throw exception::Exception("Unknown autocommit mode");
+ }
+
m_stmt->executeUpdate();
} catch(occi::SQLException &ex) {
std::ostringstream msg;
diff --git a/rdbms/wrapper/OcciStmt.hpp b/rdbms/wrapper/OcciStmt.hpp
index 5b0df16e926ce819d9e3deb5c26e37fde1dbb17f..b1d68d50cbef53ae103d1e5c9d598396e37103d0 100644
--- a/rdbms/wrapper/OcciStmt.hpp
+++ b/rdbms/wrapper/OcciStmt.hpp
@@ -52,13 +52,11 @@ public:
/**
* Constructor.
*
- * @param autocommitMode The autocommit mode of the statement.
* @param sql The SQL statement.
* @param conn The database connection.
* @param stmt The OCCI statement.
*/
OcciStmt(
- const AutocommitMode autocommitMode,
const std::string &sql,
OcciConn &conn,
oracle::occi::Statement *const stmt);
@@ -124,16 +122,19 @@ public:
void bindOptionalString(const std::string ¶mName, const optional<std::string> ¶mValue) override;
/**
- * Executes the statement and returns the result set.
+ * Executes the statement and returns the result set.
*
- * @return The result set.
+ * @param autocommitMode The autocommit mode of the statement.
+ * @return The result set.
*/
- std::unique_ptr<Rset> executeQuery() override;
+ std::unique_ptr<Rset> executeQuery(const AutocommitMode autocommitMode) override;
/**
* Executes the statement.
+ *
+ * @param autocommitMode The autocommit mode of the statement.
*/
- void executeNonQuery() override;
+ void executeNonQuery(const AutocommitMode autocommitMode) override;
/**
* Returns the number of rows affected by the last execution of this
diff --git a/rdbms/wrapper/SqliteConn.cpp b/rdbms/wrapper/SqliteConn.cpp
index c19a5702fcaa6c6a812c3947f3b21a03a0b565ae..cf2ba0291dc230cb8e8cfda671ccbd54f899e6b5 100644
--- a/rdbms/wrapper/SqliteConn.cpp
+++ b/rdbms/wrapper/SqliteConn.cpp
@@ -99,7 +99,7 @@ void SqliteConn::close() {
//------------------------------------------------------------------------------
// createStmt
//------------------------------------------------------------------------------
-std::unique_ptr<Stmt> SqliteConn::createStmt(const std::string &sql, const AutocommitMode autocommitMode) {
+std::unique_ptr<Stmt> SqliteConn::createStmt(const std::string &sql) {
try {
threading::MutexLocker locker(m_mutex);
@@ -107,7 +107,7 @@ std::unique_ptr<Stmt> SqliteConn::createStmt(const std::string &sql, const Autoc
throw exception::Exception("Connection is closed");
}
- return cta::make_unique<SqliteStmt>(autocommitMode , *this, sql);
+ return cta::make_unique<SqliteStmt>(*this, sql);
} catch(exception::Exception &ex) {
throw exception::Exception(std::string(__FUNCTION__) + " failed: " + ex.getMessage().str());
}
@@ -185,8 +185,8 @@ void SqliteConn::printSchema(std::ostream &os) {
"ORDER BY "
"TYPE, "
"NAME;";
- auto stmt = createStmt(sql, AutocommitMode::AUTOCOMMIT_ON);
- auto rset = stmt->executeQuery();
+ auto stmt = createStmt(sql);
+ auto rset = stmt->executeQuery(AutocommitMode::AUTOCOMMIT_ON);
os << "NAME, TYPE" << std::endl;
os << "==========" << std::endl;
while (rset->next()) {
@@ -213,8 +213,8 @@ std::list<std::string> SqliteConn::getTableNames() {
"TYPE = 'table' "
"ORDER BY "
"NAME;";
- auto stmt = createStmt(sql, AutocommitMode::AUTOCOMMIT_ON);
- auto rset = stmt->executeQuery();
+ auto stmt = createStmt(sql);
+ auto rset = stmt->executeQuery(AutocommitMode::AUTOCOMMIT_ON);
std::list<std::string> names;
while (rset->next()) {
auto name = rset->columnOptionalString("NAME");
diff --git a/rdbms/wrapper/SqliteConn.hpp b/rdbms/wrapper/SqliteConn.hpp
index b726f7d2e9d8065a949f8e2f957d843a4ddf7a45..05bac8b4e46cdced80823623952a5e392e05a6bc 100644
--- a/rdbms/wrapper/SqliteConn.hpp
+++ b/rdbms/wrapper/SqliteConn.hpp
@@ -66,10 +66,9 @@ public:
* Creates a prepared statement.
*
* @param sql The SQL statement.
- * @param autocommitMode The autocommit mode of the statement.
* @return The prepared statement.
*/
- std::unique_ptr<Stmt> createStmt(const std::string &sql, const AutocommitMode autocommitMode) override;
+ std::unique_ptr<Stmt> createStmt(const std::string &sql) override;
/**
* Commits the current transaction.
diff --git a/rdbms/wrapper/SqliteStmt.cpp b/rdbms/wrapper/SqliteStmt.cpp
index 4576179e186936c574ffafd4b087391404b20a54..ed59d3d15d0564cfb3df4f468977e39123f4098e 100644
--- a/rdbms/wrapper/SqliteStmt.cpp
+++ b/rdbms/wrapper/SqliteStmt.cpp
@@ -42,10 +42,9 @@ namespace wrapper {
// constructor
//------------------------------------------------------------------------------
SqliteStmt::SqliteStmt(
- const AutocommitMode autocommitMode,
SqliteConn &conn,
const std::string &sql):
- Stmt(sql, autocommitMode),
+ Stmt(sql),
m_conn(conn),
m_nbAffectedRows(0) {
m_stmt = nullptr;
@@ -80,32 +79,6 @@ SqliteStmt::SqliteStmt(
throw exception::Exception(std::string(__FUNCTION__) + " failed for SQL statement " + getSqlForException() +
": sqlite3_prepare_v2 failed: " + msg);
}
-
- // m_stmt has been set so it is safe to call close() from now on
- try {
- switch(autocommitMode) {
- case AutocommitMode::AUTOCOMMIT_ON:
- // Do nothing because SQLite statements autocommit be default
- break;
- case AutocommitMode::AUTOCOMMIT_OFF: {
- if(!m_conn.m_transactionInProgress) {
- beginDeferredTransaction();
- m_conn.m_transactionInProgress = true;
- }
- break;
- }
- default:
- throw exception::Exception("Unknown autocommit mode");
- }
- } catch(exception::Exception &ex) {
- close();
- throw exception::Exception(std::string(__FUNCTION__) + " failed for SQL statement " + getSqlForException() + ": " +
- ex.getMessage().str());
- } catch(std::exception &se) {
- close();
- throw exception::Exception(std::string(__FUNCTION__) + " failed for SQL statement " + getSqlForException() + ": " +
- se.what());
- }
}
//------------------------------------------------------------------------------
@@ -250,16 +223,22 @@ void SqliteStmt::bindOptionalString(const std::string ¶mName, const optional
//------------------------------------------------------------------------------
// executeQuery
//------------------------------------------------------------------------------
-std::unique_ptr<Rset> SqliteStmt::executeQuery() {
+std::unique_ptr<Rset> SqliteStmt::executeQuery(const AutocommitMode autocommitMode) {
+ threading::MutexLocker connLocker(m_conn.m_mutex);
+
+ startDeferredTransactionIfNecessary(autocommitMode);
+
return cta::make_unique<SqliteRset>(*this);
}
//------------------------------------------------------------------------------
// executeNonQuery
//------------------------------------------------------------------------------
-void SqliteStmt::executeNonQuery() {
+void SqliteStmt::executeNonQuery(const AutocommitMode autocommitMode) {
threading::MutexLocker connLocker(m_conn.m_mutex);
+ startDeferredTransactionIfNecessary(autocommitMode);
+
const int stepRc = sqlite3_step(m_stmt);
// Throw an exception if the call to sqlite3_step() failed
@@ -296,6 +275,35 @@ uint64_t SqliteStmt::getNbAffectedRows() const {
return m_nbAffectedRows;
}
+//------------------------------------------------------------------------------
+// startDeferredTransactionIfNecessary
+//------------------------------------------------------------------------------
+void SqliteStmt::startDeferredTransactionIfNecessary(const AutocommitMode autocommitMode) {
+ // PLEASE NOTE this method assumes a lock has been taken on m_conn.m_mutex
+ const bool autocommit = autocommitModeToBool(autocommitMode);
+
+ if(m_conn.m_transactionInProgress && autocommit) {
+ throw exception::Exception("SqliteStmt does not support the execution of an AUTOCOMMIT_OFF statement followed an"
+ " AUTOCOMMIT_ON statement. Use commit() between the statements instead");
+ }
+
+ if(m_conn.m_transactionInProgress && !autocommit) {
+ beginDeferredTransaction();
+ m_conn.m_transactionInProgress = true;
+ }
+}
+
+//------------------------------------------------------------------------------
+// autoCommitModeToBool
+//------------------------------------------------------------------------------
+bool SqliteStmt::autocommitModeToBool(const AutocommitMode autocommitMode) {
+ switch(autocommitMode) {
+ case AutocommitMode::AUTOCOMMIT_ON: return true;
+ case AutocommitMode::AUTOCOMMIT_OFF: return false;
+ default: throw exception::Exception("Unknown autocommit mode");
+ }
+}
+
//------------------------------------------------------------------------------
// beginDeferredTransaction
//------------------------------------------------------------------------------
diff --git a/rdbms/wrapper/SqliteStmt.hpp b/rdbms/wrapper/SqliteStmt.hpp
index 2dc3a3268874f216431dc9c2fd72ed7f5d23c6b8..be48bdd3f0b0d47bbddaa3999347be534fcda10c 100644
--- a/rdbms/wrapper/SqliteStmt.hpp
+++ b/rdbms/wrapper/SqliteStmt.hpp
@@ -45,11 +45,10 @@ public:
* This method is called by the SqliteStmt::createStmt() method and assumes
* that a lock has already been taken on SqliteStmt::m_mutex;
*
- * @param autocommitMode The autocommit mode of the statement.
* @param conn The database connection.
* @param sql The SQL statement.
*/
- SqliteStmt(const AutocommitMode autocommitMode, SqliteConn &conn, const std::string &sql);
+ SqliteStmt(SqliteConn &conn, const std::string &sql);
/**
* Destructor.
@@ -119,14 +118,17 @@ public:
/**
* Executes the statement and returns the result set.
*
+ * @param autocommitMode The autocommit mode of the statement.
* @return The result set.
*/
- std::unique_ptr<Rset> executeQuery() override;
+ std::unique_ptr<Rset> executeQuery(const AutocommitMode autocommitMode) override;
/**
* Executes the statement.
+ *
+ * @param autocommitMode The autocommit mode of the statement.
*/
- void executeNonQuery() override;
+ void executeNonQuery(const AutocommitMode autocommitMode) override;
/**
* Returns the number of rows affected by the last execution of this
@@ -158,6 +160,25 @@ private:
*/
uint64_t m_nbAffectedRows;
+ /**
+ * Starts a deferred transaction if necessary.
+ *
+ * PLEASE NOTE this method assumes a lock has been taken on m_conn.m_mutex.
+ *
+ * @param autocommitMode The autocommit mode of the statement.
+ */
+ void startDeferredTransactionIfNecessary(const AutocommitMode autocommitMode);
+
+ /**
+ * @param autocommitMode The autocommit mode of the statement.
+ *
+ * @return true if autocommitMode is AUTOCOMMIT_ON, false if autocommitMode
+ * is AUTOCOMMIT_OFF, else throws an exception.
+ * @throw exception::Exception if autocommitMode is neither AUTOCOMMIT_ON
+ * nor AUTOCOMMIT_OFF.
+ */
+ static bool autocommitModeToBool(const AutocommitMode autocommitMode);
+
/**
* Begins an SQLite deferred transaction.
*
diff --git a/rdbms/wrapper/SqliteStmtTest.cpp b/rdbms/wrapper/SqliteStmtTest.cpp
index 6cd4182727de42382be7aa68c72519d18e4c4639..52b774689ca546c68b002b1f6264747749a559c8 100644
--- a/rdbms/wrapper/SqliteStmtTest.cpp
+++ b/rdbms/wrapper/SqliteStmtTest.cpp
@@ -43,7 +43,7 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, create_table) {
// Create a connection a memory resident database
SqliteConn conn(":memory:");
- // Assert that there are currently noi tables in the database
+ // Assert that there are currently no tables in the database
{
const char *const sql =
"SELECT "
@@ -52,8 +52,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, create_table) {
"SQLITE_MASTER "
"WHERE "
"TYPE = 'table';";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- auto rset = stmt->executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt->executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
ASSERT_TRUE(rset->next());
const auto nbTables = rset->columnOptionalUint64("NB_TABLES");
ASSERT_TRUE((bool)nbTables);
@@ -69,8 +69,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, create_table) {
"COL1 TEXT,"
"COL2 TEXT,"
"COL3 INTEGER);";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- stmt->executeNonQuery();
+ auto stmt = conn.createStmt(sql);
+ stmt->executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
}
// Test for the existence of the test table
@@ -82,8 +82,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, create_table) {
"WHERE "
"NAME = 'TEST1' AND "
"TYPE = 'table';";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- auto rset = stmt->executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt->executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
ASSERT_TRUE(rset->next());
const auto nbTables = rset->columnOptionalUint64("NB_TABLES");
ASSERT_TRUE((bool)nbTables);
@@ -100,8 +100,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, create_table) {
"COL1 TEXT,"
"COL2 TEXT,"
"COL3 INTEGER);";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- stmt->executeNonQuery();
+ auto stmt = conn.createStmt(sql);
+ stmt->executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
}
// Test for the existence of the second test table
@@ -113,8 +113,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, create_table) {
"WHERE "
"NAME = 'TEST2' AND "
"TYPE = 'table';";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- auto rset = stmt->executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt->executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
ASSERT_TRUE(rset->next());
const auto nbTables = rset->columnOptionalUint64("NB_TABLES");
ASSERT_TRUE((bool)nbTables);
@@ -146,8 +146,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, select_from_empty_table) {
"COL1 TEXT,"
"COL2 TEXT,"
"COL3 INTEGER);";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- stmt->executeNonQuery();
+ auto stmt = conn.createStmt(sql);
+ stmt->executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
ASSERT_EQ(1, conn.getTableNames().size());
ASSERT_EQ("TEST", conn.getTableNames().front());
}
@@ -161,8 +161,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, select_from_empty_table) {
"COL3 "
"FROM "
"TEST;";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- auto rset = stmt->executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt->executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
ASSERT_FALSE(rset->next());
}
}
@@ -182,8 +182,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, insert_without_bind) {
"COL1 TEXT,"
"COL2 TEXT,"
"COL3 INTEGER);";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- stmt->executeNonQuery();
+ auto stmt = conn.createStmt(sql);
+ stmt->executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
ASSERT_EQ(1, conn.getTableNames().size());
ASSERT_EQ("TEST", conn.getTableNames().front());
}
@@ -199,8 +199,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, insert_without_bind) {
"'one',"
"'two',"
"3);";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- stmt->executeNonQuery();
+ auto stmt = conn.createStmt(sql);
+ stmt->executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
}
// Select the row back from the table
@@ -212,8 +212,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, insert_without_bind) {
"COL3 AS COL3 "
"FROM "
"TEST;";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- auto rset = stmt->executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt->executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
ASSERT_TRUE(rset->next());
const auto col1 = rset->columnOptionalString("COL1");
@@ -248,8 +248,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, insert_with_bind) {
"COL1 TEXT,"
"COL2 TEXT,"
"COL3 INTEGER);";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- stmt->executeNonQuery();
+ auto stmt = conn.createStmt(sql);
+ stmt->executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
ASSERT_EQ(1, conn.getTableNames().size());
ASSERT_EQ("TEST", conn.getTableNames().front());
}
@@ -265,11 +265,11 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, insert_with_bind) {
":COL1,"
":COL2,"
":COL3);";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt->bindString(":COL1", "one");
stmt->bindString(":COL2", "two");
stmt->bindUint64(":COL3", 3);
- stmt->executeNonQuery();
+ stmt->executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
}
// Select the row back from the table
@@ -281,8 +281,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, insert_with_bind) {
"COL3 AS COL3 "
"FROM "
"TEST;";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- auto rset = stmt->executeQuery();
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt->executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
ASSERT_TRUE(rset->next());
const auto col1 = rset->columnOptionalString("COL1");
@@ -316,8 +316,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, isolated_transaction) {
"COL1 TEXT,"
"COL2 TEXT,"
"COL3 INTEGER);";
- auto stmt = connForCreate.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- stmt->executeNonQuery();
+ auto stmt = connForCreate.createStmt(sql);
+ stmt->executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
ASSERT_EQ(1, connForCreate.getTableNames().size());
ASSERT_EQ("TEST", connForCreate.getTableNames().front());
}
@@ -334,8 +334,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, isolated_transaction) {
"'one',"
"'two',"
"3);";
- auto stmt = connForInsert.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- stmt->executeNonQuery();
+ auto stmt = connForInsert.createStmt(sql);
+ stmt->executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
}
// Count the number of rows in the table from within another connection
@@ -348,8 +348,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, isolated_transaction) {
"COUNT(*) AS NB_ROWS "
"FROM "
"TEST;";
- auto stmt = connForSelect.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- auto rset = stmt->executeQuery();
+ auto stmt = connForSelect.createStmt(sql);
+ auto rset = stmt->executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_OFF);
ASSERT_TRUE(rset->next());
const auto nbRows = rset->columnOptionalUint64("NB_ROWS");
@@ -375,8 +375,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, executeNonQuery_insert_violating_primar
"CREATE TABLE TEST("
"COL1 INTEGER,"
"CONSTRAINT TEST_COL1_PK PRIMARY KEY(COL1));";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- stmt->executeNonQuery();
+ auto stmt = conn.createStmt(sql);
+ stmt->executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
ASSERT_EQ(1, conn.getTableNames().size());
ASSERT_EQ("TEST", conn.getTableNames().front());
}
@@ -388,9 +388,9 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, executeNonQuery_insert_violating_primar
"COL1)"
"VALUES("
":COL1);";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt->bindUint64(":COL1", 1);
- stmt->executeNonQuery();
+ stmt->executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
}
// Try to insert an identical row into the test table
@@ -400,9 +400,9 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, executeNonQuery_insert_violating_primar
"COL1)"
"VALUES("
":COL1);";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt->bindUint64(":COL1", 1);
- ASSERT_THROW(stmt->executeNonQuery(), exception::DatabasePrimaryKeyError);
+ ASSERT_THROW(stmt->executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON), exception::DatabasePrimaryKeyError);
}
}
@@ -421,8 +421,8 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, executeQuery_insert_violating_primary_k
"CREATE TABLE TEST("
"COL1 INTEGER,"
"CONSTRAINT TEST_COL1_PK PRIMARY KEY(COL1));";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
- stmt->executeNonQuery();
+ auto stmt = conn.createStmt(sql);
+ stmt->executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
ASSERT_EQ(1, conn.getTableNames().size());
ASSERT_EQ("TEST", conn.getTableNames().front());
}
@@ -434,9 +434,9 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, executeQuery_insert_violating_primary_k
"COL1)"
"VALUES("
":COL1);";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt->bindUint64(":COL1", 1);
- stmt->executeNonQuery();
+ stmt->executeNonQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
}
// Try to insert an identical row into the test table
@@ -446,9 +446,9 @@ TEST_F(cta_rdbms_wrapper_SqliteStmtTest, executeQuery_insert_violating_primary_k
"COL1)"
"VALUES("
":COL1);";
- auto stmt = conn.createStmt(sql, rdbms::AutocommitMode::AUTOCOMMIT_ON);
+ auto stmt = conn.createStmt(sql);
stmt->bindUint64(":COL1", 1);
- auto rset = stmt->executeQuery();
+ auto rset = stmt->executeQuery(rdbms::AutocommitMode::AUTOCOMMIT_ON);
ASSERT_THROW(rset->next(), exception::DatabasePrimaryKeyError);
}
}
diff --git a/rdbms/wrapper/Stmt.cpp b/rdbms/wrapper/Stmt.cpp
index e6cd95dcff437d76a0f48256a30f92d1f309ac7c..33f73b81e4eeb637d5d022ac0c553e53c0caa1cb 100644
--- a/rdbms/wrapper/Stmt.cpp
+++ b/rdbms/wrapper/Stmt.cpp
@@ -26,9 +26,8 @@ namespace wrapper {
//------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------
-Stmt::Stmt(const std::string &sql, const AutocommitMode autocommitMode):
+Stmt::Stmt(const std::string &sql):
m_sql(sql),
- m_autocommitMode(autocommitMode),
m_paramNameToIdx(sql) {
}
@@ -45,13 +44,6 @@ const std::string &Stmt::getSql() const {
return m_sql;
}
-//------------------------------------------------------------------------------
-// getAutocommitMode
-//------------------------------------------------------------------------------
-AutocommitMode Stmt::getAutocommitMode() const noexcept {
- return m_autocommitMode;
-}
-
//------------------------------------------------------------------------------
// getParamIdx
//------------------------------------------------------------------------------
diff --git a/rdbms/wrapper/Stmt.hpp b/rdbms/wrapper/Stmt.hpp
index c4acf62b74a46859dd5669c7897f682cf49c213a..00b36a9f1a7db0d9ddc95b0ac6fe3bc4a82352a5 100644
--- a/rdbms/wrapper/Stmt.hpp
+++ b/rdbms/wrapper/Stmt.hpp
@@ -42,16 +42,8 @@ public:
* Constructor.
*
* @param sql The SQL statement.
- * @param autocommitMode The autocommit mode of the statement.
*/
- Stmt(const std::string &sql, const AutocommitMode autocommitMode);
-
- /**
- * Returns the autocommit mode of teh statement.
- *
- * @return The autocommit mode of teh statement.
- */
- AutocommitMode getAutocommitMode() const noexcept;
+ Stmt(const std::string &sql);
/**
* Destructor.
@@ -162,14 +154,17 @@ public:
/**
* Executes the statement and returns the result set.
*
+ * @param autocommitMode The autocommit mode of the statement.
* @return The result set.
*/
- virtual std::unique_ptr<Rset> executeQuery() = 0;
+ virtual std::unique_ptr<Rset> executeQuery(const AutocommitMode autocommitMode) = 0;
/**
* Executes the statement.
+ *
+ * @param autocommitMode The autocommit mode of the statement.
*/
- virtual void executeNonQuery() = 0;
+ virtual void executeNonQuery(const AutocommitMode autocommitMode) = 0;
/**
* Returns the number of rows affected by the last execution of this
@@ -200,11 +195,6 @@ private:
*/
std::string m_sql;
- /**
- * The autocommit mode of the statement.
- */
- AutocommitMode m_autocommitMode;
-
/**
* Map from SQL parameter name to parameter index.
*/