| // Copyright 2024 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/plus_addresses/webdata/plus_address_table.h" |
| |
| #include <optional> |
| #include <string_view> |
| #include <vector> |
| |
| #include "base/check_op.h" |
| #include "base/strings/strcat.h" |
| #include "base/strings/stringprintf.h" |
| #include "components/affiliations/core/browser/affiliation_utils.h" |
| #include "components/plus_addresses/plus_address_types.h" |
| #include "components/sync/base/data_type.h" |
| #include "components/sync/model/metadata_batch.h" |
| #include "components/sync/protocol/data_type_state.pb.h" |
| #include "components/sync/protocol/entity_metadata.pb.h" |
| #include "sql/database.h" |
| #include "sql/statement.h" |
| #include "sql/transaction.h" |
| |
| namespace plus_addresses { |
| |
| namespace { |
| |
| constexpr char kPlusAddressTable[] = "plus_addresses"; |
| constexpr char kProfileId[] = "profile_id"; |
| constexpr char kFacet[] = "facet"; |
| constexpr char kPlusAddress[] = "plus_address"; |
| |
| // The table name uses the legacy name "model type state" as a historic artifact |
| // to avoid a data migration. |
| constexpr char kSyncDataTypeState[] = "plus_address_sync_model_type_state"; |
| constexpr char kModelType[] = "model_type"; |
| constexpr char kValue[] = "value"; |
| |
| constexpr char kSyncEntityMetadata[] = "plus_address_sync_entity_metadata"; |
| // kModelType |
| constexpr char kStorageKey[] = "storage_key"; |
| // kValue |
| |
| // Expects that `s` is pointing to a query result containing `kProfileId`, |
| // `kFacet` and `kPlusAddress`, in that order. Attempts to construct a |
| // `PlusProfile` from that data, returning nullopt if validation fails. |
| std::optional<PlusProfile> PlusProfileFromStatement(sql::Statement& s) { |
| affiliations::FacetURI facet = |
| affiliations::FacetURI::FromPotentiallyInvalidSpec(s.ColumnString(1)); |
| if (!facet.is_valid()) { |
| // Unless modified through external means, the facet is valid. |
| return std::nullopt; |
| } |
| return PlusProfile(/*profile_id=*/s.ColumnString(0), std::move(facet), |
| PlusAddress(s.ColumnString(2)), |
| /*is_confirmed=*/true); |
| } |
| |
| // Populates the `metadata_batch`'s data type state with the state stored for |
| // `data_type`, or the default, if no state is stored. |
| // Returns false if the data type state is unparsable. |
| bool GetDataTypeState(sql::Database& db, |
| syncer::DataType data_type, |
| syncer::MetadataBatch& metadata_batch) { |
| sql::Statement data_type_state_query(db.GetUniqueStatement(base::StringPrintf( |
| "SELECT %s FROM %s WHERE %s=?", kValue, kSyncDataTypeState, kModelType))); |
| data_type_state_query.BindInt(0, |
| syncer::DataTypeToStableIdentifier(data_type)); |
| sync_pb::DataTypeState data_type_state; |
| // When the user just started syncing `data_type`, no data type state is |
| // persisted yet and `Step()` will fail. Don't treat this as an error, but |
| // fallback to the default state instead. |
| if (data_type_state_query.Step() && |
| !data_type_state.ParseFromString( |
| data_type_state_query.ColumnStringView(0))) { |
| return false; |
| } |
| metadata_batch.SetDataTypeState(data_type_state); |
| return true; |
| } |
| |
| // Adds all entity metadata stored for `data_type` to `metadata_batch`. |
| // Returns false and aborts if unparsable data is encountered. |
| bool AddEntityMetadata(sql::Database& db, |
| syncer::DataType data_type, |
| syncer::MetadataBatch& metadata_batch) { |
| sql::Statement entity_query(db.GetUniqueStatement( |
| base::StringPrintf("SELECT %s, %s FROM %s WHERE %s=?", kStorageKey, |
| kValue, kSyncEntityMetadata, kModelType))); |
| entity_query.BindInt(0, syncer::DataTypeToStableIdentifier(data_type)); |
| while (entity_query.Step()) { |
| auto entity_metadata = std::make_unique<sync_pb::EntityMetadata>(); |
| if (!entity_metadata->ParseFromString(entity_query.ColumnStringView(1))) { |
| return false; |
| } |
| metadata_batch.AddMetadata(entity_query.ColumnString(0), |
| std::move(entity_metadata)); |
| } |
| return true; |
| } |
| |
| // The `WebDatabase` manages multiple `WebDatabaseTable` in a `TypeKey` -> table |
| // map. Any unique constant, such as the address of a static suffices as a key. |
| WebDatabaseTable::TypeKey GetKey() { |
| static int table_key = 0; |
| return &table_key; |
| } |
| |
| } // namespace |
| |
| PlusAddressTable::PlusAddressTable() = default; |
| PlusAddressTable::~PlusAddressTable() = default; |
| |
| // static |
| PlusAddressTable* PlusAddressTable::FromWebDatabase(WebDatabase* db) { |
| return static_cast<PlusAddressTable*>(db->GetTable(GetKey())); |
| } |
| |
| WebDatabaseTable::TypeKey PlusAddressTable::GetTypeKey() const { |
| return GetKey(); |
| } |
| |
| bool PlusAddressTable::CreateTablesIfNecessary() { |
| return CreatePlusAddressesTable() && CreateSyncDataTypeStateTable() && |
| CreateSyncEntityMetadataTable(); |
| } |
| |
| bool PlusAddressTable::MigrateToVersion(int version, |
| bool* update_compatible_version) { |
| switch (version) { |
| case 126: |
| *update_compatible_version = false; |
| return MigrateToVersion126_InitialSchema(); |
| case 127: |
| *update_compatible_version = true; |
| return MigrateToVersion127_SyncSupport(); |
| case 128: |
| *update_compatible_version = true; |
| return MigrateToVersion128_ProfileIdString(); |
| } |
| return true; |
| } |
| |
| std::vector<PlusProfile> PlusAddressTable::GetPlusProfiles() const { |
| sql::Statement query(db()->GetUniqueStatement( |
| base::StringPrintf("SELECT %s, %s, %s FROM %s", kProfileId, kFacet, |
| kPlusAddress, kPlusAddressTable))); |
| std::vector<PlusProfile> result; |
| while (query.Step()) { |
| if (std::optional<PlusProfile> profile = PlusProfileFromStatement(query)) { |
| result.push_back(std::move(*profile)); |
| } |
| } |
| return result; |
| } |
| |
| std::optional<PlusProfile> PlusAddressTable::GetPlusProfileForId( |
| std::string_view profile_id) const { |
| sql::Statement query(db()->GetUniqueStatement( |
| base::StringPrintf("SELECT %s, %s, %s FROM %s WHERE %s=?", kProfileId, |
| kFacet, kPlusAddress, kPlusAddressTable, kProfileId))); |
| query.BindString(0, profile_id); |
| if (!query.Step()) { |
| return std::nullopt; |
| } |
| return PlusProfileFromStatement(query); |
| } |
| |
| bool PlusAddressTable::AddOrUpdatePlusProfile(const PlusProfile& profile) { |
| CHECK(profile.is_confirmed); |
| sql::Statement query(db()->GetUniqueStatement(base::StringPrintf( |
| "INSERT OR REPLACE INTO %s (%s, %s, %s) VALUES (?, ?, ?)", |
| kPlusAddressTable, kProfileId, kFacet, kPlusAddress))); |
| query.BindString(0, profile.profile_id.value()); |
| query.BindString(1, profile.facet.canonical_spec()); |
| query.BindString(2, *profile.plus_address); |
| return query.Run(); |
| } |
| |
| bool PlusAddressTable::RemovePlusProfile(std::string_view profile_id) { |
| sql::Statement query(db()->GetUniqueStatement(base::StringPrintf( |
| "DELETE FROM %s WHERE %s=?", kPlusAddressTable, kProfileId))); |
| query.BindString(0, profile_id); |
| return query.Run(); |
| } |
| |
| bool PlusAddressTable::ClearPlusProfiles() { |
| return db()->Execute(base::StrCat({"DELETE FROM ", kPlusAddressTable})); |
| } |
| |
| bool PlusAddressTable::UpdateEntityMetadata( |
| syncer::DataType data_type, |
| const std::string& storage_key, |
| const sync_pb::EntityMetadata& metadata) { |
| CHECK_EQ(data_type, syncer::PLUS_ADDRESS); |
| sql::Statement query(db()->GetUniqueStatement(base::StringPrintf( |
| "INSERT OR REPLACE INTO %s (%s, %s, %s) VALUES (?, ?, ?)", |
| kSyncEntityMetadata, kModelType, kStorageKey, kValue))); |
| query.BindInt(0, syncer::DataTypeToStableIdentifier(data_type)); |
| query.BindString(1, storage_key); |
| query.BindBlob(2, metadata.SerializeAsString()); |
| return query.Run(); |
| } |
| |
| bool PlusAddressTable::ClearEntityMetadata(syncer::DataType data_type, |
| const std::string& storage_key) { |
| CHECK_EQ(data_type, syncer::PLUS_ADDRESS); |
| sql::Statement query(db()->GetUniqueStatement( |
| base::StringPrintf("DELETE FROM %s WHERE %s=? AND %s=?", |
| kSyncEntityMetadata, kModelType, kStorageKey))); |
| query.BindInt(0, syncer::DataTypeToStableIdentifier(data_type)); |
| query.BindString(1, storage_key); |
| return query.Run(); |
| } |
| |
| bool PlusAddressTable::UpdateDataTypeState( |
| syncer::DataType data_type, |
| const sync_pb::DataTypeState& data_type_state) { |
| CHECK_EQ(data_type, syncer::PLUS_ADDRESS); |
| sql::Statement query(db()->GetUniqueStatement( |
| base::StringPrintf("INSERT OR REPLACE INTO %s (%s, %s) VALUES (?, ?)", |
| kSyncDataTypeState, kModelType, kValue))); |
| query.BindInt(0, syncer::DataTypeToStableIdentifier(data_type)); |
| query.BindBlob(1, data_type_state.SerializeAsString()); |
| return query.Run(); |
| } |
| |
| bool PlusAddressTable::ClearDataTypeState(syncer::DataType data_type) { |
| CHECK_EQ(data_type, syncer::PLUS_ADDRESS); |
| sql::Statement query(db()->GetUniqueStatement(base::StringPrintf( |
| "DELETE FROM %s WHERE %s=?", kSyncDataTypeState, kModelType))); |
| query.BindInt(0, syncer::DataTypeToStableIdentifier(data_type)); |
| return query.Run(); |
| } |
| |
| bool PlusAddressTable::GetAllSyncMetadata( |
| syncer::DataType data_type, |
| syncer::MetadataBatch& metadata_batch) { |
| CHECK_EQ(data_type, syncer::PLUS_ADDRESS); |
| return GetDataTypeState(*db(), data_type, metadata_batch) && |
| AddEntityMetadata(*db(), data_type, metadata_batch); |
| } |
| |
| bool PlusAddressTable::CreatePlusAddressesTable() { |
| return db()->DoesTableExist(kPlusAddressTable) || |
| db()->Execute(base::StringPrintf("CREATE TABLE %s (%s VARCHAR PRIMARY " |
| "KEY, %s VARCHAR, %s VARCHAR)", |
| kPlusAddressTable, kProfileId, kFacet, |
| kPlusAddress)); |
| } |
| |
| bool PlusAddressTable::CreateSyncDataTypeStateTable() { |
| return db()->DoesTableExist(kSyncDataTypeState) || |
| db()->Execute(base::StringPrintf( |
| "CREATE TABLE %s (%s INTEGER PRIMARY KEY, %s BLOB)", |
| kSyncDataTypeState, kModelType, kValue)); |
| } |
| |
| bool PlusAddressTable::CreateSyncEntityMetadataTable() { |
| return db()->DoesTableExist(kSyncEntityMetadata) || |
| db()->Execute(base::StringPrintf( |
| "CREATE TABLE %s (%s INTEGER, %s VARCHAR, %s BLOB, " |
| "PRIMARY KEY (%s, %s))", |
| kSyncEntityMetadata, kModelType, kStorageKey, kValue, kModelType, |
| kStorageKey)); |
| } |
| |
| bool PlusAddressTable::MigrateToVersion126_InitialSchema() { |
| return db()->Execute( |
| base::StringPrintf("CREATE TABLE %s (%s VARCHAR PRIMARY KEY, %s VARCHAR)", |
| kPlusAddressTable, kFacet, kPlusAddress)); |
| } |
| |
| bool PlusAddressTable::MigrateToVersion127_SyncSupport() { |
| sql::Transaction transaction(db()); |
| // The migration logic drops the existing `kPlusAddressTable` and recreates it |
| // with a new schema. No data needs to be migrated between the tables, since |
| // the table was not used yet. |
| // Then, new `kSyncDataTypeState` and `kSyncEntityMetadata` tables are |
| // created. |
| return transaction.Begin() && |
| db()->Execute(base::StrCat({"DROP TABLE ", kPlusAddressTable})) && |
| db()->Execute(base::StringPrintf("CREATE TABLE %s (%s INTEGER PRIMARY " |
| "KEY, %s VARCHAR, %s VARCHAR)", |
| kPlusAddressTable, kProfileId, kFacet, |
| kPlusAddress)) && |
| db()->Execute(base::StringPrintf( |
| "CREATE TABLE %s (%s INTEGER PRIMARY KEY, %s BLOB)", |
| kSyncDataTypeState, kModelType, kValue)) && |
| db()->Execute(base::StringPrintf( |
| "CREATE TABLE %s (%s INTEGER, %s VARCHAR, %s BLOB, " |
| "PRIMARY KEY (%s, %s))", |
| kSyncEntityMetadata, kModelType, kStorageKey, kValue, kModelType, |
| kStorageKey)) && |
| transaction.Commit(); |
| } |
| |
| bool PlusAddressTable::MigrateToVersion128_ProfileIdString() { |
| sql::Transaction transaction(db()); |
| // Recreates `kPlusAddressTable`, with `kProfileId`'s type changed to VARCHAR. |
| // No data needs to be migrated, since the table was not used yet. |
| return transaction.Begin() && |
| db()->Execute(base::StrCat({"DROP TABLE ", kPlusAddressTable})) && |
| db()->Execute(base::StringPrintf("CREATE TABLE %s (%s VARCHAR PRIMARY " |
| "KEY, %s VARCHAR, %s VARCHAR)", |
| kPlusAddressTable, kProfileId, kFacet, |
| kPlusAddress)) && |
| transaction.Commit(); |
| } |
| |
| } // namespace plus_addresses |
