diff --git a/samples/attachment.h b/samples/attachment.h
index a9de982..38c58b6 100644
--- a/samples/attachment.h
+++ b/samples/attachment.h
@@ -52,6 +52,7 @@ CREATE TABLE public.attachment (
     content text,
     some_flags bool,
     created_date timestamp with time zone,
+    bigint language_id,
 
     primary key(id)
 );
@@ -68,13 +69,17 @@ public:
 	std::string content;
 	bool some_flags;
 	PT::Date created_date;
-
+	Language language;
 
 	void map_fields()
 	{
 		field(L"id", id, false, false, true);
 		field(L"person_id", person_id);
 		field(L"name", name);
+
+		field(L"language_id", language);
+
+
 		field(L"content", content);
 		field(L"some_flags", some_flags);
 		field(L"created_date", created_date);
diff --git a/samples/main.cpp b/samples/main.cpp
index a557f49..2c7d512 100644
--- a/samples/main.cpp
+++ b/samples/main.cpp
@@ -119,6 +119,8 @@ args_options.Add(L"config", 1);
 	model_connector.set_logger(log);
 
 	postgresql_connector.set_log_queries(true);
+
+	// CHECK ME may it would be better if postgresql_connector could take the logger from model_connector?
 	postgresql_connector.set_logger(log);
 
 	morm::samples::Sample01 sample_01;
diff --git a/samples/sample01.h b/samples/sample01.h
index 1ff2756..713ab2c 100644
--- a/samples/sample01.h
+++ b/samples/sample01.h
@@ -57,7 +57,10 @@ void make()
 	std::wstring sss = L"cosik";
 	person.set_field_value_generic(L"email", L"email", sss);
 
-	person.insert();
+	//person.insert();
+	//person.update();
+	person.save();
+
 }
 
 
@@ -74,20 +77,35 @@ private:
 		person.first_name = L"MyFirstName";
 		person.last_name = L"MyLastName";
 		person.email = L"myemail@mydomain.ltd";
+		person.set_save_mode(Model::DO_INSERT_ON_SAVE);
+		//person.set_save_mode(Model::DO_UPDATE_ON_SAVE);
 
 		person.language.id = 100;
 		person.language.english_name = L"english";
 		person.language.local_name = L"polish";
 		person.language.code_str = L"en";
 		person.language.code_int = 200;
+		person.language.set_save_mode(Model::DO_INSERT_ON_SAVE);
+		//person.language.set_save_mode(Model::DO_UPDATE_ON_SAVE);
 
 		std::time_t t = std::time(0);
 
-		person.attachment.person_id = -1;
+		person.attachment.id = 300;
+		person.attachment.person_id = 200;
 		person.attachment.created_date.FromTime(t);
-		person.attachment.name = L"attchment name";
+		person.attachment.name = L"attachment name";
 		person.attachment.content = "long binary content";
 		person.attachment.some_flags = true;
+		person.attachment.set_save_mode(Model::DO_INSERT_ON_SAVE);
+		//person.attachment.set_save_mode(Model::DO_UPDATE_ON_SAVE);
+
+		person.attachment.language.id = 110;
+		person.attachment.language.english_name = L"attachment language";
+		person.attachment.language.local_name = L"attachment local name";
+		person.attachment.language.code_str = L"loen";
+		person.attachment.language.code_int = 300;
+		person.attachment.language.set_save_mode(Model::DO_UPDATE_ON_SAVE);
+
 	}
 
 
diff --git a/src/baseexpression.h b/src/baseexpression.h
index 08e36d1..5f33058 100644
--- a/src/baseexpression.h
+++ b/src/baseexpression.h
@@ -99,9 +99,23 @@ public:
 			else
 			if( work_mode == MORM_WORK_MODE_MODEL_FIELDS_VALUES )
 			{
-				put_field_name(field_name, model_env);
-				put_name_value_separator();
-				put_field_value(field_value);
+				if( model_env && model_env->set_field_name_helper )
+				{
+					if( (size_t)model_env->field_index < model_env->set_field_name_helper->size() )
+					{
+						put_field_name((*model_env->set_field_name_helper)[model_env->field_index], model_env);
+						put_name_value_separator();
+						put_field_value(field_value);
+					}
+
+					model_env->field_index += 1;
+				}
+				else
+				{
+					put_field_name(field_name, model_env);
+					put_name_value_separator();
+					put_field_value(field_value);
+				}
 			}
 
 
