Merge pull request #208 from c-jimenez/develop

c-jimenez · web-flow · commit 1fe82e8c8ebd · 2024-06-11T09:11:44.000+02:00
v1.5.3
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -5,7 +5,7 @@
 cmake_minimum_required(VERSION 3.13)
 
 project(OpenOCPP DESCRIPTION "Open Source C++ implementation of the OCPP 1.6 protocol"
-                 VERSION 1.5.2
+                 VERSION 1.5.3
 )
 
 # Definitions for Version.h file
diff --git a/examples/security_centralsystem/ChargePointDatabase.cpp b/examples/security_centralsystem/ChargePointDatabase.cpp
@@ -51,14 +51,14 @@ bool ChargePointDatabase::addChargePoint(const std::string& identifier,
 
     if (m_insert_query)
     {
-        m_insert_query->reset();
         m_insert_query->bind(0, identifier);
         m_insert_query->bind(1, serial_number);
         m_insert_query->bind(2, vendor);
         m_insert_query->bind(3, model);
         m_insert_query->bind(4, security_profile);
         m_insert_query->bind(5, authent_key);
         ret = m_insert_query->exec();
+        m_insert_query->reset();
     }
 
     return ret;
@@ -74,7 +74,6 @@ bool ChargePointDatabase::getChargePoint(const std::string& identifier,
 
     if (m_find_query)
     {
-        m_find_query->reset();
         m_find_query->bind(0, identifier);
         if (m_find_query->exec() && m_find_query->hasRows())
         {
@@ -83,6 +82,7 @@ bool ChargePointDatabase::getChargePoint(const std::string& identifier,
             authent_key      = m_find_query->getString(5);
             ret              = true;
         }
+        m_find_query->reset();
     }
 
     return ret;
@@ -95,10 +95,10 @@ bool ChargePointDatabase::setChargePointProfile(const std::string& identifier, u
 
     if (m_update_profile_query)
     {
-        m_update_profile_query->reset();
         m_update_profile_query->bind(0, security_profile);
         m_update_profile_query->bind(1, identifier);
         ret = m_update_profile_query->exec();
+        m_update_profile_query->reset();
     }
 
     return ret;
diff --git a/src/chargepoint/authent/AuthentCache.cpp b/src/chargepoint/authent/AuthentCache.cpp
@@ -130,9 +130,9 @@ bool AuthentCache::check(const std::string& id_tag, ocpp::types::IdTagInfo& tag_
                     // Entry is no more valid, delete entry
                     if (m_delete_query)
                     {
-                        m_delete_query->reset();
                         m_delete_query->bind(0, id_tag);
                         m_delete_query->exec();
+                        m_delete_query->reset();
                     }
                     ret = false;
                 }
diff --git a/src/chargepoint/connector/Connectors.cpp b/src/chargepoint/connector/Connectors.cpp
@@ -230,7 +230,6 @@ bool Connectors::loadConnector(Connector& connector)
 
     if (m_find_query)
     {
-        m_find_query->reset();
         m_find_query->bind(0, connector.id);
         ret = m_find_query->exec();
         if (ret)
@@ -272,6 +271,7 @@ bool Connectors::loadConnector(Connector& connector)
         {
             LOG_ERROR << "Could not search for connector " << connector.id << " : " << m_find_query->lastError();
         }
+        m_find_query->reset();
     }
 
     return ret;
@@ -284,7 +284,6 @@ bool Connectors::saveConnector(const Connector& connector)
 
     if (m_update_query)
     {
-        m_update_query->reset();
         m_update_query->bind(0u, static_cast<int>(connector.status));
         m_update_query->bind(1u, static_cast<int>(connector.last_notified_status));
         m_update_query->bind(2u, connector.transaction_id);
@@ -306,6 +305,7 @@ bool Connectors::saveConnector(const Connector& connector)
         {
             LOG_ERROR << "Could not update connector " << connector.id << " : " << m_update_query->lastError();
         }
+        m_update_query->reset();
     }
 
     return ret;
@@ -318,7 +318,6 @@ bool Connectors::createConnector(const Connector& connector)
 
     if (m_insert_query)
     {
-        m_insert_query->reset();
         m_insert_query->bind(0u, connector.id);
         m_insert_query->bind(1u, static_cast<int>(connector.status));
         m_insert_query->bind(2u, static_cast<int>(connector.last_notified_status));
@@ -340,6 +339,7 @@ bool Connectors::createConnector(const Connector& connector)
         {
             LOG_ERROR << "Could not create connector " << connector.id << " : " << m_insert_query->lastError();
         }
+        m_insert_query->reset();
     }
 
     return ret;
diff --git a/src/chargepoint/metervalues/MeterValuesManager.cpp b/src/chargepoint/metervalues/MeterValuesManager.cpp
@@ -158,7 +158,6 @@ void MeterValuesManager::getTxStopMeterValues(unsigned int connector_id, std::ve
     {
         // Get data from database
         meter_values.clear();
-        m_find_query->reset();
         m_find_query->bind(0, connector->transaction_id);
         if (m_find_query->exec() && m_find_query->hasRows())
         {
@@ -175,12 +174,14 @@ void MeterValuesManager::getTxStopMeterValues(unsigned int connector_id, std::ve
                     meter_values.pop_back();
                 }
             } while (m_find_query->next());
+            m_find_query->reset();
 
             // Clear data from database
-            m_delete_query->reset();
             m_delete_query->bind(0, connector->transaction_id);
             m_delete_query->exec();
+            m_delete_query->reset();
         }
+        m_find_query->reset();
     }
 }
 
@@ -335,10 +336,10 @@ void MeterValuesManager::processClockAligned(void)
                                 std::string meter_value_str = serialize(meter_value);
 
                                 // Store into database
-                                m_insert_query->reset();
                                 m_insert_query->bind(0u, connector->transaction_id);
                                 m_insert_query->bind(1u, meter_value_str);
                                 m_insert_query->exec();
+                                m_insert_query->reset();
                             }
                         }
                     }
