void TRI_InitCollectionInfo (TRI_vocbase_t* vocbase,
TRI_col_info_t* parameter,
char const* name,
TRI_col_type_e type,
TRI_voc_size_t maximalSize,
TRI_json_t* keyOptions) {
assert(parameter);
memset(parameter, 0, sizeof(TRI_col_info_t));
parameter->_version = TRI_COL_VERSION;
parameter->_type = type;
parameter->_cid = 0;
parameter->_rid = 0;
parameter->_deleted = false;
parameter->_isVolatile = false;
parameter->_isSystem = false;
parameter->_maximalSize = (maximalSize / PageSize) * PageSize;
if (parameter->_maximalSize == 0 && maximalSize != 0) {
parameter->_maximalSize = PageSize;
}
TRI_CopyString(parameter->_name, name, sizeof(parameter->_name));
parameter->_waitForSync = vocbase->_defaultWaitForSync;
parameter->_keyOptions = keyOptions;
}
static TRI_vocbase_col_t* AddCollection (TRI_vocbase_t* vocbase,
TRI_col_type_t type,
char const* name,
TRI_voc_cid_t cid,
char const* path) {
void const* found;
TRI_vocbase_col_t* col;
// create a new proxy
col = TRI_Allocate(sizeof(TRI_vocbase_col_t));
col->_vocbase = vocbase;
col->_type = type;
TRI_CopyString(col->_name, name, sizeof(col->_name));
col->_path = (path == NULL ? NULL : TRI_DuplicateString(path));
col->_collection = NULL;
col->_newBorn = 0;
col->_loaded = 0;
col->_corrupted = 0;
col->_cid = cid;
// check name
found = TRI_InsertKeyAssociativePointer(&vocbase->_collectionsByName, name, col, false);
if (found != NULL) {
TRI_Free(col);
LOG_ERROR("duplicate entry for name '%s'", name);
return NULL;
}
// check collection identifier
if (cid != 0) {
found = TRI_InsertKeyAssociativePointer(&vocbase->_collectionsById, &cid, col, false);
if (found != NULL) {
TRI_Free(col);
LOG_ERROR("duplicate entry for identifier '%s'", cid);
return NULL;
}
}
TRI_PushBackVectorPointer(&vocbase->_collections, col);
return col;
}
void TRI_CopyCollectionInfo (TRI_col_info_t* dst, const TRI_col_info_t* const src) {
assert(dst);
memset(dst, 0, sizeof(TRI_col_info_t));
dst->_version = src->_version;
dst->_type = src->_type;
dst->_cid = src->_cid;
dst->_rid = src->_rid;
dst->_deleted = src->_deleted;
dst->_isSystem = src->_isSystem;
dst->_isVolatile = src->_isVolatile;
dst->_maximalSize = src->_maximalSize;
TRI_CopyString(dst->_name, src->_name, sizeof(dst->_name));
dst->_waitForSync = src->_waitForSync;
if (src->_keyOptions) {
dst->_keyOptions = TRI_CopyJson(TRI_UNKNOWN_MEM_ZONE, src->_keyOptions);
}
else {
dst->_keyOptions = NULL;
}
}
int TRI_LoadCollectionInfo (char const* path, TRI_col_info_t* parameter) {
TRI_json_t* json;
char* filename;
char* error = NULL;
size_t i;
size_t n;
memset(parameter, 0, sizeof(TRI_col_info_t));
// find parameter file
filename = TRI_Concatenate2File(path, TRI_COL_PARAMETER_FILE);
if (filename == NULL) {
LOG_ERROR("cannot load parameter info for collection '%s', out of memory", path);
return TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
}
if (! TRI_ExistsFile(filename)) {
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return TRI_set_errno(TRI_ERROR_ARANGO_ILLEGAL_PARAMETER_FILE);
}
json = TRI_JsonFile(TRI_UNKNOWN_MEM_ZONE, filename, &error);
if (json == NULL) {
if (error != NULL) {
LOG_ERROR("cannot open '%s', parameter block not readable: %s", filename, error);
TRI_FreeString(TRI_CORE_MEM_ZONE, error);
}
else {
LOG_ERROR("cannot open '%s', parameter block not readable", filename);
}
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return TRI_set_errno(TRI_ERROR_ARANGO_ILLEGAL_PARAMETER_FILE);
}
if (json->_type != TRI_JSON_ARRAY) {
LOG_ERROR("cannot open '%s', file does not contain a json array", filename);
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return TRI_set_errno(TRI_ERROR_ARANGO_ILLEGAL_PARAMETER_FILE);
}
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
// convert json
n = json->_value._objects._length;
for (i = 0; i < n; i += 2) {
TRI_json_t* key;
TRI_json_t* value;
key = TRI_AtVector(&json->_value._objects, i);
value = TRI_AtVector(&json->_value._objects, i + 1);
if (key->_type == TRI_JSON_STRING && value->_type == TRI_JSON_NUMBER) {
if (TRI_EqualString(key->_value._string.data, "version")) {
parameter->_version = value->_value._number;
}
else if (TRI_EqualString(key->_value._string.data, "type")) {
parameter->_type = value->_value._number;
}
else if (TRI_EqualString(key->_value._string.data, "cid")) {
parameter->_cid = value->_value._number;
}
else if (TRI_EqualString(key->_value._string.data, "maximalSize")) {
parameter->_maximalSize = value->_value._number;
}
}
else if (key->_type == TRI_JSON_STRING && value->_type == TRI_JSON_STRING) {
if (TRI_EqualString(key->_value._string.data, "name")) {
TRI_CopyString(parameter->_name, value->_value._string.data, sizeof(parameter->_name));
parameter->_isSystem = TRI_IsSystemCollectionName(parameter->_name);
}
}
else if (key->_type == TRI_JSON_STRING && value->_type == TRI_JSON_BOOLEAN) {
if (TRI_EqualString(key->_value._string.data, "deleted")) {
parameter->_deleted = value->_value._boolean;
}
else if (TRI_EqualString(key->_value._string.data, "isVolatile")) {
parameter->_isVolatile = value->_value._boolean;
}
else if (TRI_EqualString(key->_value._string.data, "waitForSync")) {
parameter->_waitForSync = value->_value._boolean;
}
}
else if (key->_type == TRI_JSON_STRING && value->_type == TRI_JSON_ARRAY) {
if (TRI_EqualString(key->_value._string.data, "keyOptions")) {
parameter->_keyOptions = TRI_CopyJson(TRI_UNKNOWN_MEM_ZONE, value);
}
}
}
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, json);
return TRI_ERROR_NO_ERROR;
}
