diff --git a/core/src/dird/dbcopy/column_description.cc b/core/src/dird/dbcopy/column_description.cc index 415db4f492b..2f959d5d4e5 100644 --- a/core/src/dird/dbcopy/column_description.cc +++ b/core/src/dird/dbcopy/column_description.cc @@ -27,10 +27,14 @@ #include #include -ColumnDescription::ColumnDescription(const char* column_name_in, - const char* data_type_in, - const char* max_length_in) - : column_name(column_name_in), data_type(data_type_in) +ColumnDescription::ColumnDescription( + const std::string& column_name_in, + const std::string& column_name_lower_case_in, + const char* data_type_in, + const char* max_length_in) + : column_name(column_name_in) + , column_name_lower_case(column_name_lower_case_in) + , data_type(data_type_in) { std::string field; try { diff --git a/core/src/dird/dbcopy/column_description.h b/core/src/dird/dbcopy/column_description.h index cc72e4090ad..0df77a0c5c9 100644 --- a/core/src/dird/dbcopy/column_description.h +++ b/core/src/dird/dbcopy/column_description.h @@ -31,7 +31,8 @@ class BareosDb; class ColumnDescription { public: - ColumnDescription(const char* column_name_in, + ColumnDescription(const std::string& column_name_in, + const std::string& column_name_lower_case_in, const char* data_type_in, const char* max_length_in); virtual ~ColumnDescription() = default; @@ -43,6 +44,7 @@ class ColumnDescription { void RegisterConverterCallbackFromMap(const DataTypeConverterMap&); std::string column_name; + std::string column_name_lower_case; std::string data_type; std::size_t character_maximum_length{}; diff --git a/core/src/dird/dbcopy/database_column_descriptions.cc b/core/src/dird/dbcopy/database_column_descriptions.cc index ff811d106e0..e8316eca3c8 100644 --- a/core/src/dird/dbcopy/database_column_descriptions.cc +++ b/core/src/dird/dbcopy/database_column_descriptions.cc @@ -28,41 +28,44 @@ #include #include -DatabaseColumnDescriptions::DatabaseColumnDescriptions(BareosDb* db) : db_{db} +void DatabaseColumnDescriptions::SelectColumnDescriptionsAndAddToMap( + const std::string& sql_query) { -} - -void DatabaseColumnDescriptions::SelectColumnDescriptions( - const std::string& sql_query, - DB_RESULT_HANDLER* ResultHandler) -{ - if (!db_->SqlQuery(sql_query.c_str(), ResultHandler, this)) { + if (!db_->SqlQuery(sql_query.c_str(), ResultHandler_, this)) { std::string err{"Could not select table names: "}; err += sql_query; throw std::runtime_error(err); } - std::sort(column_descriptions.begin(), column_descriptions.end(), - [](const std::unique_ptr& v1, - const std::unique_ptr& v2) { - std::string l1, l2; - ToLowerCase(v1->column_name, v2->column_name, l1, l2); - return l1 < l2; - }); } -int DatabaseColumnDescriptionsPostgresql::ResultHandler(void* ctx, - int /*fields*/, - char** row) +int DatabaseColumnDescriptions::ResultHandler_(void* ctx, + int /*fields*/, + char** row) { auto t = static_cast(ctx); - t->column_descriptions.emplace_back(std::make_unique( - row[RowIndex::kColumnName], row[RowIndex::kDataType], - row[RowIndex::kCharMaxLenght])); + t->AddToMap(row[RowIndex::kColumnName], row[RowIndex::kDataType], + row[RowIndex::kCharMaxLenght]); return 0; } +void DatabaseColumnDescriptions::AddToMap(const char* column_name_in, + const char* data_type_in, + const char* max_length_in) + +{ + std::string column_name_lower_case; + std::string column_name{column_name_in}; + + StringToLowerCase(column_name_lower_case, column_name_in); + + column_descriptions.emplace( // std::map sorts keys ascending by default + std::piecewise_construct, std::forward_as_tuple(column_name_lower_case), + std::forward_as_tuple(column_name, column_name_lower_case, data_type_in, + max_length_in)); +} + DatabaseColumnDescriptionsPostgresql::DatabaseColumnDescriptionsPostgresql( BareosDb* db, const std::string& table_name) @@ -77,20 +80,7 @@ DatabaseColumnDescriptionsPostgresql::DatabaseColumnDescriptionsPostgresql( std::cout << "--> " << table_name << std::endl; - SelectColumnDescriptions(query, ResultHandler); -} - -int DatabaseColumnDescriptionsMysql::ResultHandler(void* ctx, - int /*fields*/, - char** row) -{ - auto t = static_cast(ctx); - - t->column_descriptions.emplace_back(std::make_unique( - row[RowIndex::kColumnName], row[RowIndex::kDataType], - row[RowIndex::kCharMaxLenght])); - - return 0; + SelectColumnDescriptionsAndAddToMap(query); } DatabaseColumnDescriptionsMysql::DatabaseColumnDescriptionsMysql( @@ -108,5 +98,6 @@ DatabaseColumnDescriptionsMysql::DatabaseColumnDescriptionsMysql( query += " table_schema='"; query += db->get_db_name(); query += "'"; - SelectColumnDescriptions(query, ResultHandler); + + SelectColumnDescriptionsAndAddToMap(query); } diff --git a/core/src/dird/dbcopy/database_column_descriptions.h b/core/src/dird/dbcopy/database_column_descriptions.h index e7638bf5fc2..0d2092dfaa4 100644 --- a/core/src/dird/dbcopy/database_column_descriptions.h +++ b/core/src/dird/dbcopy/database_column_descriptions.h @@ -32,13 +32,15 @@ class BareosDb; class DatabaseColumnDescriptions { public: - DatabaseColumnDescriptions(BareosDb* db); + DatabaseColumnDescriptions(BareosDb* db) : db_{db} {}; virtual ~DatabaseColumnDescriptions() = default; + void AddToMap(const char* column_name_in, + const char* data_type_in, + const char* max_length_in); - using VectorOfColumnDescriptions = - std::vector>; + using ColumnDescriptions = std::map; - VectorOfColumnDescriptions column_descriptions; + ColumnDescriptions column_descriptions; protected: enum RowIndex : int @@ -47,24 +49,22 @@ class DatabaseColumnDescriptions { kDataType = 1, kCharMaxLenght = 2 }; - void SelectColumnDescriptions(const std::string& sql_query, - DB_RESULT_HANDLER* ResultHandler); + void SelectColumnDescriptionsAndAddToMap(const std::string& sql_query); private: - BareosDb* db_; + BareosDb* db_{}; + static int ResultHandler_(void* ctx, int fields, char** row); }; class DatabaseColumnDescriptionsPostgresql : public DatabaseColumnDescriptions { public: DatabaseColumnDescriptionsPostgresql(BareosDb* db, const std::string& table_name); - static int ResultHandler(void* ctx, int fields, char** row); }; class DatabaseColumnDescriptionsMysql : public DatabaseColumnDescriptions { public: DatabaseColumnDescriptionsMysql(BareosDb* db, const std::string& table_name); - static int ResultHandler(void* ctx, int fields, char** row); }; #endif // BAREOS_SRC_DIRD_DBCOPY_DATABASE_COLUMN_DESCRIPTIONS_H_ diff --git a/core/src/dird/dbcopy/database_export_postgresql.cc b/core/src/dird/dbcopy/database_export_postgresql.cc index 3ede24565a7..d9f3591b603 100644 --- a/core/src/dird/dbcopy/database_export_postgresql.cc +++ b/core/src/dird/dbcopy/database_export_postgresql.cc @@ -148,7 +148,7 @@ DatabaseExportPostgresql::DatabaseExportPostgresql( if (clear_tables) { for (const auto& t : table_descriptions_->tables) { - ClearTable(db_, t.table_name); + ClearTable(db_, t.second.table_name); } } } @@ -160,15 +160,15 @@ DatabaseExportPostgresql::~DatabaseExportPostgresql() void DatabaseExportPostgresql::DoCopyInsertion(RowData& source_data_row) { - for (std::size_t i = 0; i < source_data_row.column_descriptions.size(); i++) { + size_t i = 0; + for (const auto& c : source_data_row.column_descriptions) { const ColumnDescription* column_description = table_descriptions_->GetColumnDescription( - source_data_row.table_name, - source_data_row.column_descriptions[i]->column_name); + source_data_row.table_name, c.second.column_name_lower_case); if (column_description == nullptr) { std::string err{"Could not get column description for: "}; - err += source_data_row.column_descriptions[i]->column_name; + err += c.second.column_name; throw std::runtime_error(err); } @@ -177,6 +177,7 @@ void DatabaseExportPostgresql::DoCopyInsertion(RowData& source_data_row) } else { throw std::runtime_error("Row number does not match column description"); } + ++i; } if (!db_->SqlCopyInsert(source_data_row.data_fields)) { std::string err{"DatabaseExportPostgresql: Could not execute query: "}; @@ -193,15 +194,15 @@ void DatabaseExportPostgresql::DoInsertInsertion(RowData& source_data_row) std::string query_values = " VALUES ("; - for (std::size_t i = 0; i < source_data_row.column_descriptions.size(); i++) { + size_t i = 0; + for (const auto& c : source_data_row.column_descriptions) { const ColumnDescription* column_description = table_descriptions_->GetColumnDescription( - source_data_row.table_name, - source_data_row.column_descriptions[i]->column_name); + source_data_row.table_name, c.second.column_name_lower_case); if (column_description == nullptr) { std::string err{"Could not get column description for: "}; - err += source_data_row.column_descriptions[i]->column_name; + err += c.second.column_name_lower_case; throw std::runtime_error(err); } @@ -216,6 +217,7 @@ void DatabaseExportPostgresql::DoInsertInsertion(RowData& source_data_row) } else { throw std::runtime_error("Row number does not match column description"); } + ++i; } query_values.resize(query_values.size() - 1); @@ -295,7 +297,7 @@ static bool TableIsEmtpy(BareosDb* db, const std::string& table_name) return db->SqlNumRows() <= 0; } -bool DatabaseExportPostgresql::TableExists( +bool DatabaseExportPostgresql::TableExistsAndGetColumns( const std::string& table_name, std::vector& column_names) { @@ -303,7 +305,7 @@ bool DatabaseExportPostgresql::TableExists( if (found == nullptr) { return false; } for (const auto& col : found->column_descriptions) { - column_names.push_back(col->column_name); + column_names.push_back(col.second.column_name); } return true; @@ -316,7 +318,7 @@ bool DatabaseExportPostgresql::StartTable(const std::string& table_name) std::vector column_names; - if (!TableExists(table_name, column_names)) { + if (!TableExistsAndGetColumns(table_name, column_names)) { std::cout << "--> destination table does not exist" << std::endl; return false; } diff --git a/core/src/dird/dbcopy/database_export_postgresql.h b/core/src/dird/dbcopy/database_export_postgresql.h index dc588f57bc1..1f0536d37a3 100644 --- a/core/src/dird/dbcopy/database_export_postgresql.h +++ b/core/src/dird/dbcopy/database_export_postgresql.h @@ -59,8 +59,8 @@ class DatabaseExportPostgresql : public DatabaseExport { SequenceSchemaVector sequence_schema_vector_; void SelectSequenceSchema(); - bool TableExists(const std::string& table_name, - std::vector& column_names); + bool TableExistsAndGetColumns(const std::string& table_name, + std::vector& column_names); bool UseCopyInsertion(); void DoCopyInsertion(RowData& source_data_row); void DoInsertInsertion(RowData& source_data_row); diff --git a/core/src/dird/dbcopy/database_import_mysql.cc b/core/src/dird/dbcopy/database_import_mysql.cc index bf481ed1ffb..5eb1e3c68de 100644 --- a/core/src/dird/dbcopy/database_import_mysql.cc +++ b/core/src/dird/dbcopy/database_import_mysql.cc @@ -62,27 +62,25 @@ DatabaseImportMysql::DatabaseImportMysql( } struct ResultHandlerContext { - ResultHandlerContext( - const DatabaseColumnDescriptions::VectorOfColumnDescriptions& c, - RowData& d, - DatabaseExport& e, - BareosDb* db_in, - bool is_restore_object_in, - Progress& p) - : column_descriptions(c) - , row_data(d) + ResultHandlerContext(BareosDb* db_in, + RowData& d, + DatabaseExport& e, + bool is_restore_object_in, + size_t data_field_index_of_restore_object_in, + Progress& p) + : row_data(d) , exporter(e) , db(db_in) , is_restore_object(is_restore_object_in) + , data_field_index_of_restore_object{data_field_index_of_restore_object_in} , progress(p) { } - const DatabaseColumnDescriptions::VectorOfColumnDescriptions& - column_descriptions; RowData& row_data; DatabaseExport& exporter; BareosDb* db{}; bool is_restore_object{}; + size_t data_field_index_of_restore_object{}; Progress& progress; }; @@ -97,53 +95,87 @@ static void PrintCopyStartToStdout(const Progress& progress) } } +auto constexpr invalid = std::numeric_limits::max(); + +static size_t CalculateDataFieldIndexOfRestoreobject( + const DatabaseColumnDescriptions::ColumnDescriptions& column_descriptions) +{ + std::size_t data_field_index_of_restore_object = invalid; + + size_t i = 0; + for (const auto& c : column_descriptions) { + if (c.second.data_type == "longblob") { + data_field_index_of_restore_object = i; + break; + } + ++i; + } + return data_field_index_of_restore_object; +} + + void DatabaseImportMysql::RunQuerySelectAllRows( DB_RESULT_HANDLER* ResultHandler, DatabaseExport& exporter) { for (const auto& t : table_descriptions_->tables) { - if (!exporter.StartTable(t.table_name)) { + const TableDescription& table_description = t.second; + + if (!exporter.StartTable(table_description.table_name_lower_case)) { std::cout << "--> *** skipping ***" << std::endl; continue; } - Progress progress(db_, t.table_name, limit_amount_of_rows_); + Progress progress(db_, table_description.table_name, limit_amount_of_rows_); PrintCopyStartToStdout(progress); std::string query{"SELECT `"}; - for (const auto& col : t.column_descriptions) { - query += col->column_name; + for (const auto& col : table_description.column_descriptions) { + query += col.second.column_name; query += "`, `"; } query.resize(query.size() - 3); bool is_restore_object = false; - if (t.table_name == "RestoreObject") { + size_t data_field_index_of_restore_object = invalid; + + if (table_description.table_name == "RestoreObject") { query += ", length(`RestoreObject`) as `size_of_restore_object`"; is_restore_object = true; + + data_field_index_of_restore_object = + CalculateDataFieldIndexOfRestoreobject( + table_description.column_descriptions); + + if (data_field_index_of_restore_object == invalid) { + throw std::runtime_error("No longblob object found as restore object"); + } } query += " FROM "; - query += t.table_name; + query += table_description.table_name; if (limit_amount_of_rows_ != 0U) { query += " LIMIT "; query += std::to_string(limit_amount_of_rows_); } - RowData row_data(t.column_descriptions, t.table_name); - ResultHandlerContext ctx(t.column_descriptions, row_data, exporter, db_, - is_restore_object, progress); + RowData row_data(table_description.table_name_lower_case, + table_description.column_descriptions); + + ResultHandlerContext ctx(db_, row_data, exporter, is_restore_object, + data_field_index_of_restore_object, progress); if (!db_->SqlQuery(query.c_str(), ResultHandler, &ctx)) { - std::cout << "Could not import table: " << t.table_name << std::endl; + std::cout << "Could not import table: " << table_description.table_name + << std::endl; std::string err{"Could not execute select statement: "}; err += query; std::cout << query << std::endl; } - exporter.EndTable(t.table_name); + exporter.EndTable(table_description.table_name_lower_case); std::cout << "--> success" << std::endl; } } @@ -157,39 +189,30 @@ void DatabaseImportMysql::ExportTo(DatabaseExport& exporter) static void ReadoutSizeOfRestoreObject(ResultHandlerContext* r, RowData& row_data, - int field_index_longblob, + int result_index_longblob, char** row) { - auto constexpr invalid = std::numeric_limits::max(); - std::size_t index_of_restore_object = invalid; - - for (std::size_t i = 0; i < r->column_descriptions.size(); i++) { - if (r->column_descriptions[i]->data_type == "longblob") { - index_of_restore_object = i; - break; - } - } - - if (index_of_restore_object == invalid) { - throw std::runtime_error("No longblob object found as restore object"); + if (r->data_field_index_of_restore_object > row_data.data_fields.size() - 1) { + throw std::runtime_error( + "data_field_index_of_restore_object out of bounds"); } + auto& f = row_data.data_fields[r->data_field_index_of_restore_object]; - std::istringstream(row[field_index_longblob]) >> - row_data.data_fields[index_of_restore_object].size_of_restore_object; + std::istringstream(row[result_index_longblob]) >> f.size_of_restore_object; } void DatabaseImportMysql::FillRowWithDatabaseResult(ResultHandlerContext* r, - int fields, + int number_of_result_fields, char** row) { - std::size_t number_of_fields = r->column_descriptions.size(); + size_t maximum_number_of_fields = r->row_data.column_descriptions.size(); if (r->is_restore_object) { - ++number_of_fields; // one more for the size_of_restore_object + ++maximum_number_of_fields; // one more for the size_of_restore_object } - if (fields != static_cast(number_of_fields)) { + if (number_of_result_fields != static_cast(maximum_number_of_fields)) { throw std::runtime_error( "Number of database fields does not match description"); } @@ -197,20 +220,24 @@ void DatabaseImportMysql::FillRowWithDatabaseResult(ResultHandlerContext* r, RowData& row_data = r->row_data; if (r->is_restore_object) { - std::size_t field_index_longblob = fields - 1; - ReadoutSizeOfRestoreObject(r, row_data, field_index_longblob, row); + std::size_t result_index_longblob = number_of_result_fields - 1; + ReadoutSizeOfRestoreObject(r, row_data, result_index_longblob, row); } - for (std::size_t i = 0; i < r->column_descriptions.size(); i++) { - row_data.data_fields[i].data_pointer = row[i]; - r->column_descriptions[i]->converter(r->db, row_data.data_fields[i]); + size_t i = 0; + for (const auto& c : r->row_data.column_descriptions) { + r->row_data.data_fields[i].data_pointer = row[i]; + c.second.converter(r->db, row_data.data_fields[i]); + ++i; } } -int DatabaseImportMysql::ResultHandlerCopy(void* ctx, int fields, char** row) +int DatabaseImportMysql::ResultHandlerCopy(void* ctx, + int number_of_result_fields, + char** row) { auto* r = static_cast(ctx); - FillRowWithDatabaseResult(r, fields, row); + FillRowWithDatabaseResult(r, number_of_result_fields, row); std::string insert_mode_message; r->exporter.CopyRow(r->row_data, insert_mode_message); diff --git a/core/src/dird/dbcopy/database_table_descriptions.cc b/core/src/dird/dbcopy/database_table_descriptions.cc index 478b6ff20ad..ce5feacf4a3 100644 --- a/core/src/dird/dbcopy/database_table_descriptions.cc +++ b/core/src/dird/dbcopy/database_table_descriptions.cc @@ -33,27 +33,23 @@ using TableNames = std::vector; void DatabaseTableDescriptions::SelectTableNames(const std::string& sql_query, - TableNames& table_names) + TableNames& table_names_out) { if (!db_->SqlQuery(sql_query.c_str(), DatabaseTableDescriptions::ResultHandler, - std::addressof(table_names))) { + std::addressof(table_names_out))) { std::string err{"Could not select table names: "}; err += sql_query; throw std::runtime_error(err); } - - if (!table_names.empty()) { - std::sort(table_names.begin(), table_names.end()); - } } int DatabaseTableDescriptions::ResultHandler(void* ctx, int /*fields*/, char** row) { - auto table_names = static_cast(ctx); - if (row[0] != nullptr) { table_names->emplace_back(row[0]); } + auto table_names_out = static_cast(ctx); + if (row[0] != nullptr) { table_names_out->emplace_back(row[0]); } return 0; } @@ -68,9 +64,16 @@ DatabaseTablesPostgresql::DatabaseTablesPostgresql(BareosDb* db) SelectTableNames(query, table_names); std::cout << "getting column descriptions..." << std::endl; - for (auto t : table_names) { - DatabaseColumnDescriptionsPostgresql p(db, t); - tables.emplace_back(std::move(t), std::move(p.column_descriptions)); + for (const auto& table_name : table_names) { + DatabaseColumnDescriptionsPostgresql cdesc(db, table_name); + + std::string table_name_lower_case; + StringToLowerCase(table_name_lower_case, table_name); + + tables.emplace( // std::map sorts keys ascending by default + std::piecewise_construct, std::forward_as_tuple(table_name_lower_case), + std::forward_as_tuple(table_name, table_name_lower_case, + std::move(cdesc.column_descriptions))); } } @@ -85,51 +88,58 @@ DatabaseTablesMysql::DatabaseTablesMysql(BareosDb* db) std::vector table_names; SelectTableNames(query, table_names); - for (auto t : table_names) { - DatabaseColumnDescriptionsMysql p(db, t); - tables.emplace_back(std::move(t), std::move(p.column_descriptions)); + for (const auto& table_name : table_names) { + DatabaseColumnDescriptionsMysql cdesc(db, table_name); + + std::string table_name_lower_case; + StringToLowerCase(table_name_lower_case, table_name); + + tables.emplace( // std::map sorts keys ascending by default + std::piecewise_construct, std::forward_as_tuple(table_name_lower_case), + std::forward_as_tuple(table_name, table_name_lower_case, + std::move(cdesc.column_descriptions))); } } const TableDescription* DatabaseTableDescriptions::GetTableDescription( - const std::string& table_name) const + const std::string& table_name_lower_case) const { - auto tr = std::find_if(tables.begin(), tables.end(), - [&table_name](const TableDescription& t) { - std::string l1; - std::string l2; - ToLowerCase(table_name, t.table_name, l1, l2); - return l1 == l2; - }); - return tr == tables.end() ? nullptr : std::addressof(*tr); + try { + const auto& t = tables.at(table_name_lower_case); + return std::addressof(t); + } catch (std::out_of_range&) { + return nullptr; + } } const ColumnDescription* DatabaseTableDescriptions::GetColumnDescription( - const std::string& table_name, - const std::string& column_name) const + const std::string& table_name_lower_case, + const std::string& column_name_lower_case) const { - const TableDescription* table = GetTableDescription(table_name); - if (table == nullptr) { - std::cout << "Could not get table description for table: " << table_name - << std::endl; + const auto table_description = GetTableDescription(table_name_lower_case); + + if (table_description == nullptr) { + std::cout << "Could not get table description for table: " + << table_name_lower_case << std::endl; + return nullptr; + } + try { + const auto& c = + table_description->column_descriptions.at(column_name_lower_case); + return std::addressof(c); + } catch (std::out_of_range&) { + std::cout << "Could not get columnd description for column: " + << column_name_lower_case << std::endl; return nullptr; } - auto c = std::find_if( - table->column_descriptions.cbegin(), table->column_descriptions.cend(), - [&column_name](const std::unique_ptr& c) { - std::string l1, l2; - ToLowerCase(column_name, c->column_name, l1, l2); - return l1 == l2; - }); - return (c == table->column_descriptions.cend()) ? nullptr : c->get(); } void DatabaseTableDescriptions::SetAllConverterCallbacks( const ColumnDescription::DataTypeConverterMap& map) { - for (auto& table : tables) { - for (auto& column : table.column_descriptions) { - column->RegisterConverterCallbackFromMap(map); + for (auto& t : tables) { + for (auto& c : t.second.column_descriptions) { + c.second.RegisterConverterCallbackFromMap(map); } } } diff --git a/core/src/dird/dbcopy/database_table_descriptions.h b/core/src/dird/dbcopy/database_table_descriptions.h index a4ea543c924..8be62cc1aee 100644 --- a/core/src/dird/dbcopy/database_table_descriptions.h +++ b/core/src/dird/dbcopy/database_table_descriptions.h @@ -35,37 +35,40 @@ class BareosDb; struct TableDescription { TableDescription() = delete; - TableDescription(std::string&& t, - std::vector>&& r) - : table_name(t), column_descriptions(std::move(r)){}; + TableDescription(const std::string& tn, + const std::string& tn_lc, + DatabaseColumnDescriptions::ColumnDescriptions&& c) + : table_name{tn}, table_name_lower_case{tn_lc}, column_descriptions{c} {}; std::string table_name; - DatabaseColumnDescriptions::VectorOfColumnDescriptions column_descriptions; + std::string table_name_lower_case; + DatabaseColumnDescriptions::ColumnDescriptions column_descriptions; }; class DatabaseTableDescriptions { public: - std::vector tables; + std::map tables; + public: static std::unique_ptr Create( const DatabaseConnection& connection); + virtual ~DatabaseTableDescriptions() = default; + + public: + void SetAllConverterCallbacks(const ColumnDescription::DataTypeConverterMap&); const TableDescription* GetTableDescription( - const std::string& table_name) const; + const std::string& table_name_lower_case) const; const ColumnDescription* GetColumnDescription( - const std::string& table_name, - const std::string& column_name) const; - - void SetAllConverterCallbacks(const ColumnDescription::DataTypeConverterMap&); - - virtual ~DatabaseTableDescriptions() = default; + const std::string& table_name_lower_case, + const std::string& column_name_lower_case) const; protected: DatabaseTableDescriptions(BareosDb* db) : db_{db} {} void SelectTableNames(const std::string& sql_query, - std::vector& table_names); + std::vector& table_names_out); private: BareosDb* db_{}; diff --git a/core/src/dird/dbcopy/row_data.h b/core/src/dird/dbcopy/row_data.h index 899c2a6dfe1..4abf9fcf261 100644 --- a/core/src/dird/dbcopy/row_data.h +++ b/core/src/dird/dbcopy/row_data.h @@ -30,9 +30,9 @@ class BareosDb; struct RowData { - RowData(const DatabaseColumnDescriptions::VectorOfColumnDescriptions& - column_descriptions_in, - const std::string& table_name_in) + RowData(const std::string& table_name_in, + const DatabaseColumnDescriptions::ColumnDescriptions& + column_descriptions_in) : table_name(table_name_in), column_descriptions(column_descriptions_in) { data_fields.resize(column_descriptions.size()); @@ -41,8 +41,7 @@ struct RowData { std::string table_name; std::vector data_fields; // same index as column_descriptions - const DatabaseColumnDescriptions::VectorOfColumnDescriptions& - column_descriptions; + const DatabaseColumnDescriptions::ColumnDescriptions& column_descriptions; public: ~RowData() = default; diff --git a/core/src/lib/util.cc b/core/src/lib/util.cc index 46fcbc527e0..69b3c7f9700 100644 --- a/core/src/lib/util.cc +++ b/core/src/lib/util.cc @@ -1116,6 +1116,12 @@ void StringToLowerCase(std::string& s) for (auto& c : s) { c = std::tolower(c); } } +void StringToLowerCase(std::string& out, const std::string& in) +{ + out.clear(); + for (const auto& c : in) { out += std::tolower(c); } +} + void SortCaseInsensitive(std::vector& v) { if (v.empty()) { return; } @@ -1133,14 +1139,3 @@ std::string getenv_std_string(std::string env_var) const char* v = (std::getenv(env_var.c_str())); return v ? std::string(v) : std::string(); } - -void ToLowerCase(const std::string& i1, - const std::string& i2, - std::string& o1, - std::string& o2) -{ - o1.clear(); - o2.clear(); - std::transform(i1.cbegin(), i1.cend(), std::back_inserter(o1), ::tolower); - std::transform(i2.cbegin(), i2.cend(), std::back_inserter(o2), ::tolower); -} diff --git a/core/src/lib/util.h b/core/src/lib/util.h index eb46a29f83b..854ead728ee 100644 --- a/core/src/lib/util.h +++ b/core/src/lib/util.h @@ -1,7 +1,7 @@ /* BAREOS® - Backup Archiving REcovery Open Sourced - Copyright (C) 2018-2018 Bareos GmbH & Co. KG + Copyright (C) 2018-2020 Bareos GmbH & Co. KG This program is Free Software; you can redistribute it and/or modify it under the terms of version three of the GNU Affero General Public @@ -69,9 +69,7 @@ void SetWorkingDirectory(const char* wd); const char* last_path_separator(const char* str); void SortCaseInsensitive(std::vector& v); std::string getenv_std_string(std::string env_var); -void ToLowerCase(const std::string& i1, - const std::string& i2, - std::string& o1, - std::string& o2); +void StringToLowerCase(std::string& s); +void StringToLowerCase(std::string& out, const std::string& in); #endif // BAREOS_LIB_UTIL_H_