int test_sky_data_file_deduplicate_insertion_event_data() {
struct tagbstring STR1 = bsStatic("foo");
struct tagbstring STR2 = bsStatic("bar");
struct tagbstring STR3 = bsStatic("zzz");
int rc;
sky_event *event;
sky_data_file *data_file;
INIT_DATA_FILE("tests/fixtures/data_files/dedup/0/a", 0);
// Add initial event.
event = sky_event_create(1, 10LL, 1);
event->data_count = 8;
event->data = calloc(event->data_count, sizeof(*event->data));
event->data[0] = sky_event_data_create_string(-1, &STR2);
event->data[1] = sky_event_data_create_int(-2, 200);
event->data[2] = sky_event_data_create_double(-3, 1.0);
event->data[3] = sky_event_data_create_boolean(-4, false);
event->data[4] = sky_event_data_create_string(1, &STR1);
event->data[5] = sky_event_data_create_int(2, 100);
event->data[6] = sky_event_data_create_double(3, 100.2);
event->data[7] = sky_event_data_create_boolean(4, true);
rc = sky_data_file_add_event(data_file, event);
mu_assert_int_equals(rc, 0);
ASSERT_DATA_FILE("tests/fixtures/data_files/dedup/0/b");
// Add the same event data, different timestamp.
event->timestamp = 11LL;
rc = sky_data_file_add_event(data_file, event);
mu_assert_int_equals(rc, 0);
sky_event_free(event);
ASSERT_DATA_FILE("tests/fixtures/data_files/dedup/0/c");
// Add somewhat different object state event.
event = sky_event_create(1, 12LL, 0);
event->data_count = 4;
event->data = calloc(event->data_count, sizeof(*event->data));
event->data[0] = sky_event_data_create_string(1, &STR3);
event->data[1] = sky_event_data_create_int(2, 20);
event->data[2] = sky_event_data_create_double(3, 100.2);
event->data[3] = sky_event_data_create_boolean(4, false);
rc = sky_data_file_add_event(data_file, event);
mu_assert_int_equals(rc, 0);
sky_event_free(event);
ASSERT_DATA_FILE("tests/fixtures/data_files/dedup/0/d");
sky_data_file_free(data_file);
return 0;
}
// Creates a copy of an event data item.
//
// source - The event data to copy.
// target - A reference to the new event data item.
//
// Returns 0 if successful, otherwise returns -1.
int sky_event_data_copy(sky_event_data *source, sky_event_data **target)
{
check(source != NULL, "Event data source required for copy");
switch(source->data_type) {
case SKY_DATA_TYPE_STRING:
*target = sky_event_data_create_string(source->key, source->string_value);
break;
case SKY_DATA_TYPE_INT:
*target = sky_event_data_create_int(source->key, source->int_value);
break;
case SKY_DATA_TYPE_DOUBLE:
*target = sky_event_data_create_double(source->key, source->double_value);
break;
case SKY_DATA_TYPE_BOOLEAN:
*target = sky_event_data_create_boolean(source->key, source->boolean_value);
break;
default:
sentinel("Invalid data type (%d) for event data", source->data_type);
}
return 0;
error:
if(*target) sky_event_data_free(*target);
*target = NULL;
return -1;
}
int test_sky_add_event_message_worker_map() {
importtmp("tests/fixtures/add_event_message/1/import.json");
sky_table *table = sky_table_create();
table->path = bfromcstr("tmp");
table->default_tablet_count = 1;
sky_table_open(table);
struct tagbstring XYZ_STR = bsStatic("xyz");
sky_add_event_message *message = sky_add_event_message_create();
message->event = sky_event_create(10, 1000L, 20);
message->event->data_count = 4;
message->event->data = calloc(message->event->data_count, sizeof(*message->event->data));
message->event->data[0] = sky_event_data_create_string(1, &XYZ_STR);
message->event->data[1] = sky_event_data_create_int(2, 200);
message->event->data[2] = sky_event_data_create_double(3, 100.2);
message->event->data[3] = sky_event_data_create_boolean(4, true);
sky_worker *worker = sky_worker_create();
worker->data = (void*)message;
void *null = NULL;
int rc = sky_add_event_message_worker_map(worker, table->tablets[0], &null);
mu_assert_int_equals(rc, 0);
void *data;
size_t data_length;
sky_tablet_get_path(table->tablets[0], 10, &data, &data_length);
mu_assert_int_equals(rc, 0);
mu_assert_mem(
data,
"\x03\xE8\x03\x00\x00\x00\x00\x00\x00\x14\x00\x15\x00\x00\x00\x01"
"\xA3\x78\x79\x7A\x02\xD1\x00\xC8\x03\xCB\x40\x59\x0C\xCC\xCC\xCC"
"\xCC\xCD\x04\xC3",
data_length
);
free(data);
sky_add_event_message_free(message);
sky_worker_free(worker);
sky_table_free(table);
return 0;
}
int sky_importer_process_event_data(sky_importer *importer, sky_event *event,
bstring source, jsmntok_t *tokens, uint32_t *index)
{
int rc;
bstring property_name = NULL;
assert(importer != NULL);
assert(source != NULL);
assert(tokens != NULL);
assert(index != NULL);
jsmntok_t *data_token = &tokens[*index];
(*index)++;
// Process over child tokens.
int32_t i;
for(i=0; i<(data_token->size/2); i++) {
sky_event_data *event_data = NULL;
jsmntok_t *key_token = &tokens[*index];
(*index)++;
jsmntok_t *value_token = &tokens[*index];
(*index)++;
// Retrieve property name.
sky_property *property = NULL;
property_name = sky_importer_token_parse_bstring(source, key_token);
rc = sky_property_file_find_by_name(importer->table->property_file, property_name, &property);
check(rc == 0 && property != NULL, "Unable to find property: %s", bdata(property_name));
bdestroy(property_name);
property_name = NULL;
// Reallocate event data array.
event->data_count++;
event->data = realloc(event->data, sizeof(*event->data) * event->data_count);
check_mem(event->data);
// Parse string.
char ch = bdata(source)[value_token->start];
bstring value = sky_importer_token_parse_bstring(source, value_token);
if(value_token->type == JSMN_STRING) {
event_data = sky_event_data_create_string(property->id, value); check_mem(event_data);
}
// Parse primitives.
else if(value_token->type == JSMN_PRIMITIVE) {
// True
if(ch == 't') {
event_data = sky_event_data_create_boolean(property->id, true); check_mem(event_data);
}
// False
else if(ch == 'f') {
event_data = sky_event_data_create_boolean(property->id, false); check_mem(event_data);
}
// Numbers (or null, which evaluates to Int 0).
else {
if(property->data_type == SKY_DATA_TYPE_DOUBLE) {
event_data = sky_event_data_create_double(property->id, atof(bdata(value))); check_mem(event_data);
}
else {
event_data = sky_event_data_create_int(property->id, atoll(bdata(value))); check_mem(event_data);
}
}
}
bdestroy(value);
// Make sure data was generated.
check(event_data != NULL, "Event data could not be parsed for: %s", bdata(property->name));
event->data[event->data_count-1] = event_data;
}
return 0;
error:
bdestroy(property_name);
return -1;
}
