Prodream/ormar
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
collerek
2020-11-11 10:10:30 +01:00
parent b1a30eaffc
commit 9350b929aa
15 changed files with 148 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
ormar/fields/base.py
View File

@ -18,6 +18,7 @@ class BaseField(FieldInfo):
column_type: sqlalchemy.Column
constraints: List = []
name: str
alias: str
primary_key: bool
autoincrement: bool
@ -33,10 +34,14 @@ class BaseField(FieldInfo):
default: Any
server_default: Any
@classmethod
def get_alias(cls) -> str:
return cls.alias if cls.alias else cls.name
@classmethod
def is_valid_field_info_field(cls, field_name: str) -> bool:
return (
field_name not in ["default", "default_factory"]
field_name not in ["default", "default_factory", "alias"]
and not field_name.startswith("__")
and hasattr(cls, field_name)
)
@ -93,7 +98,7 @@ class BaseField(FieldInfo):
@classmethod
def get_column(cls, name: str) -> sqlalchemy.Column:
return sqlalchemy.Column(
cls.name or name,
cls.alias or name,
cls.column_type,
*cls.constraints,
primary_key=cls.primary_key,

4
ormar/fields/foreign_key.py
View File

@ -50,6 +50,7 @@ def ForeignKey( # noqa CFQ002
virtual: bool = False,
onupdate: str = None,
ondelete: str = None,
**kwargs: Any,
) -> Any:
fk_string = to.Meta.tablename + "." + to.get_column_alias(to.Meta.pkname)
to_field = to.Meta.model_fields[to.Meta.pkname]
@ -62,7 +63,8 @@ def ForeignKey( # noqa CFQ002
namespace = dict(
__type__=__type__,
to=to,
name=name,
alias=name,
name=kwargs.pop("real_name", None),
nullable=nullable,
constraints=[
sqlalchemy.schema.ForeignKey(

1
ormar/fields/many_to_many.py
View File

@ -31,6 +31,7 @@ def ManyToMany(
__type__=__type__,
to=to,
through=through,
alias=name,
name=name,
nullable=True,
unique=unique,

3
ormar/fields/model_fields.py
View File

@ -32,7 +32,8 @@ class ModelFieldFactory:
namespace = dict(
__type__=cls._type,
name=kwargs.pop("name", None),
alias=kwargs.pop("name", None),
name=None,
primary_key=kwargs.pop("primary_key", False),
default=default,
server_default=server_default,

11
ormar/models/metaclass.py
View File

@ -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__

3
ormar/models/model.py
View File

@ -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)

18
ormar/models/modelproxy.py
View File

@ -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

6
ormar/models/newbasemodel.py
View File

@ -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:

32
ormar/queryset/join.py
View File

@ -120,7 +120,13 @@ class SqlJoin:
pkname_alias = model_cls.get_column_alias(model_cls.Meta.pkname)
if not is_multi:
self.get_order_bys(alias, to_table, pkname_alias, part)
self.get_order_bys(
alias=alias,
to_table=to_table,
pkname_alias=pkname_alias,
part=part,
model_cls=model_cls,
)
self_related_fields = model_cls.own_table_columns(
model_cls, self.fields, self.exclude_fields, nested=True,
@ -150,8 +156,21 @@ class SqlJoin:
condition[-2] == part or condition[-2][1:] == part
)
def set_aliased_order_by(
self, condition: List[str], alias: str, to_table: str, model_cls: Type["Model"],
) -> None:
direction = f"{'desc' if condition[0][0] == '-' else ''}"
column_alias = model_cls.get_column_alias(condition[-1])
order = text(f"{alias}_{to_table}.{column_alias} {direction}")
self.sorted_orders["__".join(condition)] = order
def get_order_bys( # noqa: CCR001
self, alias: str, to_table: str, pkname_alias: str, part: str
self,
alias: str,
to_table: str,
pkname_alias: str,
part: str,
model_cls: Type["Model"],
) -> None:
if self.order_columns:
split_order_columns = [
@ -159,9 +178,12 @@ class SqlJoin:
]
for condition in split_order_columns:
if self._check_if_condition_apply(condition, part):
direction = f"{'desc' if condition[0][0] == '-' else ''}"
order = text(f"{alias}_{to_table}.{condition[-1]} {direction}")
self.sorted_orders["__".join(condition)] = order
self.set_aliased_order_by(
condition=condition,
alias=alias,
to_table=to_table,
model_cls=model_cls,
)
else:
order = text(f"{alias}_{to_table}.{pkname_alias}")
self.sorted_orders[f"{to_table}.{pkname_alias}"] = order

7
ormar/queryset/query.py
View File

@ -54,14 +54,17 @@ class Query:
pkname_alias = self.model_cls.get_column_alias(self.model_cls.Meta.pkname)
return f"{self.table.name}.{pkname_alias}"
def alias(self, name: str) -> str:
return self.model_cls.get_column_alias(name)
def apply_order_bys_for_primary_model(self) -> None: # noqa: CCR001
if self.order_columns:
for clause in self.order_columns:
if "__" not in clause:
clause = (
text(f"{clause[1:]} desc")
text(f"{self.alias(clause[1:])} desc")
if clause.startswith("-")
else text(clause)
else text(self.alias(clause))
)
self.sorted_orders[clause] = clause
else:

6
ormar/queryset/queryset.py
View File

@ -337,15 +337,15 @@ class QuerySet:
expr = self.table.insert()
expr = expr.values(**new_kwargs)
instance = self.model(**kwargs)
pk = await self.database.execute(expr)
pk_name = self.model.get_column_alias(self.model_meta.pkname)
if pk_name not in kwargs and pk_name in new_kwargs:
instance.pk = new_kwargs[self.model_meta.pkname]
kwargs["pk"] = new_kwargs[self.model_meta.pkname]
if pk and isinstance(pk, self.model.pk_type()):
setattr(instance, self.model_meta.pkname, pk)
kwargs[self.model_meta.pkname] = pk
instance = self.model(**kwargs)
# refresh server side defaults
instance = await instance.load()

20
tests/test_excluding_subset_of_columns.py
View File

@ -34,7 +34,7 @@ class Car(ormar.Model):
name: str = ormar.String(max_length=100)
year: int = ormar.Integer(nullable=True)
gearbox_type: str = ormar.String(max_length=20, nullable=True)
gears: int = ormar.Integer(nullable=True)
gears: int = ormar.Integer(nullable=True, name="gears_number")
aircon_type: str = ormar.String(max_length=20, nullable=True)
@ -79,7 +79,9 @@ async def test_selecting_subset():
all_cars = (
await Car.objects.select_related("manufacturer")
.exclude_fields(["gearbox_type", "gears", "aircon_type", "year", "company__founded"])
.exclude_fields(
["gearbox_type", "gears", "aircon_type", "year", "company__founded"]
)
.all()
)
for car in all_cars:
@ -114,6 +116,20 @@ async def test_selecting_subset():
assert car.manufacturer.name == "Toyota"
assert car.manufacturer.founded == 1937
all_cars_check2 = (
await Car.objects.select_related("manufacturer")
.fields(["id", "name", "manufacturer"])
.exclude_fields("company__founded")
.all()
)
for car in all_cars_check2:
assert all(
getattr(car, x) is None
for x in ["year", "gearbox_type", "gears", "aircon_type"]
)
assert car.manufacturer.name == "Toyota"
assert car.manufacturer.founded is None
with pytest.raises(pydantic.error_wrappers.ValidationError):
# cannot exclude mandatory model columns - company__name in this example
await Car.objects.select_related("manufacturer").exclude_fields(

52
tests/test_order_by.py
View File

@ -32,6 +32,27 @@ class Owner(ormar.Model):
name: str = ormar.String(max_length=100)
class AliasNested(ormar.Model):
class Meta:
tablename = "aliases_nested"
metadata = metadata
database = database
id: int = ormar.Integer(name="alias_id", primary_key=True)
name: str = ormar.String(name="alias_name", max_length=100)
class AliasTest(ormar.Model):
class Meta:
tablename = "aliases"
metadata = metadata
database = database
id: int = ormar.Integer(name="alias_id", primary_key=True)
name: str = ormar.String(name="alias_name", max_length=100)
nested: str = ormar.ForeignKey(AliasNested, name="nested_alias")
class Toy(ormar.Model):
class Meta:
tablename = "toys"
@ -275,3 +296,34 @@ async def test_sort_order_on_many_to_many():
assert users[1].cars[1].name == "Buggy"
assert users[1].cars[2].name == "Ferrari"
assert users[1].cars[3].name == "Skoda"
@pytest.mark.asyncio
async def test_sort_order_with_aliases():
async with database:
al1 = await AliasTest.objects.create(name="Test4")
al2 = await AliasTest.objects.create(name="Test2")
await AliasTest.objects.create(name="Test1")
await AliasTest.objects.create(name="Test3")
aliases = await AliasTest.objects.order_by("-name").all()
assert [alias.name[-1] for alias in aliases] == ["4", "3", "2", "1"]
nest1 = await AliasNested.objects.create(name="Try1")
nest2 = await AliasNested.objects.create(name="Try2")
al1.nested = nest1
await al1.update()
al2.nested = nest2
await al2.update()
aliases = (
await AliasTest.objects.select_related("nested")
.order_by("-nested__name")
.all()
)
assert aliases[0].nested.name == "Try2"
assert aliases[1].nested.name == "Try1"
assert aliases[2].nested is None
assert aliases[3].nested is None

20
tests/test_properties.py
View File

@ -50,17 +50,19 @@ async def test_sort_order_on_main_model():
songs = await Song.objects.all()
song_dict = [song.dict() for song in songs]
assert all('sorted_name' in x for x in song_dict)
assert all(x['sorted_name'] == f"{x['sort_order']}: {x['name']}" for x in song_dict)
assert all("sorted_name" in x for x in song_dict)
assert all(
x["sorted_name"] == f"{x['sort_order']}: {x['name']}" for x in song_dict
)
song_json = [song.json() for song in songs]
assert all('sorted_name' in x for x in song_json)
assert all("sorted_name" in x for x in song_json)
check_include = songs[0].dict(include={"sample"})
assert 'sample' in check_include
assert 'sample2' not in check_include
assert 'sorted_name' not in check_include
assert "sample" in check_include
assert "sample2" not in check_include
assert "sorted_name" not in check_include
check_include = songs[0].dict(exclude={"sample"})
assert 'sample' not in check_include
assert 'sample2' in check_include
assert 'sorted_name' in check_include
assert "sample" not in check_include
assert "sample2" in check_include
assert "sorted_name" in check_include

2
tests/test_selecting_subset_of_columns.py
View File

@ -19,7 +19,7 @@ class Company(ormar.Model):
database = database
id: int = ormar.Integer(primary_key=True)
name: str = ormar.String(max_length=100, nullable=False)
name: str = ormar.String(max_length=100, nullable=False, name="company_name")
founded: int = ormar.Integer(nullable=True)