bool Connection::table_exists( const string &table_name ) {
AttributeList parameters;
parameters.push_back( table_name );
RowSet rows = select_all( "SELECT name FROM sqlite_master WHERE type='table' AND name = ?;",
parameters );
return ( rows.size() ? true : false );
}
TableSet TableSet::schema( Connection * connection ) {
TableSet s;
RowSet rows = connection->select_all( "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;" );
for( RowSet::iterator it = rows.begin(); it != rows.end(); ++it ) {
string table = it->get_text( "name" );
s[ table ] = table_data( connection, table );
}
return s;
}
RowSet Connection::select_all( const string &query,
const AttributeList ¶meters ) {
sqlite3_stmt *ppStmt = prepare( query, parameters );
RowSet results;
while( sqlite3_step( ppStmt ) == SQLITE_ROW ) {
results.push_back( Row( ppStmt ) );
}
sqlite3_finalize( ppStmt );
return results;
}
string table_definition( Connection &connection, const string &table_name ) {
stringstream query;
query << "SELECT sql FROM sqlite_master ";
query << "WHERE type='table'";
query << "AND name='" << table_name << "'";
RowSet rows = connection.select_all( query.str() );
if( rows.size() == 0 )
return "";
return rows.front().get_text( "sql" );
}
int DBUtil::Query(RowSet& rset, const char* sql, ...)
{
SQL_INST* sqlinst = (SQL_INST*)dbHandle_;
if(sqlinst == 0) {
radlog(L_CONS|L_ERROR, "[DBUtil::Query] invalid instance");
return -1;
}
char sqlbuf[4096];
va_list args;
va_start(args, sql);
vsNprintf(sqlbuf, sizeof(sqlbuf), sql, args);
va_end(args);
SQLSOCK* sqlsock = sql_get_socket(sqlinst);
if(sqlsock == NULL) {
return -1;
}
if(rlm_sql_select_query(sqlsock, sqlinst, sqlbuf) != 0) {
sql_release_socket(sqlinst, sqlsock);
return -1;
}
int colcnt = rlm_sql_num_fields(sqlsock, sqlinst);
int rownum = 0;
rset.clear();
for(;;) {
if(rlm_sql_fetch_row(sqlsock, sqlinst) != 0) {
rownum = -1;
break;
}
if(sqlsock->row == NULL) {
break;
}
++rownum;
Row row;
for(int i=0; i<colcnt; ++i)
row.push_back(sqlsock->row[i]);
rset.push_back(row);
}
rlm_sql_finish_select_query(sqlsock, sqlinst);
sql_release_socket(sqlinst, sqlsock);
return rownum;
}
string Table::primary_key(Sqlite3Connection *connection,
const string &table_name) {
string row_query = "PRAGMA table_info(\"" + table_name + "\");";
RowSet rows = connection->select_all(row_query);
for(RowSet::iterator it = rows.begin(); it != rows.end(); ++it) {
// cid | name | type | notnull | dflt_value | pk
// 0 | bar | INTEGER | 0 | | 0
Type::Type t = it->get_type("pk");
string tn = type_name[t];
int is_pk = atoi(it->get_text("pk").c_str());
if(is_pk != 0) {
string name = it->get_text("name");
return name;
}
}
return "";
}
Table TableSet::table_data( Connection * connection,
const string &table_name ) {
stringstream row_query;
row_query << "PRAGMA table_info( \"" << table_name << "\" );";
Table td( connection, table_name );
RowSet rows = td.connection()->select_all( row_query.str() );
for( RowSet::iterator it = rows.begin();
it != rows.end();
++it ) {
// cid | name | type | notnull | dflt_value | pk
// 0 | bar | INTEGER | 0 | | 0
string name = it->get_text( "name" );
string type_name = it->get_text( "type" );
ActiveRecord::Type type = ActiveRecord::to_type( type_name );
if( type == ActiveRecord::unknown ) {
stringstream error;
error << "Unknown type: " << type_name;
throw ActiveRecordException( error.str(), __FILE__, __LINE__ );
}
td.fields().push_back( Field( name, type ) );
}
return td;
}
/** Extract the master block from <code>problem</code>.
* The constructor also sets up the solver for the newly created master
* block. The master block can only be extracted if all sub-blocks have
* already been extracted.
* @param problem The problem from which to extract the master.
* @param blocks The sub blocks that have already been extracted.
*/
BendersOpt::Block::Block(Problem const *problem, BlockVector const &blocks)
: env(), number(-1), vars(0), rows(0), cplex(0), cb(0)
{
IloNumVarArray problemVars = problem->getVariables();
IloRangeArray problemRanges = problem->getRows();
IloExpr masterObj(env);
IloNumVarArray masterVars(env);
IloRangeArray masterRows(env);
// Find columns that do not intersect block variables and
// copy them to the master block.
IdxMap idxMap;
RowSet rowSet;
for (IloInt j = 0; j < problemVars.getSize(); ++j) {
IloNumVar x = problemVars[j];
if ( problem->getBlock(x) < 0 ) {
// Column is not in a block. Copy it to the master.
IloNumVar v(env, x.getLB(), x.getUB(), x.getType(), x.getName());
varMap.insert(VarMap::value_type(v, x));
masterObj += problem->getObjCoef(x) * v;
idxMap[x] = masterVars.getSize();
masterVars.add(v);
}
else {
// Column is in a block. Collect all rows that intersect
// this column.
RowSet const &intersected = problem->getIntersectedRows(x);
for (RowSet::const_iterator it = intersected.begin();
it != intersected.end(); ++it)
rowSet.insert(*it);
idxMap[x] = -1;
}
}
// Pick up the rows that we need to copy.
// These are the rows that are only intersected by master variables,
// that is, the rows that are not in any block's rowset.
for (IloInt i = 0; i < problemRanges.getSize(); ++i) {
IloRange r = problemRanges[i];
if ( rowSet.find(r) == rowSet.end() ) {
IloRange masterRow(env, r.getLB(), r.getUB(), r.getName());
IloExpr lhs(env);
for (IloExpr::LinearIterator it = r.getLinearIterator(); it.ok(); ++it)
{
lhs += it.getCoef() * masterVars[idxMap[it.getVar()]];
}
masterRow.setExpr(lhs);
masterRows.add(masterRow);
}
}
// Adjust variable indices in blocks so that reference to variables
// in the original problem become references to variables in the master.
for (BlockVector::const_iterator b = blocks.begin(); b != blocks.end(); ++b) {
for (std::vector<FixData>::iterator it = (*b)->fixed.begin(); it != (*b)->fixed.end(); ++it)
it->col = idxMap[problemVars[it->col]];
}
// Create the eta variables, one for each block.
// See the comments at the top of this file for details about the
// eta variables.
IloInt const firsteta = masterVars.getSize();
for (BlockVector::size_type i = 0; i < blocks.size(); ++i) {
std::stringstream s;
s << "_eta" << i;
IloNumVar eta(env, 0.0, IloInfinity, s.str().c_str());
masterObj += eta;
masterVars.add(eta);
}
// Create model and solver instance
vars = masterVars;
rows = masterRows;
IloModel model(env);
model.add(obj = IloObjective(env, masterObj, problem->getObjSense()));
model.add(vars);
model.add(rows);
cplex = IloCplex(model);
cplex.use(cb = new (env) LazyConstraintCallback(env, this, blocks,
firsteta));
for (IloExpr::LinearIterator it = obj.getLinearIterator(); it.ok(); ++it)
objMap.insert(ObjMap::value_type(it.getVar(), it.getCoef()));
}
/** Extract sub block number <code>n</code> from <code>problem</code>.
* The constructor creates a representation of block number <code>n</code>
* as described in <code>problem</code>.
* The constructor will also connect the newly created block to a remote
* object solver instance.
* @param problem The problem from which the block is to be extracted.
* @param n Index of the block to be extracted.
* @param argc Argument for IloCplex constructor.
* @param argv Argument for IloCplex constructor.
* @param machines List of machines to which to connect. If the code is
* compiled for the TCP/IP transport then the block will
* be connected to <code>machines[n]</code>.
*/
BendersOpt::Block::Block(Problem const *problem, IloInt n, int argc, char const *const *argv,
std::vector<char const *> const &machines)
: env(), number(n), vars(0), rows(0), cplex(0), cb(0)
{
IloNumVarArray problemVars = problem->getVariables();
IloRangeArray problemRanges = problem->getRows();
// Create a map that maps variables in the original model to their
// respective index in problemVars.
std::map<IloNumVar,IloInt,ExtractableLess<IloNumVar> > origIdxMap;
for (IloInt j = 0; j < problemVars.getSize(); ++j)
origIdxMap.insert(std::map<IloNumVar,IloInt,ExtractableLess<IloNumVar> >::value_type(problemVars[j], j));
// Copy non-fixed variables from original problem into primal problem.
IloExpr primalObj(env);
IloNumVarArray primalVars(env);
IloRangeArray primalRows(env);
IdxMap idxMap; // Index of original variable in block's primal model
RowSet rowSet;
for (IloInt j = 0; j < problemVars.getSize(); ++j) {
IloNumVar x = problemVars[j];
if ( problem->getBlock(x) == number ) {
// Create column in block LP with exactly the same data.
if ( x.getType() != IloNumVar::Float ) {
std::stringstream s;
s << "Cannot create non-continuous block variable " << x;
std::cerr << s.str() << std::endl;
throw s.str();
}
IloNumVar v(env, x.getLB(), x.getUB(), x.getType(), x.getName());
// Normalize objective function to 'minimize'
double coef = problem->getObjCoef(x);
if ( problem->getObjSense() != IloObjective::Minimize )
coef *= -1.0;
primalObj += coef * v;
// Record the index that the copied variable has in the
// block model.
idxMap.insert(IdxMap::value_type(x, primalVars.getSize()));
primalVars.add(v);
// Mark the rows that are intersected by this column
// so that we can collect them later.
RowSet const &intersected = problem->getIntersectedRows(x);
for (RowSet::const_iterator it = intersected.begin();
it != intersected.end(); ++it)
rowSet.insert(*it);
}
else
idxMap.insert(IdxMap::value_type(x, -1));
}
// Now copy all rows that intersect block variables.
for (IloInt i = 0; i < problemRanges.getSize(); ++i) {
IloRange r = problemRanges[i];
if ( rowSet.find(r) == rowSet.end() )
continue;
// Create a copy of the row, normalizing it to '<='
double factor = 1.0;
if ( r.getLB() > -IloInfinity )
factor = -1.0;
IloRange primalR(env,
factor < 0 ? -r.getUB() : r.getLB(),
factor < 0 ? -r.getLB() : r.getUB(), r.getName());
IloExpr lhs(env);
for (IloExpr::LinearIterator it = r.getLinearIterator(); it.ok(); ++it)
{
IloNumVar v = it.getVar();
double const val = factor * it.getCoef();
if ( problem->getBlock(v) != number ) {
// This column is not explicitly in this block. This means
// that it is a column that will be fixed by the master.
// We collect all such columns so that we can adjust the
// dual objective function according to concrete fixings.
// Store information about variables in this block that
// will be fixed by master solves.
fixed.push_back(FixData(primalRows.getSize(), origIdxMap[v], -val));
}
else {
// The column is an ordinary in this block. Just copy it.
lhs += primalVars[idxMap[v]] * val;
}
}
primalR.setExpr(lhs);
primalRows.add(primalR);
lhs.end();
}
// Create the dual of the primal model we just created.
// Note that makeDual _always_ returns a 'maximize' objective.
IloObjective objective(env, primalObj, IloObjective::Minimize);
makeDual(objective, primalVars, primalRows,
&obj, &vars, &rows);
objective.end();
primalRows.endElements();
primalRows.end();
primalVars.endElements();
primalVars.end();
primalObj.end();
// Create a model.
IloModel model(env);
model.add(obj);
model.add(vars);
model.add(rows);
for (IloExpr::LinearIterator it = obj.getLinearIterator(); it.ok(); ++it)
objMap.insert(ObjMap::value_type(it.getVar(), it.getCoef()));
// Finally create the IloCplex instance that will solve
// the problems associated with this block.
char const **transargv = new char const *[argc + 3];
for (int i = 0; i < argc; ++i)
transargv[i] = argv[i];
#if defined(USE_MPI)
char extra[128];
sprintf (extra, "-remoterank=%d", static_cast<int>(number + 1));
transargv[argc++] = extra;
(void)machines;
#elif defined(USE_PROCESS)
char extra[128];
sprintf (extra, "-logfile=block%04d.log", static_cast<int>(number));
transargv[argc++] = extra;
(void)machines;
#elif defined(USE_TCPIP)
transargv[argc++] = machines[number];
#endif
cplex = IloCplex(model, TRANSPORT, argc, transargv);
delete[] transargv;
// Suppress output from this block's solver.
cplex.setOut(env.getNullStream());
cplex.setWarning(env.getNullStream());
}
