| /* |
| * Copyright (c) 2004-2005 The Regents of The University of Michigan |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer; |
| * redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution; |
| * neither the name of the copyright holders nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * Authors: Nathan Binkert |
| */ |
| |
| #include <cassert> |
| #include <map> |
| #include <sstream> |
| #include <string> |
| #include <vector> |
| |
| #include "base/misc.hh" |
| #include "base/mysql.hh" |
| #include "base/statistics.hh" |
| #include "base/stats/info.hh" |
| #include "base/stats/mysql.hh" |
| #include "base/stats/mysql_run.hh" |
| #include "base/stats/types.hh" |
| #include "base/str.hh" |
| #include "base/types.hh" |
| #include "base/userinfo.hh" |
| |
| using namespace std; |
| |
| namespace Stats { |
| |
| void |
| MySqlRun::connect(const string &host, const string &user, const string &passwd, |
| const string &db, const string &name, const string &sample, |
| const string &project) |
| { |
| if (connected()) |
| panic("can only get one database connection at this time!"); |
| |
| mysql.connect(host, user, passwd, db); |
| if (mysql.error) |
| panic("could not connect to database server\n%s\n", mysql.error); |
| |
| if (mysql.autocommit(false)) |
| panic("could not set autocommit\n%s\n", mysql.error); |
| |
| remove(name); |
| //cleanup(); |
| setup(name, sample, user, project); |
| } |
| |
| void |
| MySqlRun::setup(const string &name, const string &sample, const string &user, |
| const string &project) |
| { |
| assert(mysql.connected()); |
| |
| stringstream insert; |
| ccprintf(insert, |
| "INSERT INTO " |
| "runs(rn_name,rn_sample,rn_user,rn_project,rn_date,rn_expire)" |
| "values(\"%s\", \"%s\", \"%s\", \"%s\", NOW()," |
| "DATE_ADD(CURDATE(), INTERVAL 31 DAY))", |
| name, sample, user, project); |
| |
| mysql.query(insert); |
| if (mysql.error) |
| panic("could not get a run\n%s\n", mysql.error); |
| |
| run_id = mysql.insert_id(); |
| if (mysql.commit()) |
| panic("could not commit transaction\n%s\n", mysql.error); |
| } |
| |
| void |
| MySqlRun::remove(const string &name) |
| { |
| assert(mysql.connected()); |
| stringstream sql; |
| ccprintf(sql, "DELETE FROM runs WHERE rn_name=\"%s\"", name); |
| mysql.query(sql); |
| if (mysql.error) |
| panic("could not delete run\n%s\n", mysql.error); |
| if (mysql.commit()) |
| panic("could not commit transaction\n%s\n", mysql.error); |
| } |
| |
| void |
| MySqlRun::cleanup() |
| { |
| assert(mysql.connected()); |
| |
| mysql.query("DELETE data " |
| "FROM data " |
| "LEFT JOIN runs ON dt_run=rn_id " |
| "WHERE rn_id IS NULL"); |
| |
| if (mysql.commit()) |
| panic("could not commit transaction\n%s\n", mysql.error); |
| |
| mysql.query("DELETE formula_ref " |
| "FROM formula_ref " |
| "LEFT JOIN runs ON fr_run=rn_id " |
| "WHERE rn_id IS NULL"); |
| |
| if (mysql.commit()) |
| panic("could not commit transaction\n%s\n", mysql.error); |
| |
| mysql.query("DELETE formulas " |
| "FROM formulas " |
| "LEFT JOIN formula_ref ON fm_stat=fr_stat " |
| "WHERE fr_stat IS NULL"); |
| |
| if (mysql.commit()) |
| panic("could not commit transaction\n%s\n", mysql.error); |
| |
| mysql.query("DELETE stats " |
| "FROM stats " |
| "LEFT JOIN data ON st_id=dt_stat " |
| "WHERE dt_stat IS NULL"); |
| |
| if (mysql.commit()) |
| panic("could not commit transaction\n%s\n", mysql.error); |
| |
| mysql.query("DELETE subdata " |
| "FROM subdata " |
| "LEFT JOIN data ON sd_stat=dt_stat " |
| "WHERE dt_stat IS NULL"); |
| |
| if (mysql.commit()) |
| panic("could not commit transaction\n%s\n", mysql.error); |
| |
| mysql.query("DELETE events" |
| "FROM events" |
| "LEFT JOIN runs ON ev_run=rn_id" |
| "WHERE rn_id IS NULL"); |
| |
| if (mysql.commit()) |
| panic("could not commit transaction\n%s\n", mysql.error); |
| |
| mysql.query("DELETE event_names" |
| "FROM event_names" |
| "LEFT JOIN events ON en_id=ev_event" |
| "WHERE ev_event IS NULL"); |
| |
| if (mysql.commit()) |
| panic("could not commit transaction\n%s\n", mysql.error); |
| } |
| |
| void |
| SetupStat::init() |
| { |
| name = ""; |
| descr = ""; |
| type = ""; |
| print = false; |
| prereq = 0; |
| prec = -1; |
| nozero = false; |
| nonan = false; |
| total = false; |
| pdf = false; |
| cdf = false; |
| min = 0; |
| max = 0; |
| bktsize = 0; |
| size = 0; |
| } |
| |
| unsigned |
| SetupStat::setup(MySqlRun *run) |
| { |
| MySQL::Connection &mysql = run->conn(); |
| |
| stringstream insert; |
| ccprintf(insert, |
| "INSERT INTO " |
| "stats(st_name, st_descr, st_type, st_print, st_prereq, " |
| "st_prec, st_nozero, st_nonan, st_total, st_pdf, st_cdf, " |
| "st_min, st_max, st_bktsize, st_size)" |
| "values(\"%s\",\"%s\",\"%s\"," |
| " %d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)", |
| name, descr, type, print, prereq, (int)prec, nozero, nonan, |
| total, pdf, cdf, |
| min, max, bktsize, size); |
| |
| mysql.query(insert); |
| if (!mysql.error) { |
| int id = mysql.insert_id(); |
| if (mysql.commit()) |
| panic("could not commit transaction\n%s\n", mysql.error); |
| return id; |
| } |
| |
| stringstream select; |
| ccprintf(select, "SELECT * FROM stats WHERE st_name=\"%s\"", name); |
| |
| mysql.query(select); |
| MySQL::Result result = mysql.store_result(); |
| if (!result) |
| panic("could not find stat\n%s\n", mysql.error); |
| |
| assert(result.num_fields() == 16); |
| MySQL::Row row = result.fetch_row(); |
| if (!row) |
| panic("could not get stat row\n%s\n", mysql.error); |
| |
| bool tb; |
| int8_t ti8; |
| uint16_t tu16; |
| int64_t ti64; |
| uint64_t tu64; |
| |
| if (name != (char *)row[1]) |
| panic("failed stat check on %s:name. %s != %s\n", |
| name, name, row[1]); |
| |
| if (descr != (char *)row[2]) |
| panic("failed stat check on %s:descr. %s != %s\n", |
| name, descr, row[2]); |
| |
| if (type != (char *)row[3]) |
| panic("failed stat check on %s:type. %s != %s\n", |
| name, type, row[3]); |
| |
| if (!to_number(row[4], tb) || print != tb) |
| panic("failed stat check on %s:print. %d != %d\n", |
| name, print, tb); |
| |
| if (!to_number(row[6], ti8) || prec != ti8) |
| panic("failed stat check on %s:prec. %d != %d\n", |
| name, prec, ti8); |
| |
| if (!to_number(row[7], tb) || nozero != tb) |
| panic("failed stat check on %s:nozero. %d != %d\n", |
| name, nozero, tb); |
| |
| if (!to_number(row[8], tb) || nonan != tb) |
| panic("failed stat check on %s:nonan. %d != %d\n", |
| name, nonan, tb); |
| |
| if (!to_number(row[9], tb) || total != tb) |
| panic("failed stat check on %s:total. %d != %d\n", |
| name, total, tb); |
| |
| if (!to_number(row[10], tb) || pdf != tb) |
| panic("failed stat check on %s:pdf. %d != %d\n", |
| name, pdf, tb); |
| |
| if (!to_number(row[11], tb) || cdf != tb) |
| panic("failed stat check on %s:cdf. %d != %d\n", |
| name, cdf, tb); |
| |
| if (!to_number(row[12], ti64) || min != ti64) |
| panic("failed stat check on %s:min. %d != %d\n", |
| name, min, ti64); |
| |
| if (!to_number(row[13], ti64) || max != ti64) |
| panic("failed stat check on %s:max. %d != %d\n", |
| name, max, ti64); |
| |
| if (!to_number(row[14], tu64) || bktsize != tu64) |
| panic("failed stat check on %s:bktsize. %d != %d\n", |
| name, bktsize, tu64); |
| |
| if (!to_number(row[15], tu16) || size != tu16) |
| panic("failed stat check on %s:size. %d != %d\n", |
| name, size, tu16); |
| |
| to_number(row[5], prereq); |
| uint16_t statid; |
| to_number(row[0], statid); |
| return statid; |
| } |
| |
| InsertData::InsertData(MySqlRun *_run) |
| : run(_run) |
| { |
| query = new char[maxsize + 1]; |
| size = 0; |
| flush(); |
| } |
| |
| InsertData::~InsertData() |
| { |
| delete [] query; |
| } |
| |
| void |
| InsertData::flush() |
| { |
| if (size) { |
| MySQL::Connection &mysql = run->conn(); |
| assert(mysql.connected()); |
| mysql.query(query); |
| if (mysql.error) |
| panic("could not insert data\n%s\n", mysql.error); |
| if (mysql.commit()) |
| panic("could not commit transaction\n%s\n", mysql.error); |
| } |
| |
| query[0] = '\0'; |
| size = 0; |
| first = true; |
| strcpy(query, "INSERT INTO " |
| "data(dt_stat,dt_x,dt_y,dt_run,dt_tick,dt_data) " |
| "values"); |
| size = strlen(query); |
| } |
| |
| void |
| InsertData::insert() |
| { |
| if (size + 1024 > maxsize) |
| flush(); |
| |
| if (!first) { |
| query[size++] = ','; |
| query[size] = '\0'; |
| } |
| |
| first = false; |
| |
| size += sprintf(query + size, "(%u,%d,%d,%u,%llu,\"%f\")", |
| stat, x, y, run->run(), (unsigned long long)tick, |
| data); |
| } |
| |
| InsertEvent::InsertEvent(MySqlRun *_run) |
| : run(_run) |
| { |
| query = new char[maxsize + 1]; |
| size = 0; |
| first = true; |
| flush(); |
| } |
| |
| InsertEvent::~InsertEvent() |
| { |
| flush(); |
| } |
| |
| void |
| InsertEvent::insert(const string &stat) |
| { |
| MySQL::Connection &mysql = run->conn(); |
| assert(mysql.connected()); |
| |
| event_map_t::iterator i = events.find(stat); |
| uint32_t event; |
| if (i == events.end()) { |
| mysql.query( |
| csprintf("SELECT en_id " |
| "from event_names " |
| "where en_name=\"%s\"", |
| stat)); |
| |
| MySQL::Result result = mysql.store_result(); |
| if (!result) |
| panic("could not get a run\n%s\n", mysql.error); |
| |
| assert(result.num_fields() == 1); |
| MySQL::Row row = result.fetch_row(); |
| if (row) { |
| if (!to_number(row[0], event)) |
| panic("invalid event id: %s\n", row[0]); |
| } else { |
| mysql.query( |
| csprintf("INSERT INTO " |
| "event_names(en_name)" |
| "values(\"%s\")", |
| stat)); |
| |
| if (mysql.error) |
| panic("could not get a run\n%s\n", mysql.error); |
| |
| event = mysql.insert_id(); |
| } |
| } else { |
| event = (*i).second; |
| } |
| |
| if (size + 1024 > maxsize) |
| flush(); |
| |
| if (!first) { |
| query[size++] = ','; |
| query[size] = '\0'; |
| } |
| |
| first = false; |
| |
| size += sprintf(query + size, "(%u,%u,%llu)", |
| event, run->run(), (unsigned long long)curTick); |
| } |
| |
| void |
| InsertEvent::flush() |
| { |
| static const char query_header[] = "INSERT INTO " |
| "events(ev_event, ev_run, ev_tick)" |
| "values"; |
| |
| MySQL::Connection &mysql = run->conn(); |
| assert(mysql.connected()); |
| |
| if (size) |
| mysql.query(query); |
| |
| query[0] = '\0'; |
| size = sizeof(query_header); |
| first = true; |
| memcpy(query, query_header, size); |
| } |
| |
| struct InsertSubData |
| { |
| uint16_t stat; |
| int16_t x; |
| int16_t y; |
| string name; |
| string descr; |
| |
| void setup(MySqlRun *run); |
| }; |
| |
| void |
| InsertSubData::setup(MySqlRun *run) |
| { |
| MySQL::Connection &mysql = run->conn(); |
| assert(mysql.connected()); |
| stringstream insert; |
| ccprintf(insert, |
| "INSERT INTO subdata(sd_stat,sd_x,sd_y,sd_name,sd_descr) " |
| "values(%d,%d,%d,\"%s\",\"%s\")", |
| stat, x, y, name, descr); |
| |
| mysql.query(insert); |
| // if (mysql.error) |
| // panic("could not insert subdata\n%s\n", mysql.error); |
| |
| if (mysql.commit()) |
| panic("could not commit transaction\n%s\n", mysql.error); |
| } |
| |
| MySql::MySql() |
| : run(new MySqlRun), newdata(run), newevent(run) |
| {} |
| |
| MySql::~MySql() |
| { |
| delete run; |
| } |
| |
| void |
| MySql::connect(const string &host, const string &user, const string &passwd, |
| const string &db, const string &name, const string &sample, |
| const string &project) |
| { |
| run->connect(host, user, passwd, db, name, sample, project); |
| } |
| |
| bool |
| MySql::connected() const |
| { |
| return run->connected(); |
| } |
| |
| void |
| MySql::configure() |
| { |
| /* |
| * set up all stats! |
| */ |
| MySQL::Connection &mysql = run->conn(); |
| |
| list<Info *>::const_iterator i, end = statsList().end(); |
| for (i = statsList().begin(); i != end; ++i) { |
| (*i)->visit(*this); |
| } |
| |
| for (i = statsList().begin(); i != end; ++i) { |
| Info *info = *i; |
| if (info->prereq) { |
| // update the prerequisite |
| uint16_t stat_id = find(info->id); |
| uint16_t prereq_id = find(info->prereq->id); |
| assert(stat_id && prereq_id); |
| |
| stringstream update; |
| ccprintf(update, "UPDATE stats SET st_prereq=%d WHERE st_id=%d", |
| prereq_id, stat_id); |
| mysql.query(update); |
| if (mysql.error) |
| panic("could not update prereq\n%s\n", mysql.error); |
| |
| if (mysql.commit()) |
| panic("could not commit transaction\n%s\n", mysql.error); |
| } |
| } |
| |
| if (mysql.commit()) |
| panic("could not commit transaction\n%s\n", mysql.error); |
| |
| configured = true; |
| } |
| |
| bool |
| MySql::configure(const Info &info, string type) |
| { |
| stat.init(); |
| stat.name = info.name; |
| stat.descr = info.desc; |
| stat.type = type; |
| stat.print = info.flags & print; |
| stat.prec = info.precision; |
| stat.nozero = info.flags & nozero; |
| stat.nonan = info.flags & nonan; |
| stat.total = info.flags & total; |
| stat.pdf = info.flags & pdf; |
| stat.cdf = info.flags & cdf; |
| |
| return stat.print; |
| } |
| |
| void |
| MySql::configure(const ScalarInfo &info) |
| { |
| if (!configure(info, "SCALAR")) |
| return; |
| |
| insert(info.id, stat.setup(run)); |
| } |
| |
| void |
| MySql::configure(const VectorInfo &info) |
| { |
| if (!configure(info, "VECTOR")) |
| return; |
| |
| uint16_t statid = stat.setup(run); |
| |
| if (!info.subnames.empty()) { |
| InsertSubData subdata; |
| subdata.stat = statid; |
| subdata.y = 0; |
| for (off_type i = 0; i < info.subnames.size(); ++i) { |
| subdata.x = i; |
| subdata.name = info.subnames[i]; |
| subdata.descr = info.subdescs.empty() ? "" : info.subdescs[i]; |
| |
| if (!subdata.name.empty() || !subdata.descr.empty()) |
| subdata.setup(run); |
| } |
| } |
| |
| insert(info.id, statid); |
| } |
| |
| void |
| MySql::configure(const DistInfo &info) |
| { |
| if (!configure(info, "DIST")) |
| return; |
| |
| const DistParams *params = |
| safe_cast<const DistParams *>(info.storageParams); |
| if (params->type == Dist) { |
| stat.size = params->buckets; |
| stat.min = params->min; |
| stat.max = params->max; |
| stat.bktsize = params->bucket_size; |
| } |
| insert(info.id, stat.setup(run)); |
| } |
| |
| void |
| MySql::configure(const VectorDistInfo &info) |
| { |
| if (!configure(info, "VECTORDIST")) |
| return; |
| |
| const DistParams *params = |
| safe_cast<const DistParams *>(info.storageParams); |
| if (params->type == Dist) { |
| stat.size = params->buckets; |
| stat.min = params->min; |
| stat.max = params->max; |
| stat.bktsize = params->bucket_size; |
| } |
| |
| uint16_t statid = stat.setup(run); |
| |
| if (!info.subnames.empty()) { |
| InsertSubData subdata; |
| subdata.stat = statid; |
| subdata.y = 0; |
| for (off_type i = 0; i < info.subnames.size(); ++i) { |
| subdata.x = i; |
| subdata.name = info.subnames[i]; |
| subdata.descr = info.subdescs.empty() ? "" : info.subdescs[i]; |
| if (!subdata.name.empty() || !subdata.descr.empty()) |
| subdata.setup(run); |
| } |
| } |
| |
| insert(info.id, statid); |
| } |
| |
| void |
| MySql::configure(const Vector2dInfo &info) |
| { |
| if (!configure(info, "VECTOR2D")) |
| return; |
| |
| uint16_t statid = stat.setup(run); |
| |
| if (!info.subnames.empty()) { |
| InsertSubData subdata; |
| subdata.stat = statid; |
| subdata.y = -1; |
| for (off_type i = 0; i < info.subnames.size(); ++i) { |
| subdata.x = i; |
| subdata.name = info.subnames[i]; |
| subdata.descr = info.subdescs.empty() ? "" : info.subdescs[i]; |
| if (!subdata.name.empty() || !subdata.descr.empty()) |
| subdata.setup(run); |
| } |
| } |
| |
| if (!info.y_subnames.empty()) { |
| InsertSubData subdata; |
| subdata.stat = statid; |
| subdata.x = -1; |
| subdata.descr = ""; |
| for (off_type i = 0; i < info.y_subnames.size(); ++i) { |
| subdata.y = i; |
| subdata.name = info.y_subnames[i]; |
| if (!subdata.name.empty()) |
| subdata.setup(run); |
| } |
| } |
| |
| insert(info.id, statid); |
| } |
| |
| void |
| MySql::configure(const FormulaInfo &info) |
| { |
| MySQL::Connection &mysql = run->conn(); |
| assert(mysql.connected()); |
| |
| configure(info, "FORMULA"); |
| insert(info.id, stat.setup(run)); |
| |
| uint16_t stat = find(info.id); |
| string formula = info.str(); |
| |
| stringstream insert_formula; |
| ccprintf(insert_formula, |
| "INSERT INTO formulas(fm_stat,fm_formula) values(%d, \"%s\")", |
| stat, formula); |
| |
| mysql.query(insert_formula); |
| // if (mysql.error) |
| // panic("could not insert formula\n%s\n", mysql.error); |
| |
| stringstream insert_ref; |
| ccprintf(insert_ref, |
| "INSERT INTO formula_ref(fr_stat,fr_run) values(%d, %d)", |
| stat, run->run()); |
| |
| mysql.query(insert_ref); |
| // if (mysql.error) |
| // panic("could not insert formula reference\n%s\n", mysql.error); |
| |
| if (mysql.commit()) |
| panic("could not commit transaction\n%s\n", mysql.error); |
| } |
| |
| bool |
| MySql::valid() const |
| { |
| return run->connected(); |
| } |
| |
| void |
| MySql::output() |
| { |
| assert(valid()); |
| |
| if (!configured) |
| configure(); |
| |
| // store sample # |
| newdata.tick = curTick; |
| |
| MySQL::Connection &mysql = run->conn(); |
| |
| list<Info *>::const_iterator i, end = statsList().end(); |
| for (i = statsList().begin(); i != end; ++i) { |
| Info *stat = *i; |
| stat->visit(*this); |
| if (mysql.commit()) |
| panic("could not commit transaction\n%s\n", mysql.error); |
| } |
| |
| newdata.flush(); |
| } |
| |
| void |
| MySql::event(const std::string &event) |
| { |
| newevent.insert(event); |
| } |
| |
| void |
| MySql::output(const ScalarInfo &info) |
| { |
| if (!(info.flags & print)) |
| return; |
| |
| newdata.stat = find(info.id); |
| newdata.x = 0; |
| newdata.y = 0; |
| newdata.data = info.value(); |
| |
| newdata.insert(); |
| } |
| |
| void |
| MySql::output(const VectorInfo &info) |
| { |
| if (!(info.flags & print)) |
| return; |
| |
| newdata.stat = find(info.id); |
| newdata.y = 0; |
| |
| const VCounter &cvec = info.value(); |
| size_type size = info.size(); |
| for (off_type x = 0; x < size; x++) { |
| newdata.x = x; |
| newdata.data = cvec[x]; |
| newdata.insert(); |
| } |
| } |
| |
| void |
| MySql::output(const DistData &data, const DistParams *params) |
| { |
| const int db_sum = -1; |
| const int db_squares = -2; |
| const int db_samples = -3; |
| const int db_min_val = -4; |
| const int db_max_val = -5; |
| const int db_underflow = -6; |
| const int db_overflow = -7; |
| |
| newdata.x = db_sum; |
| newdata.data = data.sum; |
| newdata.insert(); |
| |
| newdata.x = db_squares; |
| newdata.data = data.squares; |
| newdata.insert(); |
| |
| newdata.x = db_samples; |
| newdata.data = data.samples; |
| newdata.insert(); |
| |
| if (data.samples && params->type == Dist) { |
| newdata.x = db_min_val; |
| newdata.data = data.min_val; |
| newdata.insert(); |
| |
| newdata.x = db_max_val; |
| newdata.data = data.max_val; |
| newdata.insert(); |
| |
| newdata.x = db_underflow; |
| newdata.data = data.underflow; |
| newdata.insert(); |
| |
| newdata.x = db_overflow; |
| newdata.data = data.overflow; |
| newdata.insert(); |
| |
| size_type size = data.cvec.size(); |
| for (off_type x = 0; x < size; x++) { |
| newdata.x = x; |
| newdata.data = data.cvec[x]; |
| newdata.insert(); |
| } |
| } |
| } |
| |
| void |
| MySql::output(const DistInfo &info) |
| { |
| if (!(info.flags & print)) |
| return; |
| |
| newdata.stat = find(info.id); |
| newdata.y = 0; |
| output(info.data, safe_cast<const DistParams *>(info.storageParams)); |
| } |
| |
| void |
| MySql::output(const VectorDistInfo &info) |
| { |
| if (!(info.flags & print)) |
| return; |
| |
| newdata.stat = find(info.id); |
| |
| size_type size = info.data.size(); |
| for (off_type y = 0; y < size; ++y) { |
| newdata.y = y; |
| output(info.data[y], |
| safe_cast<const DistParams *>(info.storageParams)); |
| } |
| } |
| |
| void |
| MySql::output(const Vector2dInfo &info) |
| { |
| if (!(info.flags & print)) |
| return; |
| |
| newdata.stat = find(info.id); |
| |
| off_type index = 0; |
| for (off_type x = 0; x < info.x; x++) { |
| newdata.x = x; |
| for (off_type y = 0; y < info.y; y++) { |
| newdata.y = y; |
| newdata.data = info.cvec[index++]; |
| newdata.insert(); |
| } |
| } |
| } |
| |
| void |
| MySql::output(const FormulaInfo &info) |
| { |
| } |
| |
| /* |
| * Implement the visitor |
| */ |
| void |
| MySql::visit(const ScalarInfo &info) |
| { |
| if (!configured) |
| configure(info); |
| else |
| output(info); |
| } |
| |
| void |
| MySql::visit(const VectorInfo &info) |
| { |
| if (!configured) |
| configure(info); |
| else |
| output(info); |
| } |
| |
| void |
| MySql::visit(const DistInfo &info) |
| { |
| return; |
| if (!configured) |
| configure(info); |
| else |
| output(info); |
| } |
| |
| void |
| MySql::visit(const VectorDistInfo &info) |
| { |
| return; |
| if (!configured) |
| configure(info); |
| else |
| output(info); |
| } |
| |
| void |
| MySql::visit(const Vector2dInfo &info) |
| { |
| return; |
| if (!configured) |
| configure(info); |
| else |
| output(info); |
| } |
| |
| void |
| MySql::visit(const FormulaInfo &info) |
| { |
| if (!configured) |
| configure(info); |
| else |
| output(info); |
| } |
| |
| bool |
| initMySQL(string host, string user, string password, string database, |
| string project, string name, string sample) |
| { |
| extern list<Output *> OutputList; |
| static MySql mysql; |
| |
| if (mysql.connected()) |
| return false; |
| |
| mysql.connect(host, user, password, database, name, sample, project); |
| OutputList.push_back(&mysql); |
| |
| return true; |
| } |
| |
| /* end namespace Stats */ } |
