diff options
Diffstat (limited to 'odb-tests/common/virtual')
-rw-r--r-- | odb-tests/common/virtual/buildfile | 42 | ||||
-rw-r--r-- | odb-tests/common/virtual/driver.cxx | 154 | ||||
-rw-r--r-- | odb-tests/common/virtual/test.hxx | 171 | ||||
-rw-r--r-- | odb-tests/common/virtual/testscript | 33 |
4 files changed, 400 insertions, 0 deletions
diff --git a/odb-tests/common/virtual/buildfile b/odb-tests/common/virtual/buildfile new file mode 100644 index 0000000..96d062e --- /dev/null +++ b/odb-tests/common/virtual/buildfile @@ -0,0 +1,42 @@ +# file : common/virtual/buildfile +# license : GNU GPL v2; see accompanying LICENSE file + +import libodb = libodb%lib{odb} + +libs = + +for db: $databases + import libs += libodb-$db%lib{odb-$db} + +import libs += lib{common} + +exe{driver}: {hxx cxx}{* -*-odb -*-odb-*} {hxx ixx cxx}{test-odb} testscript + +# Introduce the metadata library target to make sure the libodb library is +# resolved for the odb_compile ad hoc rule (see build/root.build for details). +# +libue{test-meta}: $libodb + +<{hxx ixx cxx}{test-odb}>: hxx{test} libue{test-meta} + +for db: $databases +{ + exe{driver}: {hxx ixx cxx}{test-odb-$db}: include = $multi + <{hxx ixx cxx}{test-odb-$db}>: hxx{test} libue{test-meta} +} + +exe{driver}: libue{test-meta} $libs + +# Specify the ODB custom options to be used by the odb_compile ad hoc rule +# (see build/root.build for details). +# +odb_options = --table-prefix virtual_ \ + --generate-schema \ + --generate-query \ + --generate-session + +cxx.poptions =+ "-I$out_base" "-I$src_base" + +# Testscript's run-time prerequisites. +# +exe{driver}: ../../alias{database-client}: include = adhoc diff --git a/odb-tests/common/virtual/driver.cxx b/odb-tests/common/virtual/driver.cxx new file mode 100644 index 0000000..f96f543 --- /dev/null +++ b/odb-tests/common/virtual/driver.cxx @@ -0,0 +1,154 @@ +// file : common/virtual/driver.cxx +// license : GNU GPL v2; see accompanying LICENSE file + +// Test virtual data members. +// + +#include <memory> // std::auto_ptr +#include <iostream> + +#include <odb/session.hxx> +#include <odb/database.hxx> +#include <odb/transaction.hxx> + +#include <libcommon/common.hxx> + +#include "test.hxx" +#include "test-odb.hxx" + +#undef NDEBUG +#include <cassert> + +using namespace std; +using namespace odb::core; + +int +main (int argc, char* argv[]) +{ + try + { + unique_ptr<database> db (create_database (argc, argv)); + + // Test basic virtual data member functionality. + // + { + using namespace test1; + + object o; + o.i (123); + o.c1.i = 123; + o.c1.s = "abc"; + o.v1.push_back ("abc"); + o.v1.push_back ("abd"); + o.v1.push_back ("abe"); + o.p1 = new object; + + { + transaction t (db->begin ()); + db->persist (*o.p1); + db->persist (o); + t.commit (); + } + + { + transaction t (db->begin ()); + unique_ptr<object> p (db->load<object> (o.id1.v)); + t.commit (); + + assert (o == *p); + } + } + + // Test pragma resolution to virtual data member. + // + { + using namespace test2; + + object1 o1 (1); + o1.o2 = new object2 (1); + o1.o2->o1 = &o1; + + { + transaction t (db->begin ()); + db->persist (*o1.o2); + o1.n1 = o1.o2->id; + db->persist (o1); + t.commit (); + } + + { + session s; + transaction t (db->begin ()); + unique_ptr<object1> p (db->load<object1> (o1.id)); + t.commit (); + + assert (p->o2->id == o1.o2->id); + } + + { + typedef odb::query<view1> query; + typedef odb::result<view1> result; + + transaction t (db->begin ()); + result r (db->query<view1> (query::object2::id == o1.o2->id)); + result::iterator i (r.begin ()); + assert (i != r.end () && i->i == o1.n1); + assert (++i == r.end ()); + t.commit (); + } + + { + typedef odb::query<view2> query; + typedef odb::result<view2> result; + + transaction t (db->begin ()); + result r (db->query<view2> (query::o2::id == o1.o2->id)); + result::iterator i (r.begin ()); + assert (i != r.end () && i->i == o1.n1); + assert (++i == r.end ()); + t.commit (); + } + + { + typedef odb::result<view3> result; + + transaction t (db->begin ()); + result r (db->query<view3> ()); + result::iterator i (r.begin ()); + assert (i != r.end () && i->i == o1.n1); + assert (++i == r.end ()); + t.commit (); + } + } + + // Use virtual data members to implement multi-member composite object id. + // + { + using namespace test3; + + person o; + o.first_ = "John"; + o.last_ = "Doe"; + + name id; + { + transaction t (db->begin ()); + id = db->persist (o); + t.commit (); + } + + { + transaction t (db->begin ()); + unique_ptr<person> p (db->load<person> (id)); + t.commit (); + + assert (o.first_ == p->first_ && o.last_ == p->last_); + } + } + } + catch (const odb::exception& e) + { + cerr << e.what () << endl; + return 1; + } +} diff --git a/odb-tests/common/virtual/test.hxx b/odb-tests/common/virtual/test.hxx new file mode 100644 index 0000000..2654d09 --- /dev/null +++ b/odb-tests/common/virtual/test.hxx @@ -0,0 +1,171 @@ +// file : common/virtual/test.hxx +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef TEST_HXX +#define TEST_HXX + +#include <string> +#include <vector> + +#include <odb/core.hxx> + +// Test basic virtual data member functionality. +// +#pragma db namespace table("t1_") +namespace test1 +{ + #pragma db value + struct comp + { + int i; + + #pragma db transient + std::string s; + #pragma db member(s_) virtual(std::string) access(s) + + bool operator== (const comp& v) const + { + return i == v.i && s == v.s; + } + }; + + #pragma db object transient + struct object + { + object (): p1 (0) {} + ~object () {delete p1;} + + struct {unsigned long v;} id1; + + #pragma db id + #pragma db member(id) get(id1.v) virtual(unsigned long) set(id1.v) + #pragma db member(id) auto + + int i () const {return i1;} + void i (int i) {i1 = i;} + int i1; + + comp c1; + #pragma db member(c) virtual(comp) access(c1) + + typedef std::vector<std::string> strings; + strings v1; + #pragma db member(v) virtual(strings) access(v1) + + typedef object* object_ptr; + object_ptr p1; + #pragma db member(p) virtual(object_ptr) access(p1) + + bool operator== (const object& o) const + { + return id1.v == o.id1.v && + i1 == o.i1 && + c1 == o.c1 && + v1 == o.v1 && + (p1 != 0 ? o.p1 != 0 && *p1 == *o.p1 : o.p1 == 0); + } + }; + + #pragma db member(object::i) virtual(int) +} + +#pragma db member(test1::object::id) column("oid") + +// Test pragma resolution to virtual data member. +// +#pragma db namespace table("t2_") +namespace test2 +{ + struct object1; + struct object2; + + typedef object1* object1_ptr; + typedef object2* object2_ptr; + + #pragma db object + struct object2 + { + object2 (unsigned long i = 0): id (i) {} + + #pragma db id + unsigned long id; + + #pragma db inverse(o) + object1_ptr o1; + }; + + #pragma db object + struct object1 + { + object1 (unsigned long i = 0): id (i), o2 (0) {} + ~object1 () {delete o2;} + + #pragma db id + unsigned long id; + + #pragma db transient + object2_ptr o2; + #pragma db member(o) virtual(object2_ptr) access(o2) + + #pragma db transient + unsigned long n1; + #pragma db member(n) virtual(unsigned long) access(n1) + #pragma db index member(n) + }; + + #pragma db view object(object1) object(object2) + struct view1 + { + #pragma db column(object1::n) + unsigned long i; + }; + + #pragma db view object(object1 = o1) object(object2 = o2: o1::n == o2::id) + struct view2 + { + #pragma db column(o1::n) + unsigned long i; + }; + + #pragma db view object(object1: object1::n != 0) + struct view3 + { + #pragma db column(test2::object1::n) + unsigned long i; + }; +} + +// Use virtual data members to implement multi-member composite object id. +// +#pragma db namespace table("t3_") +namespace test3 +{ + #pragma db value + struct name + { + name () {} + name (const std::string& f, const std::string& l) + : first (f), last(l) {} + + std::string first; + std::string last; + + bool operator< (const name& x) const + { + return first < x.first || (first == x.first && last < x.last); + } + }; + + #pragma db object transient + struct person + { + std::string first_; + std::string last_; + + #pragma db member(name) virtual(name) id \ + get(::test3::name (this.first_, this.last_)) \ + set(this.first_ = (?).first; this.last_ = (?).last) + }; +} + +#endif // TEST_HXX diff --git a/odb-tests/common/virtual/testscript b/odb-tests/common/virtual/testscript new file mode 100644 index 0000000..769c7f9 --- /dev/null +++ b/odb-tests/common/virtual/testscript @@ -0,0 +1,33 @@ +# file : common/virtual/testscript +# license : GNU GPL v2; see accompanying LICENSE file + +.include ../../database-options.testscript + +: mysql +: +if $mysql +{ + .include ../../mysql.testscript + + $create_schema; + $* +} + +: sqlite +: +if $sqlite +{ + .include ../../sqlite.testscript + + $* +} + +: pgsql +: +if $pgsql +{ + .include ../../pgsql.testscript + + $create_schema; + $* +} |