@@ -385,10 +386,10 @@ void MeterValuesManager::processSampled(unsigned int connector_id)
                             std::string meter_value_str = serialize(meter_value);
 
                             // Store into database
-                            m_insert_query->reset();
                             m_insert_query->bind(0u, connector->transaction_id);
                             m_insert_query->bind(1u, meter_value_str);
                             m_insert_query->exec();
+                            m_insert_query->reset();
                         }
                     }
                 }
@@ -573,9 +574,9 @@ void MeterValuesManager::initDatabaseTable()
             if (!found && m_delete_query)
             {
                 LOG_INFO << "Cleaning meter values associated to not ongoing transaction : " << transaction_id;
-                m_delete_query->reset();
                 m_delete_query->bind(0, transaction_id);
                 m_delete_query->exec();
+                m_delete_query->reset();
             }
         } while (query->next());
     }
diff --git a/src/chargepoint/requestfifo/RequestFifo.cpp b/src/chargepoint/requestfifo/RequestFifo.cpp
@@ -53,12 +53,12 @@ void RequestFifo::push(unsigned int connector_id, const std::string& action, con
     m_fifo.emplace(m_id, connector_id, action, request);
     if (m_insert_query)
     {
-        m_insert_query->reset();
         m_insert_query->bind(0, m_id);
         m_insert_query->bind(1, connector_id);
         m_insert_query->bind(2, action);
         m_insert_query->bind(3, request);
         m_insert_query->exec();
+        m_insert_query->reset();
     }
 
     // Prepare for next entry
@@ -105,9 +105,9 @@ void RequestFifo::pop()
     m_fifo.pop();
     if (m_delete_query)
     {
-        m_delete_query->reset();
         m_delete_query->bind(0, id);
         m_delete_query->exec();
+        m_delete_query->reset();
     }
 }
 
