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

issue 430.3: remove redundant constructor from SingleCollectionTransaction (#5996)

This commit is contained in:
Vasiliy 2018-07-26 16:54:53 +03:00 committed by Andrey Abramov
parent e4d7f1c5f0
commit 62ca1235ac
38 changed files with 160 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
arangod/IResearch/IResearchRocksDBRecoveryHelper.cpp
View File

@ -204,10 +204,9 @@ void ensureLink(
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(*vocbase),
col.get(),
*col,
arangodb::AccessMode::Type::EXCLUSIVE
);
auto res = trx.begin();
bool created;
@ -356,7 +355,7 @@ void IResearchRocksDBRecoveryHelper::PutCF(uint32_t column_family_id,
auto doc = RocksDBValue::data(value);
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(coll->vocbase()),
coll.get(),
*coll,
arangodb::AccessMode::Type::WRITE
);
@ -398,7 +397,7 @@ void IResearchRocksDBRecoveryHelper::DeleteCF(uint32_t column_family_id,
auto docId = RocksDBKey::documentId(key);
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(coll->vocbase()),
coll.get(),
*coll,
arangodb::AccessMode::Type::WRITE
);
@ -462,4 +461,4 @@ void IResearchRocksDBRecoveryHelper::LogData(const rocksdb::Slice& blob) {
// -----------------------------------------------------------------------------
// --SECTION-- END-OF-FILE
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------

2
arangod/MMFiles/MMFilesCollection.cpp
View File

@ -1769,7 +1769,7 @@ void MMFilesCollection::open(bool ignoreErrors) {
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
&_logicalCollection,
_logicalCollection,
AccessMode::Type::READ
);

2
arangod/MMFiles/MMFilesCollectionKeys.cpp
View File

@ -99,7 +99,7 @@ void MMFilesCollectionKeys::create(TRI_voc_tick_t maxTick) {
// copy all document tokens into the result under the read-lock
{
auto ctx = transaction::StandaloneContext::Create(_collection->vocbase());
SingleCollectionTransaction trx(ctx, _collection, AccessMode::Type::READ);
SingleCollectionTransaction trx(ctx, *_collection, AccessMode::Type::READ);
// already locked by _guard
trx.addHint(transaction::Hints::Hint::NO_USAGE_LOCK);

2
arangod/MMFiles/MMFilesCollectorThread.cpp
View File

@ -762,7 +762,7 @@ int MMFilesCollectorThread::processCollectionOperations(MMFilesCollectorCache* c
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(collection->vocbase()),
collection,
*collection,
AccessMode::Type::WRITE
);

13
arangod/MMFiles/MMFilesCompactorThread.cpp
View File

@ -437,7 +437,7 @@ void MMFilesCompactorThread::compactDatafiles(LogicalCollection* collection,
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(collection->vocbase()),
collection,
*collection,
AccessMode::Type::WRITE
);
@ -688,7 +688,7 @@ bool MMFilesCompactorThread::compactCollection(LogicalCollection* collection, bo
size_t start = physical->getNextCompactionStartIndex();
// get number of documents from collection
uint64_t const numDocuments = getNumberOfDocuments(collection);
uint64_t const numDocuments = getNumberOfDocuments(*collection);
// get maximum size of result file
uint64_t maxSize = MMFilesCompactionFeature::COMPACTOR->maxSizeFactor() * static_cast<MMFilesCollection*>(collection->getPhysical())->journalSize();
@ -1022,7 +1022,9 @@ void MMFilesCompactorThread::run() {
}
/// @brief determine the number of documents in the collection
uint64_t MMFilesCompactorThread::getNumberOfDocuments(LogicalCollection* collection) {
uint64_t MMFilesCompactorThread::getNumberOfDocuments(
LogicalCollection const& collection
) {
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(_vocbase),
collection,
@ -1042,8 +1044,8 @@ uint64_t MMFilesCompactorThread::getNumberOfDocuments(LogicalCollection* collect
if (!res.ok()) {
return 16384; // assume some positive value
}
return collection->numberDocuments(&trx);
return collection.numberDocuments(&trx);
}
/// @brief write a copy of the marker into the datafile
@ -1057,4 +1059,3 @@ int MMFilesCompactorThread::copyMarker(MMFilesDatafile* compactor, MMFilesMarker
return compactor->writeElement(*result, marker);
}

2
arangod/MMFiles/MMFilesCompactorThread.h
View File

@ -97,7 +97,7 @@ class MMFilesCompactorThread final : public Thread {
int removeDatafile(LogicalCollection* collection, MMFilesDatafile* datafile);
/// @brief determine the number of documents in the collection
uint64_t getNumberOfDocuments(LogicalCollection* collection);
uint64_t getNumberOfDocuments(LogicalCollection const& collection);
/// @brief write a copy of the marker into the datafile
int copyMarker(MMFilesDatafile* compactor, MMFilesMarker const* marker,

10
arangod/MMFiles/MMFilesIncrementalSync.h
View File

@ -127,7 +127,7 @@ Result handleSyncKeysMMFiles(arangodb::DatabaseInitialSyncer& syncer,
{
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(syncer.vocbase()),
coll,
*coll,
AccessMode::Type::READ
);
Result res = trx.begin();
@ -158,7 +158,7 @@ Result handleSyncKeysMMFiles(arangodb::DatabaseInitialSyncer& syncer,
{
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(syncer.vocbase()),
coll,
*coll,
AccessMode::Type::READ
);
Result res = trx.begin();
@ -312,7 +312,7 @@ Result handleSyncKeysMMFiles(arangodb::DatabaseInitialSyncer& syncer,
// first chunk
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(syncer.vocbase()),
coll,
*coll,
AccessMode::Type::WRITE
);
@ -391,7 +391,7 @@ Result handleSyncKeysMMFiles(arangodb::DatabaseInitialSyncer& syncer,
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(syncer.vocbase()),
coll,
*coll,
AccessMode::Type::WRITE
);
@ -836,4 +836,4 @@ Result handleSyncKeysMMFiles(arangodb::DatabaseInitialSyncer& syncer,
}
} // namespace arangodb
#endif
#endif

2
arangod/MMFiles/MMFilesV8Functions.cpp
View File

@ -63,7 +63,7 @@ static void JS_RotateVocbaseCol(
SingleCollectionTransaction trx(
transaction::V8Context::Create(collection->vocbase(), true),
collection,
*collection,
AccessMode::Type::WRITE
);
Result res = trx.begin();

10
arangod/MMFiles/MMFilesWalRecoverState.cpp
View File

@ -302,7 +302,7 @@ int MMFilesWalRecoverState::executeSingleOperation(
try {
auto ctx = transaction::StandaloneContext::Create(*vocbase);
SingleCollectionTransaction trx(ctx, collection, AccessMode::Type::WRITE);
SingleCollectionTransaction trx(ctx, *collection, AccessMode::Type::WRITE);
trx.addHint(transaction::Hints::Hint::SINGLE_OPERATION);
trx.addHint(transaction::Hints::Hint::NO_BEGIN_MARKER);
@ -937,10 +937,13 @@ bool MMFilesWalRecoverState::ReplayMarker(MMFilesMarker const* marker,
<< "cannot create index " << indexId << ", collection "
<< collectionId << " in database " << databaseId;
++state->errorCount;
return state->canContinue();
} else {
auto ctx = transaction::StandaloneContext::Create(*vocbase);
arangodb::SingleCollectionTransaction trx(ctx, col.get(), AccessMode::Type::WRITE);
arangodb::SingleCollectionTransaction trx(
ctx, *col, AccessMode::Type::WRITE
);
std::shared_ptr<arangodb::Index> unused;
int res = physical->restoreIndex(&trx, payloadSlice, unused);
@ -949,6 +952,7 @@ bool MMFilesWalRecoverState::ReplayMarker(MMFilesMarker const* marker,
<< "cannot create index " << indexId << ", collection "
<< collectionId << " in database " << databaseId;
++state->errorCount;
return state->canContinue();
}
}
@ -1552,7 +1556,7 @@ int MMFilesWalRecoverState::fillIndexes() {
auto ctx = transaction::StandaloneContext::Create(collection->vocbase());
arangodb::SingleCollectionTransaction trx(
ctx, collection, AccessMode::Type::WRITE
ctx, *collection, AccessMode::Type::WRITE
);
int res = physical->fillAllIndexes(&trx);

23
arangod/Replication/DatabaseInitialSyncer.cpp
View File

@ -744,7 +744,7 @@ Result DatabaseInitialSyncer::fetchCollectionDump(
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(vocbase()),
coll,
*coll,
AccessMode::Type::EXCLUSIVE
);
@ -962,7 +962,7 @@ Result DatabaseInitialSyncer::fetchCollectionSync(
// remote collection has no documents. now truncate our local collection
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(vocbase()),
coll,
*coll,
AccessMode::Type::EXCLUSIVE
);
Result res = trx.begin();
@ -1022,7 +1022,7 @@ Result DatabaseInitialSyncer::changeCollection(arangodb::LogicalCollection* col,
}
/// @brief determine the number of documents in a collection
int64_t DatabaseInitialSyncer::getSize(arangodb::LogicalCollection* col) {
int64_t DatabaseInitialSyncer::getSize(arangodb::LogicalCollection const& col) {
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(vocbase()),
col,
@ -1034,7 +1034,7 @@ int64_t DatabaseInitialSyncer::getSize(arangodb::LogicalCollection* col) {
return -1;
}
OperationResult result = trx.count(col->name(), false);
auto result = trx.count(col.name(), false);
if (result.result.fail()) {
return -1;
@ -1152,7 +1152,7 @@ Result DatabaseInitialSyncer::handleCollection(VPackSlice const& parameters,
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(vocbase()),
col,
*col,
AccessMode::Type::EXCLUSIVE
);
Result res = trx.begin();
@ -1252,15 +1252,12 @@ Result DatabaseInitialSyncer::handleCollection(VPackSlice const& parameters,
parameters.toJson());
}
Result res;
std::string const& masterColl =
!masterUuid.empty() ? masterUuid : itoa(masterCid);
if (incremental && getSize(col) > 0) {
res = fetchCollectionSync(col, masterColl, _config.master.lastLogTick);
} else {
res = fetchCollectionDump(col, masterColl, _config.master.lastLogTick);
}
auto res = incremental && getSize(*col) > 0
? fetchCollectionSync(col, masterColl, _config.master.lastLogTick)
: fetchCollectionDump(col, masterColl, _config.master.lastLogTick)
;
if (!res.ok()) {
return res;
@ -1286,7 +1283,7 @@ Result DatabaseInitialSyncer::handleCollection(VPackSlice const& parameters,
try {
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(vocbase()),
col,
*col,
AccessMode::Type::EXCLUSIVE
);

6
arangod/Replication/DatabaseInitialSyncer.h
View File

@ -94,7 +94,6 @@ class DatabaseInitialSyncer final : public InitialSyncer {
bool isChild() const; // TODO worker safety
};
public:
DatabaseInitialSyncer(TRI_vocbase_t& vocbase,
ReplicationApplierConfiguration const& configuration);
@ -196,7 +195,7 @@ class DatabaseInitialSyncer final : public InitialSyncer {
httpclient::SimpleHttpResult*, uint64_t&);
/// @brief determine the number of documents in a collection
int64_t getSize(arangodb::LogicalCollection*);
int64_t getSize(arangodb::LogicalCollection const& col);
/// @brief incrementally fetch data from a collection
// TODO worker safety
@ -231,10 +230,9 @@ class DatabaseInitialSyncer final : public InitialSyncer {
/// @brief create non-existing views locally
Result handleViewCreation(VPackSlice const& views);
private:
Configuration _config;
};
} // namespace arangodb
#endif
#endif

4
arangod/Replication/Syncer.cpp
View File

@ -540,7 +540,7 @@ Result Syncer::createCollection(TRI_vocbase_t& vocbase,
col->guid() == col->name());
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(vocbase),
col,
*col,
AccessMode::Type::WRITE
);
Result res = trx.begin();
@ -664,7 +664,7 @@ Result Syncer::createIndex(VPackSlice const& slice) {
try {
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(*vocbase),
col.get(),
*col,
AccessMode::Type::WRITE
);
Result res = trx.begin();

2
arangod/Replication/TailingSyncer.cpp
View File

@ -392,7 +392,7 @@ Result TailingSyncer::processDocument(TRI_replication_operation_e type,
// update the apply tick for all standalone operations
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(*vocbase),
coll,
*coll,
AccessMode::Type::EXCLUSIVE
);

16
arangod/RestHandler/RestCollectionHandler.cpp
View File

@ -89,7 +89,7 @@ void RestCollectionHandler::handleCommandGet() {
if (canUse && (!excludeSystem || !coll.system())) {
// We do not need a transaction here
methods::Collections::Context ctxt(_vocbase, &coll);
methods::Collections::Context ctxt(_vocbase, coll);
collectionRepresentation(builder, ctxt,
/*showProperties*/ false,
@ -148,7 +148,7 @@ void RestCollectionHandler::handleCommandGet() {
obj->add("revision", result.slice().get("revision"));
// We do not need a transaction here
methods::Collections::Context ctxt(_vocbase, &coll);
methods::Collections::Context ctxt(_vocbase, coll);
collectionRepresentation(builder, coll, /*showProperties*/ false,
/*showFigures*/ false, /*showCount*/ false,
@ -175,7 +175,7 @@ void RestCollectionHandler::handleCommandGet() {
/*detailedCount*/ true);
} else if (sub == "revision") {
methods::Collections::Context ctxt(_vocbase, &coll);
methods::Collections::Context ctxt(_vocbase, coll);
// /_api/collection/<identifier>/revision
TRI_voc_rid_t revisionId;
auto res =
@ -366,7 +366,7 @@ void RestCollectionHandler::handleCommandPut() {
_request->value("isSynchronousReplication");
auto ctx = transaction::StandaloneContext::Create(_vocbase);
SingleCollectionTransaction trx(ctx, &coll, AccessMode::Type::EXCLUSIVE);
SingleCollectionTransaction trx(ctx, coll, AccessMode::Type::EXCLUSIVE);
res = trx.begin();
@ -418,7 +418,7 @@ void RestCollectionHandler::handleCommandPut() {
} else if (sub == "rotate") {
auto ctx = transaction::StandaloneContext::Create(_vocbase);
SingleCollectionTransaction trx(ctx, &coll, AccessMode::Type::WRITE);
SingleCollectionTransaction trx(ctx, coll, AccessMode::Type::WRITE);
res = trx.begin();
@ -433,7 +433,7 @@ void RestCollectionHandler::handleCommandPut() {
builder.add("result", VPackValue(true));
builder.close();
} else if (sub == "loadIndexesIntoMemory") {
res = methods::Collections::warmup(_vocbase, &coll);
res = methods::Collections::warmup(_vocbase, coll);
VPackObjectBuilder obj(&builder, true);
@ -529,13 +529,13 @@ void RestCollectionHandler::collectionRepresentation(
THROW_ARANGO_EXCEPTION(res);
}
methods::Collections::Context ctxt(_vocbase, &coll, trx.get());
methods::Collections::Context ctxt(_vocbase, coll, trx.get());
collectionRepresentation(builder, ctxt, showProperties, showFigures,
showCount, detailedCount);
} else {
// We do not need a transaction here
methods::Collections::Context ctxt(_vocbase, &coll);
methods::Collections::Context ctxt(_vocbase, coll);
collectionRepresentation(builder, ctxt, showProperties, showFigures,
showCount, detailedCount);

12
arangod/RestHandler/RestReplicationHandler.cpp
View File

@ -898,9 +898,7 @@ Result RestReplicationHandler::processRestoreCollection(
// instead, truncate them
auto ctx = transaction::StandaloneContext::Create(_vocbase);
SingleCollectionTransaction trx(
ctx, col, AccessMode::Type::EXCLUSIVE
);
SingleCollectionTransaction trx(ctx, *col, AccessMode::Type::EXCLUSIVE);
// to turn off waitForSync!
trx.addHint(transaction::Hints::Hint::RECOVERY);
@ -2109,9 +2107,7 @@ void RestReplicationHandler::handleCommandAddFollower() {
if (readLockId.isNone()) {
// Short cut for the case that the collection is empty
auto ctx = transaction::StandaloneContext::Create(_vocbase);
SingleCollectionTransaction trx(
ctx, col.get(), AccessMode::Type::EXCLUSIVE
);
SingleCollectionTransaction trx(ctx, *col, AccessMode::Type::EXCLUSIVE);
auto res = trx.begin();
if (res.ok()) {
@ -2323,8 +2319,8 @@ void RestReplicationHandler::handleCommandHoldReadLockCollection() {
}
auto ctx = transaction::StandaloneContext::Create(_vocbase);
auto trx =
std::make_shared<SingleCollectionTransaction>(ctx, col.get(), access);
auto trx = std::make_shared<SingleCollectionTransaction>(ctx, *col, access);
trx->addHint(transaction::Hints::Hint::LOCK_ENTIRELY);
Result res = trx->begin();

4
arangod/RocksDBEngine/RocksDBCollection.cpp
View File

@ -1667,7 +1667,7 @@ uint64_t RocksDBCollection::recalculateCounts() {
auto ctx =
transaction::StandaloneContext::Create(_logicalCollection.vocbase());
SingleCollectionTransaction trx(
ctx, &_logicalCollection, AccessMode::Type::EXCLUSIVE
ctx, _logicalCollection, AccessMode::Type::EXCLUSIVE
);
auto res = trx.begin();
@ -1802,7 +1802,7 @@ void RocksDBCollection::recalculateIndexEstimates(
auto ctx =
transaction::StandaloneContext::Create(_logicalCollection.vocbase());
arangodb::SingleCollectionTransaction trx(
ctx, &_logicalCollection, AccessMode::Type::EXCLUSIVE
ctx, _logicalCollection, AccessMode::Type::EXCLUSIVE
);
auto res = trx.begin();

7
arangod/RocksDBEngine/RocksDBIncrementalSync.cpp
View File

@ -505,14 +505,15 @@ Result handleSyncKeysRocksDB(DatabaseInitialSyncer& syncer,
ManagedDocumentResult mmdr;
OperationOptions options;
options.silent = true;
options.ignoreRevs = true;
options.isRestore = true;
if (!syncer._state.leaderId.empty()) {
options.isSynchronousReplicationFrom = syncer._state.leaderId;
}
VPackBuilder keyBuilder;
size_t const numChunks = static_cast<size_t>(chunkSlice.length());
// remove all keys that are below first remote key or beyond last remote key
@ -520,7 +521,7 @@ Result handleSyncKeysRocksDB(DatabaseInitialSyncer& syncer,
// first chunk
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(syncer.vocbase()),
col,
*col,
AccessMode::Type::EXCLUSIVE
);
@ -584,7 +585,7 @@ Result handleSyncKeysRocksDB(DatabaseInitialSyncer& syncer,
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(syncer.vocbase()),
col,
*col,
AccessMode::Type::EXCLUSIVE
);

44
arangod/Utils/SingleCollectionTransaction.cpp
View File

@ -25,42 +25,24 @@
#include "StorageEngine/TransactionCollection.h"
#include "StorageEngine/TransactionState.h"
#include "Utils/CollectionNameResolver.h"
#include "Utils/OperationResult.h"
#include "Transaction/Methods.h"
#include "Transaction/Context.h"
#include "VocBase/LogicalCollection.h"
#include "VocBase/LogicalView.h"
#include "VocBase/LogicalDataSource.h"
using namespace arangodb;
namespace arangodb {
/// @brief create the transaction, using a collection
/// @brief create the transaction, using a data-source
SingleCollectionTransaction::SingleCollectionTransaction(
std::shared_ptr<transaction::Context> const& transactionContext,
LogicalCollection const* col, AccessMode::Type accessType)
: transaction::Methods(transactionContext),
_cid(col->id()),
_trxCollection(nullptr),
_documentCollection(nullptr),
_accessType(accessType) {
// add the (sole) collection
addCollection(col->id(), col->name(), _accessType);
addHint(transaction::Hints::Hint::NO_DLD);
}
/// @brief create the transaction, using a collection id
SingleCollectionTransaction::SingleCollectionTransaction(
std::shared_ptr<transaction::Context> const& transactionContext,
LogicalView const& view, AccessMode::Type accessType)
: transaction::Methods(transactionContext),
_cid(view.id()),
_trxCollection(nullptr),
_documentCollection(nullptr),
_accessType(accessType) {
// add the (sole) view
addCollection(view.id(), view.name(), _accessType);
LogicalDataSource const& dataSource,
AccessMode::Type accessType
): transaction::Methods(transactionContext),
_cid(dataSource.id()),
_trxCollection(nullptr),
_documentCollection(nullptr),
_accessType(accessType) {
// add the (sole) data-source
addCollection(dataSource.id(), dataSource.name(), _accessType);
addHint(transaction::Hints::Hint::NO_DLD);
}
@ -113,3 +95,5 @@ std::string SingleCollectionTransaction::name() {
// will ensure we have the _trxCollection object set
return resolveTrxCollection()->collectionName();
}
} // arangodb

36
arangod/Utils/SingleCollectionTransaction.h
View File

@ -30,62 +30,56 @@
#include "VocBase/voc-types.h"
namespace arangodb {
namespace transaction {
class Context;
}
class SingleCollectionTransaction final : public transaction::Methods {
public:
//////////////////////////////////////////////////////////////////////////////
/// @brief create the transaction, using a collection
//////////////////////////////////////////////////////////////////////////////
SingleCollectionTransaction(std::shared_ptr<transaction::Context> const&,
LogicalCollection const*, AccessMode::Type);
//////////////////////////////////////////////////////////////////////////////
/// @brief create the transaction, using a view
/// @brief create the transaction, using a data-source
//////////////////////////////////////////////////////////////////////////////
SingleCollectionTransaction(std::shared_ptr<transaction::Context> const&,
LogicalView const&, AccessMode::Type);
SingleCollectionTransaction(
std::shared_ptr<transaction::Context> const& transactionContext,
LogicalDataSource const& collection,
AccessMode::Type accessType
);
//////////////////////////////////////////////////////////////////////////////
/// @brief create the transaction, using a collection name
//////////////////////////////////////////////////////////////////////////////
SingleCollectionTransaction(std::shared_ptr<transaction::Context> const&,
std::string const&, AccessMode::Type);
//////////////////////////////////////////////////////////////////////////////
/// @brief end the transaction
//////////////////////////////////////////////////////////////////////////////
~SingleCollectionTransaction() = default;
private:
//////////////////////////////////////////////////////////////////////////////
/// @brief get the underlying transaction collection
//////////////////////////////////////////////////////////////////////////////
TransactionCollection* resolveTrxCollection();
public:
//////////////////////////////////////////////////////////////////////////////
/// @brief get the underlying document collection
/// note that we have two identical versions because this is called
/// in two different situations
//////////////////////////////////////////////////////////////////////////////
LogicalCollection* documentCollection();
//////////////////////////////////////////////////////////////////////////////
/// @brief get the underlying collection's id
//////////////////////////////////////////////////////////////////////////////
inline TRI_voc_cid_t cid() const { return _cid; }
#ifdef USE_ENTERPRISE
using transaction::Methods::addCollectionAtRuntime;
#endif
@ -102,30 +96,28 @@ class SingleCollectionTransaction final : public transaction::Methods {
std::string name();
private:
//////////////////////////////////////////////////////////////////////////////
/// @brief collection id
//////////////////////////////////////////////////////////////////////////////
TRI_voc_cid_t _cid;
//////////////////////////////////////////////////////////////////////////////
/// @brief trxCollection cache
//////////////////////////////////////////////////////////////////////////////
TransactionCollection* _trxCollection;
//////////////////////////////////////////////////////////////////////////////
/// @brief LogicalCollection* cache
//////////////////////////////////////////////////////////////////////////////
LogicalCollection* _documentCollection;
//////////////////////////////////////////////////////////////////////////////
/// @brief collection access type
//////////////////////////////////////////////////////////////////////////////
AccessMode::Type _accessType;
};
}
#endif
#endif

12
arangod/V8Server/v8-collection.cpp
View File

@ -990,7 +990,7 @@ static void JS_FiguresVocbaseCol(
SingleCollectionTransaction trx(
transaction::V8Context::Create(collection->vocbase(), true),
collection,
*collection,
AccessMode::Type::READ
);
Result res = trx.begin();
@ -1385,7 +1385,7 @@ static void JS_PropertiesVocbaseCol(
consoleColl->name(),
[&](LogicalCollection& coll)->void {
VPackObjectBuilder object(&builder, true);
methods::Collections::Context ctxt(coll.vocbase(), &coll);
methods::Collections::Context ctxt(coll.vocbase(), coll);
Result res = methods::Collections::properties(ctxt, builder);
if (res.fail()) {
@ -2124,7 +2124,7 @@ static void JS_RevisionVocbaseCol(
TRI_voc_rid_t revisionId;
methods::Collections::Context ctxt(collection->vocbase(), collection);
methods::Collections::Context ctxt(collection->vocbase(), *collection);
auto res = methods::Collections::revisionId(ctxt, revisionId);
if (res.fail()) {
@ -2301,7 +2301,7 @@ static void InsertVocbaseCol(v8::Isolate* isolate,
auto transactionContext =
std::make_shared<transaction::V8Context>(collection->vocbase(), true);
SingleCollectionTransaction trx(
transactionContext, collection, AccessMode::Type::WRITE
transactionContext, *collection, AccessMode::Type::WRITE
);
if (!payloadIsArray && !options.overwrite) {
@ -2451,7 +2451,7 @@ static void JS_TruncateVocbaseCol(
auto ctx = transaction::V8Context::Create(collection->vocbase(), true);
SingleCollectionTransaction trx(
ctx, collection, AccessMode::Type::EXCLUSIVE
ctx, *collection, AccessMode::Type::EXCLUSIVE
);
Result res = trx.begin();
@ -2880,7 +2880,7 @@ static void JS_WarmupVocbaseCol(
TRI_V8_THROW_EXCEPTION_INTERNAL("cannot extract collection");
}
auto res = methods::Collections::warmup(collection->vocbase(), collection);
auto res = methods::Collections::warmup(collection->vocbase(), *collection);
if (res.fail()) {
TRI_V8_THROW_EXCEPTION(res);

4
arangod/V8Server/v8-query.cpp
View File

@ -219,7 +219,7 @@ static void JS_AllQuery(v8::FunctionCallbackInfo<v8::Value> const& args) {
std::shared_ptr<transaction::V8Context> transactionContext =
transaction::V8Context::Create(collection->vocbase(), true);
SingleCollectionTransaction trx(
transactionContext, collection, AccessMode::Type::READ
transactionContext, *collection, AccessMode::Type::READ
);
Result res = trx.begin();
@ -310,7 +310,7 @@ static void JS_AnyQuery(v8::FunctionCallbackInfo<v8::Value> const& args) {
std::shared_ptr<transaction::V8Context> transactionContext =
transaction::V8Context::Create(col->vocbase(), true);
SingleCollectionTransaction trx(
transactionContext, col, AccessMode::Type::READ
transactionContext, *col, AccessMode::Type::READ
);
Result res = trx.begin();

2
arangod/VocBase/LogicalCollection.cpp
View File

@ -1017,7 +1017,7 @@ VPackSlice LogicalCollection::keyOptions() const {
ChecksumResult LogicalCollection::checksum(bool withRevisions, bool withData) const {
auto ctx = transaction::StandaloneContext::Create(vocbase());
SingleCollectionTransaction trx(ctx, this, AccessMode::Type::READ);
SingleCollectionTransaction trx(ctx, *this, AccessMode::Type::READ);
Result res = trx.begin();
if (!res.ok()) {

32
arangod/VocBase/Methods/Collections.cpp
View File

@ -59,16 +59,17 @@ using namespace arangodb;
using namespace arangodb::basics;
using namespace arangodb::methods;
Collections::Context::Context(TRI_vocbase_t& vocbase, LogicalCollection* coll)
Collections::Context::Context(TRI_vocbase_t& vocbase, LogicalCollection& coll)
: _vocbase(vocbase), _coll(coll), _trx(nullptr), _responsibleForTrx(true) {
TRI_ASSERT(_coll != nullptr);
}
}
Collections::Context::Context(TRI_vocbase_t& vocbase, LogicalCollection* coll,
transaction::Methods* trx)
Collections::Context::Context(
TRI_vocbase_t& vocbase,
LogicalCollection& coll,
transaction::Methods* trx
)
: _vocbase(vocbase), _coll(coll), _trx(trx), _responsibleForTrx(false) {
TRI_ASSERT(_trx != nullptr);
TRI_ASSERT(_coll != nullptr);
}
Collections::Context::~Context() {
@ -109,7 +110,7 @@ TRI_vocbase_t& Collections::Context::vocbase() const {
}
LogicalCollection* Collections::Context::coll() const {
return _coll;
return &_coll;
}
void Collections::enumerate(
@ -322,8 +323,7 @@ Result Collections::load(TRI_vocbase_t& vocbase, LogicalCollection* coll) {
}
auto ctx = transaction::V8Context::CreateWhenRequired(vocbase, true);
SingleCollectionTransaction trx(ctx, coll, AccessMode::Type::READ);
SingleCollectionTransaction trx(ctx, *coll, AccessMode::Type::READ);
Result res = trx.begin();
if (res.fail()) {
@ -411,9 +411,7 @@ Result Collections::updateProperties(LogicalCollection* coll,
} else {
auto ctx =
transaction::V8Context::CreateWhenRequired(coll->vocbase(), false);
SingleCollectionTransaction trx(
ctx, coll, AccessMode::Type::EXCLUSIVE
);
SingleCollectionTransaction trx(ctx, *coll, AccessMode::Type::EXCLUSIVE);
Result res = trx.begin();
if (!res.ok()) {
@ -573,7 +571,10 @@ Result Collections::drop(TRI_vocbase_t* vocbase, LogicalCollection* coll,
return res;
}
Result Collections::warmup(TRI_vocbase_t& vocbase, LogicalCollection* coll) {
Result Collections::warmup(
TRI_vocbase_t& vocbase,
LogicalCollection const& coll
) {
ExecContext const* exec = ExecContext::CURRENT; // disallow expensive ops
if (!exec->isSuperuser() && ServerState::readOnly()) {
@ -582,7 +583,7 @@ Result Collections::warmup(TRI_vocbase_t& vocbase, LogicalCollection* coll) {
}
if (ServerState::instance()->isCoordinator()) {
auto cid = std::to_string(coll->id());
auto cid = std::to_string(coll.id());
return warmupOnCoordinator(vocbase.name(), cid);
}
@ -595,11 +596,10 @@ Result Collections::warmup(TRI_vocbase_t& vocbase, LogicalCollection* coll) {
return res;
}
auto idxs = coll->getIndexes();
auto idxs = coll.getIndexes();
auto poster = [](std::function<void()> fn) -> void {
SchedulerFeature::SCHEDULER->post(fn);
};
auto queue = std::make_shared<basics::LocalTaskQueue>(poster);
for (auto& idx : idxs) {

16
arangod/VocBase/Methods/Collections.h
View File

@ -44,9 +44,12 @@ namespace methods {
/// Common code for collection REST handler and v8-collections
struct Collections {
struct Context {
Context(TRI_vocbase_t& vocbase, LogicalCollection* coll);
Context(TRI_vocbase_t& vocbase, LogicalCollection* coll,
transaction::Methods* trx);
Context(TRI_vocbase_t& vocbase, LogicalCollection& coll);
Context(
TRI_vocbase_t& vocbase,
LogicalCollection& coll,
transaction::Methods* trx
);
~Context();
@ -57,7 +60,7 @@ struct Collections {
private:
TRI_vocbase_t& _vocbase;
LogicalCollection* _coll;
LogicalCollection& _coll;
transaction::Methods* _trx;
bool const _responsibleForTrx;
};
@ -91,7 +94,7 @@ struct Collections {
static Result drop(TRI_vocbase_t*, LogicalCollection* coll,
bool allowDropSystem, double timeout);
static Result warmup(TRI_vocbase_t& vocbase, LogicalCollection* coll);
static Result warmup(TRI_vocbase_t& vocbase, LogicalCollection const& coll);
static Result revisionId(Context& ctxt, TRI_voc_rid_t& rid);
@ -109,4 +112,5 @@ Result DropColCoordinatorEnterprise(LogicalCollection* collection,
#endif
}
}
#endif
#endif

9
arangod/VocBase/Methods/Indexes.cpp
View File

@ -138,7 +138,7 @@ arangodb::Result Indexes::getAll(LogicalCollection const* collection,
} else {
SingleCollectionTransaction trx(
transaction::StandaloneContext::Create(collection->vocbase()),
collection,
*collection,
AccessMode::Type::READ
);
@ -260,7 +260,7 @@ static Result EnsureIndexLocal(arangodb::LogicalCollection* collection,
SingleCollectionTransaction trx(
transaction::V8Context::CreateWhenRequired(collection->vocbase(), false),
collection,
*collection,
create ? AccessMode::Type::EXCLUSIVE : AccessMode::Type::READ
);
Result res = trx.begin();
@ -271,6 +271,7 @@ static Result EnsureIndexLocal(arangodb::LogicalCollection* collection,
bool created = false;
std::shared_ptr<arangodb::Index> idx;
if (create) {
try {
idx = collection->createIndex(&trx, definition, created);
@ -285,7 +286,7 @@ static Result EnsureIndexLocal(arangodb::LogicalCollection* collection,
return Result(TRI_ERROR_ARANGO_INDEX_NOT_FOUND);
}
}
TRI_ASSERT(idx != nullptr);
VPackBuilder tmp;
@ -592,7 +593,7 @@ arangodb::Result Indexes::drop(LogicalCollection const* collection,
SingleCollectionTransaction trx(
transaction::V8Context::CreateWhenRequired(collection->vocbase(), false),
collection,
*collection,
AccessMode::Type::EXCLUSIVE
);
Result res = trx.begin();

7
arangod/VocBase/Methods/UpgradeTasks.cpp
View File

@ -139,18 +139,19 @@ arangodb::Result recreateGeoIndex(TRI_vocbase_t& vocbase,
overw.close();
VPackBuilder newDesc = VPackCollection::merge(oldDesc.slice(), overw.slice(), false);
bool dropped = collection.dropIndex(iid);
if (!dropped) {
res.reset(TRI_ERROR_INTERNAL);
return res;
}
bool created = false;
auto ctx = arangodb::transaction::StandaloneContext::Create(vocbase);
arangodb::SingleCollectionTransaction trx(ctx, &collection,
arangodb::AccessMode::Type::EXCLUSIVE);
arangodb::SingleCollectionTransaction trx(
ctx, collection, arangodb::AccessMode::Type::EXCLUSIVE
);
res = trx.begin();

4
tests/IResearch/IResearchIndex-test.cpp
View File

@ -533,7 +533,7 @@ SECTION("test_async_index") {
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(collection0->vocbase()),
collection0,
*collection0,
arangodb::AccessMode::Type::WRITE
);
resThread0 = trx.begin().ok();
@ -571,7 +571,7 @@ SECTION("test_async_index") {
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(collection1->vocbase()),
collection1,
*collection1,
arangodb::AccessMode::Type::WRITE
);
resThread1 = trx.begin().ok();

4
tests/IResearch/IResearchQueryAggregate-test.cpp
View File

@ -197,7 +197,7 @@ TEST_CASE("IResearchQueryTestAggregate", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));
@ -229,7 +229,7 @@ TEST_CASE("IResearchQueryTestAggregate", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));

4
tests/IResearch/IResearchQueryAnd-test.cpp
View File

@ -197,7 +197,7 @@ TEST_CASE("IResearchQueryTestAnd", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));
@ -229,7 +229,7 @@ TEST_CASE("IResearchQueryTestAnd", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));

4
tests/IResearch/IResearchQueryBooleanTerm-test.cpp
View File

@ -202,7 +202,7 @@ TEST_CASE("IResearchQueryTestBooleanTerm", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));
@ -236,7 +236,7 @@ TEST_CASE("IResearchQueryTestBooleanTerm", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));

4
tests/IResearch/IResearchQueryComplexBoolean-test.cpp
View File

@ -197,7 +197,7 @@ TEST_CASE("IResearchQueryTestComplexBoolean", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));
@ -229,7 +229,7 @@ TEST_CASE("IResearchQueryTestComplexBoolean", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));

8
tests/IResearch/IResearchQueryExists-test.cpp
View File

@ -206,7 +206,7 @@ TEST_CASE("IResearchQueryTestExists", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));
@ -238,7 +238,7 @@ TEST_CASE("IResearchQueryTestExists", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));
@ -1464,7 +1464,7 @@ TEST_CASE("IResearchQueryTestExistsStoreMaskPartially", "[iresearch][iresearch-q
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));
@ -1496,7 +1496,7 @@ TEST_CASE("IResearchQueryTestExistsStoreMaskPartially", "[iresearch][iresearch-q
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));

4
tests/IResearch/IResearchQueryIn-test.cpp
View File

@ -197,7 +197,7 @@ TEST_CASE("IResearchQueryTestIn", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));
@ -229,7 +229,7 @@ TEST_CASE("IResearchQueryTestIn", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));

4
tests/IResearch/IResearchQueryNullTerm-test.cpp
View File

@ -200,7 +200,7 @@ TEST_CASE("IResearchQueryTestNullTerm", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));
@ -234,7 +234,7 @@ TEST_CASE("IResearchQueryTestNullTerm", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));

4
tests/IResearch/IResearchQueryPhrase-test.cpp
View File

@ -197,7 +197,7 @@ TEST_CASE("IResearchQueryTestPhrase", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));
@ -229,7 +229,7 @@ TEST_CASE("IResearchQueryTestPhrase", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));

4
tests/IResearch/IResearchQueryTokens-test.cpp
View File

@ -205,7 +205,7 @@ TEST_CASE("IResearchQueryTestTokens", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));
@ -237,7 +237,7 @@ TEST_CASE("IResearchQueryTestTokens", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));

6
tests/IResearch/IResearchQueryTraversal-test.cpp
View File

@ -198,7 +198,7 @@ TEST_CASE("IResearchQueryTestTraversal", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));
@ -230,7 +230,7 @@ TEST_CASE("IResearchQueryTestTraversal", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));
@ -252,7 +252,7 @@ TEST_CASE("IResearchQueryTestTraversal", "[iresearch][iresearch-query]") {
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));

4
tests/IResearch/IResearchQueryValue-test.cpp
View File

@ -197,7 +197,7 @@ TEST_CASE("IResearchQueryTestValue", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));
@ -229,7 +229,7 @@ TEST_CASE("IResearchQueryTestValue", "[iresearch][iresearch-query]") {
options.returnNew = true;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(vocbase),
collection,
*collection,
arangodb::AccessMode::Type::WRITE
);
CHECK((trx.begin().ok()));