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

added more tests

This commit is contained in:
Jan Steemann 2015-03-19 18:21:00 +01:00
parent cf845bbe5e
commit 50c4682655
3 changed files with 634 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
arangod/Aql/AqlItemBlock.h
View File

@ -125,6 +125,9 @@ namespace triagens {
if (! value.isEmpty()) { if (! value.isEmpty()) {
auto it = _valueCount.find(value); auto it = _valueCount.find(value);
if (it == _valueCount.end()) { if (it == _valueCount.end()) {
TRI_IF_FAILURE("AqlItemBlock::setValue") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
_valueCount.emplace(std::make_pair(value, 1)); _valueCount.emplace(std::make_pair(value, 1));
} }
else { else {

188
arangod/Aql/ExecutionBlock.cpp
View File

@ -32,9 +32,9 @@
#include "Basics/StringUtils.h" #include "Basics/StringUtils.h"
#include "Basics/StringBuffer.h" #include "Basics/StringBuffer.h"
#include "Basics/json-utilities.h" #include "Basics/json-utilities.h"
#include "V8/v8-globals.h"
#include "HashIndex/hash-index.h" #include "HashIndex/hash-index.h"
#include "Utils/Exception.h" #include "Utils/Exception.h"
#include "V8/v8-globals.h"
#include "VocBase/edge-collection.h" #include "VocBase/edge-collection.h"
#include "VocBase/index.h" #include "VocBase/index.h"
#include "VocBase/vocbase.h" #include "VocBase/vocbase.h"
@ -134,7 +134,10 @@ void AggregatorGroup::addValues (AqlItemBlock const* src,
else { else {
auto block = src->slice(firstRow, lastRow + 1); auto block = src->slice(firstRow, lastRow + 1);
try { try {
groupBlocks.push_back(block); TRI_IF_FAILURE("AggregatorGroup::addValues") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
groupBlocks.emplace_back(block);
} }
catch (...) { catch (...) {
delete block; delete block;
@ -378,6 +381,9 @@ void ExecutionBlock::inheritRegisters (AqlItemBlock const* src,
if (! src->getValue(row, i).isEmpty()) { if (! src->getValue(row, i).isEmpty()) {
AqlValue a = src->getValue(row, i).clone(); AqlValue a = src->getValue(row, i).clone();
try { try {
TRI_IF_FAILURE("ExecutionBlock::inheritRegisters") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
dst->setValue(0, i, a); dst->setValue(0, i, a);
} }
catch (...) { catch (...) {
@ -405,7 +411,10 @@ bool ExecutionBlock::getBlock (size_t atLeast, size_t atMost) {
return false; return false;
} }
try { try {
_buffer.push_back(docs); TRI_IF_FAILURE("ExecutionBlock::getBlock") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
_buffer.emplace_back(docs);
} }
catch (...) { catch (...) {
delete docs; delete docs;
@ -536,7 +545,12 @@ int ExecutionBlock::getOrSkipSome (size_t atLeast,
// The current block is too large for atMost: // The current block is too large for atMost:
if (! skipping) { if (! skipping) {
unique_ptr<AqlItemBlock> more(cur->slice(_pos, _pos + (atMost - skipped))); unique_ptr<AqlItemBlock> more(cur->slice(_pos, _pos + (atMost - skipped)));
collector.push_back(more.get());
TRI_IF_FAILURE("ExecutionBlock::getOrSkipSome") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
collector.emplace_back(more.get());
more.release(); // do not delete it! more.release(); // do not delete it!
} }
_pos += atMost - skipped; _pos += atMost - skipped;
@ -547,7 +561,12 @@ int ExecutionBlock::getOrSkipSome (size_t atLeast,
// half-eaten: // half-eaten:
if (! skipping) { if (! skipping) {
unique_ptr<AqlItemBlock> more(cur->slice(_pos, cur->size())); unique_ptr<AqlItemBlock> more(cur->slice(_pos, cur->size()));
collector.push_back(more.get());
TRI_IF_FAILURE("ExecutionBlock::getOrSkipSome") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
collector.emplace_back(more.get());
more.release(); more.release();
} }
skipped += cur->size() - _pos; skipped += cur->size() - _pos;
@ -559,7 +578,10 @@ int ExecutionBlock::getOrSkipSome (size_t atLeast,
// The current block fits into our result and is fresh: // The current block fits into our result and is fresh:
skipped += cur->size(); skipped += cur->size();
if (! skipping) { if (! skipping) {
collector.push_back(cur); TRI_IF_FAILURE("ExecutionBlock::getOrSkipSome") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
collector.emplace_back(cur);
} }
else { else {
delete cur; delete cur;
@ -581,6 +603,9 @@ int ExecutionBlock::getOrSkipSome (size_t atLeast,
} }
else if (! collector.empty()) { else if (! collector.empty()) {
try { try {
TRI_IF_FAILURE("ExecutionBlock::getOrSkipSomeConcatenate") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
result = AqlItemBlock::concatenate(collector); result = AqlItemBlock::concatenate(collector);
} }
catch (...) { catch (...) {
@ -646,10 +671,18 @@ int SingletonBlock::getOrSkipSome (size_t, // atLeast,
skipped++; skipped++;
for (RegisterId reg = 0; reg < _inputRegisterValues->getNrRegs(); ++reg) { for (RegisterId reg = 0; reg < _inputRegisterValues->getNrRegs(); ++reg) {
TRI_IF_FAILURE("SingletonBlock::getOrSkipSome") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
AqlValue a = _inputRegisterValues->getValue(0, reg); AqlValue a = _inputRegisterValues->getValue(0, reg);
_inputRegisterValues->steal(a); _inputRegisterValues->steal(a);
try { try {
TRI_IF_FAILURE("SingletonBlock::getOrSkipSomeSet") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
result->setValue(0, reg, a); result->setValue(0, reg, a);
} }
catch (...) { catch (...) {
@ -722,6 +755,10 @@ bool EnumerateCollectionBlock::moreDocuments (size_t hint) {
std::vector<TRI_doc_mptr_copy_t> newDocs; std::vector<TRI_doc_mptr_copy_t> newDocs;
TRI_IF_FAILURE("EnumerateCollectionBlock::moreDocuments") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
newDocs.reserve(hint); newDocs.reserve(hint);
int res = _scanner->scan(newDocs, hint); int res = _scanner->scan(newDocs, hint);
@ -982,7 +1019,10 @@ int IndexRangeBlock::initialize () {
// all new AstNodes are registered with the Ast in the Query // all new AstNodes are registered with the Ast in the Query
auto e = new Expression(_engine->getQuery()->ast(), a); auto e = new Expression(_engine->getQuery()->ast(), a);
try { try {
_allVariableBoundExpressions.push_back(e); TRI_IF_FAILURE("IndexRangeBlock::initialize") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
_allVariableBoundExpressions.emplace_back(e);
} }
catch (...) { catch (...) {
delete e; delete e;
@ -1020,6 +1060,9 @@ int IndexRangeBlock::initialize () {
instanciateExpression(h); instanciateExpression(h);
} }
} }
TRI_IF_FAILURE("IndexRangeBlock::initializeExpressions") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
} }
catch (...) { catch (...) {
for (auto e : _allVariableBoundExpressions) { for (auto e : _allVariableBoundExpressions) {
@ -1306,6 +1349,10 @@ void IndexRangeBlock::sortConditions () {
for (size_t s = 0; s < n; s++) { for (size_t s = 0; s < n; s++) {
_sortCoords.push_back(s); _sortCoords.push_back(s);
std::vector<size_t> next; std::vector<size_t> next;
TRI_IF_FAILURE("IndexRangeBlock::sortConditions") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
next.reserve(en->_index->fields.size()); next.reserve(en->_index->fields.size());
prefix.emplace_back(next); prefix.emplace_back(next);
// prefix[s][t] = position in _condition[s] corresponding to the <t>th index // prefix[s][t] = position in _condition[s] corresponding to the <t>th index
@ -1314,6 +1361,10 @@ void IndexRangeBlock::sortConditions () {
for (size_t u = 0; u < _condition->at(s).size(); u++) { for (size_t u = 0; u < _condition->at(s).size(); u++) {
auto ri = _condition->at(s)[u]; auto ri = _condition->at(s)[u];
if (en->_index->fields[t].compare(ri._attr) == 0) { if (en->_index->fields[t].compare(ri._attr) == 0) {
TRI_IF_FAILURE("IndexRangeBlock::sortConditionsInner") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
prefix.at(s).insert(prefix.at(s).begin() + t, u); prefix.at(s).insert(prefix.at(s).begin() + t, u);
break; break;
} }
@ -1394,6 +1445,9 @@ std::vector<RangeInfo> IndexRangeBlock::andCombineRangeInfoVecs (
RangeInfo x = ri1.clone(); RangeInfo x = ri1.clone();
x.fuse(ri2); x.fuse(ri2);
if (x.isValid()){ if (x.isValid()){
TRI_IF_FAILURE("IndexRangeBlock::andCombineRangeInfoVecs") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
out.push_back(x); out.push_back(x);
} }
} }
@ -1407,13 +1461,12 @@ std::vector<RangeInfo> IndexRangeBlock::andCombineRangeInfoVecs (
/// "and" condition containing an "or" condition, which we must then distribute. /// "and" condition containing an "or" condition, which we must then distribute.
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
IndexOrCondition* IndexRangeBlock::cartesian ( IndexOrCondition* IndexRangeBlock::cartesian (std::vector<std::vector<RangeInfo>> const& collector) {
std::vector<std::vector<RangeInfo>> const& collector) {
std::vector<size_t> indexes; std::vector<size_t> indexes;
indexes.reserve(collector.size()); indexes.reserve(collector.size());
for (size_t i = 0; i < collector.size(); i++) { for (size_t i = 0; i < collector.size(); i++) {
indexes.push_back(0); indexes.emplace_back(0);
} }
auto out = new IndexOrCondition(); auto out = new IndexOrCondition();
@ -1423,6 +1476,9 @@ IndexOrCondition* IndexRangeBlock::cartesian (
for (size_t i = 0; i < collector.size(); i++) { for (size_t i = 0; i < collector.size(); i++) {
next.push_back(collector[i][indexes[i]].clone()); next.push_back(collector[i][indexes[i]].clone());
} }
TRI_IF_FAILURE("IndexRangeBlock::cartesian") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
out->push_back(next); out->push_back(next);
size_t j = collector.size() - 1; size_t j = collector.size() - 1;
while (true) { while (true) {
@ -1465,6 +1521,9 @@ bool IndexRangeBlock::readIndex (size_t atMost) {
// entire index when we only want a small number of documents. // entire index when we only want a small number of documents.
if (_documents.empty()) { if (_documents.empty()) {
TRI_IF_FAILURE("IndexRangeBlock::readIndex") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
_documents.reserve(atMost); _documents.reserve(atMost);
} }
else { else {
@ -1869,12 +1928,13 @@ bool IndexRangeBlock::setupHashIndexSearchValue (IndexAndCondition const& range)
} }
auto shaped = TRI_ShapedJsonJson(shaper, x._lowConst.bound().json(), false); auto shaped = TRI_ShapedJsonJson(shaper, x._lowConst.bound().json(), false);
// here x->_low->_bound = x->_high->_bound // here x->_low->_bound == x->_high->_bound
if (shaped == nullptr) { if (shaped == nullptr) {
return false; return false;
} }
_hashIndexSearchValue._values[i] = *shaped; _hashIndexSearchValue._values[i] = *shaped;
// free only the pointer, but not the internals
TRI_Free(shaper->_memoryZone, shaped); TRI_Free(shaper->_memoryZone, shaped);
break; break;
} }
@ -1916,6 +1976,10 @@ void IndexRangeBlock::readHashIndex (size_t atMost) {
while (nrSent < atMost) { while (nrSent < atMost) {
size_t const n = _documents.size(); size_t const n = _documents.size();
TRI_IF_FAILURE("IndexRangeBlock::readHashIndex") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
TRI_LookupHashIndex(idx, &_hashIndexSearchValue, _documents, _hashNextElement, atMost); TRI_LookupHashIndex(idx, &_hashIndexSearchValue, _documents, _hashNextElement, atMost);
size_t const numRead = _documents.size() - n; size_t const numRead = _documents.size() - n;
@ -2074,6 +2138,9 @@ void IndexRangeBlock::readSkiplistIndex (size_t atMost) {
} }
} }
else { else {
TRI_IF_FAILURE("IndexRangeBlock::readSkiplistIndex") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
_documents.emplace_back(*(indexElement->_document)); _documents.emplace_back(*(indexElement->_document));
++nrSent; ++nrSent;
++_engine->_stats.scannedIndex; ++_engine->_stats.scannedIndex;
@ -2233,6 +2300,9 @@ AqlItemBlock* EnumerateListBlock::getSome (size_t, size_t atMost) {
// requirements // requirements
// Note that _index has been increased by 1 by getAqlValue! // Note that _index has been increased by 1 by getAqlValue!
try { try {
TRI_IF_FAILURE("EnumerateListBlock::getsome") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
res->setValue(j, cur->getNrRegs(), a); res->setValue(j, cur->getNrRegs(), a);
} }
catch (...) { catch (...) {
@ -2342,6 +2412,10 @@ size_t EnumerateListBlock::skipSome (size_t atLeast, size_t atMost) {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
AqlValue EnumerateListBlock::getAqlValue (AqlValue const& inVarReg) { AqlValue EnumerateListBlock::getAqlValue (AqlValue const& inVarReg) {
TRI_IF_FAILURE("EnumerateListBlock::getAqlValue") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
switch (inVarReg._type) { switch (inVarReg._type) {
case AqlValue::JSON: { case AqlValue::JSON: {
// FIXME: is this correct? What if the copy works, but the // FIXME: is this correct? What if the copy works, but the
@ -2404,7 +2478,7 @@ CalculationBlock::CalculationBlock (ExecutionEngine* engine,
TRI_ASSERT(it2 != en->getRegisterPlan()->varInfo.end()); TRI_ASSERT(it2 != en->getRegisterPlan()->varInfo.end());
TRI_ASSERT(it2->second.registerId < ExecutionNode::MaxRegisterId); TRI_ASSERT(it2->second.registerId < ExecutionNode::MaxRegisterId);
_inRegs.push_back(it2->second.registerId); _inRegs.emplace_back(it2->second.registerId);
} }
// check if the expression is "only" a reference to another variable // check if the expression is "only" a reference to another variable
@ -2449,6 +2523,9 @@ void CalculationBlock::fillBlockWithReference (AqlItemBlock* result) {
// care of correct freeing: // care of correct freeing:
AqlValue a = result->getValueReference(i, _inRegs[0]); AqlValue a = result->getValueReference(i, _inRegs[0]);
try { try {
TRI_IF_FAILURE("CalculationBlock::fillBlockWithReference") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
result->setValue(i, _outReg, a); result->setValue(i, _outReg, a);
} }
catch (...) { catch (...) {
@ -2479,6 +2556,9 @@ void CalculationBlock::executeExpression (AqlItemBlock* result) {
AqlValue conditionResult = result->getValueReference(i, _conditionReg); AqlValue conditionResult = result->getValueReference(i, _conditionReg);
if (! conditionResult.isTrue()) { if (! conditionResult.isTrue()) {
TRI_IF_FAILURE("CalculationBlock::executeExpressionWithCondition") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
result->setValue(i, _outReg, AqlValue(new Json(TRI_UNKNOWN_MEM_ZONE, &Expression::NullJson, Json::NOFREE))); result->setValue(i, _outReg, AqlValue(new Json(TRI_UNKNOWN_MEM_ZONE, &Expression::NullJson, Json::NOFREE)));
continue; continue;
} }
@ -2488,6 +2568,9 @@ void CalculationBlock::executeExpression (AqlItemBlock* result) {
TRI_document_collection_t const* myCollection = nullptr; TRI_document_collection_t const* myCollection = nullptr;
AqlValue a = _expression->execute(_trx, docColls, data, nrRegs * i, _inVars, _inRegs, &myCollection); AqlValue a = _expression->execute(_trx, docColls, data, nrRegs * i, _inVars, _inRegs, &myCollection);
try { try {
TRI_IF_FAILURE("CalculationBlock::executeExpression") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
result->setValue(i, _outReg, a); result->setValue(i, _outReg, a);
} }
catch (...) { catch (...) {
@ -2635,6 +2718,9 @@ AqlItemBlock* SubqueryBlock::getSome (size_t atLeast,
subqueryResults = executeSubquery(); subqueryResults = executeSubquery();
TRI_ASSERT(subqueryResults != nullptr); TRI_ASSERT(subqueryResults != nullptr);
try { try {
TRI_IF_FAILURE("SubqueryBlock::getSome") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
res->setValue(i, _outReg, AqlValue(subqueryResults)); res->setValue(i, _outReg, AqlValue(subqueryResults));
} }
catch (...) { catch (...) {
@ -2674,7 +2760,12 @@ std::vector<AqlItemBlock*>* SubqueryBlock::executeSubquery () {
if (tmp.get() == nullptr) { if (tmp.get() == nullptr) {
break; break;
} }
results->push_back(tmp.get());
TRI_IF_FAILURE("SubqueryBlock::executeSubquery") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
results->emplace_back(tmp.get());
tmp.release(); tmp.release();
} }
while (true); while (true);
@ -2740,7 +2831,11 @@ bool FilterBlock::getBlock (size_t atLeast, size_t atMost) {
_chosen.reserve(cur->size()); _chosen.reserve(cur->size());
for (size_t i = 0; i < cur->size(); ++i) { for (size_t i = 0; i < cur->size(); ++i) {
if (takeItem(cur, i)) { if (takeItem(cur, i)) {
_chosen.push_back(i); TRI_IF_FAILURE("FilterBlock::getBlock") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
_chosen.emplace_back(i);
} }
} }
@ -2789,7 +2884,12 @@ int FilterBlock::getOrSkipSome (size_t atLeast,
if (! skipping) { if (! skipping) {
unique_ptr<AqlItemBlock> more(cur->slice(_chosen, unique_ptr<AqlItemBlock> more(cur->slice(_chosen,
_pos, _pos + (atMost - skipped))); _pos, _pos + (atMost - skipped)));
collector.push_back(more.get());
TRI_IF_FAILURE("FilterBlock::getOrSkipSome1") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
collector.emplace_back(more.get());
more.release(); more.release();
} }
_pos += atMost - skipped; _pos += atMost - skipped;
@ -2800,7 +2900,12 @@ int FilterBlock::getOrSkipSome (size_t atLeast,
// half-eaten or needs to be copied anyway: // half-eaten or needs to be copied anyway:
if (! skipping) { if (! skipping) {
unique_ptr<AqlItemBlock> more(cur->steal(_chosen, _pos, _chosen.size())); unique_ptr<AqlItemBlock> more(cur->steal(_chosen, _pos, _chosen.size()));
collector.push_back(more.get());
TRI_IF_FAILURE("FilterBlock::getOrSkipSome2") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
collector.emplace_back(more.get());
more.release(); more.release();
} }
skipped += _chosen.size() - _pos; skipped += _chosen.size() - _pos;
@ -2814,7 +2919,10 @@ int FilterBlock::getOrSkipSome (size_t atLeast,
// takes them all, so we can just hand it on: // takes them all, so we can just hand it on:
skipped += cur->size(); skipped += cur->size();
if (! skipping) { if (! skipping) {
collector.push_back(cur); TRI_IF_FAILURE("FilterBlock::getOrSkipSome3") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
collector.emplace_back(cur);
} }
else { else {
delete cur; delete cur;
@ -2838,6 +2946,9 @@ int FilterBlock::getOrSkipSome (size_t atLeast,
} }
else if (collector.size() > 1) { else if (collector.size() > 1) {
try { try {
TRI_IF_FAILURE("FilterBlock::getOrSkipSomeConcatenate") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
result = AqlItemBlock::concatenate(collector); result = AqlItemBlock::concatenate(collector);
} }
catch (...) { catch (...) {
@ -3096,6 +3207,10 @@ int AggregateBlock::getOrSkipSome (size_t atLeast,
try { try {
// emit last buffered group // emit last buffered group
if (! skipping) { if (! skipping) {
TRI_IF_FAILURE("AggregateBlock::getOrSkipSome") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
emitGroup(cur, res.get(), skipped); emitGroup(cur, res.get(), skipped);
++skipped; ++skipped;
TRI_ASSERT(skipped > 0); TRI_ASSERT(skipped > 0);
@ -3254,6 +3369,9 @@ void SortBlock::doSorting () {
sum += block->size(); sum += block->size();
} }
TRI_IF_FAILURE("SortBlock::doSorting") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
coords.reserve(sum); coords.reserve(sum);
// install the coords // install the coords
@ -3261,14 +3379,14 @@ void SortBlock::doSorting () {
for (auto block : _buffer) { for (auto block : _buffer) {
for (size_t i = 0; i < block->size(); i++) { for (size_t i = 0; i < block->size(); i++) {
coords.push_back(std::make_pair(count, i)); coords.emplace_back(std::make_pair(count, i));
} }
count++; count++;
} }
std::vector<TRI_document_collection_t const*> colls; std::vector<TRI_document_collection_t const*> colls;
for (RegisterId i = 0; i < _sortRegisters.size(); i++) { for (RegisterId i = 0; i < _sortRegisters.size(); i++) {
colls.push_back(_buffer.front()->getDocumentCollection(_sortRegisters[i].first)); colls.emplace_back(_buffer.front()->getDocumentCollection(_sortRegisters[i].first));
} }
// comparison function // comparison function
@ -3297,7 +3415,10 @@ void SortBlock::doSorting () {
size_t sizeNext = (std::min)(sum - count, DefaultBatchSize); size_t sizeNext = (std::min)(sum - count, DefaultBatchSize);
AqlItemBlock* next = new AqlItemBlock(sizeNext, nrregs); AqlItemBlock* next = new AqlItemBlock(sizeNext, nrregs);
try { try {
newbuffer.push_back(next); TRI_IF_FAILURE("SortBlock::doSortingInner") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
newbuffer.emplace_back(next);
} }
catch (...) { catch (...) {
delete next; delete next;
@ -3329,6 +3450,9 @@ void SortBlock::doSorting () {
// Was already stolen for another block // Was already stolen for another block
AqlValue b = a.clone(); AqlValue b = a.clone();
try { try {
TRI_IF_FAILURE("SortBlock::doSortingCache") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
cache.emplace(make_pair(a, b)); cache.emplace(make_pair(a, b));
} }
catch (...) { catch (...) {
@ -3336,6 +3460,9 @@ void SortBlock::doSorting () {
throw; throw;
} }
try { try {
TRI_IF_FAILURE("SortBlock::doSortingNext1") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
next->setValue(i, j, b); next->setValue(i, j, b);
} }
catch (...) { catch (...) {
@ -3355,6 +3482,9 @@ void SortBlock::doSorting () {
// If this has worked, responsibility is now with the // If this has worked, responsibility is now with the
// new block or indeed with us! // new block or indeed with us!
try { try {
TRI_IF_FAILURE("SortBlock::doSortingNext2") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
next->setValue(i, j, a); next->setValue(i, j, a);
} }
catch (...) { catch (...) {
@ -3552,6 +3682,10 @@ AqlItemBlock* ReturnBlock::getSome (size_t atLeast,
if (! a.isEmpty()) { if (! a.isEmpty()) {
res->steal(a); res->steal(a);
try { try {
TRI_IF_FAILURE("ReturnBlock::getSome") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
stripped->setValue(i, 0, a); stripped->setValue(i, 0, a);
} }
catch (...) { catch (...) {
@ -3634,7 +3768,11 @@ AqlItemBlock* ModificationBlock::getSome (size_t atLeast,
break; break;
} }
blocks.push_back(res); TRI_IF_FAILURE("ModificationBlock::getSome") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
blocks.emplace_back(res);
} }
// now apply the modifications for the complete input // now apply the modifications for the complete input
@ -3651,7 +3789,11 @@ AqlItemBlock* ModificationBlock::getSome (size_t atLeast,
break; break;
} }
blocks.push_back(res); TRI_IF_FAILURE("ModificationBlock::getSome") {
THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
}
blocks.emplace_back(res);
replyBlocks = work(blocks); replyBlocks = work(blocks);
if (replyBlocks != nullptr) { if (replyBlocks != nullptr) {
@ -3690,7 +3832,7 @@ int ModificationBlock::extractKey (AqlValue const& value,
TRI_json_t const* json = member.json(); TRI_json_t const* json = member.json();
if (TRI_IsStringJson(json)) { if (TRI_IsStringJson(json)) {
key = std::string(json->_value._string.data, json->_value._string.length - 1); key.assign(json->_value._string.data, json->_value._string.length - 1);
return TRI_ERROR_NO_ERROR; return TRI_ERROR_NO_ERROR;
} }
} }

466
js/server/tests/aql-failures.js Normal file
View File

@ -0,0 +1,466 @@
/*jshint strict: true, maxlen: 200 */
/*global require, fail, assertEqual, AQL_EXECUTE */
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure scenarios
///
/// @file
///
/// DISCLAIMER
///
/// Copyright 2010-2012 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 triAGENS GmbH, Cologne, Germany
///
/// @author Jan Steemann
/// @author Copyright 2012, triAGENS GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
var jsunity = require("jsunity");
var arangodb = require("org/arangodb");
var db = arangodb.db;
var internal = require("internal");
// -----------------------------------------------------------------------------
// --SECTION-- aql failures
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief test suite
////////////////////////////////////////////////////////////////////////////////
function ahuacatlFailureSuite () {
"use strict";
var cn = "UnitTestsAhuacatlFailures";
var c;
var count = 2000;
var assertFailingQuery = function (query) {
try {
AQL_EXECUTE(query);
fail();
}
catch (err) {
if (err.errorNum === undefined) {
require("internal").print("\nERROR: ", query, err, "\n");
}
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
}
};
return {
setUp: function () {
internal.debugClearFailAt();
db._drop(cn);
c = db._create(cn);
for (var i = 0; i < count; ++i) {
c.save({ value: i, value2: i % 10 });
}
},
tearDown: function () {
internal.debugClearFailAt();
db._drop(cn);
c = null;
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testAggregateBlock1 : function () {
internal.debugSetFailAt("AggregatorGroup::addValues");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i.value INTO g RETURN [ key, g ]");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i.value2 INTO g RETURN [ key, g ]");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testAggregateBlock2 : function () {
internal.debugSetFailAt("AggregateBlock::getOrSkipSome");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i.value INTO g RETURN [ key, g ]");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i.value2 INTO g RETURN [ key, g ]");
assertFailingQuery("FOR i IN 1..10000 COLLECT key = i INTO g RETURN [ key, g ]");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
/* TODO: make this test throw errors!
testSingletonBlock1 : function () {
internal.debugSetFailAt("SingletonBlock::getOrSkipSome");
assertFailingQuery("LET a = 1 FOR i IN 1..10 RETURN a");
assertFailingQuery("FOR i IN " + c.name() + " RETURN 1");
},
*/
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
/* TODO: make this test throw errors!
testSingletonBlock2 : function () {
internal.debugSetFailAt("SingletonBlock::getOrSkipSomeSet");
assertFailingQuery("FOR i IN 1..10 RETURN 1");
assertFailingQuery("FOR i IN " + c.name() + " RETURN 1");
},
*/
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
/* TODO: make this test throw errors!
testReturnBlock : function () {
internal.debugSetFailAt("ReturnBlock::getOrSkipSome");
assertFailingQuery("RETURN 1");
assertFailingQuery("FOR i IN 1..10 RETURN 1");
assertFailingQuery("FOR i IN " + c.name() + " RETURN 1");
},
*/
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testSortBlock1 : function () {
internal.debugSetFailAt("SortBlock::doSorting");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i._key SORT key RETURN key");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i.value SORT key RETURN key");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i.value2 SORT key RETURN key");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testSortBlock2 : function () {
internal.debugSetFailAt("SortBlock::doSortingInner");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i._key SORT key RETURN key");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i.value SORT key RETURN key");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i.value2 SORT key RETURN key");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
/* TODO: make this test throw errors!
testSortBlock3 : function () {
internal.debugSetFailAt("SortBlock::doSortingCache");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i._key SORT key RETURN key");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i.value SORT key RETURN key");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i.value2 SORT key RETURN key");
},
*/
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
/* TODO: make this test throw errors!
testSortBlock4 : function () {
internal.debugSetFailAt("SortBlock::doSortingNext1");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i._key SORT key RETURN key");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i.value SORT key RETURN key");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i.value2 SORT key RETURN key");
},
*/
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testSortBlock5 : function () {
internal.debugSetFailAt("SortBlock::doSortingNext2");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i._key SORT key RETURN key");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i.value SORT key RETURN key");
assertFailingQuery("FOR i IN " + c.name() + " COLLECT key = i.value2 SORT key RETURN key");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
/* TODO: make this test throw errors!
testFilterBlock1 : function () {
internal.debugSetFailAt("FilterBlock::getOrSkipSome1");
assertFailingQuery("FOR i IN " + c.name() + " FILTER i.value2 == 7 RETURN i");
assertFailingQuery("FOR i IN 1..10000 FILTER i.value % 4 == 0 RETURN i");
},
*/
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
/* TODO: make this test throw errors!
testFilterBlock2 : function () {
internal.debugSetFailAt("FilterBlock::getOrSkipSome2");
assertFailingQuery("FOR i IN " + c.name() + " FILTER i.value2 == 7 RETURN i");
assertFailingQuery("FOR i IN 1..10000 FILTER i.value % 4 == 0 RETURN i");
},
*/
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
/* TODO: make this test throw errors!
testFilterBlock3 : function () {
internal.debugSetFailAt("FilterBlock::getOrSkipSome3");
assertFailingQuery("FOR i IN " + c.name() + " FILTER i.value2 == 7 RETURN i");
assertFailingQuery("FOR i IN 1..10000 FILTER i.value % 4 == 0 RETURN i");
},
*/
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
/* TODO: make this test throw errors!
testFilterBlock4 : function () {
internal.debugSetFailAt("FilterBlock::getOrSkipSomeConcatenate");
assertFailingQuery("FOR i IN " + c.name() + " FILTER i.value2 == 7 RETURN i");
assertFailingQuery("FOR i IN 1..10000 FILTER i.value % 4 == 0 RETURN i");
},
*/
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testModificationBlock : function () {
internal.debugSetFailAt("ModificationBlock::getSome");
assertFailingQuery("FOR i IN " + c.name() + " REMOVE i IN " + c.name());
assertFailingQuery("FOR i IN 1..10000 REMOVE CONCAT('test' + i) IN " + c.name() + " OPTIONS { ignoreErrors: true }");
assertFailingQuery("FOR i IN " + c.name() + " REMOVE i IN " + c.name());
assertFailingQuery("FOR i IN 1..10000 INSERT { value3: i } IN " + c.name());
assertEqual(count, c.count());
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testCalculationBlock1 : function () {
internal.debugSetFailAt("CalculationBlock::fillBlockWithReference");
assertFailingQuery("FOR i IN " + c.name() + " LET v = i RETURN v");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
/* TODO: make this test throw errors!
testCalculationBlock2 : function () {
internal.debugSetFailAt("CalculationBlock::executeExpression");
assertFailingQuery("FOR i IN " + c.name() + " LET v = i RETURN v");
assertFailingQuery("FOR i IN " + c.name() + " LET v = CONCAT(i._key, 'foo') RETURN v");
assertFailingQuery("FOR i IN " + c.name() + " LET v = i._key RETURN v");
},
*/
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
/* TODO: make this test throw errors!
testEnumerateListBlock1 : function () {
internal.debugSetFailAt("EnumerateListBlock::getSome");
assertFailingQuery("LET values = (FOR i IN " + c.name() + " RETURN i) FOR x IN values RETURN x");
assertFailingQuery("FOR i IN 1..10000 RETURN i");
},
*/
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testEnumerateListBlock2 : function () {
internal.debugSetFailAt("EnumerateListBlock::getAqlValue");
assertFailingQuery("LET values = (FOR i IN " + c.name() + " RETURN i) FOR x IN values RETURN x");
assertFailingQuery("FOR i IN 1..10000 RETURN i");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testSubqueryBlock1 : function () {
internal.debugSetFailAt("SubqueryBlock::getSome");
assertFailingQuery("LET values = (FOR i IN " + c.name() + " RETURN i) FOR x IN values RETURN x");
assertFailingQuery("LET values = (FOR i IN 1..10000 RETURN i) FOR x IN values RETURN x");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testSubqueryBlock2 : function () {
internal.debugSetFailAt("SubqueryBlock::executeSubquery");
assertFailingQuery("LET values = (FOR i IN " + c.name() + " RETURN i) FOR x IN values RETURN x");
assertFailingQuery("LET values = (FOR i IN 1..10000 RETURN i) FOR x IN values RETURN x");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
/* TODO: make this test throw errors!
testExecutionBlock1 : function () {
internal.debugSetFailAt("ExecutionBlock::inheritRegisters");
assertFailingQuery("FOR i IN " + c.name() + " FILTER i.value > 10 LIMIT 99 RETURN CONCAT(i, 'foo')");
},
*/
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testExecutionBlock2 : function () {
internal.debugSetFailAt("ExecutionBlock::getBlock");
assertFailingQuery("FOR i IN 1..10000 FILTER i.value % 4 == 0 LIMIT 9999 RETURN CONCAT(i, 'foo')");
assertFailingQuery("LET values = (FOR i IN " + c.name() + " RETURN i) FOR x IN values LIMIT 9999 RETURN x");
assertFailingQuery("FOR i IN " + c.name() + " FILTER i.value2 == 9 COLLECT key = i._key LIMIT 9999 RETURN key");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testExecutionBlock3 : function () {
internal.debugSetFailAt("ExecutionBlock::getOrSkipSome");
assertFailingQuery("FOR i IN 1..10000 FILTER i.value % 4 == 0 LIMIT 9999 RETURN CONCAT(i, 'foo')");
assertFailingQuery("LET values = (FOR i IN " + c.name() + " RETURN i) FOR x IN values LIMIT 9999 RETURN x");
assertFailingQuery("FOR i IN " + c.name() + " FILTER i.value2 == 9 COLLECT key = i._key LIMIT 9999 RETURN key");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
/* TODO: make this test throw errors!
testExecutionBlock4 : function () {
internal.debugSetFailAt("ExecutionBlock::getOrSkipSomeConcatenate");
assertFailingQuery("FOR i IN 1..10000 FILTER i.value % 4 == 0 LIMIT 9999 RETURN CONCAT(i, 'foo')");
assertFailingQuery("LET values = (FOR i IN " + c.name() + " RETURN i) FOR x IN values LIMIT 9999 RETURN x");
assertFailingQuery("FOR i IN " + c.name() + " LIMIT 99999 COLLECT key = i._key LIMIT 9999 RETURN key");
},
*/
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testEnumerateCollectionBlock : function () {
internal.debugSetFailAt("EnumerateCollectionBlock::moreDocuments");
assertFailingQuery("FOR i IN " + c.name() + " FILTER i.value2 == 9 COLLECT key = i._key RETURN key");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testIndexRangeBlock1 : function () {
c.ensureHashIndex("value");
internal.debugSetFailAt("IndexRangeBlock::initialize");
assertFailingQuery("LET f = PASSTHRU(1) FOR j IN 1..10 FOR i IN " + c.name() + " FILTER i.value == j FILTER i.value == f RETURN i");
assertFailingQuery("FOR j IN 1..10 FOR i IN " + c.name() + " FILTER i.value == j RETURN i");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testIndexRangeBlock2 : function () {
c.ensureHashIndex("value");
internal.debugSetFailAt("IndexRangeBlock::initializeExpressions");
assertFailingQuery("LET f = PASSTHRU(1) FOR j IN 1..10 FOR i IN " + c.name() + " FILTER i.value == j FILTER i.value == f RETURN i");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
/* TODO: make this test throw errors!
testIndexRangeBlock3 : function () {
c.ensureHashIndex("value", "value2");
internal.debugSetFailAt("IndexRangeBlock::sortConditions");
assertFailingQuery("FOR j IN 1..10 FOR k IN 1..2 FOR i IN " + c.name() + " FILTER i.value == j FILTER i.value2 == k RETURN i");
},
*/
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
/* TODO: make this test throw errors!
testIndexRangeBlock4 : function () {
c.ensureHashIndex("value", "value2");
internal.debugSetFailAt("IndexRangeBlock::sortConditionsInner");
assertFailingQuery("FOR j IN 1..10 FOR k IN 1..2 FOR i IN " + c.name() + " FILTER i.value == j FILTER i.value2 == k RETURN i");
},
*/
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testIndexRangeBlock5 : function () {
c.ensureHashIndex("value", "value2");
internal.debugSetFailAt("IndexRangeBlock::cartesian");
assertFailingQuery("FOR j IN 1..10 FOR k IN 1..2 FOR i IN " + c.name() + " FILTER i.value == j FILTER i.value2 == k RETURN i");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
/* TODO: make this test throw errors!
testIndexRangeBlock6 : function () {
c.ensureHashIndex("value", "value2");
internal.debugSetFailAt("IndexRangeBlock::andCombineRangeInfoVecs");
assertFailingQuery("FOR j IN 1..10 FOR k IN 1..2 FOR i IN " + c.name() + " FILTER i.value == j FILTER i.value2 == k RETURN i");
},
*/
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testIndexRangeBlock7 : function () {
c.ensureSkiplist("value", "value2");
internal.debugSetFailAt("IndexRangeBlock::readIndex");
assertFailingQuery("FOR i IN " + c.name() + " FILTER i.value == 25 RETURN i");
assertFailingQuery("FOR j IN 1..10 FOR i IN " + c.name() + " FILTER i.value == j RETURN i");
assertFailingQuery("FOR j IN 1..10 FOR k IN 1..2 FOR i IN " + c.name() + " FILTER i.value == j FILTER i.value2 == k RETURN i");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testIndexRangeBlock8 : function () {
c.ensureHashIndex("value", "value2");
internal.debugSetFailAt("IndexRangeBlock::readHashIndex");
assertFailingQuery("FOR i IN " + c.name() + " FILTER i.value == 25 && i.value2 == 5 RETURN i");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test failure
////////////////////////////////////////////////////////////////////////////////
testIndexRangeBlock9 : function () {
c.ensureSkiplist("value", "value2");
internal.debugSetFailAt("IndexRangeBlock::readSkiplistIndex");
assertFailingQuery("FOR i IN " + c.name() + " FILTER i.value == 25 && i.value2 == 5 RETURN i");
}
};
}
// -----------------------------------------------------------------------------
// --SECTION-- main
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief executes the test suites
////////////////////////////////////////////////////////////////////////////////
if (internal.debugCanUseFailAt()) {
jsunity.run(ahuacatlFailureSuite);
}
return jsunity.done();
// Local Variables:
// mode: outline-minor
// outline-regexp: "^\\(/// @brief\\|/// @addtogroup\\|// --SECTION--\\|/// @page\\|/// @}\\)"
// End: