void as_view(const Functor& fn) const {
if (size() == 1) {
fn(ExpressionResultLiteral(values.front(), is_nullable() && nulls.front()));
} else if (nulls.size() == 1 && nulls.front()) {
fn(ExpressionResultLiteral(T{}, true));
} else if (!is_nullable()) {
fn(ExpressionResultNonNullSeries(values));
} else {
fn(ExpressionResultNullableSeries(values, nulls));
}
}
size_t Object::get_for_primary_key_impl(ContextType& ctx, Table const& table,
const Property &primary_prop,
ValueType primary_value) {
bool is_null = ctx.is_null(primary_value);
if (is_null && !is_nullable(primary_prop.type))
throw std::logic_error("Invalid null value for non-nullable primary key.");
if (primary_prop.type == PropertyType::String) {
return table.find_first(primary_prop.table_column,
ctx.template unbox<StringData>(primary_value));
}
if (is_nullable(primary_prop.type))
return table.find_first(primary_prop.table_column,
ctx.template unbox<util::Optional<int64_t>>(primary_value));
return table.find_first(primary_prop.table_column,
ctx.template unbox<int64_t>(primary_value));
}
ValueType Object::get_property_value_impl(ContextType& ctx, const Property &property)
{
verify_attached();
size_t column = property.table_column;
if (is_nullable(property.type) && m_row.is_null(column))
return ctx.null_value();
if (is_array(property.type) && property.type != PropertyType::LinkingObjects)
return ctx.box(List(m_realm, *m_row.get_table(), column, m_row.get_index()));
switch (property.type & ~PropertyType::Flags) {
case PropertyType::Bool: return ctx.box(m_row.get_bool(column));
case PropertyType::Int: return ctx.box(m_row.get_int(column));
case PropertyType::Float: return ctx.box(m_row.get_float(column));
case PropertyType::Double: return ctx.box(m_row.get_double(column));
case PropertyType::String: return ctx.box(m_row.get_string(column));
case PropertyType::Data: return ctx.box(m_row.get_binary(column));
case PropertyType::Date: return ctx.box(m_row.get_timestamp(column));
case PropertyType::Any: return ctx.box(m_row.get_mixed(column));
case PropertyType::Object: {
auto linkObjectSchema = m_realm->schema().find(property.object_type);
TableRef table = ObjectStore::table_for_object_type(m_realm->read_group(), property.object_type);
return ctx.box(Object(m_realm, *linkObjectSchema, table->get(m_row.get_link(column))));
}
case PropertyType::LinkingObjects: {
auto target_object_schema = m_realm->schema().find(property.object_type);
auto link_property = target_object_schema->property_for_name(property.link_origin_property_name);
TableRef table = ObjectStore::table_for_object_type(m_realm->read_group(), target_object_schema->name);
auto tv = m_row.get_table()->get_backlink_view(m_row.get_index(), table.get(), link_property->table_column);
return ctx.box(Results(m_realm, std::move(tv)));
}
default: REALM_UNREACHABLE();
}
}
static auto switch_on_type(PropertyType type, Fn&& fn)
{
using PT = PropertyType;
bool is_optional = is_nullable(type);
switch (type & ~PropertyType::Flags) {
case PT::Int: return is_optional ? fn((util::Optional<int64_t>*)0) : fn((int64_t*)0);
case PT::Bool: return is_optional ? fn((util::Optional<bool>*)0) : fn((bool*)0);
case PT::Float: return is_optional ? fn((util::Optional<float>*)0) : fn((float*)0);
case PT::Double: return is_optional ? fn((util::Optional<double>*)0) : fn((double*)0);
case PT::String: return fn((StringData*)0);
case PT::Data: return fn((BinaryData*)0);
case PT::Date: return fn((Timestamp*)0);
case PT::Object: return fn((RowExpr*)0);
default: REALM_COMPILER_HINT_UNREACHABLE();
}
}
static std::string convert(List const& list)
{
std::stringstream ss;
auto type = list.get_type();
ss << string_for_property_type(type & ~PropertyType::Flags);
if (is_nullable(type))
ss << "?";
ss << "{";
StringifyingContext ctx;
for (size_t i = 0, count = list.size(); i < count; ++i)
ss << list.get(ctx, i) << ", ";
auto str = ss.str();
str.pop_back();
str.back() = '}';
return str;
}
static std::string convert(Results const& r)
{
auto& results = const_cast<Results&>(r);
std::stringstream ss;
auto type = results.get_type();
ss << string_for_property_type(type & ~PropertyType::Flags);
if (is_nullable(type))
ss << "?";
ss << "{";
StringifyingContext ctx;
for (size_t i = 0, count = results.size(); i < count; ++i)
ss << results.get(ctx, i) << ", ";
auto str = ss.str();
str.pop_back();
str.back() = '}';
return str;
}
void Object::set_property_value_impl(ContextType& ctx, const Property &property,
ValueType value, bool try_update, bool is_default)
{
ctx.will_change(*this, property);
auto& table = *m_row.get_table();
size_t col = property.table_column;
size_t row = m_row.get_index();
if (is_nullable(property.type) && ctx.is_null(value)) {
if (property.type == PropertyType::Object) {
if (!is_default)
table.nullify_link(col, row);
}
else {
table.set_null(col, row, is_default);
}
ctx.did_change();
return;
}
if (is_array(property.type)) {
if (property.type == PropertyType::LinkingObjects)
throw ReadOnlyPropertyException(m_object_schema->name, property.name);
REALM_ASSERT(property.type == PropertyType::Object);
List list(m_realm, m_row.get_linklist(col));
list.remove_all();
if (!ctx.is_null(value)) {
ContextType child_ctx(ctx, property);
ctx.enumerate_list(value, [&](auto&& element) {
list.add(child_ctx, element, try_update);
});
}
ctx.did_change();
return;
}
switch (property.type & ~PropertyType::Flags) {
case PropertyType::Bool:
table.set(col, row, ctx.template unbox<bool>(value), is_default);
break;
case PropertyType::Int:
table.set(col, row, ctx.template unbox<int64_t>(value), is_default);
break;
case PropertyType::Float:
table.set(col, row, ctx.template unbox<float>(value), is_default);
break;
case PropertyType::Double:
table.set(col, row, ctx.template unbox<double>(value), is_default);
break;
case PropertyType::String:
table.set(col, row, ctx.template unbox<StringData>(value), is_default);
break;
case PropertyType::Data:
table.set(col, row, ctx.template unbox<BinaryData>(value), is_default);
break;
case PropertyType::Any:
throw std::logic_error("not supported");
case PropertyType::Date:
table.set(col, row, ctx.template unbox<Timestamp>(value), is_default);
break;
case PropertyType::Object: {
ContextType child_ctx(ctx, property);
auto link = child_ctx.template unbox<RowExpr>(value, true, try_update);
table.set_link(col, row, link.get_index(), is_default);
break;
}
default:
REALM_COMPILER_HINT_UNREACHABLE();
}
ctx.did_change();
}
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;
}
int
main (int argc, char *argv[])
{
const unsigned char *p, *eof;
int i;
int rc;
const char *error_string;
struct stat sb;
Marpa_Config marpa_configuration;
Marpa_Grammar g;
Marpa_Recognizer r;
/* Longest rule is <= 4 symbols */
Marpa_Symbol_ID rhs[4];
plan(13);
marpa_c_init (&marpa_configuration);
g = marpa_g_new (&marpa_configuration);
if (!g)
{
Marpa_Error_Code errcode =
marpa_c_error (&marpa_configuration, &error_string);
printf ("marpa_g_new returned %d: %s", errcode, error_string);
exit (1);
}
((S_top = marpa_g_symbol_new (g)) >= 0)
|| fail ("marpa_g_symbol_new", g);
((marpa_g_symbol_is_nulled_event_set(g, S_top, 1)) >= 0)
|| fail ("marpa_g_symbol_is_nulled_event_set", g);
((S_A1 = marpa_g_symbol_new (g)) >= 0)
|| fail ("marpa_g_symbol_new", g);
((marpa_g_symbol_is_nulled_event_set(g, S_A1, 1)) >= 0)
|| fail ("marpa_g_symbol_is_nulled_event_set", g);
((S_A2 = marpa_g_symbol_new (g)) >= 0)
|| fail ("marpa_g_symbol_new", g);
((marpa_g_symbol_is_nulled_event_set(g, S_A2, 1)) >= 0)
|| fail ("marpa_g_symbol_is_nulled_event_set", g);
((S_B1 = marpa_g_symbol_new (g)) >= 0)
|| fail ("marpa_g_symbol_new", g);
((marpa_g_symbol_is_nulled_event_set(g, S_B1, 1)) >= 0)
|| fail ("marpa_g_symbol_is_nulled_event_set", g);
((S_B2 = marpa_g_symbol_new (g)) >= 0)
|| fail ("marpa_g_symbol_new", g);
((marpa_g_symbol_is_nulled_event_set(g, S_B2, 1)) >= 0)
|| fail ("marpa_g_symbol_is_nulled_event_set", g);
((S_C1 = marpa_g_symbol_new (g)) >= 0)
|| fail ("marpa_g_symbol_new", g);
((marpa_g_symbol_is_nulled_event_set(g, S_C1, 1)) >= 0)
|| fail ("marpa_g_symbol_is_nulled_event_set", g);
((S_C2 = marpa_g_symbol_new (g)) >= 0)
|| fail ("marpa_g_symbol_new", g);
((marpa_g_symbol_is_nulled_event_set(g, S_C2, 1)) >= 0)
|| fail ("marpa_g_symbol_is_nulled_event_set", g);
rhs[0] = S_A1;
(marpa_g_rule_new (g, S_top, rhs, 1) >= 0)
|| fail ("marpa_g_rule_new", g);
rhs[0] = S_A2;
(marpa_g_rule_new (g, S_top, rhs, 1) >= 0)
|| fail ("marpa_g_rule_new", g);
rhs[0] = S_B1;
(marpa_g_rule_new (g, S_A1, rhs, 1) >= 0)
|| fail ("marpa_g_rule_new", g);
rhs[0] = S_B2;
(marpa_g_rule_new (g, S_A2, rhs, 1) >= 0)
|| fail ("marpa_g_rule_new", g);
rhs[0] = S_C1;
(marpa_g_rule_new (g, S_B1, rhs, 1) >= 0)
|| fail ("marpa_g_rule_new", g);
rhs[0] = S_C2;
(marpa_g_rule_new (g, S_B2, rhs, 1) >= 0)
|| fail ("marpa_g_rule_new", g);
(marpa_g_rule_new (g, S_C1, rhs, 0) >= 0)
|| fail ("marpa_g_rule_new", g);
(marpa_g_rule_new (g, S_C2, rhs, 0) >= 0)
|| fail ("marpa_g_rule_new", g);
(marpa_g_start_symbol_set (g, S_top) >= 0)
|| fail ("marpa_g_start_symbol_set", g);
if (marpa_g_precompute (g) < 0)
{
marpa_g_error (g, &error_string);
puts (error_string);
exit (1);
}
ok(1, "precomputation succeeded");
r = marpa_r_new (g);
if (!r)
{
marpa_g_error (g, &error_string);
puts (error_string);
exit (1);
}
rc = marpa_r_start_input (r);
if (!rc)
{
marpa_g_error (g, &error_string);
puts (error_string);
exit (1);
}
ok((marpa_r_is_exhausted(r)), "exhausted at earleme 0");
{
Marpa_Event event;
const int highest_symbol_id = marpa_g_highest_symbol_id (g);
int exhausted_event_triggered = 0;
int spurious_events = 0;
int spurious_nulled_events = 0;
int event_ix;
const int event_count = marpa_g_event_count (g);
int *nulled_symbols = calloc ((highest_symbol_id + 1), sizeof (int));
if (!nulled_symbols) abort();
ok ((event_count == 8), "event count at earleme 0 is %ld",
(long) event_count);
for (event_ix = 0; event_ix < event_count; event_ix++)
{
int event_type = marpa_g_event (g, &event, event_ix);
if (event_type == MARPA_EVENT_SYMBOL_NULLED)
{
const Marpa_Symbol_ID event_symbol_id = marpa_g_event_value(&event);
nulled_symbols[event_symbol_id]++;
continue;
}
if (event_type == MARPA_EVENT_EXHAUSTED)
{
exhausted_event_triggered++;
continue;
}
printf ("event type is %ld\n", (long) event_type);
spurious_events++;
}
ok ((spurious_events == 0),
"spurious events triggered: %ld", (long) spurious_events);
ok (exhausted_event_triggered, "exhausted event triggered");
for (i = 0; i <= highest_symbol_id; i++)
{
if (is_nullable (i))
{
ok (1, "nulled event triggered for %s", symbol_name (i));
continue;
}
spurious_nulled_events++;
}
ok ((spurious_nulled_events == 0), "spurious nulled events triggered = %ld",
(long) spurious_nulled_events);
free (nulled_symbols);
}
return 0;
}
void Object::set_property_value_impl(ContextType& ctx, const Property &property,
ValueType value, bool try_update, bool update_only_diff, bool is_default)
{
ctx.will_change(*this, property);
auto& table = *m_row.get_table();
size_t col = property.table_column;
size_t row = m_row.get_index();
if (is_nullable(property.type) && ctx.is_null(value)) {
if (!update_only_diff || !table.is_null(col, row)) {
if (property.type == PropertyType::Object) {
if (!is_default)
table.nullify_link(col, row);
}
else {
table.set_null(col, row, is_default);
}
}
ctx.did_change();
return;
}
if (is_array(property.type)) {
if (property.type == PropertyType::LinkingObjects)
throw ReadOnlyPropertyException(m_object_schema->name, property.name);
ContextType child_ctx(ctx, property);
List list(m_realm, table, col, m_row.get_index());
list.assign(child_ctx, value, try_update, update_only_diff);
ctx.did_change();
return;
}
switch (property.type & ~PropertyType::Nullable) {
case PropertyType::Object: {
ContextType child_ctx(ctx, property);
auto curr_link = table.get_link(col,row);
auto link = child_ctx.template unbox<RowExpr>(value, true, try_update, update_only_diff, curr_link);
if (!update_only_diff || curr_link != link.get_index()) {
table.set_link(col, row, link.get_index(), is_default);
}
break;
}
case PropertyType::Bool:
do_update_value<bool>(ctx, table, value, col, row, update_only_diff, is_default);
break;
case PropertyType::Int:
do_update_value<int64_t>(ctx, table, value, col, row, update_only_diff, is_default);
break;
case PropertyType::Float:
do_update_value<float>(ctx, table, value, col, row, update_only_diff, is_default);
break;
case PropertyType::Double:
do_update_value<double>(ctx, table, value, col, row, update_only_diff, is_default);
break;
case PropertyType::String:
do_update_value<StringData>(ctx, table, value, col, row, update_only_diff, is_default);
break;
case PropertyType::Data:
do_update_value<BinaryData>(ctx, table, value, col, row, update_only_diff, is_default);
break;
case PropertyType::Date:
do_update_value<Timestamp>(ctx, table, value, col, row, update_only_diff, is_default);
break;
case PropertyType::Any:
throw std::logic_error("not supported");
default:
REALM_COMPILER_HINT_UNREACHABLE();
}
ctx.did_change();
}
inline bool StringEnumColumn::is_null(size_t ndx) const noexcept
{
return is_nullable() ? get(ndx).is_null() : false;
}
/*=== parse_field ===========================================================
* <Description Text>
*
* Assumes: ?
*
* Returns: (value) when X
* (value) when Y
*
* Modifies: ?
*
* Calls: nothing
*
* Called By: ?
*
* History: MM/DD/YY MRH Created initial version based on function
* 'func()' in motif/csr/file.c
*/
static PARSE_TABLE_TYPE
parse_field(FILE *file,
char *field_name,
FIELD_TYPE *field_type,
int *field_length,
char *null_allowable)
{
char type_string[80];
char nullable[80];
char comment1[80];
char comment2[80];
char line[256];
char *p;
int space_only;
int num_args;
fgets(line, sizeof(line), file);
num_args = sscanf(line, "%s %s %s %s %s",
field_name, type_string, nullable, comment1, comment2);
if (num_args >= 2 && is_comment(field_name))
return TABLE_COMMENT;
if (num_args == 1 && strchr(field_name, ')'))
return TABLE_END;
space_only = 1;
for (p = &(line[0]); p < &(line[strlen(line)]); p++)
if (*p != ' ' && *p != '\n')
space_only = 0;
if (space_only)
return TABLE_COMMENT;
if (num_args < 2)
{
fprintf(stderr, "Unable to scan line (args = %d) : '%s'.",
num_args, line);
return TABLE_PARSE_ERROR;
}
/*
* OK - we have a valid field line. Get the type and length;
* determine if it is null-allowable.
*/
*field_type = get_field_type(type_string);
if (*field_type == FIELD_STRING_TYPE)
*field_length = find_array_length(type_string);
else
*field_length = type_length[*field_type];
*null_allowable = is_nullable(nullable, comment1);
/*
* Finally, determine if the line contains a closing table parenthesis.
* This is a bit tricky, since there may be pairs that we want to ignore.
*/
if (is_table_end(line))
return TABLE_DONE;
return TABLE_OK;
}