Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

index creation with ids

This commit is contained in:
Jan Steemann 2014-02-13 11:00:08 +01:00
parent 4a8e4dbcaa
commit 4fc8cae57d
17 changed files with 238 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
arangod/CapConstraint/cap-constraint.c
View File

@ -285,6 +285,7 @@ static int RemoveCapConstraint (TRI_index_t* idx,
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_CreateCapConstraint (struct TRI_primary_collection_s* primary,
TRI_idx_iid_t iid,
size_t count,
int64_t size) {
TRI_cap_constraint_t* cap;
@ -299,7 +300,7 @@ TRI_index_t* TRI_CreateCapConstraint (struct TRI_primary_collection_s* primary,
idx = &cap->base;
idx->typeName = TypeNameCapConstraint;
TRI_InitIndex(idx, TRI_IDX_TYPE_CAP_CONSTRAINT, primary, false, true);
TRI_InitIndex(idx, iid, TRI_IDX_TYPE_CAP_CONSTRAINT, primary, false, true);
idx->json = JsonCapConstraint;
idx->removeIndex = RemoveIndexCapConstraint;

1
arangod/CapConstraint/cap-constraint.h
View File

@ -79,6 +79,7 @@ extern "C" {
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_CreateCapConstraint (struct TRI_primary_collection_s*,
TRI_idx_iid_t,
size_t,
int64_t);

56
arangod/Cluster/ClusterInfo.cpp
View File

@ -54,6 +54,40 @@ static inline int setErrormsg (int ourerrno, string& errorMsg) {
errorMsg = TRI_errno_string(ourerrno);
return ourerrno;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief check whether the JSON returns an error
////////////////////////////////////////////////////////////////////////////////
static inline bool hasError (TRI_json_t const* json) {
TRI_json_t const* error = TRI_LookupArrayJson(json, "error");
return (TRI_IsBooleanJson(error) && error->_value._boolean);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief extract the error message from a JSON
////////////////////////////////////////////////////////////////////////////////
static string extractErrorMessage (string const& shardId,
TRI_json_t const* json) {
string msg = " shardID:" + shardId + ": ";
// add error message text
TRI_json_t const* errorMessage = TRI_LookupArrayJson(json, "errorMessage");
if (TRI_IsStringJson(errorMessage)) {
msg += string(errorMessage->_value._string.data,
errorMessage->_value._string.length - 1);
}
// add error number
TRI_json_t const* errorNum = TRI_LookupArrayJson(json, "errorNum");
if (TRI_IsNumberJson(errorNum)) {
msg += " (errNum=" + triagens::basics::StringUtils::itoa(static_cast<uint32_t>(errorNum->_value._number)) + ")";
}
return msg;
}
// -----------------------------------------------------------------------------
// --SECTION-- CollectionInfo class
@ -1539,6 +1573,16 @@ int ClusterInfo::ensureIndexCoordinator (string const& databaseName,
for (size_t i = 0; i < indexes->_value._objects._length; ++i) {
TRI_json_t const* v = TRI_LookupListJson(indexes, i);
// check for errors
if (hasError(v)) {
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, newIndex);
string errorMsg = extractErrorMessage((*it).first, v);
errorMsg = "Error during index creation: " + errorMsg;
return TRI_ERROR_ARANGO_INDEX_CREATION_FAILED;
}
TRI_json_t const* k = TRI_LookupArrayJson(v, "id");
if (! TRI_IsStringJson(k) || idString != string(k->_value._string.data)) {
@ -1643,14 +1687,24 @@ int ClusterInfo::dropIndexCoordinator (string const& databaseName,
for (size_t i = 0; i < indexes->_value._objects._length; ++i) {
TRI_json_t const* v = TRI_LookupListJson(indexes, i);
TRI_json_t const* id = TRI_LookupArrayJson(v, "id");
TRI_json_t const* type = TRI_LookupArrayJson(v, "type");
if (! TRI_IsStringJson(id)) {
if (! TRI_IsStringJson(id) || ! TRI_IsStringJson(type)) {
continue;
}
if (idString == string(id->_value._string.data)) {
// found our index, ignore it when copying
found = true;
string const typeString(type->_value._string.data);
if (typeString == "primary" || typeString == "edge") {
// must not delete these index types
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, copy);
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, collectionJson);
return setErrormsg(TRI_ERROR_FORBIDDEN, errorMsg);
}
continue;
}

6
arangod/GeoIndex/geo-index.c
View File

@ -500,6 +500,7 @@ static int RemoveGeoIndex (TRI_index_t* idx,
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_CreateGeo1Index (struct TRI_primary_collection_s* primary,
TRI_idx_iid_t iid,
char const* locationName,
TRI_shape_pid_t location,
bool geoJson,
@ -515,7 +516,7 @@ TRI_index_t* TRI_CreateGeo1Index (struct TRI_primary_collection_s* primary,
TRI_InitVectorString(&idx->_fields, TRI_CORE_MEM_ZONE);
idx->typeName = TypeNameGeo1Index;
TRI_InitIndex(idx, TRI_IDX_TYPE_GEO1_INDEX, primary, unique, true);
TRI_InitIndex(idx, iid, TRI_IDX_TYPE_GEO1_INDEX, primary, unique, true);
idx->_ignoreNull = ignoreNull;
@ -553,6 +554,7 @@ TRI_index_t* TRI_CreateGeo1Index (struct TRI_primary_collection_s* primary,
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_CreateGeo2Index (struct TRI_primary_collection_s* primary,
TRI_idx_iid_t iid,
char const* latitudeName,
TRI_shape_pid_t latitude,
char const* longitudeName,
@ -570,7 +572,7 @@ TRI_index_t* TRI_CreateGeo2Index (struct TRI_primary_collection_s* primary,
TRI_InitVectorString(&idx->_fields, TRI_CORE_MEM_ZONE);
idx->typeName = TypeNameGeo2Index;
TRI_InitIndex(idx, TRI_IDX_TYPE_GEO2_INDEX, primary, unique, true);
TRI_InitIndex(idx, iid, TRI_IDX_TYPE_GEO2_INDEX, primary, unique, true);
idx->_ignoreNull = ignoreNull;

28
arangod/GeoIndex/geo-index.h
View File

@ -53,24 +53,26 @@ extern "C" {
/// @brief creates a geo-index for lists
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_CreateGeo1Index (struct TRI_primary_collection_s* collection,
char const* locationName,
TRI_shape_pid_t location,
bool geoJson,
bool constraint,
bool ignoreNull);
TRI_index_t* TRI_CreateGeo1Index (struct TRI_primary_collection_s*,
TRI_idx_iid_t,
char const*,
TRI_shape_pid_t,
bool,
bool,
bool);
////////////////////////////////////////////////////////////////////////////////
/// @brief creates a geo-index for arrays
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_CreateGeo2Index (struct TRI_primary_collection_s* collection,
char const* latitudeName,
TRI_shape_pid_t latitude,
char const* longitudeName,
TRI_shape_pid_t longitude,
bool constraint,
bool ignoreNull);
TRI_index_t* TRI_CreateGeo2Index (struct TRI_primary_collection_s*,
TRI_idx_iid_t,
char const*,
TRI_shape_pid_t ,
char const*,
TRI_shape_pid_t,
bool,
bool);
////////////////////////////////////////////////////////////////////////////////
/// @brief frees the memory allocated, but does not free the pointer

3
arangod/HashIndex/hash-index.c
View File

@ -576,6 +576,7 @@ static int RemoveHashIndex (TRI_index_t* idx,
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_CreateHashIndex (struct TRI_primary_collection_s* primary,
TRI_idx_iid_t iid,
TRI_vector_pointer_t* fields,
TRI_vector_t* paths,
bool unique,
@ -592,7 +593,7 @@ TRI_index_t* TRI_CreateHashIndex (struct TRI_primary_collection_s* primary,
idx = &hashIndex->base;
idx->typeName = TypeNameHashIndex;
TRI_InitIndex(idx, TRI_IDX_TYPE_HASH_INDEX, primary, unique, true);
TRI_InitIndex(idx, iid, TRI_IDX_TYPE_HASH_INDEX, primary, unique, true);
idx->json = JsonHashIndex;
idx->insert = InsertHashIndex;

19
arangod/HashIndex/hash-index.h
View File

@ -99,23 +99,24 @@ TRI_hash_index_t;
/// @brief creates a hash index
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_CreateHashIndex (struct TRI_primary_collection_s* collection,
TRI_vector_pointer_t* fields,
TRI_vector_t* paths,
bool unique,
size_t initialDocumentCount);
TRI_index_t* TRI_CreateHashIndex (struct TRI_primary_collection_s*,
TRI_idx_iid_t,
TRI_vector_pointer_t*,
TRI_vector_t*,
bool,
size_t);
////////////////////////////////////////////////////////////////////////////////
/// @brief frees the memory allocated, but does not free the pointer
////////////////////////////////////////////////////////////////////////////////
void TRI_DestroyHashIndex (TRI_index_t* idx);
void TRI_DestroyHashIndex (TRI_index_t*);
////////////////////////////////////////////////////////////////////////////////
/// @brief frees the memory allocated and frees the pointer
////////////////////////////////////////////////////////////////////////////////
void TRI_FreeHashIndex (TRI_index_t* idx);
void TRI_FreeHashIndex (TRI_index_t*);
////////////////////////////////////////////////////////////////////////////////
/// @}
@ -134,8 +135,8 @@ void TRI_FreeHashIndex (TRI_index_t* idx);
/// @brief locates entries in the hash index given shaped json objects
////////////////////////////////////////////////////////////////////////////////
TRI_index_result_t TRI_LookupHashIndex (TRI_index_t* idx,
struct TRI_index_search_value_s* searchValue);
TRI_index_result_t TRI_LookupHashIndex (TRI_index_t*,
struct TRI_index_search_value_s*);
////////////////////////////////////////////////////////////////////////////////
/// @}

61
arangod/V8Server/v8-vocbase.cpp
View File

@ -1086,7 +1086,8 @@ static int EnhanceJsonIndexCap (v8::Handle<v8::Object> const& obj,
////////////////////////////////////////////////////////////////////////////////
static int EnhanceIndexJson (v8::Arguments const& argv,
TRI_json_t*& json) {
TRI_json_t*& json,
bool create) {
v8::Handle<v8::Object> obj = argv[0].As<v8::Object>();
// extract index type
@ -1104,6 +1105,14 @@ static int EnhanceIndexJson (v8::Arguments const& argv,
if (type == TRI_IDX_TYPE_UNKNOWN) {
return TRI_ERROR_BAD_PARAMETER;
}
if (create) {
if (type == TRI_IDX_TYPE_PRIMARY_INDEX ||
type == TRI_IDX_TYPE_EDGE_INDEX) {
// creating these indexes is forbidden
return TRI_ERROR_FORBIDDEN;
}
}
json = TRI_CreateArrayJson(TRI_UNKNOWN_MEM_ZONE);
@ -1554,7 +1563,7 @@ static v8::Handle<v8::Value> EnsureIndex (v8::Arguments const& argv,
}
TRI_json_t* json = 0;
int res = EnhanceIndexJson(argv, json);
int res = EnhanceIndexJson(argv, json, create);
if (res != TRI_ERROR_NO_ERROR) {
if (json != 0) {
@ -2738,7 +2747,7 @@ static v8::Handle<v8::Value> CreateCollectionCoordinator (
ClusterInfo* ci = ClusterInfo::instance();
// fetch a unique id for the new collection plus one for each shard to create
uint64_t id = ci->uniqid(1 + numberOfShards);
const uint64_t id = ci->uniqid(1 + numberOfShards);
// collection id is the first unique id we got
const string cid = StringUtils::itoa(id);
@ -2789,6 +2798,46 @@ static v8::Handle<v8::Value> CreateCollectionCoordinator (
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "shardKeys", JsonHelper::stringList(TRI_UNKNOWN_MEM_ZONE, shardKeys));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "shards", JsonHelper::stringObject(TRI_UNKNOWN_MEM_ZONE, shards));
TRI_json_t* indexes = TRI_CreateListJson(TRI_UNKNOWN_MEM_ZONE);
if (indexes == 0) {
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, json);
TRI_V8_EXCEPTION(scope, TRI_ERROR_OUT_OF_MEMORY);
}
// create a dummy primary index
TRI_index_t* idx = TRI_CreatePrimaryIndex(0);
if (idx == 0) {
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, indexes);
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, json);
TRI_V8_EXCEPTION(scope, TRI_ERROR_OUT_OF_MEMORY);
}
TRI_json_t* idxJson = idx->json(idx);
TRI_FreeIndex(idx);
TRI_PushBack3ListJson(TRI_UNKNOWN_MEM_ZONE, indexes, TRI_CopyJson(TRI_UNKNOWN_MEM_ZONE, idxJson));
TRI_FreeJson(TRI_CORE_MEM_ZONE, idxJson);
if (collectionType == TRI_COL_TYPE_EDGE) {
// create a dummy edge index
idx = TRI_CreateEdgeIndex(0, id);
if (idx == 0) {
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, indexes);
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, json);
TRI_V8_EXCEPTION(scope, TRI_ERROR_OUT_OF_MEMORY);
}
idxJson = idx->json(idx);
TRI_FreeIndex(idx);
TRI_PushBack3ListJson(TRI_UNKNOWN_MEM_ZONE, indexes, TRI_CopyJson(TRI_UNKNOWN_MEM_ZONE, idxJson));
TRI_FreeJson(TRI_CORE_MEM_ZONE, idxJson);
}
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "indexes", indexes);
string errorMsg;
int myerrno = ci->createCollectionCoordinator( databaseName, cid,
numberOfShards, json,
@ -6041,8 +6090,10 @@ static v8::Handle<v8::Value> JS_DropIndexVocbaseCol (v8::Arguments const& argv)
}
}
if (idx->_iid == 0) {
return scope.Close(v8::False());
if (idx->_iid == 0 ||
idx->_type == TRI_IDX_TYPE_PRIMARY_INDEX ||
idx->_type == TRI_IDX_TYPE_EDGE_INDEX) {
TRI_V8_EXCEPTION(scope, TRI_ERROR_FORBIDDEN);
}
// .............................................................................

66
arangod/VocBase/document-collection.c
View File

@ -2814,7 +2814,7 @@ static bool InitDocumentCollection (TRI_document_collection_t* document,
if (document->base.base._info._type == TRI_COL_TYPE_EDGE) {
TRI_index_t* edgesIndex;
edgesIndex = TRI_CreateEdgeIndex(&document->base);
edgesIndex = TRI_CreateEdgeIndex(&document->base, document->base.base._info._cid);
if (edgesIndex == NULL) {
TRI_FreeIndex(primaryIndex);
@ -3670,7 +3670,7 @@ static bool DropIndex (TRI_document_collection_t* document,
if (idx->_type == TRI_IDX_TYPE_PRIMARY_INDEX ||
idx->_type == TRI_IDX_TYPE_EDGE_INDEX) {
// cannot remove these index types
continue;
break;
}
if (idx->_iid == iid) {
@ -4310,7 +4310,7 @@ static TRI_index_t* CreateCapConstraintDocumentCollection (TRI_document_collecti
}
// create a new index
idx = TRI_CreateCapConstraint(primary, count, size);
idx = TRI_CreateCapConstraint(primary, iid, count, size);
if (idx == NULL) {
TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
@ -4318,10 +4318,6 @@ static TRI_index_t* CreateCapConstraintDocumentCollection (TRI_document_collecti
return NULL;
}
if (iid) {
idx->_iid = iid;
}
// initialises the index with all existing documents
res = FillIndex(document, idx);
@ -4579,14 +4575,14 @@ static TRI_index_t* CreateGeoIndexDocumentCollection (TRI_document_collection_t*
// create a new index
if (location != NULL) {
idx = TRI_CreateGeo1Index(primary, location, loc, geoJson, unique, ignoreNull);
idx = TRI_CreateGeo1Index(primary, iid, location, loc, geoJson, unique, ignoreNull);
LOG_TRACE("created geo-index for location '%s': %ld",
location,
(unsigned long) loc);
}
else if (longitude != NULL && latitude != NULL) {
idx = TRI_CreateGeo2Index(primary, latitude, lat, longitude, lon, unique, ignoreNull);
idx = TRI_CreateGeo2Index(primary, iid, latitude, lat, longitude, lon, unique, ignoreNull);
LOG_TRACE("created geo-index for location '%s': %ld, %ld",
location,
@ -4599,10 +4595,6 @@ static TRI_index_t* CreateGeoIndexDocumentCollection (TRI_document_collection_t*
return NULL;
}
if (iid) {
idx->_iid = iid;
}
// initialises the index with all existing documents
res = FillIndex(document, idx);
@ -5049,6 +5041,7 @@ static TRI_index_t* CreateHashIndexDocumentCollection (TRI_document_collection_t
// create the hash index. we'll provide it with the current number of documents
// in the collection so the index can do a sensible memory preallocation
idx = TRI_CreateHashIndex(&document->base,
iid,
&fields,
&paths,
unique,
@ -5065,11 +5058,6 @@ static TRI_index_t* CreateHashIndexDocumentCollection (TRI_document_collection_t
TRI_DestroyVector(&paths);
TRI_DestroyVectorPointer(&fields);
// if index id given, use it otherwise use the default.
if (iid) {
idx->_iid = iid;
}
// initialises the index with all existing documents
res = FillIndex(document, idx);
@ -5270,7 +5258,7 @@ static TRI_index_t* CreateSkiplistIndexDocumentCollection (TRI_document_collecti
}
// Create the skiplist index
idx = TRI_CreateSkiplistIndex(&document->base, &fields, &paths, unique);
idx = TRI_CreateSkiplistIndex(&document->base, iid, &fields, &paths, unique);
if (idx == NULL) {
TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
@ -5281,11 +5269,6 @@ static TRI_index_t* CreateSkiplistIndexDocumentCollection (TRI_document_collecti
TRI_DestroyVector(&paths);
TRI_DestroyVectorPointer(&fields);
// If index id given, use it otherwise use the default.
if (iid) {
idx->_iid = iid;
}
// initialises the index with all existing documents
res = FillIndex(document, idx);
@ -5506,18 +5489,13 @@ static TRI_index_t* CreateFulltextIndexDocumentCollection (TRI_document_collecti
}
// Create the fulltext index
idx = TRI_CreateFulltextIndex(&document->base, attributeName, indexSubstrings, minWordLength);
idx = TRI_CreateFulltextIndex(&document->base, iid, attributeName, indexSubstrings, minWordLength);
if (idx == NULL) {
TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
return NULL;
}
// If index id given, use it otherwise use the default.
if (iid) {
idx->_iid = iid;
}
// initialises the index with all existing documents
res = FillIndex(document, idx);
@ -5722,13 +5700,13 @@ TRI_index_t* TRI_EnsureFulltextIndexDocumentCollection (TRI_document_collection_
////////////////////////////////////////////////////////////////////////////////
static TRI_index_t* CreateBitarrayIndexDocumentCollection (TRI_document_collection_t* document,
const TRI_vector_pointer_t* attributes,
const TRI_vector_pointer_t* values,
TRI_idx_iid_t iid,
bool supportUndef,
bool* created,
int* errorNum,
char** errorStr) {
const TRI_vector_pointer_t* attributes,
const TRI_vector_pointer_t* values,
TRI_idx_iid_t iid,
bool supportUndef,
bool* created,
int* errorNum,
char** errorStr) {
TRI_index_t* idx;
TRI_vector_pointer_t fields;
TRI_vector_t paths;
@ -5780,7 +5758,7 @@ static TRI_index_t* CreateBitarrayIndexDocumentCollection (TRI_document_collecti
// Create the bitarray index
// ...........................................................................
idx = TRI_CreateBitarrayIndex(&document->base, &fields, &paths, (TRI_vector_pointer_t*)(values), supportUndef, errorNum, errorStr);
idx = TRI_CreateBitarrayIndex(&document->base, iid, &fields, &paths, (TRI_vector_pointer_t*)(values), supportUndef, errorNum, errorStr);
if (idx == NULL) {
TRI_DestroyVector(&paths);
@ -5789,7 +5767,6 @@ static TRI_index_t* CreateBitarrayIndexDocumentCollection (TRI_document_collecti
return NULL;
}
// ...........................................................................
// release memory allocated to fields & paths vectors
// ...........................................................................
@ -5797,16 +5774,6 @@ static TRI_index_t* CreateBitarrayIndexDocumentCollection (TRI_document_collecti
TRI_DestroyVector(&paths);
TRI_DestroyVectorPointer(&fields);
// ...........................................................................
// If an index id given, use it otherwise use the default (generate one)
// ...........................................................................
if (iid) {
idx->_iid = iid;
}
// ...........................................................................
// initialises the index with all existing documents
// ...........................................................................
@ -5827,7 +5794,6 @@ static TRI_index_t* CreateBitarrayIndexDocumentCollection (TRI_document_collecti
return NULL;
}
// ...........................................................................
// store index within the collection and return
// ...........................................................................

42
arangod/VocBase/index.c
View File

@ -67,13 +67,26 @@
////////////////////////////////////////////////////////////////////////////////
void TRI_InitIndex (TRI_index_t* idx,
const TRI_idx_type_e type,
TRI_idx_iid_t iid,
TRI_idx_type_e type,
struct TRI_primary_collection_s* primary,
bool unique,
bool needsFullCoverage) {
// note: primary can be NULL
assert(idx != NULL);
idx->_iid = TRI_NewTickServer();
if (iid > 0) {
// use iid if specified
idx->_iid = iid;
}
else if (type == TRI_IDX_TYPE_PRIMARY_INDEX) {
// override iid
idx->_iid = 0;
}
else {
idx->_iid = TRI_NewTickServer();
}
idx->_type = type;
idx->_collection = primary;
idx->_unique = unique;
@ -597,18 +610,21 @@ TRI_index_t* TRI_CreatePrimaryIndex (struct TRI_primary_collection_s* primary) {
TRI_index_t* idx;
char* id;
// note: primary can be NULL
// create primary index
idx = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(TRI_index_t), false);
if (idx == NULL) {
return NULL;
}
id = TRI_DuplicateStringZ(TRI_CORE_MEM_ZONE, "_id");
TRI_InitVectorString(&idx->_fields, TRI_CORE_MEM_ZONE);
TRI_PushBackVectorString(&idx->_fields, id);
idx->typeName = TypeNamePrimary;
TRI_InitIndex(idx, TRI_IDX_TYPE_PRIMARY_INDEX, primary, true, true);
// override iid
idx->_iid = 0;
TRI_InitIndex(idx, 0, TRI_IDX_TYPE_PRIMARY_INDEX, primary, true, true);
idx->json = JsonPrimary;
idx->insert = InsertPrimary;
@ -890,7 +906,8 @@ static TRI_json_t* JsonEdge (TRI_index_t* idx) {
/// @brief create the edge index
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_CreateEdgeIndex (struct TRI_primary_collection_s* primary) {
TRI_index_t* TRI_CreateEdgeIndex (struct TRI_primary_collection_s* primary,
TRI_idx_iid_t iid) {
TRI_edge_index_t* edgeIndex;
TRI_index_t* idx;
char* id;
@ -924,7 +941,7 @@ TRI_index_t* TRI_CreateEdgeIndex (struct TRI_primary_collection_s* primary) {
TRI_PushBackVectorString(&idx->_fields, id);
idx->typeName = TypeNameEdge;
TRI_InitIndex(idx, TRI_IDX_TYPE_EDGE_INDEX, primary, false, true);
TRI_InitIndex(idx, iid, TRI_IDX_TYPE_EDGE_INDEX, primary, false, true);
idx->json = JsonEdge;
idx->insert = InsertEdge;
@ -1485,6 +1502,7 @@ static int RemoveSkiplistIndex (TRI_index_t* idx,
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_CreateSkiplistIndex (TRI_primary_collection_t* primary,
TRI_idx_iid_t iid,
TRI_vector_pointer_t* fields,
TRI_vector_t* paths,
bool unique) {
@ -1503,7 +1521,7 @@ TRI_index_t* TRI_CreateSkiplistIndex (TRI_primary_collection_t* primary,
idx = &skiplistIndex->base;
idx->typeName = TypeNameSkiplistIndex;
TRI_InitIndex(idx, TRI_IDX_TYPE_SKIPLIST_INDEX, primary, unique, true);
TRI_InitIndex(idx, iid, TRI_IDX_TYPE_SKIPLIST_INDEX, primary, unique, true);
idx->json = JsonSkiplistIndex;
idx->insert = InsertSkiplistIndex;
@ -1816,6 +1834,7 @@ static int CleanupFulltextIndex (TRI_index_t* idx) {
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_CreateFulltextIndex (struct TRI_primary_collection_s* primary,
TRI_idx_iid_t iid,
const char* attributeName,
const bool indexSubstrings,
int minWordLength) {
@ -1846,7 +1865,7 @@ TRI_index_t* TRI_CreateFulltextIndex (struct TRI_primary_collection_s* primary,
idx = &fulltextIndex->base;
idx->typeName = TypeNameFulltextIndex;
TRI_InitIndex(idx, TRI_IDX_TYPE_FULLTEXT_INDEX, primary, false, true);
TRI_InitIndex(idx, iid, TRI_IDX_TYPE_FULLTEXT_INDEX, primary, false, true);
idx->json = JsonFulltextIndex;
idx->insert = InsertFulltextIndex;
@ -2492,6 +2511,7 @@ static int RemoveBitarrayIndex (TRI_index_t* idx,
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_CreateBitarrayIndex (struct TRI_primary_collection_s* primary,
TRI_idx_iid_t iid,
TRI_vector_pointer_t* fields,
TRI_vector_t* paths,
TRI_vector_pointer_t* values,
@ -2561,7 +2581,7 @@ TRI_index_t* TRI_CreateBitarrayIndex (struct TRI_primary_collection_s* primary,
idx = &baIndex->base;
idx->typeName = TypeNameBitarrayIndex;
TRI_InitIndex(idx, TRI_IDX_TYPE_BITARRAY_INDEX, primary, false, false);
TRI_InitIndex(idx, iid, TRI_IDX_TYPE_BITARRAY_INDEX, primary, false, false);
idx->json = JsonBitarrayIndex;
idx->insert = InsertBitarrayIndex;

17
arangod/VocBase/index.h
View File

@ -282,8 +282,9 @@ TRI_index_search_value_t;
/// @brief initialise basic index properties
////////////////////////////////////////////////////////////////////////////////
void TRI_InitIndex (TRI_index_t*,
const TRI_idx_type_e,
void TRI_InitIndex (TRI_index_t*,
TRI_idx_iid_t,
TRI_idx_type_e,
struct TRI_primary_collection_s*,
bool,
bool);
@ -441,7 +442,8 @@ void TRI_FreePrimaryIndex (TRI_index_t*);
/// @brief create the edge index
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_CreateEdgeIndex (struct TRI_primary_collection_s*);
TRI_index_t* TRI_CreateEdgeIndex (struct TRI_primary_collection_s*,
TRI_idx_iid_t);
////////////////////////////////////////////////////////////////////////////////
/// @brief destroys an edge index, but does not free the pointer
@ -480,9 +482,10 @@ TRI_skiplist_iterator_t* TRI_LookupSkiplistIndex (TRI_index_t*,
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_CreateSkiplistIndex (struct TRI_primary_collection_s*,
TRI_vector_pointer_t* fields,
TRI_vector_t* paths,
bool unique);
TRI_idx_iid_t,
TRI_vector_pointer_t*,
TRI_vector_t*,
bool);
////////////////////////////////////////////////////////////////////////////////
/// @brief frees the memory allocated, but does not free the pointer
@ -521,6 +524,7 @@ struct TRI_doc_mptr_s** TRI_LookupFulltextIndex (TRI_index_t*,
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_CreateFulltextIndex (struct TRI_primary_collection_s*,
TRI_idx_iid_t,
const char*,
const bool,
int);
@ -568,6 +572,7 @@ TRI_index_iterator_t* TRI_LookupBitarrayIndex (TRI_index_t*,
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_CreateBitarrayIndex (struct TRI_primary_collection_s*,
TRI_idx_iid_t,
TRI_vector_pointer_t*,
TRI_vector_t*,
TRI_vector_pointer_t*,

1
js/apps/system/aardvark/frontend/js/bootstrap/errors.js
View File

@ -95,6 +95,7 @@
"ERROR_ARANGO_INVALID_KEY_GENERATOR" : { "code" : 1232, "message" : "invalid key generator" },
"ERROR_ARANGO_INVALID_EDGE_ATTRIBUTE" : { "code" : 1233, "message" : "edge attribute missing" },
"ERROR_ARANGO_INDEX_DOCUMENT_ATTRIBUTE_MISSING" : { "code" : 1234, "message" : "index insertion warning - attribute missing in document" },
"ERROR_ARANGO_INDEX_CREATION_FAILED" : { "code" : 1235, "message" : "index creation failed" },
"ERROR_ARANGO_DATAFILE_FULL" : { "code" : 1300, "message" : "datafile full" },
"ERROR_REPLICATION_NO_RESPONSE" : { "code" : 1400, "message" : "no response" },
"ERROR_REPLICATION_INVALID_RESPONSE" : { "code" : 1401, "message" : "invalid response" },

1
js/common/bootstrap/errors.js
View File

@ -95,6 +95,7 @@
"ERROR_ARANGO_INVALID_KEY_GENERATOR" : { "code" : 1232, "message" : "invalid key generator" },
"ERROR_ARANGO_INVALID_EDGE_ATTRIBUTE" : { "code" : 1233, "message" : "edge attribute missing" },
"ERROR_ARANGO_INDEX_DOCUMENT_ATTRIBUTE_MISSING" : { "code" : 1234, "message" : "index insertion warning - attribute missing in document" },
"ERROR_ARANGO_INDEX_CREATION_FAILED" : { "code" : 1235, "message" : "index creation failed" },
"ERROR_ARANGO_DATAFILE_FULL" : { "code" : 1300, "message" : "datafile full" },
"ERROR_REPLICATION_NO_RESPONSE" : { "code" : 1400, "message" : "no response" },
"ERROR_REPLICATION_INVALID_RESPONSE" : { "code" : 1401, "message" : "invalid response" },

19
js/server/modules/org/arangodb/cluster.js
View File

@ -533,15 +533,28 @@ function createLocalCollections (plannedCollections) {
for (i = 0; i < payload.indexes.length; ++i) {
index = payload.indexes[i];
if (! indexes.hasOwnProperty(index.id)) {
if (index.type !== "primary" && index.type !== "edge" &&
! indexes.hasOwnProperty(index.id)) {
console.info("creating index '%s/%s': %s",
database,
shard,
JSON.stringify(index));
arangodb.db._collection(shard).ensureIndex(index);
payload.DBServer = ourselves;
indexes[index.id] = index;
try {
arangodb.db._collection(shard).ensureIndex(index);
indexes[index.id].error = false;
indexes[index.id].errorNum = 0;
indexes[index.id].errorMessage = "";
}
catch (err4) {
indexes[index.id].error = true;
indexes[index.id].errorNum = err4.errorNum;
indexes[index.id].errorMessage = err4.errorMessage;
}
payload.DBServer = ourselves;
writeLocked({ part: "Current" },
createCollectionAgency,

3
lib/BasicsC/errors.dat
View File

@ -112,7 +112,8 @@ ERROR_ARANGO_USE_SYSTEM_DATABASE,1230,"operation only allowed in system database
ERROR_ARANGO_ENDPOINT_NOT_FOUND,1231,"endpoint not found","Will be raised when there is an attempt to delete a non-existing endpoint."
ERROR_ARANGO_INVALID_KEY_GENERATOR,1232,"invalid key generator","Will be raised when an invalid key generator description is used."
ERROR_ARANGO_INVALID_EDGE_ATTRIBUTE,1233,"edge attribute missing","will be raised when the _from or _to values of an edge are undefined or contain an invalid value."
ERROR_ARANGO_INDEX_DOCUMENT_ATTRIBUTE_MISSING,1234,"index insertion warning - attribute missing in document","Will be raised when an attempt to insert a document into an index is caused by in the document not having one or more attributes which the index is built on"
ERROR_ARANGO_INDEX_DOCUMENT_ATTRIBUTE_MISSING,1234,"index insertion warning - attribute missing in document","Will be raised when an attempt to insert a document into an index is caused by in the document not having one or more attributes which the index is built on."
ERROR_ARANGO_INDEX_CREATION_FAILED,1235,"index creation failed","Will be raised when an attempt to create an index has failed."
################################################################################
## ArangoDB storage errors

1
lib/BasicsC/voc-errors.c
View File

@ -91,6 +91,7 @@ void TRI_InitialiseErrorMessages (void) {
REG_ERROR(ERROR_ARANGO_INVALID_KEY_GENERATOR, "invalid key generator");
REG_ERROR(ERROR_ARANGO_INVALID_EDGE_ATTRIBUTE, "edge attribute missing");
REG_ERROR(ERROR_ARANGO_INDEX_DOCUMENT_ATTRIBUTE_MISSING, "index insertion warning - attribute missing in document");
REG_ERROR(ERROR_ARANGO_INDEX_CREATION_FAILED, "index creation failed");
REG_ERROR(ERROR_ARANGO_DATAFILE_FULL, "datafile full");
REG_ERROR(ERROR_REPLICATION_NO_RESPONSE, "no response");
REG_ERROR(ERROR_REPLICATION_INVALID_RESPONSE, "invalid response");

16
lib/BasicsC/voc-errors.h
View File

@ -192,7 +192,9 @@ extern "C" {
/// - 1234: @LIT{index insertion warning - attribute missing in document}
/// Will be raised when an attempt to insert a document into an index is
/// caused by in the document not having one or more attributes which the
/// index is built on
/// index is built on.
/// - 1235: @LIT{index creation failed}
/// Will be raised when an attempt to create an index has failed.
/// - 1300: @LIT{datafile full}
/// Will be raised when the datafile reaches its limit.
/// - 1400: @LIT{no response}
@ -1310,11 +1312,21 @@ void TRI_InitialiseErrorMessages (void);
///
/// Will be raised when an attempt to insert a document into an index is caused
/// by in the document not having one or more attributes which the index is
/// built on
/// built on.
////////////////////////////////////////////////////////////////////////////////
#define TRI_ERROR_ARANGO_INDEX_DOCUMENT_ATTRIBUTE_MISSING (1234)
////////////////////////////////////////////////////////////////////////////////
/// @brief 1235: ERROR_ARANGO_INDEX_CREATION_FAILED
///
/// index creation failed
///
/// Will be raised when an attempt to create an index has failed.
////////////////////////////////////////////////////////////////////////////////
#define TRI_ERROR_ARANGO_INDEX_CREATION_FAILED (1235)
////////////////////////////////////////////////////////////////////////////////
/// @brief 1300: ERROR_ARANGO_DATAFILE_FULL
///