namespace am
{
+/**
+ * Macro to handle SQLITE errors on prepare
+ */
+#define MY_SQLITE_PREPARE_V2(db,zSql,nByte,ppStmt,pzTail) \
+ if ((eCode = sqlite3_prepare_v2(db, zSql, nByte, ppStmt, pzTail))) \
+ { \
+ logError("CAmDatabaseHandler::my_sqlite_prepare_v2 on Command",zSql,"failed with errorCode:", eCode); \
+ return (E_DATABASE_ERROR); \
+ }
+
+#define MY_SQLITE_PREPARE_V2_BOOL(db,zSql,nByte,ppStmt,pzTail) \
+ if ((eCode = sqlite3_prepare_v2(db, zSql, nByte, ppStmt, pzTail))) \
+ { \
+ logError("CAmDatabaseHandler::my_sqlite_prepare_v2_bool on Command",zSql,"failed with errorCode:", eCode); \
+ return (false); \
+ }
+
+/**
+ * Macro to handle SQLITE errors bind text
+ */
+#define MY_SQLITE_BIND_TEXT(query,index,text,size,static_) \
+ if ((eCode = sqlite3_bind_text(query, index, text, size, static_))) \
+ { \
+ logError("CAmDatabaseHandler::sqlite3_bind_text failed with errorCode:", eCode); \
+ return (E_DATABASE_ERROR); \
+ }
+
+/**
+ * Macro to handle SQLITE errors on bind int
+ */
+#define MY_SQLITE_BIND_INT(query, index, data) \
+ if((eCode = sqlite3_bind_int(query, index, data))) \
+ { \
+ logError("CAmDatabaseHandler::sqlite3_bind_int failed with errorCode:", eCode); \
+ return (E_DATABASE_ERROR); \
+ }
+
+/**
+ * Macro to handle SQLITE errors on reset
+ */
+#define MY_SQLITE_RESET(query) \
+ if((eCode = sqlite3_reset(query))) \
+ { \
+ logError("CAmDatabaseHandler::sqlite3_reset failed with errorCode:", eCode); \
+ return (E_DATABASE_ERROR); \
+ }
+
+/**
+ * Macro to handle SQLITE finalize
+ */
+#define MY_SQLITE_FINALIZE(query) \
+ if((eCode = sqlite3_finalize(query))) \
+ { \
+ logError("CAmDatabaseHandler::sqlite3_finalize failed with errorCode:", eCode); \
+ return (E_DATABASE_ERROR); \
+ }
+
+#define MY_SQLITE_FINALIZE_BOOL(query) \
+ if((eCode = sqlite3_finalize(query))) \
+ { \
+ logError("CAmDatabaseHandler::sqlite3_finalize failed with errorCode:", eCode); \
+ return (true); \
+ }
+
#define DOMAIN_TABLE "Domains" //!< domain table
#define SOURCE_CLASS_TABLE "SourceClasses" //!< source class table
#define SINK_CLASS_TABLE "SinkClasses" //!< sink class table
#define CONNECTION_TABLE "Connections" //!< connection table
#define MAINCONNECTION_TABLE "MainConnections" //!< main connection table
#define SYSTEM_TABLE "SystemProperties" //!< system properties table
-
/**
* table that holds table informations
*/
assert(domainData.state>=DS_UNKNOWN && domainData.state<=DS_MAX);
//first check for a reserved domain
- sqlite3_stmt* query = NULL, *queryFinal;
+ sqlite3_stmt* query = NULL;
int eCode = 0;
std::string command = "SELECT domainID FROM " + std::string(DOMAIN_TABLE) + " WHERE name=?";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, domainData.name.c_str(), domainData.name.size(), SQLITE_STATIC);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, domainData.name.c_str(), domainData.name.size(), SQLITE_STATIC)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
command = "UPDATE " + std::string(DOMAIN_TABLE) + " SET name=?, busname=?, nodename=?, early=?, complete=?, state=?, reserved=? WHERE domainID=" + i2s(sqlite3_column_int(query, 0));
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterDomainDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &queryFinal, NULL);
- sqlite3_bind_text(queryFinal, 1, domainData.name.c_str(), domainData.name.size(), SQLITE_STATIC);
- sqlite3_bind_text(queryFinal, 2, domainData.busname.c_str(), domainData.busname.size(), SQLITE_STATIC);
- sqlite3_bind_text(queryFinal, 3, domainData.nodename.c_str(), domainData.nodename.size(), SQLITE_STATIC);
- sqlite3_bind_int(queryFinal, 4, domainData.early);
- sqlite3_bind_int(queryFinal, 5, domainData.complete);
- sqlite3_bind_int(queryFinal, 6, domainData.state);
- sqlite3_bind_int(queryFinal, 7, 0);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, domainData.name.c_str(), domainData.name.size(), SQLITE_STATIC)
+ MY_SQLITE_BIND_TEXT(query, 2, domainData.busname.c_str(), domainData.busname.size(), SQLITE_STATIC)
+ MY_SQLITE_BIND_TEXT(query, 3, domainData.nodename.c_str(), domainData.nodename.size(), SQLITE_STATIC)
+ MY_SQLITE_BIND_INT(query, 4, domainData.early)
+ MY_SQLITE_BIND_INT(query, 5, domainData.complete)
+ MY_SQLITE_BIND_INT(query, 6, domainData.state)
+ MY_SQLITE_BIND_INT(query, 7, 0)
- if ((eCode = sqlite3_step(queryFinal)) != SQLITE_DONE)
+ if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterDomainDB SQLITE Step error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
-
- if ((eCode = sqlite3_finalize(queryFinal)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterDomainDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
domainID = sqlite3_last_insert_rowid(mpDatabase);
logInfo("DatabaseHandler::enterDomainDB entered new domain with name=", domainData.name, "busname=", domainData.busname, "nodename=", domainData.nodename, "assigned ID:", domainID);
int eCode = 0;
int16_t delay = 0;
std::string command = "INSERT INTO " + std::string(MAINCONNECTION_TABLE) + "(sourceID, sinkID, connectionState, delay) VALUES (?,?,?,-1)";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, mainConnectionData.sourceID);
- sqlite3_bind_int(query, 2, mainConnectionData.sinkID);
- sqlite3_bind_int(query, 3, mainConnectionData.connectionState);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, mainConnectionData.sourceID)
+ MY_SQLITE_BIND_INT(query, 2, mainConnectionData.sinkID)
+ MY_SQLITE_BIND_INT(query, 3, mainConnectionData.connectionState)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterMainConnectionDB SQLITE Step error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterMainConnectionDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
connectionID = sqlite3_last_insert_rowid(mpDatabase);
//now check the connectionTable for all connections in the route. IF connectionID exist
command = "SELECT delay FROM " + std::string(CONNECTION_TABLE) + (" WHERE connectionID=?");
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
std::vector<am_connectionID_t>::const_iterator elementIterator = mainConnectionData.listConnectionID.begin();
for (; elementIterator < mainConnectionData.listConnectionID.end(); ++elementIterator)
{
- sqlite3_bind_int(query, 1, *elementIterator);
+ MY_SQLITE_BIND_INT(query, 1, *elementIterator)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
else
{
logError("DatabaseHandler::enterMainConnectionDB did not find route for MainConnection:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
- }
-
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterMainConnectionDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
+ MY_SQLITE_RESET(query)
}
+ MY_SQLITE_FINALIZE(query)
//now we create a table with references to the connections;
command = "CREATE TABLE MainConnectionRoute" + i2s(connectionID) + std::string("(connectionID INTEGER)");
- assert(this->sqQuery(command));
+ if (!this->sqQuery(command))
+ return (E_DATABASE_ERROR);
command = "INSERT INTO MainConnectionRoute" + i2s(connectionID) + "(connectionID) VALUES (?)";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
std::vector<am_connectionID_t>::const_iterator listConnectionIterator(mainConnectionData.listConnectionID.begin());
for (; listConnectionIterator < mainConnectionData.listConnectionID.end(); ++listConnectionIterator)
{
- sqlite3_bind_int(query, 1, *listConnectionIterator);
+ MY_SQLITE_BIND_INT(query, 1, *listConnectionIterator)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterMainConnectionDB SQLITE Step error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
- }
-
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterMainConnectionDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
+ MY_SQLITE_RESET(query)
}
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::enterMainConnectionDB entered new mainConnection with sourceID", mainConnectionData.sourceID, "sinkID:", mainConnectionData.sinkID, "delay:", delay, "assigned ID:", connectionID);
if (mpDatabaseObserver)
assert(!sinkData.listConnectionFormats.empty());
assert(sinkData.muteState>=MS_UNKNOWN && sinkData.muteState<=MS_MAX);
- sqlite3_stmt *query = NULL, *queryFinal = NULL;
+ sqlite3_stmt *query = NULL;
int eCode = 0;
std::string command = "SELECT sinkID FROM " + std::string(SINK_TABLE) + " WHERE name=? AND reserved=1";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, sinkData.name.c_str(), sinkData.name.size(), SQLITE_STATIC);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, sinkData.name.c_str(), sinkData.name.size(), SQLITE_STATIC)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
//check if the ID already exists
if (existSinkNameOrID(sinkData.sinkID, sinkData.name))
{
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_ALREADY_EXISTS);
}
command = "INSERT INTO " + std::string(SINK_TABLE) + "(name, domainID, sinkClassID, volume, visible, availability, availabilityReason, muteState, mainVolume, reserved, sinkID) VALUES (?,?,?,?,?,?,?,?,?,?,?)";
else
{
logError("DatabaseHandler::enterSinkDB SQLITE Step error code:", eCode);
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterSinkDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &queryFinal, NULL);
- sqlite3_bind_text(queryFinal, 1, sinkData.name.c_str(), sinkData.name.size(), SQLITE_STATIC);
- sqlite3_bind_int(queryFinal, 2, sinkData.domainID);
- sqlite3_bind_int(queryFinal, 3, sinkData.sinkClassID);
- sqlite3_bind_int(queryFinal, 4, sinkData.volume);
- sqlite3_bind_int(queryFinal, 5, sinkData.visible);
- sqlite3_bind_int(queryFinal, 6, sinkData.available.availability);
- sqlite3_bind_int(queryFinal, 7, sinkData.available.availabilityReason);
- sqlite3_bind_int(queryFinal, 8, sinkData.muteState);
- sqlite3_bind_int(queryFinal, 9, sinkData.mainVolume);
- sqlite3_bind_int(queryFinal, 10, 0);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, sinkData.name.c_str(), sinkData.name.size(), SQLITE_STATIC)
+ MY_SQLITE_BIND_INT(query, 2, sinkData.domainID)
+ MY_SQLITE_BIND_INT(query, 3, sinkData.sinkClassID)
+ MY_SQLITE_BIND_INT(query, 4, sinkData.volume)
+ MY_SQLITE_BIND_INT(query, 5, sinkData.visible)
+ MY_SQLITE_BIND_INT(query, 6, sinkData.available.availability)
+ MY_SQLITE_BIND_INT(query, 7, sinkData.available.availabilityReason)
+ MY_SQLITE_BIND_INT(query, 8, sinkData.muteState)
+ MY_SQLITE_BIND_INT(query, 9, sinkData.mainVolume)
+ MY_SQLITE_BIND_INT(query, 10, 0)
//if the ID is not created, we add it to the query
if (sinkData.sinkID != 0)
{
- sqlite3_bind_int(queryFinal, 11, sinkData.sinkID);
+ MY_SQLITE_BIND_INT(query, 11, sinkData.sinkID)
}
//if the first static sink is entered, we need to set it onto the boundary
else if (mFirstStaticSink)
{
- sqlite3_bind_int(queryFinal, 11, DYNAMIC_ID_BOUNDARY);
+ MY_SQLITE_BIND_INT(query, 11, DYNAMIC_ID_BOUNDARY)
mFirstStaticSink = false;
}
- if ((eCode = sqlite3_step(queryFinal)) != SQLITE_DONE)
+ if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterSinkDB SQLITE Step error code:", eCode);
- sqlite3_finalize(queryFinal);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(queryFinal)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterSinkDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
//now read back the sinkID
command = "SELECT sinkID FROM " + std::string(SINK_TABLE) + " WHERE name=?";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, sinkData.name.c_str(), sinkData.name.size(), SQLITE_STATIC);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, sinkData.name.c_str(), sinkData.name.size(), SQLITE_STATIC)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
sinkID = sqlite3_column_int(query, 0);
{
sinkID = 0;
logError("DatabaseHandler::existSink database error!:", eCode);
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
//now we need to create the additional tables:
command = "CREATE TABLE SinkConnectionFormat" + i2s(sinkID) + std::string("(soundFormat INTEGER)");
- assert(this->sqQuery(command));
+ if (!this->sqQuery(command))
+ return (E_DATABASE_ERROR);
command = "CREATE TABLE SinkSoundProperty" + i2s(sinkID) + std::string("(soundPropertyType INTEGER, value INTEGER)");
- assert(this->sqQuery(command));
+ if (!this->sqQuery(command))
+ return (E_DATABASE_ERROR);
//fill ConnectionFormats
command = "INSERT INTO SinkConnectionFormat" + i2s(sinkID) + std::string("(soundFormat) VALUES (?)");
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
std::vector<am_ConnectionFormat_e>::const_iterator connectionFormatIterator = sinkData.listConnectionFormats.begin();
for (; connectionFormatIterator < sinkData.listConnectionFormats.end(); ++connectionFormatIterator)
{
- sqlite3_bind_int(query, 1, *connectionFormatIterator);
+ MY_SQLITE_BIND_INT(query, 1, *connectionFormatIterator)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterSinkDB SQLITE Step error code:", eCode);
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
+ MY_SQLITE_RESET(query)
}
//Fill SinkSoundProperties
command = "INSERT INTO SinkSoundProperty" + i2s(sinkID) + std::string("(soundPropertyType,value) VALUES (?,?)");
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
std::vector<am_SoundProperty_s>::const_iterator SoundPropertyIterator = sinkData.listSoundProperties.begin();
for (; SoundPropertyIterator < sinkData.listSoundProperties.end(); ++SoundPropertyIterator)
{
- sqlite3_bind_int(query, 1, SoundPropertyIterator->type);
- sqlite3_bind_int(query, 2, SoundPropertyIterator->value);
+ MY_SQLITE_BIND_INT(query, 1, SoundPropertyIterator->type)
+ MY_SQLITE_BIND_INT(query, 2, SoundPropertyIterator->value)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterSinkDB SQLITE Step error code:", eCode);
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
+ MY_SQLITE_RESET(query)
}
if (sinkData.visible == true)
{
command = "CREATE TABLE SinkMainSoundProperty" + i2s(sinkID) + std::string("(soundPropertyType INTEGER, value INTEGER)");
- assert(this->sqQuery(command));
+ if (!this->sqQuery(command))
+ return (E_DATABASE_ERROR);
//Fill MainSinkSoundProperties
command = "INSERT INTO SinkMainSoundProperty" + i2s(sinkID) + std::string("(soundPropertyType,value) VALUES (?,?)");
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
std::vector<am_MainSoundProperty_s>::const_iterator mainSoundPropertyIterator = sinkData.listMainSoundProperties.begin();
for (; mainSoundPropertyIterator < sinkData.listMainSoundProperties.end(); ++mainSoundPropertyIterator)
{
- sqlite3_bind_int(query, 1, mainSoundPropertyIterator->type);
- sqlite3_bind_int(query, 2, mainSoundPropertyIterator->value);
+ MY_SQLITE_BIND_INT(query, 1, mainSoundPropertyIterator->type)
+ MY_SQLITE_BIND_INT(query, 2, mainSoundPropertyIterator->value)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterSinkDB SQLITE Step error code:", eCode);
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
+ MY_SQLITE_RESET(query)
}
+ MY_SQLITE_FINALIZE(query)
}
logInfo("DatabaseHandler::enterSinkDB entered new sink with name", sinkData.name, "domainID:", sinkData.domainID, "classID:", sinkData.sinkClassID, "volume:", sinkData.volume, "assigned ID:", sinkID);
command = "INSERT INTO " + std::string(CROSSFADER_TABLE) + "(name, sinkID_A, sinkID_B, sourceID, hotSink, crossfaderID) VALUES (?,?,?,?,?,?)";
}
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
- sqlite3_bind_text(query, 1, crossfaderData.name.c_str(), crossfaderData.name.size(), SQLITE_STATIC);
- sqlite3_bind_int(query, 2, crossfaderData.sinkID_A);
- sqlite3_bind_int(query, 3, crossfaderData.sinkID_B);
- sqlite3_bind_int(query, 4, crossfaderData.sourceID);
- sqlite3_bind_int(query, 5, crossfaderData.hotSink);
+ MY_SQLITE_BIND_TEXT(query, 1, crossfaderData.name.c_str(), crossfaderData.name.size(), SQLITE_STATIC)
+ MY_SQLITE_BIND_INT(query, 2, crossfaderData.sinkID_A)
+ MY_SQLITE_BIND_INT(query, 3, crossfaderData.sinkID_B)
+ MY_SQLITE_BIND_INT(query, 4, crossfaderData.sourceID)
+ MY_SQLITE_BIND_INT(query, 5, crossfaderData.hotSink)
//if the ID is not created, we add it to the query
if (crossfaderData.crossfaderID != 0)
{
- sqlite3_bind_int(query, 6, crossfaderData.crossfaderID);
+ MY_SQLITE_BIND_INT(query, 6, crossfaderData.crossfaderID)
}
//if the first static sink is entered, we need to set it onto the boundary
else if (mFirstStaticCrossfader)
{
- sqlite3_bind_int(query, 6, DYNAMIC_ID_BOUNDARY);
+ MY_SQLITE_BIND_INT(query, 6, DYNAMIC_ID_BOUNDARY)
mFirstStaticCrossfader = false;
}
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterCrossfaderDB SQLITE Step error code:", eCode);
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterCrossfaderDB SQLITE Finalize error code:", eCode);
- sqlite3_finalize(query);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
//now read back the crossfaderID
command = "SELECT crossfaderID FROM " + std::string(CROSSFADER_TABLE) + " WHERE name=?";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, crossfaderData.name.c_str(), crossfaderData.name.size(), SQLITE_STATIC);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, crossfaderData.name.c_str(), crossfaderData.name.size(), SQLITE_STATIC)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
crossfaderID = sqlite3_column_int(query, 0);
{
crossfaderID = 0;
logError("DatabaseHandler::enterCrossfaderDB database error!:", eCode);
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::enterCrossfaderDB entered new crossfader with name=", crossfaderData.name, "sinkA= ", crossfaderData.sinkID_A, "sinkB=", crossfaderData.sinkID_B, "source=", crossfaderData.sourceID, "assigned ID:", crossfaderID);
command = "INSERT INTO " + std::string(GATEWAY_TABLE) + "(name, sinkID, sourceID, domainSinkID, domainSourceID, controlDomainID, gatewayID) VALUES (?,?,?,?,?,?,?)";
}
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, gatewayData.name.c_str(), gatewayData.name.size(), SQLITE_STATIC);
- sqlite3_bind_int(query, 2, gatewayData.sinkID);
- sqlite3_bind_int(query, 3, gatewayData.sourceID);
- sqlite3_bind_int(query, 4, gatewayData.domainSinkID);
- sqlite3_bind_int(query, 5, gatewayData.domainSourceID);
- sqlite3_bind_int(query, 6, gatewayData.controlDomainID);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, gatewayData.name.c_str(), gatewayData.name.size(), SQLITE_STATIC)
+ MY_SQLITE_BIND_INT(query, 2, gatewayData.sinkID)
+ MY_SQLITE_BIND_INT(query, 3, gatewayData.sourceID)
+ MY_SQLITE_BIND_INT(query, 4, gatewayData.domainSinkID)
+ MY_SQLITE_BIND_INT(query, 5, gatewayData.domainSourceID)
+ MY_SQLITE_BIND_INT(query, 6, gatewayData.controlDomainID)
//if the ID is not created, we add it to the query
if (gatewayData.gatewayID != 0)
{
- sqlite3_bind_int(query, 7, gatewayData.gatewayID);
+ MY_SQLITE_BIND_INT(query, 7, gatewayData.gatewayID)
}
//if the first static sink is entered, we need to set it onto the boundary
else if (mFirstStaticGateway)
{
- sqlite3_bind_int(query, 7, DYNAMIC_ID_BOUNDARY);
+ MY_SQLITE_BIND_INT(query, 7, DYNAMIC_ID_BOUNDARY)
mFirstStaticGateway = false;
}
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterGatewayDB SQLITE Step error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterGatewayDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
gatewayID = sqlite3_last_insert_rowid(mpDatabase);
mListConnectionFormat.insert(std::make_pair(gatewayID, gatewayData.convertionMatrix));
command = "CREATE TABLE GatewaySourceFormat" + i2s(gatewayID) + std::string("(soundFormat INTEGER)");
- assert(this->sqQuery(command));
+ if (!this->sqQuery(command))
+ return (E_DATABASE_ERROR);
command = "CREATE TABLE GatewaySinkFormat" + i2s(gatewayID) + std::string("(soundFormat INTEGER)");
- assert(this->sqQuery(command));
+ if (!this->sqQuery(command))
+ return (E_DATABASE_ERROR);
//fill ConnectionFormats
command = "INSERT INTO GatewaySourceFormat" + i2s(gatewayID) + std::string("(soundFormat) VALUES (?)");
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
std::vector<am_ConnectionFormat_e>::const_iterator connectionFormatIterator = gatewayData.listSourceFormats.begin();
for (; connectionFormatIterator < gatewayData.listSourceFormats.end(); ++connectionFormatIterator)
{
- sqlite3_bind_int(query, 1, *connectionFormatIterator);
+ MY_SQLITE_BIND_INT(query, 1, *connectionFormatIterator)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterGatewayDB SQLITE Step error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
+ MY_SQLITE_RESET(query)
}
+ MY_SQLITE_FINALIZE(query)
command = "INSERT INTO GatewaySinkFormat" + i2s(gatewayID) + std::string("(soundFormat) VALUES (?)");
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
connectionFormatIterator = gatewayData.listSinkFormats.begin();
for (; connectionFormatIterator < gatewayData.listSinkFormats.end(); ++connectionFormatIterator)
{
- sqlite3_bind_int(query, 1, *connectionFormatIterator);
+ MY_SQLITE_BIND_INT(query, 1, *connectionFormatIterator)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterGatewayDB SQLITE Step error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
+ MY_SQLITE_RESET(query)
}
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::enterGatewayDB entered new gateway with name", gatewayData.name, "sourceID:", gatewayData.sourceID, "sinkID:", gatewayData.sinkID, "assigned ID:", gatewayID);
am_Gateway_s gateway = gatewayData;
assert(!sourceData.listConnectionFormats.empty());
assert(sourceData.sourceState>=SS_UNKNNOWN && sourceData.sourceState<=SS_MAX);
- sqlite3_stmt* query = NULL, *queryFinal = NULL;
+ sqlite3_stmt* query = NULL;
;
int eCode = 0;
std::string command = "SELECT sourceID FROM " + std::string(SOURCE_TABLE) + " WHERE name=? AND reserved=1";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, sourceData.name.c_str(), sourceData.name.size(), SQLITE_STATIC);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, sourceData.name.c_str(), sourceData.name.size(), SQLITE_STATIC)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
//check if the ID already exists
if (existSourceNameOrID(sourceData.sourceID, sourceData.name))
{
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_ALREADY_EXISTS);
}
command = "INSERT INTO " + std::string(SOURCE_TABLE) + "(name, domainID, sourceClassID, sourceState, volume, visible, availability, availabilityReason, interruptState, reserved, sourceID) VALUES (?,?,?,?,?,?,?,?,?,?,?)";
else
{
logError("DatabaseHandler::enterSourceDB SQLITE Step error code:", eCode);
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterSourceDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &queryFinal, NULL);
- sqlite3_bind_text(queryFinal, 1, sourceData.name.c_str(), sourceData.name.size(), SQLITE_STATIC);
- sqlite3_bind_int(queryFinal, 2, sourceData.domainID);
- sqlite3_bind_int(queryFinal, 3, sourceData.sourceClassID);
- sqlite3_bind_int(queryFinal, 4, sourceData.sourceState);
- sqlite3_bind_int(queryFinal, 5, sourceData.volume);
- sqlite3_bind_int(queryFinal, 6, sourceData.visible);
- sqlite3_bind_int(queryFinal, 7, sourceData.available.availability);
- sqlite3_bind_int(queryFinal, 8, sourceData.available.availabilityReason);
- sqlite3_bind_int(queryFinal, 9, sourceData.interruptState);
- sqlite3_bind_int(queryFinal, 10, 0);
+ MY_SQLITE_FINALIZE(query)
+
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, sourceData.name.c_str(), sourceData.name.size(), SQLITE_STATIC)
+ MY_SQLITE_BIND_INT(query, 2, sourceData.domainID)
+ MY_SQLITE_BIND_INT(query, 3, sourceData.sourceClassID)
+ MY_SQLITE_BIND_INT(query, 4, sourceData.sourceState)
+ MY_SQLITE_BIND_INT(query, 5, sourceData.volume)
+ MY_SQLITE_BIND_INT(query, 6, sourceData.visible)
+ MY_SQLITE_BIND_INT(query, 7, sourceData.available.availability)
+ MY_SQLITE_BIND_INT(query, 8, sourceData.available.availabilityReason)
+ MY_SQLITE_BIND_INT(query, 9, sourceData.interruptState)
+ MY_SQLITE_BIND_INT(query, 10, 0)
//if the ID is not created, we add it to the query
if (sourceData.sourceID != 0)
{
- sqlite3_bind_int(queryFinal, 11, sourceData.sourceID);
+ MY_SQLITE_BIND_INT(query, 11, sourceData.sourceID)
}
//if the first static sink is entered, we need to set it onto the boundary
else if (mFirstStaticSource)
{
- sqlite3_bind_int(queryFinal, 11, DYNAMIC_ID_BOUNDARY);
+ MY_SQLITE_BIND_INT(query, 11, DYNAMIC_ID_BOUNDARY)
mFirstStaticSource = false;
}
- if ((eCode = sqlite3_step(queryFinal)) != SQLITE_DONE)
+ if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterSourceDB SQLITE Step error code:", eCode);
- sqlite3_finalize(queryFinal);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(queryFinal)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterSourceDB SQLITE Finalize error code:", eCode);
- sqlite3_finalize(queryFinal);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
//now read back the sinkID
command = "SELECT sourceID FROM " + std::string(SOURCE_TABLE) + " WHERE name=?";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, sourceData.name.c_str(), sourceData.name.size(), SQLITE_STATIC);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, sourceData.name.c_str(), sourceData.name.size(), SQLITE_STATIC)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
sourceID = sqlite3_column_int(query, 0);
{
sourceID = 0;
logError("DatabaseHandler::existSink database error!:", eCode);
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
//now we need to create the additional tables:
command = "CREATE TABLE SourceConnectionFormat" + i2s(sourceID) + std::string("(soundFormat INTEGER)");
- assert(this->sqQuery(command));
+ if (!this->sqQuery(command))
+ return (E_DATABASE_ERROR);
command = "CREATE TABLE SourceSoundProperty" + i2s(sourceID) + std::string("(soundPropertyType INTEGER, value INTEGER)");
- assert(this->sqQuery(command));
+ if (!this->sqQuery(command))
+ return (E_DATABASE_ERROR);
//fill ConnectionFormats
command = "INSERT INTO SourceConnectionFormat" + i2s(sourceID) + std::string("(soundFormat) VALUES (?)");
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
std::vector<am_ConnectionFormat_e>::const_iterator connectionFormatIterator = sourceData.listConnectionFormats.begin();
for (; connectionFormatIterator < sourceData.listConnectionFormats.end(); ++connectionFormatIterator)
{
- sqlite3_bind_int(query, 1, *connectionFormatIterator);
+ MY_SQLITE_BIND_INT(query, 1, *connectionFormatIterator)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterSourceDB SQLITE Step error code:", eCode);
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
+ MY_SQLITE_RESET(query)
}
+ MY_SQLITE_FINALIZE(query)
//Fill SinkSoundProperties
command = "INSERT INTO SourceSoundProperty" + i2s(sourceID) + std::string("(soundPropertyType,value) VALUES (?,?)");
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
std::vector<am_SoundProperty_s>::const_iterator SoundPropertyIterator = sourceData.listSoundProperties.begin();
for (; SoundPropertyIterator < sourceData.listSoundProperties.end(); ++SoundPropertyIterator)
{
- sqlite3_bind_int(query, 1, SoundPropertyIterator->type);
- sqlite3_bind_int(query, 2, SoundPropertyIterator->value);
+ MY_SQLITE_BIND_INT(query, 1, SoundPropertyIterator->type)
+ MY_SQLITE_BIND_INT(query, 2, SoundPropertyIterator->value)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterSinkDB SQLITE Step error code:", eCode);
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
+ MY_SQLITE_RESET(query)
}
+ MY_SQLITE_FINALIZE(query)
+
if (sourceData.visible == true)
{
command = "CREATE TABLE SourceMainSoundProperty" + i2s(sourceID) + std::string("(soundPropertyType INTEGER, value INTEGER)");
- assert(this->sqQuery(command));
+ if (!this->sqQuery(command))
+ return (E_DATABASE_ERROR);
//Fill MainSinkSoundProperties
command = "INSERT INTO SourceMainSoundProperty" + i2s(sourceID) + std::string("(soundPropertyType,value) VALUES (?,?)");
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
std::vector<am_MainSoundProperty_s>::const_iterator mainSoundPropertyIterator = sourceData.listMainSoundProperties.begin();
for (; mainSoundPropertyIterator < sourceData.listMainSoundProperties.end(); ++mainSoundPropertyIterator)
{
- sqlite3_bind_int(query, 1, mainSoundPropertyIterator->type);
- sqlite3_bind_int(query, 2, mainSoundPropertyIterator->value);
+ MY_SQLITE_BIND_INT(query, 1, mainSoundPropertyIterator->type)
+ MY_SQLITE_BIND_INT(query, 2, mainSoundPropertyIterator->value)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterSourceDB SQLITE Step error code:", eCode);
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
+ MY_SQLITE_RESET(query)
}
+ MY_SQLITE_FINALIZE(query)
}
logInfo("DatabaseHandler::enterSourceDB entered new source with name", sourceData.name, "domainID:", sourceData.domainID, "classID:", sourceData.sourceClassID, "visible:", sourceData.visible, "assigned ID:", sourceID);
int16_t delay = 0;
command = "SELECT delay FROM " + std::string(CONNECTION_TABLE) + (" WHERE connectionID=?");
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
std::vector<am_connectionID_t>::const_iterator elementIterator = listConnectionID.begin();
for (; elementIterator < listConnectionID.end(); ++elementIterator)
{
- sqlite3_bind_int(query, 1, *elementIterator);
+ MY_SQLITE_BIND_INT(query, 1, *elementIterator)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
else
{
logError("DatabaseHandler::changeMainConnectionRouteDB did not find route for MainConnection:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
+ MY_SQLITE_RESET(query)
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeMainConnectionRouteDB SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
//now we delete the data in the table
command = "DELETE from MainConnectionRoute" + i2s(mainconnectionID);
- assert(this->sqQuery(command));
+ if (!this->sqQuery(command))
+ return (E_DATABASE_ERROR);
command = "INSERT INTO MainConnectionRoute" + i2s(mainconnectionID) + "(connectionID) VALUES (?)";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
std::vector<am_connectionID_t>::const_iterator listConnectionIterator(listConnectionID.begin());
for (; listConnectionIterator != listConnectionID.end(); ++listConnectionIterator)
{
- sqlite3_bind_int(query, 1, *listConnectionIterator);
+ MY_SQLITE_BIND_INT(query, 1, *listConnectionIterator)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeMainConnectionRouteDB SQLITE Step error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
+ MY_SQLITE_RESET(query)
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeMainConnectionRouteDB SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::changeMainConnectionRouteDB entered new route:", mainconnectionID);
return (E_OK);
}
return (E_NON_EXISTENT);
}
command = "UPDATE " + std::string(MAINCONNECTION_TABLE) + " SET connectionState=? WHERE mainConnectionID=" + i2s(mainconnectionID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, connectionState);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, connectionState)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeMainConnectionStateDB SQLITE Step error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeMainConnectionStateDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::changeMainConnectionStateDB changed mainConnectionState of MainConnection:", mainconnectionID, "to:", connectionState);
if (mpDatabaseObserver)
return (E_NON_EXISTENT);
}
command = "UPDATE " + std::string(SINK_TABLE) + " SET mainVolume=? WHERE sinkID=" + i2s(sinkID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, mainVolume);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, mainVolume)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeSinkMainVolumeDB SQLITE Step error code:", eCode);
- return (E_DATABASE_ERROR);
- }
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeSinkMainVolumeDB SQLITE Finalize error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::changeSinkMainVolumeDB changed mainVolume of sink:", sinkID, "to:", mainVolume);
if (mpDatabaseObserver)
return (E_NON_EXISTENT);
}
command = "UPDATE " + std::string(SINK_TABLE) + " SET availability=?, availabilityReason=? WHERE sinkID=" + i2s(sinkID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, availability.availability);
- sqlite3_bind_int(query, 2, availability.availabilityReason);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, availability.availability)
+ MY_SQLITE_BIND_INT(query, 2, availability.availabilityReason)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeSinkAvailabilityDB SQLITE Step error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
assert(sinkID!=0);
-
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeSinkAvailabilityDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
-
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::changeSinkAvailabilityDB changed sinkAvailability of sink:", sinkID, "to:", availability.availability, "Reason:", availability.availabilityReason);
if (mpDatabaseObserver && sourceVisible(sinkID))
return (E_NON_EXISTENT);
}
command = "UPDATE " + std::string(DOMAIN_TABLE) + " SET state=? WHERE domainID=" + i2s(domainID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, domainState);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, domainState)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changDomainStateDB SQLITE Step error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changDomainStateDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::changDomainStateDB changed domainState of domain:", domainID, "to:", domainState);
return (E_OK);
return (E_NON_EXISTENT);
}
command = "UPDATE " + std::string(SINK_TABLE) + " SET muteState=? WHERE sinkID=" + i2s(sinkID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, muteState);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, muteState)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeSinkMuteStateDB SQLITE Step error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
assert(sinkID!=0);
-
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeSinkMuteStateDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
-
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::changeSinkMuteStateDB changed sinkMuteState of sink:", sinkID, "to:", muteState);
if (mpDatabaseObserver)
return (E_NON_EXISTENT);
}
command = "UPDATE SinkMainSoundProperty" + i2s(sinkID) + " SET value=? WHERE soundPropertyType=" + i2s(soundProperty.type);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, soundProperty.value);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, soundProperty.value)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeMainSinkSoundPropertyDB SQLITE Step error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
assert(sinkID!=0);
-
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeMainSinkSoundPropertyDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
-
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::changeMainSinkSoundPropertyDB changed MainSinkSoundProperty of sink:", sinkID, "type:", soundProperty.type, "to:", soundProperty.value);
if (mpDatabaseObserver)
mpDatabaseObserver->mainSinkSoundPropertyChanged(sinkID, soundProperty);
return (E_NON_EXISTENT);
}
command = "UPDATE SourceMainSoundProperty" + i2s(sourceID) + " SET value=? WHERE soundPropertyType=" + i2s(soundProperty.type);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, soundProperty.value);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, soundProperty.value)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeMainSourceSoundPropertyDB SQLITE Step error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
-
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeMainSourceSoundPropertyDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::changeMainSourceSoundPropertyDB changed MainSinkSoundProperty of source:", sourceID, "type:", soundProperty.type, "to:", soundProperty.value);
return (E_NON_EXISTENT);
}
command = "UPDATE " + std::string(SOURCE_TABLE) + " SET availability=?, availabilityReason=? WHERE sourceID=" + i2s(sourceID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, availability.availability);
- sqlite3_bind_int(query, 2, availability.availabilityReason);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, availability.availability)
+ MY_SQLITE_BIND_INT(query, 2, availability.availabilityReason)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeSourceAvailabilityDB SQLITE Step error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeSourceAvailabilityDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::changeSourceAvailabilityDB changed changeSourceAvailabilityDB of source:", sourceID, "to:", availability.availability, "Reason:", availability.availabilityReason);
int eCode = 0;
std::string command = "UPDATE " + std::string(SYSTEM_TABLE) + " set value=? WHERE type=?";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, property.value);
- sqlite3_bind_int(query, 2, property.type);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, property.value)
+ MY_SQLITE_BIND_INT(query, 2, property.type)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeSystemPropertyDB SQLITE Step error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeSystemPropertyDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::changeSystemPropertyDB changed system property");
int eCode = 0;
am_ClassProperty_s propertyTemp;
std::string command = "SELECT sourceClassID FROM " + std::string(SOURCE_TABLE) + " WHERE sourceID=" + (i2s(sourceID));
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::getSourceClassInfoDB SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getSourceClassInfoDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
command = "SELECT name FROM " + std::string(SOURCE_CLASS_TABLE) + " WHERE sourceClassID=" + (i2s(classInfo.sourceClassID));
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::getSourceClassInfoDB SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getSourceClassInfoDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
//read out Properties
command = "SELECT classProperty, value FROM SourceClassProperties" + i2s(classInfo.sourceClassID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
propertyTemp.classProperty = (am_ClassProperty_e) sqlite3_column_int(query, 0);
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getSourceClassInfoDB SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getSourceClassInfoDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
am_SoundProperty_s tempSoundProperty;
am_MainSoundProperty_s tempMainSoundProperty;
std::string command = "SELECT name, domainID, sinkClassID, volume, visible, availability, availabilityReason, muteState, mainVolume, sinkID FROM " + std::string(SINK_TABLE) + " WHERE reserved=0 and sinkID=" + i2s(sinkID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
//read out the connectionFormats
std::string commandConnectionFormat = "SELECT soundFormat FROM SinkConnectionFormat" + i2s(sinkID);
- sqlite3_prepare_v2(mpDatabase, commandConnectionFormat.c_str(), -1, &qConnectionFormat, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandConnectionFormat.c_str(), -1, &qConnectionFormat, NULL)
while ((eCode = sqlite3_step(qConnectionFormat)) == SQLITE_ROW)
{
tempConnectionFormat = (am_ConnectionFormat_e) sqlite3_column_int(qConnectionFormat, 0);
sinkData.listConnectionFormats.push_back(tempConnectionFormat);
}
- if ((eCode = sqlite3_finalize(qConnectionFormat)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getSinkInfoDB SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(qConnectionFormat)
//read out sound properties
std::string commandSoundProperty = "SELECT soundPropertyType, value FROM SinkSoundProperty" + i2s(sinkID);
- sqlite3_prepare_v2(mpDatabase, commandSoundProperty.c_str(), -1, &qSoundProperty, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandSoundProperty.c_str(), -1, &qSoundProperty, NULL)
while ((eCode = sqlite3_step(qSoundProperty)) == SQLITE_ROW)
{
tempSoundProperty.type = (am_SoundPropertyType_e) sqlite3_column_int(qSoundProperty, 0);
sinkData.listSoundProperties.push_back(tempSoundProperty);
}
- if ((eCode = sqlite3_finalize(qSoundProperty)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getSinkInfoDB SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(qSoundProperty)
//read out MainSoundProperties
std::string commandMainSoundProperty = "SELECT soundPropertyType, value FROM SinkMainSoundProperty" + i2s(sinkID);
- sqlite3_prepare_v2(mpDatabase, commandMainSoundProperty.c_str(), -1, &qMAinSoundProperty, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandMainSoundProperty.c_str(), -1, &qMAinSoundProperty, NULL)
while ((eCode = sqlite3_step(qMAinSoundProperty)) == SQLITE_ROW)
{
tempMainSoundProperty.type = (am_MainSoundPropertyType_e) sqlite3_column_int(qMAinSoundProperty, 0);
sinkData.listMainSoundProperties.push_back(tempMainSoundProperty);
}
- if ((eCode = sqlite3_finalize(qMAinSoundProperty)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getSinkInfoDB SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(qMAinSoundProperty)
}
else if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getSinkInfoDB SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getSinkInfoDB SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
am_SoundProperty_s tempSoundProperty;
am_MainSoundProperty_s tempMainSoundProperty;
std::string command = "SELECT name, domainID, sourceClassID, sourceState, volume, visible, availability, availabilityReason, interruptState, sourceID FROM " + std::string(SOURCE_TABLE) + " WHERE reserved=0 AND sourceID=" + i2s(sourceID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
//read out the connectionFormats
std::string commandConnectionFormat = "SELECT soundFormat FROM SourceConnectionFormat" + i2s(sourceID);
- sqlite3_prepare_v2(mpDatabase, commandConnectionFormat.c_str(), -1, &qConnectionFormat, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandConnectionFormat.c_str(), -1, &qConnectionFormat, NULL)
while ((eCode = sqlite3_step(qConnectionFormat)) == SQLITE_ROW)
{
tempConnectionFormat = (am_ConnectionFormat_e) sqlite3_column_int(qConnectionFormat, 0);
sourceData.listConnectionFormats.push_back(tempConnectionFormat);
}
- if ((eCode = sqlite3_finalize(qConnectionFormat)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSources SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(qConnectionFormat)
//read out sound properties
std::string commandSoundProperty = "SELECT soundPropertyType, value FROM SourceSoundProperty" + i2s(sourceID);
- sqlite3_prepare_v2(mpDatabase, commandSoundProperty.c_str(), -1, &qSoundProperty, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandSoundProperty.c_str(), -1, &qSoundProperty, NULL);
while ((eCode = sqlite3_step(qSoundProperty)) == SQLITE_ROW)
{
tempSoundProperty.type = (am_SoundPropertyType_e) sqlite3_column_int(qSoundProperty, 0);
sourceData.listSoundProperties.push_back(tempSoundProperty);
}
- if ((eCode = sqlite3_finalize(qSoundProperty)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getSourceInfoDB SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(qSoundProperty)
//read out MainSoundProperties
std::string commandMainSoundProperty = "SELECT soundPropertyType, value FROM SourceMainSoundProperty" + i2s(sourceID);
- sqlite3_prepare_v2(mpDatabase, commandMainSoundProperty.c_str(), -1, &qMAinSoundProperty, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandMainSoundProperty.c_str(), -1, &qMAinSoundProperty, NULL)
while ((eCode = sqlite3_step(qMAinSoundProperty)) == SQLITE_ROW)
{
tempMainSoundProperty.type = (am_MainSoundPropertyType_e) sqlite3_column_int(qMAinSoundProperty, 0);
sourceData.listMainSoundProperties.push_back(tempMainSoundProperty);
}
- if ((eCode = sqlite3_finalize(qMAinSoundProperty)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getSourceInfoDB SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(qMAinSoundProperty)
}
else if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getSourceInfoDB SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getSourceInfoDB SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
am_MainConnection_s temp;
std::string command = "SELECT mainConnectionID, sourceID, sinkID, connectionState, delay FROM " + std::string(MAINCONNECTION_TABLE) + " WHERE mainConnectionID=" + i2s(mainConnectionID);
std::string command1 = "SELECT connectionID FROM MainConnectionRoute";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
mainConnectionData.connectionState = (am_ConnectionState_e) sqlite3_column_int(query, 3);
mainConnectionData.delay = sqlite3_column_int(query, 4);
std::string statement = command1 + i2s(mainConnectionID);
- sqlite3_prepare_v2(mpDatabase, statement.c_str(), -1, &query1, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, statement.c_str(), -1, &query1, NULL)
while ((eCode = sqlite3_step(query1)) == SQLITE_ROW)
{
mainConnectionData.listConnectionID.push_back(sqlite3_column_int(query1, 0));
}
+ MY_SQLITE_FINALIZE(query1)
}
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getMainConnectionInfoDB SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getMainConnectionInfoDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
//fill ConnectionFormats
std::string command = "UPDATE SinkClassProperties" + i2s(sinkClass.sinkClassID) + " set value=? WHERE classProperty=?;";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
std::vector<am_ClassProperty_s>::const_iterator Iterator = sinkClass.listClassProperties.begin();
for (; Iterator < sinkClass.listClassProperties.end(); ++Iterator)
{
- sqlite3_bind_int(query, 1, Iterator->value);
- sqlite3_bind_int(query, 2, Iterator->classProperty);
+ MY_SQLITE_BIND_INT(query, 1, Iterator->value)
+ MY_SQLITE_BIND_INT(query, 2, Iterator->classProperty)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::setSinkClassInfoDB SQLITE Step error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
+ MY_SQLITE_RESET(query)
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::setSinkClassInfoDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::setSinkClassInfoDB set setSinkClassInfo");
return (E_OK);
//fill ConnectionFormats
std::string command = "UPDATE SourceClassProperties" + i2s(sourceClass.sourceClassID) + " set value=? WHERE classProperty=?;";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
std::vector<am_ClassProperty_s>::const_iterator Iterator = sourceClass.listClassProperties.begin();
for (; Iterator < sourceClass.listClassProperties.end(); ++Iterator)
{
- sqlite3_bind_int(query, 1, Iterator->value);
- sqlite3_bind_int(query, 2, Iterator->classProperty);
+ MY_SQLITE_BIND_INT(query, 1, Iterator->value)
+ MY_SQLITE_BIND_INT(query, 2, Iterator->classProperty)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::setSinkClassInfoDB SQLITE Step error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
+ MY_SQLITE_RESET(query)
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::setSinkClassInfoDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::setSinkClassInfoDB set setSinkClassInfo");
return (E_OK);
int eCode = 0;
am_ClassProperty_s propertyTemp;
std::string command = "SELECT sinkClassID FROM " + std::string(SINK_TABLE) + " WHERE sinkID=" + (i2s(sinkID));
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::getSinkClassInfoDB SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getSinkClassInfoDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
command = "SELECT name FROM " + std::string(SINK_CLASS_TABLE) + " WHERE sinkClassID=" + (i2s(sinkClass.sinkClassID));
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::getSinkClassInfoDB SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getSinkClassInfoDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
//read out Properties
command = "SELECT classProperty, value FROM SinkClassProperties" + i2s(sinkClass.sinkClassID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
propertyTemp.classProperty = (am_ClassProperty_e) sqlite3_column_int(query, 0);
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getSinkClassInfoDB SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getSinkClassInfoDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
int eCode = 0;
am_ConnectionFormat_e tempConnectionFormat;
std::string command = "SELECT name, sinkID, sourceID, domainSinkID, domainSourceID, controlDomainID, gatewayID FROM " + std::string(GATEWAY_TABLE) + " WHERE gatewayID=" + i2s(gatewayID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (iter == mListConnectionFormat.end())
{
logError("DatabaseHandler::getGatewayInfoDB database error with convertionFormat");
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
gatewayData.convertionMatrix = iter->second;
//read out the connectionFormats
std::string commandConnectionFormat = "SELECT soundFormat FROM GatewaySourceFormat" + i2s(gatewayData.gatewayID);
- sqlite3_prepare_v2(mpDatabase, commandConnectionFormat.c_str(), -1, &qSourceConnectionFormat, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandConnectionFormat.c_str(), -1, &qSourceConnectionFormat, NULL)
while ((eCode = sqlite3_step(qSourceConnectionFormat)) == SQLITE_ROW)
{
tempConnectionFormat = (am_ConnectionFormat_e) sqlite3_column_int(qSourceConnectionFormat, 0);
gatewayData.listSourceFormats.push_back(tempConnectionFormat);
}
- if ((eCode = sqlite3_finalize(qSourceConnectionFormat)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getGatewayInfoDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(qSourceConnectionFormat)
//read out sound properties
commandConnectionFormat = "SELECT soundFormat FROM GatewaySinkFormat" + i2s(gatewayData.gatewayID);
- sqlite3_prepare_v2(mpDatabase, commandConnectionFormat.c_str(), -1, &qSinkConnectionFormat, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandConnectionFormat.c_str(), -1, &qSinkConnectionFormat, NULL)
while ((eCode = sqlite3_step(qSinkConnectionFormat)) == SQLITE_ROW)
{
tempConnectionFormat = (am_ConnectionFormat_e) sqlite3_column_int(qSinkConnectionFormat, 0);
gatewayData.listSinkFormats.push_back(tempConnectionFormat);
}
- if ((eCode = sqlite3_finalize(qSinkConnectionFormat)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getGatewayInfoDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(qSinkConnectionFormat)
}
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getGatewayInfoDB SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getGatewayInfoDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
sqlite3_stmt* query = NULL;
int eCode = 0;
std::string command = "SELECT name, sinkID_A, sinkID_B, sourceID, hotSink,crossfaderID FROM " + std::string(CROSSFADER_TABLE) + " WHERE crossfaderID=" + i2s(crossfaderID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getCrossfaderInfoDB SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getCrossfaderInfoDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
int eCode = 0;
am_sinkID_t temp;
std::string command = "SELECT sinkID FROM " + std::string(SINK_TABLE) + " WHERE reserved=0 AND domainID=" + (i2s(domainID));
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListSinksOfDomain SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSinksOfDomain SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
-
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
am_sourceID_t temp;
std::string command = "SELECT sourceID FROM " + std::string(SOURCE_TABLE) + " WHERE reserved=0 AND domainID=" + i2s(domainID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListSourcesOfDomain SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSourcesOfDomain SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
am_crossfaderID_t temp;
std::string command = "SELECT c.crossfaderID FROM " + std::string(CROSSFADER_TABLE) + " c," + std::string(SOURCE_TABLE) + " s WHERE c.sourceID=s.sourceID AND s.domainID=" + i2s(domainID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListCrossfadersOfDomain SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListCrossfadersOfDomain SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
am_gatewayID_t temp;
std::string command = "SELECT gatewayID FROM " + std::string(GATEWAY_TABLE) + " WHERE controlDomainID=" + i2s(domainID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListGatewaysOfDomain SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListGatewaysOfDomain SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
am_MainConnection_s temp;
std::string command = "SELECT mainConnectionID, sourceID, sinkID, connectionState, delay FROM " + std::string(MAINCONNECTION_TABLE);
std::string command1 = "SELECT connectionID FROM MainConnectionRoute";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
temp.connectionState = (am_ConnectionState_e) sqlite3_column_int(query, 3);
temp.delay = sqlite3_column_int(query, 4);
std::string statement = command1 + i2s(temp.mainConnectionID);
- sqlite3_prepare_v2(mpDatabase, statement.c_str(), -1, &query1, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, statement.c_str(), -1, &query1, NULL)
while ((eCode = sqlite3_step(query1)) == SQLITE_ROW)
{
temp.listConnectionID.push_back(sqlite3_column_int(query1, 0));
}
listMainConnections.push_back(temp);
+ MY_SQLITE_FINALIZE(query1)
}
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListMainConnections SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListMainConnections SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
int eCode = 0;
am_Domain_s temp;
std::string command = "SELECT domainID, name, busname, nodename, early, complete, state FROM " + std::string(DOMAIN_TABLE) + " WHERE reserved=0";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListDomains SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListDomains SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
int eCode = 0;
am_Connection_s temp;
std::string command = "SELECT connectionID, sourceID, sinkID, delay, connectionFormat FROM " + std::string(CONNECTION_TABLE) + " WHERE reserved=0";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListConnections SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListConnections SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
am_SoundProperty_s tempSoundProperty;
am_MainSoundProperty_s tempMainSoundProperty;
std::string command = "SELECT name, domainID, sinkClassID, volume, visible, availability, availabilityReason, muteState, mainVolume, sinkID FROM " + std::string(SINK_TABLE) + " WHERE reserved=0";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
//read out the connectionFormats
std::string commandConnectionFormat = "SELECT soundFormat FROM SinkConnectionFormat" + i2s(temp.sinkID);
- sqlite3_prepare_v2(mpDatabase, commandConnectionFormat.c_str(), -1, &qConnectionFormat, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandConnectionFormat.c_str(), -1, &qConnectionFormat, NULL)
while ((eCode = sqlite3_step(qConnectionFormat)) == SQLITE_ROW)
{
tempConnectionFormat = (am_ConnectionFormat_e) sqlite3_column_int(qConnectionFormat, 0);
temp.listConnectionFormats.push_back(tempConnectionFormat);
}
- if ((eCode = sqlite3_finalize(qConnectionFormat)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSinks SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(qConnectionFormat)
//read out sound properties
std::string commandSoundProperty = "SELECT soundPropertyType, value FROM SinkSoundProperty" + i2s(temp.sinkID);
- sqlite3_prepare_v2(mpDatabase, commandSoundProperty.c_str(), -1, &qSoundProperty, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandSoundProperty.c_str(), -1, &qSoundProperty, NULL)
while ((eCode = sqlite3_step(qSoundProperty)) == SQLITE_ROW)
{
tempSoundProperty.type = (am_SoundPropertyType_e) sqlite3_column_int(qSoundProperty, 0);
temp.listSoundProperties.push_back(tempSoundProperty);
}
- if ((eCode = sqlite3_finalize(qSoundProperty)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSinks SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(qSoundProperty)
//read out MainSoundProperties
std::string commandMainSoundProperty = "SELECT soundPropertyType, value FROM SinkMainSoundProperty" + i2s(temp.sinkID);
- sqlite3_prepare_v2(mpDatabase, commandMainSoundProperty.c_str(), -1, &qMAinSoundProperty, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandMainSoundProperty.c_str(), -1, &qMAinSoundProperty, NULL)
while ((eCode = sqlite3_step(qMAinSoundProperty)) == SQLITE_ROW)
{
tempMainSoundProperty.type = (am_MainSoundPropertyType_e) sqlite3_column_int(qMAinSoundProperty, 0);
temp.listMainSoundProperties.push_back(tempMainSoundProperty);
}
- if ((eCode = sqlite3_finalize(qMAinSoundProperty)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSinks SQLITE Finalize error code:", eCode);
+ MY_SQLITE_FINALIZE(qMAinSoundProperty)
- return (E_DATABASE_ERROR);
- }
listSinks.push_back(temp);
temp.listConnectionFormats.clear();
temp.listMainSoundProperties.clear();
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListSinks SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSinks SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
am_SoundProperty_s tempSoundProperty;
am_MainSoundProperty_s tempMainSoundProperty;
std::string command = "SELECT name, domainID, sourceClassID, sourceState, volume, visible, availability, availabilityReason, interruptState, sourceID FROM " + std::string(SOURCE_TABLE) + " WHERE reserved=0";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
//read out the connectionFormats
std::string commandConnectionFormat = "SELECT soundFormat FROM SourceConnectionFormat" + i2s(temp.sourceID);
- sqlite3_prepare_v2(mpDatabase, commandConnectionFormat.c_str(), -1, &qConnectionFormat, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandConnectionFormat.c_str(), -1, &qConnectionFormat, NULL)
while ((eCode = sqlite3_step(qConnectionFormat)) == SQLITE_ROW)
{
tempConnectionFormat = (am_ConnectionFormat_e) sqlite3_column_int(qConnectionFormat, 0);
temp.listConnectionFormats.push_back(tempConnectionFormat);
}
- if ((eCode = sqlite3_finalize(qConnectionFormat)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSources SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(qConnectionFormat)
//read out sound properties
std::string commandSoundProperty = "SELECT soundPropertyType, value FROM SourceSoundProperty" + i2s(temp.sourceID);
- sqlite3_prepare_v2(mpDatabase, commandSoundProperty.c_str(), -1, &qSoundProperty, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandSoundProperty.c_str(), -1, &qSoundProperty, NULL)
while ((eCode = sqlite3_step(qSoundProperty)) == SQLITE_ROW)
{
tempSoundProperty.type = (am_SoundPropertyType_e) sqlite3_column_int(qSoundProperty, 0);
temp.listSoundProperties.push_back(tempSoundProperty);
}
- if ((eCode = sqlite3_finalize(qSoundProperty)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSources SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(qSoundProperty)
//read out MainSoundProperties
std::string commandMainSoundProperty = "SELECT soundPropertyType, value FROM SourceMainSoundProperty" + i2s(temp.sourceID);
- sqlite3_prepare_v2(mpDatabase, commandMainSoundProperty.c_str(), -1, &qMAinSoundProperty, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandMainSoundProperty.c_str(), -1, &qMAinSoundProperty, NULL)
while ((eCode = sqlite3_step(qMAinSoundProperty)) == SQLITE_ROW)
{
tempMainSoundProperty.type = (am_MainSoundPropertyType_e) sqlite3_column_int(qMAinSoundProperty, 0);
temp.listMainSoundProperties.push_back(tempMainSoundProperty);
}
- if ((eCode = sqlite3_finalize(qMAinSoundProperty)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSources SQLITE Finalize error code:", eCode);
+ MY_SQLITE_FINALIZE(qMAinSoundProperty)
- return (E_DATABASE_ERROR);
- }
listSources.push_back(temp);
temp.listConnectionFormats.clear();
temp.listMainSoundProperties.clear();
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListSources SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSources SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
std::string command = "SELECT sourceClassID, name FROM " + std::string(SOURCE_CLASS_TABLE);
std::string command2;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
//read out Properties
command2 = "SELECT classProperty, value FROM SourceClassProperties" + i2s(classTemp.sourceClassID);
- sqlite3_prepare_v2(mpDatabase, command2.c_str(), -1, &subQuery, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command2.c_str(), -1, &subQuery, NULL)
while ((eCode1 = sqlite3_step(subQuery)) == SQLITE_ROW)
{
if (eCode1 != SQLITE_DONE)
{
logError("DatabaseHandler::getListSourceClasses SQLITE error code:", eCode1);
-
+ MY_SQLITE_FINALIZE(query)
+ MY_SQLITE_FINALIZE(subQuery)
return (E_DATABASE_ERROR);
}
- if ((eCode1 = sqlite3_finalize(subQuery)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSourceClasses SQLITE Finalize error code:", eCode1);
+ MY_SQLITE_FINALIZE(subQuery)
- return (E_DATABASE_ERROR);
- }
listSourceClasses.push_back(classTemp);
}
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListSourceClasses SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(subQuery)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSourceClasses SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
int eCode = 0;
am_Crossfader_s tempData;
std::string command = "SELECT name, sinkID_A, sinkID_B, sourceID, hotSink,crossfaderID FROM " + std::string(CROSSFADER_TABLE);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListCrossfaders SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListCrossfaders SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
am_ConnectionFormat_e tempConnectionFormat;
std::string command = "SELECT name, sinkID, sourceID, domainSinkID, domainSourceID, controlDomainID, gatewayID FROM " + std::string(GATEWAY_TABLE);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
//read out the connectionFormats
std::string commandConnectionFormat = "SELECT soundFormat FROM GatewaySourceFormat" + i2s(temp.gatewayID);
- sqlite3_prepare_v2(mpDatabase, commandConnectionFormat.c_str(), -1, &qSourceConnectionFormat, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandConnectionFormat.c_str(), -1, &qSourceConnectionFormat, NULL)
while ((eCode = sqlite3_step(qSourceConnectionFormat)) == SQLITE_ROW)
{
tempConnectionFormat = (am_ConnectionFormat_e) sqlite3_column_int(qSourceConnectionFormat, 0);
temp.listSourceFormats.push_back(tempConnectionFormat);
}
- if ((eCode = sqlite3_finalize(qSourceConnectionFormat)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListGateways SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(qSourceConnectionFormat)
//read out sound properties
commandConnectionFormat = "SELECT soundFormat FROM GatewaySinkFormat" + i2s(temp.gatewayID);
- sqlite3_prepare_v2(mpDatabase, commandConnectionFormat.c_str(), -1, &qSinkConnectionFormat, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandConnectionFormat.c_str(), -1, &qSinkConnectionFormat, NULL)
while ((eCode = sqlite3_step(qSinkConnectionFormat)) == SQLITE_ROW)
{
tempConnectionFormat = (am_ConnectionFormat_e) sqlite3_column_int(qSinkConnectionFormat, 0);
temp.listSinkFormats.push_back(tempConnectionFormat);
}
- if ((eCode = sqlite3_finalize(qSinkConnectionFormat)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListGateways SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(qSinkConnectionFormat)
listGateways.push_back(temp);
temp.listSinkFormats.clear();
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListGateways SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListGateways SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
std::string command = "SELECT sinkClassID, name FROM " + std::string(SINK_CLASS_TABLE);
std::string command2;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
//read out Properties
command2 = "SELECT classProperty, value FROM SinkClassProperties" + i2s(classTemp.sinkClassID);
- sqlite3_prepare_v2(mpDatabase, command2.c_str(), -1, &subQuery, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command2.c_str(), -1, &subQuery, NULL)
while ((eCode = sqlite3_step(subQuery)) == SQLITE_ROW)
{
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(subQuery)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSourceClasses SQLITE Finalize error code:", eCode);
+ MY_SQLITE_FINALIZE(subQuery)
- return (E_DATABASE_ERROR);
- }
listSinkClasses.push_back(classTemp);
}
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListSourceClasses SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSourceClasses SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
am_MainConnectionType_s temp;
std::string command = "SELECT mainConnectionID, sourceID, sinkID, connectionState, delay FROM " + std::string(MAINCONNECTION_TABLE);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListVisibleMainConnections SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListVisibleMainConnections SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
am_SinkType_s temp;
std::string command = "SELECT name, sinkID, availability, availabilityReason, muteState, mainVolume, sinkClassID FROM " + std::string(SINK_TABLE) + " WHERE visible=1 AND reserved=0";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListSinks SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSinks SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
int eCode = 0;
am_SourceType_s temp;
std::string command = "SELECT name, sourceClassID, availability, availabilityReason, sourceID FROM " + std::string(SOURCE_TABLE) + " WHERE visible=1";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListSources SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSources SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
int eCode = 0;
am_MainSoundProperty_s temp;
std::string command = "SELECT soundPropertyType, value FROM SinkMainSoundProperty" + i2s(sinkID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListMainSinkSoundProperties SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListMainSinkSoundProperties SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
int eCode = 0;
am_MainSoundProperty_s temp;
std::string command = "SELECT soundPropertyType, value FROM SourceMainSoundProperty" + i2s(sourceID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListMainSinkSoundProperties SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListMainSinkSoundProperties SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
int eCode = 0;
am_SystemProperty_s temp;
std::string command = "SELECT type, value FROM " + std::string(SYSTEM_TABLE);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getListSystemProperties SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSystemProperties SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
int eCode = 0;
am_ConnectionFormat_e tempConnectionFormat;
std::string commandConnectionFormat = "SELECT soundFormat FROM SinkConnectionFormat" + i2s(sinkID);
- sqlite3_prepare_v2(mpDatabase, commandConnectionFormat.c_str(), -1, &qConnectionFormat, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandConnectionFormat.c_str(), -1, &qConnectionFormat, NULL)
while ((eCode = sqlite3_step(qConnectionFormat)) == SQLITE_ROW)
{
tempConnectionFormat = (am_ConnectionFormat_e) sqlite3_column_int(qConnectionFormat, 0);
listConnectionFormats.push_back(tempConnectionFormat);
}
- if ((eCode = sqlite3_finalize(qConnectionFormat)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSinkConnectionFormats SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(qConnectionFormat)
return (E_OK);
}
//read out the connectionFormats
std::string commandConnectionFormat = "SELECT soundFormat FROM SourceConnectionFormat" + i2s(sourceID);
- sqlite3_prepare_v2(mpDatabase, commandConnectionFormat.c_str(), -1, &qConnectionFormat, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, commandConnectionFormat.c_str(), -1, &qConnectionFormat, NULL)
while ((eCode = sqlite3_step(qConnectionFormat)) == SQLITE_ROW)
{
tempConnectionFormat = (am_ConnectionFormat_e) sqlite3_column_int(qConnectionFormat, 0);
listConnectionFormats.push_back(tempConnectionFormat);
}
- if ((eCode = sqlite3_finalize(qConnectionFormat)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getListSources SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(qConnectionFormat)
return (E_OK);
}
int eCode = 0;
std::string command = "SELECT delay FROM " + std::string(MAINCONNECTION_TABLE) + " WHERE mainConnectionID=" + i2s(mainConnectionID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getTimingInformation SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getTimingInformation SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
if (delay == -1)
return (E_NOT_POSSIBLE);
sqlite3_stmt* query = NULL;
int eCode = 0;
std::string command = "SELECT mainConnectionID FROM " + std::string(MAINCONNECTION_TABLE) + " WHERE delay=? AND mainConnectionID=?";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, delay);
- sqlite3_bind_int(query, 2, connectionID);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, delay)
+ MY_SQLITE_BIND_INT(query, 2, connectionID)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
command = "UPDATE " + std::string(MAINCONNECTION_TABLE) + " SET delay=? WHERE mainConnectionID=?;";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, delay);
- sqlite3_bind_int(query, 2, connectionID);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, delay)
+ MY_SQLITE_BIND_INT(query, 2, connectionID)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeDelayMainConnection SQLITE Step error code:", eCode);
- return (E_DATABASE_ERROR);
- }
-
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeDelayMainConnection SQLITE Finalize error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
if (mpDatabaseObserver)
mpDatabaseObserver->timingInformationChanged(connectionID, delay);
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
int eCode = 0;
std::string command = "INSERT INTO " + std::string(CONNECTION_TABLE) + "(sinkID, sourceID, delay, connectionFormat, reserved) VALUES (?,?,?,?,?)";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, connection.sinkID);
- sqlite3_bind_int(query, 2, connection.sourceID);
- sqlite3_bind_int(query, 3, connection.delay);
- sqlite3_bind_int(query, 4, connection.connectionFormat);
- sqlite3_bind_int(query, 5, true);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, connection.sinkID)
+ MY_SQLITE_BIND_INT(query, 2, connection.sourceID)
+ MY_SQLITE_BIND_INT(query, 3, connection.delay)
+ MY_SQLITE_BIND_INT(query, 4, connection.connectionFormat)
+ MY_SQLITE_BIND_INT(query, 5, true)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterConnectionDB SQLITE Step error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterConnectionDB SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
connectionID = sqlite3_last_insert_rowid(mpDatabase);
command = "INSERT INTO " + std::string(SINK_CLASS_TABLE) + "(name, sinkClassID) VALUES (?,?)";
}
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, sinkClass.name.c_str(), sinkClass.name.size(), SQLITE_STATIC);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, sinkClass.name.c_str(), sinkClass.name.size(), SQLITE_STATIC)
//if the ID is not created, we add it to the query
if (sinkClass.sinkClassID != 0)
{
- sqlite3_bind_int(query, 2, sinkClass.sinkClassID);
+ MY_SQLITE_BIND_INT(query, 2, sinkClass.sinkClassID)
}
//if the first static sink is entered, we need to set it onto the boundary
else if (mFirstStaticSinkClass)
{
- sqlite3_bind_int(query, 2, DYNAMIC_ID_BOUNDARY);
+ MY_SQLITE_BIND_INT(query, 2, DYNAMIC_ID_BOUNDARY)
mFirstStaticSinkClass = false;
}
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterSinkClassDB SQLITE Step error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterSinkClassDB SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
sinkClassID = sqlite3_last_insert_rowid(mpDatabase); //todo:change last_insert implementations for mulithread usage...
//now we need to create the additional tables:
command = "CREATE TABLE SinkClassProperties" + i2s(sinkClassID) + std::string("(classProperty INTEGER, value INTEGER)");
- assert(this->sqQuery(command));
+ if (!this->sqQuery(command))
+ return (E_DATABASE_ERROR);
//fill ConnectionFormats
command = "INSERT INTO SinkClassProperties" + i2s(sinkClassID) + std::string("(classProperty,value) VALUES (?,?)");
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
std::vector<am_ClassProperty_s>::const_iterator Iterator = sinkClass.listClassProperties.begin();
for (; Iterator < sinkClass.listClassProperties.end(); ++Iterator)
{
- sqlite3_bind_int(query, 1, Iterator->classProperty);
- sqlite3_bind_int(query, 2, Iterator->value);
+ MY_SQLITE_BIND_INT(query, 1, Iterator->classProperty)
+ MY_SQLITE_BIND_INT(query, 2, Iterator->value)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterSinkClassDB SQLITE Step error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
+ MY_SQLITE_RESET(query)
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterSinkClassDB SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::enterSinkClassDB entered new sinkClass");
if (mpDatabaseObserver)
command = "INSERT INTO " + std::string(SOURCE_CLASS_TABLE) + "(name, sourceClassID) VALUES (?,?)";
}
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, sourceClass.name.c_str(), sourceClass.name.size(), SQLITE_STATIC);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, sourceClass.name.c_str(), sourceClass.name.size(), SQLITE_STATIC)
//if the ID is not created, we add it to the query
if (sourceClass.sourceClassID != 0)
{
- sqlite3_bind_int(query, 2, sourceClass.sourceClassID);
+ MY_SQLITE_BIND_INT(query, 2, sourceClass.sourceClassID)
}
//if the first static sink is entered, we need to set it onto the boundary
else if (mFirstStaticSourceClass)
{
- sqlite3_bind_int(query, 2, DYNAMIC_ID_BOUNDARY);
+ MY_SQLITE_BIND_INT(query, 2, DYNAMIC_ID_BOUNDARY)
mFirstStaticSourceClass = false;
}
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterSourceClassDB SQLITE Step error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterSourceClassDB SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
sourceClassID = sqlite3_last_insert_rowid(mpDatabase); //todo:change last_insert implementations for mulithread usage...
//fill ConnectionFormats
command = "INSERT INTO SourceClassProperties" + i2s(sourceClassID) + std::string("(classProperty,value) VALUES (?,?)");
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
std::vector<am_ClassProperty_s>::const_iterator Iterator = sourceClass.listClassProperties.begin();
for (; Iterator < sourceClass.listClassProperties.end(); ++Iterator)
{
- sqlite3_bind_int(query, 1, Iterator->classProperty);
- sqlite3_bind_int(query, 2, Iterator->value);
+ MY_SQLITE_BIND_INT(query, 1, Iterator->classProperty)
+ MY_SQLITE_BIND_INT(query, 2, Iterator->value)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterSourceClassDB SQLITE Step error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
+ MY_SQLITE_RESET(query)
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterSourceClassDB SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::enterSourceClassDB entered new sourceClass");
sqlite3_stmt* query = NULL;
int eCode = 0;
std::vector<am_SystemProperty_s>::const_iterator listIterator = listSystemProperties.begin();
- std::string command = "DELETE * FROM " + std::string(SYSTEM_TABLE);
- sqQuery(command);
+ std::string command = "DELETE FROM " + std::string(SYSTEM_TABLE);
+ if (!this->sqQuery(command))
+ return (E_DATABASE_ERROR);
command = "INSERT INTO " + std::string(SYSTEM_TABLE) + " (type, value) VALUES (?,?)";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
for (; listIterator < listSystemProperties.end(); ++listIterator)
{
- sqlite3_bind_int(query, 1, listIterator->type);
- sqlite3_bind_int(query, 2, listIterator->value);
+ MY_SQLITE_BIND_INT(query, 1, listIterator->type)
+ MY_SQLITE_BIND_INT(query, 2, listIterator->value)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::enterSystemProperties SQLITE Step error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- sqlite3_reset(query);
+ MY_SQLITE_RESET(query)
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::enterSystemProperties SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::enterSystemProperties entered system properties");
return (E_OK);
std::string command = "SELECT mainConnectionID FROM " + std::string(MAINCONNECTION_TABLE) + " WHERE mainConnectionID=" + i2s(mainConnectionID);
int eCode = 0;
bool returnVal = true;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2_BOOL(mpDatabase, command.c_str(), -1, &query, NULL)
if ((eCode = sqlite3_step(query)) == SQLITE_DONE)
returnVal = false;
else if (eCode != SQLITE_ROW)
returnVal = false;
logError("DatabaseHandler::existMainConnection database error!:", eCode);
}
- sqlite3_finalize(query);
+
+ MY_SQLITE_FINALIZE_BOOL(query)
return (returnVal);
}
std::string command = "SELECT sourceID FROM " + std::string(SOURCE_TABLE) + " WHERE reserved=0 AND sourceID=" + i2s(sourceID);
int eCode = 0;
bool returnVal = true;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2_BOOL(mpDatabase, command.c_str(), -1, &query, NULL)
if ((eCode = sqlite3_step(query)) == SQLITE_DONE)
returnVal = false;
else if (eCode != SQLITE_ROW)
returnVal = false;
logError("DatabaseHandler::existSource database error!:", eCode);
}
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE_BOOL(query)
return (returnVal);
}
std::string command = "SELECT sourceID FROM " + std::string(SOURCE_TABLE) + " WHERE reserved=0 AND (name=? OR sourceID=?)";
int eCode = 0;
bool returnVal = true;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, name.c_str(), name.size(), SQLITE_STATIC);
- sqlite3_bind_int(query, 2, sourceID);
+ MY_SQLITE_PREPARE_V2_BOOL(mpDatabase, command.c_str(), -1, &query, NULL)
+
+ if ((eCode = sqlite3_bind_text(query, 1, name.c_str(), name.size(), SQLITE_STATIC)))
+ {
+ logError("CAmDatabaseHandler::sqlite3_bind_text failed with errorCode:", eCode);
+ return (false);
+ }
+
+ if ((eCode = sqlite3_bind_int(query, 2, sourceID)))
+ {
+ logError("CAmDatabaseHandler::sqlite3_bind_int failed with errorCode:", eCode);
+ return (false);
+ }
+
if ((eCode = sqlite3_step(query)) == SQLITE_DONE)
returnVal = false;
else if (eCode != SQLITE_ROW)
returnVal = false;
logError("DatabaseHandler::existSource database error!:", eCode);
}
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE_BOOL(query)
return (returnVal);
}
std::string command = "SELECT sourceID FROM " + std::string(SOURCE_TABLE) + " WHERE reserved=0 AND name=?";
int eCode = 0;
bool returnVal = true;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, name.c_str(), name.size(), SQLITE_STATIC);
+ MY_SQLITE_PREPARE_V2_BOOL(mpDatabase, command.c_str(), -1, &query, NULL)
+
+ if ((eCode = sqlite3_bind_text(query, 1, name.c_str(), name.size(), SQLITE_STATIC)))
+ {
+ logError("CAmDatabaseHandler::sqlite3_bind_text failed with errorCode:", eCode);
+ return (false);
+ }
+
if ((eCode = sqlite3_step(query)) == SQLITE_DONE)
returnVal = false;
else if (eCode != SQLITE_ROW)
returnVal = false;
logError("DatabaseHandler::existSource database error!:", eCode);
}
- sqlite3_finalize(query);
+
+ MY_SQLITE_FINALIZE_BOOL(query)
return (returnVal);
}
std::string command = "SELECT sinkID FROM " + std::string(SINK_TABLE) + " WHERE reserved=0 AND sinkID=" + i2s(sinkID);
int eCode = 0;
bool returnVal = true;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2_BOOL(mpDatabase, command.c_str(), -1, &query, NULL)
+
if ((eCode = sqlite3_step(query)) == SQLITE_DONE)
returnVal = false;
else if (eCode != SQLITE_ROW)
returnVal = false;
logError("DatabaseHandler::existSink database error!:", eCode);
}
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE_BOOL(query)
return (returnVal);
}
std::string command = "SELECT sinkID FROM " + std::string(SINK_TABLE) + " WHERE reserved=0 AND (name=? OR sinkID=?)";
int eCode = 0;
bool returnVal = true;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, name.c_str(), name.size(), SQLITE_STATIC);
- sqlite3_bind_int(query, 2, sinkID);
+ MY_SQLITE_PREPARE_V2_BOOL(mpDatabase, command.c_str(), -1, &query, NULL)
+
+ if ((eCode = sqlite3_bind_text(query, 1, name.c_str(), name.size(), SQLITE_STATIC)))
+ {
+ logError("CAmDatabaseHandler::sqlite3_bind_text failed with errorCode:", eCode);
+ return (false);
+ }
+
+ if ((eCode = sqlite3_bind_int(query, 2, sinkID)))
+ {
+ logError("CAmDatabaseHandler::sqlite3_bind_int failed with errorCode:", eCode);
+ return (false);
+ }
+
if ((eCode = sqlite3_step(query)) == SQLITE_DONE)
returnVal = false;
else if (eCode != SQLITE_ROW)
returnVal = false;
logError("DatabaseHandler::existSink database error!:", eCode);
}
- sqlite3_finalize(query);
+
+ MY_SQLITE_FINALIZE_BOOL(query)
return (returnVal);
}
std::string command = "SELECT sinkID FROM " + std::string(SINK_TABLE) + " WHERE reserved=0 AND name=?";
int eCode = 0;
bool returnVal = true;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, name.c_str(), name.size(), SQLITE_STATIC);
+ MY_SQLITE_PREPARE_V2_BOOL(mpDatabase, command.c_str(), -1, &query, NULL)
+
+ if ((eCode = sqlite3_bind_text(query, 1, name.c_str(), name.size(), SQLITE_STATIC)))
+ {
+ logError("CAmDatabaseHandler::sqlite3_bind_text failed with errorCode:", eCode);
+ return (false);
+ }
+
if ((eCode = sqlite3_step(query)) == SQLITE_DONE)
returnVal = false;
else if (eCode != SQLITE_ROW)
returnVal = false;
logError("DatabaseHandler::existSink database error!:", eCode);
}
- sqlite3_finalize(query);
+
+ MY_SQLITE_FINALIZE_BOOL(query)
return (returnVal);
}
std::string command = "SELECT domainID FROM " + std::string(DOMAIN_TABLE) + " WHERE reserved=0 AND domainID=" + i2s(domainID);
int eCode = 0;
bool returnVal = true;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2_BOOL(mpDatabase, command.c_str(), -1, &query, NULL)
+
if ((eCode = sqlite3_step(query)) == SQLITE_DONE)
returnVal = false;
else if (eCode != SQLITE_ROW)
returnVal = false;
logError("DatabaseHandler::existDomain database error!:", eCode);
}
- sqlite3_finalize(query);
+
+ MY_SQLITE_FINALIZE_BOOL(query)
return (returnVal);
}
std::string command = "SELECT gatewayID FROM " + std::string(GATEWAY_TABLE) + " WHERE gatewayID=" + i2s(gatewayID);
int eCode = 0;
bool returnVal = true;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2_BOOL(mpDatabase, command.c_str(), -1, &query, NULL)
+
if ((eCode = sqlite3_step(query)) == SQLITE_DONE)
returnVal = false;
else if (eCode != SQLITE_ROW)
returnVal = false;
logError("DatabaseHandler::existGateway database error!:", eCode);
}
- sqlite3_finalize(query);
+
+ MY_SQLITE_FINALIZE_BOOL(query)
return (returnVal);
}
std::string command = "SELECT domainID FROM " + std::string(SOURCE_TABLE) + " WHERE sourceID=" + i2s(sourceID);
int eCode = 0;
am_Error_e returnVal = E_DATABASE_ERROR;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
domainID = sqlite3_column_int(query, 0);
{
logError("DatabaseHandler::getDomainOfSource database error!:", eCode);
}
- sqlite3_finalize(query);
+
+ MY_SQLITE_FINALIZE(query)
return (returnVal);
}
std::string command = "SELECT domainID FROM " + std::string(SINK_TABLE) + " WHERE sinkID=" + i2s(sinkID);
int eCode = 0;
am_Error_e returnVal = E_DATABASE_ERROR;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
domainID = sqlite3_column_int(query, 0);
{
logError("DatabaseHandler::getDomainOfSink database error!:", eCode);
}
- sqlite3_finalize(query);
+
+ MY_SQLITE_FINALIZE(query)
return (returnVal);
}
std::string command = "SELECT sinkClassID FROM " + std::string(SINK_CLASS_TABLE) + " WHERE sinkClassID=" + i2s(sinkClassID);
int eCode = 0;
bool returnVal = true;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2_BOOL(mpDatabase, command.c_str(), -1, &query, NULL)
if ((eCode = sqlite3_step(query)) == SQLITE_DONE)
returnVal = false;
else if (eCode != SQLITE_ROW)
returnVal = false;
logError("DatabaseHandler::existSinkClass database error!:", eCode);
}
- sqlite3_finalize(query);
+
+ MY_SQLITE_FINALIZE_BOOL(query)
return (returnVal);
}
std::string command = "SELECT sourceClassID FROM " + std::string(SOURCE_CLASS_TABLE) + " WHERE sourceClassID=" + i2s(sourceClassID);
int eCode = 0;
bool returnVal = true;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2_BOOL(mpDatabase, command.c_str(), -1, &query, NULL)
+
if ((eCode = sqlite3_step(query)) == SQLITE_DONE)
returnVal = false;
else if (eCode != SQLITE_ROW)
returnVal = false;
logError("DatabaseHandler::existSinkClass database error!:", eCode);
}
- sqlite3_finalize(query);
+
+ MY_SQLITE_FINALIZE_BOOL(query)
return (returnVal);
}
{
assert(connectionID!=0);
- sqlite3_stmt *query = NULL, *queryMainConnections, *queryMainConnectionSubIDs;
+ sqlite3_stmt *query = NULL, *queryMainConnectionSubIDs = NULL;
int eCode = 0, eCode1 = 0;
std::string command = "UPDATE " + std::string(CONNECTION_TABLE) + " set delay=? WHERE connectionID=?";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, delay);
- sqlite3_bind_int(query, 2, connectionID);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, delay)
+ MY_SQLITE_BIND_INT(query, 2, connectionID)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeConnectionTimingInformation SQLITE Step error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeConnectionTimingInformation SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
//now we need to find all mainConnections that use the changed connection and update their timing
int tempMainConnectionID;
//first get all route tables for all mainconnections
command = "SELECT name FROM sqlite_master WHERE type ='table' and name LIKE 'MainConnectionRoute%'";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &queryMainConnections, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
- while ((eCode = sqlite3_step(queryMainConnections)) == SQLITE_ROW)
+ while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
//now check if the connection ID is in this table
- std::string tablename = std::string((const char*) sqlite3_column_text(queryMainConnections, 0));
+ std::string tablename = std::string((const char*) sqlite3_column_text(query, 0));
std::string command2 = "SELECT connectionID FROM " + tablename + " WHERE connectionID=" + i2s(connectionID);
- sqlite3_prepare_v2(mpDatabase, command2.c_str(), -1, &queryMainConnectionSubIDs, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command2.c_str(), -1, &queryMainConnectionSubIDs, NULL)
if ((eCode1 = sqlite3_step(queryMainConnectionSubIDs)) == SQLITE_ROW)
{
//if the connection ID is in, recalculate the mainconnection delay
return (E_DATABASE_ERROR);
}
+ MY_SQLITE_FINALIZE(queryMainConnectionSubIDs)
}
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::changeConnectionTimingInformation SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(queryMainConnections)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeConnectionTimingInformation SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
int eCode = 0;
std::string command = "UPDATE " + std::string(CONNECTION_TABLE) + " set reserved=0 WHERE connectionID=?";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, connectionID);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, connectionID)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeConnectionFinal SQLITE Step error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeConnectionFinal SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
int eCode = 0;
am_timeSync_t delay = 0;
am_timeSync_t min = 0;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
delay = sqlite3_column_int(query, 0);
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::calculateMainConnectionDelay SQLITE Step error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
{
logError("DatabaseHandler::calculateMainConnectionDelay SQLITE Finalize error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
if (min < 0)
std::string command = "SELECT visible FROM " + std::string(SOURCE_TABLE) + " WHERE sourceID=" + i2s(sourceID);
int eCode = 0;
bool returnVal = false;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2_BOOL(mpDatabase, command.c_str(), -1, &query, NULL)
+
if ((eCode = sqlite3_step(query)) == SQLITE_DONE)
{
returnVal = (bool) sqlite3_column_int(query, 0);
returnVal = false;
logError("DatabaseHandler::sourceVisible database error!:", eCode);
}
- sqlite3_finalize(query);
+
+ MY_SQLITE_FINALIZE_BOOL(query)
return (returnVal);
}
std::string command = "SELECT visible FROM " + std::string(SINK_TABLE) + " WHERE reserved=0 AND sinkID=" + i2s(sinkID);
int eCode = 0;
bool returnVal = false;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2_BOOL(mpDatabase, command.c_str(), -1, &query, NULL)
if ((eCode = sqlite3_step(query)) == SQLITE_DONE)
{
returnVal = sqlite3_column_int(query, 0);
returnVal = false;
logError("DatabaseHandler::sinkVisible database error!:", eCode);
}
- sqlite3_finalize(query);
+
+ MY_SQLITE_FINALIZE_BOOL(query)
return (returnVal);
}
std::string command = "SELECT connectionID FROM " + std::string(CONNECTION_TABLE) + " WHERE sinkID=? AND sourceID=? AND connectionFormat=? AND reserved=0";
int eCode = 0;
bool returnVal = true;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, connection.sinkID);
- sqlite3_bind_int(query, 2, connection.sourceID);
- sqlite3_bind_int(query, 3, connection.connectionFormat);
+ MY_SQLITE_PREPARE_V2_BOOL(mpDatabase, command.c_str(), -1, &query, NULL)
+
+ if ((eCode = sqlite3_bind_int(query, 1, connection.sinkID)))
+ {
+ logError("CAmDatabaseHandler::sqlite3_bind_int failed with errorCode:", eCode);
+ return (false);
+ }
+
+ if ((eCode = sqlite3_bind_int(query, 2, connection.sourceID)))
+ {
+ logError("CAmDatabaseHandler::sqlite3_bind_int failed with errorCode:", eCode);
+ return (false);
+ }
+
+ if ((eCode = sqlite3_bind_int(query, 3, connection.connectionFormat)))
+ {
+ logError("CAmDatabaseHandler::sqlite3_bind_int failed with errorCode:", eCode);
+ return (false);
+ }
+
if ((eCode = sqlite3_step(query)) == SQLITE_DONE)
returnVal = false;
else if (eCode != SQLITE_ROW)
returnVal = false;
logError("DatabaseHandler::existMainConnection database error!:", eCode);
}
- sqlite3_finalize(query);
+
+ MY_SQLITE_FINALIZE_BOOL(query)
return (returnVal);
}
std::string command = "SELECT connectionID FROM " + std::string(CONNECTION_TABLE) + " WHERE connectionID=? AND reserved=0";
int eCode = 0;
bool returnVal = true;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, connectionID);
+ MY_SQLITE_PREPARE_V2_BOOL(mpDatabase, command.c_str(), -1, &query, NULL)
+
+ if ((eCode = sqlite3_bind_int(query, 1, connectionID)))
+ {
+ logError("CAmDatabaseHandler::sqlite3_bind_int failed with errorCode:", eCode);
+ return (false);
+ }
+
if ((eCode = sqlite3_step(query)) == SQLITE_DONE)
returnVal = false;
else if (eCode != SQLITE_ROW)
returnVal = false;
logError("DatabaseHandler::existMainConnection database error!:", eCode);
}
- sqlite3_finalize(query);
+
+ MY_SQLITE_FINALIZE_BOOL(query)
return (returnVal);
}
std::string command = "SELECT crossfaderID FROM " + std::string(CROSSFADER_TABLE) + " WHERE crossfaderID=?";
int eCode = 0;
bool returnVal = true;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, crossfaderID);
+ MY_SQLITE_PREPARE_V2_BOOL(mpDatabase, command.c_str(), -1, &query, NULL)
+
+ if ((eCode = sqlite3_bind_int(query, 1, crossfaderID)))
+ {
+ logError("CAmDatabaseHandler::sqlite3_bind_int failed with errorCode:", eCode);
+ return (false);
+ }
+
if ((eCode = sqlite3_step(query)) == SQLITE_DONE)
returnVal = false;
else if (eCode != SQLITE_ROW)
returnVal = false;
logError("DatabaseHandler::existMainConnection database error!:", eCode);
}
- sqlite3_finalize(query);
+
+ MY_SQLITE_FINALIZE_BOOL(query)
return (returnVal);
}
sourceState = SS_UNKNNOWN;
std::string command = "SELECT sourceState FROM " + std::string(SOURCE_TABLE) + " WHERE sourceID=" + i2s(sourceID);
int eCode = 0;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
sourceState = (am_SourceState_e) sqlite3_column_int(query, 0);
{
logError("DatabaseHandler::getSoureState database error!:", eCode);
}
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
sqlite3_stmt* query = NULL;
std::string command = "UPDATE " + std::string(SOURCE_TABLE) + " SET sourceState=? WHERE sourceID=" + i2s(sourceID);
int eCode = 0;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, sourceState);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, sourceState)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeSourceState SQLITE Step error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeSourceState SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
volume = -1;
std::string command = "SELECT volume FROM " + std::string(SINK_TABLE) + " WHERE sinkID=" + i2s(sinkID);
int eCode = 0;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
volume = sqlite3_column_int(query, 0);
{
logError("DatabaseHandler::getSinkVolume database error!:", eCode);
}
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
volume = -1;
std::string command = "SELECT volume FROM " + std::string(SOURCE_TABLE) + " WHERE sourceID=" + i2s(sourceID);
int eCode = 0;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
volume = sqlite3_column_int(query, 0);
{
logError("DatabaseHandler::getSourceVolume database error!:", eCode);
}
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
sqlite3_stmt* query = NULL;
int eCode = 0;
std::string command = "SELECT value FROM SinkSoundProperty" + i2s(sinkID) + " WHERE soundPropertyType=" + i2s(propertyType);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getSinkSoundPropertyValue SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getSinkSoundPropertyValue SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
sqlite3_stmt* query = NULL;
int eCode = 0;
std::string command = "SELECT value FROM SourceSoundProperty" + i2s(sourceID) + " WHERE soundPropertyType=" + i2s(propertyType);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getSinkSoundPropertyValue SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getSinkSoundPropertyValue SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
state = DS_UNKNOWN;
std::string command = "SELECT domainState FROM " + std::string(DOMAIN_TABLE) + " WHERE domainID=" + i2s(domainID);
int eCode = 0;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
state = (am_DomainState_e) sqlite3_column_int(query, 0);
{
logError("DatabaseHandler::getDomainState database error!:", eCode);
}
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
sqlite3_stmt* query = NULL, *queryInsert = NULL;
std::string command = "SELECT domainID FROM " + std::string(DOMAIN_TABLE) + " WHERE name=?";
int eCode = 0, eCode1 = 0;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, name.c_str(), name.size(), SQLITE_STATIC);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, name.c_str(), name.size(), SQLITE_STATIC)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
domainID = sqlite3_column_int(query, 0);
else if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::peekDomain database error!:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
else
{
command = "INSERT INTO " + std::string(DOMAIN_TABLE) + " (name,reserved) VALUES (?,?)";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &queryInsert, NULL);
- sqlite3_bind_text(queryInsert, 1, name.c_str(), name.size(), SQLITE_STATIC);
- sqlite3_bind_int(queryInsert, 2, 1); //reservation flag
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &queryInsert, NULL)
+ MY_SQLITE_BIND_TEXT(queryInsert, 1, name.c_str(), name.size(), SQLITE_STATIC)
+ MY_SQLITE_BIND_INT(queryInsert, 2, 1)
+ //reservation flag
if ((eCode1 = sqlite3_step(queryInsert)) != SQLITE_DONE)
{
logError("DatabaseHandler::peekDomain SQLITE Step error code:", eCode1);
+ MY_SQLITE_FINALIZE(queryInsert)
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode1 = sqlite3_finalize(queryInsert)) != SQLITE_OK)
- {
- logError("DatabaseHandler::peekDomain SQLITE Finalize error code:", eCode1);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(queryInsert)
+
domainID = sqlite3_last_insert_rowid(mpDatabase);
}
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
+
return (E_OK);
}
sqlite3_stmt* query = NULL, *queryInsert = NULL;
std::string command = "SELECT sinkID FROM " + std::string(SINK_TABLE) + " WHERE name=?";
int eCode = 0, eCode1 = 0;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, name.c_str(), name.size(), SQLITE_STATIC);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, name.c_str(), name.size(), SQLITE_STATIC)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
sinkID = sqlite3_column_int(query, 0);
else if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::peekSink database error!:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
else
{
command = "INSERT INTO " + std::string(SINK_TABLE) + " (name,reserved) VALUES (?,?)";
}
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &queryInsert, NULL);
- sqlite3_bind_text(queryInsert, 1, name.c_str(), name.size(), SQLITE_STATIC);
- sqlite3_bind_int(queryInsert, 2, 1); //reservation flag
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &queryInsert, NULL)
+ MY_SQLITE_BIND_TEXT(queryInsert, 1, name.c_str(), name.size(), SQLITE_STATIC)
+ MY_SQLITE_BIND_INT(queryInsert, 2, 1)
+ //reservation flag
if ((eCode1 = sqlite3_step(queryInsert)) != SQLITE_DONE)
{
logError("DatabaseHandler::peekSink SQLITE Step error code:", eCode1);
+ MY_SQLITE_FINALIZE(queryInsert)
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode1 = sqlite3_finalize(queryInsert)) != SQLITE_OK)
- {
- logError("DatabaseHandler::peekDomain SQLITE Finalize error code:", eCode1);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(queryInsert)
+
sinkID = sqlite3_last_insert_rowid(mpDatabase);
}
- sqlite3_finalize(query);
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
sqlite3_stmt* query = NULL, *queryInsert = NULL;
std::string command = "SELECT sourceID FROM " + std::string(SOURCE_TABLE) + " WHERE name=?";
int eCode = 0, eCode1 = 0;
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, name.c_str(), name.size(), SQLITE_STATIC);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, name.c_str(), name.size(), SQLITE_STATIC)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
sourceID = sqlite3_column_int(query, 0);
else if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::peekSink database error!:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
else
{
command = "INSERT INTO " + std::string(SOURCE_TABLE) + " (name,reserved) VALUES (?,?)";
}
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &queryInsert, NULL);
- sqlite3_bind_text(queryInsert, 1, name.c_str(), name.size(), SQLITE_STATIC);
- sqlite3_bind_int(queryInsert, 2, 1); //reservation flag
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &queryInsert, NULL)
+ MY_SQLITE_BIND_TEXT(queryInsert, 1, name.c_str(), name.size(), SQLITE_STATIC)
+ MY_SQLITE_BIND_INT(queryInsert, 2, 1)
+ //reservation flag
if ((eCode1 = sqlite3_step(queryInsert)) != SQLITE_DONE)
{
logError("DatabaseHandler::peekSink SQLITE Step error code:", eCode1);
+ MY_SQLITE_FINALIZE(queryInsert)
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode1 = sqlite3_finalize(queryInsert)) != SQLITE_OK)
- {
- logError("DatabaseHandler::peekDomain SQLITE Finalize error code:", eCode1);
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(queryInsert)
sourceID = sqlite3_last_insert_rowid(mpDatabase);
}
- sqlite3_finalize(query);
+
+ MY_SQLITE_FINALIZE(query)
return (E_OK);
}
return (E_NON_EXISTENT);
}
command = "UPDATE " + std::string(SINK_TABLE) + " SET volume=? WHERE sinkID=" + i2s(sinkID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, volume);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, volume)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeSinkVolume SQLITE Step error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeSinkVolume SQLITE Finalize error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::changeSinkVolume changed volume of sink:", sinkID, "to:", volume);
-
return (E_OK);
}
return (E_NON_EXISTENT);
}
command = "UPDATE " + std::string(SOURCE_TABLE) + " SET volume=? WHERE sourceID=" + i2s(sourceID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, volume);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, volume)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeSourceVolume SQLITE Step error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeSourceVolume SQLITE Finalize error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::changeSourceVolume changed volume of source=:", sourceID, "to:", volume);
return (E_OK);
return (E_NON_EXISTENT);
}
command = "UPDATE SourceSoundProperty" + i2s(sourceID) + " SET value=? WHERE soundPropertyType=" + i2s(soundProperty.type);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, soundProperty.value);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, soundProperty.value)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeSourceSoundPropertyDB SQLITE Step error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
-
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeSourceSoundPropertyDB SQLITE Finalize error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::changeSourceSoundPropertyDB changed SourceSoundProperty of source:", sourceID, "type:", soundProperty.type, "to:", soundProperty.value);
-
return (E_OK);
}
return (E_NON_EXISTENT);
}
command = "UPDATE SinkSoundProperty" + i2s(sinkID) + " SET value=? WHERE soundPropertyType=" + i2s(soundProperty.type);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, soundProperty.value);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, soundProperty.value)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeSinkSoundPropertyDB SQLITE Step error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
assert(sinkID!=0);
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeSinkSoundPropertyDB SQLITE Finalize error code:", eCode);
- return (E_DATABASE_ERROR);
- }
-
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::changeSinkSoundPropertyDB changed MainSinkSoundProperty of sink:", sinkID, "type:", soundProperty.type, "to:", soundProperty.value);
-
return (E_OK);
}
return (E_NON_EXISTENT);
}
command = "UPDATE " + std::string(CROSSFADER_TABLE) + " SET hotsink=? WHERE crossfaderID=" + i2s(crossfaderID);
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, hotsink);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, hotsink)
if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
{
logError("DatabaseHandler::changeCrossFaderHotSink SQLITE Step error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::changeCrossFaderHotSink SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
-
+ MY_SQLITE_FINALIZE(query)
logInfo("DatabaseHandler::changeCrossFaderHotSink changed hotsink of crossfader=", crossfaderID, "to:", hotsink);
return (E_OK);
}
parent = flatTree.at(i - 1);
rootID = parent->returnDomainID();
}
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_int(query, 1, rootID);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_INT(query, 1, rootID)
while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
if (eCode != SQLITE_DONE)
{
logError("DatabaseHandler::getRoutingTree SQLITE error code:", eCode);
-
+ MY_SQLITE_FINALIZE(query)
return (E_DATABASE_ERROR);
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::getRoutingTree SQLITE Finalize error code:", eCode);
-
- return (E_DATABASE_ERROR);
- }
+ MY_SQLITE_FINALIZE(query)
i++;
} while (flatTree.size() > (i - 1));
sqlite3_stmt* query = NULL;
int eCode = 0;
std::string command = "SELECT sinkClassID FROM " + std::string(SINK_CLASS_TABLE) + " WHERE name=?";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, name.c_str(), name.size(), SQLITE_STATIC);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, name.c_str(), name.size(), SQLITE_STATIC)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
{
sinkClassID = 0;
logError("DatabaseHandler::peekSinkClassID SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
returnVal = E_DATABASE_ERROR;
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::peekSinkClassID SQLITE Finalize error code:", eCode);
- returnVal = E_DATABASE_ERROR;
- }
+ MY_SQLITE_FINALIZE(query)
return (returnVal);
}
sqlite3_stmt* query = NULL;
int eCode = 0;
std::string command = "SELECT sourceClassID FROM " + std::string(SOURCE_CLASS_TABLE) + " WHERE name=?";
- sqlite3_prepare_v2(mpDatabase, command.c_str(), -1, &query, NULL);
- sqlite3_bind_text(query, 1, name.c_str(), name.size(), SQLITE_STATIC);
+ MY_SQLITE_PREPARE_V2(mpDatabase, command.c_str(), -1, &query, NULL)
+ MY_SQLITE_BIND_TEXT(query, 1, name.c_str(), name.size(), SQLITE_STATIC)
if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
{
{
sourceClassID = 0;
logError("DatabaseHandler::peekSourceClassID SQLITE error code:", eCode);
+ MY_SQLITE_FINALIZE(query)
returnVal = E_DATABASE_ERROR;
}
- if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
- {
- logError("DatabaseHandler::peekSourceClassID SQLITE Finalize error code:", eCode);
- returnVal = E_DATABASE_ERROR;
- }
+ MY_SQLITE_FINALIZE(query)
return (returnVal);
}
{
for (uint16_t i = 0; i < sizeof(databaseTables) / sizeof(databaseTables[0]); i++)
{
- assert(sqQuery("CREATE TABLE " + databaseTables[i]));
+ if (!sqQuery("CREATE TABLE " + databaseTables[i]))
+ throw std::runtime_error("CAmDatabaseHandler Could not create tables!");
}
}
}