some work in morm

now in Model we have field() methods for other Model or std::list<Model>
(code not tested)




git-svn-id: svn://ttmath.org/publicrep/morm/trunk@1118 e52654a7-88a9-db11-a3e9-0013d4bc506e
This commit is contained in:
Tomasz Sowa 2018-07-03 16:55:06 +00:00
parent 6fc4e23e44
commit f85f03a889
9 changed files with 376 additions and 123 deletions

View File

@ -337,16 +337,11 @@ void BaseExpression::esc(double val, PT::TextStream & stream)
void BaseExpression::esc(long double val, PT::TextStream & stream)
{
// IMPLEMENT ME in PT::TextStream
//stream << val;
}
void BaseExpression::esc(void* val, PT::TextStream & stream)
{
stream << val;
}
void BaseExpression::esc(const PT::Date & date, PT::TextStream & stream)
{
stream << date;

View File

@ -117,28 +117,17 @@ public:
}
template<typename ModelClass>
void field_list(const wchar_t * field_name, const std::list<ModelClass> & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
void field_list(const wchar_t * field_name, const std::list<ModelClass> & field_value, bool insertable, bool updatable, bool is_primary_key, int model_connector_mode)
{
if( out_stream && can_field_be_generated(insertable, updatable, is_primary_key) )
{
field_before();
// IMPLEMENTME
// if( work_mode == MORM_WORK_MODE_MODEL_FIELDS )
// {
// put_field_name(field_name);
// }
// else
// if( work_mode == MORM_WORK_MODE_MODEL_VALUES )
// {
// put_field_value(field_value);
// }
// else
if( work_mode == MORM_WORK_MODE_MODEL_FIELDS_VALUES )
{
put_field_name(field_name);
put_name_value_separator();
put_field_value_list(field_value);
put_field_value_list(field_value, model_connector_mode);
}
field_after();
@ -205,11 +194,13 @@ public:
virtual void esc(float val, PT::TextStream & stream);
virtual void esc(double val, PT::TextStream & stream);
virtual void esc(long double val, PT::TextStream & stream);
virtual void esc(void* val, PT::TextStream & stream);
//virtual void esc(void* val, PT::TextStream & stream);
virtual void esc(const PT::Date & date, PT::TextStream & stream);
protected:
int work_mode; /* what to do: generating fields list, values list or fields-values list */
@ -260,7 +251,7 @@ protected:
template<typename ModelClass>
void put_field_value_list(const std::list<ModelClass> & field_value)
void put_field_value_list(const std::list<ModelClass> & field_value, int model_connector_mode)
{
if( out_stream )
{
@ -280,7 +271,10 @@ protected:
}
//before_field_value(field_value);
// FIX ME what about setting model connector to the m? !!!!!!!!!!!!
m.model_connector_mode = model_connector_mode;
generate_from_model(m);
m.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
//after_field_value(field_value);
is_first = false;
}

View File

@ -314,11 +314,13 @@ void DbConnector::clear_value(std::wstring & field_value)
field_value.clear();
}
void DbConnector::clear_value(std::string & field_value)
{
field_value.clear();
}
void DbConnector::clear_value(bool & field_value)
{
field_value = false;
@ -384,6 +386,10 @@ void DbConnector::clear_value(PT::Date & field_value)
field_value.Clear();
}
void DbConnector::clear_value(Model & field_value)
{
field_value.clear();
}
@ -399,6 +405,7 @@ void DbConnector::get_value(const char * value_str, char & field_value)
}
void DbConnector::get_value(const char * value_str, unsigned char & field_value)
{
field_value = *(const unsigned char*)value_str;

View File

@ -114,6 +114,13 @@ public:
virtual void clear_value(long double & field_value);
virtual void clear_value(PT::Date & field_value);
virtual void clear_value(Model & field_value);
template<typename ModelClass>
void clear_value(std::list<ModelClass> & list)
{
list.clear();
}
virtual void get_value(const char * value_str, char & field_value);
virtual void get_value(const char * value_str, unsigned char & field_value);
@ -132,7 +139,7 @@ public:
virtual void get_value(const char * value_str, double & field_value);
virtual void get_value(const char * value_str, long double & field_value);
virtual void get_value(const char * value_str, PT::Date & field_value);
//virtual void get_value(const char * value_str, void* & field_value);
template<typename FieldValue>
@ -179,6 +186,10 @@ protected:
};
}
#endif

