Implementation Details
Index
Code Generator litesql-gen
LiteSQL uses XML database definition file which is used to generate Persistent and Relation classes.
litesql-gen is the code generator written in C++ that generates code from database definition file.
Small help:
./litesql-gen --help
Usage: litesql-gen [options] <my-database.xml>
Options:
-t, --target=TARGET generate code for TARGET (default: c++)
-v, --verbose verbosely report code generation
--help print help
--output-dir=/path/to/src output all files to directory
--output-sources=/path/to/src output sources to directory
(only with target c++)
--output-include=/path/to/include output includes to directory
(only with target c++)
Supported targets:
'c++' C++ target (.cpp,.hpp)
'graphviz' Graphviz file (.dot)
'ruby-activerecord' experimental ruby support, generates migration and activeRecord classes
The example database definition file (exampledatabase.xml) page will result in two files (exampledatabase.hpp and testdatabase.cpp) when fed to code generator.
<?xml version="1.0"?>
<!DOCTYPE database SYSTEM "litesql.dtd">
<database name="ExampleDatabase" namespace="example">
<include name="auth.xml" />
<object name="Person">
<field name="name" type="string"/>
<field name="age" type="integer" default="15"/>
<field name="image" type="blob"/>
<field name="aDoubleValue" type="double"/>
<field name="sex" type="integer">
<value name="Male" value="0"/>
<value name="Female" value="1"/>
</field>
<method name="sayHello"/>
<index unique="true">
<indexfield name="name"/>
<indexfield name="age"/>
</index>
</object>
<relation id="Mother" unidir="true">
<relate object="Person" limit="many" handle="mother"/>
<relate object="Person" limit="one"/>
</relation>
<relation id="Father" unidir="true">
<relate object="Person" limit="many" handle="father"/>
<relate object="Person" limit="one"/>
</relation>
<relation id="Siblings">
<relate object="Person" handle="siblings"/>
<relate object="Person"/>
</relation>
<relation id="Children" unidir="true">
<relate object="Person" handle="children"/>
<relate object="Person"/>
</relation>
<object name="Role"/>
<object name="Student" inherits="Role"/>
<object name="Employee" inherits="Role"/>
<relation id="Roles" name="RoleRelation">
<relate object="Person" handle="roles" limit="one"/>
<relate object="Role" handle="person"/>
</relation>
<object name="School">
<field name="name" type="string"/>
</object>
<relation>
<relate object="Student" handle="school"/>
<relate object="School" handle="students" limit="one"/>
</relation>
<object name="Office"/>
<relation>
<relate object="Employee" handle="office"/>
<relate object="Office" handle="employees"/>
</relation>
<object name="ThingWithMethods">
<method name="sayHello">
<param type="std::string" name="text" />
<param type="int" name="repeat" />
</method>
</object>
</database>
exampledatabase.hpp contains class declarations for persistent objects and relations
#ifndef exampledatabase_hpp
#define exampledatabase_hpp
#include "litesql.hpp"
namespace example {
class user;
class Person;
class Role;
class Student;
class Employee;
class School;
class Office;
class ThingWithMethods;
class PersonPersonRelationMother {
public:
class Row {
public:
litesql::Field<int> person2;
litesql::Field<int> person1;
};
static const std::string table__;
static void link(const litesql::Database& db, const example::Person& o0, const example::Person& o1);
static void unlink(const litesql::Database& db, const example::Person& o0, const example::Person& o1);
static litesql::DataSource<PersonPersonRelationMother::Row> getRows(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr());
static litesql::DataSource<example::Person> getPerson1(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
static litesql::DataSource<example::Person> getPerson2(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
};
class PersonPersonRelationFather {
public:
class Row {
public:
litesql::Field<int> person2;
litesql::Field<int> person1;
Row(const litesql::Database& db, const litesql::Record& rec=litesql::Record());
};
static const std::string table__;
static const litesql::FieldType Person1;
static const litesql::FieldType Person2;
static void link(const litesql::Database& db, const example::Person& o0, const example::Person& o1);
static void unlink(const litesql::Database& db, const example::Person& o0, const example::Person& o1);
static void del(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr());
static litesql::DataSource<PersonPersonRelationFather::Row> getRows(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr());
static litesql::DataSource<example::Person> getPerson1(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
static litesql::DataSource<example::Person> getPerson2(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
};
class PersonPersonRelationSiblings {
public:
class Row {
public:
litesql::Field<int> person2;
litesql::Field<int> person1;
Row(const litesql::Database& db, const litesql::Record& rec=litesql::Record());
};
static const std::string table__;
static const litesql::FieldType Person1;
static const litesql::FieldType Person2;
static void link(const litesql::Database& db, const example::Person& o0, const example::Person& o1);
static void unlink(const litesql::Database& db, const example::Person& o0, const example::Person& o1);
static void del(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr());
static litesql::DataSource<PersonPersonRelationSiblings::Row> getRows(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr());
static litesql::DataSource<example::Person> getPerson1(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
static litesql::DataSource<example::Person> getPerson2(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
};
class PersonPersonRelationChildren {
public:
class Row {
public:
litesql::Field<int> person2;
litesql::Field<int> person1;
Row(const litesql::Database& db, const litesql::Record& rec=litesql::Record());
};
static const std::string table__;
static const litesql::FieldType Person1;
static const litesql::FieldType Person2;
static void link(const litesql::Database& db, const example::Person& o0, const example::Person& o1);
static void unlink(const litesql::Database& db, const example::Person& o0, const example::Person& o1);
static void del(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr());
static litesql::DataSource<PersonPersonRelationChildren::Row> getRows(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr());
static litesql::DataSource<example::Person> getPerson1(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
static litesql::DataSource<example::Person> getPerson2(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
};
class RoleRelation {
public:
class Row {
public:
litesql::Field<int> role;
litesql::Field<int> person;
Row(const litesql::Database& db, const litesql::Record& rec=litesql::Record());
};
static const std::string table__;
static const litesql::FieldType Person;
static const litesql::FieldType Role;
static void link(const litesql::Database& db, const example::Person& o0, const example::Role& o1);
static void unlink(const litesql::Database& db, const example::Person& o0, const example::Role& o1);
static void del(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr());
static litesql::DataSource<RoleRelation::Row> getRows(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr());
template <class T> static litesql::DataSource<T> get(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
;
;
};
class SchoolStudentRelation {
public:
class Row {
public:
litesql::Field<int> student;
litesql::Field<int> school;
Row(const litesql::Database& db, const litesql::Record& rec=litesql::Record());
};
static const std::string table__;
static const litesql::FieldType School;
static const litesql::FieldType Student;
static void link(const litesql::Database& db, const example::School& o0, const example::Student& o1);
static void unlink(const litesql::Database& db, const example::School& o0, const example::Student& o1);
static void del(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr());
static litesql::DataSource<SchoolStudentRelation::Row> getRows(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr());
template <class T> static litesql::DataSource<T> get(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
;
;
};
class EmployeeOfficeRelation {
public:
class Row {
public:
litesql::Field<int> office;
litesql::Field<int> employee;
Row(const litesql::Database& db, const litesql::Record& rec=litesql::Record());
};
static const std::string table__;
static const litesql::FieldType Employee;
static const litesql::FieldType Office;
static void link(const litesql::Database& db, const example::Employee& o0, const example::Office& o1);
static void unlink(const litesql::Database& db, const example::Employee& o0, const example::Office& o1);
static void del(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr());
static litesql::DataSource<EmployeeOfficeRelation::Row> getRows(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr());
template <class T> static litesql::DataSource<T> get(const litesql::Database& db, const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
;
;
};
class user : public litesql::Persistent {
public:
class Own {
public:
static const litesql::FieldType Id;
};
static const std::string type__;
static const std::string table__;
static const std::string sequence__;
static const litesql::FieldType Id;
litesql::Field<int> id;
static const litesql::FieldType Type;
litesql::Field<std::string> type;
static const litesql::FieldType Name;
litesql::Field<std::string> name;
static const litesql::FieldType Passwd;
litesql::Field<std::string> passwd;
protected:
void defaults();
public:
user(const litesql::Database& db);
user(const litesql::Database& db, const litesql::Record& rec);
user(const user& obj);
const user& operator=(const user& obj);
virtual void sayHello();
protected:
std::string insert(litesql::Record& tables, litesql::Records& fieldRecs, litesql::Records& valueRecs);
void create();
virtual void addUpdates(Updates& updates);
virtual void addIDUpdates(Updates& updates);
public:
static void getFieldTypes(std::vector<litesql::FieldType>& ftypes);
protected:
virtual void delRecord();
virtual void delRelations();
public:
virtual void update();
virtual void del();
virtual bool typeIsCorrect();
std::auto_ptr<user> upcast();
std::auto_ptr<user> upcastCopy();
};
std::ostream & operator<<(std::ostream& os, user o);
class Person : public litesql::Persistent {
public:
class Own {
public:
static const litesql::FieldType Id;
};
class SexType : public litesql::FieldType {
public:
static const int Male;
static const int Female;
SexType(const std::string& n, const std::string& t, const std::string& tbl, const litesql::FieldType::Values& vals=Values());
};
class Sex {
public:
static const int Male;
static const int Female;
};
class MotherHandle : public litesql::RelationHandle<Person> {
public:
MotherHandle(const Person& owner);
void link(const Person& o0);
void unlink(const Person& o0);
void del(const litesql::Expr& expr=litesql::Expr());
litesql::DataSource<Person> get(const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
litesql::DataSource<PersonPersonRelationMother::Row> getRows(const litesql::Expr& expr=litesql::Expr());
};
class FatherHandle : public litesql::RelationHandle<Person> {
public:
FatherHandle(const Person& owner);
void link(const Person& o0);
void unlink(const Person& o0);
void del(const litesql::Expr& expr=litesql::Expr());
litesql::DataSource<Person> get(const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
litesql::DataSource<PersonPersonRelationFather::Row> getRows(const litesql::Expr& expr=litesql::Expr());
};
class SiblingsHandle : public litesql::RelationHandle<Person> {
public:
SiblingsHandle(const Person& owner);
void link(const Person& o0);
void unlink(const Person& o0);
void del(const litesql::Expr& expr=litesql::Expr());
litesql::DataSource<Person> get(const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
litesql::DataSource<PersonPersonRelationSiblings::Row> getRows(const litesql::Expr& expr=litesql::Expr());
};
class ChildrenHandle : public litesql::RelationHandle<Person> {
public:
ChildrenHandle(const Person& owner);
void link(const Person& o0);
void unlink(const Person& o0);
void del(const litesql::Expr& expr=litesql::Expr());
litesql::DataSource<Person> get(const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
litesql::DataSource<PersonPersonRelationChildren::Row> getRows(const litesql::Expr& expr=litesql::Expr());
};
class RolesHandle : public litesql::RelationHandle<Person> {
public:
RolesHandle(const Person& owner);
void link(const Role& o0);
void unlink(const Role& o0);
void del(const litesql::Expr& expr=litesql::Expr());
litesql::DataSource<Role> get(const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
litesql::DataSource<RoleRelation::Row> getRows(const litesql::Expr& expr=litesql::Expr());
};
static const std::string type__;
static const std::string table__;
static const std::string sequence__;
static const litesql::FieldType Id;
litesql::Field<int> id;
static const litesql::FieldType Type;
litesql::Field<std::string> type;
static const litesql::FieldType Name;
litesql::Field<std::string> name;
static const litesql::FieldType Age;
litesql::Field<int> age;
static const litesql::FieldType Image;
litesql::Field<litesql::Blob> image;
static const litesql::FieldType ADoubleValue;
litesql::Field<double> aDoubleValue;
protected:
static std::vector < std::pair< std::string, std::string > > sex_values;
public:
static const Person::SexType Sex;
litesql::Field<int> sex;
static void initValues();
protected:
void defaults();
public:
Person(const litesql::Database& db);
Person(const litesql::Database& db, const litesql::Record& rec);
Person(const Person& obj);
const Person& operator=(const Person& obj);
Person::MotherHandle mother();
Person::FatherHandle father();
Person::SiblingsHandle siblings();
Person::ChildrenHandle children();
Person::RolesHandle roles();
virtual void sayHello();
protected:
std::string insert(litesql::Record& tables, litesql::Records& fieldRecs, litesql::Records& valueRecs);
void create();
virtual void addUpdates(Updates& updates);
virtual void addIDUpdates(Updates& updates);
public:
static void getFieldTypes(std::vector<litesql::FieldType>& ftypes);
protected:
virtual void delRecord();
virtual void delRelations();
public:
virtual void update();
virtual void del();
virtual bool typeIsCorrect();
std::auto_ptr<Person> upcast();
std::auto_ptr<Person> upcastCopy();
};
std::ostream & operator<<(std::ostream& os, Person o);
class Role : public litesql::Persistent {
public:
class Own {
public:
static const litesql::FieldType Id;
};
class PersonHandle : public litesql::RelationHandle<Role> {
public:
PersonHandle(const Role& owner);
void link(const Person& o0);
void unlink(const Person& o0);
void del(const litesql::Expr& expr=litesql::Expr());
litesql::DataSource<Person> get(const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
litesql::DataSource<RoleRelation::Row> getRows(const litesql::Expr& expr=litesql::Expr());
};
static const std::string type__;
static const std::string table__;
static const std::string sequence__;
static const litesql::FieldType Id;
litesql::Field<int> id;
static const litesql::FieldType Type;
litesql::Field<std::string> type;
protected:
void defaults();
public:
Role(const litesql::Database& db);
Role(const litesql::Database& db, const litesql::Record& rec);
Role(const Role& obj);
const Role& operator=(const Role& obj);
Role::PersonHandle person();
protected:
std::string insert(litesql::Record& tables, litesql::Records& fieldRecs, litesql::Records& valueRecs);
void create();
virtual void addUpdates(Updates& updates);
virtual void addIDUpdates(Updates& updates);
public:
static void getFieldTypes(std::vector<litesql::FieldType>& ftypes);
protected:
virtual void delRecord();
virtual void delRelations();
public:
virtual void update();
virtual void del();
virtual bool typeIsCorrect();
std::auto_ptr<Role> upcast();
std::auto_ptr<Role> upcastCopy();
};
std::ostream & operator<<(std::ostream& os, Role o);
class Student : public Role {
public:
class Own {
public:
static const litesql::FieldType Id;
};
class SchoolHandle : public litesql::RelationHandle<Student> {
public:
SchoolHandle(const Student& owner);
void link(const School& o0);
void unlink(const School& o0);
void del(const litesql::Expr& expr=litesql::Expr());
litesql::DataSource<School> get(const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
litesql::DataSource<SchoolStudentRelation::Row> getRows(const litesql::Expr& expr=litesql::Expr());
};
static const std::string type__;
static const std::string table__;
Student(const litesql::Database& db);
Student(const litesql::Database& db, const litesql::Record& rec);
Student(const Student& obj);
const Student& operator=(const Student& obj);
Student::SchoolHandle school();
protected:
std::string insert(litesql::Record& tables, litesql::Records& fieldRecs, litesql::Records& valueRecs);
void create();
virtual void addUpdates(Updates& updates);
virtual void addIDUpdates(Updates& updates);
public:
static void getFieldTypes(std::vector<litesql::FieldType>& ftypes);
protected:
virtual void delRecord();
virtual void delRelations();
public:
virtual void update();
virtual void del();
virtual bool typeIsCorrect();
std::auto_ptr<Student> upcast();
std::auto_ptr<Student> upcastCopy();
};
std::ostream & operator<<(std::ostream& os, Student o);
class Employee : public Role {
public:
class Own {
public:
static const litesql::FieldType Id;
};
class OfficeHandle : public litesql::RelationHandle<Employee> {
public:
OfficeHandle(const Employee& owner);
void link(const Office& o0);
void unlink(const Office& o0);
void del(const litesql::Expr& expr=litesql::Expr());
litesql::DataSource<Office> get(const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
litesql::DataSource<EmployeeOfficeRelation::Row> getRows(const litesql::Expr& expr=litesql::Expr());
};
static const std::string type__;
static const std::string table__;
Employee(const litesql::Database& db);
Employee(const litesql::Database& db, const litesql::Record& rec);
Employee(const Employee& obj);
const Employee& operator=(const Employee& obj);
Employee::OfficeHandle office();
protected:
std::string insert(litesql::Record& tables, litesql::Records& fieldRecs, litesql::Records& valueRecs);
void create();
virtual void addUpdates(Updates& updates);
virtual void addIDUpdates(Updates& updates);
public:
static void getFieldTypes(std::vector<litesql::FieldType>& ftypes);
protected:
virtual void delRecord();
virtual void delRelations();
public:
virtual void update();
virtual void del();
virtual bool typeIsCorrect();
std::auto_ptr<Employee> upcast();
std::auto_ptr<Employee> upcastCopy();
};
std::ostream & operator<<(std::ostream& os, Employee o);
class School : public litesql::Persistent {
public:
class Own {
public:
static const litesql::FieldType Id;
};
class StudentsHandle : public litesql::RelationHandle<School> {
public:
StudentsHandle(const School& owner);
void link(const Student& o0);
void unlink(const Student& o0);
void del(const litesql::Expr& expr=litesql::Expr());
litesql::DataSource<Student> get(const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
litesql::DataSource<SchoolStudentRelation::Row> getRows(const litesql::Expr& expr=litesql::Expr());
};
static const std::string type__;
static const std::string table__;
static const std::string sequence__;
static const litesql::FieldType Id;
litesql::Field<int> id;
static const litesql::FieldType Type;
litesql::Field<std::string> type;
static const litesql::FieldType Name;
litesql::Field<std::string> name;
protected:
void defaults();
public:
School(const litesql::Database& db);
School(const litesql::Database& db, const litesql::Record& rec);
School(const School& obj);
const School& operator=(const School& obj);
School::StudentsHandle students();
protected:
std::string insert(litesql::Record& tables, litesql::Records& fieldRecs, litesql::Records& valueRecs);
void create();
virtual void addUpdates(Updates& updates);
virtual void addIDUpdates(Updates& updates);
public:
static void getFieldTypes(std::vector<litesql::FieldType>& ftypes);
protected:
virtual void delRecord();
virtual void delRelations();
public:
virtual void update();
virtual void del();
virtual bool typeIsCorrect();
std::auto_ptr<School> upcast();
std::auto_ptr<School> upcastCopy();
};
std::ostream & operator<<(std::ostream& os, School o);
class Office : public litesql::Persistent {
public:
class Own {
public:
static const litesql::FieldType Id;
};
class EmployeesHandle : public litesql::RelationHandle<Office> {
public:
EmployeesHandle(const Office& owner);
void link(const Employee& o0);
void unlink(const Employee& o0);
void del(const litesql::Expr& expr=litesql::Expr());
litesql::DataSource<Employee> get(const litesql::Expr& expr=litesql::Expr(), const litesql::Expr& srcExpr=litesql::Expr());
litesql::DataSource<EmployeeOfficeRelation::Row> getRows(const litesql::Expr& expr=litesql::Expr());
};
static const std::string type__;
static const std::string table__;
static const std::string sequence__;
static const litesql::FieldType Id;
litesql::Field<int> id;
static const litesql::FieldType Type;
litesql::Field<std::string> type;
protected:
void defaults();
public:
Office(const litesql::Database& db);
Office(const litesql::Database& db, const litesql::Record& rec);
Office(const Office& obj);
const Office& operator=(const Office& obj);
Office::EmployeesHandle employees();
protected:
std::string insert(litesql::Record& tables, litesql::Records& fieldRecs, litesql::Records& valueRecs);
void create();
virtual void addUpdates(Updates& updates);
virtual void addIDUpdates(Updates& updates);
public:
static void getFieldTypes(std::vector<litesql::FieldType>& ftypes);
protected:
virtual void delRecord();
virtual void delRelations();
public:
virtual void update();
virtual void del();
virtual bool typeIsCorrect();
std::auto_ptr<Office> upcast();
std::auto_ptr<Office> upcastCopy();
};
std::ostream & operator<<(std::ostream& os, Office o);
class ThingWithMethods : public litesql::Persistent {
public:
class Own {
public:
static const litesql::FieldType Id;
};
static const std::string type__;
static const std::string table__;
static const std::string sequence__;
static const litesql::FieldType Id;
litesql::Field<int> id;
static const litesql::FieldType Type;
litesql::Field<std::string> type;
protected:
void defaults();
public:
ThingWithMethods(const litesql::Database& db);
ThingWithMethods(const litesql::Database& db, const litesql::Record& rec);
ThingWithMethods(const ThingWithMethods& obj);
const ThingWithMethods& operator=(const ThingWithMethods& obj);
virtual void sayHello(std::string text, int repeat);
protected:
std::string insert(litesql::Record& tables, litesql::Records& fieldRecs, litesql::Records& valueRecs);
void create();
virtual void addUpdates(Updates& updates);
virtual void addIDUpdates(Updates& updates);
public:
static void getFieldTypes(std::vector<litesql::FieldType>& ftypes);
protected:
virtual void delRecord();
virtual void delRelations();
public:
virtual void update();
virtual void del();
virtual bool typeIsCorrect();
std::auto_ptr<ThingWithMethods> upcast();
std::auto_ptr<ThingWithMethods> upcastCopy();
};
std::ostream & operator<<(std::ostream& os, ThingWithMethods o);
class ExampleDatabase : public litesql::Database {
public:
ExampleDatabase(std::string backendType, std::string connInfo);
protected:
virtual std::vector<litesql::Database::SchemaItem> getSchema() const;
static void initialize();
};
}
#endif
template class which holds SelectQuery for selecting objects of type T
Definition datasource.hpp:34
Definition field.hpp:24
include this from your project
exampledatabase.cpp contains implementation of methods and lots of static data.
#include "exampledatabase.hpp"
namespace example {
using namespace litesql;
: person2(PersonPersonRelationMother::Person2), person1(PersonPersonRelationMother::Person1) {
switch(rec.size()) {
case 2:
person2 = rec[1];
case 1:
person1 = rec[0];
}
}
const std::string PersonPersonRelationMother::table__("Person_Person_Mother");
void PersonPersonRelationMother::link(const litesql::Database& db, const example::Person& o0, const example::Person& o1) {
Record values;
Split fields;
fields.push_back(Person1.name());
values.push_back(o0.id);
fields.push_back(Person2.name());
values.push_back(o1.id);
db.insert(table__, values, fields);
}
void PersonPersonRelationMother::unlink(const litesql::Database& db, const example::Person& o0, const example::Person& o1) {
db.delete_(table__, (Person1 == o0.id && Person2 == o1.id));
}
db.delete_(table__, expr);
}
litesql::DataSource<PersonPersonRelationMother::Row> PersonPersonRelationMother::getRows(const litesql::Database& db, const litesql::Expr& expr) {
SelectQuery sel;
sel.result(Person1.fullName());
sel.result(Person2.fullName());
sel.source(table__);
sel.where(expr);
return DataSource<PersonPersonRelationMother::Row>(db, sel);
}
litesql::DataSource<example::Person> PersonPersonRelationMother::getPerson1(const litesql::Database& db, const litesql::Expr& expr, const litesql::Expr& srcExpr) {
SelectQuery sel;
sel.source(table__);
sel.result(Person1.fullName());
sel.where(srcExpr);
return DataSource<example::Person>(db, example::Person::Id.in(sel) && expr);
}
litesql::DataSource<example::Person> PersonPersonRelationMother::getPerson2(const litesql::Database& db, const litesql::Expr& expr, const litesql::Expr& srcExpr) {
SelectQuery sel;
sel.source(table__);
sel.result(Person2.fullName());
sel.where(srcExpr);
return DataSource<example::Person>(db, example::Person::Id.in(sel) && expr);
}
: person2(PersonPersonRelationFather::Person2), person1(PersonPersonRelationFather::Person1) {
switch(rec.size()) {
case 2:
person2 = rec[1];
case 1:
person1 = rec[0];
}
}
const std::string PersonPersonRelationFather::table__("Person_Person_Father");
void PersonPersonRelationFather::link(const litesql::Database& db, const example::Person& o0, const example::Person& o1) {
Record values;
Split fields;
fields.push_back(Person1.name());
values.push_back(o0.id);
fields.push_back(Person2.name());
values.push_back(o1.id);
db.insert(table__, values, fields);
}
void PersonPersonRelationFather::unlink(const litesql::Database& db, const example::Person& o0, const example::Person& o1) {
db.delete_(table__, (Person1 == o0.id && Person2 == o1.id));
}
db.delete_(table__, expr);
}
litesql::DataSource<PersonPersonRelationFather::Row> PersonPersonRelationFather::getRows(const litesql::Database& db, const litesql::Expr& expr) {
SelectQuery sel;
sel.result(Person1.fullName());
sel.result(Person2.fullName());
sel.source(table__);
sel.where(expr);
return DataSource<PersonPersonRelationFather::Row>(db, sel);
}
litesql::DataSource<example::Person> PersonPersonRelationFather::getPerson1(const litesql::Database& db, const litesql::Expr& expr, const litesql::Expr& srcExpr) {
SelectQuery sel;
sel.source(table__);
sel.result(Person1.fullName());
sel.where(srcExpr);
return DataSource<example::Person>(db, example::Person::Id.in(sel) && expr);
}
litesql::DataSource<example::Person> PersonPersonRelationFather::getPerson2(const litesql::Database& db, const litesql::Expr& expr, const litesql::Expr& srcExpr) {
SelectQuery sel;
sel.source(table__);
sel.result(Person2.fullName());
sel.where(srcExpr);
return DataSource<example::Person>(db, example::Person::Id.in(sel) && expr);
}
: person2(PersonPersonRelationSiblings::Person2), person1(PersonPersonRelationSiblings::Person1) {
switch(rec.size()) {
case 2:
person2 = rec[1];
case 1:
person1 = rec[0];
}
}
const std::string PersonPersonRelationSiblings::table__("Person_Person_Siblings");
void PersonPersonRelationSiblings::link(const litesql::Database& db, const example::Person& o0, const example::Person& o1) {
Record values;
Split fields;
fields.push_back(Person1.name());
values.push_back(o0.id);
fields.push_back(Person2.name());
values.push_back(o1.id);
db.insert(table__, values, fields);
fields.clear();
values.clear();
fields.push_back(Person1.name());
values.push_back(o1.id);
fields.push_back(Person2.name());
values.push_back(o0.id);
db.insert(table__, values, fields);
}
void PersonPersonRelationSiblings::unlink(const litesql::Database& db, const example::Person& o0, const example::Person& o1) {
db.delete_(table__, (Person1 == o0.id && Person2 == o1.id));
db.delete_(table__, (Person1 == o1.id && Person2 == o0.id));
}
db.delete_(table__, expr);
}
litesql::DataSource<PersonPersonRelationSiblings::Row> PersonPersonRelationSiblings::getRows(const litesql::Database& db, const litesql::Expr& expr) {
SelectQuery sel;
sel.result(Person1.fullName());
sel.result(Person2.fullName());
sel.source(table__);
sel.where(expr);
return DataSource<PersonPersonRelationSiblings::Row>(db, sel);
}
litesql::DataSource<example::Person> PersonPersonRelationSiblings::getPerson1(const litesql::Database& db, const litesql::Expr& expr, const litesql::Expr& srcExpr) {
SelectQuery sel;
sel.source(table__);
sel.result(Person1.fullName());
sel.where(srcExpr);
return DataSource<example::Person>(db, example::Person::Id.in(sel) && expr);
}
litesql::DataSource<example::Person> PersonPersonRelationSiblings::getPerson2(const litesql::Database& db, const litesql::Expr& expr, const litesql::Expr& srcExpr) {
SelectQuery sel;
sel.source(table__);
sel.result(Person2.fullName());
sel.where(srcExpr);
return DataSource<example::Person>(db, example::Person::Id.in(sel) && expr);
}
: person2(PersonPersonRelationChildren::Person2), person1(PersonPersonRelationChildren::Person1) {
switch(rec.size()) {
case 2:
person2 = rec[1];
case 1:
person1 = rec[0];
}
}
const std::string PersonPersonRelationChildren::table__("Person_Person_Children");
void PersonPersonRelationChildren::link(const litesql::Database& db, const example::Person& o0, const example::Person& o1) {
Record values;
Split fields;
fields.push_back(Person1.name());
values.push_back(o0.id);
fields.push_back(Person2.name());
values.push_back(o1.id);
db.insert(table__, values, fields);
}
void PersonPersonRelationChildren::unlink(const litesql::Database& db, const example::Person& o0, const example::Person& o1) {
db.delete_(table__, (Person1 == o0.id && Person2 == o1.id));
}
db.delete_(table__, expr);
}
litesql::DataSource<PersonPersonRelationChildren::Row> PersonPersonRelationChildren::getRows(const litesql::Database& db, const litesql::Expr& expr) {
SelectQuery sel;
sel.result(Person1.fullName());
sel.result(Person2.fullName());
sel.source(table__);
sel.where(expr);
return DataSource<PersonPersonRelationChildren::Row>(db, sel);
}
litesql::DataSource<example::Person> PersonPersonRelationChildren::getPerson1(const litesql::Database& db, const litesql::Expr& expr, const litesql::Expr& srcExpr) {
SelectQuery sel;
sel.source(table__);
sel.result(Person1.fullName());
sel.where(srcExpr);
return DataSource<example::Person>(db, example::Person::Id.in(sel) && expr);
}
litesql::DataSource<example::Person> PersonPersonRelationChildren::getPerson2(const litesql::Database& db, const litesql::Expr& expr, const litesql::Expr& srcExpr) {
SelectQuery sel;
sel.source(table__);
sel.result(Person2.fullName());
sel.where(srcExpr);
return DataSource<example::Person>(db, example::Person::Id.in(sel) && expr);
}
: role(RoleRelation::Role), person(RoleRelation::Person) {
switch(rec.size()) {
case 2:
role = rec[1];
case 1:
person = rec[0];
}
}
const std::string RoleRelation::table__("Person_Role_Roles");
void RoleRelation::link(const litesql::Database& db, const example::Person& o0, const example::Role& o1) {
Record values;
Split fields;
fields.push_back(Person.name());
values.push_back(o0.id);
fields.push_back(Role.name());
values.push_back(o1.id);
db.insert(table__, values, fields);
}
void RoleRelation::unlink(const litesql::Database& db, const example::Person& o0, const example::Role& o1) {
db.delete_(table__, (Person == o0.id && Role == o1.id));
}
db.delete_(table__, expr);
}
litesql::DataSource<RoleRelation::Row> RoleRelation::getRows(const litesql::Database& db, const litesql::Expr& expr) {
SelectQuery sel;
sel.result(Person.fullName());
sel.result(Role.fullName());
sel.source(table__);
sel.where(expr);
return DataSource<RoleRelation::Row>(db, sel);
}
template <> litesql::DataSource<example::Person> RoleRelation::get(const litesql::Database& db, const litesql::Expr& expr, const litesql::Expr& srcExpr) {
SelectQuery sel;
sel.source(table__);
sel.result(Person.fullName());
sel.where(srcExpr);
return DataSource<example::Person>(db, example::Person::Id.in(sel) && expr);
}
template <> litesql::DataSource<example::Role> RoleRelation::get(const litesql::Database& db, const litesql::Expr& expr, const litesql::Expr& srcExpr) {
SelectQuery sel;
sel.source(table__);
sel.result(Role.fullName());
sel.where(srcExpr);
return DataSource<example::Role>(db, example::Role::Id.in(sel) && expr);
}
: student(SchoolStudentRelation::Student), school(SchoolStudentRelation::School) {
switch(rec.size()) {
case 2:
student = rec[1];
case 1:
school = rec[0];
}
}
const std::string SchoolStudentRelation::table__("School_Student_");
void SchoolStudentRelation::link(const litesql::Database& db, const example::School& o0, const example::Student& o1) {
Record values;
Split fields;
fields.push_back(School.name());
values.push_back(o0.id);
fields.push_back(Student.name());
values.push_back(o1.id);
db.insert(table__, values, fields);
}
void SchoolStudentRelation::unlink(const litesql::Database& db, const example::School& o0, const example::Student& o1) {
db.delete_(table__, (School == o0.id && Student == o1.id));
}
db.delete_(table__, expr);
}
litesql::DataSource<SchoolStudentRelation::Row> SchoolStudentRelation::getRows(const litesql::Database& db, const litesql::Expr& expr) {
SelectQuery sel;
sel.result(School.fullName());
sel.result(Student.fullName());
sel.source(table__);
sel.where(expr);
return DataSource<SchoolStudentRelation::Row>(db, sel);
}
template <> litesql::DataSource<example::School> SchoolStudentRelation::get(const litesql::Database& db, const litesql::Expr& expr, const litesql::Expr& srcExpr) {
SelectQuery sel;
sel.source(table__);
sel.result(School.fullName());
sel.where(srcExpr);
return DataSource<example::School>(db, example::School::Id.in(sel) && expr);
}
template <> litesql::DataSource<example::Student> SchoolStudentRelation::get(const litesql::Database& db, const litesql::Expr& expr, const litesql::Expr& srcExpr) {
SelectQuery sel;
sel.source(table__);
sel.result(Student.fullName());
sel.where(srcExpr);
return DataSource<example::Student>(db, example::Student::Id.in(sel) && expr);
}
: office(EmployeeOfficeRelation::Office), employee(EmployeeOfficeRelation::Employee) {
switch(rec.size()) {
case 2:
office = rec[1];
case 1:
employee = rec[0];
}
}
const std::string EmployeeOfficeRelation::table__("Employee_Office_");
void EmployeeOfficeRelation::link(const litesql::Database& db, const example::Employee& o0, const example::Office& o1) {
Record values;
Split fields;
fields.push_back(Employee.name());
values.push_back(o0.id);
fields.push_back(Office.name());
values.push_back(o1.id);
db.insert(table__, values, fields);
}
void EmployeeOfficeRelation::unlink(const litesql::Database& db, const example::Employee& o0, const example::Office& o1) {
db.delete_(table__, (Employee == o0.id && Office == o1.id));
}
db.delete_(table__, expr);
}
litesql::DataSource<EmployeeOfficeRelation::Row> EmployeeOfficeRelation::getRows(const litesql::Database& db, const litesql::Expr& expr) {
SelectQuery sel;
sel.result(Employee.fullName());
sel.result(Office.fullName());
sel.source(table__);
sel.where(expr);
return DataSource<EmployeeOfficeRelation::Row>(db, sel);
}
template <> litesql::DataSource<example::Employee> EmployeeOfficeRelation::get(const litesql::Database& db, const litesql::Expr& expr, const litesql::Expr& srcExpr) {
SelectQuery sel;
sel.source(table__);
sel.result(Employee.fullName());
sel.where(srcExpr);
return DataSource<example::Employee>(db, example::Employee::Id.in(sel) && expr);
}
template <> litesql::DataSource<example::Office> EmployeeOfficeRelation::get(const litesql::Database& db, const litesql::Expr& expr, const litesql::Expr& srcExpr) {
SelectQuery sel;
sel.source(table__);
sel.result(Office.fullName());
sel.where(srcExpr);
return DataSource<example::Office>(db, example::Office::Id.in(sel) && expr);
}
const std::string user::type__("user");
const std::string user::table__("user_");
const std::string user::sequence__("user_seq");
void user::defaults() {
id = 0;
}
user::user(const litesql::Database& db)
: litesql::Persistent(db), id(Id), type(Type), name(Name), passwd(Passwd) {
defaults();
}
: litesql::Persistent(db, rec), id(Id), type(Type), name(Name), passwd(Passwd) {
defaults();
size_t size = (rec.size() > 4) ? 4 : rec.size();
switch(size) {
case 4: passwd = convert<const std::string&, std::string>(rec[3]);
passwd.setModified(false);
case 3: name = convert<const std::string&, std::string>(rec[2]);
name.setModified(false);
case 2: type = convert<const std::string&, std::string>(rec[1]);
type.setModified(false);
id.setModified(false);
}
}
user::user(const user& obj)
: litesql::Persistent(obj), id(obj.id), type(obj.type), name(obj.name), passwd(obj.passwd) {
}
const user& user::operator=(const user& obj) {
if (this != &obj) {
id = obj.id;
type = obj.type;
name = obj.name;
passwd = obj.passwd;
}
return *this;
}
std::string user::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(name.name());
values.push_back(name);
name.setModified(false);
fields.push_back(passwd.name());
values.push_back(passwd);
passwd.setModified(false);
fieldRecs.push_back(fields);
valueRecs.push_back(values);
return litesql::Persistent::insert(tables, fieldRecs, valueRecs, sequence__);
}
void user::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 user::addUpdates(Updates& updates) {
prepareUpdate(updates, table__);
updateField(updates, table__, id);
updateField(updates, table__, type);
updateField(updates, table__, name);
updateField(updates, table__, passwd);
}
void user::addIDUpdates(Updates& updates) {
}
void user::getFieldTypes(std::vector<litesql::FieldType>& ftypes) {
ftypes.push_back(Id);
ftypes.push_back(Type);
ftypes.push_back(Name);
ftypes.push_back(Passwd);
}
void user::delRecord() {
deleteFromTable(table__, id);
}
void user::delRelations() {
}
void user::update() {
if (!inDatabase) {
create();
return;
}
Updates updates;
addUpdates(updates);
if (id != oldKey) {
if (!typeIsCorrect())
upcastCopy()->addIDUpdates(updates);
}
litesql::Persistent::update(updates);
oldKey = id;
}
void user::del() {
if (typeIsCorrect() == false) {
std::auto_ptr<user> p(upcastCopy());
p->delRelations();
p->onDelete();
p->delRecord();
} else {
onDelete();
delRecord();
}
inDatabase = false;
}
bool user::typeIsCorrect() {
return type == type__;
}
std::auto_ptr<user> user::upcast() {
return auto_ptr<user>(new user(*this));
}
std::auto_ptr<user> user::upcastCopy() {
user* np = new user(*this);
np->id = id;
np->type = type;
np->name = name;
np->passwd = passwd;
np->inDatabase = inDatabase;
return auto_ptr<user>(np);
}
std::ostream & operator<<(std::ostream& os, user o) {
os << "-------------------------------------" << std::endl;
os << o.id.name() << " = " << o.id << std::endl;
os << o.type.name() << " = " << o.type << std::endl;
os << o.name.name() << " = " << o.name << std::endl;
os << o.passwd.name() << " = " << o.passwd << std::endl;
os << "-------------------------------------" << std::endl;
return os;
}
const int Person::SexType::Male(0);
const int Person::SexType::Female(1);
Person::SexType::SexType(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 Person::Sex::Male(0);
const int Person::Sex::Female(1);
Person::MotherHandle::MotherHandle(const Person& owner)
: litesql::RelationHandle<Person>(owner) {
}
void Person::MotherHandle::link(const Person& o0) {
PersonPersonRelationMother::link(owner->getDatabase(), *owner, o0);
}
void Person::MotherHandle::unlink(const Person& o0) {
PersonPersonRelationMother::unlink(owner->getDatabase(), *owner, o0);
}
PersonPersonRelationMother::del(owner->getDatabase(), expr && PersonPersonRelationMother::Person1 == owner->id);
}
litesql::DataSource<Person> Person::MotherHandle::get(const litesql::Expr& expr, const litesql::Expr& srcExpr) {
return PersonPersonRelationMother::getPerson2(owner->getDatabase(), expr, (PersonPersonRelationMother::Person1 == owner->id) && srcExpr);
}
litesql::DataSource<PersonPersonRelationMother::Row> Person::MotherHandle::getRows(const litesql::Expr& expr) {
return PersonPersonRelationMother::getRows(owner->getDatabase(), expr && (PersonPersonRelationMother::Person1 == owner->id));
}
Person::FatherHandle::FatherHandle(const Person& owner)
: litesql::RelationHandle<Person>(owner) {
}
void Person::FatherHandle::link(const Person& o0) {
PersonPersonRelationFather::link(owner->getDatabase(), *owner, o0);
}
void Person::FatherHandle::unlink(const Person& o0) {
PersonPersonRelationFather::unlink(owner->getDatabase(), *owner, o0);
}
PersonPersonRelationFather::del(owner->getDatabase(), expr && PersonPersonRelationFather::Person1 == owner->id);
}
litesql::DataSource<Person> Person::FatherHandle::get(const litesql::Expr& expr, const litesql::Expr& srcExpr) {
return PersonPersonRelationFather::getPerson2(owner->getDatabase(), expr, (PersonPersonRelationFather::Person1 == owner->id) && srcExpr);
}
litesql::DataSource<PersonPersonRelationFather::Row> Person::FatherHandle::getRows(const litesql::Expr& expr) {
return PersonPersonRelationFather::getRows(owner->getDatabase(), expr && (PersonPersonRelationFather::Person1 == owner->id));
}
Person::SiblingsHandle::SiblingsHandle(const Person& owner)
: litesql::RelationHandle<Person>(owner) {
}
void Person::SiblingsHandle::link(const Person& o0) {
PersonPersonRelationSiblings::link(owner->getDatabase(), *owner, o0);
}
void Person::SiblingsHandle::unlink(const Person& o0) {
PersonPersonRelationSiblings::unlink(owner->getDatabase(), *owner, o0);
}
PersonPersonRelationSiblings::del(owner->getDatabase(), expr && PersonPersonRelationSiblings::Person1 == owner->id);
}
litesql::DataSource<Person> Person::SiblingsHandle::get(const litesql::Expr& expr, const litesql::Expr& srcExpr) {
return PersonPersonRelationSiblings::getPerson2(owner->getDatabase(), expr, (PersonPersonRelationSiblings::Person1 == owner->id) && srcExpr);
}
litesql::DataSource<PersonPersonRelationSiblings::Row> Person::SiblingsHandle::getRows(const litesql::Expr& expr) {
return PersonPersonRelationSiblings::getRows(owner->getDatabase(), expr && (PersonPersonRelationSiblings::Person1 == owner->id));
}
Person::ChildrenHandle::ChildrenHandle(const Person& owner)
: litesql::RelationHandle<Person>(owner) {
}
void Person::ChildrenHandle::link(const Person& o0) {
PersonPersonRelationChildren::link(owner->getDatabase(), *owner, o0);
}
void Person::ChildrenHandle::unlink(const Person& o0) {
PersonPersonRelationChildren::unlink(owner->getDatabase(), *owner, o0);
}
PersonPersonRelationChildren::del(owner->getDatabase(), expr && PersonPersonRelationChildren::Person1 == owner->id);
}
litesql::DataSource<Person> Person::ChildrenHandle::get(const litesql::Expr& expr, const litesql::Expr& srcExpr) {
return PersonPersonRelationChildren::getPerson2(owner->getDatabase(), expr, (PersonPersonRelationChildren::Person1 == owner->id) && srcExpr);
}
litesql::DataSource<PersonPersonRelationChildren::Row> Person::ChildrenHandle::getRows(const litesql::Expr& expr) {
return PersonPersonRelationChildren::getRows(owner->getDatabase(), expr && (PersonPersonRelationChildren::Person1 == owner->id));
}
Person::RolesHandle::RolesHandle(const Person& owner)
: litesql::RelationHandle<Person>(owner) {
}
void Person::RolesHandle::link(const Role& o0) {
RoleRelation::link(owner->getDatabase(), *owner, o0);
}
void Person::RolesHandle::unlink(const Role& o0) {
RoleRelation::unlink(owner->getDatabase(), *owner, o0);
}
RoleRelation::del(owner->getDatabase(), expr && RoleRelation::Person == owner->id);
}
litesql::DataSource<Role> Person::RolesHandle::get(const litesql::Expr& expr, const litesql::Expr& srcExpr) {
return RoleRelation::get<Role>(owner->getDatabase(), expr, (RoleRelation::Person == owner->id) && srcExpr);
}
return RoleRelation::getRows(owner->getDatabase(), expr && (RoleRelation::Person == owner->id));
}
const std::string Person::type__("Person");
const std::string Person::table__("Person_");
const std::string Person::sequence__("Person_seq");
std::vector < std::pair< std::string, std::string > > Person::sex_values;
const Person::SexType Person::Sex("sex_","INTEGER",table__,sex_values);
void Person::initValues() {
sex_values.clear();
sex_values.push_back(make_pair<std::string, std::string>("Male","0"));
sex_values.push_back(make_pair<std::string, std::string>("Female","1"));
}
void Person::defaults() {
id = 0;
age = 15;
image = Blob::nil;
aDoubleValue = 0.0;
sex = 0;
}
Person::Person(const litesql::Database& db)
: litesql::Persistent(db), id(Id), type(Type), name(Name), age(Age), image(Image), aDoubleValue(ADoubleValue), sex(Sex) {
defaults();
}
: litesql::Persistent(db, rec), id(Id), type(Type), name(Name), age(Age), image(Image), aDoubleValue(ADoubleValue), sex(Sex) {
defaults();
size_t size = (rec.size() > 7) ? 7 : rec.size();
switch(size) {
case 7: sex = convert<const std::string&, int>(rec[6]);
sex.setModified(false);
case 6: aDoubleValue = convert<const std::string&, double>(rec[5]);
aDoubleValue.setModified(false);
case 5: image = convert<const std::string&, litesql::Blob>(rec[4]);
image.setModified(false);
case 4: age = convert<const std::string&, int>(rec[3]);
age.setModified(false);
case 3: name = convert<const std::string&, std::string>(rec[2]);
name.setModified(false);
case 2: type = convert<const std::string&, std::string>(rec[1]);
type.setModified(false);
id.setModified(false);
}
}
Person::Person(const Person& obj)
: litesql::Persistent(obj), id(obj.id), type(obj.type), name(obj.name), age(obj.age), image(obj.image), aDoubleValue(obj.aDoubleValue), sex(obj.sex) {
}
const Person& Person::operator=(const Person& obj) {
if (this != &obj) {
id = obj.id;
type = obj.type;
name = obj.name;
age = obj.age;
image = obj.image;
aDoubleValue = obj.aDoubleValue;
sex = obj.sex;
}
return *this;
}
Person::MotherHandle Person::mother() {
return Person::MotherHandle(*this);
}
Person::FatherHandle Person::father() {
return Person::FatherHandle(*this);
}
Person::SiblingsHandle Person::siblings() {
return Person::SiblingsHandle(*this);
}
Person::ChildrenHandle Person::children() {
return Person::ChildrenHandle(*this);
}
Person::RolesHandle Person::roles() {
return Person::RolesHandle(*this);
}
std::string Person::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(name.name());
values.push_back(name);
name.setModified(false);
fields.push_back(age.name());
values.push_back(age);
age.setModified(false);
fields.push_back(image.name());
values.push_back(image);
image.setModified(false);
fields.push_back(aDoubleValue.name());
values.push_back(aDoubleValue);
aDoubleValue.setModified(false);
fields.push_back(sex.name());
values.push_back(sex);
sex.setModified(false);
fieldRecs.push_back(fields);
valueRecs.push_back(values);
return litesql::Persistent::insert(tables, fieldRecs, valueRecs, sequence__);
}
void Person::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 Person::addUpdates(Updates& updates) {
prepareUpdate(updates, table__);
updateField(updates, table__, id);
updateField(updates, table__, type);
updateField(updates, table__, name);
updateField(updates, table__, age);
updateField(updates, table__, image);
updateField(updates, table__, aDoubleValue);
updateField(updates, table__, sex);
}
void Person::addIDUpdates(Updates& updates) {
}
void Person::getFieldTypes(std::vector<litesql::FieldType>& ftypes) {
ftypes.push_back(Id);
ftypes.push_back(Type);
ftypes.push_back(Name);
ftypes.push_back(Age);
ftypes.push_back(Image);
ftypes.push_back(ADoubleValue);
ftypes.push_back(Sex);
}
void Person::delRecord() {
deleteFromTable(table__, id);
}
void Person::delRelations() {
PersonPersonRelationMother::del(*db, (PersonPersonRelationMother::Person1 == id) || (PersonPersonRelationMother::Person2 == id));
PersonPersonRelationFather::del(*db, (PersonPersonRelationFather::Person1 == id) || (PersonPersonRelationFather::Person2 == id));
PersonPersonRelationSiblings::del(*db, (PersonPersonRelationSiblings::Person1 == id) || (PersonPersonRelationSiblings::Person2 == id));
PersonPersonRelationChildren::del(*db, (PersonPersonRelationChildren::Person1 == id) || (PersonPersonRelationChildren::Person2 == id));
RoleRelation::del(*db, (RoleRelation::Person == id));
}
void Person::update() {
if (!inDatabase) {
create();
return;
}
Updates updates;
addUpdates(updates);
if (id != oldKey) {
if (!typeIsCorrect())
upcastCopy()->addIDUpdates(updates);
}
litesql::Persistent::update(updates);
oldKey = id;
}
void Person::del() {
if (typeIsCorrect() == false) {
std::auto_ptr<Person> p(upcastCopy());
p->delRelations();
p->onDelete();
p->delRecord();
} else {
onDelete();
delRecord();
}
inDatabase = false;
}
bool Person::typeIsCorrect() {
return type == type__;
}
std::auto_ptr<Person> Person::upcast() {
return auto_ptr<Person>(new Person(*this));
}
std::auto_ptr<Person> Person::upcastCopy() {
Person* np = new Person(*this);
np->id = id;
np->type = type;
np->name = name;
np->age = age;
np->image = image;
np->aDoubleValue = aDoubleValue;
np->sex = sex;
np->inDatabase = inDatabase;
return auto_ptr<Person>(np);
}
std::ostream & operator<<(std::ostream& os, Person o) {
os << "-------------------------------------" << std::endl;
os << o.id.name() << " = " << o.id << std::endl;
os << o.type.name() << " = " << o.type << std::endl;
os << o.name.name() << " = " << o.name << std::endl;
os << o.age.name() << " = " << o.age << std::endl;
os << o.image.name() << " = " << o.image << std::endl;
os << o.aDoubleValue.name() << " = " << o.aDoubleValue << std::endl;
os << o.sex.name() << " = " << o.sex << std::endl;
os << "-------------------------------------" << std::endl;
return os;
}
Role::PersonHandle::PersonHandle(const Role& owner)
: litesql::RelationHandle<Role>(owner) {
}
void Role::PersonHandle::link(const Person& o0) {
RoleRelation::link(owner->getDatabase(), o0, *owner);
}
void Role::PersonHandle::unlink(const Person& o0) {
RoleRelation::unlink(owner->getDatabase(), o0, *owner);
}
RoleRelation::del(owner->getDatabase(), expr && RoleRelation::Role == owner->id);
}
litesql::DataSource<Person> Role::PersonHandle::get(const litesql::Expr& expr, const litesql::Expr& srcExpr) {
return RoleRelation::get<Person>(owner->getDatabase(), expr, (RoleRelation::Role == owner->id) && srcExpr);
}
return RoleRelation::getRows(owner->getDatabase(), expr && (RoleRelation::Role == owner->id));
}
const std::string Role::type__("Role");
const std::string Role::table__("Role_");
const std::string Role::sequence__("Role_seq");
void Role::defaults() {
id = 0;
}
Role::Role(const litesql::Database& db)
: litesql::Persistent(db), id(Id), type(Type) {
defaults();
}
: litesql::Persistent(db, rec), id(Id), type(Type) {
defaults();
size_t size = (rec.size() > 2) ? 2 : rec.size();
switch(size) {
case 2: type = convert<const std::string&, std::string>(rec[1]);
type.setModified(false);
id.setModified(false);
}
}
Role::Role(const Role& obj)
: litesql::Persistent(obj), id(obj.id), type(obj.type) {
}
const Role& Role::operator=(const Role& obj) {
if (this != &obj) {
id = obj.id;
type = obj.type;
}
return *this;
}
Role::PersonHandle Role::person() {
return Role::PersonHandle(*this);
}
std::string Role::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);
fieldRecs.push_back(fields);
valueRecs.push_back(values);
return litesql::Persistent::insert(tables, fieldRecs, valueRecs, sequence__);
}
void Role::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 Role::addUpdates(Updates& updates) {
prepareUpdate(updates, table__);
updateField(updates, table__, id);
updateField(updates, table__, type);
}
void Role::addIDUpdates(Updates& updates) {
}
void Role::getFieldTypes(std::vector<litesql::FieldType>& ftypes) {
ftypes.push_back(Id);
ftypes.push_back(Type);
}
void Role::delRecord() {
deleteFromTable(table__, id);
}
void Role::delRelations() {
RoleRelation::del(*db, (RoleRelation::Role == id));
}
void Role::update() {
if (!inDatabase) {
create();
return;
}
Updates updates;
addUpdates(updates);
if (id != oldKey) {
if (!typeIsCorrect())
upcastCopy()->addIDUpdates(updates);
}
litesql::Persistent::update(updates);
oldKey = id;
}
void Role::del() {
if (typeIsCorrect() == false) {
std::auto_ptr<Role> p(upcastCopy());
p->delRelations();
p->onDelete();
p->delRecord();
} else {
onDelete();
delRecord();
}
inDatabase = false;
}
bool Role::typeIsCorrect() {
return type == type__;
}
std::auto_ptr<Role> Role::upcast() {
if (type == Student::type__)
if (type == Employee::type__)
return auto_ptr<Role>(new Role(*this));
}
std::auto_ptr<Role> Role::upcastCopy() {
Role* np = NULL;
if (type == "Student")
np = new Student(*db);
if (type == "Employee")
np = new Employee(*db);
np->id = id;
np->type = type;
np->inDatabase = inDatabase;
return auto_ptr<Role>(np);
}
std::ostream & operator<<(std::ostream& os, Role o) {
os << "-------------------------------------" << std::endl;
os << o.id.name() << " = " << o.id << std::endl;
os << o.type.name() << " = " << o.type << std::endl;
os << "-------------------------------------" << std::endl;
return os;
}
Student::SchoolHandle::SchoolHandle(const Student& owner)
: litesql::RelationHandle<Student>(owner) {
}
void Student::SchoolHandle::link(const School& o0) {
SchoolStudentRelation::link(owner->getDatabase(), o0, *owner);
}
void Student::SchoolHandle::unlink(const School& o0) {
SchoolStudentRelation::unlink(owner->getDatabase(), o0, *owner);
}
SchoolStudentRelation::del(owner->getDatabase(), expr && SchoolStudentRelation::Student == owner->id);
}
litesql::DataSource<School> Student::SchoolHandle::get(const litesql::Expr& expr, const litesql::Expr& srcExpr) {
return SchoolStudentRelation::get<School>(owner->getDatabase(), expr, (SchoolStudentRelation::Student == owner->id) && srcExpr);
}
litesql::DataSource<SchoolStudentRelation::Row> Student::SchoolHandle::getRows(const litesql::Expr& expr) {
return SchoolStudentRelation::getRows(owner->getDatabase(), expr && (SchoolStudentRelation::Student == owner->id));
}
const std::string Student::type__("Student");
const std::string Student::table__("Student_");
Student::Student(const litesql::Database& db)
: Role(db) {
}
: Role(db, rec) {
}
Student::Student(const Student& obj)
: Role(obj) {
}
const Student& Student::operator=(const Student& obj) {
Role::operator=(obj);
return *this;
}
Student::SchoolHandle Student::school() {
return Student::SchoolHandle(*this);
}
std::string Student::insert(litesql::Record& tables, litesql::Records& fieldRecs, litesql::Records& valueRecs) {
tables.push_back(table__);
litesql::Record fields;
litesql::Record values;
fields.push_back("id_");
values.push_back(id);
fieldRecs.push_back(fields);
valueRecs.push_back(values);
return Role::insert(tables, fieldRecs, valueRecs);
}
void Student::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 Student::addUpdates(Updates& updates) {
prepareUpdate(updates, table__);
Role::addUpdates(updates);
}
void Student::addIDUpdates(Updates& updates) {
prepareUpdate(updates, table__);
updateField(updates, table__, id);
}
void Student::getFieldTypes(std::vector<litesql::FieldType>& ftypes) {
Role::getFieldTypes(ftypes);
}
void Student::delRecord() {
deleteFromTable(table__, id);
Role::delRecord();
}
void Student::delRelations() {
SchoolStudentRelation::del(*db, (SchoolStudentRelation::Student == id));
}
void Student::update() {
if (!inDatabase) {
create();
return;
}
Updates updates;
addUpdates(updates);
if (id != oldKey) {
if (!typeIsCorrect())
upcastCopy()->addIDUpdates(updates);
else
addIDUpdates(updates);
}
litesql::Persistent::update(updates);
oldKey = id;
}
void Student::del() {
if (typeIsCorrect() == false) {
std::auto_ptr<Student> p(upcastCopy());
p->delRelations();
p->onDelete();
p->delRecord();
} else {
onDelete();
delRecord();
}
inDatabase = false;
}
bool Student::typeIsCorrect() {
return type == type__;
}
std::auto_ptr<Student> Student::upcast() {
return auto_ptr<Student>(new Student(*this));
}
std::auto_ptr<Student> Student::upcastCopy() {
Student* np = new Student(*this);
np->inDatabase = inDatabase;
return auto_ptr<Student>(np);
}
std::ostream & operator<<(std::ostream& os, Student o) {
os << "-------------------------------------" << std::endl;
os << o.id.name() << " = " << o.id << std::endl;
os << o.type.name() << " = " << o.type << std::endl;
os << "-------------------------------------" << std::endl;
return os;
}
Employee::OfficeHandle::OfficeHandle(const Employee& owner)
: litesql::RelationHandle<Employee>(owner) {
}
void Employee::OfficeHandle::link(const Office& o0) {
EmployeeOfficeRelation::link(owner->getDatabase(), *owner, o0);
}
void Employee::OfficeHandle::unlink(const Office& o0) {
EmployeeOfficeRelation::unlink(owner->getDatabase(), *owner, o0);
}
EmployeeOfficeRelation::del(owner->getDatabase(), expr && EmployeeOfficeRelation::Employee == owner->id);
}
litesql::DataSource<Office> Employee::OfficeHandle::get(const litesql::Expr& expr, const litesql::Expr& srcExpr) {
return EmployeeOfficeRelation::get<Office>(owner->getDatabase(), expr, (EmployeeOfficeRelation::Employee == owner->id) && srcExpr);
}
litesql::DataSource<EmployeeOfficeRelation::Row> Employee::OfficeHandle::getRows(const litesql::Expr& expr) {
return EmployeeOfficeRelation::getRows(owner->getDatabase(), expr && (EmployeeOfficeRelation::Employee == owner->id));
}
const std::string Employee::type__("Employee");
const std::string Employee::table__("Employee_");
Employee::Employee(const litesql::Database& db)
: Role(db) {
}
: Role(db, rec) {
}
Employee::Employee(const Employee& obj)
: Role(obj) {
}
const Employee& Employee::operator=(const Employee& obj) {
Role::operator=(obj);
return *this;
}
Employee::OfficeHandle Employee::office() {
return Employee::OfficeHandle(*this);
}
std::string Employee::insert(litesql::Record& tables, litesql::Records& fieldRecs, litesql::Records& valueRecs) {
tables.push_back(table__);
litesql::Record fields;
litesql::Record values;
fields.push_back("id_");
values.push_back(id);
fieldRecs.push_back(fields);
valueRecs.push_back(values);
return Role::insert(tables, fieldRecs, valueRecs);
}
void Employee::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 Employee::addUpdates(Updates& updates) {
prepareUpdate(updates, table__);
Role::addUpdates(updates);
}
void Employee::addIDUpdates(Updates& updates) {
prepareUpdate(updates, table__);
updateField(updates, table__, id);
}
void Employee::getFieldTypes(std::vector<litesql::FieldType>& ftypes) {
Role::getFieldTypes(ftypes);
}
void Employee::delRecord() {
deleteFromTable(table__, id);
Role::delRecord();
}
void Employee::delRelations() {
EmployeeOfficeRelation::del(*db, (EmployeeOfficeRelation::Employee == id));
}
void Employee::update() {
if (!inDatabase) {
create();
return;
}
Updates updates;
addUpdates(updates);
if (id != oldKey) {
if (!typeIsCorrect())
upcastCopy()->addIDUpdates(updates);
else
addIDUpdates(updates);
}
litesql::Persistent::update(updates);
oldKey = id;
}
void Employee::del() {
if (typeIsCorrect() == false) {
std::auto_ptr<Employee> p(upcastCopy());
p->delRelations();
p->onDelete();
p->delRecord();
} else {
onDelete();
delRecord();
}
inDatabase = false;
}
bool Employee::typeIsCorrect() {
return type == type__;
}
std::auto_ptr<Employee> Employee::upcast() {
return auto_ptr<Employee>(new Employee(*this));
}
std::auto_ptr<Employee> Employee::upcastCopy() {
Employee* np = new Employee(*this);
np->inDatabase = inDatabase;
return auto_ptr<Employee>(np);
}
std::ostream & operator<<(std::ostream& os, Employee o) {
os << "-------------------------------------" << std::endl;
os << o.id.name() << " = " << o.id << std::endl;
os << o.type.name() << " = " << o.type << std::endl;
os << "-------------------------------------" << std::endl;
return os;
}
School::StudentsHandle::StudentsHandle(const School& owner)
: litesql::RelationHandle<School>(owner) {
}
void School::StudentsHandle::link(const Student& o0) {
SchoolStudentRelation::link(owner->getDatabase(), *owner, o0);
}
void School::StudentsHandle::unlink(const Student& o0) {
SchoolStudentRelation::unlink(owner->getDatabase(), *owner, o0);
}
SchoolStudentRelation::del(owner->getDatabase(), expr && SchoolStudentRelation::School == owner->id);
}
litesql::DataSource<Student> School::StudentsHandle::get(const litesql::Expr& expr, const litesql::Expr& srcExpr) {
return SchoolStudentRelation::get<Student>(owner->getDatabase(), expr, (SchoolStudentRelation::School == owner->id) && srcExpr);
}
litesql::DataSource<SchoolStudentRelation::Row> School::StudentsHandle::getRows(const litesql::Expr& expr) {
return SchoolStudentRelation::getRows(owner->getDatabase(), expr && (SchoolStudentRelation::School == owner->id));
}
const std::string School::type__("School");
const std::string School::table__("School_");
const std::string School::sequence__("School_seq");
void School::defaults() {
id = 0;
}
School::School(const litesql::Database& db)
: litesql::Persistent(db), id(Id), type(Type), name(Name) {
defaults();
}
: litesql::Persistent(db, rec), id(Id), type(Type), name(Name) {
defaults();
size_t size = (rec.size() > 3) ? 3 : rec.size();
switch(size) {
case 3: name = convert<const std::string&, std::string>(rec[2]);
name.setModified(false);
case 2: type = convert<const std::string&, std::string>(rec[1]);
type.setModified(false);
id.setModified(false);
}
}
School::School(const School& obj)
: litesql::Persistent(obj), id(obj.id), type(obj.type), name(obj.name) {
}
const School& School::operator=(const School& obj) {
if (this != &obj) {
id = obj.id;
type = obj.type;
name = obj.name;
}
return *this;
}
School::StudentsHandle School::students() {
return School::StudentsHandle(*this);
}
std::string School::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(name.name());
values.push_back(name);
name.setModified(false);
fieldRecs.push_back(fields);
valueRecs.push_back(values);
return litesql::Persistent::insert(tables, fieldRecs, valueRecs, sequence__);
}
void School::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 School::addUpdates(Updates& updates) {
prepareUpdate(updates, table__);
updateField(updates, table__, id);
updateField(updates, table__, type);
updateField(updates, table__, name);
}
void School::addIDUpdates(Updates& updates) {
}
void School::getFieldTypes(std::vector<litesql::FieldType>& ftypes) {
ftypes.push_back(Id);
ftypes.push_back(Type);
ftypes.push_back(Name);
}
void School::delRecord() {
deleteFromTable(table__, id);
}
void School::delRelations() {
SchoolStudentRelation::del(*db, (SchoolStudentRelation::School == id));
}
void School::update() {
if (!inDatabase) {
create();
return;
}
Updates updates;
addUpdates(updates);
if (id != oldKey) {
if (!typeIsCorrect())
upcastCopy()->addIDUpdates(updates);
}
litesql::Persistent::update(updates);
oldKey = id;
}
void School::del() {
if (typeIsCorrect() == false) {
std::auto_ptr<School> p(upcastCopy());
p->delRelations();
p->onDelete();
p->delRecord();
} else {
onDelete();
delRecord();
}
inDatabase = false;
}
bool School::typeIsCorrect() {
return type == type__;
}
std::auto_ptr<School> School::upcast() {
return auto_ptr<School>(new School(*this));
}
std::auto_ptr<School> School::upcastCopy() {
School* np = new School(*this);
np->id = id;
np->type = type;
np->name = name;
np->inDatabase = inDatabase;
return auto_ptr<School>(np);
}
std::ostream & operator<<(std::ostream& os, School o) {
os << "-------------------------------------" << std::endl;
os << o.id.name() << " = " << o.id << std::endl;
os << o.type.name() << " = " << o.type << std::endl;
os << o.name.name() << " = " << o.name << std::endl;
os << "-------------------------------------" << std::endl;
return os;
}
Office::EmployeesHandle::EmployeesHandle(const Office& owner)
: litesql::RelationHandle<Office>(owner) {
}
void Office::EmployeesHandle::link(const Employee& o0) {
EmployeeOfficeRelation::link(owner->getDatabase(), o0, *owner);
}
void Office::EmployeesHandle::unlink(const Employee& o0) {
EmployeeOfficeRelation::unlink(owner->getDatabase(), o0, *owner);
}
EmployeeOfficeRelation::del(owner->getDatabase(), expr && EmployeeOfficeRelation::Office == owner->id);
}
litesql::DataSource<Employee> Office::EmployeesHandle::get(const litesql::Expr& expr, const litesql::Expr& srcExpr) {
return EmployeeOfficeRelation::get<Employee>(owner->getDatabase(), expr, (EmployeeOfficeRelation::Office == owner->id) && srcExpr);
}
litesql::DataSource<EmployeeOfficeRelation::Row> Office::EmployeesHandle::getRows(const litesql::Expr& expr) {
return EmployeeOfficeRelation::getRows(owner->getDatabase(), expr && (EmployeeOfficeRelation::Office == owner->id));
}
const std::string Office::type__("Office");
const std::string Office::table__("Office_");
const std::string Office::sequence__("Office_seq");
void Office::defaults() {
id = 0;
}
Office::Office(const litesql::Database& db)
: litesql::Persistent(db), id(Id), type(Type) {
defaults();
}
: litesql::Persistent(db, rec), id(Id), type(Type) {
defaults();
size_t size = (rec.size() > 2) ? 2 : rec.size();
switch(size) {
case 2: type = convert<const std::string&, std::string>(rec[1]);
type.setModified(false);
id.setModified(false);
}
}
Office::Office(const Office& obj)
: litesql::Persistent(obj), id(obj.id), type(obj.type) {
}
const Office& Office::operator=(const Office& obj) {
if (this != &obj) {
id = obj.id;
type = obj.type;
}
return *this;
}
Office::EmployeesHandle Office::employees() {
return Office::EmployeesHandle(*this);
}
std::string Office::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);
fieldRecs.push_back(fields);
valueRecs.push_back(values);
return litesql::Persistent::insert(tables, fieldRecs, valueRecs, sequence__);
}
void Office::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 Office::addUpdates(Updates& updates) {
prepareUpdate(updates, table__);
updateField(updates, table__, id);
updateField(updates, table__, type);
}
void Office::addIDUpdates(Updates& updates) {
}
void Office::getFieldTypes(std::vector<litesql::FieldType>& ftypes) {
ftypes.push_back(Id);
ftypes.push_back(Type);
}
void Office::delRecord() {
deleteFromTable(table__, id);
}
void Office::delRelations() {
EmployeeOfficeRelation::del(*db, (EmployeeOfficeRelation::Office == id));
}
void Office::update() {
if (!inDatabase) {
create();
return;
}
Updates updates;
addUpdates(updates);
if (id != oldKey) {
if (!typeIsCorrect())
upcastCopy()->addIDUpdates(updates);
}
litesql::Persistent::update(updates);
oldKey = id;
}
void Office::del() {
if (typeIsCorrect() == false) {
std::auto_ptr<Office> p(upcastCopy());
p->delRelations();
p->onDelete();
p->delRecord();
} else {
onDelete();
delRecord();
}
inDatabase = false;
}
bool Office::typeIsCorrect() {
return type == type__;
}
std::auto_ptr<Office> Office::upcast() {
return auto_ptr<Office>(new Office(*this));
}
std::auto_ptr<Office> Office::upcastCopy() {
Office* np = new Office(*this);
np->id = id;
np->type = type;
np->inDatabase = inDatabase;
return auto_ptr<Office>(np);
}
std::ostream & operator<<(std::ostream& os, Office o) {
os << "-------------------------------------" << std::endl;
os << o.id.name() << " = " << o.id << std::endl;
os << o.type.name() << " = " << o.type << std::endl;
os << "-------------------------------------" << std::endl;
return os;
}
const std::string ThingWithMethods::type__("ThingWithMethods");
const std::string ThingWithMethods::table__("ThingWithMethods_");
const std::string ThingWithMethods::sequence__("ThingWithMethods_seq");
void ThingWithMethods::defaults() {
id = 0;
}
ThingWithMethods::ThingWithMethods(const litesql::Database& db)
: litesql::Persistent(db), id(Id), type(Type) {
defaults();
}
: litesql::Persistent(db, rec), id(Id), type(Type) {
defaults();
size_t size = (rec.size() > 2) ? 2 : rec.size();
switch(size) {
case 2: type = convert<const std::string&, std::string>(rec[1]);
type.setModified(false);
id.setModified(false);
}
}
ThingWithMethods::ThingWithMethods(const ThingWithMethods& obj)
: litesql::Persistent(obj), id(obj.id), type(obj.type) {
}
const ThingWithMethods& ThingWithMethods::operator=(const ThingWithMethods& obj) {
if (this != &obj) {
id = obj.id;
type = obj.type;
}
return *this;
}
std::string ThingWithMethods::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);
fieldRecs.push_back(fields);
valueRecs.push_back(values);
return litesql::Persistent::insert(tables, fieldRecs, valueRecs, sequence__);
}
void ThingWithMethods::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 ThingWithMethods::addUpdates(Updates& updates) {
prepareUpdate(updates, table__);
updateField(updates, table__, id);
updateField(updates, table__, type);
}
void ThingWithMethods::addIDUpdates(Updates& updates) {
}
void ThingWithMethods::getFieldTypes(std::vector<litesql::FieldType>& ftypes) {
ftypes.push_back(Id);
ftypes.push_back(Type);
}
void ThingWithMethods::delRecord() {
deleteFromTable(table__, id);
}
void ThingWithMethods::delRelations() {
}
void ThingWithMethods::update() {
if (!inDatabase) {
create();
return;
}
Updates updates;
addUpdates(updates);
if (id != oldKey) {
if (!typeIsCorrect())
upcastCopy()->addIDUpdates(updates);
}
litesql::Persistent::update(updates);
oldKey = id;
}
void ThingWithMethods::del() {
if (typeIsCorrect() == false) {
std::auto_ptr<ThingWithMethods> p(upcastCopy());
p->delRelations();
p->onDelete();
p->delRecord();
} else {
onDelete();
delRecord();
}
inDatabase = false;
}
bool ThingWithMethods::typeIsCorrect() {
return type == type__;
}
std::auto_ptr<ThingWithMethods> ThingWithMethods::upcast() {
return auto_ptr<ThingWithMethods>(new ThingWithMethods(*this));
}
std::auto_ptr<ThingWithMethods> ThingWithMethods::upcastCopy() {
ThingWithMethods* np = new ThingWithMethods(*this);
np->id = id;
np->type = type;
np->inDatabase = inDatabase;
return auto_ptr<ThingWithMethods>(np);
}
std::ostream & operator<<(std::ostream& os, ThingWithMethods o) {
os << "-------------------------------------" << std::endl;
os << o.id.name() << " = " << o.id << std::endl;
os << o.type.name() << " = " << o.type << std::endl;
os << "-------------------------------------" << std::endl;
return os;
}
ExampleDatabase::ExampleDatabase(std::string backendType, std::string connInfo)
: litesql::Database(backendType, connInfo) {
initialize();
}
std::vector<litesql::Database::SchemaItem> ExampleDatabase::getSchema() const {
vector<Database::SchemaItem> res;
res.push_back(Database::SchemaItem("schema_","table","CREATE TABLE schema_ (name_ TEXT, type_ TEXT, sql_ TEXT);"));
if (backend->supportsSequences()) {
res.push_back(Database::SchemaItem("user_seq","sequence","CREATE SEQUENCE user_seq START 1 INCREMENT 1"));
res.push_back(Database::SchemaItem("Person_seq","sequence","CREATE SEQUENCE Person_seq START 1 INCREMENT 1"));
res.push_back(Database::SchemaItem("Role_seq","sequence","CREATE SEQUENCE Role_seq START 1 INCREMENT 1"));
res.push_back(Database::SchemaItem("School_seq","sequence","CREATE SEQUENCE School_seq START 1 INCREMENT 1"));
res.push_back(Database::SchemaItem("Office_seq","sequence","CREATE SEQUENCE Office_seq START 1 INCREMENT 1"));
res.push_back(Database::SchemaItem("ThingWithMethods_seq","sequence","CREATE SEQUENCE ThingWithMethods_seq START 1 INCREMENT 1"));
}
res.push_back(Database::SchemaItem("user_","table","CREATE TABLE user_ (id_ " + backend->getRowIDType() + ",type_ TEXT,name_ TEXT,passwd_ TEXT)"));
res.push_back(Database::SchemaItem("Person_","table","CREATE TABLE Person_ (id_ " + backend->getRowIDType() + ",type_ TEXT,name_ TEXT,age_ INTEGER,image_ BLOB,aDoubleValue_ DOUBLE,sex_ INTEGER)"));
res.push_back(Database::SchemaItem("Role_","table","CREATE TABLE Role_ (id_ " + backend->getRowIDType() + ",type_ TEXT)"));
res.push_back(Database::SchemaItem("Student_","table","CREATE TABLE Student_ (id_ " + backend->getRowIDType() + ")"));
res.push_back(Database::SchemaItem("Employee_","table","CREATE TABLE Employee_ (id_ " + backend->getRowIDType() + ")"));
res.push_back(Database::SchemaItem("School_","table","CREATE TABLE School_ (id_ " + backend->getRowIDType() + ",type_ TEXT,name_ TEXT)"));
res.push_back(Database::SchemaItem("Office_","table","CREATE TABLE Office_ (id_ " + backend->getRowIDType() + ",type_ TEXT)"));
res.push_back(Database::SchemaItem("ThingWithMethods_","table","CREATE TABLE ThingWithMethods_ (id_ " + backend->getRowIDType() + ",type_ TEXT)"));
res.push_back(Database::SchemaItem("Person_Person_Mother","table","CREATE TABLE Person_Person_Mother (Person1 INTEGER UNIQUE,Person2 INTEGER)"));
res.push_back(Database::SchemaItem("Person_Person_Father","table","CREATE TABLE Person_Person_Father (Person1 INTEGER UNIQUE,Person2 INTEGER)"));
res.push_back(Database::SchemaItem("Person_Person_Siblings","table","CREATE TABLE Person_Person_Siblings (Person1 INTEGER,Person2 INTEGER)"));
res.push_back(Database::SchemaItem("Person_Person_Children","table","CREATE TABLE Person_Person_Children (Person1 INTEGER,Person2 INTEGER)"));
res.push_back(Database::SchemaItem("Person_Role_Roles","table","CREATE TABLE Person_Role_Roles (Person1 INTEGER,Role2 INTEGER UNIQUE)"));
res.push_back(Database::SchemaItem("School_Student_","table","CREATE TABLE School_Student_ (School1 INTEGER,Student2 INTEGER UNIQUE)"));
res.push_back(Database::SchemaItem("Employee_Office_","table","CREATE TABLE Employee_Office_ (Employee1 INTEGER,Office2 INTEGER)"));
res.push_back(Database::SchemaItem("Person__name_age_idx","index","CREATE UNIQUE INDEX Person__name_age_idx ON Person_ (name_,age_)"));
res.push_back(Database::SchemaItem("Person_Person_MotherPerson1idx","index","CREATE INDEX Person_Person_MotherPerson1idx ON Person_Person_Mother (Person1)"));
res.push_back(Database::SchemaItem("Person_Person_MotherPerson2idx","index","CREATE INDEX Person_Person_MotherPerson2idx ON Person_Person_Mother (Person2)"));
res.push_back(Database::SchemaItem("Person_Person_Mother_all_idx","index","CREATE INDEX Person_Person_Mother_all_idx ON Person_Person_Mother (Person1,Person2)"));
res.push_back(Database::SchemaItem("Person_Person_FatherPerson1idx","index","CREATE INDEX Person_Person_FatherPerson1idx ON Person_Person_Father (Person1)"));
res.push_back(Database::SchemaItem("Person_Person_FatherPerson2idx","index","CREATE INDEX Person_Person_FatherPerson2idx ON Person_Person_Father (Person2)"));
res.push_back(Database::SchemaItem("Person_Person_Father_all_idx","index","CREATE INDEX Person_Person_Father_all_idx ON Person_Person_Father (Person1,Person2)"));
res.push_back(Database::SchemaItem("_fc4501d1c1e9cc173fbe356a08a9d12f","index","CREATE INDEX _fc4501d1c1e9cc173fbe356a08a9d12f ON Person_Person_Siblings (Person1)"));
res.push_back(Database::SchemaItem("_29908e51ecc673e39c38238d4abe5b3b","index","CREATE INDEX _29908e51ecc673e39c38238d4abe5b3b ON Person_Person_Siblings (Person2)"));
res.push_back(Database::SchemaItem("Person_Person_Siblings_all_idx","index","CREATE INDEX Person_Person_Siblings_all_idx ON Person_Person_Siblings (Person1,Person2)"));
res.push_back(Database::SchemaItem("_c77a0c252bbee950ec06bda52dd09648","index","CREATE INDEX _c77a0c252bbee950ec06bda52dd09648 ON Person_Person_Children (Person1)"));
res.push_back(Database::SchemaItem("_64f9014350ce47b5d0f7606b127df7c3","index","CREATE INDEX _64f9014350ce47b5d0f7606b127df7c3 ON Person_Person_Children (Person2)"));
res.push_back(Database::SchemaItem("Person_Person_Children_all_idx","index","CREATE INDEX Person_Person_Children_all_idx ON Person_Person_Children (Person1,Person2)"));
res.push_back(Database::SchemaItem("Person_Role_RolesPerson1idx","index","CREATE INDEX Person_Role_RolesPerson1idx ON Person_Role_Roles (Person1)"));
res.push_back(Database::SchemaItem("Person_Role_RolesRole2idx","index","CREATE INDEX Person_Role_RolesRole2idx ON Person_Role_Roles (Role2)"));
res.push_back(Database::SchemaItem("Person_Role_Roles_all_idx","index","CREATE INDEX Person_Role_Roles_all_idx ON Person_Role_Roles (Person1,Role2)"));
res.push_back(Database::SchemaItem("School_Student_School1idx","index","CREATE INDEX School_Student_School1idx ON School_Student_ (School1)"));
res.push_back(Database::SchemaItem("School_Student_Student2idx","index","CREATE INDEX School_Student_Student2idx ON School_Student_ (Student2)"));
res.push_back(Database::SchemaItem("School_Student__all_idx","index","CREATE INDEX School_Student__all_idx ON School_Student_ (School1,Student2)"));
res.push_back(Database::SchemaItem("Employee_Office_Employee1idx","index","CREATE INDEX Employee_Office_Employee1idx ON Employee_Office_ (Employee1)"));
res.push_back(Database::SchemaItem("Employee_Office_Office2idx","index","CREATE INDEX Employee_Office_Office2idx ON Employee_Office_ (Office2)"));
res.push_back(Database::SchemaItem("Employee_Office__all_idx","index","CREATE INDEX Employee_Office__all_idx ON Employee_Office_ (Employee1,Office2)"));
return res;
}
void ExampleDatabase::initialize() {
static bool initialized = false;
if (initialized)
return;
initialized = true;
Person::initValues();
}
}
intermediate representation of single entity in relational database, table, index or sequence
Definition database.hpp:53
void insert(const string &table, const Record &r, const Split &fields=Split()) const
executes SQL INSERT statement.
Definition database.cpp:226
void delete_(const string &table, const Expr &e=Expr()) const
deletes rows from single table, deleted rows are selected by Expr if specified
Definition database.cpp:252
const Persistent & operator=(const Persistent &p)
copies values and keeps fields unchanged
Definition persistent.cpp:14
std::string insert(Record &tables, Records &fieldRecs, Records &values, const std::string &sequence)
executed when object is created into database
Definition persistent.cpp:23
base class of relation handles attached to Persistent objects
Definition relation.hpp:17
litesql::DataSource< T > select(const litesql::Database &db, const litesql::Expr &e=litesql::Expr())
returns DataSource for accessing objects of type T
Definition operations.hpp:16
Mapping Objects to Relational Database
Fields of multiple Persistent-classes are stored in separate tables. Each Persistent-class has its own table. Also, each relation is stored in separate table. An example database demonstrates data mapping.
<database name="example">
<object name="Playable">
<field name="name" type="string"/>
<method name="play"/>
</object>
<object name="AudioFile" inherits="Playable">
<field name="file" type="string"/>
<method name="play"/>
</object>
<object name="Collection">
<field name="description" type="string"/>
</object>
<relation>
<relate object="AudioFile" handle="collections"/>
<relate object="Collection" handle="files"/>
<field name="percent" type="integer" default="100"/>
</relation>
</database>
The database schema extracted from definitions above is similar to following:
CREATE TABLE Playable_ (id_ INTEGER PRIMARY KEY, type_ TEXT, name_ TEXT);
CREATE TABLE AudioFile_ (id_ INTEGER PRIMARY KEY, file_ TEXT);
CREATE TABLE Collection_ (id_ INTEGER PRIMARY KEY, type_ TEXT, description_ TEXT);
CREATE TABLE AudioFile_Collection_ (AudioFile1 INTEGER, Collection2 INTEGER, percent_ INTEGER);
-- original name: idx_AudioFile_Collection_AudioFile1
CREATE INDEX _71b11d59ca507479edd464e053cd01 ON AudioFile_Collection_ (AudioFile1);
-- original name: idx_AudioFile_Collection_Collection2
CREATE INDEX _e1305d9ca2d1c6947b38fc301ad676 ON AudioFile_Collection_ (Collection2);
-- original name: idx_AudioFile_Collection_AudioFile1_Collection2
CREATE INDEX _7e632b2ede1b6f3348d36e44e443d0 ON AudioFile_Collection_ (AudioFile1,Collection2);
The relation table AudioFile_Collection_ is indexed by both of its fields. If table or index identifier is longer than 31 characters, it will be truncated by calculating MD5-sum of the identifier because all backends do not support longer identifiers (certain PostgreSQL - versions at least).
Fields in tables of Persistent classes and relation attributes (extra fields in relation tables) are postfixed with an underscore to allow usage of SQL's reserved words in identifiers.
Virtual Methods
Using database defined in previous section, suppose one needs to select a Playable from database and play() it. The routine selecting and playing the Playable cannot know the actual type of the Playable.
After Playable-object is selected from database it really is a Playable despite it was stored as an AudioFile for example.
In order to retrieve all fields that AudioFile has, the Playable object needs to be upcasted.
AudioFile af(db);
af.name = "A good song";
af.file = "goodsong.mp3";
af.update();
Playable p = select<Playable>(db, Playable::Name == "A good song").one()
// p has only one field: name
p.upcast().play();
// this executes actually select<AudioFile>(db, Playable::Id == x).one().play();
The code generator (litesql-gen) writes upcast-method that returns object of correct type.
Sometimes extra fields that an inherited Persistent may have are not needed when accessing virtual methods. It would be futile to execute SQL statements. Another upcaster function is provided to help in this situation.
For example, onDelete() - may not need any fields. del() - method that calls onDelete() uses upcastCopy() to access onDelete() of inherited Persistent.
// same Playable is selected as in above example
p.upcastCopy()->makeLogEntry(log)
Note that upcastCopy will return a Persistent whose all fields are not retrieved from database.