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