diff --git a/src/dbexpression.cpp b/src/dbexpression.cpp
index fb8ba48..689dac8 100644
--- a/src/dbexpression.cpp
+++ b/src/dbexpression.cpp
@@ -142,7 +142,9 @@ void DbExpression::put_name_value_separator()
 {
 	if( output_type == MORM_OUTPUT_TYPE_DB_PRIMARY_KEY ||
 		output_type == MORM_OUTPUT_TYPE_WHERE_EQ ||
-		output_type == MORM_OUTPUT_TYPE_DB_UPDATE)
+		output_type == MORM_OUTPUT_TYPE_DB_UPDATE ||
+		output_type == MORM_OUTPUT_TYPE_DB_INSERT_PRIMARY_KEY ||
+		output_type == MORM_OUTPUT_TYPE_DB_UPDATE_PRIMARY_KEY )
 	{
 		(*out_stream) << "=";
 	}
diff --git a/src/model.cpp b/src/model.cpp
index e12efb1..583e9d1 100644
--- a/src/model.cpp
+++ b/src/model.cpp
@@ -232,6 +232,12 @@ void Model::generate_insert_query(PT::TextStream & stream, ModelData * model_dat
 }
 
 
+bool Model::insert(ModelData & model_data, bool insert_whole_tree)
+{
+	return insert(&model_data, insert_whole_tree);
+}
+
+
 bool Model::insert(ModelData * model_data, bool insert_whole_tree)
 {
 	ModelEnv model_env_local;
@@ -248,13 +254,14 @@ bool Model::insert(ModelData * model_data, bool insert_whole_tree)
 
 
 // has ModelEnv set
+// FIX ME we need to propagage the status from the whole tree, if there is an error somewhere then we should return error from the parent
 bool Model::insert_tree(bool insert_whole_tree)
 {
 	bool result = false;
 
 	if( insert_whole_tree )
 	{
-		model_env->model_connector_mode = MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_AND_INSERT;
+		model_env->model_connector_mode = MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITH_FOREIGN_KEY_AND_INSERT;
 		map_fields();
 	}
 
@@ -288,7 +295,7 @@ bool Model::insert_tree(bool insert_whole_tree)
 
 	if( insert_whole_tree )
 	{
-		model_env->model_connector_mode = MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_AND_INSERT_XXX;
+		model_env->model_connector_mode = MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITHOUT_FOREIGN_KEY_AND_INSERT;
 		map_fields();
 	}
 
@@ -297,12 +304,6 @@ bool Model::insert_tree(bool insert_whole_tree)
 
 
 
-bool Model::insert(ModelData & model_data, bool insert_whole_tree)
-{
-	return insert(&model_data, insert_whole_tree);
-}
-
-
 void Model::generate_update_query(PT::TextStream & stream, ModelData * model_data)
 {
 	ModelEnv model_env_local;
@@ -325,16 +326,40 @@ void Model::generate_update_query(PT::TextStream & stream, ModelData * model_dat
 }
 
 
-bool Model::update(ModelData * model_data)
+bool Model::update(ModelData & model_data, bool update_whole_tree)
+{
+	return update(&model_data, update_whole_tree);
+}
+
+
+bool Model::update(ModelData * model_data, bool update_whole_tree)
+{
+	ModelEnv model_env_local;
+	model_env = &model_env_local;
+
+	model_env->model_data = model_data;
+	bool status = update_tree(update_whole_tree);
+
+	// what about if an exception was thrown? this pointer will not be null
+	model_env = nullptr;
+
+	return status;
+}
+
+
+// FIX ME we need to propagage the status from the whole tree, if there is an error somewhere then we should return error from the parent
+bool Model::update_tree(bool update_whole_tree)
 {
 	bool result = false;
 
+	if( update_whole_tree )
+	{
+		model_env->model_connector_mode = MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITH_FOREIGN_KEY_AND_UPDATE;
+		map_fields();
+	}
+
 	if( model_connector )
 	{
-		ModelEnv model_env_local;
-		model_env = &model_env_local;
-
-		model_env->model_data = model_data;
 		model_env->model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL;
 		DbConnector * db_connector = model_connector->get_db_connector();
 
@@ -352,21 +377,18 @@ bool Model::update(ModelData * model_data)
 			else
 				after_update_failure();
 		}
+	}
 
-		// what about if an exception was thrown? this pointer will not be null
-		model_env = nullptr;
+	if( update_whole_tree )
+	{
+		model_env->model_connector_mode = MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITHOUT_FOREIGN_KEY_AND_UPDATE;
+		map_fields();
 	}
 
 	return result;
 }
 
 
-bool Model::update(ModelData & model_data)
-{
-	return update(&model_data);
-}
-
-
 void Model::generate_remove_query(PT::TextStream & stream, ModelData * model_data)
 {
 	ModelEnv model_env_local;
@@ -436,22 +458,52 @@ bool Model::remove(ModelData & model_data)
 }
 
 
-bool Model::save(ModelData * model_data)
+
+bool Model::save(ModelData & model_data, bool save_whole_tree)
+{
+	return save(&model_data, save_whole_tree);
+}
+
+bool Model::save(ModelData * model_data, bool save_whole_tree)
+{
+	ModelEnv model_env_local;
+	model_env = &model_env_local;
+
+	model_env->model_data = model_data;
+	bool status = save_tree(save_whole_tree);
+
+	// what about if an exception was thrown? this pointer will not be null
+	model_env = nullptr;
+
+	return status;
+}
+
+
+// FIX ME we need to propagage the status from the whole tree, if there is an error somewhere then we should return error from the parent
+bool Model::save_tree(bool save_whole_tree)
 {
 	bool result = false;
 
+	if( save_whole_tree )
+	{
+		model_env->model_connector_mode = MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITH_FOREIGN_KEY_AND_SAVE;
+		map_fields();
+	}
+
+	ModelEnv * old_model_env = model_env; // remove, insert or update will set model_env to nullptr
+
 	switch( save_mode )
 	{
 	case DO_DELETE_ON_SAVE:
-		result = remove(model_data);
+		result = remove(model_env->model_data);// without the whole tree
 		break;
 
 	case DO_INSERT_ON_SAVE:
-		result = insert(model_data);
+		result = insert(model_env->model_data, false);
 		break;
 
 	case DO_UPDATE_ON_SAVE:
-		result = update(model_data);
+		result = update(model_env->model_data, false);
 		break;
 
 	case DO_NOTHING_ON_SAVE:
@@ -459,16 +511,18 @@ bool Model::save(ModelData * model_data)
 		break;
 	}
 
+	model_env = old_model_env;
+
+	if( save_whole_tree )
+	{
+		model_env->model_connector_mode = MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITHOUT_FOREIGN_KEY_AND_SAVE;
+		map_fields();
+	}
+
 	return result;
 }
 
 
-bool Model::save(ModelData & model_data)
-{
-	return save(&model_data);
-}
-
-
 void Model::generate_select_columns(PT::TextStream & stream)
 {
 	if( model_connector && model_env )
diff --git a/src/model.h b/src/model.h
index ee5d0ee..f42a60e 100644
--- a/src/model.h
+++ b/src/model.h
@@ -114,15 +114,15 @@ public:
 	virtual bool insert(ModelData & model_data, bool insert_whole_tree = true);
 
 	virtual void generate_update_query(PT::TextStream & stream, ModelData * model_data = nullptr);
-	virtual bool update(ModelData * model_data = nullptr);
-	virtual bool update(ModelData & model_data);
+	virtual bool update(ModelData * model_data = nullptr, bool update_whole_tree = true);
+	virtual bool update(ModelData & model_data, bool update_whole_tree = true);
 
 	virtual void generate_remove_query(PT::TextStream & stream, ModelData * model_data = nullptr);
 	virtual bool remove(ModelData * model_data = nullptr);
 	virtual bool remove(ModelData & model_data);
 
-	virtual bool save(ModelData * model_data = nullptr);
-	virtual bool save(ModelData & model_data);
+	virtual bool save(ModelData * model_data = nullptr, bool save_whole_tree = true);
+	virtual bool save(ModelData & model_data, bool save_whole_tree = true);
 
 	virtual void generate_select_columns(PT::TextStream & stream);
 
@@ -187,6 +187,8 @@ protected:
 	virtual ModelData * get_model_data();
 
 	virtual bool insert_tree(bool insert_whole_tree);
+	virtual bool update_tree(bool update_whole_tree);
+	virtual bool save_tree(bool save_whole_tree);
 
 	virtual void map_values_from_query();
 
@@ -889,25 +891,45 @@ protected:
 					field_model_left_join(db_field_name, flat_field_name, field_model, insertable, updatable, has_foreign_key, db_expression);
 				}
 
-				if( db_expression->get_work_mode() == MORM_WORK_MODE_MODEL_FIELDS && db_expression->get_output_type() == MORM_OUTPUT_TYPE_DB_INSERT && has_foreign_key )
+				if( has_foreign_key )
 				{
-					int not_used_object = 0;
-					db_expression->field(db_field_name, not_used_object, insertable, updatable, false, model_env);
-				}
+					if( db_expression->get_work_mode() == MORM_WORK_MODE_MODEL_FIELDS && db_expression->get_output_type() == MORM_OUTPUT_TYPE_DB_INSERT )
+					{
+						int not_used_object = 0;
+						db_expression->field(db_field_name, not_used_object, insertable, updatable, false, model_env);
+					}
 
-				if( db_expression->get_work_mode() == MORM_WORK_MODE_MODEL_VALUES && db_expression->get_output_type() == MORM_OUTPUT_TYPE_DB_INSERT && has_foreign_key )
-				{
-					db_expression->set_output_type(MORM_OUTPUT_TYPE_DB_INSERT_PRIMARY_KEY);
-					field_model.map_fields();
-					db_expression->set_output_type(MORM_OUTPUT_TYPE_DB_INSERT);
+					if( db_expression->get_work_mode() == MORM_WORK_MODE_MODEL_VALUES && db_expression->get_output_type() == MORM_OUTPUT_TYPE_DB_INSERT )
+					{
+						db_expression->set_output_type(MORM_OUTPUT_TYPE_DB_INSERT_PRIMARY_KEY);
+						field_model.map_fields();
+						db_expression->set_output_type(MORM_OUTPUT_TYPE_DB_INSERT);
+					}
+
+					if( db_expression->get_work_mode() == MORM_WORK_MODE_MODEL_FIELDS_VALUES && db_expression->get_output_type() == MORM_OUTPUT_TYPE_DB_UPDATE )
+					{
+						std::vector<const wchar_t *> key_fields;
+						key_fields.push_back(db_field_name); // at the moment only one key
+
+						db_expression->set_output_type(MORM_OUTPUT_TYPE_DB_UPDATE_PRIMARY_KEY);
+						field_model.model_env->field_index = 0;
+						field_model.model_env->set_field_name_helper = &key_fields;
+						field_model.map_fields();
+						db_expression->set_output_type(MORM_OUTPUT_TYPE_DB_UPDATE);
+
+						if( (size_t)field_model.model_env->field_index != key_fields.size() )
+						{
+							// number of keys are different
+							// put error log here
+						}
+					}
 				}
 
 				if( db_expression->get_output_type() != MORM_OUTPUT_TYPE_JOIN_TABLES &&
+					db_expression->get_output_type() != MORM_OUTPUT_TYPE_DB_PRIMARY_KEY &&
 					db_expression->get_output_type() != MORM_OUTPUT_TYPE_DB_INSERT &&
 					db_expression->get_output_type() != MORM_OUTPUT_TYPE_DB_UPDATE )
 				{
-					// FIX ME
-					// UPDATE, INSERT, REMOVE for models
 					field_model.map_fields();
 				}
 
@@ -1030,36 +1052,52 @@ protected:
 				field_model_set_parent_key(db_field_name, flat_field_name, field_model);
 			}
 
-			if( model_env->model_connector_mode == MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_AND_INSERT && has_foreign_key )
+			if( model_env->model_connector_mode == MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITH_FOREIGN_KEY_AND_INSERT && has_foreign_key )
 			{
 				if( !is_empty_field(db_field_name) )
 				{
-					field_model.map_fields();
 					field_model.insert_tree(true);
 				}
 			}
 
-			if( model_env->model_connector_mode == MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_AND_INSERT_XXX && !has_foreign_key )
+			if( model_env->model_connector_mode == MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITHOUT_FOREIGN_KEY_AND_INSERT && !has_foreign_key )
 			{
 				if( !is_empty_field(db_field_name) )
 				{
-					field_model.map_fields();
 					field_model.insert_tree(true);
 				}
 			}
 
-			if( model_env->model_connector_mode == MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_AND_UPDATE )
+			if( model_env->model_connector_mode == MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITH_FOREIGN_KEY_AND_UPDATE && has_foreign_key )
 			{
-				// IMPROVE ME what about if db_field_name is empty? not iterate in such a case?
-				//field_model.map_fields();
-				//field_model.update_tree(true);
+				if( !is_empty_field(db_field_name) )
+				{
+					field_model.update_tree(true);
+				}
 			}
 
-			if( model_env->model_connector_mode == MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_AND_SAVE )
+			if( model_env->model_connector_mode == MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITHOUT_FOREIGN_KEY_AND_UPDATE && !has_foreign_key )
 			{
-				// IMPROVE ME what about if db_field_name is empty? not iterate in such a case?
-				//field_model.map_fields();
-				//field_model.save_tree(true);
+				if( !is_empty_field(db_field_name) )
+				{
+					field_model.update_tree(true);
+				}
+			}
+
+			if( model_env->model_connector_mode == MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITH_FOREIGN_KEY_AND_SAVE && has_foreign_key )
+			{
+				if( !is_empty_field(db_field_name) )
+				{
+					field_model.save_tree(true);
+				}
+			}
+
+			if( model_env->model_connector_mode == MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITHOUT_FOREIGN_KEY_AND_SAVE && !has_foreign_key )
+			{
+				if( !is_empty_field(db_field_name) )
+				{
+					field_model.save_tree(true);
+				}
 			}
 
 			if( model_env->model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING )
diff --git a/src/modelenv.h b/src/modelenv.h
index d616628..0548a29 100644
--- a/src/modelenv.h
+++ b/src/modelenv.h
@@ -62,6 +62,7 @@ public:
 	int table_index;
 	int field_index;
 
+	std::vector<const wchar_t *> * set_field_name_helper;
 	SetFieldValueHelper * set_field_value_helper;
 
 
@@ -84,6 +85,7 @@ public:
 		model_connector_mode = e.model_connector_mode;
 		table_index = e.table_index;
 		doc_field_pointer = e.doc_field_pointer;
+		set_field_name_helper = e.set_field_name_helper;
 		set_field_value_helper = e.set_field_value_helper;
 		field_index = e.field_index;
 
@@ -112,6 +114,7 @@ public:
 		table_name.clear();
 		table_name_short.clear();
 		table_index = 0;
+		set_field_name_helper = nullptr;
 		set_field_value_helper = nullptr;
 		field_index = 0;
 	}
