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

377 lines
14 KiB
C++
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
/// @brief collection name resolver
///
/// @file
///
/// DISCLAIMER
///
/// Copyright 2014 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
/// http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Jan Steemann
/// @author Copyright 2014, ArangoDB GmbH, Cologne, Germany
/// @author Copyright 2012-2013, triAGENS GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
#ifndef ARANGODB_UTILS_COLLECTION_NAME_RESOLVER_H
#define ARANGODB_UTILS_COLLECTION_NAME_RESOLVER_H 1
#include "Basics/Common.h"
#include "Basics/ReadLocker.h"
#include "Basics/StringBuffer.h"
#include "Basics/StringUtils.h"
#include "Cluster/ServerState.h"
#include "Cluster/ClusterInfo.h"
#include "VocBase/vocbase.h"
namespace triagens {
namespace arango {
// -----------------------------------------------------------------------------
// --SECTION-- class CollectionNameResolver
// -----------------------------------------------------------------------------
class CollectionNameResolver {
// -----------------------------------------------------------------------------
// --SECTION-- constructors / destructors
// -----------------------------------------------------------------------------
public:
////////////////////////////////////////////////////////////////////////////////
/// @brief create the resolver
////////////////////////////////////////////////////////////////////////////////
CollectionNameResolver (TRI_vocbase_t* vocbase)
: _vocbase(vocbase),
_resolvedNames(),
_resolvedIds() {
}
////////////////////////////////////////////////////////////////////////////////
/// @brief destroy the resolver
////////////////////////////////////////////////////////////////////////////////
~CollectionNameResolver () {
}
// -----------------------------------------------------------------------------
// --SECTION-- public methods
// -----------------------------------------------------------------------------
public:
////////////////////////////////////////////////////////////////////////////////
/// @brief look up a collection id for a collection name (local case)
////////////////////////////////////////////////////////////////////////////////
TRI_voc_cid_t getCollectionId (std::string const& name) const {
if (name[0] >= '0' && name[0] <= '9') {
// name is a numeric id
return static_cast<TRI_voc_cid_t>(triagens::basics::StringUtils::uint64(name));
}
TRI_vocbase_col_t const* collection = getCollectionStruct(name);
if (collection != nullptr) {
return collection->_cid;
}
return 0;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief look up a collection struct for a collection name
////////////////////////////////////////////////////////////////////////////////
TRI_vocbase_col_t const* getCollectionStruct (std::string const& name) const {
auto it = _resolvedNames.find(name);
if (it != _resolvedNames.end()) {
return (*it).second;
}
TRI_vocbase_col_t const* collection = TRI_LookupCollectionByNameVocBase(_vocbase, name.c_str());
if (collection != nullptr) {
_resolvedNames.emplace(name, collection);
}
return collection;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief look up a cluster collection id for a cluster collection name
////////////////////////////////////////////////////////////////////////////////
TRI_voc_cid_t getCollectionIdCluster (std::string const& name) const {
if (! ServerState::instance()->isRunningInCluster()) {
return getCollectionId(name);
}
if (name[0] >= '0' && name[0] <= '9') {
// name is a numeric id
return (TRI_voc_cid_t) triagens::basics::StringUtils::uint64(name);
}
// We have to look up the collection info:
ClusterInfo* ci = ClusterInfo::instance();
std::shared_ptr<CollectionInfo> cinfo
= ci->getCollection(DatabaseID(_vocbase->_name),
name);
if (cinfo->empty()) {
return 0;
}
return cinfo->id();
}
////////////////////////////////////////////////////////////////////////////////
/// @brief look up a collection name for a collection id, this implements
/// some magic in the cluster case: a DBserver in a cluster will automatically
/// translate the local collection ID into a cluster wide collection name.
////////////////////////////////////////////////////////////////////////////////
std::string getCollectionName (TRI_voc_cid_t cid) const {
auto it = _resolvedIds.find(cid);
if (it != _resolvedIds.end()) {
return (*it).second;
}
std::string name;
if (ServerState::instance()->isDBServer()) {
READ_LOCKER(_vocbase->_collectionsLock);
TRI_vocbase_col_t* found
= static_cast<TRI_vocbase_col_t*>(
TRI_LookupByKeyAssociativePointer
(&_vocbase->_collectionsById, &cid));
if (nullptr != found) {
if (found->_planId == 0) {
// DBserver local case
char* n = TRI_GetCollectionNameByIdVocBase(_vocbase, cid);
if (n != nullptr) {
name = n;
TRI_Free(TRI_UNKNOWN_MEM_ZONE, n);
}
}
else {
// DBserver case of a shard:
name = triagens::basics::StringUtils::itoa(found->_planId);
std::shared_ptr<CollectionInfo> ci
= ClusterInfo::instance()->getCollection(found->_dbName,name);
name = ci->name(); // can be empty, if collection unknown
}
}
}
else {
// exactly as in the non-cluster case
char* n = TRI_GetCollectionNameByIdVocBase(_vocbase, cid);
if (nullptr != n) {
name = n;
TRI_Free(TRI_UNKNOWN_MEM_ZONE, n);
}
}
if (name.empty()) {
name = "_unknown";
}
_resolvedIds.emplace(cid, name);
return name;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief look up a collection name for a collection id, this implements
/// some magic in the cluster case: a DBserver in a cluster will automatically
/// translate the local collection ID into a cluster wide collection name.
///
/// the name is copied into <buffer>. the caller is responsible for allocating
/// a big-enough buffer (that is, at least 64 bytes). no NUL byte is appended
/// to the buffer. the length of the collection name is returned.
////////////////////////////////////////////////////////////////////////////////
size_t getCollectionName (char* buffer,
TRI_voc_cid_t cid) const {
auto it = _resolvedIds.find(cid);
if (it != _resolvedIds.end()) {
memcpy(buffer, (*it).second.c_str(), (*it).second.size());
return (*it).second.size();
}
std::string&& name(getCollectionName(cid));
memcpy(buffer, name.c_str(), name.size());
return name.size();
}
////////////////////////////////////////////////////////////////////////////////
/// @brief look up a collection name for a collection id, this implements
/// some magic in the cluster case: a DBserver in a cluster will automatically
/// translate the local collection ID into a cluster wide collection name.
///
/// the name is copied into <buffer>. the caller is responsible for allocating
/// a big-enough buffer (that is, at least 64 bytes). no NUL byte is appended
/// to the buffer. the length of the collection name is returned.
////////////////////////////////////////////////////////////////////////////////
void getCollectionName (TRI_voc_cid_t cid,
triagens::basics::StringBuffer& buffer) const {
auto const& it = _resolvedIds.find(cid);
if (it != _resolvedIds.end()) {
buffer.appendText((*it).second.c_str(), (*it).second.size());
return;
}
std::string name(std::move(getCollectionName(cid)));
buffer.appendText(name.c_str(), name.size());
}
////////////////////////////////////////////////////////////////////////////////
/// @brief look up a cluster-wide collection name for a cluster-wide
/// collection id
////////////////////////////////////////////////////////////////////////////////
std::string getCollectionNameCluster (TRI_voc_cid_t cid) const {
if (! ServerState::instance()->isRunningInCluster()) {
return getCollectionName(cid);
}
int tries = 0;
while (tries++ < 2) {
std::shared_ptr<CollectionInfo> ci
= ClusterInfo::instance()->getCollection(_vocbase->_name,
triagens::basics::StringUtils::itoa(cid));
std::string name = ci->name();
if (name.empty()) {
ClusterInfo::instance()->flush();
continue;
}
return name;
}
return "_unknown";
}
////////////////////////////////////////////////////////////////////////////////
/// @brief look up a cluster-wide collection name for a cluster-wide
/// collection id
///
/// the name is copied into <buffer>. the caller is responsible for allocating
/// a big-enough buffer (that is, at least 64 bytes). no NUL byte is appended
/// to the buffer. the length of the collection name is returned.
////////////////////////////////////////////////////////////////////////////////
size_t getCollectionNameCluster (char* buffer,
TRI_voc_cid_t cid) const {
if (! ServerState::instance()->isRunningInCluster()) {
return getCollectionName(buffer, cid);
}
int tries = 0;
while (tries++ < 2) {
std::shared_ptr<CollectionInfo> ci
= ClusterInfo::instance()->getCollection(_vocbase->_name,
triagens::basics::StringUtils::itoa(cid));
std::string name = ci->name();
if (name.empty()) {
ClusterInfo::instance()->flush();
continue;
}
memcpy(buffer, name.c_str(), name.size());
return name.size();
}
memcpy(buffer, "_unknown", strlen("_unknown"));
return strlen("_unknown");
}
////////////////////////////////////////////////////////////////////////////////
/// @brief look up a cluster-wide collection name for a cluster-wide
/// collection id
////////////////////////////////////////////////////////////////////////////////
void getCollectionNameCluster (TRI_voc_cid_t cid,
triagens::basics::StringBuffer& buffer) const {
if (! ServerState::instance()->isRunningInCluster()) {
return getCollectionName(cid, buffer);
}
int tries = 0;
while (tries++ < 2) {
std::shared_ptr<CollectionInfo> ci
= ClusterInfo::instance()->getCollection(_vocbase->_name,
triagens::basics::StringUtils::itoa(cid));
std::string name = ci->name();
if (name.empty()) {
ClusterInfo::instance()->flush();
continue;
}
buffer.appendText(name);
return;
}
buffer.appendText("_unknown");
}
// -----------------------------------------------------------------------------
// --SECTION-- private variables
// -----------------------------------------------------------------------------
private:
////////////////////////////////////////////////////////////////////////////////
/// @brief vocbase base pointer
////////////////////////////////////////////////////////////////////////////////
TRI_vocbase_t* _vocbase;
////////////////////////////////////////////////////////////////////////////////
/// @brief collection id => collection struct map
////////////////////////////////////////////////////////////////////////////////
mutable std::unordered_map<std::string, TRI_vocbase_col_t const*> _resolvedNames;
////////////////////////////////////////////////////////////////////////////////
/// @brief collection id => collection name map
////////////////////////////////////////////////////////////////////////////////
mutable std::unordered_map<TRI_voc_cid_t, std::string> _resolvedIds;
};
}
}
#endif
// -----------------------------------------------------------------------------
// --SECTION-- END-OF-FILE
// -----------------------------------------------------------------------------
// Local Variables:
// mode: outline-minor
// outline-regexp: "/// @brief\\|/// {@inheritDoc}\\|/// @page\\|// --SECTION--\\|/// @\\}"
// End:
Reference in New Issue View Git Blame Copy Permalink