diff --git a/catalogue/3.0/mysql_catalogue_schema.sql b/catalogue/3.0/mysql_catalogue_schema.sql
index dcac6016cb89b5b59f44a434c6c230f3a2765ecf..b236e948620088c3826fb3682bc35dde8e4cd45d 100644
--- a/catalogue/3.0/mysql_catalogue_schema.sql
+++ b/catalogue/3.0/mysql_catalogue_schema.sql
@@ -33,7 +33,9 @@ CREATE TABLE CTA_CATALOGUE(
SCHEMA_VERSION_MINOR BIGINT UNSIGNED CONSTRAINT CTA_CATALOGUE_SVM2_NN NOT NULL,
NEXT_SCHEMA_VERSION_MAJOR BIGINT UNSIGNED,
NEXT_SCHEMA_VERSION_MINOR BIGINT UNSIGNED,
- STATUS VARCHAR(100)
+ STATUS VARCHAR(100),
+ IS_PRODUCTION CHAR(1) DEFAULT '0' CONSTRAINT CTA_CATALOGUE_IP_NN NOT NULL,
+ CONSTRAINT CTA_CATALOGUE_IP_BOOL_CK CHECK(IS_PRODUCTION IN ('0','1'))
);
CREATE TABLE ADMIN_USER(
ADMIN_USER_NAME VARCHAR(100) CONSTRAINT ADMIN_USER_AUN_NN NOT NULL,
diff --git a/catalogue/3.0/oracle_catalogue_schema.sql b/catalogue/3.0/oracle_catalogue_schema.sql
index 82459ed1ec59e755490592b74af750f647c9631d..11dd0659ca578e315a91725c90d01e2086104e93 100644
--- a/catalogue/3.0/oracle_catalogue_schema.sql
+++ b/catalogue/3.0/oracle_catalogue_schema.sql
@@ -62,7 +62,9 @@ CREATE TABLE CTA_CATALOGUE(
SCHEMA_VERSION_MINOR NUMERIC(20, 0) CONSTRAINT CTA_CATALOGUE_SVM2_NN NOT NULL,
NEXT_SCHEMA_VERSION_MAJOR NUMERIC(20, 0),
NEXT_SCHEMA_VERSION_MINOR NUMERIC(20, 0),
- STATUS VARCHAR2(100)
+ STATUS VARCHAR2(100),
+ IS_PRODUCTION CHAR(1) DEFAULT '0' CONSTRAINT CTA_CATALOGUE_IP_NN NOT NULL,
+ CONSTRAINT CTA_CATALOGUE_IP_BOOL_CK CHECK(IS_PRODUCTION IN ('0','1'))
);
CREATE TABLE ADMIN_USER(
ADMIN_USER_NAME VARCHAR2(100) CONSTRAINT ADMIN_USER_AUN_NN NOT NULL,
diff --git a/catalogue/3.0/postgres_catalogue_schema.sql b/catalogue/3.0/postgres_catalogue_schema.sql
index 00f49e130ce6c8bd8f45f30fbde26839f4f5089d..e0c29901f61782721d5c8fdc765bebdf54259e96 100644
--- a/catalogue/3.0/postgres_catalogue_schema.sql
+++ b/catalogue/3.0/postgres_catalogue_schema.sql
@@ -45,7 +45,9 @@ CREATE TABLE CTA_CATALOGUE(
SCHEMA_VERSION_MINOR NUMERIC(20, 0) CONSTRAINT CTA_CATALOGUE_SVM2_NN NOT NULL,
NEXT_SCHEMA_VERSION_MAJOR NUMERIC(20, 0),
NEXT_SCHEMA_VERSION_MINOR NUMERIC(20, 0),
- STATUS VARCHAR(100)
+ STATUS VARCHAR(100),
+ IS_PRODUCTION CHAR(1) DEFAULT '0' CONSTRAINT CTA_CATALOGUE_IP_NN NOT NULL,
+ CONSTRAINT CTA_CATALOGUE_IP_BOOL_CK CHECK(IS_PRODUCTION IN ('0','1'))
);
CREATE TABLE ADMIN_USER(
ADMIN_USER_NAME VARCHAR(100) CONSTRAINT ADMIN_USER_AUN_NN NOT NULL,
diff --git a/catalogue/3.0/sqlite_catalogue_schema.sql b/catalogue/3.0/sqlite_catalogue_schema.sql
index 26da00179c9de142adc9af3017e1e4613680040e..f6d8fc0c85861e3f18f1ab4eed49b7d93fe0c28e 100644
--- a/catalogue/3.0/sqlite_catalogue_schema.sql
+++ b/catalogue/3.0/sqlite_catalogue_schema.sql
@@ -21,7 +21,9 @@ CREATE TABLE CTA_CATALOGUE(
SCHEMA_VERSION_MINOR INTEGER CONSTRAINT CTA_CATALOGUE_SVM2_NN NOT NULL,
NEXT_SCHEMA_VERSION_MAJOR INTEGER,
NEXT_SCHEMA_VERSION_MINOR INTEGER,
- STATUS VARCHAR(100)
+ STATUS VARCHAR(100),
+ IS_PRODUCTION CHAR(1) DEFAULT '0' CONSTRAINT CTA_CATALOGUE_IP_NN NOT NULL,
+ CONSTRAINT CTA_CATALOGUE_IP_BOOL_CK CHECK(IS_PRODUCTION IN ('0','1'))
);
CREATE TABLE ADMIN_USER(
ADMIN_USER_NAME VARCHAR(100) CONSTRAINT ADMIN_USER_AUN_NN NOT NULL,
diff --git a/catalogue/AllCatalogueSchema.hpp b/catalogue/AllCatalogueSchema.hpp
index e4563f3f8f0990513dc19d41240506975b372c9a..3a5b25001cedee23b6e2586e07672654add45603 100644
--- a/catalogue/AllCatalogueSchema.hpp
+++ b/catalogue/AllCatalogueSchema.hpp
@@ -3866,7 +3866,9 @@ namespace catalogue{
" SCHEMA_VERSION_MINOR NUMERIC(20, 0) CONSTRAINT CTA_CATALOGUE_SVM2_NN NOT NULL,"
" NEXT_SCHEMA_VERSION_MAJOR NUMERIC(20, 0),"
" NEXT_SCHEMA_VERSION_MINOR NUMERIC(20, 0),"
- " STATUS VARCHAR2(100)"
+ " STATUS VARCHAR2(100),"
+ " IS_PRODUCTION CHAR(1) DEFAULT '0' CONSTRAINT CTA_CATALOGUE_IP_NN NOT NULL,"
+ " CONSTRAINT CTA_CATALOGUE_IP_BOOL_CK CHECK(IS_PRODUCTION IN ('0','1'))"
");"
"CREATE TABLE ADMIN_USER("
" ADMIN_USER_NAME VARCHAR2(100) CONSTRAINT ADMIN_USER_AUN_NN NOT NULL,"
@@ -4266,7 +4268,9 @@ namespace catalogue{
" SCHEMA_VERSION_MINOR BIGINT UNSIGNED CONSTRAINT CTA_CATALOGUE_SVM2_NN NOT NULL,"
" NEXT_SCHEMA_VERSION_MAJOR BIGINT UNSIGNED,"
" NEXT_SCHEMA_VERSION_MINOR BIGINT UNSIGNED,"
- " STATUS VARCHAR(100)"
+ " STATUS VARCHAR(100),"
+ " IS_PRODUCTION CHAR(1) DEFAULT '0' CONSTRAINT CTA_CATALOGUE_IP_NN NOT NULL,"
+ " CONSTRAINT CTA_CATALOGUE_IP_BOOL_CK CHECK(IS_PRODUCTION IN ('0','1'))"
");"
"CREATE TABLE ADMIN_USER("
" ADMIN_USER_NAME VARCHAR(100) CONSTRAINT ADMIN_USER_AUN_NN NOT NULL,"
@@ -4653,7 +4657,9 @@ namespace catalogue{
" SCHEMA_VERSION_MINOR INTEGER CONSTRAINT CTA_CATALOGUE_SVM2_NN NOT NULL,"
" NEXT_SCHEMA_VERSION_MAJOR INTEGER,"
" NEXT_SCHEMA_VERSION_MINOR INTEGER,"
- " STATUS VARCHAR(100)"
+ " STATUS VARCHAR(100),"
+ " IS_PRODUCTION CHAR(1) DEFAULT '0' CONSTRAINT CTA_CATALOGUE_IP_NN NOT NULL,"
+ " CONSTRAINT CTA_CATALOGUE_IP_BOOL_CK CHECK(IS_PRODUCTION IN ('0','1'))"
");"
"CREATE TABLE ADMIN_USER("
" ADMIN_USER_NAME VARCHAR(100) CONSTRAINT ADMIN_USER_AUN_NN NOT NULL,"
@@ -5062,7 +5068,9 @@ namespace catalogue{
" SCHEMA_VERSION_MINOR NUMERIC(20, 0) CONSTRAINT CTA_CATALOGUE_SVM2_NN NOT NULL,"
" NEXT_SCHEMA_VERSION_MAJOR NUMERIC(20, 0),"
" NEXT_SCHEMA_VERSION_MINOR NUMERIC(20, 0),"
- " STATUS VARCHAR(100)"
+ " STATUS VARCHAR(100),"
+ " IS_PRODUCTION CHAR(1) DEFAULT '0' CONSTRAINT CTA_CATALOGUE_IP_NN NOT NULL,"
+ " CONSTRAINT CTA_CATALOGUE_IP_BOOL_CK CHECK(IS_PRODUCTION IN ('0','1'))"
");"
"CREATE TABLE ADMIN_USER("
" ADMIN_USER_NAME VARCHAR(100) CONSTRAINT ADMIN_USER_AUN_NN NOT NULL,"
diff --git a/catalogue/CMakeLists.txt b/catalogue/CMakeLists.txt
index b67b276fe9c47a208964fdf7c620c567864b8d56..fea9123a2716d25b4676b63ea0806da7212c8367 100644
--- a/catalogue/CMakeLists.txt
+++ b/catalogue/CMakeLists.txt
@@ -104,7 +104,8 @@ install (TARGETS ctacatalogue DESTINATION usr/${CMAKE_INSTALL_LIBDIR})
target_link_libraries (ctacatalogue
ctacommon
- ctardbms)
+ ctardbms
+)
include(${PROJECT_SOURCE_DIR}/cmake/CTAVersions.cmake)
@@ -258,6 +259,27 @@ add_executable(cta-catalogue-schema-create
PostgresCatalogueSchema.cpp
MysqlCatalogueSchema.cpp)
+set (SCHEMA_CHECKER_LIB_SRC_FILES
+ SQLiteSchemaInserter.cpp
+ SchemaSqlStatementsReader.cpp
+ SchemaComparer.cpp
+ SQLiteSchemaComparer.cpp
+ DbToSQLiteStatementTransformer.cpp
+ SchemaCheckerResult.cpp
+ SchemaChecker.cpp
+ DatabaseMetadataGetter.cpp
+ CatalogueSchema.cpp
+ OracleCatalogueSchema.cpp
+ SqliteCatalogueSchema.cpp
+ PostgresCatalogueSchema.cpp
+ MysqlCatalogueSchema.cpp
+)
+
+add_library (ctaschemachecker SHARED
+ ${SCHEMA_CHECKER_LIB_SRC_FILES})
+
+install (TARGETS ctaschemachecker DESTINATION usr/${CMAKE_INSTALL_LIBDIR})
+
target_link_libraries (cta-catalogue-schema-create ctacatalogue)
set_property(TARGET cta-catalogue-schema-create APPEND PROPERTY INSTALL_RPATH ${PROTOBUF3_RPATH})
set_property(TARGET cta-catalogue-schema-create APPEND PROPERTY INSTALL_RPATH ${ORACLE-INSTANTCLIENT_RPATH})
@@ -270,7 +292,7 @@ add_executable(cta-catalogue-schema-drop
DropSchemaCmdLineArgs.cpp
DropSchemaCmdMain.cpp)
-target_link_libraries (cta-catalogue-schema-drop ctacatalogue)
+target_link_libraries (cta-catalogue-schema-drop ctacatalogue ctaschemachecker)
set_property(TARGET cta-catalogue-schema-drop APPEND PROPERTY INSTALL_RPATH ${PROTOBUF3_RPATH})
set_property(TARGET cta-catalogue-schema-drop APPEND PROPERTY INSTALL_RPATH ${ORACLE-INSTANTCLIENT_RPATH})
@@ -301,27 +323,6 @@ set_property(TARGET cta-catalogue-admin-user-create APPEND PROPERTY INSTALL_RPAT
install(TARGETS cta-catalogue-admin-user-create DESTINATION /usr/bin)
install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/cta-catalogue-admin-user-create.1cta DESTINATION /usr/share/man/man1)
-set (SCHEMA_CHECKER_LIB_SRC_FILES
- SQLiteSchemaInserter.cpp
- SchemaSqlStatementsReader.cpp
- SchemaComparer.cpp
- SQLiteSchemaComparer.cpp
- DbToSQLiteStatementTransformer.cpp
- SchemaComparerResult.cpp
- SchemaChecker.cpp
- DatabaseMetadataGetter.cpp
- CatalogueSchema.cpp
- OracleCatalogueSchema.cpp
- SqliteCatalogueSchema.cpp
- PostgresCatalogueSchema.cpp
- MysqlCatalogueSchema.cpp
-)
-
-add_library (ctaschemachecker SHARED
- ${SCHEMA_CHECKER_LIB_SRC_FILES})
-
-install (TARGETS ctaschemachecker DESTINATION usr/${CMAKE_INSTALL_LIBDIR})
-
add_executable(cta-catalogue-schema-verify
VerifySchemaCmd.cpp
VerifySchemaCmdLineArgs.cpp
diff --git a/catalogue/DropSchemaCmd.cpp b/catalogue/DropSchemaCmd.cpp
index 63a65b967e045e6432ac2f7adfbf882d87e4b051..187c096f5bf8f46b11eb74ae3d4eef574b1568c3 100644
--- a/catalogue/DropSchemaCmd.cpp
+++ b/catalogue/DropSchemaCmd.cpp
@@ -20,6 +20,7 @@
#include "catalogue/DropSchemaCmdLineArgs.hpp"
#include "common/exception/Exception.hpp"
#include "rdbms/ConnPool.hpp"
+#include "catalogue/SchemaChecker.hpp"
#include <algorithm>
@@ -65,6 +66,12 @@ int DropSchemaCmd::exceptionThrowingMain(const int argc, char *const *const argv
return 0;
}
+ if(isProductionProtectionCheckable(conn,dbLogin.dbType)){
+ if(isProductionSet(conn)){
+ throw cta::exception::Exception("Cannot drop a production database. If you still wish to proceed then please modify the database manually to remove its production status before trying again.");
+ }
+ }
+
if(userConfirmsDropOfSchema(dbLogin)) {
m_out << "DROPPING the schema of the CTA calalogue database" << std::endl;
dropCatalogueSchema(dbLogin.dbType, conn);
@@ -351,6 +358,28 @@ void DropSchemaCmd::dropDatabaseSequences(rdbms::Conn &conn, const std::list<std
}
}
+bool DropSchemaCmd::isProductionSet(cta::rdbms::Conn & conn){
+ const char * const sql = "SELECT CTA_CATALOGUE.IS_PRODUCTION AS IS_PRODUCTION FROM CTA_CATALOGUE";
+ auto stmt = conn.createStmt(sql);
+ auto rset = stmt.executeQuery();
+ if(rset.next()){
+ return rset.columnBool("IS_PRODUCTION");
+ }
+ //We should never arrive here
+ throw cta::exception::Exception("Cannot check the IS_PRODUCTION bit because the CTA_CATALOGUE table is empty or does not exist.");
+}
+
+
+bool DropSchemaCmd::isProductionProtectionCheckable(rdbms::Conn& conn, const cta::rdbms::Login::DbType dbType) {
+ cta::catalogue::SchemaChecker::Builder builder("catalogue",dbType,conn);
+ auto checker = builder.build();
+ SchemaCheckerResult res = checker->checkTableContainsColumns("CTA_CATALOGUE",{"IS_PRODUCTION"});
+ if(res.getStatus() == SchemaCheckerResult::Status::FAILED){
+ return false;
+ }
+ return true;
+}
+
//------------------------------------------------------------------------------
// printUsage
//------------------------------------------------------------------------------
diff --git a/catalogue/DropSchemaCmd.hpp b/catalogue/DropSchemaCmd.hpp
index 54da56020581ff5c69cb7537b190d73cafbe5343..e6806fe6297c804de7920b55de3d9d6b09fb9ce0 100644
--- a/catalogue/DropSchemaCmd.hpp
+++ b/catalogue/DropSchemaCmd.hpp
@@ -128,6 +128,21 @@ private:
* @param seqeuncesToDrop The names of the database sequences to be dropped.
*/
void dropDatabaseSequences(rdbms::Conn &conn, const std::list<std::string> &sequencesToDrop);
+
+ /**
+ * Checks if the IS_PRODUCTION bit is set on the CTA_CATALOGUE table
+ * @return true if the IS_PRODUCTION bit is set, false otherwise
+ */
+ bool isProductionSet(rdbms::Conn & conn);
+
+ /**
+ * Checks if we can check the IS_PRODUCTION bit. This allows the backward-compatibility of
+ * this tool if we use it against a schema that does not have the IS_PRODUCTION bit.
+ * @param conn the connection to the Catalogue database
+ * @param dbType the type of the Catalogue database
+ * @return true if the production bit is set, false otherwise
+ */
+ bool isProductionProtectionCheckable(rdbms::Conn & conn, const cta::rdbms::Login::DbType dbType);
}; // class DropSchemaCmd
diff --git a/catalogue/RdbmsCatalogue.cpp b/catalogue/RdbmsCatalogue.cpp
index 8172b35feb3edb0514c11c5ec32f5825bee0936e..530453216d5fa43b2b35bce87de743b82f539ae8 100644
--- a/catalogue/RdbmsCatalogue.cpp
+++ b/catalogue/RdbmsCatalogue.cpp
@@ -7971,16 +7971,16 @@ SchemaVersion RdbmsCatalogue::getSchemaVersion() const {
if(rset.next()) {
SchemaVersion::Builder schemaVersionBuilder;
- schemaVersionBuilder.schemaVersionMajor(rset.columnUint64("SCHEMA_VERSION_MAJOR"))
- .schemaVersionMinor(rset.columnUint64("SCHEMA_VERSION_MINOR"))
- .status(rset.columnString("STATUS"));
- auto schemaVersionMajorNext = rset.columnOptionalUint64("NEXT_SCHEMA_VERSION_MAJOR");
- auto schemaVersionMinorNext = rset.columnOptionalUint64("NEXT_SCHEMA_VERSION_MINOR");
- if(schemaVersionMajorNext && schemaVersionMinorNext){
- schemaVersionBuilder.nextSchemaVersionMajor(schemaVersionMajorNext.value())
- .nextSchemaVersionMinor(schemaVersionMinorNext.value());
- }
- return schemaVersionBuilder.build();
+ schemaVersionBuilder.schemaVersionMajor(rset.columnUint64("SCHEMA_VERSION_MAJOR"))
+ .schemaVersionMinor(rset.columnUint64("SCHEMA_VERSION_MINOR"))
+ .status(rset.columnString("STATUS"));
+ auto schemaVersionMajorNext = rset.columnOptionalUint64("NEXT_SCHEMA_VERSION_MAJOR");
+ auto schemaVersionMinorNext = rset.columnOptionalUint64("NEXT_SCHEMA_VERSION_MINOR");
+ if(schemaVersionMajorNext && schemaVersionMinorNext){
+ schemaVersionBuilder.nextSchemaVersionMajor(schemaVersionMajorNext.value())
+ .nextSchemaVersionMinor(schemaVersionMinorNext.value());
+ }
+ return schemaVersionBuilder.build();
} else {
throw exception::Exception("CTA_CATALOGUE does not contain any row");
}
diff --git a/catalogue/SQLiteSchemaComparer.cpp b/catalogue/SQLiteSchemaComparer.cpp
index 50dd9fb37e2b2e65da1979869b59fb4ef1bb2c1c..7526ade6e7ae9d0e3fafc86960bc3dbab2d9940d 100644
--- a/catalogue/SQLiteSchemaComparer.cpp
+++ b/catalogue/SQLiteSchemaComparer.cpp
@@ -43,23 +43,23 @@ SQLiteSchemaComparer::~SQLiteSchemaComparer() {
m_sqliteConnPool.reset();
}
-SchemaComparerResult SQLiteSchemaComparer::compareAll(){
+SchemaCheckerResult SQLiteSchemaComparer::compareAll(){
insertSchemaInSQLite();
- SchemaComparerResult res;
+ SchemaCheckerResult res;
res += compareTables();
res += compareIndexes();
return res;
}
-SchemaComparerResult SQLiteSchemaComparer::compareTables(){
+SchemaCheckerResult SQLiteSchemaComparer::compareTables(){
insertSchemaInSQLite();
std::list<std::string> catalogueTables = m_databaseMetadataGetter.getTableNames();
std::list<std::string> schemaTables = m_schemaMetadataGetter->getTableNames();
- SchemaComparerResult res = compareTables(catalogueTables,schemaTables);
+ SchemaCheckerResult res = compareTables(catalogueTables,schemaTables);
return res;
}
-SchemaComparerResult SQLiteSchemaComparer::compareTablesLocatedInSchema(){
+SchemaCheckerResult SQLiteSchemaComparer::compareTablesLocatedInSchema(){
insertSchemaInSQLite();
std::list<std::string> databaseTables = m_databaseMetadataGetter.getTableNames();
std::list<std::string> schemaTables = m_schemaMetadataGetter->getTableNames();
@@ -68,7 +68,7 @@ SchemaComparerResult SQLiteSchemaComparer::compareTablesLocatedInSchema(){
return schemaTable == catalogueTable;
}) == schemaTables.end();
});
- SchemaComparerResult res = compareTables(databaseTables,schemaTables);
+ SchemaCheckerResult res = compareTables(databaseTables,schemaTables);
return res;
}
@@ -84,30 +84,30 @@ void SQLiteSchemaComparer::insertSchemaInSQLite() {
m_isSchemaInserted = true;
}
-SchemaComparerResult SQLiteSchemaComparer::compareIndexes(){
+SchemaCheckerResult SQLiteSchemaComparer::compareIndexes(){
insertSchemaInSQLite();
std::list<std::string> catalogueIndexes = m_databaseMetadataGetter.getIndexNames();
std::list<std::string> schemaIndexes = m_schemaMetadataGetter->getIndexNames();
return compareItems("INDEX", catalogueIndexes, schemaIndexes);
}
-SchemaComparerResult SQLiteSchemaComparer::compareItems(const std::string &itemType, const std::list<std::string>& itemsFromDatabase, const std::list<std::string>& itemsFromSQLite){
- SchemaComparerResult result;
+SchemaCheckerResult SQLiteSchemaComparer::compareItems(const std::string &itemType, const std::list<std::string>& itemsFromDatabase, const std::list<std::string>& itemsFromSQLite){
+ SchemaCheckerResult result;
for(auto &databaseItem: itemsFromDatabase){
if(std::find(itemsFromSQLite.begin(),itemsFromSQLite.end(),databaseItem) == itemsFromSQLite.end()){
- result.addDiff(itemType+" "+databaseItem+" is missing in the schema but defined in the "+m_databaseToCheckName+" database.");
+ result.addError(itemType+" "+databaseItem+" is missing in the schema but defined in the "+m_databaseToCheckName+" database.");
}
}
for(auto &sqliteItem: itemsFromSQLite){
if(std::find(itemsFromDatabase.begin(),itemsFromDatabase.end(),sqliteItem) == itemsFromDatabase.end()){
- result.addDiff(itemType+" "+sqliteItem+" is missing in the "+m_databaseToCheckName+" database but is defined in the schema.");
+ result.addError(itemType+" "+sqliteItem+" is missing in the "+m_databaseToCheckName+" database but is defined in the schema.");
}
}
return result;
}
-SchemaComparerResult SQLiteSchemaComparer::compareTables(const std::list<std::string>& databaseTables, const std::list<std::string>& schemaTables){
- SchemaComparerResult result;
+SchemaCheckerResult SQLiteSchemaComparer::compareTables(const std::list<std::string>& databaseTables, const std::list<std::string>& schemaTables){
+ SchemaCheckerResult result;
std::map<std::string, std::map<std::string, std::string>> databaseTableColumns;
std::map<std::string, std::map<std::string, std::string>> schemaTableColumns;
std::map<std::string,std::list<std::string>> databaseTableConstraints;
@@ -132,8 +132,8 @@ SchemaComparerResult SQLiteSchemaComparer::compareTables(const std::list<std::st
return result;
}
-SchemaComparerResult SQLiteSchemaComparer::compareTableColumns(const TableColumns & schema1TableColumns, const std::string &schema1Type,const TableColumns & schema2TableColumns, const std::string &schema2Type){
- SchemaComparerResult result;
+SchemaCheckerResult SQLiteSchemaComparer::compareTableColumns(const TableColumns & schema1TableColumns, const std::string &schema1Type,const TableColumns & schema2TableColumns, const std::string &schema2Type){
+ SchemaCheckerResult result;
for(auto &kvFirstSchemaTableColumns: schema1TableColumns){
//For each firstSchema table, get the corresponding secondSchema table
//If it does not exist, add a difference and go ahead
@@ -149,14 +149,14 @@ SchemaComparerResult SQLiteSchemaComparer::compareTableColumns(const TableColumn
try {
std::string schemaColumnType = mapSchema2ColumnType.at(schema1ColumnName);
if( schema1ColumnType != schemaColumnType){
- result.addDiff("TABLE "+schema1TableName+" from "+schema1Type+" has a column named "+schema1ColumnName+" that has a type "+schema1ColumnType+" that does not match the column type from the "+schema2Type+" ("+schemaColumnType+")");
+ result.addError("TABLE "+schema1TableName+" from "+schema1Type+" has a column named "+schema1ColumnName+" that has a type "+schema1ColumnType+" that does not match the column type from the "+schema2Type+" ("+schemaColumnType+")");
}
} catch (const std::out_of_range &) {
- result.addDiff("TABLE "+schema1TableName+" from "+schema1Type+" has a column named " + schema1ColumnName + " that is missing in the "+schema2Type+".");
+ result.addError("TABLE "+schema1TableName+" from "+schema1Type+" has a column named " + schema1ColumnName + " that is missing in the "+schema2Type+".");
}
}
} catch (const std::out_of_range &) {
- result.addDiff("TABLE "+schema1TableName+" is missing in the "+schema2Type+" but is defined in the "+schema1Type+".");
+ result.addError("TABLE "+schema1TableName+" is missing in the "+schema2Type+" but is defined in the "+schema1Type+".");
}
}
return result;
diff --git a/catalogue/SQLiteSchemaComparer.hpp b/catalogue/SQLiteSchemaComparer.hpp
index 2f146938b75df50947d2422f3df9d972844be3e3..b501c0a6d59dc0daa212cee169a0a7ae381ccc8c 100644
--- a/catalogue/SQLiteSchemaComparer.hpp
+++ b/catalogue/SQLiteSchemaComparer.hpp
@@ -38,19 +38,19 @@ public:
* Compare the catalogue schema against the InMemory SQLite catalogue schema
* @return a SchemaComparerResult object that will contain the differences if there are some
*/
- SchemaComparerResult compareAll() override;
- SchemaComparerResult compareIndexes() override;
- SchemaComparerResult compareTables() override;
- SchemaComparerResult compareTablesLocatedInSchema() override;
+ SchemaCheckerResult compareAll() override;
+ SchemaCheckerResult compareIndexes() override;
+ SchemaCheckerResult compareTables() override;
+ SchemaCheckerResult compareTablesLocatedInSchema() override;
virtual ~SQLiteSchemaComparer();
private:
void insertSchemaInSQLite();
- SchemaComparerResult compareItems(const std::string &itemType, const std::list<std::string>& itemsFromDatabase, const std::list<std::string>& itemsFromSQLite);
- SchemaComparerResult compareTables(const std::list<std::string> &databaseTables, const std::list<std::string> &schemaTables);
+ SchemaCheckerResult compareItems(const std::string &itemType, const std::list<std::string>& itemsFromDatabase, const std::list<std::string>& itemsFromSQLite);
+ SchemaCheckerResult compareTables(const std::list<std::string> &databaseTables, const std::list<std::string> &schemaTables);
typedef std::map<std::string, std::map<std::string, std::string>> TableColumns;
- SchemaComparerResult compareTableColumns(const TableColumns & schema1TableColumns, const std::string &schema1Type,const TableColumns & schema2TableColumns, const std::string &schema2Type);
+ SchemaCheckerResult compareTableColumns(const TableColumns & schema1TableColumns, const std::string &schema1Type,const TableColumns & schema2TableColumns, const std::string &schema2Type);
rdbms::Conn m_sqliteConn;
std::unique_ptr<rdbms::ConnPool> m_sqliteConnPool;
std::unique_ptr<SchemaMetadataGetter> m_schemaMetadataGetter;
diff --git a/catalogue/SchemaChecker.cpp b/catalogue/SchemaChecker.cpp
index d671da69d99e807e32f09005b5d877c12abfea98..0721964913f88ead54691e89569c57069a035d72 100644
--- a/catalogue/SchemaChecker.cpp
+++ b/catalogue/SchemaChecker.cpp
@@ -36,71 +36,70 @@ void SchemaChecker::checkSchemaComparerNotNull(const std::string& methodName){
}
}
-SchemaChecker::Status SchemaChecker::compareSchema(){
- checkSchemaComparerNotNull(__PRETTY_FUNCTION__);
- SchemaComparerResult totalResult;
- std::cout << "Schema version : " << m_databaseMetadataGetter->getCatalogueVersion().getSchemaVersion<std::string>() << std::endl;
- std::cout << "Checking indexes..." << std::endl;
- cta::catalogue::SchemaComparerResult resIndex = m_schemaComparer->compareIndexes();
+SchemaCheckerResult SchemaChecker::displayingCompareSchema(std::ostream & stdOut, std::ostream & stdErr){
+ checkSchemaComparerNotNull(__PRETTY_FUNCTION__);
+ SchemaCheckerResult totalResult;
+ stdOut << "Schema version : " << m_databaseMetadataGetter->getCatalogueVersion().getSchemaVersion<std::string>() << std::endl;
+ stdOut << "Checking indexes..." << std::endl;
+ cta::catalogue::SchemaCheckerResult resIndex = m_schemaComparer->compareIndexes();
totalResult += resIndex;
- resIndex.printDiffs();
- std::cout <<" "<<resIndex.statusToString(resIndex.getStatus())<<std::endl;
+ resIndex.displayErrors(stdErr);
+ stdOut <<" "<<resIndex.statusToString(resIndex.getStatus())<<std::endl;
if(m_dbType == rdbms::Login::DbType::DBTYPE_MYSQL){
- std::cout << "Checking tables and columns..." << std::endl;
+ stdOut << "Checking tables and columns..." << std::endl;
} else {
- std::cout << "Checking tables, columns and constraints..." << std::endl;
+ stdOut << "Checking tables, columns and constraints..." << std::endl;
}
- cta::catalogue::SchemaComparerResult resTables = m_schemaComparer->compareTables();
+ cta::catalogue::SchemaCheckerResult resTables = m_schemaComparer->compareTables();
totalResult += resTables;
- resTables.printDiffs();
- std::cout <<" "<<resTables.statusToString(resTables.getStatus())<<std::endl;
- std::cout << "Status of the checking : " << cta::catalogue::SchemaComparerResult::statusToString(totalResult.getStatus()) << std::endl;
- if(totalResult.getStatus() == SchemaComparerResult::Status::FAILED){
- return SchemaChecker::FAILURE;
- }
- return SchemaChecker::OK;
+ resTables.displayErrors(stdErr);
+ stdOut <<" "<<resTables.statusToString(resTables.getStatus())<<std::endl;
+ stdOut << "Status of the checking : " << cta::catalogue::SchemaCheckerResult::statusToString(totalResult.getStatus()) << std::endl;
+ return totalResult;
}
-void SchemaChecker::checkNoParallelTables(){
+SchemaCheckerResult SchemaChecker::checkNoParallelTables(){
+ SchemaCheckerResult res;
std::list<std::string> parallelTables = m_databaseMetadataGetter->getParallelTableNames();
for(auto& table:parallelTables) {
- std::cout << "WARNING : TABLE " << table << " is set as PARALLEL" << std::endl;
+ std::string warning = "TABLE " + table + " is set as PARALLEL";
+ res.addWarning(warning);
}
+ return res;
}
-void SchemaChecker::checkSchemaNotUpgrading(){
+SchemaCheckerResult SchemaChecker::checkSchemaNotUpgrading(){
+ SchemaCheckerResult res;
SchemaVersion catalogueVersion = m_databaseMetadataGetter->getCatalogueVersion();
if(catalogueVersion.getStatus<SchemaVersion::Status>() == SchemaVersion::Status::UPGRADING){
- std::cout << "WARNING : The status of the schema is " << catalogueVersion.getStatus<std::string>() << ", the future version is " << catalogueVersion.getSchemaVersionNext<std::string>() << std::endl;
+ std::string warning = "The status of the schema is " + catalogueVersion.getStatus<std::string>() + ", the future version is " + catalogueVersion.getSchemaVersionNext<std::string>();
+ res.addWarning(warning);
}
+ return res;
}
-SchemaChecker::Status SchemaChecker::compareTablesLocatedInSchema(){
+SchemaCheckerResult SchemaChecker::compareTablesLocatedInSchema(){
checkSchemaComparerNotNull(__PRETTY_FUNCTION__);
- SchemaComparerResult res = m_schemaComparer->compareTablesLocatedInSchema();
- if(res.getStatus() == SchemaComparerResult::Status::FAILED){
- res.printDiffs();
- return SchemaChecker::Status::FAILURE;
- }
- return SchemaChecker::Status::OK;
+ return m_schemaComparer->compareTablesLocatedInSchema();
}
-SchemaChecker::Status SchemaChecker::checkTableContainsColumns(const std::string& tableName, const std::list<std::string> columnNames){
+SchemaCheckerResult SchemaChecker::checkTableContainsColumns(const std::string& tableName, const std::list<std::string> columnNames){
std::map<std::string, std::string> mapColumnsTypes = m_databaseMetadataGetter->getColumns(tableName);
- SchemaChecker::Status status = SchemaChecker::Status::OK;
+ SchemaCheckerResult res;
if(mapColumnsTypes.empty()){
- std::cerr << "TABLE " << tableName << " does not exist." << std::endl;
- return SchemaChecker::Status::FAILURE;
+ std::string error = "TABLE " + tableName +" does not exist.";
+ res.addError(error);
+ return res;
}
for(auto &columnName: columnNames){
try{
mapColumnsTypes.at(columnName);
} catch(std::out_of_range &){
- std::cerr << "TABLE " << tableName << " does not contain the column " << columnName << "."<< std::endl;
- status = SchemaChecker::Status::FAILURE;
+ std::string error = "TABLE " + tableName + " does not contain the column " + columnName + ".";
+ res.addError(error);
}
}
- return status;
+ return res;
}
/////////////////////////////////////////
@@ -139,6 +138,4 @@ std::unique_ptr<SchemaChecker> SchemaChecker::Builder::build() {
return std::move(schemaChecker);
}
-
-
}}
\ No newline at end of file
diff --git a/catalogue/SchemaChecker.hpp b/catalogue/SchemaChecker.hpp
index b499112f61076dcd1440447a949cbce465eaf304..381a27ce022d2101dfdfa4b0e794af5691e1cf56 100644
--- a/catalogue/SchemaChecker.hpp
+++ b/catalogue/SchemaChecker.hpp
@@ -21,6 +21,7 @@
#include "rdbms/Conn.hpp"
#include "SchemaComparer.hpp"
#include "CatalogueSchema.hpp"
+#include "SchemaCheckerResult.hpp"
namespace cta{
namespace catalogue{
@@ -39,43 +40,38 @@ namespace catalogue{
*/
class SchemaChecker {
public:
- /**
- * The status of the checking of the database
- */
- enum Status {
- OK,
- FAILURE
- };
/**
* Destructor
*/
virtual ~SchemaChecker();
/**
- * Compare the schema by using a SchemaComparer
+ * Compare the schema by using a SchemaComparer and output what it is doing and errors
* @throws Exception if no SchemaComparer has been set.
- * @return a Status : OK or FAILURE
+ * @return a SchemaCheckerResult
*/
- Status compareSchema();
+ SchemaCheckerResult displayingCompareSchema(std::ostream & stdout, std::ostream & stderr);
+
/**
* Checks if the catalogue database contains PARALLEL tables
* It will display a warning with the table name if this is the case
+ * @return a SchemaCheckerResult
*/
- void checkNoParallelTables();
+ SchemaCheckerResult checkNoParallelTables();
/**
* Checks if the catalogue database schema is upgrading or not
*/
- void checkSchemaNotUpgrading();
+ SchemaCheckerResult checkSchemaNotUpgrading();
/**
* Compare the schema tables whose names are located in the tableList parameter
* @param tableList the table names we would like to compare
* @return a Status OK or FAILURE
*/
- Status compareTablesLocatedInSchema();
+ SchemaCheckerResult compareTablesLocatedInSchema();
- Status checkTableContainsColumns(const std::string &tableName, const std::list<std::string> columnNames);
+ SchemaCheckerResult checkTableContainsColumns(const std::string &tableName, const std::list<std::string> columnNames);
class Builder {
public:
diff --git a/catalogue/SchemaCheckerResult.cpp b/catalogue/SchemaCheckerResult.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e254736c36c2045c473b2150cc56da1aa5914bfb
--- /dev/null
+++ b/catalogue/SchemaCheckerResult.cpp
@@ -0,0 +1,94 @@
+/**
+ * The CERN Tape Archive (CTA) project
+ * Copyright © 2018 CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <iostream>
+
+#include "SchemaCheckerResult.hpp"
+
+namespace cta {
+namespace catalogue {
+
+SchemaCheckerResult::SchemaCheckerResult():m_status(Status::SUCCESS) {
+}
+
+SchemaCheckerResult::SchemaCheckerResult(const SchemaCheckerResult& orig) {
+ m_errors = orig.m_errors;
+ m_warnings = orig.m_warnings;
+ m_status = orig.m_status;
+}
+
+SchemaCheckerResult SchemaCheckerResult::operator=(const SchemaCheckerResult &other){
+ if(this != &other){
+ m_errors = other.m_errors;
+ m_warnings = other.m_warnings;
+ m_status = other.m_status;
+ }
+ return *this;
+}
+
+SchemaCheckerResult SchemaCheckerResult::operator +=(const SchemaCheckerResult& other){
+ m_errors.insert(m_errors.end(),other.m_errors.begin(),other.m_errors.end());
+ m_warnings.insert(m_warnings.end(),other.m_warnings.begin(), other.m_warnings.end());
+ if(m_status == Status::SUCCESS){
+ // The status should not change if it is failed
+ m_status = other.m_status;
+ }
+ return *this;
+}
+
+SchemaCheckerResult::~SchemaCheckerResult() {
+}
+
+void SchemaCheckerResult::addError(const std::string& error){
+ m_errors.emplace_back(error);
+ m_status = Status::FAILED;
+}
+
+void SchemaCheckerResult::addWarning(const std::string& warning){
+ m_warnings.emplace_back(warning);
+}
+
+SchemaCheckerResult::Status SchemaCheckerResult::getStatus() const {
+ return m_status;
+}
+
+void SchemaCheckerResult::displayErrors(std::ostream & os) const {
+ for(auto &error: m_errors){
+ os << " ERROR: " << error << std::endl;
+ }
+}
+
+void SchemaCheckerResult::displayWarnings(std::ostream& os) const{
+ for(auto &warning: m_warnings){
+ os << " WARNING: " << warning << std::endl;
+ }
+}
+
+
+std::string SchemaCheckerResult::statusToString(const Status& status){
+ switch(status){
+ case Status::SUCCESS:
+ return "SUCCESS";
+ case Status::FAILED:
+ return "FAILED";
+ default:
+ return " UnknownStatus";
+ }
+}
+
+}}
\ No newline at end of file
diff --git a/catalogue/SchemaComparerResult.hpp b/catalogue/SchemaCheckerResult.hpp
similarity index 67%
rename from catalogue/SchemaComparerResult.hpp
rename to catalogue/SchemaCheckerResult.hpp
index 685acad1e45ea7fd0bfa7f6904c54adb7d0785be..dc7cabc03846626350a9e1ce0b935257c933323e 100644
--- a/catalogue/SchemaComparerResult.hpp
+++ b/catalogue/SchemaCheckerResult.hpp
@@ -27,9 +27,10 @@ namespace catalogue {
* This class holds the results of the Schema comparison against the catalogue database schema
* It is simply composed of:
* - a list of differences between the catalogue schema and the schema we are comparing it against
+ * - a list of warnings
* - a Status (SUCCESS or FAILED)
*/
-class SchemaComparerResult {
+class SchemaCheckerResult {
public:
/**
* The comparison is either SUCCESS or FAILED
@@ -40,9 +41,9 @@ public:
};
static std::string statusToString(const Status& status);
- SchemaComparerResult();
- SchemaComparerResult(const SchemaComparerResult& orig);
- SchemaComparerResult operator=(const SchemaComparerResult &other);
+ SchemaCheckerResult();
+ SchemaCheckerResult(const SchemaCheckerResult& orig);
+ SchemaCheckerResult operator=(const SchemaCheckerResult &other);
/**
* We can combine the SchemaComparerResult in order to add other Results to it
* @param other the SchemaComparerResult object to add
@@ -51,24 +52,39 @@ public:
* Note: The status will never change if it is failed (this or other)
* It will simply append the list of differences of other to this SchemaComparerResult
*/
- SchemaComparerResult operator+=(const SchemaComparerResult &other);
+ SchemaCheckerResult operator+=(const SchemaCheckerResult &other);
+
+ /**
+ * Prints the errors the ostream
+ * @param os the ostream to print the errors
+ */
+ void displayErrors(std::ostream & os) const;
+
/**
- * Prints the differences in this result
+ * Prints the warnings the ostream
+ * @param os the ostream to print the warnings
*/
- void printDiffs() const;
+ void displayWarnings(std::ostream & os) const;
/**
* Returns the status of the SchemaComparerResult
* @return the status of the SchemaComparerResult
*/
Status getStatus() const;
/**
- * Add a difference to this Result
- * @param diff the difference to add
+ * Add an error to this result
+ * @param error the error to add
*/
- void addDiff(const std::string &diff);
- virtual ~SchemaComparerResult();
+ void addError(const std::string &error);
+ /**
+ * Add a warning to this result
+ * @param warning the warning to add
+ */
+ void addWarning(const std::string & warning);
+
+ virtual ~SchemaCheckerResult();
private:
- std::list<std::string> m_diffs;
+ std::list<std::string> m_errors;
+ std::list<std::string> m_warnings;
Status m_status;
};
diff --git a/catalogue/SchemaComparer.hpp b/catalogue/SchemaComparer.hpp
index 1a281d8e3ffbefd8129f0521abbc01d6ca5bcdc8..2db94cde3b3c6c82af2513b71f48d93923e1d08a 100644
--- a/catalogue/SchemaComparer.hpp
+++ b/catalogue/SchemaComparer.hpp
@@ -25,7 +25,7 @@
#pragma once
#include "rdbms/ConnPool.hpp"
-#include "SchemaComparerResult.hpp"
+#include "SchemaCheckerResult.hpp"
#include "DatabaseMetadataGetter.hpp"
#include "SchemaSqlStatementsReader.hpp"
@@ -51,24 +51,24 @@ public:
* Compare the schema to compare against the database
* @return a SchemaComparerResult object that will contain the differences if there are some
*/
- virtual SchemaComparerResult compareAll() = 0;
+ virtual SchemaCheckerResult compareAll() = 0;
/**
* Compare the tables of the schema against the catalogue database
* @return a SchemaComparerResult that will contain the differences if there are some
*/
- virtual SchemaComparerResult compareTables() = 0;
+ virtual SchemaCheckerResult compareTables() = 0;
/**
* Compare the indexes of the schema against the catalogue database
* @return a SchemaComparerResult that will contain the differences if there are some
*/
- virtual SchemaComparerResult compareIndexes() = 0;
+ virtual SchemaCheckerResult compareIndexes() = 0;
/**
* Compare only the tables that are located in the schema
* This is useful when want to compare ONLY tables that are defined in a schema
* @return a SchemaComparerResult that will contain the differences if there are some
*/
- virtual SchemaComparerResult compareTablesLocatedInSchema() = 0;
+ virtual SchemaCheckerResult compareTablesLocatedInSchema() = 0;
/**
* Sets the way the schema sql statements will be read to do the schemas comparison
* @param schemaSqlStatementsReader the reader used to get the schema sql statements in order to do schema comparison
diff --git a/catalogue/SchemaComparerResult.cpp b/catalogue/SchemaComparerResult.cpp
deleted file mode 100644
index d90165ccb55b17dfe20812e6bf484b770f8f826b..0000000000000000000000000000000000000000
--- a/catalogue/SchemaComparerResult.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-/**
- * The CERN Tape Archive (CTA) project
- * Copyright © 2018 CERN
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <iostream>
-
-#include "SchemaComparerResult.hpp"
-
-namespace cta {
-namespace catalogue {
-
-SchemaComparerResult::SchemaComparerResult():m_status(Status::SUCCESS) {
-}
-
-SchemaComparerResult::SchemaComparerResult(const SchemaComparerResult& orig) {
- m_diffs = orig.m_diffs;
- m_status = orig.m_status;
-}
-
-SchemaComparerResult SchemaComparerResult::operator=(const SchemaComparerResult &other){
- if(this != &other){
- m_diffs = other.m_diffs;
- m_status = other.m_status;
- }
- return *this;
-}
-
-SchemaComparerResult SchemaComparerResult::operator +=(const SchemaComparerResult& other){
- m_diffs.insert(m_diffs.end(),other.m_diffs.begin(),other.m_diffs.end());
- if(m_status == Status::SUCCESS){
- // The status should not change if it is failed
- m_status = other.m_status;
- }
- return *this;
-}
-
-SchemaComparerResult::~SchemaComparerResult() {
-}
-
-void SchemaComparerResult::addDiff(const std::string& diff){
- m_diffs.emplace_back(diff);
- m_status = Status::FAILED;
-}
-
-SchemaComparerResult::Status SchemaComparerResult::getStatus() const {
- return m_status;
-}
-
-void SchemaComparerResult::printDiffs() const {
- for(auto &diff: m_diffs){
- std::cerr << " ERROR: " << diff << std::endl;
- }
-}
-
-std::string SchemaComparerResult::statusToString(const Status& status){
- switch(status){
- case Status::SUCCESS:
- return "SUCCESS";
- case Status::FAILED:
- return "FAILED";
- default:
- return " UnknownStatus";
- }
-}
-
-}}
\ No newline at end of file
diff --git a/catalogue/SchemaVersion.cpp b/catalogue/SchemaVersion.cpp
index a4eca8333e0a2a72fb3d069874b8faa7ce9d236d..929d20f521e50fad6eecef7e0d63fddacfedb115 100644
--- a/catalogue/SchemaVersion.cpp
+++ b/catalogue/SchemaVersion.cpp
@@ -24,10 +24,6 @@ namespace cta { namespace catalogue {
SchemaVersion::SchemaVersion(){}
-SchemaVersion::SchemaVersion(const uint64_t schemaVersionMajor, const uint64_t schemaVersionMinor, const cta::optional<uint64_t> schemaVersionMajorNext, const cta::optional<uint64_t> schemaVersionMinorNext, const Status status):m_schemaVersionMajor(schemaVersionMajor), m_schemaVersionMinor(schemaVersionMinor), m_nextSchemaVersionMajor(schemaVersionMajorNext), m_nextSchemaVersionMinor(schemaVersionMinorNext), m_status(status) {
-
-}
-
SchemaVersion::SchemaVersion(const SchemaVersion& orig) {
if(this != &orig){
m_schemaVersionMajor = orig.m_schemaVersionMajor;
diff --git a/catalogue/SchemaVersion.hpp b/catalogue/SchemaVersion.hpp
index 6536a3f1109a2b15811c203e2b67e88f05345a10..7998dd9163a737b59afbb8838459c82403c0e48d 100644
--- a/catalogue/SchemaVersion.hpp
+++ b/catalogue/SchemaVersion.hpp
@@ -54,7 +54,6 @@ private:
cta::optional<uint64_t> m_nextSchemaVersionMinor;
SchemaVersion::Status m_status;
SchemaVersion();
- SchemaVersion(const uint64_t schemaVersionMajor, const uint64_t schemaVersionMinor, const cta::optional<uint64_t> nextSchemaVersionMajor, const cta::optional<uint64_t> nextSchemaVersionMinor, const Status status);
};
class SchemaVersion::Builder{
diff --git a/catalogue/VerifySchemaCmd.cpp b/catalogue/VerifySchemaCmd.cpp
index cc8f70d3507ef158ada0fd45fd24b88145db9c61..5bea49f513099ab061f392162b451fe534f4e418 100644
--- a/catalogue/VerifySchemaCmd.cpp
+++ b/catalogue/VerifySchemaCmd.cpp
@@ -80,10 +80,11 @@ int VerifySchemaCmd::exceptionThrowingMain(const int argc, char *const *const ar
.useSQLiteSchemaComparer()
.build());
- SchemaChecker::Status comparisonStatus = schemaChecker->compareSchema();
- schemaChecker->checkNoParallelTables();
- schemaChecker->checkSchemaNotUpgrading();
- if(comparisonStatus == SchemaChecker::Status::FAILURE){
+ SchemaCheckerResult result = schemaChecker->displayingCompareSchema(std::cout,std::cerr);
+ result += schemaChecker->checkNoParallelTables();
+ result += schemaChecker->checkSchemaNotUpgrading();
+ result.displayWarnings(std::cout);
+ if(result.getStatus() == SchemaCheckerResult::Status::FAILED){
return 1;
}
return 0;
diff --git a/catalogue/common_catalogue_schema.sql b/catalogue/common_catalogue_schema.sql
index c69e545a346850f5dd5de994519b9daaa71f378f..f740467c7494c4f7d4761b30a54eaae16cf122e6 100644
--- a/catalogue/common_catalogue_schema.sql
+++ b/catalogue/common_catalogue_schema.sql
@@ -3,7 +3,9 @@ CREATE TABLE CTA_CATALOGUE(
SCHEMA_VERSION_MINOR UINT64TYPE CONSTRAINT CTA_CATALOGUE_SVM2_NN NOT NULL,
NEXT_SCHEMA_VERSION_MAJOR UINT64TYPE,
NEXT_SCHEMA_VERSION_MINOR UINT64TYPE,
- STATUS VARCHAR(100)
+ STATUS VARCHAR(100),
+ IS_PRODUCTION CHAR(1) DEFAULT '0' CONSTRAINT CTA_CATALOGUE_IP_NN NOT NULL,
+ CONSTRAINT CTA_CATALOGUE_IP_BOOL_CK CHECK(IS_PRODUCTION IN ('0','1'))
);
CREATE TABLE ADMIN_USER(
ADMIN_USER_NAME VARCHAR(100) CONSTRAINT ADMIN_USER_AUN_NN NOT NULL,
diff --git a/statistics/StatisticsSaveCmd.cpp b/statistics/StatisticsSaveCmd.cpp
index 7a7e0c25a965b687d424c625ab5cd1560cb9e182..a0937f4831dfed991735b36576b38563bbd6a77c 100644
--- a/statistics/StatisticsSaveCmd.cpp
+++ b/statistics/StatisticsSaveCmd.cpp
@@ -229,7 +229,7 @@ void StatisticsSaveCmd::checkCatalogueSchema(cta::rdbms::Conn& catalogueConn, ct
SchemaChecker::Builder catalogueCheckerBuilder("catalogue",dbType,catalogueConn);
std::unique_ptr<cta::catalogue::SchemaChecker> catalogueChecker = catalogueCheckerBuilder.build();
- SchemaChecker::Status tapeTableStatus =
+ SchemaCheckerResult result =
catalogueChecker->checkTableContainsColumns("TAPE",{
"NB_MASTER_FILES",
"MASTER_DATA_IN_BYTES",
@@ -240,10 +240,10 @@ void StatisticsSaveCmd::checkCatalogueSchema(cta::rdbms::Conn& catalogueConn, ct
"DIRTY"
}
);
- SchemaChecker::Status voTableStatus =
- catalogueChecker->checkTableContainsColumns("TAPE_POOL",{"VIRTUAL_ORGANIZATION_ID"});
+ result += catalogueChecker->checkTableContainsColumns("TAPE_POOL",{"VIRTUAL_ORGANIZATION_ID"});
- if(tapeTableStatus == SchemaChecker::Status::FAILURE || voTableStatus == SchemaChecker::Status::FAILURE ){
+ if(result.getStatus() == SchemaCheckerResult::FAILED){
+ result.displayErrors(std::cerr);
throw cta::exception::Exception("Catalogue schema checking failed.");
}
}
@@ -258,8 +258,9 @@ void StatisticsSaveCmd::checkStatisticsSchema(cta::rdbms::Conn& statisticsDataba
statisticsCheckerBuilder.useCppSchemaStatementsReader(*statisticsSchema)
.useSQLiteSchemaComparer()
.build();
- SchemaChecker::Status compareTablesStatus = statisticsChecker->compareTablesLocatedInSchema();
- if(compareTablesStatus == SchemaChecker::Status::FAILURE){
+ SchemaCheckerResult compareTablesStatus = statisticsChecker->compareTablesLocatedInSchema();
+ if(compareTablesStatus.getStatus() == SchemaCheckerResult::FAILED){
+ compareTablesStatus.displayErrors(std::cerr);
throw cta::exception::Exception("Statistics schema checking failed.");
}
}
diff --git a/statistics/StatisticsUpdateCmd.cpp b/statistics/StatisticsUpdateCmd.cpp
index e06702a449cb9d2fa03ee697560afe9afa8e78ce..dd5bd9e090ae9c60645f725789a8221b52ea2de6 100644
--- a/statistics/StatisticsUpdateCmd.cpp
+++ b/statistics/StatisticsUpdateCmd.cpp
@@ -66,7 +66,7 @@ int StatisticsUpdateCmd::exceptionThrowingMain(const int argc, char *const *cons
std::unique_ptr<cta::catalogue::SchemaChecker> catalogueChecker;
catalogueChecker = catalogueCheckerBuilder.build();
- SchemaChecker::Status tapeTableStatus = catalogueChecker->checkTableContainsColumns("TAPE",{"VID",
+ SchemaCheckerResult result = catalogueChecker->checkTableContainsColumns("TAPE",{"VID",
"DIRTY",
"NB_MASTER_FILES",
"MASTER_DATA_IN_BYTES",
@@ -75,10 +75,11 @@ int StatisticsUpdateCmd::exceptionThrowingMain(const int argc, char *const *cons
"NB_COPY_NB_GT_1",
"COPY_NB_GT_1_IN_BYTES"
});
- SchemaChecker::Status tapeFileTableStatus = catalogueChecker->checkTableContainsColumns("TAPE_FILE",{"VID","ARCHIVE_FILE_ID","FSEQ","COPY_NB","SUPERSEDED_BY_VID","SUPERSEDED_BY_FSEQ"});
- SchemaChecker::Status archiveFileTableStatus = catalogueChecker->checkTableContainsColumns("ARCHIVE_FILE",{"ARCHIVE_FILE_ID","SIZE_IN_BYTES"});
+ result += catalogueChecker->checkTableContainsColumns("TAPE_FILE",{"VID","ARCHIVE_FILE_ID","FSEQ","COPY_NB","SUPERSEDED_BY_VID","SUPERSEDED_BY_FSEQ"});
+ result += catalogueChecker->checkTableContainsColumns("ARCHIVE_FILE",{"ARCHIVE_FILE_ID","SIZE_IN_BYTES"});
- if(tapeTableStatus == SchemaChecker::Status::FAILURE || tapeFileTableStatus == SchemaChecker::Status::FAILURE || archiveFileTableStatus == SchemaChecker::Status::FAILURE){
+ if(result.getStatus() == SchemaCheckerResult::FAILED){
+ result.displayErrors(std::cerr);
return EXIT_FAILURE;
}