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();
}
