black, add additional tests with combined fields and exclude_fields, add aliases for column names to tests with fields and exclude_fields

ormar/models/metaclass.py

@@ -88,7 +88,7 @@ def register_reverse_model_fields(
         adjust_through_many_to_many_model(model, child, model_field)
     else:
         model.Meta.model_fields[child_model_name] = ForeignKey(
-            child, name=child_model_name, virtual=True
+            child, real_name=child_model_name, virtual=True
         )
 
 
@@ -96,10 +96,10 @@ def adjust_through_many_to_many_model(
     model: Type["Model"], child: Type["Model"], model_field: Type[ManyToManyField]
 ) -> None:
     model_field.through.Meta.model_fields[model.get_name()] = ForeignKey(
-        model, name=model.get_name(), ondelete="CASCADE"
+        model, real_name=model.get_name(), ondelete="CASCADE"
     )
     model_field.through.Meta.model_fields[child.get_name()] = ForeignKey(
-        child, name=child.get_name(), ondelete="CASCADE"
+        child, real_name=child.get_name(), ondelete="CASCADE"
     )
 
     create_and_append_m2m_fk(model, model_field)
@@ -166,7 +166,7 @@ def sqlalchemy_columns_from_model_fields(
             and not field.virtual
             and not issubclass(field, ManyToManyField)
         ):
-            columns.append(field.get_column(field_name))
+            columns.append(field.get_column(field.get_alias()))
         register_relation_in_alias_manager(table_name, field)
     return pkname, columns
 
@@ -211,8 +211,7 @@ def populate_pydantic_default_values(attrs: Dict) -> Tuple[Dict, Dict]:
         {k: v for k, v in attrs.items() if lenient_issubclass(v, BaseField)}
     )
     for field_name, field in potential_fields.items():
-        if field.name is None:
-            field.name = field_name
+        field.name = field_name
         attrs = populate_default_pydantic_field_value(field, field_name, attrs)
         model_fields[field_name] = field
         attrs["__annotations__"][field_name] = field.__type__

ormar/models/model.py

@@ -164,8 +164,11 @@ class Model(NewBaseModel):
         if not self.pk and self.Meta.model_fields[self.Meta.pkname].autoincrement:
             self_fields.pop(self.Meta.pkname, None)
         self_fields = self.populate_default_values(self_fields)
+
+        self_fields = self.translate_columns_to_aliases(self_fields)
         expr = self.Meta.table.insert()
         expr = expr.values(**self_fields)
+
         item_id = await self.Meta.database.execute(expr)
         if item_id:  # postgress does not return id if it's already there
             setattr(self, self.Meta.pkname, item_id)

ormar/models/modelproxy.py

@@ -65,14 +65,14 @@ class ModelTableProxy:
     @classmethod
     def get_column_alias(cls, field_name: str) -> str:
         field = cls.Meta.model_fields.get(field_name)
-        if field and field.name is not None and field.name != field_name:
-            return field.name
+        if field and field.alias is not None:
+            return field.alias
         return field_name
 
     @classmethod
     def get_column_name_from_alias(cls, alias: str) -> str:
         for field_name, field in cls.Meta.model_fields.items():
-            if field and field.name == alias:
+            if field and field.alias == alias:
                 return field_name
         return alias  # if not found it's not an alias but actual name
 
@@ -164,19 +164,15 @@ class ModelTableProxy:
     @classmethod
     def translate_columns_to_aliases(cls, new_kwargs: Dict) -> Dict:
         for field_name, field in cls.Meta.model_fields.items():
-            if (
-                field_name in new_kwargs
-                and field.name is not None
-                and field.name != field_name
-            ):
-                new_kwargs[field.name] = new_kwargs.pop(field_name)
+            if field_name in new_kwargs:
+                new_kwargs[field.get_alias()] = new_kwargs.pop(field_name)
         return new_kwargs
 
     @classmethod
     def translate_aliases_to_columns(cls, new_kwargs: Dict) -> Dict:
         for field_name, field in cls.Meta.model_fields.items():
-            if field.name in new_kwargs and field.name != field_name:
-                new_kwargs[field_name] = new_kwargs.pop(field.name)
+            if field.alias and field.alias in new_kwargs:
+                new_kwargs[field_name] = new_kwargs.pop(field.alias)
         return new_kwargs
 
     @classmethod

ormar/models/newbasemodel.py

@@ -138,9 +138,9 @@ class NewBaseModel(pydantic.BaseModel, ModelTableProxy, metaclass=ModelMetaclass
     def _extract_related_model_instead_of_field(
         self, item: str
     ) -> Optional[Union["T", Sequence["T"]]]:
-        alias = self.get_column_alias(item)
-        if alias in self._orm:
-            return self._orm.get(alias)
+        # alias = self.get_column_alias(item)
+        if item in self._orm:
+            return self._orm.get(item)
         return None  # pragma no cover
 
     def __eq__(self, other: object) -> bool: