MySQLPreparedStatement::~MySQLPreparedStatement()
{
// delete all params
clearParameters();
mysql_stmt_close(stmt);
delete[] bind;
}
void
IB_Statement::describeInput (const IB_SSHORT16 suggestedInputCols)
{
// If sqldaIn_ is already allocated, reuse it.
// Otherwise, allocate space for a suggestedInputCols parameter list.
// If more space is needed, allocate more later.
if (!sqldaIn_)
sqldaIn_ = (XSQLDA *) malloc (XSQLDA_LENGTH (suggestedInputCols));
if (!sqldaIn_)
throw new IB_SQLException (IB_SQLException::outOfMemory__,
IB_SQLException::outOfMemoryException__);
sqldaIn_->sqln = suggestedInputCols;
sqldaIn_->version = sqldaVersion__;
dsqlDescribeBind ();
IB_SSHORT16 actualInputCols = sqldaIn_->sqld;
if (actualInputCols > sqldaIn_->sqln) {
sqldaIn_ = (XSQLDA *) realloc (sqldaIn_,
XSQLDA_LENGTH (actualInputCols));
sqldaIn_->version = sqldaVersion__;
sqldaIn_->sqln = actualInputCols;
dsqlDescribeBind ();
}
// Its harmless to delete a NULL pointer.
// !!! future enhancement - make this a realloc
delete inputBuffer_;
inputBuffer_ = new IB_InputBuffer (this);
// !!! do we really need to call clearParameters() here?
clearParameters ();
}
void TFunction::swapParameters(const TFunction ¶metersSource)
{
clearParameters();
for (auto parameter : parametersSource.parameters)
{
addParameter(parameter);
}
}
void Statement::finilize() {
if (!_stmt) {
return;
}
sqlite3_finalize(_stmt);
_stmt = nullptr;
if (!_db.expired()) {
_db.lock()->unregisterStatement(this);
}
clearColumnInfo();
clearParameters();
}
bool CEvaluationNodeCall::compile(const CEvaluationTree * pTree)
{
bool success = true;
clearParameters(mpCallParameters, mCallNodes);
switch (mType & 0x00FFFFFF)
{
case FUNCTION:
mpFunction =
dynamic_cast<CFunction *>(CCopasiRootContainer::getFunctionList()->findFunction(mData));
if (!mpFunction) return false;
// We need to check whether the provided arguments match the on needed by the
// function;
if (!verifyParameters(mCallNodes, mpFunction->getVariables())) return false;
mpCallParameters = buildParameters(mCallNodes);
break;
case EXPRESSION:
mpExpression =
dynamic_cast<CExpression *>(CCopasiRootContainer::getFunctionList()->findFunction(mData));
if (!mpExpression)
{
// We may have a function with no arguments the parser is not able to distinguish
// between that and an expression.
mpFunction =
dynamic_cast<CFunction *>(CCopasiRootContainer::getFunctionList()->findFunction(mData));
if (!mpFunction) return false;
mType = (CEvaluationNode::Type)(CEvaluationNode::CALL | FUNCTION);
success = compile(pTree);
}
else
{
success = mpExpression->compile(static_cast<const CExpression *>(pTree)->getListOfContainer());
}
break;
default:
success = false;
break;
}
return success;
}
MultiAgentEnvironment::~MultiAgentEnvironment()
{
saveParameters();
if (m_Layout)
{
clearParameters();
delete m_LayoutStatistics;
delete m_GroupBoxGeneralParameters;
m_PcMAE.free();
delete m_GroupBoxSpecificParameters;
delete m_GroupBoxDisturbanceParameters;
delete m_Layout;
}
}
void Statement::initParameters() {
if (!_stmt) {
return;
}
clearParameters();
_parametersCount = sqlite3_bind_parameter_count(_stmt);
if (_parametersCount <= 0) {
return;
}
for (int i = 1; i <= _parametersCount; ++i) {
const char *name = sqlite3_bind_parameter_name(_stmt, i);
if (name && name[0]) {
_nameParameters[name] = i;
}
}
}
void processParameters(char *parameterString)
{
clearParameters();
if (NULL != parameterString && strlen(parameterString))
{
uint8_t i = 0;
const char delimiter[] = " ";
char *token;
// break up remaining strings into parameters
token = strtok(parameterString, delimiter);
while (NULL != token)
{
// copy parameters into the global parameter variables
strcpy(gParameters[i++], token);
token = strtok(NULL, delimiter);
}
}
}
Result Statement::prepare() {
if (_stmt) {
return Result::success();
}
clearParameters();
if (_db.expired()) {
return Result::error();
}
auto ptr = _db.lock();
sqlite3 *db = ptr->db();
Result ret(sqlite3_prepare_v2(db, _command.c_str(), static_cast<int>(_command.size() + 1), &_stmt, nullptr), _db);
if (ret) {
ptr->registerStatement(this);
initParameters();
}
return ret;
}
void
CEvaluationNodeCall::clearParameters(CCallParameters< C_FLOAT64 > * pCallParameters,
const std::vector<CEvaluationNode *> & vector)
{
if (!pCallParameters) return;
std::vector<CEvaluationNode *>::const_iterator it = vector.begin();
std::vector<CEvaluationNode *>::const_iterator end = vector.end();
size_t i;
for (i = 0; it != end; ++it, i++)
{
if ((*it)->mainType() == CEvaluationNode::T_VECTOR)
clearParameters((*pCallParameters)[i].vector,
static_cast<const CEvaluationNodeVector *>(*it)->getNodes());
}
delete pCallParameters;
return;
}
//
// Functions have buried pointers to delete.
//
TFunction::~TFunction()
{
clearParameters();
}
ClientStub::~ClientStub()
{
disconnect();
clearParameters();
}
OptimizableGraph::~OptimizableGraph()
{
clear();
clearParameters();
}
bool CEvaluationNodeCall::compile(const CEvaluationTree * pTree)
{
bool success = true;
clearParameters(mpCallParameters, mCallNodes);
CObjectInterface * pObjectInterface = NULL;
if (mRegisteredFunctionCN != "")
{
pObjectInterface = const_cast< CObjectInterface * >(CCopasiRootContainer::getRoot()->getObject(mRegisteredFunctionCN));
}
switch (mSubType)
{
case S_FUNCTION:
if (pObjectInterface != NULL)
{
mpFunction = dynamic_cast< CFunction * >(pObjectInterface);
}
else
{
mpFunction =
dynamic_cast<CFunction *>(CCopasiRootContainer::getFunctionList()->findFunction(mData));
}
if (!mpFunction) return false;
mRegisteredFunctionCN = mpFunction->getCN();
// We need to check whether the provided arguments match the on needed by the
// function;
if (!verifyParameters(mCallNodes, mpFunction->getVariables())) return false;
mpCallParameters = buildParameters(mCallNodes);
break;
case S_EXPRESSION:
if (pObjectInterface != NULL)
{
mpExpression = dynamic_cast<CExpression *>(pObjectInterface);
}
else
{
mpExpression =
dynamic_cast<CExpression *>(CCopasiRootContainer::getFunctionList()->findFunction(mData));
}
if (!mpExpression)
{
// We may have a function with no arguments the parser is not able to distinguish
// between that and an expression.
if (pObjectInterface != NULL)
{
mpFunction = dynamic_cast< CFunction * >(pObjectInterface);
}
else
{
mpFunction =
dynamic_cast<CFunction *>(CCopasiRootContainer::getFunctionList()->findFunction(mData));
}
if (!mpFunction) return false;
mRegisteredFunctionCN = mpFunction->getCN();
mMainType = T_CALL;
mSubType = S_FUNCTION;
success = compile(pTree);
}
else
{
mRegisteredFunctionCN = mpExpression->getCN();
success = mpExpression->compile(static_cast<const CExpression *>(pTree)->getListOfContainer());
}
break;
default:
success = false;
break;
}
return success;
}