From 08a47c70ad517b80b72914d47d547463f576bcd3 Mon Sep 17 00:00:00 2001 From: Boris Kolpackov Date: Mon, 24 Oct 2011 16:32:51 +0200 Subject: Generate database schema from database model instead of C++ model We now first create the so-called database model from C++ model and then use that to generate the database schema. The new approach also adds more general support for primary/foreign keys, including multi- column keys. Finally, for MySQL we now generate out-of-line foreign key definitions. Because MySQL does not support deferred constraints checking, deferred foreign keys are written commented out, for documentation. --- odb/semantics/relational.hxx | 18 ++ odb/semantics/relational/column.cxx | 35 ++++ odb/semantics/relational/column.hxx | 118 +++++++++++++ odb/semantics/relational/elements.cxx | 137 +++++++++++++++ odb/semantics/relational/elements.hxx | 277 +++++++++++++++++++++++++++++++ odb/semantics/relational/foreign-key.cxx | 35 ++++ odb/semantics/relational/foreign-key.hxx | 87 ++++++++++ odb/semantics/relational/index.cxx | 35 ++++ odb/semantics/relational/index.hxx | 44 +++++ odb/semantics/relational/key.cxx | 43 +++++ odb/semantics/relational/key.hxx | 100 +++++++++++ odb/semantics/relational/model.cxx | 35 ++++ odb/semantics/relational/model.hxx | 39 +++++ odb/semantics/relational/primary-key.cxx | 35 ++++ odb/semantics/relational/primary-key.hxx | 45 +++++ odb/semantics/relational/table.cxx | 52 ++++++ odb/semantics/relational/table.hxx | 56 +++++++ 17 files changed, 1191 insertions(+) create mode 100644 odb/semantics/relational.hxx create mode 100644 odb/semantics/relational/column.cxx create mode 100644 odb/semantics/relational/column.hxx create mode 100644 odb/semantics/relational/elements.cxx create mode 100644 odb/semantics/relational/elements.hxx create mode 100644 odb/semantics/relational/foreign-key.cxx create mode 100644 odb/semantics/relational/foreign-key.hxx create mode 100644 odb/semantics/relational/index.cxx create mode 100644 odb/semantics/relational/index.hxx create mode 100644 odb/semantics/relational/key.cxx create mode 100644 odb/semantics/relational/key.hxx create mode 100644 odb/semantics/relational/model.cxx create mode 100644 odb/semantics/relational/model.hxx create mode 100644 odb/semantics/relational/primary-key.cxx create mode 100644 odb/semantics/relational/primary-key.hxx create mode 100644 odb/semantics/relational/table.cxx create mode 100644 odb/semantics/relational/table.hxx (limited to 'odb/semantics') diff --git a/odb/semantics/relational.hxx b/odb/semantics/relational.hxx new file mode 100644 index 0000000..0d3d06c --- /dev/null +++ b/odb/semantics/relational.hxx @@ -0,0 +1,18 @@ +// file : odb/semantics/relational.hxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#ifndef ODB_SEMANTICS_RELATIONAL_HXX +#define ODB_SEMANTICS_RELATIONAL_HXX + +#include +#include +#include +#include +#include +#include +#include +#include + +#endif // ODB_SEMANTICS_RELATIONAL_HXX diff --git a/odb/semantics/relational/column.cxx b/odb/semantics/relational/column.cxx new file mode 100644 index 0000000..99df5d9 --- /dev/null +++ b/odb/semantics/relational/column.cxx @@ -0,0 +1,35 @@ +// file : odb/semantics/relational/column.cxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#include + +#include + +namespace semantics +{ + namespace relational + { + // type info + // + namespace + { + struct init + { + init () + { + using compiler::type_info; + + // column + // + { + type_info ti (typeid (column)); + ti.add_base (typeid (nameable)); + insert (ti); + } + } + } init_; + } + } +} diff --git a/odb/semantics/relational/column.hxx b/odb/semantics/relational/column.hxx new file mode 100644 index 0000000..a1024cf --- /dev/null +++ b/odb/semantics/relational/column.hxx @@ -0,0 +1,118 @@ +// file : odb/semantics/relational/column.hxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#ifndef ODB_SEMANTICS_RELATIONAL_COLUMN_HXX +#define ODB_SEMANTICS_RELATIONAL_COLUMN_HXX + +#include +#include + +namespace semantics +{ + namespace relational + { + class contains; + + class column: public nameable + { + typedef std::vector contained_list; + + public: + column (string const& id, string const& type, bool null) + : nameable (id), type_ (type), null_ (null) + { + } + + string const& + type () const + { + return type_; + } + + bool + null () const + { + return null_; + } + + string const& + default_ () const + { + return default__; + } + + void + default_ (string const& d) + { + default__ = d; + } + + string const& + options () const + { + return options_; + } + + void + options (string const& o) + { + options_ = o; + } + + public: + typedef relational::table table_type; + + table_type& + table () const + { + return dynamic_cast (scope ()); + } + + // Key containment. + // + public: + typedef + pointer_iterator + contained_iterator; + + contained_iterator + contained_begin () const + { + return contained_.begin (); + } + + contained_iterator + contained_end () const + { + return contained_.end (); + } + + public: + void + add_edge_right (contains& e) + { + contained_.push_back (&e); + } + + using nameable::add_edge_right; + + virtual string + kind () const + { + return "column"; + } + + private: + string type_; + bool null_; + string default__; + string options_; + + contained_list contained_; + }; + } +} + +#endif // ODB_SEMANTICS_RELATIONAL_COLUMN_HXX diff --git a/odb/semantics/relational/elements.cxx b/odb/semantics/relational/elements.cxx new file mode 100644 index 0000000..6ab977a --- /dev/null +++ b/odb/semantics/relational/elements.cxx @@ -0,0 +1,137 @@ +// file : odb/semantics/relational/elements.cxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#include + +#include +#include +#include + +namespace semantics +{ + namespace relational + { + // scope + // + + scope::names_iterator scope:: + find (string const& name) + { + names_map::iterator i (names_map_.find (name)); + + if (i == names_map_.end ()) + return names_.end (); + else + return i->second; + } + + scope::names_const_iterator scope:: + find (string const& name) const + { + names_map::const_iterator i (names_map_.find (name)); + + if (i == names_map_.end ()) + return names_.end (); + else + return names_const_iterator (i->second); + } + + scope::names_iterator scope:: + find (names const& e) + { + names_iterator_map::iterator i (iterator_map_.find (&e)); + return i != iterator_map_.end () ? i->second : names_.end (); + } + + scope::names_const_iterator scope:: + find (names const& e) const + { + names_iterator_map::const_iterator i (iterator_map_.find (&e)); + return i != iterator_map_.end () ? i->second : names_.end (); + } + + void scope:: + add_edge_left (names& e) + { + nameable& n (e.nameable ()); + string const& name (e.name ()); + + names_map::iterator i (names_map_.find (name)); + + if (i == names_map_.end ()) + { + names_list::iterator i; + + // We want the order to be columns first, then the primary key, + // and then the foreign keys. + // + if (n.is_a ()) + i = names_.insert (first_key_, &e); + else + { + if (n.is_a ()) + first_key_ = i = names_.insert (first_key_, &e); + else + { + i = names_.insert (names_.end (), &e); + + if (first_key_ == names_.end ()) + first_key_ = i; + } + } + + names_map_[name] = i; + iterator_map_[&e] = i; + } + else + throw duplicate_name (*this, (*i->second)->nameable (), n); + } + + // type info + // + namespace + { + struct init + { + init () + { + using compiler::type_info; + + // node + // + insert (type_info (typeid (node))); + + // edge + // + insert (type_info (typeid (edge))); + + // names + // + { + type_info ti (typeid (names)); + ti.add_base (typeid (edge)); + insert (ti); + } + + // nameable + // + { + type_info ti (typeid (nameable)); + ti.add_base (typeid (node)); + insert (ti); + } + + // scope + // + { + type_info ti (typeid (scope)); + ti.add_base (typeid (node)); + insert (ti); + } + } + } init_; + } + } +} diff --git a/odb/semantics/relational/elements.hxx b/odb/semantics/relational/elements.hxx new file mode 100644 index 0000000..d07902d --- /dev/null +++ b/odb/semantics/relational/elements.hxx @@ -0,0 +1,277 @@ +// file : odb/semantics/relational/elements.hxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#ifndef ODB_SEMANTICS_RELATIONAL_ELEMENTS_HXX +#define ODB_SEMANTICS_RELATIONAL_ELEMENTS_HXX + +#include +#include +#include +#include +#include + +#include +#include +#include + +namespace semantics +{ + namespace relational + { + using namespace cutl; + + using std::string; + + using container::graph; + using container::pointer_iterator; + + using compiler::context; + + // + // + class node; + class edge; + + // + // + class edge: public context + { + public: + virtual + ~edge () {} + + public: + template + bool + is_a () const + { + return dynamic_cast (this) != 0; + } + }; + + // + // + class node: public context + { + public: + virtual + ~node () {} + + // Return name of the node. + // + virtual string + kind () const = 0; + + public: + template + bool + is_a () const + { + return dynamic_cast (this) != 0; + } + + // Sink functions that allow extensions in the form of one-way + // edges. + // + public: + void + add_edge_right (edge&) + { + } + }; + + // + // + class scope; + class nameable; + + // + // + class names: public edge + { + public: + typedef relational::scope scope_type; + typedef relational::nameable nameable_type; + + string const& + name () const + { + return name_; + } + + scope_type& + scope () const + { + return *scope_; + } + + nameable_type& + nameable () const + { + return *nameable_; + } + + public: + names (string const& name): name_ (name) {} + + void + set_left_node (scope_type& n) + { + scope_ = &n; + } + + void + set_right_node (nameable_type& n) + { + nameable_ = &n; + } + + protected: + string name_; + scope_type* scope_; + nameable_type* nameable_; + }; + + // + // + class nameable: public virtual node + { + public: + typedef relational::scope scope_type; + + string const& + name () const + { + return named_->name (); + } + + scope_type& + scope () const + { + return named ().scope (); + } + + names& + named () const + { + return *named_; + } + + public: + // Id identifies the C++ node (e.g., a class or a data member) that + // this model node corresponds to. The ids are not necessarily unique + // (e.g., there can be a table and an index with the same id that + // correspond to a container member). However, in any given scope, + // the {id,typeid} must be unique. This becomes important when we + // try to find correspondance between nodes during model diff'ing. + // + nameable (string const& id): id_ (id), named_ (0) {} + + void + add_edge_right (names& e) + { + assert (named_ == 0); + named_ = &e; + } + + using node::add_edge_right; + + private: + string id_; + names* named_; + }; + + + // + // + struct duplicate_name + { + typedef relational::scope scope_type; + typedef relational::nameable nameable_type; + + duplicate_name (scope_type& s, nameable_type& n, nameable_type& d) + : scope (s), nameable (n), duplicate (d) + { + } + + scope_type& scope; + nameable_type& nameable; + nameable_type& duplicate; + }; + + class scope: public virtual node + { + protected: + typedef std::list names_list; + typedef std::map names_map; + typedef std::map names_iterator_map; + + public: + typedef pointer_iterator names_iterator; + typedef + pointer_iterator + names_const_iterator; + + public: + // Iteration. + // + names_iterator + names_begin () + { + return names_.begin (); + } + + names_iterator + names_end () + { + return names_.end (); + } + + names_const_iterator + names_begin () const + { + return names_.begin (); + } + + names_const_iterator + names_end () const + { + return names_.end (); + } + + // Find. + // + names_iterator + find (string const& name); + + names_const_iterator + find (string const& name) const; + + names_iterator + find (names const&); + + names_const_iterator + find (names const&) const; + + public: + scope () + : first_key_ (names_.end ()) + { + } + + void + add_edge_left (names&); + + private: + names_list names_; + names_map names_map_; + names_iterator_map iterator_map_; + + names_list::iterator first_key_; + }; + } +} + +#endif // ODB_SEMANTICS_RELATIONAL_ELEMENTS_HXX diff --git a/odb/semantics/relational/foreign-key.cxx b/odb/semantics/relational/foreign-key.cxx new file mode 100644 index 0000000..eae9c5f --- /dev/null +++ b/odb/semantics/relational/foreign-key.cxx @@ -0,0 +1,35 @@ +// file : odb/semantics/relational/foreign-key.cxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#include + +#include + +namespace semantics +{ + namespace relational + { + // type info + // + namespace + { + struct init + { + init () + { + using compiler::type_info; + + // foreign_key + // + { + type_info ti (typeid (foreign_key)); + ti.add_base (typeid (key)); + insert (ti); + } + } + } init_; + } + } +} diff --git a/odb/semantics/relational/foreign-key.hxx b/odb/semantics/relational/foreign-key.hxx new file mode 100644 index 0000000..4a0b543 --- /dev/null +++ b/odb/semantics/relational/foreign-key.hxx @@ -0,0 +1,87 @@ +// file : odb/semantics/relational/foreign-key.hxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#ifndef ODB_SEMANTICS_RELATIONAL_FOREIGN_KEY_HXX +#define ODB_SEMANTICS_RELATIONAL_FOREIGN_KEY_HXX + +#include +#include + +namespace semantics +{ + namespace relational + { + class foreign_key: public key + { + public: + enum action + { + no_action, + cascade + }; + + foreign_key (string const& id, + string const& referenced_table, + bool deferred, + action on_delete = no_action) + : key (id), + referenced_table_ (referenced_table), + deferred_ (deferred), + on_delete_ (on_delete) + { + } + + public: + string + referenced_table () const + { + return referenced_table_; + } + + typedef std::vector columns; + + columns const& + referenced_columns () const + { + return referenced_columns_; + } + + columns& + referenced_columns () + { + return referenced_columns_; + } + + public: + bool + deferred () const + { + return deferred_; + } + + public: + action + on_delete () const + { + return on_delete_; + } + + public: + virtual string + kind () const + { + return "foreign key"; + } + + private: + string referenced_table_; + columns referenced_columns_; + bool deferred_; + action on_delete_; + }; + } +} + +#endif // ODB_SEMANTICS_RELATIONAL_FOREIGN_KEY_HXX diff --git a/odb/semantics/relational/index.cxx b/odb/semantics/relational/index.cxx new file mode 100644 index 0000000..376a312 --- /dev/null +++ b/odb/semantics/relational/index.cxx @@ -0,0 +1,35 @@ +// file : odb/semantics/relational/index.cxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#include + +#include + +namespace semantics +{ + namespace relational + { + // type info + // + namespace + { + struct init + { + init () + { + using compiler::type_info; + + // index + // + { + type_info ti (typeid (index)); + ti.add_base (typeid (key)); + insert (ti); + } + } + } init_; + } + } +} diff --git a/odb/semantics/relational/index.hxx b/odb/semantics/relational/index.hxx new file mode 100644 index 0000000..ee6b202 --- /dev/null +++ b/odb/semantics/relational/index.hxx @@ -0,0 +1,44 @@ +// file : odb/semantics/relational/index.hxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#ifndef ODB_SEMANTICS_RELATIONAL_INDEX_HXX +#define ODB_SEMANTICS_RELATIONAL_INDEX_HXX + +#include +#include +#include + +namespace semantics +{ + namespace relational + { + // Note that unlike other keys, indexes are defined in the model + // scope, not table scope. + // + class index: public key + { + public: + relational::table& + table () const + { + return contains_begin ()->column ().table (); + } + + public: + index (string const& id) + : key (id) + { + } + + virtual string + kind () const + { + return "index"; + } + }; + } +} + +#endif // ODB_SEMANTICS_RELATIONAL_INDEX_HXX diff --git a/odb/semantics/relational/key.cxx b/odb/semantics/relational/key.cxx new file mode 100644 index 0000000..648fb26 --- /dev/null +++ b/odb/semantics/relational/key.cxx @@ -0,0 +1,43 @@ +// file : odb/semantics/relational/key.cxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#include + +#include + +namespace semantics +{ + namespace relational + { + // type info + // + namespace + { + struct init + { + init () + { + using compiler::type_info; + + // contains + // + { + type_info ti (typeid (contains)); + ti.add_base (typeid (edge)); + insert (ti); + } + + // key + // + { + type_info ti (typeid (key)); + ti.add_base (typeid (nameable)); + insert (ti); + } + } + } init_; + } + } +} diff --git a/odb/semantics/relational/key.hxx b/odb/semantics/relational/key.hxx new file mode 100644 index 0000000..7e7a847 --- /dev/null +++ b/odb/semantics/relational/key.hxx @@ -0,0 +1,100 @@ +// file : odb/semantics/relational/key.hxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#ifndef ODB_SEMANTICS_RELATIONAL_KEY_HXX +#define ODB_SEMANTICS_RELATIONAL_KEY_HXX + +#include +#include + +namespace semantics +{ + namespace relational + { + class key; + + class contains: public edge + { + public: + typedef relational::key key_type; + typedef relational::column column_type; + + key_type& + key () const + { + return *key_; + } + + column_type& + column () const + { + return *column_; + } + + public: + void + set_left_node (key_type& n) + { + key_ = &n; + } + + void + set_right_node (column_type& n) + { + column_ = &n; + } + + protected: + key_type* key_; + column_type* column_; + }; + + class key: public nameable + { + typedef std::vector contains_list; + + public: + typedef + pointer_iterator + contains_iterator; + + contains_iterator + contains_begin () const + { + return contains_.begin (); + } + + contains_iterator + contains_end () const + { + return contains_.end (); + } + + contains_list::size_type + contains_size () const + { + return contains_.size (); + } + + public: + void + add_edge_left (contains& e) + { + contains_.push_back (&e); + } + + protected: + key (string const& id) + : nameable (id) + { + } + + private: + contains_list contains_; + }; + } +} + +#endif // ODB_SEMANTICS_RELATIONAL_KEY_HXX diff --git a/odb/semantics/relational/model.cxx b/odb/semantics/relational/model.cxx new file mode 100644 index 0000000..a0ac23f --- /dev/null +++ b/odb/semantics/relational/model.cxx @@ -0,0 +1,35 @@ +// file : odb/semantics/relational/model.cxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#include + +#include + +namespace semantics +{ + namespace relational + { + // type info + // + namespace + { + struct init + { + init () + { + using compiler::type_info; + + // model + // + { + type_info ti (typeid (model)); + ti.add_base (typeid (scope)); + insert (ti); + } + } + } init_; + } + } +} diff --git a/odb/semantics/relational/model.hxx b/odb/semantics/relational/model.hxx new file mode 100644 index 0000000..7d2f944 --- /dev/null +++ b/odb/semantics/relational/model.hxx @@ -0,0 +1,39 @@ +// file : odb/semantics/relational/model.hxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#ifndef ODB_SEMANTICS_RELATIONAL_MODEL_HXX +#define ODB_SEMANTICS_RELATIONAL_MODEL_HXX + +#include + +namespace semantics +{ + namespace relational + { + class model: public graph, public scope + { + public: + model () + { + } + + virtual string + kind () const + { + return "model"; + } + + public: + using scope::add_edge_left; + using scope::add_edge_right; + + private: + model (model const&); + model& operator= (model const&); + }; + } +} + +#endif // ODB_SEMANTICS_RELATIONAL_MODEL_HXX diff --git a/odb/semantics/relational/primary-key.cxx b/odb/semantics/relational/primary-key.cxx new file mode 100644 index 0000000..367013e --- /dev/null +++ b/odb/semantics/relational/primary-key.cxx @@ -0,0 +1,35 @@ +// file : odb/semantics/relational/primary-key.cxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#include + +#include + +namespace semantics +{ + namespace relational + { + // type info + // + namespace + { + struct init + { + init () + { + using compiler::type_info; + + // primary_key + // + { + type_info ti (typeid (primary_key)); + ti.add_base (typeid (key)); + insert (ti); + } + } + } init_; + } + } +} diff --git a/odb/semantics/relational/primary-key.hxx b/odb/semantics/relational/primary-key.hxx new file mode 100644 index 0000000..a35e8f5 --- /dev/null +++ b/odb/semantics/relational/primary-key.hxx @@ -0,0 +1,45 @@ +// file : odb/semantics/relational/primary-key.hxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#ifndef ODB_SEMANTICS_RELATIONAL_PRIMARY_KEY_HXX +#define ODB_SEMANTICS_RELATIONAL_PRIMARY_KEY_HXX + +#include +#include + +namespace semantics +{ + namespace relational + { + class primary_key: public key + { + public: + bool + auto_ () const + { + return auto__; + } + + public: + // Primary key has the implicit empty id. + // + primary_key (bool auto_) + : key (""), auto__ (auto_) + { + } + + virtual string + kind () const + { + return "primary key"; + } + + private: + bool auto__; + }; + } +} + +#endif // ODB_SEMANTICS_RELATIONAL_PRIMARY_KEY_HXX diff --git a/odb/semantics/relational/table.cxx b/odb/semantics/relational/table.cxx new file mode 100644 index 0000000..a9290c6 --- /dev/null +++ b/odb/semantics/relational/table.cxx @@ -0,0 +1,52 @@ +// file : odb/semantics/relational/table.cxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#include + +#include + +namespace semantics +{ + namespace relational + { + // type info + // + namespace + { + struct init + { + init () + { + using compiler::type_info; + + // table + // + { + type_info ti (typeid (table)); + ti.add_base (typeid (nameable)); + ti.add_base (typeid (scope)); + insert (ti); + } + + // object_table + // + { + type_info ti (typeid (object_table)); + ti.add_base (typeid (table)); + insert (ti); + } + + // container_table + // + { + type_info ti (typeid (container_table)); + ti.add_base (typeid (table)); + insert (ti); + } + } + } init_; + } + } +} diff --git a/odb/semantics/relational/table.hxx b/odb/semantics/relational/table.hxx new file mode 100644 index 0000000..d2f8649 --- /dev/null +++ b/odb/semantics/relational/table.hxx @@ -0,0 +1,56 @@ +// file : odb/semantics/relational/table.hxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v3; see accompanying LICENSE file + +#ifndef ODB_SEMANTICS_RELATIONAL_TABLE_HXX +#define ODB_SEMANTICS_RELATIONAL_TABLE_HXX + +#include + +namespace semantics +{ + namespace relational + { + class table: public nameable, public scope + { + protected: + table (string const& id) + : nameable (id) + { + } + }; + + class object_table: public table + { + public: + object_table (string const& id) + : table (id) + { + } + + virtual string + kind () const + { + return "object table"; + } + }; + + class container_table: public table + { + public: + container_table (string const& id) + : table (id) + { + } + + virtual string + kind () const + { + return "container table"; + } + }; + } +} + +#endif // ODB_SEMANTICS_RELATIONAL_TABLE_HXX -- cgit v1.1