tomasz.sowa/morm
1
0
Fork 0
Code Issues 2 Pull Requests Releases Activity

changed: some methods from ModelConnector moved to Model

Browse Source 
git-svn-id: svn://ttmath.org/publicrep/morm/trunk@1119 e52654a7-88a9-db11-a3e9-0013d4bc506e
This commit is contained in:
Tomasz Sowa
2018-07-04 11:34:49 +00:00
parent f85f03a889
commit 08cd621d41
5 changed files with 324 additions and 468 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/finder.h
View File

@@ -202,7 +202,7 @@ public:
if( model_connector && out_stream ) if( model_connector && out_stream )
{ {
(*out_stream) << "SELECT "; (*out_stream) << "SELECT ";
model_connector->generate_select_columns(*out_stream, model, column_prefix); model.generate_select_columns(*out_stream, column_prefix);
(*out_stream) << " FROM "; (*out_stream) << " FROM ";
model.table_name(*out_stream); model.table_name(*out_stream);
@@ -454,7 +454,7 @@ public:
if( db_connector->last_select_size() == 1 ) 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 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(); result.after_select();
} }
else 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.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.model_data = model_data;
added_model.before_select(); added_model.before_select();
model_connector->map_values_from_query(added_model); added_model.map_values_from_query();
added_model.after_select(); added_model.after_select();
db_connector->advance_current_row(); db_connector->advance_current_row();

166
src/model.cpp
View File

@@ -148,19 +148,35 @@ void Model::to_text(PT::TextStream & stream, bool clear_stream)
stream.clear(); stream.clear();
} }
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING;
if( model_connector ) 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) 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); if( out_stream )
stream.to_string(str, clear_string); {
to_text(*out_stream, true);
out_stream->to_string(str, clear_string);
}
}
} }
@@ -168,7 +184,7 @@ std::string Model::to_text()
{ {
std::string str; std::string str;
to_text(str); to_text(str, false);
return str; return str;
} }
@@ -179,14 +195,25 @@ std::string Model::to_string()
} }
void Model::generate_insert_query(PT::TextStream & stream) void Model::generate_insert_query(PT::TextStream & stream)
{ {
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
if( model_connector ) 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 Model::insert(ModelData * model_data)
{ {
@@ -195,20 +222,38 @@ bool Model::insert(ModelData * model_data)
if( model_connector ) if( model_connector )
{ {
this->model_data = model_data; 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 )
{
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 save_mode = DO_UPDATE_ON_SAVE; // IMPROVE ME check if there is a primary key
result = true; after_insert();
}
else
{
after_insert_failure();
}
} }
this->model_data = nullptr; this->model_data = nullptr;
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
} }
return result; return result;
} }
bool Model::insert(ModelData & model_data) bool Model::insert(ModelData & model_data)
{ {
return insert(&model_data); return insert(&model_data);
@@ -217,12 +262,21 @@ bool Model::insert(ModelData & model_data)
void Model::generate_update_query(PT::TextStream & stream) void Model::generate_update_query(PT::TextStream & stream)
{ {
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
if( model_connector ) 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;
}
bool Model::update(ModelData * model_data) bool Model::update(ModelData * model_data)
{ {
@@ -231,8 +285,26 @@ bool Model::update(ModelData * model_data)
if( model_connector ) if( model_connector )
{ {
this->model_data = model_data; 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; this->model_data = nullptr;
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
} }
return result; return result;
@@ -249,7 +321,15 @@ void Model::generate_remove_query(PT::TextStream & stream)
{ {
if( model_connector ) 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 ) if( model_connector )
{ {
this->model_data = model_data; 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 )
{
before_remove();
out_stream->clear();
result = db_connector->remove(*out_stream, *this);
if( result )
{ {
save_mode = DO_INSERT_ON_SAVE; save_mode = DO_INSERT_ON_SAVE;
result = true; after_remove();
}
else
{
after_remove_failure();
}
} }
this->model_data = nullptr; this->model_data = nullptr;
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
} }
return result; return result;
@@ -300,7 +397,7 @@ bool Model::save(ModelData * model_data)
break; break;
case DO_NOTHING_ON_SAVE: case DO_NOTHING_ON_SAVE:
// may return true? result = true;
break; 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 ) 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; save_mode = DO_INSERT_ON_SAVE;
model_data = nullptr; model_data = nullptr;
// do not set model_connector_mode here as it can be set to 'clearing'
} }
void Model::before_select() void Model::before_select()
{ {
} }
@@ -381,6 +506,11 @@ int Model::get_connector_mode()
return model_connector_mode; return model_connector_mode;
} }
bool Model::is_empty_field(const wchar_t * value)
{
return (!value || *value == '\0');
}
} // namespace } // namespace

213
src/model.h
View File

