void SequentialPlan::execute_plan( DropActionCallback& callback, shared_ptr<sftp_provider> provider) const { OperationExecutor executor(callback); for (unsigned int i = 0; i < m_copy_list.size(); ++i) { const Operation& operation = m_copy_list.at(i); executor(operation, i, m_copy_list.size(), provider); } }
void checkSuppressionThreads(const char code[], const std::string &suppression = "") { errout.str(""); output.str(""); std::vector<std::string> filenames; std::map<std::string, long> filesizes; filenames.push_back("test.cpp"); Settings settings; settings._jobs = 1; settings._inlineSuppressions = true; if (!suppression.empty()) { std::string r = settings.nomsg.addSuppressionLine(suppression); ASSERT_EQUALS("", r); } ThreadExecutor executor(filenames, filesizes, settings, *this); for (unsigned int i = 0; i < filenames.size(); ++i) executor.addFileContent(filenames[i], code); executor.check(); reportUnmatchedSuppressions(settings.nomsg.getUnmatchedGlobalSuppressions()); }
void HelloV1::onEOM() noexcept { folly::fbstring out{}; auto task = executor()->addFuture([&out, input = parameter]() { // Sanitize input! // Process // Prepare output out = folly::sformat("{{\"response\":\"HelloV1 {}\"}}", input); }).onError([&out](const std::exception &e) { // DB error, or some such failure out = "{\"response\": \"server failed\"}"; LOG(ERROR) << e.what() << '\n'; }); task.wait(); ResponseBuilder(downstream_) .status(200, "OK") .header(HTTPHeaderCode::HTTP_HEADER_CONTENT_TYPE, JSON_content_type) .header(HTTPHeaderCode::HTTP_HEADER_CACHE_CONTROL, MAXAGE_4hour) .body(std::move(out)) .sendWithEOM(); }
TEST_F(CreateTests, CreatingTable) { catalog::Bootstrapper::bootstrap(); // Insert a table first auto id_column = catalog::Column(VALUE_TYPE_INTEGER, GetTypeSize(VALUE_TYPE_INTEGER), "dept_id", true); auto name_column = catalog::Column(VALUE_TYPE_VARCHAR, 32, "dept_name", false); std::unique_ptr<catalog::Schema> table_schema(new catalog::Schema({id_column, name_column})); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); std::unique_ptr<executor::ExecutorContext> context( new executor::ExecutorContext(txn)); planner::CreatePlan node("department_table", std::move(table_schema)); executor::CreateExecutor executor(&node, context.get()); executor.Init(); executor.Execute(); txn_manager.CommitTransaction(); EXPECT_EQ(catalog::Bootstrapper::global_catalog->GetDatabaseWithName("default_database")->GetTableCount(), 1); }
void TextEditWidget::contextMenuEvent(QContextMenuEvent *event) { ActionExecutor::Object executor(this, this); QMenu menu(this); Menu *notesMenu(new Menu(Menu::NotesMenu, &menu)); notesMenu->setExecutor(executor); menu.addMenu(notesMenu); menu.addSeparator(); menu.addAction(new Action(ActionsManager::UndoAction, {}, executor, &menu)); menu.addAction(new Action(ActionsManager::RedoAction, {}, executor, &menu)); menu.addSeparator(); menu.addAction(new Action(ActionsManager::CutAction, {}, executor, &menu)); menu.addAction(new Action(ActionsManager::CopyAction, {}, executor, &menu)); menu.addAction(new Action(ActionsManager::PasteAction, {}, executor, &menu)); menu.addAction(new Action(ActionsManager::DeleteAction, {}, executor, &menu)); menu.addSeparator(); menu.addAction(new Action(ActionsManager::CopyToNoteAction, {}, executor, &menu)); menu.addSeparator(); menu.addAction(new Action(ActionsManager::ClearAllAction, {}, executor, &menu)); menu.addAction(new Action(ActionsManager::SelectAllAction, {}, executor, &menu)); menu.addSeparator(); menu.addAction(new Action(ActionsManager::CheckSpellingAction, {}, executor, &menu)); Menu *dictionariesMenu(new Menu(Menu::DictionariesMenu, &menu)); dictionariesMenu->setExecutor(executor); menu.addMenu(dictionariesMenu); menu.exec(event->globalPos()); }
unsigned int checkSuppressionThreads(const char code[], const std::string &suppression = emptyString) { errout.str(""); output.str(""); std::map<std::string, std::size_t> files; files["test.cpp"] = 1; Settings settings; settings.jobs = 1; settings.inlineSuppressions = true; settings.addEnabled("information"); if (!suppression.empty()) { ASSERT_EQUALS("", settings.nomsg.addSuppressionLine(suppression)); } ThreadExecutor executor(files, settings, *this); for (std::map<std::string, std::size_t>::const_iterator i = files.begin(); i != files.end(); ++i) executor.addFileContent(i->first, code); unsigned int exitCode = executor.check(); std::map<std::string, std::string> files_for_report; for (std::map<std::string, std::size_t>::const_iterator file = files.begin(); file != files.end(); ++file) files_for_report[file->first] = ""; reportSuppressions(settings, files_for_report); return exitCode; }
void InsertTuple(storage::DataTable *table, common::VarlenPool *pool, oid_t tilegroup_count_per_loader, UNUSED_ATTRIBUTE uint64_t thread_itr) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); oid_t tuple_count = tilegroup_count_per_loader * TEST_TUPLES_PER_TILEGROUP; // Start a txn for each insert auto txn = txn_manager.BeginTransaction(); std::unique_ptr<storage::Tuple> tuple( ExecutorTestsUtil::GetTuple(table, ++loader_tuple_id, pool)); std::unique_ptr<executor::ExecutorContext> context( new executor::ExecutorContext(txn)); auto project_info = MakeProjectInfoFromTuple(tuple.get()); planner::InsertPlan node(table, std::move(project_info)); // Insert the desired # of tuples for (oid_t tuple_itr = 0; tuple_itr < tuple_count; tuple_itr++) { executor::InsertExecutor executor(&node, context.get()); executor.Execute(); } txn_manager.CommitTransaction(txn); }
UpdateResult update(OperationContext* txn, Database* db, const UpdateRequest& request, OpDebug* opDebug) { UpdateExecutor executor(&request, opDebug); return executor.execute(txn, db); }
void SequencedTaskExecutor::executeTask(ExecutorId id, vespalib::Executor::Task::UP task) { assert(id.getId() < _executors.size()); vespalib::ThreadStackExecutorBase &executor(*_executors[id.getId()]); auto rejectedTask = executor.execute(std::move(task)); assert(!rejectedTask); }
Document::Ptr SQLiteDocumentDAO::findById(qulonglong id) const { if(repository()->publications()->contains(id)) { return repository()->publications()->find(id); } QueryExecutor executor(database()); QSqlQuery query = executor.select("document", QStringList(), makeQueryParameters("id", id)); if(query.next()) { QSqlRecord record = query.record(); qulonglong id = record.value("id").toULongLong(); Document::Ptr pub = Document::Ptr(new Document()); pub->setId(id); pub->setTitle(record.value("title").toString()); pub->setAbstract(record.value("abstract").toString()); pub->setYear(record.value("year").toInt()); pub->setMonth(record.value("month").toInt()); pub->setConference(record.value("conference").toString()); pub->setPublisher(record.value("publisher").toString()); pub->setVolume(record.value("volume").toInt()); pub->setNumber(record.value("number").toInt()); pub->setUrl(record.value("url").toString()); pub->setDoi(record.value("doi").toString()); pub->setIsbn(record.value("isbn").toString()); pub->setLocalUrl(record.value("localURL").toString()); pub->setType(static_cast<DocumentType>(record.value("type").toUInt())); pub->setPublished(record.value("isPublished").toBool()); pub->setPeerReviewed(record.value("isPeerReviewed").toBool()); pub->setKeywords(QStringList()); pub->setSeries(record.value("series").toString()); pub->setSubTitle(record.value("subTitle").toString()); pub->setPages(PageRange::fromString(record.value("pages").toString())); pub->setCiteKey(record.value("citeKey").toString()); repository()->publications()->insert(id, pub); QString authors = record.value("authors").toString(); pub->setAuthors(StringUtils::deserialize(authors)); QString editors = record.value("editors").toString(); pub->setEditors(StringUtils::deserialize(editors)); qulonglong jid = record.value("journalId").toULongLong(); if(jid != 0) { pub->setJournal(repository()->journalDAO()->findById(jid)); } emit dataChanged(); return pub; } return Document::Ptr(); }
TEST_F(ProjectionTests, BasicTest) { MockExecutor child_executor; EXPECT_CALL(child_executor, DInit()).WillOnce(Return(true)); EXPECT_CALL(child_executor, DExecute()) .WillOnce(Return(true)) .WillOnce(Return(false)); size_t tile_size = 5; // Create a table and wrap it in logical tile auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); std::unique_ptr<storage::DataTable> data_table( ExecutorTestsUtil::CreateTable(tile_size)); ExecutorTestsUtil::PopulateTable(txn, data_table.get(), tile_size, false, false, false); txn_manager.CommitTransaction(); std::unique_ptr<executor::LogicalTile> source_logical_tile1( executor::LogicalTileFactory::WrapTileGroup(data_table->GetTileGroup(0))); EXPECT_CALL(child_executor, GetOutput()) .WillOnce(Return(source_logical_tile1.release())); // Create the plan node planner::ProjectInfo::TargetList target_list; planner::ProjectInfo::DirectMapList direct_map_list; ///////////////////////////////////////////////////////// // PROJECTION 0 ///////////////////////////////////////////////////////// // construct schema std::vector<catalog::Column> columns; auto orig_schema = data_table.get()->GetSchema(); columns.push_back(orig_schema->GetColumn(0)); std::shared_ptr<const catalog::Schema> schema(new catalog::Schema(columns)); // direct map planner::ProjectInfo::DirectMap direct_map = std::make_pair(0, std::make_pair(0, 0)); direct_map_list.push_back(direct_map); std::unique_ptr<const planner::ProjectInfo> project_info( new planner::ProjectInfo(std::move(target_list), std::move(direct_map_list))); planner::ProjectionPlan node(std::move(project_info), schema); // Create and set up executor executor::ProjectionExecutor executor(&node, nullptr); executor.AddChild(&child_executor); RunTest(executor, 1); }
/** * Inserts a tuple in a table */ void InsertTuple(storage::DataTable *table, std::unique_ptr<storage::Tuple> tuple) { auto txn = peloton::concurrency::current_txn; std::unique_ptr<executor::ExecutorContext> context( new executor::ExecutorContext(txn)); planner::InsertPlan node(table, std::move(tuple)); executor::InsertExecutor executor(&node, context.get()); executor.Init(); executor.Execute(); }
int main() { hpx::threads::executors::pool_executor executor("default"); auto future = hpx::make_ready_future().share(); future.then(executor, [](hpx::shared_future<void> future) { future.get(); }); return 0; }
// Insert a logical tile into a table TEST_F(MutateTests, InsertTest) { auto &txn_manager = concurrency::OptimisticTxnManager::GetInstance(); // We are going to insert a tile group into a table in this test std::unique_ptr<storage::DataTable> source_data_table( ExecutorTestsUtil::CreateAndPopulateTable()); std::unique_ptr<storage::DataTable> dest_data_table( ExecutorTestsUtil::CreateTable()); const std::vector<storage::Tuple *> tuples; EXPECT_EQ(source_data_table->GetTileGroupCount(), 3); EXPECT_EQ(dest_data_table->GetTileGroupCount(), 1); auto txn = txn_manager.BeginTransaction(); std::unique_ptr<executor::ExecutorContext> context( new executor::ExecutorContext(txn)); planner::InsertPlan node(dest_data_table.get(), nullptr); executor::InsertExecutor executor(&node, context.get()); MockExecutor child_executor; executor.AddChild(&child_executor); // Uneventful init... EXPECT_CALL(child_executor, DInit()).WillOnce(Return(true)); // Will return one tile. EXPECT_CALL(child_executor, DExecute()) .WillOnce(Return(true)) .WillOnce(Return(false)); // Construct input logical tile auto physical_tile_group = source_data_table->GetTileGroup(0); auto tile_count = physical_tile_group->GetTileCount(); std::vector<std::shared_ptr<storage::Tile> > physical_tile_refs; for (oid_t tile_itr = 0; tile_itr < tile_count; tile_itr++) physical_tile_refs.push_back( physical_tile_group->GetTileReference(tile_itr)); std::unique_ptr<executor::LogicalTile> source_logical_tile( executor::LogicalTileFactory::WrapTiles(physical_tile_refs)); EXPECT_CALL(child_executor, GetOutput()) .WillOnce(Return(source_logical_tile.release())); EXPECT_TRUE(executor.Init()); EXPECT_TRUE(executor.Execute()); EXPECT_FALSE(executor.Execute()); txn_manager.CommitTransaction(); // We have inserted all the tuples in this logical tile EXPECT_EQ(dest_data_table->GetTileGroupCount(), 1); }
static void multiUpdate( OperationContext* txn, const BatchItemRef& updateItem, WriteOpResult* result ) { const NamespaceString nsString(updateItem.getRequest()->getNS()); UpdateRequest request(nsString); request.setQuery(updateItem.getUpdate()->getQuery()); request.setUpdates(updateItem.getUpdate()->getUpdateExpr()); request.setMulti(updateItem.getUpdate()->getMulti()); request.setUpsert(updateItem.getUpdate()->getUpsert()); request.setUpdateOpLog(true); UpdateLifecycleImpl updateLifecycle(true, request.getNamespaceString()); request.setLifecycle(&updateLifecycle); UpdateExecutor executor(&request, &txn->getCurOp()->debug()); Status status = executor.prepare(); if (!status.isOK()) { result->setError(toWriteError(status)); return; } /////////////////////////////////////////// Lock::DBWrite writeLock(txn->lockState(), nsString.ns()); /////////////////////////////////////////// if (!checkShardVersion(txn, &shardingState, *updateItem.getRequest(), result)) return; Client::Context ctx( nsString.ns(), storageGlobalParams.dbpath, false /* don't check version */ ); try { UpdateResult res = executor.execute(txn, ctx.db()); const long long numDocsModified = res.numDocsModified; const long long numMatched = res.numMatched; const BSONObj resUpsertedID = res.upserted; // We have an _id from an insert const bool didInsert = !resUpsertedID.isEmpty(); result->getStats().nModified = didInsert ? 0 : numDocsModified; result->getStats().n = didInsert ? 1 : numMatched; result->getStats().upsertedID = resUpsertedID; } catch (const DBException& ex) { status = ex.toStatus(); if (ErrorCodes::isInterruption(status.code())) { throw; } result->setError(toWriteError(status)); } }
/** * Perform a remove operation, which might remove multiple documents. Dispatches to remove code * currently to do most of this. * * Might fault or error, otherwise populates the result. */ static void multiRemove( const BatchItemRef& removeItem, WriteOpResult* result ) { const NamespaceString nss( removeItem.getRequest()->getNS() ); DeleteRequest request( nss ); request.setQuery( removeItem.getDelete()->getQuery() ); request.setMulti( removeItem.getDelete()->getLimit() != 1 ); request.setUpdateOpLog(true); request.setGod( false ); DeleteExecutor executor( &request ); Status status = executor.prepare(); if ( !status.isOK() ) { result->error = toWriteError( status ); return; } // NOTE: Deletes will not fault outside the lock once any data has been written PageFaultRetryableSection pFaultSection; /////////////////////////////////////////// Lock::DBWrite writeLock( nss.ns() ); /////////////////////////////////////////// // Check version once we're locked if ( !checkShardVersion( &shardingState, *removeItem.getRequest(), &result->error ) ) { // Version error return; } // Context once we're locked, to set more details in currentOp() // TODO: better constructor? Client::Context writeContext( nss.ns(), storageGlobalParams.dbpath, false /* don't check version */); try { result->stats.n = executor.execute(); } catch ( const PageFaultException& ex ) { // TODO: An actual data structure that's not an exception for this result->fault = new PageFaultException( ex ); } catch ( const DBException& ex ) { status = ex.toStatus(); if (ErrorCodes::isInterruption(status.code())) { throw; } result->error = toWriteError(status); } }
int main(int argc, char **argv) { if (argc != 2){ std::cerr << "No input file\nUsage: task1 pathname\n"; } reader_rules reader("rules.cfg"); std::vector<text_transformation*> funcs = reader.read(); executor_rules executor(argv[1],"out.txt"); executor.execute(funcs); return 0; }
extern char * execute(const char * xquery, const char * context_xml, char * (* resolver)(void *, const char *), void * resolver_arg) { Executor executor( &memory_manager, xquery, context_xml, resolver, resolver_arg); try { return executor.execute(); } catch (XQException & ex) { //std::cout << UTF8(ex.getError()) << std::endl; } catch (...) { //std::cout << "ex" << std::endl; } return NULL; }
int CppCheckExecutor::check(int argc, const char* const argv[]) { CppCheck cppCheck(*this); try { cppCheck.parseFromArgs(argc, argv); } catch (std::runtime_error &e) { std::cerr << e.what() << std::endl; return EXIT_FAILURE; } _settings = cppCheck.settings(); if (_settings._xml) { reportErr(ErrorLogger::ErrorMessage::getXMLHeader()); } unsigned int returnValue = 0; if (_settings._jobs == 1) { // Single process returnValue = cppCheck.check(); } else if (!ThreadExecutor::isEnabled()) { std::cout << "No thread support yet implemented for this platform." << std::endl; } else { // Multiple processes const std::vector<std::string> &filenames = cppCheck.filenames(); Settings settings = cppCheck.settings(); ThreadExecutor executor(filenames, settings, *this); returnValue = executor.check(); } if (_settings._xml) { reportErr(ErrorLogger::ErrorMessage::getXMLFooter()); } if (returnValue) return _settings._exitCode; else return 0; }
void LoadYCSBDatabase() { const oid_t col_count = state.column_count + 1; const int tuple_count = state.scale_factor * DEFAULT_TUPLES_PER_TILEGROUP; // Pick the user table auto table_schema = user_table->GetSchema(); ///////////////////////////////////////////////////////// // Load in the data ///////////////////////////////////////////////////////// std::unique_ptr<type::AbstractPool> pool(new type::EphemeralPool()); // Insert tuples into tile_group. auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); const bool allocate = true; auto txn = txn_manager.BeginTransaction(); std::unique_ptr<executor::ExecutorContext> context( new executor::ExecutorContext(txn)); int rowid; for (rowid = 0; rowid < tuple_count; rowid++) { std::unique_ptr<storage::Tuple> tuple( new storage::Tuple(table_schema, allocate)); auto primary_key_value = type::ValueFactory::GetIntegerValue(rowid); tuple->SetValue(0, primary_key_value, nullptr); if (state.string_mode == true) { auto key_value = type::ValueFactory::GetVarcharValue(std::string(100, 'z')); for (oid_t col_itr = 1; col_itr < col_count; col_itr++) { tuple->SetValue(col_itr, key_value, pool.get()); } } else { auto key_value = type::ValueFactory::GetIntegerValue(rowid); for (oid_t col_itr = 1; col_itr < col_count; col_itr++) { tuple->SetValue(col_itr, key_value, nullptr); } } planner::InsertPlan node(user_table, std::move(tuple)); executor::InsertExecutor executor(&node, context.get()); executor.Execute(); } txn_manager.CommitTransaction(txn); }
int CppCheckExecutor::check(int argc, const char* const argv[]) { CppCheck cppCheck(*this, true); if (!parseFromArgs(&cppCheck, argc, argv)) { return EXIT_FAILURE; } if (cppCheck.settings().reportProgress) time1 = std::time(0); _settings = cppCheck.settings(); if (_settings._xml) { reportErr(ErrorLogger::ErrorMessage::getXMLHeader(_settings._xml_version)); } unsigned int returnValue = 0; if (_settings._jobs == 1) { // Single process returnValue = cppCheck.check(); } else if (!ThreadExecutor::isEnabled()) { std::cout << "No thread support yet implemented for this platform." << std::endl; } else { // Multiple processes const std::vector<std::string> &filenames = cppCheck.filenames(); Settings &settings = cppCheck.settings(); ThreadExecutor executor(filenames, settings, *this); returnValue = executor.check(); } reportUnmatchedSuppressions(cppCheck.settings().nomsg.getUnmatchedGlobalSuppressions()); if (_settings._xml) { reportErr(ErrorLogger::ErrorMessage::getXMLFooter(_settings._xml_version)); } if (returnValue) return _settings._exitCode; else return 0; }
void InsertTuple(storage::DataTable *table, VarlenPool *pool) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); std::unique_ptr<executor::ExecutorContext> context( new executor::ExecutorContext(txn)); for (oid_t tuple_itr = 0; tuple_itr < 10; tuple_itr++) { auto tuple = ExecutorTestsUtil::GetTuple(table, ++tuple_id, pool); planner::InsertPlan node(table, std::move(tuple)); executor::InsertExecutor executor(&node, context.get()); executor.Execute(); } txn_manager.CommitTransaction(); }
bool TupleSamplesStorage::InsertSampleTuple( storage::DataTable *samples_table, std::unique_ptr<storage::Tuple> tuple, concurrency::TransactionContext *txn) { if (txn == nullptr) { return false; } std::unique_ptr<executor::ExecutorContext> context( new executor::ExecutorContext(txn)); planner::InsertPlan node(samples_table, std::move(tuple)); executor::InsertExecutor executor(&node, context.get()); executor.Init(); bool status = executor.Execute(); return status; }
/* ns: namespace, e.g. <database>.<collection> pattern: the "where" clause / criteria justOne: stop after 1 match god: allow access to system namespaces, and don't yield */ long long deleteObjects(OperationContext* txn, Database* db, const StringData& ns, BSONObj pattern, bool justOne, bool logop, bool god) { NamespaceString nsString(ns); DeleteRequest request(nsString); request.setQuery(pattern); request.setMulti(!justOne); request.setUpdateOpLog(logop); request.setGod(god); DeleteExecutor executor(&request); return executor.execute(txn, db); }
TEST_F(TransactionCoordinatorServiceTest, CoordinatorIsCanceledIfDeadlinePassesAndHasNotReceivedParticipantList) { auto coordinatorService = TransactionCoordinatorService::get(operationContext()); const auto deadline = executor()->now() + Milliseconds(1000 * 60 * 10 /* 10 hours */); coordinatorService->createCoordinator(operationContext(), _lsid, _txnNumber, deadline); // Reach the deadline. network()->enterNetwork(); network()->advanceTime(deadline); network()->exitNetwork(); // The coordinator should no longer exist. ASSERT(boost::none == coordinatorService->coordinateCommit( operationContext(), _lsid, _txnNumber, kTwoShardIdSet)); }
// "Pass-through" test case. There is nothing to materialize as // there is only one base tile in the logical tile. TEST_F(MaterializationTests, SingleBaseTileTest) { const int tuple_count = 9; std::shared_ptr<storage::TileGroup> tile_group( ExecutorTestsUtil::CreateTileGroup(tuple_count)); ExecutorTestsUtil::PopulateTiles(tile_group, tuple_count); // Create logical tile from single base tile. auto source_base_tile = tile_group->GetTileReference(0); // Add a reference because we are going to wrap around it and we don't own it std::unique_ptr<executor::LogicalTile> source_logical_tile( executor::LogicalTileFactory::WrapTiles({source_base_tile})); // Pass through materialization executor. executor::MaterializationExecutor executor(nullptr, nullptr); std::unique_ptr<executor::LogicalTile> result_logical_tile( ExecutorTestsUtil::ExecuteTile(&executor, source_logical_tile.release())); // Verify that logical tile is only made up of a single base tile. int num_cols = result_logical_tile->GetColumnCount(); EXPECT_EQ(2, num_cols); storage::Tile *result_base_tile = result_logical_tile->GetBaseTile(0); EXPECT_THAT(result_base_tile, NotNull()); EXPECT_TRUE(source_base_tile.get() == result_base_tile); EXPECT_EQ(result_logical_tile->GetBaseTile(1), result_base_tile); // Check that the base tile has the correct values. for (int i = 0; i < tuple_count; i++) { type::Value val0 = (result_base_tile->GetValue(i, 0)); type::Value val1 = (result_base_tile->GetValue(i, 1)); type::CmpBool cmp = (val0.CompareEquals( type::ValueFactory::GetIntegerValue(ExecutorTestsUtil::PopulatedValue(i, 0)))); EXPECT_TRUE(cmp == type::CMP_TRUE); cmp = val1.CompareEquals(type::ValueFactory::GetIntegerValue( ExecutorTestsUtil::PopulatedValue(i, 1))); EXPECT_TRUE(cmp == type::CMP_TRUE); // Double check that logical tile is functioning. type::Value logic_val0 = (result_logical_tile->GetValue(i, 0)); type::Value logic_val1 = (result_logical_tile->GetValue(i, 1)); cmp = (logic_val0.CompareEquals(val0)); EXPECT_TRUE(cmp == type::CMP_TRUE); cmp = (logic_val1.CompareEquals(val1)); EXPECT_TRUE(cmp == type::CMP_TRUE); } }
/** * Perform a remove operation, which might remove multiple documents. Dispatches to remove code * currently to do most of this. * * Might fault or error, otherwise populates the result. */ static void multiRemove( OperationContext* txn, const BatchItemRef& removeItem, WriteOpResult* result ) { const NamespaceString nss( removeItem.getRequest()->getNS() ); DeleteRequest request( nss ); request.setQuery( removeItem.getDelete()->getQuery() ); request.setMulti( removeItem.getDelete()->getLimit() != 1 ); request.setUpdateOpLog(true); request.setGod( false ); DeleteExecutor executor( &request ); Status status = executor.prepare(); if ( !status.isOK() ) { result->setError(toWriteError(status)); return; } /////////////////////////////////////////// Lock::DBWrite writeLock(txn->lockState(), nss.ns()); /////////////////////////////////////////// // Check version once we're locked if (!checkShardVersion(txn, &shardingState, *removeItem.getRequest(), result)) { // Version error return; } // Context once we're locked, to set more details in currentOp() // TODO: better constructor? Client::Context writeContext( nss.ns(), storageGlobalParams.dbpath, false /* don't check version */); try { result->getStats().n = executor.execute(txn, writeContext.db()); } catch ( const DBException& ex ) { status = ex.toStatus(); if (ErrorCodes::isInterruption(status.code())) { throw; } result->setError(toWriteError(status)); } }
Timer::RunStats FileBasedPredicateEvaluationTestRunner::runOnce(const bool measure_cache_misses) { FileBasedPredicateEvaluationQueryExecutor executor(relation_, *predicate_, select_column_, thread_affinities_, tuple_stores_, indices_); Timer timer(measure_cache_misses); timer.start(); if (use_index_ >= 0) { executor.executeWithIndex(use_index_, sort_matches_); } else { executor.executeOnTupleStore(); } timer.stop(); return timer.getRunStats(); }
NS_IMETHODIMP nsHtml5Parser::Terminate() { // We should only call DidBuildModel once, so don't do anything if this is // the second time that Terminate has been called. if (mExecutor->IsComplete()) { return NS_OK; } // XXX - [ until we figure out a way to break parser-sink circularity ] // Hack - Hold a reference until we are completely done... nsCOMPtr<nsIParser> kungFuDeathGrip(this); RefPtr<nsHtml5StreamParser> streamParser(GetStreamParser()); RefPtr<nsHtml5TreeOpExecutor> executor(mExecutor); if (streamParser) { streamParser->Terminate(); } return executor->DidBuildModel(true); }
void ProgramController::ExecuteProject(std::string projectName) { FileController archiverListFile(archiverFile, false); FileController projectSettingsFile(projectName, false); ArchiverMap archiverMap = ArchiverMap(); ProjectSettings projectSettings = ProjectSettings(); if (archiverListFile.IsFileOpen()) { archiverMap = archiverListFile.LoadArchiverMapFromFile(); } if (projectSettingsFile.IsFileOpen() && projectSettingsFile.IsFileCorrect()) { projectSettings = projectSettingsFile.LoadProjectSettingsFromFile(); } ArchiverExecutor executor(archiverMap, projectSettings); executor.ExecutePacking(); }