std::vector<ObjectSchemaValidationException> ObjectStore::verify_object_schema(ObjectSchema const& table_schema, ObjectSchema& target_schema) { std::vector<ObjectSchemaValidationException> exceptions; // check to see if properties are the same for (auto& current_prop : table_schema.persisted_properties) { auto target_prop = target_schema.property_for_name(current_prop.name); if (!target_prop) { exceptions.emplace_back(MissingPropertyException(table_schema.name, current_prop)); continue; } if (property_has_changed(current_prop, *target_prop)) { exceptions.emplace_back(MismatchedPropertiesException(table_schema.name, current_prop, *target_prop)); continue; } // create new property with aligned column target_prop->table_column = current_prop.table_column; } // check for change to primary key if (table_schema.primary_key != target_schema.primary_key) { exceptions.emplace_back(ChangedPrimaryKeyException(table_schema.name, table_schema.primary_key, target_schema.primary_key)); } // check for new missing properties for (auto& target_prop : target_schema.persisted_properties) { if (!table_schema.property_for_name(target_prop.name)) { exceptions.emplace_back(ExtraPropertyException(table_schema.name, target_prop)); } } return exceptions; }
static void compare(ObjectSchema const& existing_schema, ObjectSchema const& target_schema, std::vector<SchemaChange>& changes) { for (auto& current_prop : existing_schema.persisted_properties) { auto target_prop = target_schema.property_for_name(current_prop.name); if (!target_prop) { changes.emplace_back(schema_change::RemoveProperty{&existing_schema, ¤t_prop}); continue; } if (target_schema.property_is_computed(*target_prop)) { changes.emplace_back(schema_change::RemoveProperty{&existing_schema, ¤t_prop}); continue; } if (current_prop.type != target_prop->type || current_prop.object_type != target_prop->object_type || is_array(current_prop.type) != is_array(target_prop->type)) { changes.emplace_back(schema_change::ChangePropertyType{&existing_schema, ¤t_prop, target_prop}); continue; } if (is_nullable(current_prop.type) != is_nullable(target_prop->type)) { if (is_nullable(current_prop.type)) changes.emplace_back(schema_change::MakePropertyRequired{&existing_schema, ¤t_prop}); else changes.emplace_back(schema_change::MakePropertyNullable{&existing_schema, ¤t_prop}); } if (target_prop->requires_index()) { if (!current_prop.is_indexed) changes.emplace_back(schema_change::AddIndex{&existing_schema, ¤t_prop}); } else if (current_prop.requires_index()) { changes.emplace_back(schema_change::RemoveIndex{&existing_schema, ¤t_prop}); } } if (existing_schema.primary_key != target_schema.primary_key) { changes.emplace_back(schema_change::ChangePrimaryKey{&existing_schema, target_schema.primary_key_property()}); } for (auto& target_prop : target_schema.persisted_properties) { if (!existing_schema.property_for_name(target_prop.name)) { changes.emplace_back(schema_change::AddProperty{&existing_schema, &target_prop}); } } // Move all RemovePropertys to the end and sort in descending order of // column index, as removing a column will shift all columns after that one auto it = std::partition(begin(changes), end(changes), IsNotRemoveProperty{}); std::sort(it, end(changes), [](auto a, auto b) { return GetRemovedColumn()(a) > GetRemovedColumn()(b); }); }
std::vector<std::string> ObjectStore::validate_schema(Group *group, ObjectSchema &target_schema) { vector<string> validation_errors; ObjectSchema table_schema(group, target_schema.name); // check to see if properties are the same for (auto& current_prop : table_schema.properties) { auto target_prop = target_schema.property_for_name(current_prop.name); if (!target_prop) { validation_errors.push_back("Property '" + current_prop.name + "' is missing from latest object model."); continue; } if (current_prop.type != target_prop->type) { validation_errors.push_back("Property types for '" + target_prop->name + "' property do not match. " + "Old type '" + string_for_property_type(current_prop.type) + "', new type '" + string_for_property_type(target_prop->type) + "'"); continue; } if (current_prop.type == PropertyTypeObject || target_prop->type == PropertyTypeArray) { if (current_prop.object_type != target_prop->object_type) { validation_errors.push_back("Target object type for property '" + current_prop.name + "' does not match. " + "Old type '" + current_prop.object_type + "', new type '" + target_prop->object_type + "'."); } } if (current_prop.is_primary != target_prop->is_primary) { if (current_prop.is_primary) { validation_errors.push_back("Property '" + current_prop.name + "' is no longer a primary key."); } else { validation_errors.push_back("Property '" + current_prop.name + "' has been made a primary key."); } } if (current_prop.is_nullable != target_prop->is_nullable) { if (current_prop.is_nullable) { validation_errors.push_back("Property '" + current_prop.name + "' is no longer optional."); } else { validation_errors.push_back("Property '" + current_prop.name + "' has been made optional."); } } // create new property with aligned column target_prop->table_column = current_prop.table_column; } // check for new missing properties for (auto& target_prop : target_schema.properties) { if (!table_schema.property_for_name(target_prop.name)) { validation_errors.push_back("Property '" + target_prop.name + "' has been added to latest object model."); } } return validation_errors; }
Object Object::get_for_primary_key(ContextType& ctx, std::shared_ptr<Realm> const& realm, const ObjectSchema &object_schema, ValueType primary_value) { auto primary_prop = object_schema.primary_key_property(); if (!primary_prop) { throw MissingPrimaryKeyException(object_schema.name); } auto table = ObjectStore::table_for_object_type(realm->read_group(), object_schema.name); if (!table) return Object(realm, object_schema, RowExpr()); auto row_index = get_for_primary_key_impl(ctx, *table, *primary_prop, primary_value); return Object(realm, object_schema, row_index == realm::not_found ? Row() : Row(table->get(row_index))); }
Object Object::create(ContextType& ctx, std::shared_ptr<Realm> const& realm, ObjectSchema const& object_schema, ValueType value, bool try_update, Row* out_row) { realm->verify_in_write(); // get or create our accessor bool created = false; // try to get existing row if updating size_t row_index = realm::not_found; TableRef table = ObjectStore::table_for_object_type(realm->read_group(), object_schema.name); bool skip_primary = true; if (auto primary_prop = object_schema.primary_key_property()) { // search for existing object based on primary key type auto primary_value = ctx.value_for_property(value, primary_prop->name, primary_prop - &object_schema.persisted_properties[0]); if (!primary_value) primary_value = ctx.default_value_for_property(object_schema, primary_prop->name); if (!primary_value) { if (!is_nullable(primary_prop->type)) throw MissingPropertyValueException(object_schema.name, primary_prop->name); primary_value = ctx.null_value(); } row_index = get_for_primary_key_impl(ctx, *table, *primary_prop, *primary_value); if (row_index == realm::not_found) { created = true; if (primary_prop->type == PropertyType::Int) { #if REALM_HAVE_SYNC_STABLE_IDS row_index = sync::create_object_with_primary_key(realm->read_group(), *table, ctx.template unbox<util::Optional<int64_t>>(*primary_value)); #else row_index = table->add_empty_row(); if (ctx.is_null(*primary_value)) table->set_null_unique(primary_prop->table_column, row_index); else table->set_unique(primary_prop->table_column, row_index, ctx.template unbox<int64_t>(*primary_value)); #endif // REALM_HAVE_SYNC_STABLE_IDS } else if (primary_prop->type == PropertyType::String) { auto value = ctx.template unbox<StringData>(*primary_value); #if REALM_HAVE_SYNC_STABLE_IDS row_index = sync::create_object_with_primary_key(realm->read_group(), *table, value); #else row_index = table->add_empty_row(); table->set_unique(primary_prop->table_column, row_index, value); #endif // REALM_HAVE_SYNC_STABLE_IDS } else { REALM_TERMINATE("Unsupported primary key type."); } } else if (!try_update) { if (realm->is_in_migration()) { // Creating objects with duplicate primary keys is allowed in migrations // as long as there are no duplicates at the end, as adding an entirely // new column which is the PK will inherently result in duplicates at first row_index = table->add_empty_row(); created = true; skip_primary = false; } else { throw std::logic_error(util::format("Attempting to create an object of type '%1' with an existing primary key value '%2'.", object_schema.name, ctx.print(*primary_value))); } } } else { #if REALM_HAVE_SYNC_STABLE_IDS row_index = sync::create_object(realm->read_group(), *table); #else row_index = table->add_empty_row(); #endif // REALM_HAVE_SYNC_STABLE_IDS created = true; } // populate Object object(realm, object_schema, table->get(row_index)); if (out_row) *out_row = object.row(); for (size_t i = 0; i < object_schema.persisted_properties.size(); ++i) { auto& prop = object_schema.persisted_properties[i]; if (skip_primary && prop.is_primary) continue; auto v = ctx.value_for_property(value, prop.name, i); if (!created && !v) continue; bool is_default = false; if (!v) { v = ctx.default_value_for_property(object_schema, prop.name); is_default = true; } if ((!v || ctx.is_null(*v)) && !is_nullable(prop.type) && !is_array(prop.type)) { if (prop.is_primary || !ctx.allow_missing(value)) throw MissingPropertyValueException(object_schema.name, prop.name); } if (v) object.set_property_value_impl(ctx, prop, *v, try_update, is_default); } return object; }