void Exception::loadProperties(IBPP::Statement& statement, wxMBConv* converter)
{
setPropertiesLoaded(false);
std::string message;
statement->Get(2, message);
messageM = wxString(message.c_str(), *converter);
statement->Get(3, numberM);
if (statement->IsNull(4))
setDescriptionIsEmpty();
setPropertiesLoaded(true);
}
//-----------------------------------------------------------------------------
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();
}
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 MetadataItem::invalidate()
{
setChildrenLoaded(false);
setPropertiesLoaded(false);
notifyObservers();
}
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);
}
void Domain::loadProperties(IBPP::Statement& statement, wxMBConv* converter)
{
setPropertiesLoaded(false);
statement->Get(2, &datatypeM);
if (statement->IsNull(3))
subtypeM = 0;
else
statement->Get(3, &subtypeM);
// determine the (var)char field length
// - system tables use field_len and char_len is null
// - computed columns have field_len/bytes_per_char, char_len is 0
// - view columns have field_len/bytes_per_char, char_len is null
// - regular table columns and SP params have field_len/bytes_per_char
// they also have proper char_len, but we don't use it now
statement->Get(4, &lengthM);
int bpc = 0; // bytes per char
if (!statement->IsNull(14))
statement->Get(14, &bpc);
if (bpc && (!statement->IsNull(8) || !statement->IsNull(13)))
lengthM /= bpc;
if (statement->IsNull(5))
precisionM = 0;
else
statement->Get(5, &precisionM);
if (statement->IsNull(6))
scaleM = 0;
else
statement->Get(6, &scaleM);
if (statement->IsNull(7))
charsetM = "";
else
{
std::string s;
statement->Get(7, s);
charsetM = std2wxIdentifier(s, converter);
}
bool notNull = false;
if (!statement->IsNull(9))
{
statement->Get(9, notNull);
}
nullableM = !notNull;
hasDefaultM = !statement->IsNull(10);
if (hasDefaultM)
{
readBlob(statement, 10, defaultM, converter);
defaultM = trimDefaultValue(defaultM);
}
else
defaultM = wxEmptyString;
if (statement->IsNull(11))
collationM = wxEmptyString;
else
{
std::string s;
statement->Get(11, s);
collationM = std2wxIdentifier(s, converter);
}
readBlob(statement, 12, checkM, converter);
setPropertiesLoaded(true);
}