diff --git a/src/morm_types.h b/src/morm_types.h
index 6133404..ce2884f 100644
--- a/src/morm_types.h
+++ b/src/morm_types.h
@@ -47,21 +47,23 @@
 #define MORM_MODEL_CONNECTOR_MODE_READING_VALUE_FROM_DB_RESULTSET 6
 #define MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE 7
 
-// RENAME TO MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITH_FOREIGN_KEY_AND_INSERT
-#define MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_AND_INSERT 8
 
-// RENAME ME MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITHOUT_FOREIGN_KEY_AND_INSERT
-#define MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_AND_INSERT_XXX 30
+#define MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITH_FOREIGN_KEY_AND_INSERT 8
+#define MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITHOUT_FOREIGN_KEY_AND_INSERT 9
+
+#define MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITH_FOREIGN_KEY_AND_UPDATE 10
+#define MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITHOUT_FOREIGN_KEY_AND_UPDATE 11
+
+#define MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITH_FOREIGN_KEY_AND_SAVE 12
+#define MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_WITHOUT_FOREIGN_KEY_AND_SAVE 13
+
+#define MORM_MODEL_CONNECTOR_MODE_SET_PARENT_ID 14
+
+#define MORM_MODEL_CONNECTOR_MODE_ITERATE_PRIMARY_KEY_VALUES 15
+
+#define MORM_MODEL_CONNECTOR_MODE_SET_FIELD_VALUE 16
 
 
-#define MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_AND_UPDATE 9
-#define MORM_MODEL_CONNECTOR_MODE_ITERATE_THROUGH_CHILDS_AND_SAVE 10
-
-#define MORM_MODEL_CONNECTOR_MODE_SET_PARENT_ID 11
-
-#define MORM_MODEL_CONNECTOR_MODE_ITERATE_PRIMARY_KEY_VALUES 12
-
-#define MORM_MODEL_CONNECTOR_MODE_SET_FIELD_VALUE 13
 
 
 #define MORM_WORK_MODE_MODEL_FIELDS 1
