testdb.cpp

LiteSQL is a C++ library that integrates C++ objects tightly to relational database and thus provide

#include "testdb.hpp"
using namespace litesql;
const int Object::KekeType::Joo(1);
const int Object::KekeType::Jee(2);
const int Object::KekeType::Juu(3);
Object::KekeType::KekeType(const std::string& n, const std::string& t, const std::string& tbl, const litesql::FieldType::Values& vals)
         : litesql::FieldType(n,t,tbl,vals) {
}
const int Object::Keke::Joo(1);
const int Object::Keke::Jee(2);
const int Object::Keke::Juu(3);
const std::string Object::type__("Object");
const std::string Object::table__("Object_");
const std::string Object::sequence__("Object_seq");
const litesql::FieldType Object::Id("id_","INTEGER",table__);
const litesql::FieldType Object::Type("type_","TEXT",table__);
const litesql::FieldType Object::Date("date_","INTEGER",table__);
const litesql::FieldType Object::Time("time_","INTEGER",table__);
const litesql::FieldType Object::Datetime("datetime_","INTEGER",table__);
const litesql::FieldType Object::B("b_","INTEGER",table__);
std::vector < std::pair< std::string, std::string > > Object::keke_values;
Object::KekeType Object::Keke("keke_","INTEGER",table__,keke_values);
void Object::initValues() {
    keke_values.clear();
    keke_values.push_back(make_pair("Joo","1"));
    keke_values.push_back(make_pair("Jee","2"));
    keke_values.push_back(make_pair("Juu","3"));
}
void Object::defaults() {
    id = 0;
    b = 0;
    keke = 0;
}
Object::Object(const litesql::Database& db)
     : litesql::Persistent(db), id(Id), type(Type), date(Date), time(Time), datetime(Datetime), b(B), keke(Keke) {
    defaults();
}
Object::Object(const litesql::Database& db, const litesql::Record& rec)
     : litesql::Persistent(db, rec), id(Id), type(Type), date(Date), time(Time), datetime(Datetime), b(B), keke(Keke) {
    defaults();
    size_t size = (rec.size() > 7) ? 7 : rec.size();
    switch(size) {
    case 7: keke = rec[6];
    case 6: b = rec[5];
    case 5: datetime = rec[4];
    case 4: time = rec[3];
    case 3: date = rec[2];
    case 2: type = rec[1];
    case 1: id = rec[0];
    }
}
Object::Object(const Object& obj)
     : litesql::Persistent(obj), id(obj.id), type(obj.type), date(obj.date), time(obj.time), datetime(obj.datetime), b(obj.b), keke(obj.keke) {
}
const Object& Object::operator=(const Object& obj) {
    if (this != &obj) {
        id = obj.id;
        type = obj.type;
        date = obj.date;
        time = obj.time;
        datetime = obj.datetime;
        b = obj.b;
        keke = obj.keke;
    }
    litesql::Persistent::operator=(obj);
    return *this;
}
std::string Object::insert(litesql::Record& tables, litesql::Records& fieldRecs, litesql::Records& valueRecs) {
    tables.push_back(table__);
    litesql::Record fields;
    litesql::Record values;
    fields.push_back(id.name());
    values.push_back(id);
    id.setModified(false);
    fields.push_back(type.name());
    values.push_back(type);
    type.setModified(false);
    fields.push_back(date.name());
    values.push_back(date);
    date.setModified(false);
    fields.push_back(time.name());
    values.push_back(time);
    time.setModified(false);
    fields.push_back(datetime.name());
    values.push_back(datetime);
    datetime.setModified(false);
    fields.push_back(b.name());
    values.push_back(b);
    b.setModified(false);
    fields.push_back(keke.name());
    values.push_back(keke);
    keke.setModified(false);
    fieldRecs.push_back(fields);
    valueRecs.push_back(values);
    return litesql::Persistent::insert(tables, fieldRecs, valueRecs, sequence__);
}
void Object::create() {
    litesql::Record tables;
    litesql::Records fieldRecs;
    litesql::Records valueRecs;
    type = type__;
    std::string newID = insert(tables, fieldRecs, valueRecs);
    if (id == 0)
        id = newID;
}
void Object::addUpdates(Updates& updates) {
    prepareUpdate(updates, table__);
    updateField(updates, table__, id);
    updateField(updates, table__, type);
    updateField(updates, table__, date);
    updateField(updates, table__, time);
    updateField(updates, table__, datetime);
    updateField(updates, table__, b);
    updateField(updates, table__, keke);
}
void Object::addIDUpdates(Updates& updates) {
}
void Object::getFieldTypes(std::vector<litesql::FieldType>& ftypes) {
    ftypes.push_back(Id);
    ftypes.push_back(Type);
    ftypes.push_back(Date);
    ftypes.push_back(Time);
    ftypes.push_back(Datetime);
    ftypes.push_back(B);
    ftypes.push_back(Keke);
}
void Object::delRecord() {
    deleteFromTable(table__, id);
}
void Object::delRelations() {
}
void Object::update() {
    if (!inDatabase) {
        create();
        return;
    }
    Updates updates;
    addUpdates(updates);
    if (id != oldKey) {
        if (!typeIsCorrect()) 
            upcastCopy()->addIDUpdates(updates);
    }
    litesql::Persistent::update(updates);
    oldKey = id;
}
void Object::del() {
    if (typeIsCorrect() == false) {
        std::auto_ptr<Object> p(upcastCopy());
        p->delRelations();
        p->onDelete();
        p->delRecord();
    } else {
        onDelete();
        delRecord();
    }
    inDatabase = false;
}
bool Object::typeIsCorrect() {
    return type == type__;
}
std::auto_ptr<Object> Object::upcast() {
    return auto_ptr<Object>(new Object(*this));
}
std::auto_ptr<Object> Object::upcastCopy() {
    Object* np = NULL;
    np->id = id;
    np->type = type;
    np->date = date;
    np->time = time;
    np->datetime = datetime;
    np->b = b;
    np->keke = keke;
    np->inDatabase = inDatabase;
    if (!np)
        np = new Object(*this);
    return auto_ptr<Object>(np);
}
std::ostream & operator<<(std::ostream& os, Object o) {
    os << "-------------------------------------" << std::endl;
    os << o.id.name() << " = " << o.id << std::endl;
    os << o.type.name() << " = " << o.type << std::endl;
    os << o.date.name() << " = " << o.date << std::endl;
    os << o.time.name() << " = " << o.time << std::endl;
    os << o.datetime.name() << " = " << o.datetime << std::endl;
    os << o.b.name() << " = " << o.b << std::endl;
    os << o.keke.name() << " = " << o.keke << std::endl;
    os << "-------------------------------------" << std::endl;
    return os;
}
TestDB::TestDB(std::string backendType, std::string connInfo)
     : litesql::Database(backendType, connInfo) {
    initialize();
}
std::vector<litesql::Database::SchemaItem> TestDB::getSchema() const {
    vector<Database::SchemaItem> res;
    res.push_back(Database::SchemaItem("schema","table","CREATE TABLE schema (name TEXT, type TEXT, sql TEXT);"));
    res.push_back(Database::SchemaItem(Object::table__,"table","CREATE TABLE " + Object::table__ + " (" + Object::Id.name() + " " + backend->getRowIDType() + "," + Object::Type.name() + " " + Object::Type.type() + "," + Object::Date.name() + " " + Object::Date.type() + "," + Object::Time.name() + " " + Object::Time.type() + "," + Object::Datetime.name() + " " + Object::Datetime.type() + "," + Object::B.name() + " " + Object::B.type() + "," + Object::Keke.name() + " " + Object::Keke.type() + ")"));
    if (backend->supportsSequences())
    res.push_back(Database::SchemaItem(Object::sequence__,"sequence","CREATE SEQUENCE " + Object::sequence__ + " START 1 INCREMENT 1"));
    return res;
}
void TestDB::initialize() {
    static bool initialized = false;
    if (initialized)
        return;
    initialized = true;
    Object::initValues();
}