persistent.hpp

Go to the documentation of this file.

/* LiteSQL 
 * 
 * The list of contributors at http://litesql.sf.net/ 
 * 
 * See LICENSE for copyright information. */
 
#ifndef litesql_persistent_hpp
#define litesql_persistent_hpp
 
#include <memory>
#include <string>
#include <vector>
#include <functional>
#include <map>
#include "litesql/utils.hpp"
#include "litesql/database.hpp"
#include "litesql/cursor.hpp"
#include "litesql/expr.hpp"
#include "litesql/selectquery.hpp"
#include "litesql/relation.hpp"
#include "litesql/operations.hpp"

 
namespace litesql {

class Persistent {
protected:
    typedef std::map<std::string, std::vector<pair<FieldType, std::string> > > Updates;    
    std::string insert(Record& tables, 
                  Records& fieldRecs,
                  Records& values,
                  const std::string& sequence);
    void update(const Updates& updates); 
    template <class T>
    void updateField(litesql::Persistent::Updates& updates, 
                     const std::string& table, 
                     litesql::Field<T> fld) {
        if (fld.modified()) {
            updates[table].push_back(make_pair(fld.fieldType(), 
                       litesql::convert<const T&, std::string>(fld.value())));
            fld.setModified(false);
        }
    }
    void prepareUpdate(Updates& updates, const std::string& table);
    void deleteFromTable(const std::string& table, const std::string& id);
    const Database *db;
    bool inDatabase;
    int oldKey;
public:
    const Database & getDatabase() const {
        return *db;
    }

    bool isInDatabase() const {
        return inDatabase;
    }

    const Persistent & operator=(const Persistent & p);
    Persistent(const Persistent & p) 
        : db(p.db), inDatabase(p.inDatabase), oldKey(p.oldKey) {}
    Persistent(const Database & _db, const Record & row) 
        : db(&_db), inDatabase(true), oldKey(0) {
        if (row.size() > 0)
            oldKey = atoi(row[0]);
    }
    Persistent(const Database & _db) 
        : db(&_db), inDatabase(false), oldKey(0) {}
    virtual void onDelete() {}
    virtual ~Persistent() {}
    static Split getTablesFromFieldTypes(const std::vector<FieldType> & fdatas);

//    virtual void getTables(Split & tables) const =0 ;
};
 
}
#endif