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

added BaseExpression::is_long_field_name() 

added BaseExpression::need_to_add_field_prefix()
      now the fields() methods don't take add_column_prefix parameter
      but the field_name (wchar_t*) is tested whether is it a long (with a period) or short name
added BaseExpression::save_foreign_key() (code moved from field())
removed some default method arguments from BaseExpression
added neq() method for Finder
added DbExpression::prepare_short_table_name(const PT::TextStream & table_name, PT::TextStream & short_table_name)




git-svn-id: svn://ttmath.org/publicrep/morm/branches/join_models@1194 e52654a7-88a9-db11-a3e9-0013d4bc506e
This commit is contained in:
Tomasz Sowa 2019-05-31 18:28:09 +00:00
parent a1d18735b0
commit b6fbe29805
13 changed files with 286 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
src/baseexpression.cpp
View File

@ -44,9 +44,7 @@ namespace morm
BaseExpression::BaseExpression()
{
out_stream = nullptr;
is_first_field = false;
work_mode = 0;
clear();
}
BaseExpression::~BaseExpression()
@ -54,6 +52,15 @@ BaseExpression::~BaseExpression()
}
void BaseExpression::clear()
{
out_stream = nullptr;
is_first_field = false;
work_mode = 0;
use_prefix = false;
}
void BaseExpression::set_work_mode(int work_mode)
{
this->work_mode = work_mode;
@ -66,14 +73,6 @@ int BaseExpression::get_work_mode()
}
void BaseExpression::prepare_to_new_expression()
{
out_stream = nullptr;
is_first_field = false;
work_mode = 0;
use_prefix = true;
}
PT::TextStream * BaseExpression::get_current_stream()
{
@ -158,21 +157,80 @@ void BaseExpression::field_after()
}
bool BaseExpression::is_long_field_name(const wchar_t * field_name)
{
bool is_long = false;
void BaseExpression::put_field_name(const wchar_t * field_name, bool add_column_prefix, ModelEnv * model_env)
while( *field_name != 0 )
{
if( *field_name == '.' )
{
is_long = true;
break;
}
field_name += 1;
}
return is_long;
}
bool BaseExpression::is_long_field_name(const PT::TextStream & field_name)
{
PT::TextStream::const_iterator i = field_name.begin();
bool is_long = false;
while( i != field_name.end() )
{
if( *i == '.' )
{
is_long = true;
break;
}
++i;
}
return is_long;
}
bool BaseExpression::is_long_table_name(const wchar_t * table_name)
{
return is_long_field_name(table_name);
}
bool BaseExpression::is_long_table_name(const PT::TextStream & table_name)
{
return is_long_field_name(table_name);
}
bool BaseExpression::need_to_add_field_prefix(const wchar_t * field_name)
{
return !is_long_field_name(field_name);
}
void BaseExpression::put_field_name(const wchar_t * field_name, ModelEnv * model_env)
{
before_field_name();
if( use_prefix && model_env && add_column_prefix )
if( use_prefix && model_env )
{
esc(model_env->table_name_simple, *out_stream);
if( model_env->table_index > 1 )
if( need_to_add_field_prefix(field_name) )
{
(*out_stream) << model_env->table_index;
}
esc(model_env->table_name_short, *out_stream);
(*out_stream) << '.';
if( model_env->table_index > 1 )
{
(*out_stream) << model_env->table_index;
}
(*out_stream) << '.';
}
}
esc(field_name, *out_stream);
@ -180,6 +238,22 @@ void BaseExpression::put_field_name(const wchar_t * field_name, bool add_column_
}
void BaseExpression::save_foreign_key(const wchar_t * field_name, ModelEnv * model_env)
{
PT::TextStream str;
PT::TextStream * old_out_stream = out_stream;
out_stream = &str;
put_field_name(field_name, model_env);
out_stream = old_out_stream;
if( model_env && model_env->finder_helper )
{
model_env->finder_helper->foreign_keys.emplace_back();
std::string & key_str = model_env->finder_helper->foreign_keys.back();
str.to_string(key_str, false);
}
}
void BaseExpression::put_field_doc(Model & model, const void * field_pointer, bool insertable, bool updatable, bool is_primary_key, ModelEnv * model_env)
{

109
src/baseexpression.h
View File

@ -60,7 +60,7 @@ public:
virtual void set_work_mode(int work_mode);
virtual int get_work_mode();
virtual void prepare_to_new_expression();
virtual void clear();
virtual void generate_from_model(PT::TextStream & stream, Model & model);
@ -76,8 +76,7 @@ public:
template<typename FieldValue>
void field(const wchar_t * field_name, const FieldValue & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false,
bool add_column_prefix = true, ModelEnv * model_env = nullptr)
void field(const wchar_t * field_name, const FieldValue & field_value, bool insertable, bool updatable, bool is_primary_key, ModelEnv * model_env)
{
if( out_stream && can_field_be_generated(insertable, updatable, is_primary_key) )
{
@ -85,24 +84,12 @@ public:
if( work_mode == MORM_WORK_MODE_MODEL_FIELDS )
{
put_field_name(field_name, add_column_prefix, model_env);
put_field_name(field_name, model_env);
}
else
if( work_mode == MORM_WORK_MODE_MODEL_SAVE_FIELDS )
{
PT::TextStream str;
PT::TextStream * old_out_stream = out_stream;
out_stream = &str;
put_field_name(field_name, add_column_prefix, model_env);
out_stream = old_out_stream;
if( model_env && model_env->finder_helper )
{
model_env->finder_helper->morm_foreign_keys.emplace_back();
std::string & key_str = model_env->finder_helper->morm_foreign_keys.back();
str.to_string(key_str, false);
}
save_foreign_key(field_name, model_env);
}
else
if( work_mode == MORM_WORK_MODE_MODEL_VALUES )
@ -112,7 +99,7 @@ public:
else
if( work_mode == MORM_WORK_MODE_MODEL_FIELDS_VALUES )
{
put_field_name(field_name, add_column_prefix, model_env);
put_field_name(field_name, model_env);
put_name_value_separator();
put_field_value(field_value);
}
@ -125,16 +112,13 @@ public:
template<typename FieldValue>
void field_doc(Model & model, const wchar_t * field_name, const FieldValue & field_value,
bool insertable = true, bool updatable = true,
bool is_primary_key = false, bool add_column_prefix = true,
ModelEnv * model_env = nullptr)
void field_doc(Model & model, const wchar_t * field_name, const FieldValue & field_value, bool insertable, bool updatable, bool is_primary_key, ModelEnv * model_env)
{
if( out_stream )
{
field_before();
put_field_name(field_name, add_column_prefix, model_env);
put_field_name(field_name, model_env);
put_name_value_separator();
put_field_doc(model, reinterpret_cast<const void*>(&field_value), insertable, updatable, is_primary_key, model_env);
@ -147,38 +131,30 @@ public:
}
/*
template<typename FieldValue>
void field(const PT::TextStream & field_name, const FieldValue & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false, bool add_column_prefix = true)
void field_in(PT::TextStream & stream, const wchar_t * field_name, const std::set<FieldValue> & container, ModelEnv * model_env)
{
std::wstring field_name_str; // field() methods can be called recursively, so don't make it as class object
field_name.to_string(field_name_str);
return field(field_name_str.c_str(), field_value, insertable, updatable, is_primary_key, add_column_prefix);
}
*/
template<typename FieldValue>
void field_in(PT::TextStream & stream, const wchar_t * field_name, const std::set<FieldValue> & container)
{
field_in_generic<FieldValue, std::set<FieldValue>>(stream, field_name, container);
field_in_generic<FieldValue, std::set<FieldValue>>(stream, field_name, container, model_env);
}
template<typename FieldValue>
void field_in(PT::TextStream & stream, const wchar_t * field_name, const std::list<FieldValue> & container)
{
field_in_generic<FieldValue, std::list<FieldValue>>(stream, field_name, container);
}
template<typename FieldValue>
void field_in(PT::TextStream & stream, const wchar_t * field_name, const std::vector<FieldValue> & container)
void field_in(PT::TextStream & stream, const wchar_t * field_name, const std::list<FieldValue> & container, ModelEnv * model_env)
{
field_in_generic<FieldValue, std::vector<FieldValue>>(stream, field_name, container);
field_in_generic<FieldValue, std::list<FieldValue>>(stream, field_name, container, model_env);
}
template<typename FieldValue>
void field_in(PT::TextStream & stream, const wchar_t * field_name, const std::vector<FieldValue> & container, ModelEnv * model_env)
{
field_in_generic<FieldValue, std::vector<FieldValue>>(stream, field_name, container, model_env);
}
template<typename ModelContainer>
void field_list(const wchar_t * field_name, ModelContainer & field_value, bool insertable, bool updatable, bool is_primary_key,
ModelConnector * model_connector, ModelEnv * model_env)
ModelConnector * model_connector, ModelEnv * model_env)
{
if( out_stream && can_field_be_generated(insertable, updatable, is_primary_key) )
{
@ -191,7 +167,7 @@ public:
// else
if( work_mode == MORM_WORK_MODE_MODEL_FIELDS_VALUES )
{
put_field_name(field_name); // what about model_env? put it here?
put_field_name(field_name, model_env);
put_name_value_separator();
put_field_value_list(field_value, model_connector, model_env);
}
@ -201,7 +177,7 @@ public:
}
template<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, bool updatable, bool is_primary_key, ModelEnv * model_env)
{
if( out_stream && can_field_be_generated(insertable, updatable, is_primary_key) )
{
@ -209,7 +185,7 @@ public:
if( work_mode == MORM_WORK_MODE_MODEL_FIELDS )
{
put_field_name(field_name);
put_field_name(field_name, model_env);
}
else
if( work_mode == MORM_WORK_MODE_MODEL_VALUES )
@ -219,7 +195,7 @@ public:
else
if( work_mode == MORM_WORK_MODE_MODEL_FIELDS_VALUES )
{
put_field_name(field_name);
put_field_name(field_name, model_env);
put_name_value_separator();
generate_from_model(field_model);
}
@ -229,11 +205,11 @@ public:
}
template<typename FieldValue>
void field_to_stream(PT::TextStream & stream, const wchar_t * field_name, const FieldValue & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false,
bool add_column_prefix = true, ModelEnv * model_env = nullptr)
void field_to_stream(PT::TextStream & stream, const wchar_t * field_name, const FieldValue & field_value, bool insertable, bool updatable, bool is_primary_key,
ModelEnv * model_env)
{
this->out_stream = &stream;
field(field_name, field_value, insertable, updatable, is_primary_key, add_column_prefix, model_env);
field(field_name, field_value, insertable, updatable, is_primary_key, model_env);
this->out_stream = nullptr;
}
@ -265,6 +241,11 @@ public:
virtual void esc(const PT::Date & date, PT::TextStream & stream);
virtual void esc(const PT::TextStream & val,PT::TextStream & stream);
virtual bool is_long_field_name(const wchar_t * field_name);
virtual bool is_long_field_name(const PT::TextStream & table_name);
virtual bool is_long_table_name(const wchar_t * field_name);
virtual bool is_long_table_name(const PT::TextStream & table_name);
@ -287,7 +268,12 @@ protected:
//void field(const wchar_t * field_name, Model & field, bool insertable = true, bool updatable = true);
virtual void put_field_name(const wchar_t * field_name, bool add_column_prefix = true, ModelEnv * model_env = nullptr);
virtual bool need_to_add_field_prefix(const wchar_t * field_name);
virtual void put_field_name(const wchar_t * field_name, ModelEnv * model_env);
virtual void save_foreign_key(const wchar_t * field_name, ModelEnv * model_env);
template<typename FieldValue>
void put_field_value(const FieldValue & field_value)
@ -316,6 +302,15 @@ protected:
(*out_stream) << ",";
}
virtual void put_statement_in_starts()
{
(*out_stream) << "(";
}
virtual void put_statement_in_ends()
{
(*out_stream) << ") ";
}
// what about lists with a pod types? e.g. list<int>
template<typename ModelContainer>
@ -350,7 +345,7 @@ protected:
// used in 'in()' statements, may should be renamed?
template<typename FieldValue, typename Container>
void field_in_generic(PT::TextStream & stream, const wchar_t * field_name, const Container & container)
void field_in_generic(PT::TextStream & stream, const wchar_t * field_name, const Container & container, ModelEnv * model_env)
{
// IMPROVE ME
// what about if container is empty?
@ -358,24 +353,24 @@ protected:
this->out_stream = &stream;
field_before();
put_field_name(field_name);
put_field_name(field_name, model_env);
put_name_value_separator();
bool is_first = true;
(*out_stream) << "(";
put_statement_in_starts();
for(const FieldValue & v : container)
{
if( !is_first )
{
(*out_stream) << ",";
field_value_list_separator();
}
put_field_value(v);
is_first = false;
}
(*out_stream) << ") ";
put_statement_in_ends();
field_after();
this->out_stream = nullptr;
}

15
src/dbconnector.cpp
View File

@ -157,9 +157,10 @@ void DbConnector::generate_select_columns(PT::TextStream & stream, Model & model
if( db_expression )
{
db_expression->prepare_to_new_expression();
db_expression->clear();
db_expression->set_work_mode(MORM_WORK_MODE_MODEL_FIELDS);
db_expression->set_output_type(MORM_OUTPUT_TYPE_SELECT_COLUMNS);
db_expression->allow_to_use_prefix(true);
db_expression->generate_from_model(stream, model);
}
}
@ -171,7 +172,9 @@ void DbConnector::generate_insert_query(PT::TextStream & stream, Model & model)
if( db_expression )
{
db_expression->prepare_to_new_expression();
db_expression->clear();
db_expression->allow_to_use_prefix(true);
stream << "insert into ";
model.table_name(stream);
@ -194,7 +197,9 @@ void DbConnector::generate_update_query(PT::TextStream & stream, Model & model)
if( db_expression )
{
db_expression->prepare_to_new_expression();
db_expression->clear();
db_expression->allow_to_use_prefix(true);
stream << "update ";
model.table_name(stream);
@ -217,7 +222,9 @@ void DbConnector::generate_remove_query(PT::TextStream & stream, Model & model)
if( db_expression )
{
db_expression->prepare_to_new_expression();
db_expression->clear();
db_expression->allow_to_use_prefix(true);
stream << "delete from ";
model.table_name(stream);
stream << " where ";

41
src/dbexpression.cpp
View File

@ -140,6 +140,11 @@ void DbExpression::put_name_value_separator()
(*out_stream) << " = ";
}
else
if( output_type == MORM_OUTPUT_TYPE_WHERE_NOT_EQ )
{
(*out_stream) << " <> ";
}
else
if( output_type == MORM_OUTPUT_TYPE_WHERE_LT )
{
(*out_stream) << " < ";
@ -296,4 +301,40 @@ DbExpression & DbExpression::page(PT::TextStream & stream, size_t page_number, s
return *this;
}
void DbExpression::prepare_short_table_name(const PT::TextStream & table_name, PT::TextStream & short_table_name)
{
short_table_name.clear();
if( is_long_table_name(table_name) )
{
PT::TextStream::const_iterator i = table_name.begin();
bool was_dot = false;
while( i != table_name.end() )
{
if( was_dot )
{
short_table_name << *i;
}
else
if( *i == '.' )
{
was_dot = true;
}
++i;
}
}
if( short_table_name.empty() )
{
short_table_name = table_name;
}
}
}

7
src/dbexpression.h
View File

@ -71,10 +71,15 @@ public:
column_expression += L" as ";
column_expression += new_column_name;
field(column_expression.c_str(), field_value, false, false, false, false);
// put nullptr to ModelEnv* to not allow to use prefix
// or may better remember current value of use_prefix and set it to false for a while?
field(column_expression.c_str(), field_value, false, false, false, nullptr);
}
virtual void prepare_short_table_name(const PT::TextStream & table_name, PT::TextStream & short_table_name);
protected:
int output_type;

83
src/finder.h
View File

@ -116,23 +116,6 @@ public:
protected:
void set_out_stream()
{
if( model_connector )
{
this->out_stream = model_connector->get_stream();
}
else
{
this->out_stream = nullptr;
}
}
public:
Finder<ModelClass> & set_out_stream(PT::TextStream * out_stream)
{
this->out_stream = out_stream;
@ -243,22 +226,22 @@ public:
model.model_env = &model_env;
model.model_env->model_data = model_data;
model.model_env->finder_helper = &finder_helper;
model.prepare_to_select();
has_autogenerated_select = true;
if( model_connector && out_stream )
if( model_connector && out_stream && db_expression )
{
model.table_name(model.model_env->table_name);
model.table_name_for_join_as(model.model_env->table_name_simple);
model.model_env->table_index = finder_helper.add_join_table(model.model_env->table_name_simple);
db_expression->prepare_short_table_name(model.model_env->table_name, model.model_env->table_name_short);
model.model_env->table_index = finder_helper.add_join_table(model.model_env->table_name_short);
(*out_stream) << "SELECT ";
model.generate_select_columns(*out_stream);
(*out_stream) << " FROM " << model.model_env->table_name << " AS ";
(*out_stream) << model.model_env->table_name_simple;
(*out_stream) << model.model_env->table_name_short;
(*out_stream) << " ";
(*out_stream) << finder_helper.morm_finder_join_tables;
(*out_stream) << finder_helper.join_tables_str;
}
return *this;
@ -342,27 +325,32 @@ public:
if( db_expression )
{
db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_EQ);
bool put_table_prefix = true;
// IMPROVE ME
// add check if there is a dot char in field_name?
// or add a second eq() method with an additional parameter -- table name?
db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, put_table_prefix, &model_env);
db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, &model_env);
}
return *this;
}
template<typename FieldValue>
Finder<ModelClass> & neq(const wchar_t * field_name, const FieldValue & field_value)
{
if( db_expression )
{
db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_NOT_EQ);
db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, &model_env);
}
return *this;
}
template<typename FieldValue>
Finder<ModelClass> & lt(const wchar_t * field_name, const FieldValue & field_value)
{
if( db_expression )
{
db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_LT);
db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, true, &model_env);
db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, &model_env);
}
return *this;
@ -375,7 +363,7 @@ public:
if( db_expression )
{
db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_GT);
db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, true, &model_env);
db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, &model_env);
}
return *this;
@ -388,7 +376,7 @@ public:
if( db_expression )
{
db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_LE);
db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, true, &model_env);
db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, &model_env);
}
return *this;
@ -401,7 +389,7 @@ public:
if( db_expression )
{
db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_GE);
db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, true, &model_env);
db_expression->field_to_stream(*out_stream, field_name, field_value, false, false, false, &model_env);
}
return *this;
@ -415,7 +403,7 @@ public:
if( db_expression )
{
db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_IN);
db_expression->field_in(*out_stream, field_name, container);
db_expression->field_in(*out_stream, field_name, container, &model_env);
}
return *this;
@ -427,7 +415,7 @@ public:
if( db_expression )
{
db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_IN);
db_expression->field_in(*out_stream, field_name, container);
db_expression->field_in(*out_stream, field_name, container, &model_env);
}
return *this;
@ -439,7 +427,7 @@ public:
if( db_expression )
{
db_expression->set_output_type(MORM_OUTPUT_TYPE_WHERE_IN);
db_expression->field_in(*out_stream, field_name, container);
db_expression->field_in(*out_stream, field_name, container, &model_env);
}
return *this;
@ -566,6 +554,22 @@ public:
protected:
void set_out_stream()
{
if( model_connector )
{
this->out_stream = model_connector->get_stream();
}
else
{
this->out_stream = nullptr;
}
}
private:
@ -591,12 +595,13 @@ private:
if( db_connector )
{
db_expression = db_connector->get_expression();
db_expression->allow_to_use_prefix(true);
}
}
}
};
} // namespace

