From b6fbe29805f9cd73ba369c51c3b7e4c82ee48ba6 Mon Sep 17 00:00:00 2001 From: Tomasz Sowa Date: Fri, 31 May 2019 18:28:09 +0000 Subject: [PATCH] added BaseExpression::is_long_field_name() added BaseExpression::need_to_add_field_prefix() now the fields() methods don't take add_column_prefix parameter but the field_name (wchar_t*) is tested whether is it a long (with a period) or short name added BaseExpression::save_foreign_key() (code moved from field()) removed some default method arguments from BaseExpression added neq() method for Finder added DbExpression::prepare_short_table_name(const PT::TextStream & table_name, PT::TextStream & short_table_name) git-svn-id: svn://ttmath.org/publicrep/morm/branches/join_models@1194 e52654a7-88a9-db11-a3e9-0013d4bc506e --- src/baseexpression.cpp | 112 ++++++++++++++++++++++++++++++++++------- src/baseexpression.h | 109 +++++++++++++++++++-------------------- src/dbconnector.cpp | 15 ++++-- src/dbexpression.cpp | 41 +++++++++++++++ src/dbexpression.h | 7 ++- src/finder.h | 83 ++++++++++++++++-------------- src/finderhelper.h | 16 +++--- src/flatconnector.cpp | 2 + src/jsonexpression.h | 10 ---- src/model.cpp | 42 +--------------- src/model.h | 49 +++++++++--------- src/modelenv.h | 4 +- src/morm_types.h | 1 + 13 files changed, 286 insertions(+), 205 deletions(-) diff --git a/src/baseexpression.cpp b/src/baseexpression.cpp index e7d1cc3..a108b6b 100644 --- a/src/baseexpression.cpp +++ b/src/baseexpression.cpp @@ -44,9 +44,7 @@ namespace morm BaseExpression::BaseExpression() { - out_stream = nullptr; - is_first_field = false; - work_mode = 0; + clear(); } BaseExpression::~BaseExpression() @@ -54,6 +52,15 @@ BaseExpression::~BaseExpression() } +void BaseExpression::clear() +{ + out_stream = nullptr; + is_first_field = false; + work_mode = 0; + use_prefix = false; +} + + void BaseExpression::set_work_mode(int work_mode) { this->work_mode = work_mode; @@ -66,14 +73,6 @@ int BaseExpression::get_work_mode() } -void BaseExpression::prepare_to_new_expression() -{ - out_stream = nullptr; - is_first_field = false; - work_mode = 0; - use_prefix = true; -} - PT::TextStream * BaseExpression::get_current_stream() { @@ -158,21 +157,80 @@ void BaseExpression::field_after() } +bool BaseExpression::is_long_field_name(const wchar_t * field_name) +{ + bool is_long = false; -void BaseExpression::put_field_name(const wchar_t * field_name, bool add_column_prefix, ModelEnv * model_env) + while( *field_name != 0 ) + { + if( *field_name == '.' ) + { + is_long = true; + break; + } + + field_name += 1; + } + + return is_long; +} + + +bool BaseExpression::is_long_field_name(const PT::TextStream & field_name) +{ + PT::TextStream::const_iterator i = field_name.begin(); + bool is_long = false; + + while( i != field_name.end() ) + { + if( *i == '.' ) + { + is_long = true; + break; + } + + ++i; + } + + return is_long; +} + + +bool BaseExpression::is_long_table_name(const wchar_t * table_name) +{ + return is_long_field_name(table_name); +} + +bool BaseExpression::is_long_table_name(const PT::TextStream & table_name) +{ + return is_long_field_name(table_name); +} + + +bool BaseExpression::need_to_add_field_prefix(const wchar_t * field_name) +{ + return !is_long_field_name(field_name); +} + + + +void BaseExpression::put_field_name(const wchar_t * field_name, ModelEnv * model_env) { before_field_name(); - if( use_prefix && model_env && add_column_prefix ) + if( use_prefix && model_env ) { - esc(model_env->table_name_simple, *out_stream); - - if( model_env->table_index > 1 ) + if( need_to_add_field_prefix(field_name) ) { - (*out_stream) << model_env->table_index; - } + esc(model_env->table_name_short, *out_stream); - (*out_stream) << '.'; + if( model_env->table_index > 1 ) + { + (*out_stream) << model_env->table_index; + } + + (*out_stream) << '.'; + } } esc(field_name, *out_stream); @@ -180,6 +238,22 @@ void BaseExpression::put_field_name(const wchar_t * field_name, bool add_column_ } +void BaseExpression::save_foreign_key(const wchar_t * field_name, ModelEnv * model_env) +{ + PT::TextStream str; + PT::TextStream * old_out_stream = out_stream; + + out_stream = &str; + put_field_name(field_name, model_env); + out_stream = old_out_stream; + + if( model_env && model_env->finder_helper ) + { + model_env->finder_helper->foreign_keys.emplace_back(); + std::string & key_str = model_env->finder_helper->foreign_keys.back(); + str.to_string(key_str, false); + } +} void BaseExpression::put_field_doc(Model & model, const void * field_pointer, bool insertable, bool updatable, bool is_primary_key, ModelEnv * model_env) { diff --git a/src/baseexpression.h b/src/baseexpression.h index fd2f56c..351b8b9 100644 --- a/src/baseexpression.h +++ b/src/baseexpression.h @@ -60,7 +60,7 @@ public: virtual void set_work_mode(int work_mode); virtual int get_work_mode(); - virtual void prepare_to_new_expression(); + virtual void clear(); virtual void generate_from_model(PT::TextStream & stream, Model & model); @@ -76,8 +76,7 @@ public: template - void field(const wchar_t * field_name, const FieldValue & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false, - bool add_column_prefix = true, ModelEnv * model_env = nullptr) + void field(const wchar_t * field_name, const FieldValue & field_value, bool insertable, bool updatable, bool is_primary_key, ModelEnv * model_env) { if( out_stream && can_field_be_generated(insertable, updatable, is_primary_key) ) { @@ -85,24 +84,12 @@ public: if( work_mode == MORM_WORK_MODE_MODEL_FIELDS ) { - put_field_name(field_name, add_column_prefix, model_env); + put_field_name(field_name, model_env); } else if( work_mode == MORM_WORK_MODE_MODEL_SAVE_FIELDS ) { - PT::TextStream str; - PT::TextStream * old_out_stream = out_stream; - - out_stream = &str; - put_field_name(field_name, add_column_prefix, model_env); - out_stream = old_out_stream; - - if( model_env && model_env->finder_helper ) - { - model_env->finder_helper->morm_foreign_keys.emplace_back(); - std::string & key_str = model_env->finder_helper->morm_foreign_keys.back(); - str.to_string(key_str, false); - } + save_foreign_key(field_name, model_env); } else if( work_mode == MORM_WORK_MODE_MODEL_VALUES ) @@ -112,7 +99,7 @@ public: else if( work_mode == MORM_WORK_MODE_MODEL_FIELDS_VALUES ) { - put_field_name(field_name, add_column_prefix, model_env); + put_field_name(field_name, model_env); put_name_value_separator(); put_field_value(field_value); } @@ -125,16 +112,13 @@ public: template - void field_doc(Model & model, const wchar_t * field_name, const FieldValue & field_value, - bool insertable = true, bool updatable = true, - bool is_primary_key = false, bool add_column_prefix = true, - ModelEnv * model_env = nullptr) + void field_doc(Model & model, const wchar_t * field_name, const FieldValue & field_value, bool insertable, bool updatable, bool is_primary_key, ModelEnv * model_env) { if( out_stream ) { field_before(); - put_field_name(field_name, add_column_prefix, model_env); + put_field_name(field_name, model_env); put_name_value_separator(); put_field_doc(model, reinterpret_cast(&field_value), insertable, updatable, is_primary_key, model_env); @@ -147,38 +131,30 @@ public: } - /* template - void field(const PT::TextStream & field_name, const FieldValue & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false, bool add_column_prefix = true) + void field_in(PT::TextStream & stream, const wchar_t * field_name, const std::set & container, ModelEnv * model_env) { - std::wstring field_name_str; // field() methods can be called recursively, so don't make it as class object - field_name.to_string(field_name_str); - - return field(field_name_str.c_str(), field_value, insertable, updatable, is_primary_key, add_column_prefix); - } - */ - - template - void field_in(PT::TextStream & stream, const wchar_t * field_name, const std::set & container) - { - field_in_generic>(stream, field_name, container); + field_in_generic>(stream, field_name, container, model_env); } - template - void field_in(PT::TextStream & stream, const wchar_t * field_name, const std::list & container) - { - field_in_generic>(stream, field_name, container); - } template - void field_in(PT::TextStream & stream, const wchar_t * field_name, const std::vector & container) + void field_in(PT::TextStream & stream, const wchar_t * field_name, const std::list & container, ModelEnv * model_env) { - field_in_generic>(stream, field_name, container); + field_in_generic>(stream, field_name, container, model_env); } + + template + void field_in(PT::TextStream & stream, const wchar_t * field_name, const std::vector & container, ModelEnv * model_env) + { + field_in_generic>(stream, field_name, container, model_env); + } + + template void field_list(const wchar_t * field_name, ModelContainer & field_value, bool insertable, bool updatable, bool is_primary_key, - ModelConnector * model_connector, ModelEnv * model_env) + ModelConnector * model_connector, ModelEnv * model_env) { if( out_stream && can_field_be_generated(insertable, updatable, is_primary_key) ) { @@ -191,7 +167,7 @@ public: // else if( work_mode == MORM_WORK_MODE_MODEL_FIELDS_VALUES ) { - put_field_name(field_name); // what about model_env? put it here? + put_field_name(field_name, model_env); put_name_value_separator(); put_field_value_list(field_value, model_connector, model_env); } @@ -201,7 +177,7 @@ public: } template - void field_model(const wchar_t * field_name, ModelClass & field_model, bool insertable = true, bool updatable = true, bool is_primary_key = false) + void field_model(const wchar_t * field_name, ModelClass & field_model, bool insertable, bool updatable, bool is_primary_key, ModelEnv * model_env) { if( out_stream && can_field_be_generated(insertable, updatable, is_primary_key) ) { @@ -209,7 +185,7 @@ public: if( work_mode == MORM_WORK_MODE_MODEL_FIELDS ) { - put_field_name(field_name); + put_field_name(field_name, model_env); } else if( work_mode == MORM_WORK_MODE_MODEL_VALUES ) @@ -219,7 +195,7 @@ public: else if( work_mode == MORM_WORK_MODE_MODEL_FIELDS_VALUES ) { - put_field_name(field_name); + put_field_name(field_name, model_env); put_name_value_separator(); generate_from_model(field_model); } @@ -229,11 +205,11 @@ public: } template - void field_to_stream(PT::TextStream & stream, const wchar_t * field_name, const FieldValue & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false, - bool add_column_prefix = true, ModelEnv * model_env = nullptr) + void field_to_stream(PT::TextStream & stream, const wchar_t * field_name, const FieldValue & field_value, bool insertable, bool updatable, bool is_primary_key, + ModelEnv * model_env) { this->out_stream = &stream; - field(field_name, field_value, insertable, updatable, is_primary_key, add_column_prefix, model_env); + field(field_name, field_value, insertable, updatable, is_primary_key, model_env); this->out_stream = nullptr; } @@ -265,6 +241,11 @@ public: virtual void esc(const PT::Date & date, PT::TextStream & stream); virtual void esc(const PT::TextStream & val,PT::TextStream & stream); + virtual bool is_long_field_name(const wchar_t * field_name); + virtual bool is_long_field_name(const PT::TextStream & table_name); + + virtual bool is_long_table_name(const wchar_t * field_name); + virtual bool is_long_table_name(const PT::TextStream & table_name); @@ -287,7 +268,12 @@ protected: //void field(const wchar_t * field_name, Model & field, bool insertable = true, bool updatable = true); - virtual void put_field_name(const wchar_t * field_name, bool add_column_prefix = true, ModelEnv * model_env = nullptr); + virtual bool need_to_add_field_prefix(const wchar_t * field_name); + + virtual void put_field_name(const wchar_t * field_name, ModelEnv * model_env); + + virtual void save_foreign_key(const wchar_t * field_name, ModelEnv * model_env); + template void put_field_value(const FieldValue & field_value) @@ -316,6 +302,15 @@ protected: (*out_stream) << ","; } + virtual void put_statement_in_starts() + { + (*out_stream) << "("; + } + + virtual void put_statement_in_ends() + { + (*out_stream) << ") "; + } // what about lists with a pod types? e.g. list template @@ -350,7 +345,7 @@ protected: // used in 'in()' statements, may should be renamed? template - void field_in_generic(PT::TextStream & stream, const wchar_t * field_name, const Container & container) + void field_in_generic(PT::TextStream & stream, const wchar_t * field_name, const Container & container, ModelEnv * model_env) { // IMPROVE ME // what about if container is empty? @@ -358,24 +353,24 @@ protected: this->out_stream = &stream; field_before(); - put_field_name(field_name); + put_field_name(field_name, model_env); put_name_value_separator(); bool is_first = true; - (*out_stream) << "("; + put_statement_in_starts(); for(const FieldValue & v : container) { if( !is_first ) { - (*out_stream) << ","; + field_value_list_separator(); } put_field_value(v); is_first = false; } - (*out_stream) << ") "; + put_statement_in_ends(); field_after(); this->out_stream = nullptr; } diff --git a/src/dbconnector.cpp b/src/dbconnector.cpp index d74d1d2..9654b8a 100644 --- a/src/dbconnector.cpp +++ b/src/dbconnector.cpp @@ -157,9 +157,10 @@ void DbConnector::generate_select_columns(PT::TextStream & stream, Model & model if( db_expression ) { - db_expression->prepare_to_new_expression(); + db_expression->clear(); db_expression->set_work_mode(MORM_WORK_MODE_MODEL_FIELDS); db_expression->set_output_type(MORM_OUTPUT_TYPE_SELECT_COLUMNS); + db_expression->allow_to_use_prefix(true); db_expression->generate_from_model(stream, model); } } @@ -171,7 +172,9 @@ void DbConnector::generate_insert_query(PT::TextStream & stream, Model & model) if( db_expression ) { - db_expression->prepare_to_new_expression(); + db_expression->clear(); + db_expression->allow_to_use_prefix(true); + stream << "insert into "; model.table_name(stream); @@ -194,7 +197,9 @@ void DbConnector::generate_update_query(PT::TextStream & stream, Model & model) if( db_expression ) { - db_expression->prepare_to_new_expression(); + db_expression->clear(); + db_expression->allow_to_use_prefix(true); + stream << "update "; model.table_name(stream); @@ -217,7 +222,9 @@ void DbConnector::generate_remove_query(PT::TextStream & stream, Model & model) if( db_expression ) { - db_expression->prepare_to_new_expression(); + db_expression->clear(); + db_expression->allow_to_use_prefix(true); + stream << "delete from "; model.table_name(stream); stream << " where "; diff --git a/src/dbexpression.cpp b/src/dbexpression.cpp index 43f098b..f65e48e 100644 --- a/src/dbexpression.cpp +++ b/src/dbexpression.cpp @@ -140,6 +140,11 @@ void DbExpression::put_name_value_separator() (*out_stream) << " = "; } else + if( output_type == MORM_OUTPUT_TYPE_WHERE_NOT_EQ ) + { + (*out_stream) << " <> "; + } + else if( output_type == MORM_OUTPUT_TYPE_WHERE_LT ) { (*out_stream) << " < "; @@ -296,4 +301,40 @@ DbExpression & DbExpression::page(PT::TextStream & stream, size_t page_number, s return *this; } + + + + +void DbExpression::prepare_short_table_name(const PT::TextStream & table_name, PT::TextStream & short_table_name) +{ + short_table_name.clear(); + + if( is_long_table_name(table_name) ) + { + PT::TextStream::const_iterator i = table_name.begin(); + bool was_dot = false; + + while( i != table_name.end() ) + { + if( was_dot ) + { + short_table_name << *i; + } + else + if( *i == '.' ) + { + was_dot = true; + } + + ++i; + } + } + + if( short_table_name.empty() ) + { + short_table_name = table_name; + } +} + + } diff --git a/src/dbexpression.h b/src/dbexpression.h index b679c36..53d2dba 100644 --- a/src/dbexpression.h +++ b/src/dbexpression.h @@ -71,10 +71,15 @@ public: column_expression += L" as "; column_expression += new_column_name; - field(column_expression.c_str(), field_value, false, false, false, false); + // put nullptr to ModelEnv* to not allow to use prefix + // or may better remember current value of use_prefix and set it to false for a while? + field(column_expression.c_str(), field_value, false, false, false, nullptr); } + virtual void prepare_short_table_name(const PT::TextStream & table_name, PT::TextStream & short_table_name); + + protected: int output_type; diff --git a/src/finder.h b/src/finder.h index cf645f5..86faf13 100644 --- a/src/finder.h +++ b/src/finder.h @@ -116,23 +116,6 @@ public: -protected: - - void set_out_stream() - { - if( model_connector ) - { - this->out_stream = model_connector->get_stream(); - } - else - { - this->out_stream = nullptr; - } - } - - -public: - Finder & set_out_stream(PT::TextStream * out_stream) { this->out_stream = out_stream; @@ -243,22 +226,22 @@ public: model.model_env = &model_env; model.model_env->model_data = model_data; model.model_env->finder_helper = &finder_helper; - model.prepare_to_select(); has_autogenerated_select = true; - if( model_connector && out_stream ) + if( model_connector && out_stream && db_expression ) { model.table_name(model.model_env->table_name); - model.table_name_for_join_as(model.model_env->table_name_simple); - model.model_env->table_index = finder_helper.add_join_table(model.model_env->table_name_simple); + db_expression->prepare_short_table_name(model.model_env->table_name, model.model_env->table_name_short); + + model.model_env->table_index = finder_helper.add_join_table(model.model_env->table_name_short); (*out_stream) << "SELECT "; model.generate_select_columns(*out_stream); (*out_stream) << " FROM " << model.model_env->table_name << " AS "; - (*out_stream) << model.model_env->table_name_simple; + (*out_stream) << model.model_env->table_name_short; (*out_stream) << " "; - (*out_stream) << finder_helper.morm_finder_join_tables; + (*out_stream) << finder_helper.join_tables_str; } return *this; @@ -342,27 +325,32 @@ public: if( db_expression ) { db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_EQ); - - bool put_table_prefix = true; - - // IMPROVE ME - // add check if there is a dot char in field_name? - // or add a second eq() method with an additional parameter -- table name? - - db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, put_table_prefix, &model_env); + db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, &model_env); } return *this; } + template + Finder & neq(const wchar_t * field_name, const FieldValue & field_value) + { + if( db_expression ) + { + db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_NOT_EQ); + db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, &model_env); + } + + return *this; + } + template Finder & lt(const wchar_t * field_name, const FieldValue & field_value) { if( db_expression ) { db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_LT); - db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, true, &model_env); + db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, &model_env); } return *this; @@ -375,7 +363,7 @@ public: if( db_expression ) { db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_GT); - db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, true, &model_env); + db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, &model_env); } return *this; @@ -388,7 +376,7 @@ public: if( db_expression ) { db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_LE); - db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, true, &model_env); + db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, &model_env); } return *this; @@ -401,7 +389,7 @@ public: if( db_expression ) { db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_GE); - db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, true, &model_env); + db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, &model_env); } return *this; @@ -415,7 +403,7 @@ public: if( db_expression ) { db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_IN); - db_expression->field_in(*out_stream, field_name, container); + db_expression->field_in(*out_stream, field_name, container, &model_env); } return *this; @@ -427,7 +415,7 @@ public: if( db_expression ) { db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_IN); - db_expression->field_in(*out_stream, field_name, container); + db_expression->field_in(*out_stream, field_name, container, &model_env); } return *this; @@ -439,7 +427,7 @@ public: if( db_expression ) { db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_IN); - db_expression->field_in(*out_stream, field_name, container); + db_expression->field_in(*out_stream, field_name, container, &model_env); } return *this; @@ -566,6 +554,22 @@ public: +protected: + + void set_out_stream() + { + if( model_connector ) + { + this->out_stream = model_connector->get_stream(); + } + else + { + this->out_stream = nullptr; + } + } + + + private: @@ -591,12 +595,13 @@ private: if( db_connector ) { db_expression = db_connector->get_expression(); - db_expression->allow_to_use_prefix(true); } } } + + }; } // namespace diff --git a/src/finderhelper.h b/src/finderhelper.h index ba1e3a8..4898fe8 100644 --- a/src/finderhelper.h +++ b/src/finderhelper.h @@ -46,9 +46,11 @@ class FinderHelper { public: - PT::TextStream morm_finder_join_tables; - std::map morm_table_join_map; - std::list morm_foreign_keys; + PT::TextStream join_tables_str; + + std::map join_tables_map; + + std::list foreign_keys; @@ -64,9 +66,9 @@ public: virtual void clear() { - morm_finder_join_tables.clear(); - morm_table_join_map.clear(); - morm_foreign_keys.clear(); + join_tables_str.clear(); + join_tables_map.clear(); + foreign_keys.clear(); } @@ -81,7 +83,7 @@ public: virtual int add_join_table(const std::string & table_name) { - auto res = morm_table_join_map.insert(std::make_pair(table_name, 1)); + auto res = join_tables_map.insert(std::make_pair(table_name, 1)); if( !res.second ) { diff --git a/src/flatconnector.cpp b/src/flatconnector.cpp index d686fd5..99bdb7d 100644 --- a/src/flatconnector.cpp +++ b/src/flatconnector.cpp @@ -74,7 +74,9 @@ void FlatConnector::to_text(PT::TextStream & stream, Model & model) if( flat_expression ) { + flat_expression->clear(); flat_expression->set_work_mode(MORM_WORK_MODE_MODEL_FIELDS_VALUES); + flat_expression->allow_to_use_prefix(false); flat_expression->generate_from_model(stream, model); } } diff --git a/src/jsonexpression.h b/src/jsonexpression.h index 4a7e5e5..2d149f5 100644 --- a/src/jsonexpression.h +++ b/src/jsonexpression.h @@ -68,16 +68,6 @@ protected: void after_field_value_list(); - template - void print_field_name_value(const wchar_t * field_name, const FieldValue & field_value) - { - put_field_name(field_name); - (*out_stream) << ":"; - put_field_value(field_value); - } - - - void esc(char val, PT::TextStream & stream); diff --git a/src/model.cpp b/src/model.cpp index 8770457..7ce8d7f 100644 --- a/src/model.cpp +++ b/src/model.cpp @@ -99,39 +99,6 @@ void Model::table_name(PT::TextStream & stream) } -// the body can be moved to dbexpression -// the algorithm can be different depending on the database used -void Model::table_name_for_join_as(PT::TextStream & stream) -{ - PT::TextStream str_temp; - table_name(str_temp); - - // temporarily - std::string str; - str_temp.to_string(str); - - size_t i = str.size(); - - while( i-- > 0 ) - { - if( str[i] == '.' ) - { - break; - } - } - - - if( str[i] == '.' ) - { - i += 1; - } - - for( ; i < str.size() ; ++i) - { - stream << str[i]; - } -} - void Model::set_connector(ModelConnector & connector) { @@ -175,9 +142,9 @@ void Model::to_text(PT::TextStream & stream, ModelData * model_data, bool clear_ if( flat_connector ) { - this->model_env->model_data = model_data; + model_env->model_data = model_data; flat_connector->to_text(stream, *this); - this->model_env->model_data = nullptr; + model_env->model_data = nullptr; } } @@ -554,11 +521,6 @@ void Model::clear() } -void Model::prepare_to_select() -{ - model_env->table_index = 1; -} - diff --git a/src/model.h b/src/model.h index 7eec1cd..e14b616 100644 --- a/src/model.h +++ b/src/model.h @@ -95,7 +95,6 @@ public: * */ virtual void table_name(PT::TextStream & stream); - virtual void table_name_for_join_as(PT::TextStream & stream); virtual void to_text(PT::TextStream & stream, ModelData * model_data, bool clear_stream = true); virtual void to_text(PT::TextStream & stream, ModelData & model_data, bool clear_stream = true); @@ -131,8 +130,6 @@ public: // set object to default values virtual void clear(); - // we need a pointer to ModelData here? - virtual void prepare_to_select(); protected: @@ -649,7 +646,7 @@ protected: if( flat_expression && !is_empty_field(flat_field_name) ) { // insertable, updatable and is_primary_key are ignored here - flat_expression->field(flat_field_name, field_value, insertable, updatable, is_primary_key, true, model_env); + flat_expression->field(flat_field_name, field_value, insertable, updatable, is_primary_key, model_env); } } } @@ -664,7 +661,7 @@ protected: if( db_expression && !is_empty_field(db_field_name) ) { - db_expression->field(db_field_name, field_value, insertable, updatable, is_primary_key, true, model_env); + db_expression->field(db_field_name, field_value, insertable, updatable, is_primary_key, model_env); } } } @@ -712,7 +709,7 @@ protected: if( doc_expression && !is_empty_field(flat_field_name) ) { // insertable, updatable and is_primary_key are ignored here - doc_expression->field_doc(*this, flat_field_name, field_value, insertable, updatable, is_primary_key); + doc_expression->field_doc(*this, flat_field_name, field_value, insertable, updatable, is_primary_key, model_env); } } } @@ -724,14 +721,14 @@ protected: { if( model_env && field_model.model_env && model_env->finder_helper ) { - model_env->finder_helper->morm_foreign_keys.clear(); - field_model.model_env->table_index = model_env->finder_helper->add_join_table(field_model.model_env->table_name_simple); + model_env->finder_helper->foreign_keys.clear(); + field_model.model_env->table_index = model_env->finder_helper->add_join_table(field_model.model_env->table_name_short); - model_env->finder_helper->morm_finder_join_tables << "LEFT JOIN " << field_model.model_env->table_name - << " AS " << field_model.model_env->table_name_simple; + model_env->finder_helper->join_tables_str << "LEFT JOIN " << field_model.model_env->table_name + << " AS " << field_model.model_env->table_name_short; if( field_model.model_env->table_index > 1 ) - model_env->finder_helper->morm_finder_join_tables << field_model.model_env->table_index; + model_env->finder_helper->join_tables_str << field_model.model_env->table_index; int expr_work_mode = db_expression->get_work_mode(); int expr_output_type = db_expression->get_output_type(); @@ -745,29 +742,29 @@ protected: { field_model.map_fields(); - model_env->finder_helper->morm_finder_join_tables << " ON " << model_env->table_name_simple << '.' - << db_field_name << " = " << field_model.model_env->table_name_simple << '.'; + model_env->finder_helper->join_tables_str << " ON " << model_env->table_name_short << '.' + << db_field_name << " = " << field_model.model_env->table_name_short << '.'; - if( model_env->finder_helper->morm_foreign_keys.size() == 1 ) + if( model_env->finder_helper->foreign_keys.size() == 1 ) { - model_env->finder_helper->morm_finder_join_tables << model_env->finder_helper->morm_foreign_keys.front(); + model_env->finder_helper->join_tables_str << model_env->finder_helper->foreign_keys.front(); } } else { map_fields(); - model_env->finder_helper->morm_finder_join_tables << " ON " << model_env->table_name_simple << '.'; + model_env->finder_helper->join_tables_str << " ON " << model_env->table_name_short << '.'; - if( model_env->finder_helper->morm_foreign_keys.size() == 1 ) + if( model_env->finder_helper->foreign_keys.size() == 1 ) { - model_env->finder_helper->morm_finder_join_tables << model_env->finder_helper->morm_foreign_keys.front(); + model_env->finder_helper->join_tables_str << model_env->finder_helper->foreign_keys.front(); } - model_env->finder_helper->morm_finder_join_tables << " = " << field_model.model_env->table_name_simple << '.' << db_field_name; + model_env->finder_helper->join_tables_str << " = " << field_model.model_env->table_name_short << '.' << db_field_name; } - model_env->finder_helper->morm_finder_join_tables << ' '; + model_env->finder_helper->join_tables_str << ' '; db_expression->set_work_mode(expr_work_mode); db_expression->set_output_type(expr_output_type); @@ -777,7 +774,7 @@ protected: - void field_model_generate_flat_string(const wchar_t * db_field_name, const wchar_t * flat_field_name, Model & field_model, bool insertable, bool updatable, bool has_foreign_key) + void field_model_generate_flat_string(const wchar_t * db_field_name, const wchar_t * flat_field_name, Model & field_model, bool insertable, bool updatable) { FlatConnector * flat_connector = model_connector->get_flat_connector(); @@ -788,7 +785,7 @@ protected: if( flat_expression && !is_empty_field(flat_field_name) ) { field_model.model_env->model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING; - flat_expression->field_model(flat_field_name, field_model, insertable, updatable, false); + flat_expression->field_model(flat_field_name, field_model, insertable, updatable, false, model_env); } } } @@ -807,7 +804,7 @@ protected: field_model.model_env->model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL; field_model.table_name(field_model.model_env->table_name); - field_model.table_name_for_join_as(field_model.model_env->table_name_simple); + db_expression->prepare_short_table_name(field_model.model_env->table_name, field_model.model_env->table_name_short); if( db_expression->get_output_type() == MORM_OUTPUT_TYPE_SELECT_COLUMNS ) { @@ -848,7 +845,7 @@ protected: if( doc_expression && !is_empty_field(flat_field_name) ) { // insertable, updatable and is_primary_key are ignored here - doc_expression->field_doc(*this, flat_field_name, field_model, insertable, updatable, false); + doc_expression->field_doc(*this, flat_field_name, field_model, insertable, updatable, false, model_env); } } } @@ -885,7 +882,7 @@ protected: if( model_env->model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING ) { - field_model_generate_flat_string(db_field_name, flat_field_name, field_model, insertable, updatable, has_foreign_key); + field_model_generate_flat_string(db_field_name, flat_field_name, field_model, insertable, updatable); } if( model_env->model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL ) @@ -976,7 +973,7 @@ protected: if( doc_expression && !is_empty_field(flat_field_name) ) { // insertable, updatable and is_primary_key are ignored here - doc_expression->field_doc(*this, flat_field_name, field_container, insertable, updatable, false, model_env->model_data); + doc_expression->field_doc(*this, flat_field_name, field_container, insertable, updatable, false, model_env); } } } diff --git a/src/modelenv.h b/src/modelenv.h index f6eb01d..776d439 100644 --- a/src/modelenv.h +++ b/src/modelenv.h @@ -56,7 +56,7 @@ public: const void * doc_field_pointer; PT::TextStream table_name; - PT::TextStream table_name_simple; + PT::TextStream table_name_short; int table_index; @@ -102,7 +102,7 @@ public: model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; doc_field_pointer = nullptr; table_name.clear(); - table_name_simple.clear(); + table_name_short.clear(); table_index = 0; } diff --git a/src/morm_types.h b/src/morm_types.h index 5b3f801..d1a2c61 100644 --- a/src/morm_types.h +++ b/src/morm_types.h @@ -77,6 +77,7 @@ #define MORM_OUTPUT_TYPE_WHERE_LE 13 #define MORM_OUTPUT_TYPE_WHERE_GE 14 #define MORM_OUTPUT_TYPE_WHERE_IN 15 +#define MORM_OUTPUT_TYPE_WHERE_NOT_EQ 16 #define MORM_CONJUNCTION_AND 1