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); });
}
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;
}