@@ -125,6 +125,7 @@ public:
virtual bool save(ModelData * model_data = nullptr); virtual bool save(ModelData * model_data = nullptr);
virtual bool save(ModelData & model_data); virtual bool save(ModelData & model_data);
virtual void generate_select_columns(PT::TextStream & stream, const std::wstring & column_prefix);
// set object to default values // set object to default values
virtual void clear(); virtual void clear();
@@ -157,6 +158,10 @@ protected:
virtual int get_connector_mode(); 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) 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); 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 ) field_model(field_name, field_name, field_value, insertable, updatable, is_primary_key);
{
model_connector->field_model(field_name, field_name, field_model, insertable, updatable, is_primary_key, model_connector_mode);
}
} }
template<typename ModelClass> template<typename ModelClass>
void field(const wchar_t * field_name, std::list<ModelClass> & field_list, bool insertable = true, bool updatable = true, bool is_primary_key = false) void field(const wchar_t * field_name, std::list<ModelClass> & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{ {
if( model_connector ) field_list(field_name, field_name, field_value, insertable, updatable, is_primary_key);
{
model_connector->field_list(field_name, field_name, field_list, insertable, updatable, is_primary_key, model_connector_mode);
}
} }
@@ -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 ) field_model(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
{
model_connector->field_model(db_field_name, flat_field_name, field_model, insertable, updatable, is_primary_key, model_connector_mode);
}
} }
template<typename ModelClass> template<typename ModelClass>
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, std::list<ModelClass> & 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<ModelClass> & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{ {
if( model_connector ) field_list(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
{
model_connector->field_list(db_field_name, flat_field_name, field_list, insertable, updatable, is_primary_key, model_connector_mode);
}
} }
////////////////////// //////////////////////
@@ -402,54 +395,154 @@ protected:
protected: protected:
template<typename FieldValue> template<typename FieldValue>
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 ) 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);
}
} }
} }
template<typename FieldValue> if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL )
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) {
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<typename ModelClass>
void field_list(const wchar_t * db_field_name, const wchar_t * flat_field_name, std::list<ModelClass> & 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<typename ModelX>
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 ) 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: public:
/*
template<typename FieldValue>
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<typename FieldValue>
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<typename FieldValue> template<typename FieldValue>
void get_last_sequence(const wchar_t * sequence_table_name, FieldValue & field_value) void get_last_sequence(const wchar_t * sequence_table_name, FieldValue & field_value)
{ {
if( model_connector ) 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 ) 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 else
if( get_connector_mode() == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING ) 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 else
if( get_connector_mode() == MORM_MODEL_CONNECTOR_MODE_READING_VALUE_FROM_DB_RESULTSET ) 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 else
if( get_connector_mode() == MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE ) 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); add_field_for_select(new_column_expression, new_column_name, new_column_name, field_value);
} }
template<typename ModelClass> friend class Finder;
friend class ModelConnector;
protected:
virtual bool is_empty_field(const wchar_t * value);
template<typename ModelClass> friend class Finder;
friend class BaseExpression; friend class BaseExpression;
// WILL BE REMOVED when ModelConnector::set_connector_for_childs(Model & model) will be removed
friend class ModelConnector;
}; };
} // namespace } // namespace

226
src/modelconnector.cpp
View File

@@ -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() void ModelConnector::deallocate_stream()
{ {
if( out_stream_allocated ) 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) void ModelConnector::set_db_connector(DbConnector & db_connector)
{ {
this->db_connector = &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) void ModelConnector::set_connector_for_childs(Model & model)
{ {
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_SETTING_CONNECTOR_FOR_CHILDS; 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');
}
} }

177
src/modelconnector.h
View File

@@ -73,43 +73,16 @@ public:
virtual PT::TextStream * get_stream(); virtual PT::TextStream * get_stream();
virtual void set_flat_connector(FlatConnector & flat_connector); virtual void set_flat_connector(FlatConnector & flat_connector);
virtual FlatConnector * get_flat_connector();
virtual void set_db_connector(DbConnector & db_connector); virtual void set_db_connector(DbConnector & db_connector);
virtual DbConnector * get_db_connector(); virtual DbConnector * get_db_connector();
virtual void set_db_expression_output_type(int output_type); // WILL BE REMOVED
// model connector for childs will be set when needed
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<typename ModelClass>
void clear_values(std::list<ModelClass> & list)
{
list.clear();
}
virtual void set_connector_for_childs(Model & model); virtual void set_connector_for_childs(Model & model);
// template<typename ModelClass>
// Finder<ModelClass> & find()
// {
// allocate_default_stream_if_needed();
// return Finder<ModelClass>(this);
// }
protected: protected:
@@ -122,154 +95,10 @@ protected:
PT::TextStream * out_stream; // IMPROVE ME give here an interface to the base stream (implement him) PT::TextStream * out_stream; // IMPROVE ME give here an interface to the base stream (implement him)
bool out_stream_allocated; bool out_stream_allocated;
//BaseExpression * expression_callback;
//DbConnector * db_connector_callback;
void allocate_default_stream(); void allocate_default_stream();
void allocate_default_stream_if_needed(); void allocate_default_stream_if_needed();
void deallocate_stream(); void deallocate_stream();
template<typename FieldValue>
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<typename FieldValue>
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<typename ModelClass>
//void field_list(const wchar_t * field_name, std::list<ModelClass> & 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<ModelClass> & 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<typename ModelClass>
//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<typename FieldValue>
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<typename FieldValue>
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<typename ModelClass> friend class Finder;
}; };
} }