View File

@ -43,6 +43,7 @@ Model::Model()
model_connector = nullptr;
model_data = nullptr;
save_mode = DO_INSERT_ON_SAVE;
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
}
Model::~Model()
@ -113,12 +114,17 @@ void Model::table_name(PT::TextStream & stream)
void Model::set_connector(ModelConnector & connector)
{
model_connector = &connector;
set_connector(&connector);
}
void Model::set_connector(ModelConnector * connector)
{
model_connector = connector;
if( model_connector )
{
model_connector->set_connector_for_childs(*this);
}
}
@ -317,6 +323,8 @@ void Model::clear()
save_mode = DO_INSERT_ON_SAVE;
model_data = nullptr;
// do not set model_connector_mode here as it can be set to 'clearing'
}
@ -370,12 +378,7 @@ void Model::after_remove_failure()
int Model::get_connector_mode()
{
if( model_connector )
{
return model_connector->get_connector_mode();
}
return MORM_MODEL_CONNECTOR_MODE_NONE;
return model_connector_mode;
}

View File

@ -135,6 +135,7 @@ protected:
ModelConnector * model_connector;
SaveMode save_mode;
ModelData * model_data;
int model_connector_mode;
Model();
virtual ~Model();
@ -156,22 +157,275 @@ protected:
virtual int get_connector_mode();
// temporarily workaround
// these templates will be removed
void fieldb(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool & 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);
}
}
/////////////////////////////////
void field(const wchar_t * field_name, char & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * field_name, unsigned char & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * field_name, std::wstring & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
// void field(const wchar_t * field_name, wchar_t * field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
// {
// field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
// }
void field(const wchar_t * field_name, std::string & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
// void field(const wchar_t * field_name, char * field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
// {
// field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
// }
void field(const wchar_t * field_name, bool & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * field_name, short & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * field_name, unsigned short & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * field_name, int & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * field_name, unsigned int & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * field_name, long & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * field_name, unsigned long & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * field_name, long long & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * field_name, unsigned long long & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * field_name, float & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * field_name, double & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * field_name, long double & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
// void field(const wchar_t * field_name, void * field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
// {
// field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
// }
void field(const wchar_t * field_name, PT::Date & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
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)
{
if( model_connector )
{
model_connector->field_model(field_name, field_name, field_model, insertable, updatable, is_primary_key, model_connector_mode);
}
}
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)
{
if( model_connector )
{
model_connector->field_list(field_name, field_name, field_list, insertable, updatable, is_primary_key, model_connector_mode);
}
}
//////////////////////
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, char & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, unsigned char & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, std::wstring & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
// void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, wchar_t * field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
// {
// field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
// }
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, std::string & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
// void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, char * field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
// {
// field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
// }
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, short & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, unsigned short & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, int & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, unsigned int & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, long & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, unsigned long & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, long long & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, unsigned long long & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, float & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, double & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, long double & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
// void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, void * field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
// {
// field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
// }
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, PT::Date & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
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)
{
if( model_connector )
{
model_connector->field_model(db_field_name, flat_field_name, field_model, insertable, updatable, is_primary_key, model_connector_mode);
}
}
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)
{
if( model_connector )
{
model_connector->field_list(db_field_name, flat_field_name, field_list, insertable, updatable, is_primary_key, model_connector_mode);
}
}
//////////////////////
protected:
template<typename FieldValue>
void field(const wchar_t * field_name, FieldValue & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
void field_generic(const wchar_t * 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);
}
}
template<typename FieldValue>
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)
{
if( model_connector )
{
model_connector->field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key, model_connector_mode);
}
}
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 )
{
@ -180,51 +434,14 @@ protected:
}
template<typename FieldValue>
void field(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)
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>
void field(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(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 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)
{
if( model_connector )
{
model_connector->field_list(field_name, field_list, insertable, updatable, is_primary_key);
}
}
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)
{
if( model_connector )
{
// is there a possibility for the childs to be connected to different model connectors?
field_model.set_connector(model_connector);
model_connector->field_model(field_name, field_model, insertable, updatable, is_primary_key);
}
}
*/
template<typename FieldValue>
@ -244,22 +461,22 @@ protected:
{
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->add_field_for_select(new_column_expression, new_column_name, field_value, model_connector_mode);
}
else
if( get_connector_mode() == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING )
{
model_connector->field(L"", flat_field_name, field_value, false, false, false);
model_connector->field_generic(L"", flat_field_name, field_value, false, false, false, model_connector_mode);
}
else
if( get_connector_mode() == MORM_MODEL_CONNECTOR_MODE_READING_VALUE_FROM_DB_RESULTSET )
{
model_connector->field(new_column_name, L"", field_value, false, false, false);
model_connector->field_generic(new_column_name, L"", field_value, false, false, false, model_connector_mode);
}
else
if( get_connector_mode() == MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE )
{
model_connector->field(L"", L"", field_value, false, false, false); // the names don't matter here
model_connector->field_generic(L"", L"", field_value, false, false, false, model_connector_mode); // the names don't matter here
}
}
}
@ -269,11 +486,12 @@ protected:
{
add_field_for_select(new_column_expression, new_column_name, new_column_name, field_value);
}
//void field(const wchar_t * field_name, Model & field, bool insertable = true, bool updatable = true);
template<typename ModelClass> friend class Finder;
friend class ModelConnector;
friend class BaseExpression;
};
} // namespace

