From 7f6c64f2211d37db76a97fbc79a4b5492302ef2f Mon Sep 17 00:00:00 2001 From: Boris Kolpackov Date: Wed, 27 Oct 2010 17:36:59 +0200 Subject: Implement support for composite value types New test: common/composite. --- odb/mysql/common.cxx | 265 ++++++++++++++----------- odb/mysql/common.hxx | 65 ++----- odb/mysql/context.cxx | 107 ++++++++++ odb/mysql/context.hxx | 10 + odb/mysql/header.cxx | 146 +++++++++++--- odb/mysql/inline.cxx | 44 ++--- odb/mysql/schema.cxx | 27 +-- odb/mysql/source.cxx | 527 +++++++++++++++++++++++++++++++++++++------------- 8 files changed, 829 insertions(+), 362 deletions(-) (limited to 'odb/mysql') diff --git a/odb/mysql/common.cxx b/odb/mysql/common.cxx index 284a80e..372d08e 100644 --- a/odb/mysql/common.cxx +++ b/odb/mysql/common.cxx @@ -3,6 +3,8 @@ // copyright : Copyright (c) 2009-2010 Code Synthesis Tools CC // license : GNU GPL v3; see accompanying LICENSE file +#include + #include using namespace std; @@ -25,109 +27,114 @@ namespace mysql pre (m); - sql_type const& t (db_type (m)); - - switch (t.type) + if (comp_value (m.type ())) + traverse_composite (m); + else { - // Integral types. - // - case sql_type::TINYINT: - case sql_type::SMALLINT: - case sql_type::MEDIUMINT: - case sql_type::INT: - case sql_type::BIGINT: - { - traverse_integer (m, t); - break; - } + sql_type const& t (db_type (m)); - // Float types. - // - case sql_type::FLOAT: - case sql_type::DOUBLE: - { - traverse_float (m, t); - break; - } - case sql_type::DECIMAL: + switch (t.type) { - traverse_decimal (m, t); - break; - } - - // Data-time types. - // - case sql_type::DATE: - case sql_type::TIME: - case sql_type::DATETIME: - case sql_type::TIMESTAMP: - case sql_type::YEAR: - { - traverse_date_time (m, t); - break; - } - - // String and binary types. - // - case sql_type::CHAR: - case sql_type::VARCHAR: - case sql_type::TINYTEXT: - case sql_type::TEXT: - case sql_type::MEDIUMTEXT: - case sql_type::LONGTEXT: - { - // For string types the limit is in characters rather - // than in bytes. The fixed-length pre-allocated buffer - // optimization can only be used for 1-byte encodings. - // To support this we will need the character encoding - // in sql_type. + // Integral types. // - traverse_long_string (m, t); - break; - } - case sql_type::BINARY: - case sql_type::TINYBLOB: - { - // BINARY's range is always 255 or less from MySQL 5.0.3. - // TINYBLOB can only store up to 255 bytes. + case sql_type::TINYINT: + case sql_type::SMALLINT: + case sql_type::MEDIUMINT: + case sql_type::INT: + case sql_type::BIGINT: + { + traverse_integer (m, t); + break; + } + + // Float types. // - traverse_short_string (m, t); - break; - } - case sql_type::VARBINARY: - case sql_type::BLOB: - case sql_type::MEDIUMBLOB: - case sql_type::LONGBLOB: - { - if (t.range && t.range_value <= 255) - traverse_short_string (m, t); - else + case sql_type::FLOAT: + case sql_type::DOUBLE: + { + traverse_float (m, t); + break; + } + case sql_type::DECIMAL: + { + traverse_decimal (m, t); + break; + } + + // Data-time types. + // + case sql_type::DATE: + case sql_type::TIME: + case sql_type::DATETIME: + case sql_type::TIMESTAMP: + case sql_type::YEAR: + { + traverse_date_time (m, t); + break; + } + + // String and binary types. + // + case sql_type::CHAR: + case sql_type::VARCHAR: + case sql_type::TINYTEXT: + case sql_type::TEXT: + case sql_type::MEDIUMTEXT: + case sql_type::LONGTEXT: + { + // For string types the limit is in characters rather + // than in bytes. The fixed-length pre-allocated buffer + // optimization can only be used for 1-byte encodings. + // To support this we will need the character encoding + // in sql_type. + // traverse_long_string (m, t); - - break; - } - - // Other types. - // - case sql_type::BIT: - { - traverse_bit (m, t); - break; - } - case sql_type::ENUM: - { - traverse_enum (m, t); - break; - } - case sql_type::SET: - { - traverse_set (m, t); - break; - } - case sql_type::invalid: - { - assert (false); - break; + break; + } + case sql_type::BINARY: + case sql_type::TINYBLOB: + { + // BINARY's range is always 255 or less from MySQL 5.0.3. + // TINYBLOB can only store up to 255 bytes. + // + traverse_short_string (m, t); + break; + } + case sql_type::VARBINARY: + case sql_type::BLOB: + case sql_type::MEDIUMBLOB: + case sql_type::LONGBLOB: + { + if (t.range && t.range_value <= 255) + traverse_short_string (m, t); + else + traverse_long_string (m, t); + + break; + } + + // Other types. + // + case sql_type::BIT: + { + traverse_bit (m, t); + break; + } + case sql_type::ENUM: + { + traverse_enum (m, t); + break; + } + case sql_type::SET: + { + traverse_set (m, t); + break; + } + case sql_type::invalid: + { + assert (false); + break; + } } } @@ -171,6 +178,13 @@ namespace mysql } void member_image_type:: + traverse_composite (type& m) + { + type_ = "composite_value_traits< " + m.type ().fq_name () + + " >::image_type"; + } + + void member_image_type:: traverse_integer (type&, sql_type const& t) { if (t.unsign) @@ -297,6 +311,12 @@ namespace mysql } void member_database_type:: + traverse_composite (type&) + { + assert (false); + } + + void member_database_type:: traverse_integer (type&, sql_type const& t) { size_t i ((t.type - sql_type::TINYINT) * 2 + (t.unsign ? 1 : 0)); @@ -346,21 +366,23 @@ namespace mysql } // - // query_column + // query_columns // - query_column:: - query_column (context& c) - : context (c), + query_columns:: + query_columns (context& c) + : object_columns_base (c), + context (c), decl_ (true), member_image_type_ (c, false), member_database_type_ (c) { } - query_column:: - query_column (context& c, semantics::class_& cl) - : context (c), + query_columns:: + query_columns (context& c, semantics::class_& cl) + : object_columns_base (c), + context (c), decl_ (false), member_image_type_ (c, false), member_database_type_ (c) @@ -369,10 +391,37 @@ namespace mysql table_ = table_name (cl); } - void query_column:: - traverse (type& m) + void query_columns:: + composite (semantics::data_member& m) + { + string name (public_name (m)); + + if (decl_) + { + os << "// " << name << endl + << "//" << endl + << "struct " << name + << "{"; + + object_columns_base::composite (m); + + os << "};"; + } + else + { + string old_scope (scope_); + scope_ += "::" + name; + + object_columns_base::composite (m); + + scope_ = old_scope; + } + } + + void query_columns:: + column (semantics::data_member& m, string const& col_name, bool) { - string name (escape (public_name (m))); + string name (public_name (m)); string db_type (member_database_type_.database_type (m)); string type ( @@ -394,7 +443,7 @@ namespace mysql } else { - string column ("\"`" + table_ + "`.`" + column_name (m) + "`\""); + string column ("\"`" + table_ + "`.`" + col_name + "`\""); os << "const mysql::query_column<" << endl << " " << type << "," << endl diff --git a/odb/mysql/common.hxx b/odb/mysql/common.hxx index c689bb6..83fa998 100644 --- a/odb/mysql/common.hxx +++ b/odb/mysql/common.hxx @@ -32,6 +32,11 @@ namespace mysql } virtual void + traverse_composite (type&) + { + } + + virtual void traverse_integer (type&, sql_type const&) { } @@ -96,6 +101,9 @@ namespace mysql image_type (type&); virtual void + traverse_composite (type&); + + virtual void traverse_integer (type&, sql_type const&); virtual void @@ -131,6 +139,9 @@ namespace mysql database_type (type&); virtual void + traverse_composite (type&); + + virtual void traverse_integer (type&, sql_type const&); virtual void @@ -158,60 +169,16 @@ namespace mysql string type_; }; - struct has_grow_member: member_base + struct query_columns: object_columns_base, context { - has_grow_member (context& c) - : member_base (c, false), r_ (false) - { - } - - bool - result () - { - return r_; - } - - virtual void - traverse_decimal (type&, sql_type const&) - { - r_ = true; - } + query_columns (context&); + query_columns (context&, semantics::class_&); virtual void - traverse_long_string (type&, sql_type const&) - { - r_ = true; - } - - virtual void - traverse_short_string (type&, sql_type const&) - { - r_ = true; // @@ Short string optimization disabled. - } - - virtual void - traverse_enum (type&, sql_type const&) - { - r_ = true; - } - - virtual void - traverse_set (type&, sql_type const&) - { - r_ = true; - } - - private: - bool r_; - }; - - struct query_column: traversal::data_member, context - { - query_column (context&); - query_column (context&, semantics::class_&); + composite (semantics::data_member&); virtual void - traverse (type&); + column (semantics::data_member&, string const&, bool); private: string scope_; diff --git a/odb/mysql/context.cxx b/odb/mysql/context.cxx index 7665ed6..f33916e 100644 --- a/odb/mysql/context.cxx +++ b/odb/mysql/context.cxx @@ -9,6 +9,7 @@ #include #include +#include using namespace std; @@ -76,6 +77,112 @@ namespace mysql { } + namespace + { + struct has_grow: traversal::class_ + { + has_grow (context& c) + : member_ (c, *this) + { + *this >> member_names_ >> member_; + *this >> inherits_ >> *this; + } + + bool + dispatch (semantics::type& t) + { + r_ = false; + traversal::class_::dispatch (t); + return r_; + } + + virtual void + traverse (type& c) + { + if (c.count ("mysql::grow")) + r_ = c.get ("mysql::grow"); + else + { + // r_ should be false. + // + inherits (c); + + if (!r_) + names (c); + + c.set ("mysql::grow", r_); + } + } + + private: + struct member: member_base + { + member (context& c, has_grow& hg) : member_base (c, false), hg_ (hg) {} + + virtual void + traverse_composite (type& m) + { + if (!hg_.r_) + hg_.r_ = hg_.dispatch (m.type ()); + } + + virtual void + traverse_decimal (type&, sql_type const&) + { + hg_.r_ = true; + } + + virtual void + traverse_long_string (type&, sql_type const&) + { + hg_.r_ = true; + } + + virtual void + traverse_short_string (type&, sql_type const&) + { + hg_.r_ = true; // @@ Short string optimization disabled. + } + + virtual void + traverse_enum (type&, sql_type const&) + { + hg_.r_ = true; + } + + virtual void + traverse_set (type&, sql_type const&) + { + hg_.r_ = true; + } + + private: + has_grow& hg_; + }; + + bool r_; + + member member_; + traversal::names member_names_; + + traversal::inherits inherits_; + }; + } + + bool context:: + grow (semantics::class_& c) + { + if (c.count ("mysql::grow")) + return c.get ("mysql::grow"); + + has_grow t (*this); + return t.dispatch (c); + } + + // + // SQL type parsing. + // + string context:: column_type (semantics::data_member& m) const { diff --git a/odb/mysql/context.hxx b/odb/mysql/context.hxx index c4615e8..266d38f 100644 --- a/odb/mysql/context.hxx +++ b/odb/mysql/context.hxx @@ -76,6 +76,16 @@ namespace mysql class context: public ::context { + // Predicates. + // + public: + + // Return true if an object or value type has members for which + // the image can grow. + // + bool + grow (semantics::class_&); + private: typedef ::context base_context; diff --git a/odb/mysql/header.cxx b/odb/mysql/header.cxx index cc13264..2544ff3 100644 --- a/odb/mysql/header.cxx +++ b/odb/mysql/header.cxx @@ -30,6 +30,13 @@ namespace mysql } virtual void + traverse_composite (type&) + { + os << image_type << " " << var << "value;" + << endl; + } + + virtual void traverse_integer (type&, sql_type const&) { os << image_type << " " << var << "value;" @@ -140,19 +147,51 @@ namespace mysql member_image_type member_image_type_; }; + struct image_base: traversal::class_, context + { + image_base (context& c): context (c), first_ (true) {} + + virtual void + traverse (type& c) + { + if (first_) + { + os << ": "; + first_ = false; + } + else + { + os << "," << endl + << " "; + } + + os << "composite_value_traits< " << c.fq_name () << " >::image_type"; + } + + private: + bool first_; + }; + struct image_type: traversal::class_, context { image_type (context& c) - : context (c), image_member_ (c, false) + : context (c), member_ (c, false) { - *this >> names_image_member_ >> image_member_; + *this >> names_member_ >> member_; } virtual void traverse (type& c) { - os << "struct image_type" - << "{"; + os << "struct image_type"; + + { + image_base b (*this); + traversal::inherits i (b); + inherits (c, i); + } + + os << "{"; names (c); @@ -160,8 +199,8 @@ namespace mysql } private: - image_member image_member_; - traversal::names names_image_member_; + image_member member_; + traversal::names names_member_; }; struct id_image_type: traversal::class_, context @@ -193,10 +232,8 @@ namespace mysql class_ (context& c) : context (c), image_type_ (c), - id_image_type_ (c), - query_column_ (c) + id_image_type_ (c) { - *this >> query_column_names_ >> query_column_; } virtual void @@ -205,9 +242,15 @@ namespace mysql if (c.file () != unit.file ()) return; - if (!c.count ("object")) - return; + if (c.count ("object")) + traverse_object (c); + else if (comp_value (c)) + traverse_value (c); + } + virtual void + traverse_object (type& c) + { string const& type (c.fq_name ()); bool def_ctor (TYPE_HAS_DEFAULT_CONSTRUCTOR (c.tree_node ())); @@ -215,9 +258,6 @@ namespace mysql semantics::data_member& id (*id_member_.member ()); bool auto_id (id.count ("auto")); - member_count_.traverse (c); - size_t column_count (member_count_.count ()); - os << "// " << c.name () << endl << "//" << endl; @@ -260,7 +300,10 @@ namespace mysql os << "struct query_type: query_base_type" << "{"; - names (c, query_column_names_); + { + query_columns t (*this); + t.traverse (c); + } os << "query_type ();" << "query_type (const std::string&);" @@ -270,8 +313,8 @@ namespace mysql // column_count // - os << "static const std::size_t column_count = " << column_count << - "UL;" + os << "static const std::size_t column_count = " << + column_count (c) << "UL;" << endl; // Queries. @@ -301,13 +344,13 @@ namespace mysql // bind (image_type) // os << "static void" << endl - << "bind (mysql::binding&, image_type&);" + << "bind (MYSQL_BIND*, image_type&);" << endl; // bind (id_image_type) // os << "static void" << endl - << "bind (mysql::binding&, id_image_type&);" + << "bind (MYSQL_BIND*, id_image_type&);" << endl; // init (image, object) @@ -368,14 +411,59 @@ namespace mysql os << "};"; } + virtual void + traverse_value (type& c) + { + string const& type (c.fq_name ()); + + os << "// " << c.name () << endl + << "//" << endl; + + os << "template <>" << endl + << "class access::composite_value_traits< " << type << " >" + << "{" + << "public:" << endl; + + // object_type + // + os << "typedef " << type << " value_type;" + << endl; + + // image_type + // + image_type_.traverse (c); + + // grow () + // + os << "static bool" << endl + << "grow (image_type&, my_bool*);" + << endl; + + // bind (image_type) + // + os << "static void" << endl + << "bind (MYSQL_BIND*, image_type&);" + << endl; + + // init (image, object) + // + os << "static bool" << endl + << "init (image_type&, const value_type&);" + << endl; + + // init (object, image) + // + os << "static void" << endl + << "init (value_type&, const image_type&);" + << endl; + + os << "};"; + } + private: id_member id_member_; - member_count member_count_; image_type image_type_; id_image_type id_image_type_; - - query_column query_column_; - traversal::names query_column_names_; }; } @@ -398,17 +486,13 @@ namespace mysql ctx.os << "#include " << endl // std::size_t << endl; - ctx.os << "#include " << endl - << "#include " << endl; - if (ctx.options.generate_query ()) - ctx.os << "#include " << endl; + ctx.os << "#include " << endl + << endl; - ctx.os << endl - << "#include " << endl + ctx.os << "#include " << endl << "#include " << endl - << "#include " << endl - << endl; + << "#include " << endl; if (ctx.options.generate_query ()) ctx.os << "#include " << endl; diff --git a/odb/mysql/inline.cxx b/odb/mysql/inline.cxx index 2527e1f..47766e2 100644 --- a/odb/mysql/inline.cxx +++ b/odb/mysql/inline.cxx @@ -23,9 +23,15 @@ namespace mysql if (c.file () != unit.file ()) return; - if (!c.count ("object")) - return; + if (c.count ("object")) + traverse_object (c); + else if (comp_value (c)) + traverse_value (c); + } + virtual void + traverse_object (type& c) + { string const& type (c.fq_name ()); string traits ("access::object_traits< " + type + " >"); @@ -33,14 +39,6 @@ namespace mysql t.traverse (c); semantics::data_member& id (*t.member ()); - bool has_grow; - { - has_grow_member m (*this); - traversal::names n (m); - names (c, n); - has_grow = m.result (); - } - os << "// " << c.name () << endl << "//" << endl << endl; @@ -79,20 +77,20 @@ namespace mysql << "{" << "return obj." << id.name () << ";" << endl << "}"; + } - // grow () - // - if (!has_grow) - { - // The dummy implementation is needed for result_impl. - // - os << "inline" << endl - << "bool " << traits << "::" << endl - << "grow (image_type&, my_bool*)" - << "{" - << "return false;" - << "}"; - } + virtual void + traverse_value (type&) + { + /* + string const& type (c.fq_name ()); + string traits ("access::composite_value_traits< " + type + " >"); + + os << "// " << c.name () << endl + << "//" << endl + << endl; + + */ } }; } diff --git a/odb/mysql/schema.cxx b/odb/mysql/schema.cxx index 59a6900..3ef412b 100644 --- a/odb/mysql/schema.cxx +++ b/odb/mysql/schema.cxx @@ -4,38 +4,32 @@ // license : GNU GPL v3; see accompanying LICENSE file #include + +#include #include namespace mysql { namespace { - struct data_member: traversal::data_member, context + struct object_columns: object_columns_base, context { - data_member (context& c) - : context (c), first_ (true) + object_columns (context& c) + : object_columns_base (c), context (c) { } virtual void - traverse (type& m) + column (semantics::data_member& m, string const& name, bool first) { - if (m.count ("transient")) - return; - - if (first_) - first_ = false; - else + if (!first) os << "," << endl; - os << " `" << column_name (m) << "` " << column_type (m); + os << " `" << name << "` " << column_type (m); if (m.count ("id")) os << " PRIMARY KEY"; } - - private: - bool first_; }; struct class_create: traversal::class_, context @@ -65,9 +59,8 @@ namespace mysql os << "CREATE TABLE `" << name << "` (" << endl; { - data_member m (*this); - traversal::names n (m); - names (c, n); + object_columns t (*this); + t.traverse (c); } os << ")"; diff --git a/odb/mysql/source.cxx b/odb/mysql/source.cxx index c0ce773..d572560 100644 --- a/odb/mysql/source.cxx +++ b/odb/mysql/source.cxx @@ -16,30 +16,24 @@ namespace mysql { namespace { - struct member_column: traversal::data_member, context + struct object_columns: object_columns_base, context { - member_column (context& c, string const& suffix = "") - : context (c), suffix_ (suffix), first_ (true) + object_columns (context& c, string const& suffix = "") + : object_columns_base (c), context (c), suffix_ (suffix) { } virtual void - traverse (type& m) + column (semantics::data_member&, string const& name, bool first) { - if (m.count ("transient")) - return; - - if (first_) - first_ = false; - else + if (!first) os << ",\"" << endl; - os << "\"`" << column_name (m) << "`" << suffix_; + os << "\"`" << name << "`" << suffix_; } private: string suffix_; - bool first_; }; const char* integer_buffer_types[] = @@ -82,10 +76,14 @@ namespace mysql "MYSQL_TYPE_BLOB" // LONGBLOB }; + // + // bind + // + struct bind_member: member_base { - bind_member (context& c, bool id) - : member_base (c, id), index_ (0) + bind_member (context& c, size_t& index, bool id) + : member_base (c, id), index_ (index) { } @@ -93,7 +91,7 @@ namespace mysql pre (type& m) { ostringstream ostr; - ostr << "b.bind[" << index_ << "UL]"; + ostr << "b[" << index_ << "UL]"; b = ostr.str (); if (!id_) @@ -102,9 +100,21 @@ namespace mysql } virtual void - post (type&) + post (type& m) { - index_++; + if (semantics::class_* c = comp_value (m.type ())) + index_ += column_count (*c); + else + index_++; + } + + virtual void + traverse_composite (type& m) + { + os << "composite_value_traits< " << m.type ().fq_name () << + " >::bind (" << endl + << "b + " << index_ << "UL, i." << var << "value);" + << endl; } virtual void @@ -234,13 +244,40 @@ namespace mysql private: string b; - size_t index_; + size_t& index_; + }; + + struct bind_base: traversal::class_, context + { + bind_base (context& c, size_t& index) + : context (c), index_ (index) + { + } + + virtual void + traverse (type& c) + { + os << "// " << c.name () << " base" << endl + << "//" << endl + << "composite_value_traits< " << c.fq_name () << + " >::bind (b + " << index_ << "UL, i);" + << endl; + + index_ += column_count (c); + } + + private: + size_t& index_; }; + // + // grow + // + struct grow_member: member_base { - grow_member (context& c) - : member_base (c, false), index_ (0) + grow_member (context& c, size_t& index) + : member_base (c, false), index_ (index) { } @@ -256,9 +293,23 @@ namespace mysql } virtual void - post (type&) + post (type& m) { - index_++; + if (semantics::class_* c = comp_value (m.type ())) + index_ += column_count (*c); + else + index_++; + } + + virtual void + traverse_composite (type& m) + { + os << "if (composite_value_traits< " << m.type ().fq_name () << + " >::grow (" << endl + << "i." << var << "value, e + " << index_ << "UL))" + << "{" + << "r = true;" + << "}"; } virtual void @@ -349,11 +400,38 @@ namespace mysql private: string e; - size_t index_; + size_t& index_; + }; + + struct grow_base: traversal::class_, context + { + grow_base (context& c, size_t& index) + : context (c), index_ (index) + { + } + + virtual void + traverse (type& c) + { + os << "// " << c.name () << " base" << endl + << "//" << endl + << "if (composite_value_traits< " << c.fq_name () << + " >::grow (i, e + " << index_ << "UL))" + << "{" + << "r = true;" + << "}"; + + index_ += column_count (c); + } + + private: + size_t& index_; }; // + // init image // + struct init_image_member: member_base { init_image_member (context& c, bool id) @@ -366,14 +444,21 @@ namespace mysql virtual void pre (type& m) { - type = m.type ().fq_name (m.belongs ().hint ()); - image_type = member_image_type_.image_type (m); - db_type = member_database_type_.database_type (m); + semantics::type& t (m.type ()); - traits = "mysql::value_traits< " - + type + ", " - + image_type + ", " - + db_type + " >"; + if (comp_value (t)) + traits = "composite_value_traits< " + t.fq_name () + " >"; + else + { + type = t.fq_name (m.belongs ().hint ()); + image_type = member_image_type_.image_type (m); + db_type = member_database_type_.database_type (m); + + traits = "mysql::value_traits< " + + type + ", " + + image_type + ", " + + db_type + " >"; + } if (id_) member = "id"; @@ -388,21 +473,35 @@ namespace mysql } virtual void + traverse_composite (type&) + { + os << "if (" << traits << "::init (i." << var << "value, " << + member << "))" + << "{" + << "grew = true;" + << "}"; + } + + virtual void traverse_integer (type&, sql_type const&) { - os << traits << "::set_image (" << endl + os << "{" + << "bool is_null;" + << traits << "::set_image (" << endl << "i." << var << "value, is_null, " << member << ");" << "i." << var << "null = is_null;" - << endl; + << "}"; } virtual void traverse_float (type&, sql_type const&) { - os << traits << "::set_image (" << endl + os << "{" + << "bool is_null;" + << traits << "::set_image (" << endl << "i." << var << "value, is_null, " << member << ");" << "i." << var << "null = is_null;" - << endl; + << "}"; } virtual void @@ -411,6 +510,7 @@ namespace mysql // @@ Optimization: can remove growth check if buffer is fixed. // os << "{" + << "bool is_null;" << "std::size_t size;" << "std::size_t cap (i." << var << "value.capacity ());" << traits << "::set_image (" << endl @@ -427,10 +527,12 @@ namespace mysql virtual void traverse_date_time (type&, sql_type const&) { - os << traits << "::set_image (" << endl + os << "{" + << "bool is_null;" + << traits << "::set_image (" << endl << "i." << var << "value, is_null, " << member << ");" << "i." << var << "null = is_null;" - << endl; + << "}"; } virtual void @@ -439,6 +541,7 @@ namespace mysql // @@ Optimization: can remove growth check if buffer is fixed. // os << "{" + << "bool is_null;" << "std::size_t size;" << "std::size_t cap (i." << var << "value.capacity ());" << traits << "::set_image (" << endl @@ -456,6 +559,7 @@ namespace mysql traverse_long_string (type&, sql_type const&) { os << "{" + << "bool is_null;" << "std::size_t size;" << "std::size_t cap (i." << var << "value.capacity ());" << traits << "::set_image (" << endl @@ -475,6 +579,7 @@ namespace mysql // Represented as a BLOB. // os << "{" + << "bool is_null;" << "std::size_t size;" << traits << "::set_image (" << endl << "i." << var << "value," << endl @@ -493,6 +598,7 @@ namespace mysql // Represented as a string. // os << "{" + << "bool is_null;" << "std::size_t size;" << "std::size_t cap (i." << var << "value.capacity ());" << traits << "::set_image (" << endl @@ -512,6 +618,7 @@ namespace mysql // Represented as a string. // os << "{" + << "bool is_null;" << "std::size_t size;" << "std::size_t cap (i." << var << "value.capacity ());" << traits << "::set_image (" << endl @@ -536,8 +643,30 @@ namespace mysql member_database_type member_database_type_; }; + struct init_image_base: traversal::class_, context + { + init_image_base (context& c) + : context (c) + { + } + + virtual void + traverse (type& c) + { + os << "// " << c.name () << " base" << endl + << "//" << endl + << "if (composite_value_traits< " << c.fq_name () << + " >::init (i, o))" + << "{" + << "grew = true;" + << "}"; + } + }; + // + // init value // + struct init_value_member: member_base { init_value_member (context& c) @@ -550,20 +679,34 @@ namespace mysql virtual void pre (type& m) { - type = m.type ().fq_name (m.belongs ().hint ()); - image_type = member_image_type_.image_type (m); - db_type = member_database_type_.database_type (m); + semantics::type& t (m.type ()); - traits = "mysql::value_traits< " - + type + ", " - + image_type + ", " - + db_type + " >"; + if (comp_value (t)) + traits = "composite_value_traits< " + t.fq_name () + " >"; + else + { + type = m.type ().fq_name (m.belongs ().hint ()); + image_type = member_image_type_.image_type (m); + db_type = member_database_type_.database_type (m); + + traits = "mysql::value_traits< " + + type + ", " + + image_type + ", " + + db_type + " >"; + } os << "// " << m.name () << endl << "//" << endl; } virtual void + traverse_composite (type& m) + { + os << traits << "::init (o." << m.name () << ", i." << var << "value);" + << endl; + } + + virtual void traverse_integer (type& m, sql_type const&) { os << traits << "::set_value (" << endl @@ -672,19 +815,54 @@ namespace mysql member_database_type member_database_type_; }; + struct init_value_base: traversal::class_, context + { + init_value_base (context& c) + : context (c) + { + } + + virtual void + traverse (type& c) + { + os << "// " << c.name () << " base" << endl + << "//" << endl + << "composite_value_traits< " << c.fq_name () << " >::init (o, i);" + << endl; + } + }; + // // struct class_: traversal::class_, context { class_ (context& c) : context (c), + grow_base_ (c, index_), + grow_member_ (c, index_), + bind_base_ (c, index_), + bind_member_ (c, index_, false), + bind_id_member_ (c, index_, true), + init_image_base_ (c), init_image_member_ (c, false), init_id_image_member_ (c, true), + init_value_base_ (c), init_value_member_ (c) { - *this >> init_image_member_names_ >> init_image_member_; - *this >> init_id_image_member_names_ >> init_id_image_member_; - *this >> init_value_member_names_ >> init_value_member_; + grow_base_inherits_ >> grow_base_; + grow_member_names_ >> grow_member_; + + bind_base_inherits_ >> bind_base_; + bind_member_names_ >> bind_member_; + bind_id_member_names_ >> bind_id_member_; + + init_image_base_inherits_ >> init_image_base_; + init_image_member_names_ >> init_image_member_; + + init_id_image_member_names_ >> init_id_image_member_; + + init_value_base_inherits_ >> init_value_base_; + init_value_member_names_ >> init_value_member_; } virtual void @@ -693,28 +871,25 @@ namespace mysql if (c.file () != unit.file ()) return; - if (!c.count ("object")) - return; + if (c.count ("object")) + traverse_object (c); + else if (comp_value (c)) + traverse_value (c); + } + virtual void + traverse_object (type& c) + { string const& type (c.fq_name ()); string traits ("access::object_traits< " + type + " >"); + + bool grow (context::grow (c)); bool def_ctor (TYPE_HAS_DEFAULT_CONSTRUCTOR (c.tree_node ())); id_member_.traverse (c); semantics::data_member& id (*id_member_.member ()); bool auto_id (id.count ("auto")); - member_count_.traverse (c); - size_t column_count (member_count_.count ()); - - bool has_grow; - { - has_grow_member m (*this); - traversal::names n (m); - names (c, n); - has_grow = m.result (); - } - os << "// " << c.name () << endl << "//" << endl << endl; @@ -723,9 +898,8 @@ namespace mysql // if (options.generate_query ()) { - query_column t (*this, c); - traversal::names n (t); - names (c, n); + query_columns t (*this, c); + t.traverse (c); } // persist_statement @@ -734,15 +908,14 @@ namespace mysql << "\"INSERT INTO `" << table_name (c) << "` (\"" << endl; { - member_column m (*this); - traversal::names n (m); - names (c, n); + object_columns t (*this); + t.traverse (c); } os << "\"" << endl << "\") VALUES ("; - for (size_t i (0); i < column_count; ++i) + for (size_t i (0), n (column_count (c)); i < n; ++i) os << (i != 0 ? "," : "") << '?'; os << ")\";" @@ -754,9 +927,8 @@ namespace mysql << "\"SELECT \"" << endl; { - member_column m (*this); - traversal::names n (m); - names (c, n); + object_columns t (*this); + t.traverse (c); } os << "\"" << endl @@ -770,9 +942,8 @@ namespace mysql << "\"UPDATE `" << table_name (c) << "` SET \"" << endl; { - member_column m (*this, " = ?"); - traversal::names n (m); - names (c, n); + object_columns t (*this, " = ?"); + t.traverse (c); } os << "\"" << endl @@ -794,9 +965,8 @@ namespace mysql << "\"SELECT \"" << endl; { - member_column m (*this); - traversal::names n (m); - names (c, n); + object_columns t (*this); + t.traverse (c); } os << "\"" << endl @@ -806,53 +976,41 @@ namespace mysql // grow () // - if (has_grow) - { - os << "bool " << traits << "::" << endl - << "grow (image_type& i, my_bool* e)" - << "{" - << "bool r (false);" - << endl; + os << "bool " << traits << "::" << endl + << "grow (image_type&" << (grow ? " i" : "") << ", my_bool* e)" + << "{" + << "bool r (false);" + << endl; - { - grow_member m (*this); - traversal::names n (m); - names (c, n); - } + index_ = 0; + inherits (c, grow_base_inherits_); + names (c, grow_member_names_); - os << "return r;" - << "}"; - } + os << "return r;" + << "}"; // bind (image_type) // os << "void " << traits << "::" << endl - << "bind (mysql::binding& b, image_type& i)" + << "bind (MYSQL_BIND* b, image_type& i)" << "{"; - { - bind_member m (*this, false); - traversal::names n (m); - names (c, n); - } + index_ = 0; + inherits (c, bind_base_inherits_); + names (c, bind_member_names_); - os << "b.version++;" - << "}"; + os << "}"; // bind (id_image_type) // os << "void " << traits << "::" << endl - << "bind (mysql::binding& b, id_image_type& i)" + << "bind (MYSQL_BIND* b, id_image_type& i)" << "{"; - { - bind_member m (*this, true); - traversal::names n (m); - names (c, n); - } + index_ = 0; + names (c, bind_id_member_names_); - os << "b.version++;" - << "}"; + os << "}"; // init (image, object) // @@ -860,9 +1018,11 @@ namespace mysql << "init (image_type& i, const object_type& o)" << "{" << "bool grew (false);" - << "bool is_null;" << endl; + + inherits (c, init_image_base_inherits_); names (c, init_image_member_names_); + os << "return grew;" << "}"; @@ -871,7 +1031,10 @@ namespace mysql os << "void " << traits << "::" << endl << "init (object_type& o, const image_type& i)" << "{"; + + inherits (c, init_value_base_inherits_); names (c, init_value_member_names_); + os << "}"; // persist () @@ -892,9 +1055,11 @@ namespace mysql os << "obj." << id.name () << " = 0;" << endl; - os << "if (init (sts.image (), obj) || b.version == 0)" << endl - << "bind (b, sts.image ());" - << endl + os << "if (init (sts.image (), obj) || b.version == 0)" + << "{" + << "bind (b.bind, sts.image ());" + << "b.version++;" + << "}" << "mysql::persist_statement& st (sts.persist_statement ());" << "st.execute ();"; @@ -914,18 +1079,22 @@ namespace mysql << "object_statements& sts (" << endl << "conn.statement_cache ().find ());" << endl - << "bool is_null, grew (false);" + << "bool grew (false);" << "const id_type& id (object_traits::id (obj));" << "id_image_type& i (sts.id_image ());"; names (c, init_id_image_member_names_); os << "binding& idb (sts.id_image_binding ());" - << "if (grew || idb.version == 0)" << endl - << "bind (idb, i);" - << endl + << "if (grew || idb.version == 0)" + << "{" + << "bind (idb.bind, i);" + << "idb.version++;" + << "}" << "binding& imb (sts.image_binding ());" - << "if (init (sts.image (), obj) || imb.version == 0)" << endl - << "bind (imb, sts.image ());" - << endl + << "if (init (sts.image (), obj) || imb.version == 0)" + << "{" + << "bind (imb.bind, sts.image ());" + << "imb.version++;" + << "}" << "sts.update_statement ().execute ();" << "}"; @@ -940,13 +1109,15 @@ namespace mysql << "object_statements& sts (" << endl << "conn.statement_cache ().find ());" << endl - << "bool is_null, grew (false);" + << "bool grew (false);" << "id_image_type& i (sts.id_image ());"; names (c, init_id_image_member_names_); os << "binding& idb (sts.id_image_binding ());" - << "if (grew || idb.version == 0)" << endl - << "bind (idb, i);" - << endl + << "if (grew || idb.version == 0)" + << "{" + << "bind (idb.bind, i);" + << "idb.version++;" + << "}" << "sts.erase_statement ().execute ();" << "}"; @@ -999,17 +1170,21 @@ namespace mysql << "{" << "using namespace mysql;" << endl - << "bool is_null, grew (false);" + << "bool grew (false);" << "id_image_type& i (sts.id_image ());"; names (c, init_id_image_member_names_); os << "binding& idb (sts.id_image_binding ());" - << "if (grew || idb.version == 0)" << endl - << "bind (idb, i);" - << endl + << "if (grew || idb.version == 0)" + << "{" + << "bind (idb.bind, i);" + << "idb.version++;" + << "}" << "binding& imb (sts.image_binding ());" - << "if (imb.version == 0)" << endl - << "bind (imb, sts.image ());" - << endl + << "if (imb.version == 0)" + << "{" + << "bind (imb.bind, sts.image ());" + << "imb.version++;" + << "}" << "mysql::find_statement& st (sts.find_statement ());" << "mysql::find_statement::result r (st.execute ());" << endl @@ -1017,12 +1192,13 @@ namespace mysql << "return false;" << endl; - if (has_grow) + if (grow) os << "if (r == mysql::find_statement::truncated)" << "{" << "if (grow (sts.image (), sts.image_error ()))" << "{" - << "bind (imb, sts.image ());" + << "bind (imb.bind, sts.image ());" + << "imb.version++;" << "st.refetch ();" << "}" << "}"; @@ -1046,9 +1222,11 @@ namespace mysql << "conn.statement_cache ().find ());" << endl << "binding& imb (sts.image_binding ());" - << "if (imb.version == 0)" << endl - << "bind (imb, sts.image ());" - << endl + << "if (imb.version == 0)" + << "{" + << "bind (imb.bind, sts.image ());" + << "imb.version++;" + << "}" << "details::shared_ptr st (" << endl << "new (details::shared) query_statement (conn," << endl << "query_clause + q.clause ()," << endl @@ -1063,16 +1241,97 @@ namespace mysql } } + virtual void + traverse_value (type& c) + { + string const& type (c.fq_name ()); + string traits ("access::composite_value_traits< " + type + " >"); + + os << "// " << c.name () << endl + << "//" << endl + << endl; + + // grow () + // + os << "bool " << traits << "::" << endl + << "grow (image_type&" << (grow (c) ? " i" : "") << ", my_bool* e)" + << "{" + << "bool r (false);" + << endl; + + index_ = 0; + inherits (c, grow_base_inherits_); + names (c, grow_member_names_); + + os << "return r;" + << "}"; + + // bind (image_type) + // + os << "void " << traits << "::" << endl + << "bind (MYSQL_BIND* b, image_type& i)" + << "{"; + + index_ = 0; + inherits (c, bind_base_inherits_); + names (c, bind_member_names_); + + os << "}"; + + // init (image, object) + // + os << "bool " << traits << "::" << endl + << "init (image_type& i, const value_type& o)" + << "{" + << "bool grew (false);" + << endl; + + inherits (c, init_image_base_inherits_); + names (c, init_image_member_names_); + + os << "return grew;" + << "}"; + + // init (object, image) + // + os << "void " << traits << "::" << endl + << "init (value_type& o, const image_type& i)" + << "{"; + + inherits (c, init_value_base_inherits_); + names (c, init_value_member_names_); + + os << "}"; + } + private: id_member id_member_; - member_count member_count_; + bool id_; + size_t index_; + + grow_base grow_base_; + traversal::inherits grow_base_inherits_; + grow_member grow_member_; + traversal::names grow_member_names_; + + bind_base bind_base_; + traversal::inherits bind_base_inherits_; + bind_member bind_member_; + traversal::names bind_member_names_; + bind_member bind_id_member_; + traversal::names bind_id_member_names_; + + init_image_base init_image_base_; + traversal::inherits init_image_base_inherits_; init_image_member init_image_member_; traversal::names init_image_member_names_; init_image_member init_id_image_member_; traversal::names init_id_image_member_names_; + init_value_base init_value_base_; + traversal::inherits init_value_base_inherits_; init_value_member init_value_member_; traversal::names init_value_member_names_; }; -- cgit v1.1