bool PropertiesHandler::handleURI(URI& uri) { if (uri.action != "properties") return false; MetadataItemPropertiesPanel* parent = dynamic_cast< MetadataItemPropertiesPanel*>(getParentWindow(uri)); if (!parent) return true; DatabasePtr db = parent->getObservedObject()->getDatabase(); if (!db) return true; NodeType n = getTypeByName(uri.getParam("object_type")); MetadataItem* object = db->findByNameAndType(n, uri.getParam("object_name")); if (!object) { ::wxMessageBox( _("Cannot find destination object\nThis should never happen."), _("Error"), wxICON_ERROR); return true; } if (uri.getParam("target") == "new_tab") { MetadataItemPropertiesFrame::openNewPropertyPageInTab(object, parent->getParentFrame()); } else if (uri.getParam("target") == "new") MetadataItemPropertiesFrame::openNewPropertyPageInFrame(object); else MetadataItemPropertiesFrame::showPropertyPage(object); return true; }
QueryProcessingStage::Enum StorageMerge::getQueryProcessingStage(const Context & context) const { auto stage_in_source_tables = QueryProcessingStage::FetchColumns; DatabasePtr database = context.getDatabase(source_database); DatabaseIteratorPtr iterator = database->getIterator(context); size_t selected_table_size = 0; while (iterator->isValid()) { if (table_name_regexp.match(iterator->name())) { auto & table = iterator->table(); if (table.get() != this) { ++selected_table_size; stage_in_source_tables = std::max(stage_in_source_tables, table->getQueryProcessingStage(context)); } } iterator->next(); } return selected_table_size == 1 ? stage_in_source_tables : std::min(stage_in_source_tables, QueryProcessingStage::WithMergeableState); }
void Exceptions::load(ProgressIndicator* progressIndicator) { DatabasePtr db = getDatabase(); MetadataLoader* loader = db->getMetadataLoader(); MetadataLoaderTransaction tr(loader); wxMBConv* converter = db->getCharsetConverter(); IBPP::Statement& st1 = loader->getStatement( Exception::getLoadStatement(true)); CollectionType exceptions; st1->Execute(); checkProgressIndicatorCanceled(progressIndicator); while (st1->Fetch()) { if (!st1->IsNull(1)) { std::string s; st1->Get(1, s); wxString name(std2wxIdentifier(s, converter)); ExceptionPtr exception = findByName(name); if (!exception) { exception.reset(new Exception(db, name)); initializeLockCount(exception, getLockCount()); } exceptions.push_back(exception); exception->loadProperties(st1, converter); } checkProgressIndicatorCanceled(progressIndicator); } setItems(exceptions); }
//! reads checks info from database void Table::loadCheckConstraints() { if (checkConstraintsLoadedM) return; checkConstraintsM.clear(); DatabasePtr db = getDatabase(); wxMBConv* conv = db->getCharsetConverter(); MetadataLoader* loader = db->getMetadataLoader(); // first start a transaction for metadata loading, then lock the table // when objects go out of scope and are destroyed, table will be unlocked // before the transaction is committed - any update() calls on observers // can possibly use the same transaction MetadataLoaderTransaction tr(loader); SubjectLocker lock(this); IBPP::Statement& st1 = loader->getStatement( "select r.rdb$constraint_name, t.rdb$trigger_source, d.rdb$field_name " " from rdb$relation_constraints r " " join rdb$check_constraints c on r.rdb$constraint_name=c.rdb$constraint_name and r.rdb$constraint_type = 'CHECK'" " join rdb$triggers t on c.rdb$trigger_name=t.rdb$trigger_name and t.rdb$trigger_type = 1 " " left join rdb$dependencies d on t.rdb$trigger_name = d.rdb$dependent_name " " and d.rdb$depended_on_name = r.rdb$relation_name " " and d.rdb$depended_on_type = 0 " " where r.rdb$relation_name=? " " order by 1 " ); st1->Set(1, wx2std(getName_(), conv)); st1->Execute(); CheckConstraint *cc = 0; while (st1->Fetch()) { std::string s; st1->Get(1, s); wxString cname(std2wxIdentifier(s, conv)); if (!cc || cname != cc->getName_()) // new constraint { wxString source; readBlob(st1, 2, source, conv); CheckConstraint c; c.setParent(this); c.setName_(cname); c.sourceM = source; checkConstraintsM.push_back(c); cc = &checkConstraintsM.back(); } if (!st1->IsNull(3)) { st1->Get(3, s); wxString fname(std2wxIdentifier(s, conv)); cc->columnsM.push_back(fname); } } checkConstraintsLoadedM = true; }
//! determine the path, load and display html page void MetadataItemPropertiesPanel::loadPage() { wxString fileName = config().getHtmlTemplatesPath(); switch (pageTypeM) { case ptSummary: fileName += objectM->getTypeName() + ".html"; break; case ptConstraints: fileName += objectM->getTypeName() + "constraints.html"; break; case ptTriggers: fileName += objectM->getTypeName() + "triggers.html"; break; case ptPrivileges: fileName += objectM->getTypeName() + "privileges.html"; break; case ptTableIndices: fileName += "TABLEindices.html"; break; case ptDependencies: fileName += "dependencies.html"; break; case ptDDL: fileName += "DDL.html"; break; } wxBusyCursor bc; // start a transaction for metadata loading and lock the object DatabasePtr db = objectM->getDatabase(); MetadataLoaderTransaction tr((db) ? db->getMetadataLoader() : 0); SubjectLocker lock(objectM); ProgressDialog pd(this, _("Processing template...")); pd.doShow(); wxString htmlpage; HtmlTemplateProcessor tp(objectM, this); tp.processTemplateFile(htmlpage, fileName, 0, &pd); pd.SetTitle(_("Rendering page...")); wxWindowUpdateLocker freeze(html_window); int x = 0, y = 0; html_window->GetViewStart(&x, &y); // save scroll position html_window->setPageSource(htmlpage); html_window->Scroll(x, y); // restore scroll position // set title if (MetadataItemPropertiesFrame* pf = getParentFrame()) { pf->setTabTitle(this, objectM->getName_() + ": " + html_window->GetOpenedPageTitle()); } }
//! reads uniques from database void Table::loadUniqueConstraints() { if (uniqueConstraintsLoadedM) return; uniqueConstraintsM.clear(); DatabasePtr db = getDatabase(); wxMBConv* conv = db->getCharsetConverter(); MetadataLoader* loader = db->getMetadataLoader(); // first start a transaction for metadata loading, then lock the table // when objects go out of scope and are destroyed, table will be unlocked // before the transaction is committed - any update() calls on observers // can possibly use the same transaction MetadataLoaderTransaction tr(loader); SubjectLocker lock(this); IBPP::Statement& st1 = loader->getStatement( "select r.rdb$constraint_name, i.rdb$field_name, r.rdb$index_name " "from rdb$relation_constraints r, rdb$index_segments i " "where r.rdb$relation_name=? and r.rdb$index_name=i.rdb$index_name and " "(r.rdb$constraint_type='UNIQUE') order by r.rdb$constraint_name, i.rdb$field_position" ); st1->Set(1, wx2std(getName_(), conv)); st1->Execute(); UniqueConstraint *cc = 0; while (st1->Fetch()) { std::string s; st1->Get(1, s); wxString cname(std2wxIdentifier(s, conv)); st1->Get(2, s); wxString fname(std2wxIdentifier(s, conv)); st1->Get(3, s); wxString ixname(std2wxIdentifier(s, conv)); if (cc && cc->getName_() == cname) cc->columnsM.push_back(fname); else { UniqueConstraint c; uniqueConstraintsM.push_back(c); cc = &uniqueConstraintsM.back(); cc->indexNameM = ixname; cc->setName_(cname); cc->columnsM.push_back(fname); cc->setParent(this); } } uniqueConstraintsLoadedM = true; }
void ScheduleBroadcastCmd::OnContextChanged() { if ( m_spContext != NULL ) { DatabasePtr spDatabase = m_spContext->GetDatabase(); // Get broadcast by ID m_spBroadcast = spDatabase->GetBroadcast( m_u32BroadcastID ); } else { m_spBroadcast = BroadcastPtr(); } }
DatabaseAndTable InterpreterDropQuery::tryGetDatabaseAndTable(String & database_name, String & table_name, bool if_exists) { DatabasePtr database = tryGetDatabase(database_name, if_exists); if (database) { StoragePtr table = database->tryGetTable(context, table_name); if (!table && !if_exists) throw Exception("Table " + backQuoteIfNeed(database_name) + "." + backQuoteIfNeed(table_name) + " doesn't exist.", ErrorCodes::UNKNOWN_TABLE); return {std::move(database), std::move(table)}; } return {}; }
IceGrid::RegistryReplicaAdminRouter::RegistryReplicaAdminRouter(const string& name, const DatabasePtr& database) : AdminRouter(database->getTraceLevels()), _name(name), _database(database) { }
/* static */ InstanceKeyPtrSetPtr D3DatabasePermissionBase::GetAll(DatabasePtr pDB) { DatabasePtr pDatabase = pDB; if (!pDatabase) return NULL; if (pDatabase->GetMetaDatabase() != MetaDatabase::GetMetaDatabase("D3MDDB")) pDatabase = pDatabase->GetDatabaseWorkspace()->GetDatabase(MetaDatabase::GetMetaDatabase("D3MDDB")); if (!pDatabase) return NULL; return pDatabase->GetMetaDatabase()->GetMetaEntity(D3MDDB_D3DatabasePermission)->GetPrimaryMetaKey()->GetInstanceKeySet(pDatabase); }
RestoreFrame::RestoreFrame(wxWindow* parent, DatabasePtr db) : BackupRestoreBaseFrame(parent, db) { setIdString(this, getFrameId(db)); wxString databaseName(db->getName_()); wxString serverName(db->getServer()->getName_()); SetTitle(wxString::Format(_("Restore Database \"%s:%s\""), serverName.c_str(), databaseName.c_str())); createControls(); layoutControls(); updateControls(); text_ctrl_filename->SetFocus(); }
void RestoreFrame::updateControls() { bool running = getThreadRunning(); button_browse->Enable(!running); text_ctrl_filename->Enable(!running); checkbox_replace->Enable(!running); checkbox_deactivate->Enable(!running); checkbox_noshadow->Enable(!running); checkbox_validity->Enable(!running); checkbox_commit->Enable(!running); checkbox_space->Enable(!running); choice_pagesize->Enable(!running); DatabasePtr db = getDatabase(); button_start->Enable(!running && !text_ctrl_filename->GetValue().empty() && db && !db->isConnected()); }
/* static */ void D3DatabasePermissionBase::LoadAll(DatabasePtr pDB, bool bRefresh, bool bLazyFetch) { DatabasePtr pDatabase = pDB; if (!pDatabase) return; if (pDatabase->GetMetaDatabase() != MetaDatabase::GetMetaDatabase("D3MDDB")) pDatabase = pDatabase->GetDatabaseWorkspace()->GetDatabase(MetaDatabase::GetMetaDatabase("D3MDDB")); if (!pDatabase) return; pDatabase->GetMetaDatabase()->GetMetaEntity(D3MDDB_D3DatabasePermission)->LoadAll(pDatabase, bRefresh, bLazyFetch); }
InternalRegistryI::InternalRegistryI(const RegistryIPtr& registry, const DatabasePtr& database, const ReapThreadPtr& reaper, const WellKnownObjectsManagerPtr& wellKnownObjects, ReplicaSessionManager& session) : _registry(registry), _database(database), _reaper(reaper), _wellKnownObjects(wellKnownObjects), _fileCache(new FileCache(database->getCommunicator())), _session(session) { Ice::PropertiesPtr properties = database->getCommunicator()->getProperties(); _nodeSessionTimeout = properties->getPropertyAsIntWithDefault("IceGrid.Registry.NodeSessionTimeout", 30); _replicaSessionTimeout = properties->getPropertyAsIntWithDefault("IceGrid.Registry.ReplicaSessionTimeout", 30); }
/*static*/ wxString RestoreFrame::getFrameId(DatabasePtr db) { if (db) return wxString("RestoreFrame/" + db->getItemPath()); else return wxEmptyString; }
wxString EventWatcherFrame::getFrameId(DatabasePtr db) { if (db) return wxString("EventWatcherFrame/" + db->getItemPath()); else return wxEmptyString; }
// find all tables from "tables" which have foreign keys with "table" // and return them in "list" bool Table::tablesRelate(const std::vector<wxString>& tables, Table* table, std::vector<ForeignKey>& list) { // see if "table" references some of the "tables" std::vector<ForeignKey> *fks = table->getForeignKeys(); for (std::vector<ForeignKey>::iterator it = fks->begin(); it != fks->end(); ++it) { ForeignKey& fk = (*it); for (std::vector<wxString>::const_iterator i2 = tables.begin(); i2 != tables.end(); ++i2) if ((*i2) == fk.referencedTableM) list.push_back(fk); } // see if some of the "tables" reference the "table" std::vector<Dependency> deplist; table->getDependencies(deplist, false); for (std::vector<Dependency>::iterator it = deplist.begin(); it != deplist.end(); ++it) { if ((*it).getType() == ntTable) { for (std::vector<wxString>::const_iterator i2 = tables.begin(); i2 != tables.end(); ++i2) { if ((*i2) == (*it).getName_()) { // find foreign keys for that table DatabasePtr db = table->getDatabase(); Table* other_table = dynamic_cast<Table*>(db->findByNameAndType(ntTable, (*i2))); if (!other_table) break; std::vector<ForeignKey>* fks = other_table->getForeignKeys(); for (std::vector<ForeignKey>::iterator it = fks->begin(); it != fks->end(); ++it) { ForeignKey& fk = (*it); if (table->getName_() == fk.referencedTableM) { list.push_back(fk); break; // no need for more } } } } } } return !list.empty(); }
void Exception::loadProperties() { setPropertiesLoaded(false); DatabasePtr db = getDatabase(); MetadataLoader* loader = db->getMetadataLoader(); MetadataLoaderTransaction tr(loader); wxMBConv* converter = db->getCharsetConverter(); IBPP::Statement& st1 = loader->getStatement(getLoadStatement(false)); st1->Set(1, wx2std(getName_(), converter)); st1->Execute(); if (!st1->Fetch()) throw FRError(_("Exception not found: ") + getName_()); loadProperties(st1, converter); }
//----------------------------------------------------------------------------- void Server::createDatabase(DatabasePtr db, int pagesize, int dialect) { QString extra_params; if (pagesize) extra_params += (QString::fromLatin1(" PAGE_SIZE ") + pagesize); QString charset(db->getConnectionCharset()); if (!charset.isEmpty()) extra_params += (QString::fromLatin1(" DEFAULT CHARACTER SET ") + charset); IBPP::Database db1; db1 = IBPP::DatabaseFactory(wx2std(getConnectionString()), wx2std(db->getPath()), wx2std(db->getUsername()), wx2std(db->getDecryptedPassword()), "", wx2std(charset), wx2std(extra_params)); db1->Create(dialect); }
void EventWatcherFrame::OnButtonStartStopClick(wxCommandEvent& WXUNUSED(event)) { if (eventsM != 0) eventsM.clear(); else { DatabasePtr database = getDatabase(); if (!database) { Close(); return; } IBPP::Database db(database->getIBPPDatabase()); eventsM = IBPP::EventsFactory(db); defineMonitoredEvents(); } updateMonitoringActive(); }
//----------------------------------------------------------------------------- void Server::addDatabase(DatabasePtr database) { if (database) { databasesM.push_back(database); database->setServer(shared_from_this()); notifyObservers(); } }
void RestoreFrame::OnStartButtonClick(wxCommandEvent& WXUNUSED(event)) { verboseMsgsM = checkbox_showlog->IsChecked(); clearLog(); DatabasePtr database = getDatabase(); wxCHECK_RET(database, "Cannot restore unassigned database"); ServerPtr server = database->getServer(); wxCHECK_RET(server, "Cannot restore database without assigned server"); wxString username; wxString password; if (!getConnectionCredentials(this, database, username, password)) return; int flags = (int)IBPP::brVerbose; // this will be ORed in anyway if (checkbox_replace->IsChecked()) flags |= (int)IBPP::brReplace; if (checkbox_deactivate->IsChecked()) flags |= (int)IBPP::brDeactivateIdx; if (checkbox_noshadow->IsChecked()) flags |= (int)IBPP::brNoShadow; if (checkbox_validity->IsChecked()) flags |= (int)IBPP::brNoValidity; if (checkbox_commit->IsChecked()) flags |= (int)IBPP::brPerTableCommit; if (checkbox_space->IsChecked()) flags |= (int)IBPP::brUseAllSpace; unsigned long pagesize; if (!choice_pagesize->GetStringSelection().ToULong(&pagesize)) pagesize = 0; std::auto_ptr<wxThread> thread(new RestoreThread(this, server->getConnectionString(), username, password, text_ctrl_filename->GetValue(), database->getPath(), pagesize, (IBPP::BRF)flags)); startThread(thread); updateControls(); }
ServerProxyWrapper(const DatabasePtr& database, const string& id) : _id(id) { try { _proxy = database->getServer(_id)->getProxy(_activationTimeout, _deactivationTimeout, _node, false, 5); } catch(const SynchronizationException&) { throw DeploymentException("server is being updated"); } }
DatabasePtr Tracker::track(bool gratis) { DatabasePtr db = DatabasePtr(new Database); std::string content = fetch(); HTML::ParserDom parser; tree<HTML::Node> dom = parser.parseTree(content); for (tree<HTML::Node>::iterator it = dom.begin(); it != dom.end(); ++it) { if (it->tagName()=="div" && it->text().find("class=\"media-body\"") != std::string::npos) { DataItemPtr di = getOneDataItem(content, it, gratis); if (!inIgnoreList(di->m_URL)) db->add(di); } } return db; }
//----------------------------------------------------------------------------- void Exception::loadProperties() { setPropertiesLoaded(false); DatabasePtr db = getDatabase(); MetadataLoader* loader = db->getMetadataLoader(); MetadataLoaderTransaction tr(loader); IBPP::Statement& st1 = loader->getStatement( "select RDB$MESSAGE, RDB$EXCEPTION_NUMBER from RDB$EXCEPTIONS" " where RDB$EXCEPTION_NAME = ?"); st1->Set(1, wx2std(getName_(), db->getCharsetConverter())); st1->Execute(); st1->Fetch(); std::string message; st1->Get(1, message); messageM = std2wx(message, db->getCharsetConverter()); st1->Get(2, numberM); setPropertiesLoaded(true); }
//! MetadataItemPropertiesFrame class MetadataItemPropertiesFrame::MetadataItemPropertiesFrame(wxWindow* parent, MetadataItem* object) : BaseFrame(parent, wxID_ANY, wxEmptyString) { // we need to store this right now, since we might lose the object later setStorageName(object); wxStatusBar* sb = CreateStatusBar(); DatabasePtr db = object->getDatabase(); if (db) // server property page doesn't have a database, so don't crash sb->SetStatusText(db->getConnectionInfoString()); else sb->SetStatusText(object->getName_()); if (db && config().get("linksOpenInTabs", true)) { SetIcon(wxArtProvider::GetIcon(ART_DatabaseConnected, wxART_FRAME_ICON)); databaseNameM = db->getName_(); } else // when linksOpenInTabs, only the server node { SetIcon(getMetadataItemIcon(object->getType())); } notebookM = new wxAuiNotebook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxAUI_NB_DEFAULT_STYLE | wxAUI_NB_WINDOWLIST_BUTTON | wxAUI_NB_TAB_EXTERNAL_MOVE | wxNO_BORDER); auiManagerM.SetManagedWindow(this); auiManagerM.AddPane(notebookM, wxAuiPaneInfo().CenterPane().PaneBorder(false)); auiManagerM.Update(); Connect(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, wxAuiNotebookEventHandler( MetadataItemPropertiesFrame::OnNotebookPageClose), NULL, this); Connect(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED, wxAuiNotebookEventHandler( MetadataItemPropertiesFrame::OnNotebookPageChanged), NULL, this); }
TablePtr AddConstraintHandler::selectTable(DatabasePtr db, wxWindow* parent) const { wxArrayString tables; TablesPtr ts(db->getTables()); for (Tables::const_iterator it = ts->begin(); it != ts->end(); ++it) tables.Add((*it)->getName_()); int index = ::wxGetSingleChoiceIndex(_("Select table to reference"), _("Creating foreign key"), tables, parent); if (index == -1) return TablePtr(); return ts->findByName(tables[index]); }
StorageMerge::StorageListWithLocks StorageMerge::getSelectedTables(const ASTPtr & query, bool has_virtual_column, bool get_lock) const { StorageListWithLocks selected_tables; DatabasePtr database = global_context.getDatabase(source_database); DatabaseIteratorPtr iterator = database->getIterator(global_context); auto virtual_column = ColumnString::create(); while (iterator->isValid()) { if (table_name_regexp.match(iterator->name())) { StoragePtr storage = iterator->table(); if (query && typeid_cast<ASTSelectQuery *>(query.get())->prewhere_expression && !storage->supportsPrewhere()) throw Exception("Storage " + storage->getName() + " doesn't support PREWHERE.", ErrorCodes::ILLEGAL_PREWHERE); if (storage.get() != this) { virtual_column->insert(storage->getTableName()); selected_tables.emplace_back(storage, get_lock ? storage->lockStructure(false) : TableStructureReadLockPtr{}); } } iterator->next(); } if (has_virtual_column) { Block virtual_columns_block = Block{ColumnWithTypeAndName(std::move(virtual_column), std::make_shared<DataTypeString>(), "_table")}; VirtualColumnUtils::filterBlockWithQuery(query, virtual_columns_block, global_context); auto values = VirtualColumnUtils::extractSingleValueFromBlock<String>(virtual_columns_block, "_table"); /// Remove unused tables from the list selected_tables.remove_if([&] (const auto & elem) { return values.find(elem.first->getTableName()) == values.end(); }); } return selected_tables; }
int main(int argc, char ** argv) try { Poco::AutoPtr<Poco::ConsoleChannel> channel = new Poco::ConsoleChannel(std::cerr); Logger::root().setChannel(channel); Logger::root().setLevel("trace"); /// Pre-initialize the `DateLUT` so that the first initialization does not affect the measured execution speed. DateLUT::instance(); Context context; context.setPath("./"); loadMetadata(context); DatabasePtr system = std::make_shared<DatabaseOrdinary>("system", "./metadata/system/"); context.addDatabase("system", system); system->loadTables(context, nullptr, false); system->attachTable("one", StorageSystemOne::create("one")); system->attachTable("numbers", StorageSystemNumbers::create("numbers")); context.setCurrentDatabase("default"); ReadBufferFromIStream in(std::cin); WriteBufferFromOStream out(std::cout); executeQuery(in, out, /* allow_into_outfile = */ false, context, {}); return 0; } catch (const Exception & e) { std::cerr << e.what() << ", " << e.displayText() << std::endl << std::endl << "Stack trace:" << std::endl << e.getStackTrace().toString(); return 1; }
//----------------------------------------------------------------------------- void Generator::loadProperties() { setPropertiesLoaded(false); DatabasePtr db = getDatabase(); MetadataLoader* loader = db->getMetadataLoader(); MetadataLoaderTransaction tr(loader); // IMPORTANT: for all other loading where the name of the db object is // Set() into a parameter getName_() is used, but for dynamically // building the SQL statement getQuotedName() must be used! std::string sqlName(wx2std(getQuotedName(), db->getCharsetConverter())); // do not use cached statements, because this can not be reused IBPP::Statement st1 = loader->createStatement( "select gen_id(" + sqlName + ", 0) from rdb$database"); st1->Execute(); st1->Fetch(); st1->Get(1, &valueM); setPropertiesLoaded(true); notifyObservers(); }