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 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 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);
}
//-----------------------------------------------------------------------------
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();
}
DomainPtr DomainCollectionBase::getDomain(const wxString& name)
{
DomainPtr domain = findByName(name);
if (!domain)
{
SubjectLocker lock(this);
DatabasePtr db = getDatabase();
MetadataLoader* loader = db->getMetadataLoader();
MetadataLoaderTransaction tr(loader);
wxMBConv* converter = db->getCharsetConverter();
IBPP::Statement& st1 = loader->getStatement(
Domain::getLoadStatement(false));
st1->Set(1, wx2std(name, converter));
st1->Execute();
if (st1->Fetch())
{
domain = insert(name);
domain->loadProperties(st1, converter);
}
}
return domain;
}
void Function::loadProperties()
{
setPropertiesLoaded(false);
wxString mechanismNames[] = { "value", "reference",
"descriptor", "blob descriptor", "scalar array",
"null", wxEmptyString };
wxString mechanismDDL[] = { " BY VALUE ", wxEmptyString,
" BY DESCRIPTOR ", wxEmptyString, " BY SCALAR ARRAY ",
" NULL ", wxEmptyString };
bool first = true;
wxString retstr;
definitionM = getName_() + "(" + wxTextBuffer::GetEOL();
paramListM = wxEmptyString;
DatabasePtr db = getDatabase();
MetadataLoader* loader = db->getMetadataLoader();
wxMBConv* converter = db->getCharsetConverter();
MetadataLoaderTransaction tr(loader);
IBPP::Statement& st1 = loader->getStatement(
"SELECT f.RDB$RETURN_ARGUMENT, a.RDB$MECHANISM,"
" a.RDB$ARGUMENT_POSITION, a.RDB$FIELD_TYPE, a.RDB$FIELD_SCALE,"
" a.RDB$FIELD_LENGTH, a.RDB$FIELD_SUB_TYPE, a.RDB$FIELD_PRECISION,"
" f.RDB$MODULE_NAME, f.RDB$ENTRYPOINT, c.RDB$CHARACTER_SET_NAME "
" FROM RDB$FUNCTIONS f"
" LEFT OUTER JOIN RDB$FUNCTION_ARGUMENTS a"
" ON f.RDB$FUNCTION_NAME = a.RDB$FUNCTION_NAME"
" LEFT OUTER JOIN RDB$CHARACTER_SETS c"
" ON a.RDB$CHARACTER_SET_ID = c.RDB$CHARACTER_SET_ID"
" WHERE f.RDB$FUNCTION_NAME = ? "
" ORDER BY a.RDB$ARGUMENT_POSITION"
);
st1->Set(1, wx2std(getName_(), converter));
st1->Execute();
while (st1->Fetch())
{
short returnarg, mechanism, type, scale, length, subtype, precision,
retpos;
std::string libraryName, entryPoint, charset;
st1->Get(1, returnarg);
st1->Get(2, mechanism);
st1->Get(3, retpos);
st1->Get(4, type);
st1->Get(5, scale);
st1->Get(6, length);
st1->Get(7, subtype);
st1->Get(8, precision);
st1->Get(9, libraryName);
libraryNameM = wxString(libraryName.c_str(), *converter).Strip();
st1->Get(10, entryPoint);
entryPointM = wxString(entryPoint.c_str(), *converter).Strip();
wxString datatype = Domain::dataTypeToString(type, scale,
precision, subtype, length);
if (!st1->IsNull(11))
{
st1->Get(11, charset);
wxString chset = wxString(charset.c_str(), *converter).Strip();
if (db->getDatabaseCharset() != chset)
{
datatype += " " + SqlTokenizer::getKeyword(kwCHARACTER)
+ " " + SqlTokenizer::getKeyword(kwSET)
+ " " + chset;
}
}
if (type == 261) // avoid subtype information for BLOB
datatype = SqlTokenizer::getKeyword(kwBLOB);
int mechIndex = (mechanism < 0 ? -mechanism : mechanism);
if (mechIndex >= (sizeof(mechanismNames)/sizeof(wxString)))
mechIndex = (sizeof(mechanismNames)/sizeof(wxString)) - 1;
wxString param = " " + datatype + " "
+ SqlTokenizer::getKeyword(kwBY) + " "
+ mechanismNames[mechIndex];
if (mechanism < 0)
param += wxString(" ") + SqlTokenizer::getKeyword(kwFREE_IT);
if (returnarg == retpos) // output
{
retstr = param;
retstrM = datatype + mechanismDDL[mechIndex];
if (retpos != 0)
{
retstrM = SqlTokenizer::getKeyword(kwPARAMETER) + " ";
retstrM << retpos;
if (!paramListM.IsEmpty())
paramListM += ", ";
paramListM += datatype + mechanismDDL[mechIndex];
}
}
else
{
if (first)
first = false;
else
definitionM += wxString(",") + wxTextBuffer::GetEOL();
definitionM += param;
if (!paramListM.empty())
paramListM += ", ";
paramListM += datatype + mechanismDDL[mechIndex];
}
}
definitionM += wxString(wxTextBuffer::GetEOL()) + ")"
+ wxTextBuffer::GetEOL() + SqlTokenizer::getKeyword(kwRETURNS)
+ ":" + wxTextBuffer::GetEOL() + retstr;
setPropertiesLoaded(true);
}
//! reads indices from database
void Table::loadIndices()
{
if (indicesLoadedM)
return;
indicesM.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 i.rdb$index_name, i.rdb$unique_flag, i.rdb$index_inactive, "
" i.rdb$index_type, i.rdb$statistics, "
" s.rdb$field_name, rc.rdb$constraint_name, i.rdb$expression_source "
" from rdb$indices i "
" left join rdb$index_segments s on i.rdb$index_name = s.rdb$index_name "
" left join rdb$relation_constraints rc "
" on rc.rdb$index_name = i.rdb$index_name "
" where i.rdb$relation_name = ? "
" order by i.rdb$index_name, s.rdb$field_position "
);
st1->Set(1, wx2std(getName_(), conv));
st1->Execute();
Index* i = 0;
while (st1->Fetch())
{
std::string s;
st1->Get(1, s);
wxString ixname(std2wxIdentifier(s, conv));
short unq, inactive, type;
if (st1->IsNull(2)) // null = non-unique
unq = 0;
else
st1->Get(2, unq);
if (st1->IsNull(3)) // null = active
inactive = 0;
else
st1->Get(3, inactive);
if (st1->IsNull(4)) // null = ascending
type = 0;
else
st1->Get(4, type);
double statistics;
if (st1->IsNull(5)) // this can happen, see bug #1825725
statistics = -1;
else
st1->Get(5, statistics);
st1->Get(6, s);
wxString fname(std2wxIdentifier(s, conv));
wxString expression;
readBlob(st1, 8, expression, conv);
if (i && i->getName_() == ixname)
i->getSegments()->push_back(fname);
else
{
Index x(
unq == 1,
inactive == 0,
type == 0,
statistics,
!st1->IsNull(7),
expression
);
indicesM.push_back(x);
i = &indicesM.back();
i->setName_(ixname);
i->getSegments()->push_back(fname);
i->setParent(this);
}
}
indicesLoadedM = true;
}
//! reads foreign keys info from database
void Table::loadForeignKeys()
{
if (foreignKeysLoadedM)
return;
foreignKeysM.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, c.rdb$update_rule, "
" c.rdb$delete_rule, c.RDB$CONST_NAME_UQ, r.rdb$index_name "
"from rdb$relation_constraints r, rdb$index_segments i, rdb$ref_constraints c "
"where r.rdb$relation_name=? and r.rdb$index_name=i.rdb$index_name "
"and r.rdb$constraint_name = c.rdb$constraint_name "
"and (r.rdb$constraint_type='FOREIGN KEY') order by 1, i.rdb$field_position"
);
IBPP::Statement& st2 = loader->getStatement(
"select r.rdb$relation_name, i.rdb$field_name"
" from rdb$relation_constraints r"
" join rdb$index_segments i on i.rdb$index_name = r.rdb$index_name "
" where r.rdb$constraint_name = ?"
" order by i.rdb$field_position "
);
st1->Set(1, wx2std(getName_(), conv));
st1->Execute();
ForeignKey *fkp = 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 update_rule(std2wxIdentifier(s, conv));
st1->Get(4, s);
wxString delete_rule(std2wxIdentifier(s, conv));
std::string ref_constraint;
st1->Get(5, ref_constraint);
st1->Get(6, s);
wxString ixname(std2wxIdentifier(s, conv));
if (fkp && fkp->getName_() == cname) // add column
fkp->columnsM.push_back(fname);
else
{
ForeignKey fk;
foreignKeysM.push_back(fk);
fkp = &foreignKeysM.back();
fkp->setName_(cname);
fkp->setParent(this);
fkp->updateActionM = update_rule;
fkp->deleteActionM = delete_rule;
fkp->indexNameM = ixname;
st2->Set(1, ref_constraint);
st2->Execute();
std::string rtable;
while (st2->Fetch())
{
st2->Get(1, rtable);
st2->Get(2, s);
fkp->referencedColumnsM.push_back(std2wxIdentifier(s, conv));
}
fkp->referencedTableM = std2wxIdentifier(rtable, conv);
fkp->columnsM.push_back(fname);
}
}
foreignKeysLoadedM = true;
}