diff --git a/src/chargepoint/security/CaCertificatesDatabase.cpp b/src/chargepoint/security/CaCertificatesDatabase.cpp
@@ -111,7 +111,6 @@ ocpp::types::DeleteCertificateStatusEnumType CaCertificatesDatabase::deleteCerti
             if (!in_use)
             {
                 // Delete the requested certificate
-                m_delete_query->reset();
                 m_delete_query->bind(0, id);
                 if (m_delete_query->exec())
                 {
@@ -144,7 +143,6 @@ void CaCertificatesDatabase::getCertificateList(ocpp::types::CertificateUseEnumT
     if (m_list_query)
     {
         // List certificates
-        m_list_query->reset();
         m_list_query->bind(0, static_cast<unsigned int>(type));
         m_list_query->bind(1, static_cast<int64_t>(std::numeric_limits<std::time_t>::max()));
         m_list_query->bind(2, 0);
@@ -175,7 +173,6 @@ std::string CaCertificatesDatabase::getCertificateListPem(ocpp::types::Certifica
     if (m_list_query)
     {
         // List certificates
-        m_list_query->reset();
         m_list_query->bind(0, static_cast<unsigned int>(type));
         m_list_query->bind(1, static_cast<int64_t>(DateTime::now().timestamp()));
         m_list_query->bind(2, static_cast<int64_t>(DateTime::now().timestamp()));
@@ -215,7 +212,6 @@ unsigned int CaCertificatesDatabase::getCertificateCount(ocpp::types::Certificat
             validity_from = std::numeric_limits<std::time_t>::max();
             validity_to   = 0;
         }
-        m_count_query->reset();
         m_count_query->bind(0, static_cast<unsigned int>(type));
         m_count_query->bind(1, static_cast<int64_t>(validity_from));
         m_count_query->bind(2, static_cast<int64_t>(validity_to));
@@ -247,7 +243,6 @@ bool CaCertificatesDatabase::addCertificate(ocpp::types::CertificateUseEnumType
         if (!findCertificate(hash_data, id, in_use))
         {
             // Add certificate
-            m_insert_query->reset();
             m_insert_query->bind(0, static_cast<unsigned int>(type));
             m_insert_query->bind(1, static_cast<int64_t>(certificate.validityFrom()));
             m_insert_query->bind(2, static_cast<int64_t>(certificate.validityTo()));
@@ -284,7 +279,6 @@ bool CaCertificatesDatabase::findCertificate(const ocpp::types::CertificateHashD
     if (m_find_query)
     {
         // Look for the requested certificate
-        m_find_query->reset();
         m_find_query->bind(0, certificate.issuerNameHash);
         m_find_query->bind(1, certificate.issuerKeyHash);
         m_find_query->bind(2, certificate.serialNumber);
diff --git a/src/chargepoint/security/CpCertificatesDatabase.cpp b/src/chargepoint/security/CpCertificatesDatabase.cpp
@@ -100,11 +100,10 @@ void CpCertificatesDatabase::saveCertificateRequest(const ocpp::x509::Certificat
     if (m_delete_csr_query && m_insert_csr_query)
     {
         // Delete any existing request
-        m_delete_csr_query->reset();
         m_delete_csr_query->exec();
+        m_delete_csr_query->reset();
 
         // Insert new request
-        m_insert_csr_query->reset();
         m_insert_csr_query->bind(0, certificate_request.pem());
         m_insert_csr_query->bind(1, private_key.privatePem());
         if (!m_insert_csr_query->exec())
@@ -113,7 +112,6 @@ void CpCertificatesDatabase::saveCertificateRequest(const ocpp::x509::Certificat
         }
 
         // Reset all queries
-        m_delete_csr_query->reset();
         m_insert_csr_query->reset();
     }
 }
@@ -126,7 +124,6 @@ std::string CpCertificatesDatabase::getCertificateRequest(unsigned int& id)
     if (m_find_csr_query)
     {
         // Look for the certificate request
-        m_find_csr_query->reset();
         if (m_find_csr_query->exec())
         {
             // Read data
@@ -149,7 +146,6 @@ bool CpCertificatesDatabase::installCertificate(unsigned int request_id, const o
     if (m_update_csr_to_cert_query)
     {
         // Install certificate
-        m_update_csr_to_cert_query->reset();
         m_update_csr_to_cert_query->bind(0, static_cast<int64_t>(certificate.validityFrom()));
         m_update_csr_to_cert_query->bind(1, static_cast<int64_t>(certificate.validityTo()));
         m_update_csr_to_cert_query->bind(2, certificate.pem());
@@ -178,7 +174,6 @@ bool CpCertificatesDatabase::isValidCertificateInstalled()
     if (m_list_query)
     {
         // Find valid certificates
-        m_list_query->reset();
         m_list_query->bind(0, static_cast<int64_t>(DateTime::now().timestamp()));
         m_list_query->bind(1, static_cast<int64_t>(DateTime::now().timestamp()));
         ret = (m_list_query->exec() && m_list_query->hasRows());
@@ -198,7 +193,6 @@ std::string CpCertificatesDatabase::getChargePointCertificate(std::string& priva
     if (m_list_query)
     {
         // Find valid certificates
-        m_list_query->reset();
         m_list_query->bind(0, static_cast<int64_t>(DateTime::now().timestamp()));
         m_list_query->bind(1, static_cast<int64_t>(DateTime::now().timestamp()));
         if (m_list_query->exec() && m_list_query->hasRows())
diff --git a/src/chargepoint/security/SecurityLogsDatabase.cpp b/src/chargepoint/security/SecurityLogsDatabase.cpp
@@ -47,7 +47,6 @@ bool SecurityLogsDatabase::log(const std::string& type, const std::string& messa
 
     if (m_insert_query)
     {
-        m_insert_query->reset();
         m_insert_query->bind(0, static_cast<int64_t>(timestamp));
         m_insert_query->bind(1, type);
         m_insert_query->bind(2, message);
@@ -57,6 +56,7 @@ bool SecurityLogsDatabase::log(const std::string& type, const std::string& messa
         {
             LOG_ERROR << "Unable to store security log : " << m_insert_query->lastError();
         }
+        m_insert_query->reset();
     }
 
     return ret;
@@ -69,12 +69,12 @@ bool SecurityLogsDatabase::clear()
 
     if (m_clear_query)
     {
-        m_clear_query->reset();
         ret = m_clear_query->exec();
         if (!ret)
         {
             LOG_ERROR << "Unable to clear security logs : " << m_clear_query->lastError();
         }
+        m_clear_query->reset();
     }
 
     return ret;
diff --git a/src/chargepoint/smartcharging/ProfileDatabase.cpp b/src/chargepoint/smartcharging/ProfileDatabase.cpp
@@ -98,9 +98,9 @@ bool ProfileDatabase::clear(ocpp::types::Optional<int>
                 // Erase from database
                 if (m_delete_query)
                 {
-                    m_delete_query->reset();
                     m_delete_query->bind(0, id);
                     m_delete_query->exec();
+                    m_delete_query->reset();
                 }
                 ret = true;
                 break;
@@ -157,9 +157,9 @@ bool ProfileDatabase::clear(ocpp::types::Optional<int>
                 // Erase in database
                 if (m_delete_query)
                 {
-                    m_delete_query->reset();
                     m_delete_query->bind(0, iter->second.chargingProfileId);
                     m_delete_query->exec();
+                    m_delete_query->reset();
                 }
 
                 // Erase in list
@@ -212,9 +212,9 @@ bool ProfileDatabase::install(unsigned int connector_id, const ocpp::types::Char
         // Erase existing profile
         if (m_delete_query)
         {
-            m_delete_query->reset();
             m_delete_query->bind(0, iter_profile->second.chargingProfileId);
             m_delete_query->exec();
+            m_delete_query->reset();
         }
         profiles_list->erase(iter_profile);
     }
@@ -233,11 +233,11 @@ bool ProfileDatabase::install(unsigned int connector_id, const ocpp::types::Char
             std::string profile_str = serialize(profile);
 
             // Insert
-            m_insert_query->reset();
             m_insert_query->bind(0, profile.chargingProfileId);
             m_insert_query->bind(1, connector_id);
             m_insert_query->bind(2, profile_str);
             m_insert_query->exec();
+            m_insert_query->reset();
         }
 
         ret = true;
diff --git a/src/config/InternalConfigManager.cpp b/src/config/InternalConfigManager.cpp
diff --git a/src/tools/log/LogDatabase.cpp b/src/tools/log/LogDatabase.cpp

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`cmake_minimum_required(VERSION 3.13)`
`6`	`6`
`7`	`7`	`project(OpenOCPP DESCRIPTION "Open Source C++ implementation of the OCPP 1.6 protocol"`
`8`		`- VERSION 1.5.2`
	`8`	`+ VERSION 1.5.3`
`9`	`9`	`)`
`10`	`10`
`11`	`11`	`# Definitions for Version.h file`
Original file line number	Diff line number	Diff line change
`@@ -51,14 +51,14 @@ bool ChargePointDatabase::addChargePoint(const std::string& identifier,`
`51`	`51`
`52`	`52`	`if (m_insert_query)`
`53`	`53`	`{`
`54`		`- m_insert_query->reset();`
`55`	`54`	`m_insert_query->bind(0, identifier);`
`56`	`55`	`m_insert_query->bind(1, serial_number);`
`57`	`56`	`m_insert_query->bind(2, vendor);`
`58`	`57`	`m_insert_query->bind(3, model);`
`59`	`58`	`m_insert_query->bind(4, security_profile);`
`60`	`59`	`m_insert_query->bind(5, authent_key);`
`61`	`60`	`ret = m_insert_query->exec();`
	`61`	`+ m_insert_query->reset();`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`return ret;`
`@@ -74,7 +74,6 @@ bool ChargePointDatabase::getChargePoint(const std::string& identifier,`
`74`	`74`
`75`	`75`	`if (m_find_query)`
`76`	`76`	`{`
`77`		`- m_find_query->reset();`
`78`	`77`	`m_find_query->bind(0, identifier);`
`79`	`78`	`if (m_find_query->exec() && m_find_query->hasRows())`
`80`	`79`	`{`
`@@ -83,6 +82,7 @@ bool ChargePointDatabase::getChargePoint(const std::string& identifier,`
`83`	`82`	`authent_key = m_find_query->getString(5);`
`84`	`83`	`ret = true;`
`85`	`84`	`}`
	`85`	`+ m_find_query->reset();`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`return ret;`
`@@ -95,10 +95,10 @@ bool ChargePointDatabase::setChargePointProfile(const std::string& identifier, u`
`95`	`95`
`96`	`96`	`if (m_update_profile_query)`
`97`	`97`	`{`
`98`		`- m_update_profile_query->reset();`
`99`	`98`	`m_update_profile_query->bind(0, security_profile);`
`100`	`99`	`m_update_profile_query->bind(1, identifier);`
`101`	`100`	`ret = m_update_profile_query->exec();`
	`101`	`+ m_update_profile_query->reset();`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`return ret;`
Original file line number	Diff line number	Diff line change
`@@ -130,9 +130,9 @@ bool AuthentCache::check(const std::string& id_tag, ocpp::types::IdTagInfo& tag_`
`130`	`130`	`// Entry is no more valid, delete entry`
`131`	`131`	`if (m_delete_query)`
`132`	`132`	`{`
`133`		`- m_delete_query->reset();`
`134`	`133`	`m_delete_query->bind(0, id_tag);`
`135`	`134`	`m_delete_query->exec();`
	`135`	`+ m_delete_query->reset();`
`136`	`136`	`}`
`137`	`137`	`ret = false;`
`138`	`138`	`}`
Original file line number	Diff line number	Diff line change
`@@ -230,7 +230,6 @@ bool Connectors::loadConnector(Connector& connector)`
`230`	`230`
`231`	`231`	`if (m_find_query)`
`232`	`232`	`{`
`233`		`- m_find_query->reset();`
`234`	`233`	`m_find_query->bind(0, connector.id);`
`235`	`234`	`ret = m_find_query->exec();`
`236`	`235`	`if (ret)`
`@@ -272,6 +271,7 @@ bool Connectors::loadConnector(Connector& connector)`
`272`	`271`	`{`
`273`	`272`	`LOG_ERROR << "Could not search for connector " << connector.id << " : " << m_find_query->lastError();`
`274`	`273`	`}`
	`274`	`+ m_find_query->reset();`
`275`	`275`	`}`
`276`	`276`
`277`	`277`	`return ret;`
`@@ -284,7 +284,6 @@ bool Connectors::saveConnector(const Connector& connector)`
`284`	`284`
`285`	`285`	`if (m_update_query)`
`286`	`286`	`{`
`287`		`- m_update_query->reset();`
`288`	`287`	`m_update_query->bind(0u, static_cast<int>(connector.status));`
`289`	`288`	`m_update_query->bind(1u, static_cast<int>(connector.last_notified_status));`
`290`	`289`	`m_update_query->bind(2u, connector.transaction_id);`
`@@ -306,6 +305,7 @@ bool Connectors::saveConnector(const Connector& connector)`
`306`	`305`	`{`
`307`	`306`	`LOG_ERROR << "Could not update connector " << connector.id << " : " << m_update_query->lastError();`
`308`	`307`	`}`
	`308`	`+ m_update_query->reset();`
`309`	`309`	`}`
`310`	`310`
`311`	`311`	`return ret;`
`@@ -318,7 +318,6 @@ bool Connectors::createConnector(const Connector& connector)`
`318`	`318`
`319`	`319`	`if (m_insert_query)`
`320`	`320`	`{`
`321`		`- m_insert_query->reset();`
`322`	`321`	`m_insert_query->bind(0u, connector.id);`
`323`	`322`	`m_insert_query->bind(1u, static_cast<int>(connector.status));`
`324`	`323`	`m_insert_query->bind(2u, static_cast<int>(connector.last_notified_status));`
`@@ -340,6 +339,7 @@ bool Connectors::createConnector(const Connector& connector)`
`340`	`339`	`{`
`341`	`340`	`LOG_ERROR << "Could not create connector " << connector.id << " : " << m_insert_query->lastError();`
`342`	`341`	`}`
	`342`	`+ m_insert_query->reset();`
`343`	`343`	`}`
`344`	`344`
`345`	`345`	`return ret;`
Original file line number	Diff line number	Diff line change
`@@ -158,7 +158,6 @@ void MeterValuesManager::getTxStopMeterValues(unsigned int connector_id, std::ve`
`158`	`158`	`{`
`159`	`159`	`// Get data from database`
`160`	`160`	`meter_values.clear();`
`161`		`- m_find_query->reset();`
`162`	`161`	`m_find_query->bind(0, connector->transaction_id);`
`163`	`162`	`if (m_find_query->exec() && m_find_query->hasRows())`
`164`	`163`	`{`
`@@ -175,12 +174,14 @@ void MeterValuesManager::getTxStopMeterValues(unsigned int connector_id, std::ve`
`175`	`174`	`meter_values.pop_back();`
`176`	`175`	`}`
`177`	`176`	`} while (m_find_query->next());`
	`177`	`+ m_find_query->reset();`
`178`	`178`
`179`	`179`	`// Clear data from database`
`180`		`- m_delete_query->reset();`
`181`	`180`	`m_delete_query->bind(0, connector->transaction_id);`
`182`	`181`	`m_delete_query->exec();`
	`182`	`+ m_delete_query->reset();`
`183`	`183`	`}`
	`184`	`+ m_find_query->reset();`
`184`	`185`	`}`
`185`	`186`	`}`
`186`	`187`
`@@ -335,10 +336,10 @@ void MeterValuesManager::processClockAligned(void)`
`335`	`336`	`std::string meter_value_str = serialize(meter_value);`
`336`	`337`
`337`	`338`	`// Store into database`
`338`		`- m_insert_query->reset();`
`339`	`339`	`m_insert_query->bind(0u, connector->transaction_id);`
`340`	`340`	`m_insert_query->bind(1u, meter_value_str);`
`341`	`341`	`m_insert_query->exec();`
	`342`	`+ m_insert_query->reset();`
`342`	`343`	`}`
`343`	`344`	`}`
`344`	`345`	`}`
`@@ -385,10 +386,10 @@ void MeterValuesManager::processSampled(unsigned int connector_id)`
`385`	`386`	`std::string meter_value_str = serialize(meter_value);`
`386`	`387`
`387`	`388`	`// Store into database`
`388`		`- m_insert_query->reset();`
`389`	`389`	`m_insert_query->bind(0u, connector->transaction_id);`
`390`	`390`	`m_insert_query->bind(1u, meter_value_str);`
`391`	`391`	`m_insert_query->exec();`
	`392`	`+ m_insert_query->reset();`
`392`	`393`	`}`
`393`	`394`	`}`
`394`	`395`	`}`
`@@ -573,9 +574,9 @@ void MeterValuesManager::initDatabaseTable()`
`573`	`574`	`if (!found && m_delete_query)`
`574`	`575`	`{`
`575`	`576`	`LOG_INFO << "Cleaning meter values associated to not ongoing transaction : " << transaction_id;`
`576`		`- m_delete_query->reset();`
`577`	`577`	`m_delete_query->bind(0, transaction_id);`
`578`	`578`	`m_delete_query->exec();`
	`579`	`+ m_delete_query->reset();`
`579`	`580`	`}`
`580`	`581`	`} while (query->next());`
`581`	`582`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,12 +53,12 @@ void RequestFifo::push(unsigned int connector_id, const std::string& action, con`
`53`	`53`	`m_fifo.emplace(m_id, connector_id, action, request);`
`54`	`54`	`if (m_insert_query)`
`55`	`55`	`{`
`56`		`- m_insert_query->reset();`
`57`	`56`	`m_insert_query->bind(0, m_id);`
`58`	`57`	`m_insert_query->bind(1, connector_id);`
`59`	`58`	`m_insert_query->bind(2, action);`
`60`	`59`	`m_insert_query->bind(3, request);`
`61`	`60`	`m_insert_query->exec();`
	`61`	`+ m_insert_query->reset();`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`// Prepare for next entry`
`@@ -105,9 +105,9 @@ void RequestFifo::pop()`
`105`	`105`	`m_fifo.pop();`
`106`	`106`	`if (m_delete_query)`
`107`	`107`	`{`
`108`		`- m_delete_query->reset();`
`109`	`108`	`m_delete_query->bind(0, id);`
`110`	`109`	`m_delete_query->exec();`
	`110`	`+ m_delete_query->reset();`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`
Original file line number	Diff line number	Diff line change
`@@ -100,11 +100,10 @@ void CpCertificatesDatabase::saveCertificateRequest(const ocpp::x509::Certificat`
`100`	`100`	`if (m_delete_csr_query && m_insert_csr_query)`
`101`	`101`	`{`
`102`	`102`	`// Delete any existing request`
`103`		`- m_delete_csr_query->reset();`
`104`	`103`	`m_delete_csr_query->exec();`
	`104`	`+ m_delete_csr_query->reset();`
`105`	`105`
`106`	`106`	`// Insert new request`
`107`		`- m_insert_csr_query->reset();`
`108`	`107`	`m_insert_csr_query->bind(0, certificate_request.pem());`
`109`	`108`	`m_insert_csr_query->bind(1, private_key.privatePem());`
`110`	`109`	`if (!m_insert_csr_query->exec())`
`@@ -113,7 +112,6 @@ void CpCertificatesDatabase::saveCertificateRequest(const ocpp::x509::Certificat`
`113`	`112`	`}`
`114`	`113`
`115`	`114`	`// Reset all queries`
`116`		`- m_delete_csr_query->reset();`
`117`	`115`	`m_insert_csr_query->reset();`
`118`	`116`	`}`
`119`	`117`	`}`
`@@ -126,7 +124,6 @@ std::string CpCertificatesDatabase::getCertificateRequest(unsigned int& id)`
`126`	`124`	`if (m_find_csr_query)`
`127`	`125`	`{`
`128`	`126`	`// Look for the certificate request`
`129`		`- m_find_csr_query->reset();`
`130`	`127`	`if (m_find_csr_query->exec())`
`131`	`128`	`{`
`132`	`129`	`// Read data`
`@@ -149,7 +146,6 @@ bool CpCertificatesDatabase::installCertificate(unsigned int request_id, const o`
`149`	`146`	`if (m_update_csr_to_cert_query)`
`150`	`147`	`{`
`151`	`148`	`// Install certificate`
`152`		`- m_update_csr_to_cert_query->reset();`
`153`	`149`	`m_update_csr_to_cert_query->bind(0, static_cast<int64_t>(certificate.validityFrom()));`
`154`	`150`	`m_update_csr_to_cert_query->bind(1, static_cast<int64_t>(certificate.validityTo()));`
`155`	`151`	`m_update_csr_to_cert_query->bind(2, certificate.pem());`
`@@ -178,7 +174,6 @@ bool CpCertificatesDatabase::isValidCertificateInstalled()`
`178`	`174`	`if (m_list_query)`
`179`	`175`	`{`
`180`	`176`	`// Find valid certificates`
`181`		`- m_list_query->reset();`
`182`	`177`	`m_list_query->bind(0, static_cast<int64_t>(DateTime::now().timestamp()));`
`183`	`178`	`m_list_query->bind(1, static_cast<int64_t>(DateTime::now().timestamp()));`
`184`	`179`	`ret = (m_list_query->exec() && m_list_query->hasRows());`
`@@ -198,7 +193,6 @@ std::string CpCertificatesDatabase::getChargePointCertificate(std::string& priva`
`198`	`193`	`if (m_list_query)`
`199`	`194`	`{`
`200`	`195`	`// Find valid certificates`
`201`		`- m_list_query->reset();`
`202`	`196`	`m_list_query->bind(0, static_cast<int64_t>(DateTime::now().timestamp()));`
`203`	`197`	`m_list_query->bind(1, static_cast<int64_t>(DateTime::now().timestamp()));`
`204`	`198`	`if (m_list_query->exec() && m_list_query->hasRows())`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,6 @@ bool SecurityLogsDatabase::log(const std::string& type, const std::string& messa`
`47`	`47`
`48`	`48`	`if (m_insert_query)`
`49`	`49`	`{`
`50`		`- m_insert_query->reset();`
`51`	`50`	`m_insert_query->bind(0, static_cast<int64_t>(timestamp));`
`52`	`51`	`m_insert_query->bind(1, type);`
`53`	`52`	`m_insert_query->bind(2, message);`
`@@ -57,6 +56,7 @@ bool SecurityLogsDatabase::log(const std::string& type, const std::string& messa`
`57`	`56`	`{`
`58`	`57`	`LOG_ERROR << "Unable to store security log : " << m_insert_query->lastError();`
`59`	`58`	`}`
	`59`	`+ m_insert_query->reset();`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`return ret;`
`@@ -69,12 +69,12 @@ bool SecurityLogsDatabase::clear()`
`69`	`69`
`70`	`70`	`if (m_clear_query)`
`71`	`71`	`{`
`72`		`- m_clear_query->reset();`
`73`	`72`	`ret = m_clear_query->exec();`
`74`	`73`	`if (!ret)`
`75`	`74`	`{`
`76`	`75`	`LOG_ERROR << "Unable to clear security logs : " << m_clear_query->lastError();`
`77`	`76`	`}`
	`77`	`+ m_clear_query->reset();`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`return ret;`
Original file line number	Diff line number	Diff line change
`@@ -98,9 +98,9 @@ bool ProfileDatabase::clear(ocpp::types::Optional<int>`
`98`	`98`	`// Erase from database`
`99`	`99`	`if (m_delete_query)`
`100`	`100`	`{`
`101`		`- m_delete_query->reset();`
`102`	`101`	`m_delete_query->bind(0, id);`
`103`	`102`	`m_delete_query->exec();`
	`103`	`+ m_delete_query->reset();`
`104`	`104`	`}`
`105`	`105`	`ret = true;`
`106`	`106`	`break;`
`@@ -157,9 +157,9 @@ bool ProfileDatabase::clear(ocpp::types::Optional<int>`
`157`	`157`	`// Erase in database`
`158`	`158`	`if (m_delete_query)`
`159`	`159`	`{`
`160`		`- m_delete_query->reset();`
`161`	`160`	`m_delete_query->bind(0, iter->second.chargingProfileId);`
`162`	`161`	`m_delete_query->exec();`
	`162`	`+ m_delete_query->reset();`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`// Erase in list`
`@@ -212,9 +212,9 @@ bool ProfileDatabase::install(unsigned int connector_id, const ocpp::types::Char`
`212`	`212`	`// Erase existing profile`
`213`	`213`	`if (m_delete_query)`
`214`	`214`	`{`
`215`		`- m_delete_query->reset();`
`216`	`215`	`m_delete_query->bind(0, iter_profile->second.chargingProfileId);`
`217`	`216`	`m_delete_query->exec();`
	`217`	`+ m_delete_query->reset();`
`218`	`218`	`}`
`219`	`219`	`profiles_list->erase(iter_profile);`
`220`	`220`	`}`
`@@ -233,11 +233,11 @@ bool ProfileDatabase::install(unsigned int connector_id, const ocpp::types::Char`
`233`	`233`	`std::string profile_str = serialize(profile);`
`234`	`234`
`235`	`235`	`// Insert`
`236`		`- m_insert_query->reset();`
`237`	`236`	`m_insert_query->bind(0, profile.chargingProfileId);`
`238`	`237`	`m_insert_query->bind(1, connector_id);`
`239`	`238`	`m_insert_query->bind(2, profile_str);`
`240`	`239`	`m_insert_query->exec();`
	`240`	`+ m_insert_query->reset();`
`241`	`241`	`}`
`242`	`242`
`243`	`243`	`ret = true;`