// 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; }
// Creates a reference to event data with no data type. // // key - The property id used as the key for the data. sky_event_data *sky_event_data_create(sky_property_id_t key) { sky_event_data *data = calloc(1, sizeof(sky_event_data)); check_mem(data); data->key = key; data->data_type = SKY_DATA_TYPE_NONE; return data; error: sky_event_data_free(data); return NULL; }
// Creates a reference to event data representing a boolean. // // key - The property id used as the key for the data. // value - The boolean value of the data. sky_event_data *sky_event_data_create_boolean(sky_property_id_t key, bool value) { sky_event_data *data = calloc(1, sizeof(sky_event_data)); check_mem(data); data->key = key; data->data_type = SKY_DATA_TYPE_BOOLEAN; data->boolean_value = value; return data; error: sky_event_data_free(data); return NULL; }
// Creates a reference to event data representing a double. // // key - The property id used as the key for the data. // value - The double value of the data. sky_event_data *sky_event_data_create_double(sky_property_id_t key, double value) { sky_event_data *data = calloc(1, sizeof(sky_event_data)); check_mem(data); data->key = key; data->data_type = SKY_DATA_TYPE_DOUBLE; data->double_value = value; return data; error: sky_event_data_free(data); return NULL; }
// Creates a reference to event data representing a 64-bit integer. // // key - The property id used as the key for the data. // value - The integer value of the data. sky_event_data *sky_event_data_create_int(sky_property_id_t key, int64_t value) { sky_event_data *data = calloc(1, sizeof(sky_event_data)); check_mem(data); data->key = key; data->data_type = SKY_DATA_TYPE_INT; data->int_value = value; return data; error: sky_event_data_free(data); return NULL; }
// Creates a reference to event data. // // key - The property id used as the key for the data. // value - The string value of the data. sky_event_data *sky_event_data_create_string(sky_property_id_t key, bstring value) { sky_event_data *data = calloc(1, sizeof(sky_event_data)); check_mem(data); data->key = key; data->data_type = SKY_DATA_TYPE_STRING; data->string_value = bstrcpy(value); if(value) check_mem(data->string_value); return data; error: sky_event_data_free(data); return NULL; }
// Adds an event to the tablet. // // tablet - The tablet. // event - The event to add. // // Returns 0 if successful, otherwise returns -1. int sky_tablet_add_event(sky_tablet *tablet, sky_event *event) { int rc; char *errptr = NULL; void *new_data = NULL; void *data = NULL; sky_data_object *data_object = NULL; sky_data_descriptor *descriptor = NULL; sky_cursor cursor; memset(&cursor, 0, sizeof(cursor)); assert(tablet != NULL); assert(event != NULL); // Make sure that this event is being added to the correct tablet. sky_tablet *target_tablet = NULL; rc = sky_table_get_target_tablet(tablet->table, event->object_id, &target_tablet); check(rc == 0, "Unable to determine target tablet"); check(tablet == target_tablet, "Event added to invalid tablet; IDX:%d of %d, OID:%d", tablet->index, tablet->table->tablet_count, event->object_id); // Retrieve the existing value. size_t data_length; data = (void*)leveldb_get(tablet->leveldb_db, tablet->readoptions, (const char*)&event->object_id, sizeof(event->object_id), &data_length, &errptr); check(errptr == NULL, "LevelDB get error: %s", errptr); // Find the insertion point on the path. size_t insert_offset = 0; size_t event_length; // If the object doesn't exist yet then just set the single event. Easy peasy. if(data == NULL) { event_length = sky_event_sizeof(event); new_data = calloc(1, event_length); check_mem(new_data); insert_offset = 0; } // If the object does exist, we need to find where to insert the event data. // Also, we need to strip off any state which is redundant at the point of // insertion. else { void *insert_ptr = NULL; // Initialize data descriptor. descriptor = sky_data_descriptor_create(); check_mem(descriptor); rc = sky_data_descriptor_init_with_event(descriptor, event); check(rc == 0, "Unable to initialize data descriptor for event insert"); // Initialize data object. data_object = calloc(1, descriptor->data_sz); check_mem(data); // Attach data & descriptor to the cursor. cursor.data_descriptor = descriptor; cursor.data = (void*)data_object; // Initialize the cursor. rc = sky_cursor_set_ptr(&cursor, data, data_length); check(rc == 0, "Unable to set pointer on cursor"); // Loop over cursor until we reach the event insertion point. while(!cursor.eof) { // Retrieve event insertion pointer once the timestamp is reached. if(data_object->ts >= event->timestamp) { insert_ptr = cursor.ptr; break; } // Move to next event. check(sky_cursor_next_event(&cursor) == 0, "Unable to move to next event"); } // If no insertion point was found then append the event to the // end of the path. if(insert_ptr == NULL) { insert_ptr = data + data_length; } insert_offset = insert_ptr - data; // Clear off any object data on the event that matches // what is the current state of the event in the database. uint32_t i; for(i=0; i<event->data_count; i++) { // Ignore any action properties. if(event->data[i]->key > 0) { sky_data_property_descriptor *property_descriptor = &descriptor->property_zero_descriptor[event->data[i]->key]; // If the values match then splice this from the array. // Compare strings. void *a = &event->data[i]->value; void *b = ((void*)data_object)+property_descriptor->offset; size_t n = sky_data_type_sizeof(event->data[i]->data_type); bool is_equal = false; if(event->data[i]->data_type == SKY_DATA_TYPE_STRING) { is_equal = sky_string_bequals((sky_string*)b, event->data[i]->string_value); } // Compare other types. else if(memcmp(a, b, n) == 0) { is_equal = true; } // If the data is equal then remove it. if(is_equal) { sky_event_data_free(event->data[i]); if(i < event->data_count - 1) { memmove(&event->data[i], &event->data[i+1], (event->data_count-i-1) * sizeof(*event->data)); } i--; event->data_count--; } } } // Determine the serialized size of the event. If the event is // completely redundant (e.g. it is a data-only event and the event // matches the current object state) then don't allocate space for a // new path value. event_length = sky_event_sizeof(event); if(event_length > 0) { // Allocate space for the existing data plus the new data. new_data = calloc(1, data_length + event_length); check_mem(new_data); // Copy in data before event. if(insert_offset > 0) { memmove(new_data, data, insert_ptr-data); } // Copy in data after event. if(insert_offset < data_length) { event_length = sky_event_sizeof(event); memmove(new_data+insert_offset+event_length, data+insert_offset, data_length-insert_offset); } } } // If no space was allocated then it means the event is redundant and // should be ignored. if(new_data != NULL) { // If the object doesn't exist then just set the event as the data. size_t event_sz; rc = sky_event_pack(event, new_data + insert_offset, &event_sz); check(rc == 0, "Unable to pack event"); check(event_sz == event_length, "Expected event size (%ld) does not match actual event size (%ld)", event_length, event_sz); leveldb_put(tablet->leveldb_db, tablet->writeoptions, (const char*)&event->object_id, sizeof(event->object_id), new_data, data_length + event_length, &errptr); check(errptr == NULL, "LevelDB put error: %s", errptr); } free(data_object); sky_data_descriptor_free(descriptor); free(data); free(new_data); return 0; error: if(errptr) leveldb_free(errptr); sky_data_descriptor_free(descriptor); if(data) free(data); if(new_data) free(new_data); if(data_object) free(data_object); return -1; }