@@ -82,22 +84,23 @@
 #define MORM_OUTPUT_TYPE_DB_PRIMARY_KEY 4
 
 #define MORM_OUTPUT_TYPE_DB_INSERT_PRIMARY_KEY 5
+#define MORM_OUTPUT_TYPE_DB_UPDATE_PRIMARY_KEY 5
 
 
-//#define MORM_OUTPUT_TYPE_WHERE_CUSTOM 6
-#define MORM_OUTPUT_TYPE_SELECT_COLUMNS 7
+//#define MORM_OUTPUT_TYPE_WHERE_CUSTOM 7
+#define MORM_OUTPUT_TYPE_SELECT_COLUMNS 8
 
-#define MORM_OUTPUT_TYPE_JOIN_TABLES 8
-#define MORM_OUTPUT_TYPE_COPY_PARENT_KEY 8
+#define MORM_OUTPUT_TYPE_JOIN_TABLES 9
+#define MORM_OUTPUT_TYPE_COPY_PARENT_KEY 10
 
 
-#define MORM_OUTPUT_TYPE_WHERE_EQ 10
-#define MORM_OUTPUT_TYPE_WHERE_LT 11
-#define MORM_OUTPUT_TYPE_WHERE_GT 12
-#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_OUTPUT_TYPE_WHERE_EQ 20
+#define MORM_OUTPUT_TYPE_WHERE_LT 21
+#define MORM_OUTPUT_TYPE_WHERE_GT 22
+#define MORM_OUTPUT_TYPE_WHERE_LE 23
+#define MORM_OUTPUT_TYPE_WHERE_GE 24
+#define MORM_OUTPUT_TYPE_WHERE_IN 25
+#define MORM_OUTPUT_TYPE_WHERE_NOT_EQ 26
 
 
 #define MORM_CONJUNCTION_AND 1