16
src/finderhelper.h
View File

@ -46,9 +46,11 @@ class FinderHelper
{
public:
PT::TextStream morm_finder_join_tables;
std::map<std::string, int> morm_table_join_map;
std::list<std::string> morm_foreign_keys;
PT::TextStream join_tables_str;
std::map<std::string, int> join_tables_map;
std::list<std::string> foreign_keys;
@ -64,9 +66,9 @@ public:
virtual void clear()
{
morm_finder_join_tables.clear();
morm_table_join_map.clear();
morm_foreign_keys.clear();
join_tables_str.clear();
join_tables_map.clear();
foreign_keys.clear();
}
@ -81,7 +83,7 @@ public:
virtual int add_join_table(const std::string & table_name)
{
auto res = morm_table_join_map.insert(std::make_pair(table_name, 1));
auto res = join_tables_map.insert(std::make_pair(table_name, 1));
if( !res.second )
{

2
src/flatconnector.cpp
View File

@ -74,7 +74,9 @@ void FlatConnector::to_text(PT::TextStream & stream, Model & model)
if( flat_expression )
{
flat_expression->clear();
flat_expression->set_work_mode(MORM_WORK_MODE_MODEL_FIELDS_VALUES);
flat_expression->allow_to_use_prefix(false);
flat_expression->generate_from_model(stream, model);
}
}

10
src/jsonexpression.h
View File

@ -68,16 +68,6 @@ protected:
void after_field_value_list();
template<typename FieldValue>
void print_field_name_value(const wchar_t * field_name, const FieldValue & field_value)
{
put_field_name(field_name);
(*out_stream) << ":";
put_field_value(field_value);
}
void esc(char val, PT::TextStream & stream);

42
src/model.cpp
View File

@ -99,39 +99,6 @@ void Model::table_name(PT::TextStream & stream)
}
// the body can be moved to dbexpression
// the algorithm can be different depending on the database used
void Model::table_name_for_join_as(PT::TextStream & stream)
{
PT::TextStream str_temp;
table_name(str_temp);
// temporarily
std::string str;
str_temp.to_string(str);
size_t i = str.size();
while( i-- > 0 )
{
if( str[i] == '.' )
{
break;
}
}
if( str[i] == '.' )
{
i += 1;
}
for( ; i < str.size() ; ++i)
{
stream << str[i];
}
}
void Model::set_connector(ModelConnector & connector)
{
@ -175,9 +142,9 @@ void Model::to_text(PT::TextStream & stream, ModelData * model_data, bool clear_
if( flat_connector )
{
this->model_env->model_data = model_data;
model_env->model_data = model_data;
flat_connector->to_text(stream, *this);
this->model_env->model_data = nullptr;
model_env->model_data = nullptr;
}
}
@ -554,11 +521,6 @@ void Model::clear()
}
void Model::prepare_to_select()
{
model_env->table_index = 1;
}

49
src/model.h
View File

@ -95,7 +95,6 @@ public:
*
*/
virtual void table_name(PT::TextStream & stream);
virtual void table_name_for_join_as(PT::TextStream & stream);
virtual void to_text(PT::TextStream & stream, ModelData * model_data, bool clear_stream = true);
virtual void to_text(PT::TextStream & stream, ModelData & model_data, bool clear_stream = true);
@ -131,8 +130,6 @@ public:
// set object to default values
virtual void clear();
// we need a pointer to ModelData here?
virtual void prepare_to_select();
protected:
@ -649,7 +646,7 @@ protected:
if( flat_expression && !is_empty_field(flat_field_name) )
{
// insertable, updatable and is_primary_key are ignored here
flat_expression->field(flat_field_name, field_value, insertable, updatable, is_primary_key, true, model_env);
flat_expression->field(flat_field_name, field_value, insertable, updatable, is_primary_key, model_env);
}
}
}
@ -664,7 +661,7 @@ protected:
if( db_expression && !is_empty_field(db_field_name) )
{
db_expression->field(db_field_name, field_value, insertable, updatable, is_primary_key, true, model_env);
db_expression->field(db_field_name, field_value, insertable, updatable, is_primary_key, model_env);
}
}
}
@ -712,7 +709,7 @@ protected:
if( doc_expression && !is_empty_field(flat_field_name) )
{
// insertable, updatable and is_primary_key are ignored here
doc_expression->field_doc(*this, flat_field_name, field_value, insertable, updatable, is_primary_key);
doc_expression->field_doc(*this, flat_field_name, field_value, insertable, updatable, is_primary_key, model_env);
}
}
}
@ -724,14 +721,14 @@ protected:
{
if( model_env && field_model.model_env && model_env->finder_helper )
{
model_env->finder_helper->morm_foreign_keys.clear();
field_model.model_env->table_index = model_env->finder_helper->add_join_table(field_model.model_env->table_name_simple);
model_env->finder_helper->foreign_keys.clear();
field_model.model_env->table_index = model_env->finder_helper->add_join_table(field_model.model_env->table_name_short);
model_env->finder_helper->morm_finder_join_tables << "LEFT JOIN " << field_model.model_env->table_name
<< " AS " << field_model.model_env->table_name_simple;
model_env->finder_helper->join_tables_str << "LEFT JOIN " << field_model.model_env->table_name
<< " AS " << field_model.model_env->table_name_short;
if( field_model.model_env->table_index > 1 )
model_env->finder_helper->morm_finder_join_tables << field_model.model_env->table_index;
model_env->finder_helper->join_tables_str << field_model.model_env->table_index;
int expr_work_mode = db_expression->get_work_mode();
int expr_output_type = db_expression->get_output_type();
@ -745,29 +742,29 @@ protected:
{
field_model.map_fields();
model_env->finder_helper->morm_finder_join_tables << " ON " << model_env->table_name_simple << '.'
<< db_field_name << " = " << field_model.model_env->table_name_simple << '.';
model_env->finder_helper->join_tables_str << " ON " << model_env->table_name_short << '.'
<< db_field_name << " = " << field_model.model_env->table_name_short << '.';
if( model_env->finder_helper->morm_foreign_keys.size() == 1 )
if( model_env->finder_helper->foreign_keys.size() == 1 )
{
model_env->finder_helper->morm_finder_join_tables << model_env->finder_helper->morm_foreign_keys.front();
model_env->finder_helper->join_tables_str << model_env->finder_helper->foreign_keys.front();
}
}
else
{
map_fields();
model_env->finder_helper->morm_finder_join_tables << " ON " << model_env->table_name_simple << '.';
model_env->finder_helper->join_tables_str << " ON " << model_env->table_name_short << '.';
if( model_env->finder_helper->morm_foreign_keys.size() == 1 )
if( model_env->finder_helper->foreign_keys.size() == 1 )
{
model_env->finder_helper->morm_finder_join_tables << model_env->finder_helper->morm_foreign_keys.front();
model_env->finder_helper->join_tables_str << model_env->finder_helper->foreign_keys.front();
}
model_env->finder_helper->morm_finder_join_tables << " = " << field_model.model_env->table_name_simple << '.' << db_field_name;
model_env->finder_helper->join_tables_str << " = " << field_model.model_env->table_name_short << '.' << db_field_name;
}
model_env->finder_helper->morm_finder_join_tables << ' ';
model_env->finder_helper->join_tables_str << ' ';
db_expression->set_work_mode(expr_work_mode);
db_expression->set_output_type(expr_output_type);
@ -777,7 +774,7 @@ protected:
void field_model_generate_flat_string(const wchar_t * db_field_name, const wchar_t * flat_field_name, Model & field_model, bool insertable, bool updatable, bool has_foreign_key)
void field_model_generate_flat_string(const wchar_t * db_field_name, const wchar_t * flat_field_name, Model & field_model, bool insertable, bool updatable)
{
FlatConnector * flat_connector = model_connector->get_flat_connector();
@ -788,7 +785,7 @@ protected:
if( flat_expression && !is_empty_field(flat_field_name) )
{
field_model.model_env->model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING;
flat_expression->field_model(flat_field_name, field_model, insertable, updatable, false);
flat_expression->field_model(flat_field_name, field_model, insertable, updatable, false, model_env);
}
}
}
@ -807,7 +804,7 @@ protected:
field_model.model_env->model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
field_model.table_name(field_model.model_env->table_name);
field_model.table_name_for_join_as(field_model.model_env->table_name_simple);
db_expression->prepare_short_table_name(field_model.model_env->table_name, field_model.model_env->table_name_short);
if( db_expression->get_output_type() == MORM_OUTPUT_TYPE_SELECT_COLUMNS )
{
@ -848,7 +845,7 @@ protected:
if( doc_expression && !is_empty_field(flat_field_name) )
{
// insertable, updatable and is_primary_key are ignored here
doc_expression->field_doc(*this, flat_field_name, field_model, insertable, updatable, false);
doc_expression->field_doc(*this, flat_field_name, field_model, insertable, updatable, false, model_env);
}
}
}
@ -885,7 +882,7 @@ protected:
if( model_env->model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING )
{
field_model_generate_flat_string(db_field_name, flat_field_name, field_model, insertable, updatable, has_foreign_key);
field_model_generate_flat_string(db_field_name, flat_field_name, field_model, insertable, updatable);
}
if( model_env->model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL )
@ -976,7 +973,7 @@ protected:
if( doc_expression && !is_empty_field(flat_field_name) )
{
// insertable, updatable and is_primary_key are ignored here
doc_expression->field_doc(*this, flat_field_name, field_container, insertable, updatable, false, model_env->model_data);
doc_expression->field_doc(*this, flat_field_name, field_container, insertable, updatable, false, model_env);
}
}
}

4
src/modelenv.h
View File

@ -56,7 +56,7 @@ public:
const void * doc_field_pointer;
PT::TextStream table_name;
PT::TextStream table_name_simple;
PT::TextStream table_name_short;
int table_index;
@ -102,7 +102,7 @@ public:
model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
doc_field_pointer = nullptr;
table_name.clear();
table_name_simple.clear();
table_name_short.clear();
table_index = 0;
}

1
src/morm_types.h
View File

@ -77,6 +77,7 @@
#define MORM_OUTPUT_TYPE_WHERE_LE 13
#define MORM_OUTPUT_TYPE_WHERE_GE 14
#define MORM_OUTPUT_TYPE_WHERE_IN 15
#define MORM_OUTPUT_TYPE_WHERE_NOT_EQ 16
#define MORM_CONJUNCTION_AND 1