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

177
src/modelconnector.h
View File

@@ -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<typename ModelClass>
void clear_values(std::list<ModelClass> & list)
{
list.clear();
}
// WILL BE REMOVED
// model connector for childs will be set when needed
virtual void set_connector_for_childs(Model & model);
// template<typename ModelClass>
// Finder<ModelClass> & find()
// {
// allocate_default_stream_if_needed();
// return Finder<ModelClass>(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<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;
};
}