diff --git a/src/finder.h b/src/finder.h index ae8a112..f0a17ce 100644 --- a/src/finder.h +++ b/src/finder.h @@ -202,7 +202,7 @@ public: if( model_connector && out_stream ) { (*out_stream) << "SELECT "; - model_connector->generate_select_columns(*out_stream, model, column_prefix); + model.generate_select_columns(*out_stream, column_prefix); (*out_stream) << " FROM "; model.table_name(*out_stream); @@ -454,7 +454,7 @@ public: if( db_connector->last_select_size() == 1 ) { result.set_save_mode(Model::DO_UPDATE_ON_SAVE); // IMPROVE ME check if there is a primary key - model_connector->map_values_from_query(result); + result.map_values_from_query(); result.after_select(); } else @@ -524,7 +524,7 @@ public: added_model.set_save_mode(Model::DO_UPDATE_ON_SAVE); // IMPROVE ME check if there is a primary key added_model.model_data = model_data; added_model.before_select(); - model_connector->map_values_from_query(added_model); + added_model.map_values_from_query(); added_model.after_select(); db_connector->advance_current_row(); diff --git a/src/model.cpp b/src/model.cpp index 71fc271..82e57a4 100644 --- a/src/model.cpp +++ b/src/model.cpp @@ -148,19 +148,35 @@ void Model::to_text(PT::TextStream & stream, bool clear_stream) stream.clear(); } + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING; + if( model_connector ) { - model_connector->to_text(stream, *this); + FlatConnector * flat_connector = model_connector->get_flat_connector(); + + if( flat_connector ) + { + flat_connector->to_text(stream, *this); + } } + + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; } void Model::to_text(std::string & str, bool clear_string) { - PT::TextStream stream; + if( model_connector ) + { + // CHECK ME what if the stream is being used by something other? + PT::TextStream * out_stream = model_connector->get_stream(); - to_text(stream, false); - stream.to_string(str, clear_string); + if( out_stream ) + { + to_text(*out_stream, true); + out_stream->to_string(str, clear_string); + } + } } @@ -168,7 +184,7 @@ std::string Model::to_text() { std::string str; - to_text(str); + to_text(str, false); return str; } @@ -179,15 +195,26 @@ std::string Model::to_string() } + void Model::generate_insert_query(PT::TextStream & stream) { + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL; + if( model_connector ) { - model_connector->generate_insert_query(stream, *this); + DbConnector * db_connector = model_connector->get_db_connector(); + + if( db_connector ) + { + db_connector->generate_insert_query(stream, *this); + } } + + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; } + bool Model::insert(ModelData * model_data) { bool result = false; @@ -195,20 +222,38 @@ bool Model::insert(ModelData * model_data) if( model_connector ) { this->model_data = model_data; + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL; + DbConnector * db_connector = model_connector->get_db_connector(); - if( model_connector->insert(*this) ) + // CHECK ME what if the stream is being used by something other? + PT::TextStream * out_stream = model_connector->get_stream(); + + if( db_connector && out_stream ) { - save_mode = DO_UPDATE_ON_SAVE; // IMPROVE ME check if there is a primary key - result = true; + before_insert(); + out_stream->clear(); + result = db_connector->insert(*out_stream, *this); + + if( result ) + { + save_mode = DO_UPDATE_ON_SAVE; // IMPROVE ME check if there is a primary key + after_insert(); + } + else + { + after_insert_failure(); + } } this->model_data = nullptr; + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; } return result; } + bool Model::insert(ModelData & model_data) { return insert(&model_data); @@ -217,10 +262,19 @@ bool Model::insert(ModelData & model_data) void Model::generate_update_query(PT::TextStream & stream) { + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL; + if( model_connector ) { - model_connector->generate_update_query(stream, *this); + DbConnector * db_connector = model_connector->get_db_connector(); + + if( db_connector ) + { + db_connector->generate_update_query(stream, *this); + } } + + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; } @@ -231,8 +285,26 @@ bool Model::update(ModelData * model_data) if( model_connector ) { this->model_data = model_data; - result = model_connector->update(*this); + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL; + DbConnector * db_connector = model_connector->get_db_connector(); + + // CHECK ME what if the stream is being used by something other? + PT::TextStream * out_stream = model_connector->get_stream(); + + if( db_connector && out_stream ) + { + before_update(); + out_stream->clear(); + result = db_connector->update(*out_stream, *this); + + if( result ) + after_update(); + else + after_update_failure(); + } + this->model_data = nullptr; + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; } return result; @@ -249,7 +321,15 @@ void Model::generate_remove_query(PT::TextStream & stream) { if( model_connector ) { - model_connector->generate_remove_query(stream, *this); + DbConnector * db_connector = model_connector->get_db_connector(); + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL; + + if( db_connector ) + { + db_connector->generate_remove_query(stream, *this); + } + + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; } } @@ -261,14 +341,31 @@ bool Model::remove(ModelData * model_data) if( model_connector ) { this->model_data = model_data; + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL; + DbConnector * db_connector = model_connector->get_db_connector(); - if( model_connector->remove(*this) ) + // CHECK ME what if the stream is being used by something other? + PT::TextStream * out_stream = model_connector->get_stream(); + + if( db_connector && out_stream ) { - save_mode = DO_INSERT_ON_SAVE; - result = true; + before_remove(); + out_stream->clear(); + result = db_connector->remove(*out_stream, *this); + + if( result ) + { + save_mode = DO_INSERT_ON_SAVE; + after_remove(); + } + else + { + after_remove_failure(); + } } this->model_data = nullptr; + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; } return result; @@ -300,7 +397,7 @@ bool Model::save(ModelData * model_data) break; case DO_NOTHING_ON_SAVE: - // may return true? + result = true; break; } @@ -314,20 +411,48 @@ bool Model::save(ModelData & model_data) } -void Model::clear() +void Model::generate_select_columns(PT::TextStream & stream, const std::wstring & column_prefix) { if( model_connector ) { - model_connector->clear_values(*this); + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL; + DbConnector * db_connector = model_connector->get_db_connector(); + + if( db_connector ) + { + db_connector->generate_select_columns(stream, *this, column_prefix); + } + + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; } +} + + +void Model::map_values_from_query() +{ + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_READING_VALUE_FROM_DB_RESULTSET; + map_fields(); + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; +} + + + +void Model::clear() +{ + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE; + map_fields(); + model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; save_mode = DO_INSERT_ON_SAVE; model_data = nullptr; - - // do not set model_connector_mode here as it can be set to 'clearing' } + + + + + void Model::before_select() { } @@ -381,6 +506,11 @@ int Model::get_connector_mode() return model_connector_mode; } +bool Model::is_empty_field(const wchar_t * value) +{ + return (!value || *value == '\0'); +} + } // namespace diff --git a/src/model.h b/src/model.h index a746cf9..59ef0a8 100644 --- a/src/model.h +++ b/src/model.h @@ -125,6 +125,7 @@ public: virtual bool save(ModelData * model_data = nullptr); virtual bool save(ModelData & model_data); + virtual void generate_select_columns(PT::TextStream & stream, const std::wstring & column_prefix); // set object to default values virtual void clear(); @@ -157,6 +158,10 @@ protected: virtual int get_connector_mode(); + // used by Finder + virtual void map_values_from_query(); + + ///////////////////////////////// void field(const wchar_t * field_name, char & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false) @@ -259,21 +264,15 @@ protected: field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key); } - void field(const wchar_t * field_name, Model & field_model, bool insertable = true, bool updatable = true, bool is_primary_key = false) + void field(const wchar_t * field_name, Model & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false) { - if( model_connector ) - { - model_connector->field_model(field_name, field_name, field_model, insertable, updatable, is_primary_key, model_connector_mode); - } + field_model(field_name, field_name, field_value, insertable, updatable, is_primary_key); } template - void field(const wchar_t * field_name, std::list & field_list, bool insertable = true, bool updatable = true, bool is_primary_key = false) + void field(const wchar_t * field_name, std::list & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false) { - if( model_connector ) - { - model_connector->field_list(field_name, field_name, field_list, insertable, updatable, is_primary_key, model_connector_mode); - } + field_list(field_name, field_name, field_value, insertable, updatable, is_primary_key); } @@ -380,21 +379,15 @@ protected: } - void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, Model & field_model, bool insertable = true, bool updatable = true, bool is_primary_key = false) + void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, Model & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false) { - if( model_connector ) - { - model_connector->field_model(db_field_name, flat_field_name, field_model, insertable, updatable, is_primary_key, model_connector_mode); - } + field_model(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key); } template - void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, std::list & field_list, bool insertable = true, bool updatable = true, bool is_primary_key = false) + void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, std::list & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false) { - if( model_connector ) - { - model_connector->field_list(db_field_name, flat_field_name, field_list, insertable, updatable, is_primary_key, model_connector_mode); - } + field_list(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key); } ////////////////////// @@ -402,54 +395,154 @@ protected: protected: + template - void field_generic(const wchar_t * field_name, FieldValue & field_value, bool insertable, bool updatable, bool is_primary_key) + void field_generic(const wchar_t * db_field_name, const wchar_t * flat_field_name, FieldValue & field_value, bool insertable, bool updatable, bool is_primary_key) { if( model_connector ) { - model_connector->field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key, model_connector_mode); + if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING ) + { + FlatConnector * flat_connector = model_connector->get_flat_connector(); + + if( flat_connector ) + { + FlatExpression * flat_expression = flat_connector->get_expression(); + + 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); + } + } + } + + if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL ) + { + DbConnector * db_connector = model_connector->get_db_connector(); + + if( db_connector ) + { + DbExpression * db_expression = db_connector->get_expression(); + + if( db_expression && !is_empty_field(db_field_name) ) + { + db_expression->field(db_field_name, field_value, insertable, updatable, is_primary_key); + } + } + } + + if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_READING_VALUE_FROM_DB_RESULTSET ) + { + DbConnector * db_connector = model_connector->get_db_connector(); + + if( db_connector ) + { + if( !is_empty_field(db_field_name) ) + db_connector->get_value_by_field_name(db_field_name, field_value); + } + } + + if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE ) + { + DbConnector * db_connector = model_connector->get_db_connector(); + + if( db_connector ) + { + // IMPROVE ME those clearing should be moved to a better place + db_connector->clear_value(field_value); + } + } } } - template - void field_generic(const wchar_t * db_field_name, const wchar_t * flat_field_name, FieldValue & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false) + + template + void field_list(const wchar_t * db_field_name, const wchar_t * flat_field_name, std::list & field_list, bool insertable, bool updatable, bool is_primary_key) + { + // IMPLEMENTME what about db? + if( model_connector ) + { + if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING ) + { + FlatConnector * flat_connector = model_connector->get_flat_connector(); + + if( flat_connector ) + { + FlatExpression * flat_expression = flat_connector->get_expression(); + + if( flat_expression && !is_empty_field(flat_field_name) ) + { + flat_expression->field_list(flat_field_name, field_list, insertable, updatable, is_primary_key, model_connector_mode); + } + } + } + + if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE ) + { + field_list.clear(); + } + + // WILL BE REMOVED + if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_SETTING_CONNECTOR_FOR_CHILDS ) + { + // IMPROVE ME + // it would be better to set the connector when an operation is needed + } + } + } + + template + void field_model(const wchar_t * db_field_name, const wchar_t * flat_field_name, ModelX & field_model, bool insertable, bool updatable, bool is_primary_key) { if( model_connector ) { - model_connector->field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key, model_connector_mode); + // IMPLEMENTME what about db? + if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING ) + { + FlatConnector * flat_connector = model_connector->get_flat_connector(); + + if( flat_connector ) + { + FlatExpression * flat_expression = flat_connector->get_expression(); + + if( flat_expression && !is_empty_field(flat_field_name) ) + { + field_model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING; + flat_expression->field_model(flat_field_name, field_model, insertable, updatable, is_primary_key); + field_model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; + } + } + } + + if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE ) + { + field_model.clear(); + } + + // WILL BE REMOVED + if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_SETTING_CONNECTOR_FOR_CHILDS ) + { + field_model.set_connector(model_connector); + } } } public: -/* - template - void field_generic_textstream(const PT::TextStream & field_name, FieldValue & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false) - { - if( model_connector ) - { - model_connector->field(field_name, field_name, field_value, insertable, updatable, is_primary_key); - } - } - - template - void field_generic_textstream(const PT::TextStream & db_field_name, const PT::TextStream & flat_field_name, FieldValue & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false) - { - if( model_connector ) - { - model_connector->field(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key); - } - } -*/ - template void get_last_sequence(const wchar_t * sequence_table_name, FieldValue & field_value) { if( model_connector ) { - model_connector->get_last_sequence(sequence_table_name, field_value); + DbConnector * db_connector = model_connector->get_db_connector(); + + if( db_connector && !is_empty_field(sequence_table_name) ) + { + db_connector->get_last_sequence(sequence_table_name, field_value); + } } } @@ -461,22 +554,32 @@ public: { if( get_connector_mode() == MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL ) { - model_connector->add_field_for_select(new_column_expression, new_column_name, field_value, model_connector_mode); + DbConnector * db_connector = model_connector->get_db_connector(); + + if( db_connector ) + { + DbExpression * db_expression = db_connector->get_expression(); + + if( db_expression && !is_empty_field(new_column_expression) ) + { + db_expression->add_field_for_select(new_column_expression, new_column_name, field_value); + } + } } else if( get_connector_mode() == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING ) { - model_connector->field_generic(L"", flat_field_name, field_value, false, false, false, model_connector_mode); + field_generic(L"", flat_field_name, field_value, false, false, false); } else if( get_connector_mode() == MORM_MODEL_CONNECTOR_MODE_READING_VALUE_FROM_DB_RESULTSET ) { - model_connector->field_generic(new_column_name, L"", field_value, false, false, false, model_connector_mode); + field_generic(new_column_name, L"", field_value, false, false, false); } else if( get_connector_mode() == MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE ) { - model_connector->field_generic(L"", L"", field_value, false, false, false, model_connector_mode); // the names don't matter here + field_generic(L"", L"", field_value, false, false, false); // the names don't matter here } } } @@ -487,11 +590,17 @@ public: add_field_for_select(new_column_expression, new_column_name, new_column_name, field_value); } - template friend class Finder; - friend class ModelConnector; +protected: + + virtual bool is_empty_field(const wchar_t * value); + + + template friend class Finder; friend class BaseExpression; + // WILL BE REMOVED when ModelConnector::set_connector_for_childs(Model & model) will be removed + friend class ModelConnector; }; } // namespace diff --git a/src/modelconnector.cpp b/src/modelconnector.cpp index 2e4fd83..9a620b1 100644 --- a/src/modelconnector.cpp +++ b/src/modelconnector.cpp @@ -72,21 +72,6 @@ void ModelConnector::set_logger(PT::Logger & logger) -void ModelConnector::set_db_expression_output_type(int output_type) -{ - if( db_connector ) - { - DbExpression * db_expression = db_connector->get_expression(); - - if( db_expression ) - { - db_expression->set_output_type(output_type); - } - } -} - - - void ModelConnector::deallocate_stream() { if( out_stream_allocated ) @@ -137,6 +122,13 @@ void ModelConnector::set_flat_connector(FlatConnector & flat_connector) } +FlatConnector * ModelConnector::get_flat_connector() +{ + return this->flat_connector; +} + + + void ModelConnector::set_db_connector(DbConnector & db_connector) { this->db_connector = &db_connector; @@ -172,205 +164,6 @@ std::wstring ModelConnector::get_db_error() - -void ModelConnector::to_text(PT::TextStream & stream, Model & model) -{ - if( flat_connector ) - { - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING; - //expression_callback = flat_connector->get_expression(); - - //if( expression_callback ) - //{ - flat_connector->to_text(stream, model); - //} - - //expression_callback = nullptr; - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; - } -} - - -void ModelConnector::generate_select_columns(PT::TextStream & stream, Model & model, const std::wstring & column_prefix) -{ - if( db_connector ) - { - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL; - //expression_callback = db_connector->get_expression(); - - //if( expression_callback ) - //{ - db_connector->generate_select_columns(stream, model, column_prefix); - //} - - //expression_callback = nullptr; - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; - } -} - - - -void ModelConnector::generate_insert_query(PT::TextStream & stream, Model & model) -{ - if( db_connector ) - { - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL; - //expression_callback = db_connector->get_expression(); - - //if( expression_callback ) - //{ - db_connector->generate_insert_query(stream, model); - //} - - //expression_callback = nullptr; - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; - } -} - - -void ModelConnector::generate_update_query(PT::TextStream & stream, Model & model) -{ - if( db_connector ) - { - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL; - //expression_callback = db_connector->get_expression(); - - //if( expression_callback ) - //{ - db_connector->generate_update_query(stream, model); - //} - - //expression_callback = nullptr; - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; - } -} - - -void ModelConnector::generate_remove_query(PT::TextStream & stream, Model & model) -{ - if( db_connector ) - { - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL; - db_connector->generate_remove_query(stream, model); - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; - } -} - - - - - -bool ModelConnector::insert(Model & model) -{ - bool result = false; - allocate_default_stream_if_needed(); - - if( db_connector && out_stream ) - { - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL; - //db_connector_callback = db_connector; - - model.before_insert(); - out_stream->clear(); - result = db_connector->insert(*out_stream, model); - - if( result ) - model.after_insert(); - else - model.after_insert_failure(); - - //db_connector_callback = nullptr; - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; - } - - return result; -} - - -bool ModelConnector::update(Model & model) -{ - bool result = false; - allocate_default_stream_if_needed(); - - if( db_connector && out_stream ) - { - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL; - //db_connector_callback = db_connector; - - model.before_update(); - out_stream->clear(); - result = db_connector->update(*out_stream, model); - - if( result ) - model.after_update(); - else - model.after_update_failure(); - - //db_connector_callback = nullptr; - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; - } - - return result; -} - - - - -bool ModelConnector::remove(Model & model) -{ - bool result = false; - allocate_default_stream_if_needed(); - - if( db_connector && out_stream ) - { - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL; - //db_connector_callback = db_connector; - - model.before_remove(); - out_stream->clear(); - result = db_connector->remove(*out_stream, model); - - if( result ) - model.after_remove(); - else - model.after_remove_failure(); - - //db_connector_callback = nullptr; - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; - } - - return result; -} - - -void ModelConnector::map_values_from_query(Model & model) -{ - // CHECK ME - // may we should set model.model_connector() to this? - // the same in other methods which get a model parameter - - if( db_connector ) - { - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_READING_VALUE_FROM_DB_RESULTSET; - //db_connector_callback = db_connector; - model.map_fields(); - //db_connector_callback = nullptr; - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; - } -} - - -void ModelConnector::clear_values(Model & model) -{ - if( db_connector ) - { - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE; - model.map_fields(); - model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; - } -} - - void ModelConnector::set_connector_for_childs(Model & model) { model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_SETTING_CONNECTOR_FOR_CHILDS; @@ -379,10 +172,5 @@ void ModelConnector::set_connector_for_childs(Model & model) } -bool ModelConnector::is_empty_field(const wchar_t * value) -{ - return (!value || *value == '\0'); -} - } diff --git a/src/modelconnector.h b/src/modelconnector.h index 4311649..8e4bac6 100644 --- a/src/modelconnector.h +++ b/src/modelconnector.h @@ -73,43 +73,16 @@ public: virtual PT::TextStream * get_stream(); virtual void set_flat_connector(FlatConnector & flat_connector); + virtual FlatConnector * get_flat_connector(); virtual void set_db_connector(DbConnector & db_connector); virtual DbConnector * get_db_connector(); - virtual void set_db_expression_output_type(int output_type); - - virtual void to_text(PT::TextStream & stream, Model & model); - - - virtual void generate_select_columns(PT::TextStream & stream, Model & model, const std::wstring & column_prefix); - virtual void generate_insert_query(PT::TextStream & stream, Model & model); - virtual void generate_update_query(PT::TextStream & stream, Model & model); - virtual void generate_remove_query(PT::TextStream & stream, Model & model); - - virtual bool insert(Model & model); - virtual bool update(Model & model); - virtual bool remove(Model & model); - - virtual void map_values_from_query(Model & model); - - virtual void clear_values(Model & model); - - template - void clear_values(std::list & list) - { - list.clear(); - } - + // WILL BE REMOVED + // model connector for childs will be set when needed virtual void set_connector_for_childs(Model & model); -// template -// Finder & find() -// { -// allocate_default_stream_if_needed(); -// return Finder(this); -// } protected: @@ -122,154 +95,10 @@ protected: PT::TextStream * out_stream; // IMPROVE ME give here an interface to the base stream (implement him) bool out_stream_allocated; - //BaseExpression * expression_callback; - //DbConnector * db_connector_callback; - void allocate_default_stream(); void allocate_default_stream_if_needed(); void deallocate_stream(); - - template - void field_generic(const wchar_t * db_field_name, const wchar_t * flat_field_name, FieldValue & field_value, bool insertable, bool updatable, bool is_primary_key, int model_connector_mode) - { - if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING && flat_connector ) - { - FlatExpression * flat_expression = flat_connector->get_expression(); - - 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); - } - } - - if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL && db_connector ) - { - DbExpression * db_expression = db_connector->get_expression(); - - if( db_expression && !is_empty_field(db_field_name) ) - { - db_expression->field(db_field_name, field_value, insertable, updatable, is_primary_key); - } - } - - if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_READING_VALUE_FROM_DB_RESULTSET && db_connector ) - { - if( !is_empty_field(db_field_name) ) - db_connector->get_value_by_field_name(db_field_name, field_value); - } - - if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE && db_connector ) - { - // IMPROVE ME those clearing should be moved to a better place - db_connector->clear_value(field_value); - } - } - - - /* - template - void field(const PT::TextStream & db_field_name, const PT::TextStream & flat_field_name, FieldValue & field_value, bool insertable, bool updatable, bool is_primary_key) - { - std::wstring db_field, flat_field; // field() methods from model connector can be called recursively, so don't make it as class objects - - db_field_name.to_string(db_field); - flat_field_name.to_string(flat_field); - - field(db_field.c_str(), flat_field.c_str(), field_value, insertable, updatable, is_primary_key); - } - */ - - template - //void field_list(const wchar_t * field_name, std::list & field_list, bool insertable = true, bool updatable = true, bool is_primary_key = false) - void field_list(const wchar_t * db_field_name, const wchar_t * flat_field_name, std::list & field_list, bool insertable, bool updatable, bool is_primary_key, int model_connector_mode) - { - // IMPLEMENTME what about db? - if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING && flat_connector ) - { - FlatExpression * flat_expression = flat_connector->get_expression(); - - if( flat_expression && !is_empty_field(flat_field_name) ) - { - flat_expression->field_list(flat_field_name, field_list, insertable, updatable, is_primary_key, model_connector_mode); - } - } - - if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE ) - { - field_list.clear(); - } - - if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_SETTING_CONNECTOR_FOR_CHILDS ) - { - // IMPROVE ME - // it would be better to set the connector when an operation is needed - } - } - - 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 * db_field_name, const wchar_t * flat_field_name, ModelClass & field_model, bool insertable, bool updatable, bool is_primary_key, int model_connector_mode) - { - // IMPLEMENTME what about db? - if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING && flat_connector ) - { - FlatExpression * flat_expression = flat_connector->get_expression(); - - if( flat_expression && !is_empty_field(flat_field_name) ) - { - field_model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING; - flat_expression->field_model(flat_field_name, field_model, insertable, updatable, is_primary_key); - field_model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE; - } - } - - if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE ) - { - field_model.clear(); - } - - if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_SETTING_CONNECTOR_FOR_CHILDS ) - { - field_model.set_connector(this); - } - } - - - template - void add_field_for_select(const wchar_t * new_column_expression, const wchar_t * new_column_name, FieldValue & field_value, int model_connector_mode) - { - if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL && db_connector ) - { - DbExpression * db_expression = db_connector->get_expression(); - - if( db_expression && !is_empty_field(new_column_expression) ) - { - db_expression->add_field_for_select(new_column_expression, new_column_name, field_value); - } - } - } - - template - void get_last_sequence(const wchar_t * sequence_table_name, FieldValue & field_value) - { - if( db_connector && !is_empty_field(sequence_table_name) ) - { - db_connector->get_last_sequence(sequence_table_name, field_value); - } - } - - - virtual bool is_empty_field(const wchar_t * value); - - /* - * Model is using field() method - */ - friend class Model; - template friend class Finder; - - }; }