void SearchEnginesDialog::addEngine() { EditSearchEngine dialog(tr("Add Search Engine"), this); dialog.hideIconLabels(); if (dialog.exec() != QDialog::Accepted) { return; } SearchEngine engine; engine.name = dialog.name(); engine.url = dialog.url(); engine.postData = dialog.postData().toUtf8(); engine.shortcut = dialog.shortcut(); engine.icon = SearchEnginesManager::iconForSearchEngine(QUrl::fromEncoded(dialog.url().toUtf8())); if (engine.name.isEmpty() || engine.url.isEmpty()) { return; } QTreeWidgetItem* item = new QTreeWidgetItem(); setEngine(item, engine); changeItemToDefault(item, false); item->setIcon(0, engine.icon); item->setText(1, engine.shortcut); ui->treeWidget->addTopLevelItem(item); }
void SearchEnginesDialog::editEngine() { QTreeWidgetItem* item = ui->treeWidget->currentItem(); if (!item) { return; } SearchEngine engine = getEngine(item); EditSearchEngine dialog(tr("Edit Search Engine"), this); dialog.setName(engine.name); dialog.setUrl(engine.url); dialog.setShortcut(engine.shortcut); dialog.setIcon(engine.icon); if (dialog.exec() != QDialog::Accepted) { return; } engine.name = dialog.name(); engine.url = dialog.url(); engine.shortcut = dialog.shortcut(); engine.icon = dialog.icon(); if (engine.name.isEmpty() || engine.url.isEmpty()) { return; } setEngine(item, engine); changeItemToDefault(item, isDefaultEngine(item)); item->setIcon(0, engine.icon); item->setText(1, engine.shortcut); }
/** * Creates instances of BasicBehaviours, needed according to the PlanRepository, with the help of the given * BehaviourCreator. If a BasicBehaviour cannot be instantiated, the Initialisation of the Pool is cancelled. * @param bc A BehaviourCreator. * @return True, if all necessary BasicBehaviours could be constructed. False, if the Initialisation was cancelled. */ bool BehaviourPool::init(IBehaviourCreator* bc) { if (_behaviourCreator != nullptr) { delete _behaviourCreator; } _behaviourCreator = bc; const PlanRepository::Accessor<BehaviourConfiguration>& behaviourConfs = _ae->getPlanRepository()->getBehaviourConfigurations(); for (const BehaviourConfiguration* beh : behaviourConfs) { auto basicBeh = _behaviourCreator->createBehaviour(beh->getId()); if (basicBeh != nullptr) { // set stuff from behaviour configuration in basic behaviour object basicBeh->setConfiguration(beh); basicBeh->setDelayedStart(beh->getDeferring()); basicBeh->setInterval(1000 / beh->getFrequency()); basicBeh->setEngine(_ae); basicBeh->init(); _availableBehaviours.insert(make_pair(beh, basicBeh)); } else { return false; } } return true; }
void HWInfo::init() { KGlobal::locale()->insertCatalog("plasma_applet_system-monitor"); setTitle(i18n("Hardware Info")); setEngine(dataEngine("soliddevice")); setSources(); connectToEngine(); }
ScriptCache::ScriptCache() : _engine(NULL) { setEngine(new QScriptEngine(this)); const qint64 SCRIPT_DEFAULT_UNUSED_MAX_SIZE = 50 * BYTES_PER_MEGABYTES; setUnusedResourceCacheSize(SCRIPT_DEFAULT_UNUSED_MAX_SIZE); }
void Hdd::init() { KGlobal::locale()->insertCatalog("plasma_applet_system-monitor"); QString predicateString("IS StorageVolume"); setEngine(dataEngine("soliddevice")); setTitle(i18n("Disk Space"), true); configChanged(); }
void SM::Ram::init() { KGlobal::locale()->insertCatalog("plasma_applet_system-monitor"); setEngine(dataEngine("systemmonitor")); setTitle(i18n("RAM")); /* At the time this method is running, not all source may be connected. */ connect(engine(), SIGNAL(sourceAdded(QString)), this, SLOT(sourceAdded(QString))); foreach (const QString& source, engine()->sources()) { sourceAdded(source); }
void Hdd_Activity::init() { KGlobal::locale()->insertCatalog("plasma_applet_system-monitor"); setEngine(dataEngine("systemmonitor")); setTitle(i18n("Disk Activity"), true); /* At the time this method is running, not all sources may be connected. */ connect(engine(), SIGNAL(sourceAdded(QString)), this, SLOT(sourceChanged(QString))); connect(engine(), SIGNAL(sourceRemoved(QString)), this, SLOT(sourceChanged(QString))); foreach (const QString& source, engine()->sources()) { sourceChanged(source); }
void SearchEnginesDialog::reloadEngines() { ui->treeWidget->clear(); const QString defaultEngineName = mApp->searchEnginesManager()->defaultEngine().name; foreach (const SearchEngine &en, m_manager->allEngines()) { QTreeWidgetItem* item = new QTreeWidgetItem(); setEngine(item, en); changeItemToDefault(item, en.name == defaultEngineName); item->setIcon(0, en.icon); item->setText(1, en.shortcut); ui->treeWidget->addTopLevelItem(item); } }
EditorView::EditorView(QWidget * parent) : KGLView(parent), m_engine(0), m_selectedItem(0), m_moving(false), m_grid(true), m_gridSize(1) { grabMouse(); setMouseTracking(true); QRect screenDim = QApplication::desktop()->screenGeometry(); m_ratio = (double)screenDim.width()/screenDim.height(); m_engine= new KGLPhysicsEngine; setEngine(m_engine); m_wallPaperItem = new KGLBoxItem(20*m_ratio, 20); m_groundItem = new KGLPhysicsItem; initEngine(); }
ScriptCache::ScriptCache() : _engine(NULL) { setEngine(new QScriptEngine(this)); }
BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create) { if (!create.cluster.empty()) { NameSet databases{create.database}; if (!create.to_table.empty()) databases.emplace(create.to_database); return executeDDLQueryOnCluster(query_ptr, context, std::move(databases)); } String path = context.getPath(); String current_database = context.getCurrentDatabase(); String database_name = create.database.empty() ? current_database : create.database; String table_name = create.table; String table_name_escaped = escapeForFileName(table_name); // If this is a stub ATTACH query, read the query definition from the database if (create.attach && !create.storage && !create.columns) { // Table SQL definition is available even if the table is detached auto query = context.getCreateTableQuery(database_name, table_name); auto & as_create = typeid_cast<const ASTCreateQuery &>(*query); create = as_create; // Copy the saved create query, but use ATTACH instead of CREATE create.attach = true; } if (create.to_database.empty()) create.to_database = current_database; if (create.select && (create.is_view || create.is_materialized_view)) { AddDefaultDatabaseVisitor visitor(current_database); visitor.visit(*create.select); } Block as_select_sample; if (create.select && (!create.attach || !create.columns)) as_select_sample = InterpreterSelectWithUnionQuery::getSampleBlock(create.select->clone(), context); String as_database_name = create.as_database.empty() ? current_database : create.as_database; String as_table_name = create.as_table; StoragePtr as_storage; TableStructureReadLockPtr as_storage_lock; if (!as_table_name.empty()) { as_storage = context.getTable(as_database_name, as_table_name); as_storage_lock = as_storage->lockStructure(false); } /// Set and retrieve list of columns. ColumnsDescription columns = setColumns(create, as_select_sample, as_storage); /// Some column types may be not allowed according to settings. if (!create.attach) checkSupportedTypes(columns, context); /// Set the table engine if it was not specified explicitly. setEngine(create); StoragePtr res; { std::unique_ptr<DDLGuard> guard; String data_path; DatabasePtr database; if (!create.temporary) { database = context.getDatabase(database_name); data_path = database->getDataPath(); /** If the request specifies IF NOT EXISTS, we allow concurrent CREATE queries (which do nothing). * If table doesnt exist, one thread is creating table, while others wait in DDLGuard. */ guard = context.getDDLGuard(database_name, table_name); /// Table can be created before or it can be created concurrently in another thread, while we were waiting in DDLGuard. if (database->isTableExist(context, table_name)) { if (create.if_not_exists) return {}; else throw Exception("Table " + database_name + "." + table_name + " already exists.", ErrorCodes::TABLE_ALREADY_EXISTS); } } else if (context.tryGetExternalTable(table_name) && create.if_not_exists) return {}; res = StorageFactory::instance().get(create, data_path, table_name, database_name, context, context.getGlobalContext(), columns, create.attach, false); if (create.temporary) context.getSessionContext().addExternalTable(table_name, res, query_ptr); else database->createTable(context, table_name, res, query_ptr); /// We must call "startup" and "shutdown" while holding DDLGuard. /// Because otherwise method "shutdown" (from InterpreterDropQuery) can be called before startup /// (in case when table was created and instantly dropped before started up) /// /// Method "startup" may create background tasks and method "shutdown" will wait for them. /// But if "shutdown" is called before "startup", it will exit early, because there are no background tasks to wait. /// Then background task is created by "startup" method. And when destructor of a table object is called, background task is still active, /// and the task will use references to freed data. res->startup(); } /// If the query is a CREATE SELECT, insert the data into the table. if (create.select && !create.attach && !create.is_view && (!create.is_materialized_view || create.is_populate)) { auto insert = std::make_shared<ASTInsertQuery>(); if (!create.temporary) insert->database = database_name; insert->table = table_name; insert->select = create.select->clone(); if (create.temporary && !context.getSessionContext().hasQueryContext()) context.getSessionContext().setQueryContext(context.getSessionContext()); return InterpreterInsertQuery(insert, create.temporary ? context.getSessionContext() : context, context.getSettingsRef().insert_allow_materialized_columns).execute(); } return {}; }
void Linear::set(const std::vector<scalar>& coeffs, const Engine* engine) { setCoefficients(coeffs); setEngine(engine); }
void pidDriver (void) { ADC_OFF; Pitch_Difference = ADC_standStill[ADC_PITCH]-ADC_runtime[ADC_PITCH]-(int)ADC_drift[ADC_PITCH]; Y_Difference_AccY = ADC_standStill[ADC_ACCY]-ADC_runtime[ADC_ACCY]; Y_Difference_GyrN = -1*(ADC_standStill[ADC_NICK]-ADC_runtime[ADC_NICK]-(int)ADC_drift[ADC_NICK]); X_Difference_AccX = ADC_standStill[ADC_ACCX]-ADC_runtime[ADC_ACCX]; //X_Difference_AccX = -1*(ADC_standStill[ADC_ACCX]-ADC_runtime[ADC_ACCX]); X_Difference_GyrR = ADC_standStill[ADC_ROLL]-ADC_runtime[ADC_ROLL]-(int)ADC_drift[ADC_ROLL]; //X_Difference_GyrR = -1*(ADC_standStill[ADC_ROLL]-ADC_runtime[ADC_ROLL]-(int)ADC_drift[ADC_ROLL]); ADC_ON; //Pitch axis //the raw sensor value DifferencePitchGyr = Pitch_Difference; //limit the raw value DifferencePitchFact = (signed int)(Pitch_Difference * fcSetup.pid_GyroPitchFact); //add limited raw value to I Pitch_Difference_Sum += DifferencePitchFact; //integral > max limit to max if (Pitch_Difference_Sum > fcSetup.pid_Pitch_IntegralMax) { Pitch_Difference_Sum = fcSetup.pid_Pitch_IntegralMax; } //integral < min limit to min if (Pitch_Difference_Sum < fcSetup.pid_Pitch_IntegralMin) { Pitch_Difference_Sum = fcSetup.pid_Pitch_IntegralMin; } //Pitch P Pitch_Difference = (signed int)(fcSetup.pid_PitchP * DifferencePitchFact); //Pitch I Pitch_Difference += (signed int)(fcSetup.pid_PitchI * Pitch_Difference_Sum); //Pitch D Pitch_Difference += (signed int)(fcSetup.pid_PitchD * (DifferencePitchFact + Pitch_Difference_old)); //Pitch Stick Pitch_Difference += (signed int)(fcSetup.pid_PitchStickFact * PWM_channel[PWM_G]); Pitch_Difference_old = DifferencePitchFact; //DifferencePitchFact = 0; //Pitch_Difference = 0; //Normalize throttle value to get -120 -> 120 to 0 -> 240 throttle = PWM_channel[PWM_THROTTLE] + fcSetup.pid_throttleOffset; if (fcSetup.components[airpressureComponent]) { altActual = ADC_standStill[AIRPRESSURE] - ADC_runtime[AIRPRESSURE]; if (PWM_channel[baroChan] < 50) { targetAlt = altActual; LED4_OFF; } else { if (altActual > targetAlt) { LED4_ON; throttle -= targetAlt - altActual; } } } //here we try to tackle the changes in throttle due to Pitch control //Subtract Pitch reaction from throttle signed int PitchLimiter = (Pitch_Difference * fcSetup.pid_PitchThrottleFact); PitchLimiter = 0; //Roll axis XACCDelta = (X_Gyr_ACC_Difference_old - X_Gyr_ACC_Difference) / 50; X_Gyr_ACC_Difference_old = X_Gyr_ACC_Difference; //Normalize Gyro and ACC Signal X_Gyr_ACC_Difference = (signed int)(X_Difference_AccX * fcSetup.pid_X_AccX_Fact); // ACC limits the Gyro to help ACC to have more force when having large ACC values // this should help ACC force to be more reactive and not to force against the gyro X_AccGyroLimiter = X_Difference_GyrR + XACCDelta; X_AccGyroLimiter = 0.0; X_Gyr_ACC_Difference += (signed int)(X_Difference_GyrR * (fcSetup.pid_X_GyroFact - X_AccGyroLimiter)); //X_Gyr_ACC_Difference += (signed int)(X_Difference_GyrR - X_AccGyroLimiter * (fcSetup.pid_X_GyroFact)); //Gyr ACC > max limit to max if(X_Gyr_ACC_Difference > fcSetup.pid_X_GyroACCFactMax) { X_Gyr_ACC_Difference = fcSetup.pid_X_GyroACCFactMax; } //Gyr ACC < min limit to min if(X_Gyr_ACC_Difference < fcSetup.pid_X_GyroACCFactMin) { X_Gyr_ACC_Difference = fcSetup.pid_X_GyroACCFactMin; } //PID - controller //Limits the Gyro ACC reaction relative to what the Stick wants to achieve //This should help the stick has not to work against the sensors XStickLimiter = fcSetup.pid_X_GyroACCFact / 120 * abs(PWM_channel[PWM_R]); XStickLimiter = 0.0; //Difference = X_DifferenceFact * factor from setting (expected = 0) 0 is expected as in a perfect world no change would ever happen X_DifferenceFact = X_Gyr_ACC_Difference * (fcSetup.pid_X_GyroACCFact - XStickLimiter); //calculate Integral I X_Difference_Sum += X_DifferenceFact; //integral > max limit to max integral coming from setting if (X_Difference_Sum > fcSetup.pid_X_IntegralMax) { X_Difference_Sum = fcSetup.pid_X_IntegralMax; } //integral < min limit to min integral coming from setting if (X_Difference_Sum < fcSetup.pid_X_IntegralMin) { X_Difference_Sum = fcSetup.pid_X_IntegralMin; } //Roll P X_Response = (signed int)(fcSetup.pid_X_P * X_DifferenceFact); //Roll I X_Response += (signed int)(fcSetup.pid_X_I * X_Difference_Sum); //Roll D X_Response += (signed int)(fcSetup.pid_X_D * (X_DifferenceFact + X_Difference_old)); //Roll Stick X_Response -= (signed int)(fcSetup.pid_RollStickFact * PWM_channel[PWM_R]); //save old value for D X_Difference_old = X_DifferenceFact; //Nick axis //Normalize Gyr Signal and AAC Y_Gyr_ACC_Difference = (signed int)(Y_Difference_GyrN * fcSetup.pid_Y_GyroFact); // ACC limits the Gyro to help ACC to have more force when having large ACC values // this should help ACC force to be more reactive and not to force against the gyro YAccGyroLimiter = fcSetup.pid_Y_GyroFact / accOneG * abs(X_Difference_AccX); YAccGyroLimiter = 0; Y_Gyr_ACC_Difference += (signed int)(Y_Difference_AccY * (fcSetup.pid_Y_AccY_Fact - YAccGyroLimiter)); //Gyr ACC > max limit to max if(Y_Gyr_ACC_Difference > fcSetup.pid_Y_GyroACCFactMax) { Y_Gyr_ACC_Difference = fcSetup.pid_Y_GyroACCFactMax; } //Gyr ACC < min limit to min if(Y_Gyr_ACC_Difference < fcSetup.pid_Y_GyroACCFactMin) { Y_Gyr_ACC_Difference = fcSetup.pid_Y_GyroACCFactMin; } //Limits the Gyro ACC reaction relative to what the Stick wants to achieve //This should help the stick has not to work against the sensors YStickLimiter = fcSetup.pid_Y_GyroACCFact / 120 * abs(PWM_channel[PWM_N]); YStickLimiter = 0; //Difference gets regulated to limit max reaction to it Y_DifferenceFact = (signed int)(Y_Gyr_ACC_Difference * (fcSetup.pid_Y_GyroACCFact - YStickLimiter)); //calculate Integral Y_Difference_Sum += Y_DifferenceFact; //integral > max limit to max if (Y_Difference_Sum > fcSetup.pid_Y_IntegralMax) { Y_Difference_Sum = fcSetup.pid_Y_IntegralMax; } //integral < min limit to min if (Y_Difference_Sum < fcSetup.pid_Y_IntegralMin) { Y_Difference_Sum = fcSetup.pid_Y_IntegralMin; } //do the controlling PID math //Nick P Y_Response = (signed int)(fcSetup.pid_Y_P * Y_DifferenceFact); //Nick I Y_Response += (signed int)(fcSetup.pid_Y_I * Y_Difference_Sum); //Nick D Y_Response += (signed int)(fcSetup.pid_Y_D * (Y_DifferenceFact + Y_Difference_old)); //Nick Stick Y_Response -= (signed int)(fcSetup.pid_NickStickFact * PWM_channel[PWM_N]); //save old value for D Y_Difference_old = Y_DifferenceFact; //set the engine values signed int pitchFact = (int)((fcSetup.pid_X_PitchFact * Pitch_Difference) + PitchLimiter) * pitchCorrection; Engine_value = (int)((throttle - X_Response) - pitchFact); setEngine(RIGHTENGINE,Engine_value); Engine_value = (int)((throttle + X_Response) - pitchFact); setEngine(LEFTENGINE,Engine_value); //this is for single axis testing //PWMEngOut[RIGHTENGINE] = 0; //PWMEngOut[LEFTENGINE] = 0; pitchFact = (int)((fcSetup.pid_Y_PitchFact * Pitch_Difference)- PitchLimiter) * pitchCorrection; Engine_value = (int)((throttle + Y_Response) + pitchFact); setEngine(FRONTENGINE,Engine_value); Engine_value = (int)((throttle - Y_Response) + pitchFact); setEngine(BACKENGINE,Engine_value); //this is for single axis testing //PWMEngOut[FRONTENGINE] = 0; //PWMEngOut[BACKENGINE] = 0; }
BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create) { if (!create.cluster.empty()) { NameSet databases{create.database}; if (!create.to_table.empty()) databases.emplace(create.to_database); return executeDDLQueryOnCluster(query_ptr, context, databases); } String path = context.getPath(); String current_database = context.getCurrentDatabase(); String database_name = create.database.empty() ? current_database : create.database; String table_name = create.table; String table_name_escaped = escapeForFileName(table_name); // If this is a stub ATTACH query, read the query definition from the database if (create.attach && !create.storage && !create.columns) { // Table SQL definition is available even if the table is detached auto query = context.getCreateTableQuery(database_name, table_name); auto & as_create = typeid_cast<const ASTCreateQuery &>(*query); create = as_create; // Copy the saved create query, but use ATTACH instead of CREATE create.attach = true; } if (create.to_database.empty()) create.to_database = current_database; if (create.select && (create.is_view || create.is_materialized_view)) create.select->setDatabaseIfNeeded(current_database); Block as_select_sample; if (create.select && (!create.attach || !create.columns)) as_select_sample = InterpreterSelectWithUnionQuery::getSampleBlock(create.select->clone(), context); String as_database_name = create.as_database.empty() ? current_database : create.as_database; String as_table_name = create.as_table; StoragePtr as_storage; TableStructureReadLockPtr as_storage_lock; if (!as_table_name.empty()) { as_storage = context.getTable(as_database_name, as_table_name); as_storage_lock = as_storage->lockStructure(false, __PRETTY_FUNCTION__); } /// Set and retrieve list of columns. ColumnsDescription columns = setColumns(create, as_select_sample, as_storage); /// Set the table engine if it was not specified explicitly. setEngine(create); StoragePtr res; { std::unique_ptr<DDLGuard> guard; String data_path; DatabasePtr database; if (!create.is_temporary) { database = context.getDatabase(database_name); data_path = database->getDataPath(); /** If the table already exists, and the request specifies IF NOT EXISTS, * then we allow concurrent CREATE queries (which do nothing). * Otherwise, concurrent queries for creating a table, if the table does not exist, * can throw an exception, even if IF NOT EXISTS is specified. */ guard = context.getDDLGuardIfTableDoesntExist(database_name, table_name, "Table " + database_name + "." + table_name + " is creating or attaching right now"); if (!guard) { if (create.if_not_exists) return {}; else throw Exception("Table " + database_name + "." + table_name + " already exists.", ErrorCodes::TABLE_ALREADY_EXISTS); } } else if (context.tryGetExternalTable(table_name) && create.if_not_exists) return {}; res = StorageFactory::instance().get(create, data_path, table_name, database_name, context, context.getGlobalContext(), columns, create.attach, false); if (create.is_temporary) context.getSessionContext().addExternalTable(table_name, res, query_ptr); else database->createTable(context, table_name, res, query_ptr); } res->startup(); /// If the query is a CREATE SELECT, insert the data into the table. if (create.select && !create.attach && !create.is_view && (!create.is_materialized_view || create.is_populate)) { auto insert = std::make_shared<ASTInsertQuery>(); if (!create.is_temporary) insert->database = database_name; insert->table = table_name; insert->select = create.select->clone(); return InterpreterInsertQuery(insert, create.is_temporary ? context.getSessionContext() : context, context.getSettingsRef().insert_allow_materialized_columns).execute(); } return {}; }
ScriptCache::ScriptCache() : _networkAccessManager(NULL), _engine(NULL) { setEngine(new QScriptEngine(this)); }
int main(void) { time_t start, end; string dir = string("./moviesdb"); // Stores the path of the folder with the files multimap<int, string> results; // Stores the qualifying files and sorts them std::tr1::unordered_set<string> stops; // Stores the stop words std::tr1::unordered_map< string, std::tr1::unordered_map<std::string,int> > files_freq; // Stores the words, files and frequency vector<string> inputs; // Stores the inputs of the user vector<ParsedFile> files; // Stores the files of the directory char searching[256]; int count = 0; cout << endl << " Building the Search Engine... "<< endl ; time (&start); // Starts the engine setEngine(dir, stops, files, files_freq); time (&end); cout << " The search engine finished building. It took: " << difftime(end,start) << " seconds" << endl << endl; do{ // Displays the logo displayLogo(); // Gets the inputs of the user getWords(inputs, count); //for (int i = 0; i < inputs.size(); i++) // cout << inputs[i] << " "; // Gets results of case with two words if(inputs.size() == 2){ results = getResults(inputs[0], inputs[1], files_freq); } // Gets results of case with one word else if (inputs.size() == 1){ results = getResults(inputs[0], inputs[0], files_freq); } //Display the three most highest files based on frequency displayResults(results); cout << "Want to keep searching? Enter 'y' if yes or 'n' if no" << endl; cin >> searching; results.clear(); count++; }while(strcmp(searching, "y") == 0 || strcmp(searching, "Y") == 0); return 0; }
Engine::Engine(unsigned int engid, double aforce[3], double pos[3], double orient[3], float force) { setEngine(engid, aforce, pos, orient, force); }
BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create) { String path = context.getPath(); String current_database = context.getCurrentDatabase(); String database_name = create.database.empty() ? current_database : create.database; String database_name_escaped = escapeForFileName(database_name); String table_name = create.table; String table_name_escaped = escapeForFileName(table_name); String data_path = path + "data/" + database_name_escaped + "/"; String metadata_path = path + "metadata/" + database_name_escaped + "/" + table_name_escaped + ".sql"; std::unique_ptr<InterpreterSelectQuery> interpreter_select; Block as_select_sample; /// Для таблиц типа view, чтобы получить столбцы, может понадобиться sample_block. if (create.select && (!create.attach || (!create.columns && (create.is_view || create.is_materialized_view)))) { interpreter_select = std::make_unique<InterpreterSelectQuery>(create.select, context); as_select_sample = interpreter_select->getSampleBlock(); } String as_database_name = create.as_database.empty() ? current_database : create.as_database; String as_table_name = create.as_table; StoragePtr as_storage; IStorage::TableStructureReadLockPtr as_storage_lock; if (!as_table_name.empty()) { as_storage = context.getTable(as_database_name, as_table_name); as_storage_lock = as_storage->lockStructure(false); } /// Устанавливаем и получаем список столбцов. ColumnsInfo columns = setColumns(create, as_select_sample, as_storage); /// Выбор нужного движка таблицы String storage_name = setEngine(create, as_storage); StoragePtr res; { std::unique_ptr<DDLGuard> guard; if (!create.is_temporary) { context.assertDatabaseExists(database_name); /** Если таблица уже существует, и в запросе указано IF NOT EXISTS, * то мы разрешаем конкуррентные запросы CREATE (которые ничего не делают). * Иначе конкуррентные запросы на создание таблицы, если таблицы не существует, * могут кидать исключение, даже если указано IF NOT EXISTS. */ guard = context.getDDLGuardIfTableDoesntExist(database_name, table_name, "Table " + database_name + "." + table_name + " is creating or attaching right now"); if (!guard) { if (create.if_not_exists) return {}; else throw Exception("Table " + database_name + "." + table_name + " already exists.", ErrorCodes::TABLE_ALREADY_EXISTS); } } res = StorageFactory::instance().get( storage_name, data_path, table_name, database_name, context, context.getGlobalContext(), query_ptr, columns.columns, columns.materialized_columns, columns.alias_columns, columns.column_defaults, create.attach); if (create.is_temporary) context.getSessionContext().addExternalTable(table_name, res); else context.getDatabase(database_name)->createTable(table_name, res, query_ptr, storage_name); } /// Если запрос CREATE SELECT, то вставим в таблицу данные if (create.select && storage_name != "View" && (storage_name != "MaterializedView" || create.is_populate)) { auto table_lock = res->lockStructure(true); /// Также см. InterpreterInsertQuery. BlockOutputStreamPtr out = std::make_shared<ProhibitColumnsBlockOutputStream>( std::make_shared<AddingDefaultBlockOutputStream>( std::make_shared<MaterializingBlockOutputStream>( std::make_shared<PushingToViewsBlockOutputStream>( create.database, create.table, create.is_temporary ? context.getSessionContext() : context, query_ptr)), /// @note shouldn't these two contexts be session contexts in case of temporary table? columns.columns, columns.column_defaults, context, static_cast<bool>(context.getSettingsRef().strict_insert_defaults)), columns.materialized_columns); BlockIO io; io.in_sample = as_select_sample; io.in = std::make_shared<NullAndDoCopyBlockInputStream>(interpreter_select->execute().in, out); return io; } return {}; }