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