View File

@ -43,7 +43,6 @@ namespace morm
ModelConnector::ModelConnector()
{
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
flat_connector = nullptr;
db_connector = nullptr;
logger = nullptr;
@ -88,12 +87,6 @@ void ModelConnector::set_db_expression_output_type(int output_type)
int ModelConnector::get_connector_mode()
{
return model_connector_mode;
}
void ModelConnector::deallocate_stream()
{
if( out_stream_allocated )
@ -184,7 +177,7 @@ void ModelConnector::to_text(PT::TextStream & stream, Model & model)
{
if( flat_connector )
{
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING;
//expression_callback = flat_connector->get_expression();
//if( expression_callback )
@ -193,7 +186,7 @@ void ModelConnector::to_text(PT::TextStream & stream, Model & model)
//}
//expression_callback = nullptr;
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
}
}
@ -202,7 +195,7 @@ void ModelConnector::generate_select_columns(PT::TextStream & stream, Model & mo
{
if( db_connector )
{
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
//expression_callback = db_connector->get_expression();
//if( expression_callback )
@ -211,7 +204,7 @@ void ModelConnector::generate_select_columns(PT::TextStream & stream, Model & mo
//}
//expression_callback = nullptr;
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
}
}
@ -221,7 +214,7 @@ void ModelConnector::generate_insert_query(PT::TextStream & stream, Model & mode
{
if( db_connector )
{
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
//expression_callback = db_connector->get_expression();
//if( expression_callback )
@ -230,7 +223,7 @@ void ModelConnector::generate_insert_query(PT::TextStream & stream, Model & mode
//}
//expression_callback = nullptr;
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
}
}
@ -239,7 +232,7 @@ void ModelConnector::generate_update_query(PT::TextStream & stream, Model & mode
{
if( db_connector )
{
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
//expression_callback = db_connector->get_expression();
//if( expression_callback )
@ -248,7 +241,7 @@ void ModelConnector::generate_update_query(PT::TextStream & stream, Model & mode
//}
//expression_callback = nullptr;
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
}
}
@ -257,9 +250,9 @@ void ModelConnector::generate_remove_query(PT::TextStream & stream, Model & mode
{
if( db_connector )
{
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
db_connector->generate_remove_query(stream, model);
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
}
}
@ -274,7 +267,7 @@ bool ModelConnector::insert(Model & model)
if( db_connector && out_stream )
{
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
//db_connector_callback = db_connector;
model.before_insert();
@ -287,7 +280,7 @@ bool ModelConnector::insert(Model & model)
model.after_insert_failure();
//db_connector_callback = nullptr;
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
}
return result;
@ -301,7 +294,7 @@ bool ModelConnector::update(Model & model)
if( db_connector && out_stream )
{
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
//db_connector_callback = db_connector;
model.before_update();
@ -314,7 +307,7 @@ bool ModelConnector::update(Model & model)
model.after_update_failure();
//db_connector_callback = nullptr;
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
}
return result;
@ -330,7 +323,7 @@ bool ModelConnector::remove(Model & model)
if( db_connector && out_stream )
{
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
//db_connector_callback = db_connector;
model.before_remove();
@ -343,7 +336,7 @@ bool ModelConnector::remove(Model & model)
model.after_remove_failure();
//db_connector_callback = nullptr;
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
}
return result;
@ -358,11 +351,11 @@ void ModelConnector::map_values_from_query(Model & model)
if( db_connector )
{
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_READING_VALUE_FROM_DB_RESULTSET;
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_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
}
}
@ -371,13 +364,21 @@ void ModelConnector::clear_values(Model & model)
{
if( db_connector )
{
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE;
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE;
model.map_fields();
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
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;
model.map_fields();
model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
}
bool ModelConnector::is_empty_field(const wchar_t * value)
{
return (!value || *value == '\0');

View File

@ -62,8 +62,6 @@ public:
virtual void set_logger(PT::Logger * logger);
virtual void set_logger(PT::Logger & logger);
virtual int get_connector_mode();
// FIX ME
// add c-copy ctr (allocate a new stream and expression)
@ -98,6 +96,14 @@ public:
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);
// template<typename ModelClass>
// Finder<ModelClass> & find()
// {
@ -108,8 +114,6 @@ public:
protected:
int model_connector_mode;
PT::Logger * logger;
FlatConnector * flat_connector;
@ -127,7 +131,7 @@ protected:
template<typename FieldValue>
void field(const wchar_t * db_field_name, const wchar_t * flat_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, int model_connector_mode)
{
if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING && flat_connector )
{
@ -164,6 +168,7 @@ protected:
}
/*
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)
{
@ -174,18 +179,20 @@ protected:
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 * 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(field_name) )
if( flat_expression && !is_empty_field(flat_field_name) )
{
flat_expression->field_list(field_name, field_list, insertable, updatable, is_primary_key);
flat_expression->field_list(flat_field_name, field_list, insertable, updatable, is_primary_key, model_connector_mode);
}
}
@ -193,19 +200,28 @@ protected:
{
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 * 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(field_name) )
if( flat_expression && !is_empty_field(flat_field_name) )
{
flat_expression->field_model(field_name, field_model, insertable, updatable, is_primary_key);
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;
}
}
@ -213,10 +229,16 @@ protected:
{
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)
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 )
{

View File

@ -45,6 +45,8 @@
#define MORM_MODEL_CONNECTOR_MODE_READING_VALUE_FROM_DB_RESULTSET 4
#define MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE 5
#define MORM_MODEL_CONNECTOR_MODE_SETTING_CONNECTOR_FOR_CHILDS 6
#define MORM_WORK_MODE_MODEL_FIELDS 1
#define MORM_WORK_MODE_MODEL_VALUES 2