Replies: 2 comments 6 replies
-
|
Python lists are ordered (elements keep in insert order), by your description I assume you mean sorted. Right now there is no auto way. You can do it manually though.
Since it's exposing |
Beta Was this translation helpful? Give feedback.
-
|
No, I did mean ordered - if I do |
Beta Was this translation helpful? Give feedback.
-
|
Well, they are ordered, just not the way you like :) You are right, db don't guarantee the order of rows so you should explicitly issue The problem is, that if you do not provide the order_by clause So based on your previous examples I assume you use I was already thinking on ability to define possibility to define the default sorting, so you are welcome to open an issue for this: something like "Possibility to define default sorting order on model and relation". It should work as follows: class MyModel(ormar.Model):
class Meta:
...
order_by =['col_A', '-col_B' ] # <= default ordering for Model, used ALWAYS for given model, UNLESS explicit order_by is
# provided for the Model, in that case this one is overwritten, reference self columns of a Model
rel_field = ormar.ForeignKey(ModelB, order_by=['col_C,'-col_D']) # <= used ALWAYS for this relation, cannot be overwritten, references related Model columns, same for ManyToMany
# also there should be and option to pass orders_by to load_all()
# since under the hood it uses `QuerySet` it's super easy to provide
...
async def load_all(follow: bool = False, exclude = None, order_by=None):
... |
Beta Was this translation helpful? Give feedback.
-
|
Opened #129 |
Beta Was this translation helpful? Give feedback.
-
|
Well, default sorting is related to what I had in mind, and maybe constitutes about 1/3 of the expected functionality, but the idea I'm trying to express is "Ormar should permit Lists that behave like Python Lists, specifically with respect to ordering." If somehow that idea isn't as obvious as it feels to me like it should be, here's a bunch of speculative code, demonstrating proposed methods and their expected behaviors, contrasted with current behavior. I can't run this file directly, because it uses methods that don't exist yet. I've tried to write it as close as feasible to a file that COULD be run, though. Please forgive any typos I've missed. I've commented from fastapi import FastAPI, Body
import databases
import ormar
from ormar import Model
import sqlalchemy
import pydantic
from pydantic.dataclasses import dataclass
from typing import Optional, List, Dict
from uuid import UUID, uuid4
import asyncio
from enum import Enum
from sqlalchemy_utils import database_exists
DATABASE_URL = "sqlite:///db.sqlite"
database = databases.Database(DATABASE_URL)
metadata = sqlalchemy.MetaData()
class BaseMeta(ormar.ModelMeta):
metadata = metadata
database = database
# The following file is intended to convey in more detail the idea of "Ormar should permit Lists that behave like Python Lists, specifically with respect to ordering."
# This SHOULD be a very simple concept. If it seems like it isn't, then most probably a miscommunication is occurring.
# The things I've labeled #SPEC are new methods, or different behavior than currently implemented.
class Animal(ormar.Model):
class Meta(BaseMeta):
tablename = "animals"
id: UUID = ormar.UUID(primary_key=True, default=uuid4)
name: str = ormar.Text(default="")
# favoriteHumans
class Human(ormar.Model):
class Meta(BaseMeta):
tablename = "humans"
id: UUID = ormar.UUID(primary_key=True, default=uuid4)
name: str = ormar.Text(default="")
favoriteAnimals: List[Animal] = ormar.ManyToMany(Animal, related_name="favoriteHumans", ordered=True) #SPEC "ordered", and implicit link table creation
# Note: X.favoriteY is intended to represent X's favorite entites, from most favorite to least favorite.
# We suppose no (easily calculable) absolute "like-score" exists in a creature's mind, only an ordering, which can
# change from day to day as the whims of the creature change.
# In terms of the database, ManyToMany with ordered=True should maintain the order of elements
# in the associated lists, initialized with their insertion order, but permitting subsequent explicit reordering.
# Such a reordering should only affect the list X being reordered; it should not affect e.g. the ordering of
# other lists that contain the same things as X, nor should it affect the ordering of the list associated with
# X via the relationship.
# THE FOLLOWING CLASS IS NOT EXPLICITLY TIED TO THE EXAMPLE CODE ABOVE IT OR BELOW IT.
# This is an example of how a possible through-table could be structured.
class Link(ormar.Model):
class Meta(BaseMeta):
tablename = "link_table"
id: UUID = ormar.UUID(primary_key=True, default=uuid4)
animal: Animal = ormar.ForeignKey(Animal)
# This gives the index of `animal` in `human`'s `favoriteAnimals` field.
# On insertion, it defaults to len(human.favoriteAnimals)-1, and is updated whenever `animal` is moved in `human.favoriteAnimals`,
# OR whenever the count of elements preceding it changes - e.g. by moving an element from the tail to the head of the list.
animal_order: int = ormar.Integer()
human: Human = ormar.ForeignKey(Human)
# This gives the index of `human` in `animal`'s `favoriteHumans` field.
# See comments several lines ago for default and update rules.
human_order: int = ormar.Integer()
#### Example usage
# Note: where I say "Current", I mean "when I ran it, I got this result". Given random IDs, the actual results may vary.
# Second note: I can only run the methods that exist. "Current" vs "Expected" means "skipping or substituting the things I can't run, I get this result, vs here's what I'd want to happen if I were able to run all the given methods."
# Create database
engine = sqlalchemy.create_engine(DATABASE_URL)
metadata.drop_all(engine)
metadata.create_all(engine)
### BEGIN HELPER FUNCTIONS
# Not intended to exist outside of this example code
# For use during example only, to help make more explicit the idea of "ordering persists across reloads"
async def reload(self):
return await type(self).objects.get(id=self.id)
Human.reload = reload
Animal.reload = reload
async def favorites(entity):
if (type(entity) == Human):
return list(map(lambda entity: entity.name, await entity.favoriteAnimals.all()))
else:
return list(map(lambda entity: entity.name, await entity.favoriteHumans.all()))
### END HELPER FUNCTIONS
alice = await Human(name="Alice").save()
bob = await Human(name="Bob").save()
charlie = await Human(name="Charlie").save()
spot = await Animal(name="Spot").save()
kitty = await Animal(name="Kitty").save()
noodle = await Animal(name="Noodle").save()
alice2 = await alice.reload()
alice == alice2 # True
alice is alice2 # False
await alice.favoriteAnimals.add(noodle)
await alice.favoriteAnimals.add(spot)
await alice.favoriteAnimals.add(kitty)
alice = await alice.reload()
await favorites(alice)
# Expected: ['Noodle', 'Spot', 'Kitty']
# Current: ['Kitty', 'Noodle', 'Spot']
# The favorites of all animals are currently ['Alice'], as expected.
await bob.favoriteAnimals.add(noodle)
await bob.favoriteAnimals.add(kitty)
await bob.favoriteAnimals.add(spot)
bob = await bob.reload()
await favorites(bob)
# Expected: ['Noodle', 'Kitty', 'Spot']
# Current: ['Kitty', 'Noodle', 'Spot']
await charlie.favoriteAnimals.add(kitty)
await charlie.favoriteAnimals.add(noodle)
await charlie.favoriteAnimals.add(spot)
charlie = await charlie.reload()
await favorites(charlie)
# Expected: ['Kitty', 'Noodle', 'Spot']
# Current: ['Kitty', 'Noodle', 'Spot'] , correct on accident
# The favorites of all animals, because of the insertion order default, are expected to be
# ['Alice', 'Bob', 'Charlie']
# Instead, they are currently
# ['Alice', 'Charlie', 'Bob']
# Zack passes through
zack = await Human(name="Zack").save()
# Zack gives Noodle a rat, and is immediately promoted to her most-favorite
await noodle.favoriteHumans.insert(0, zack) #SPEC .insert(index, entity)
# Lacking .insert, I instead use .add
noodle = await noodle.reload()
await favorites(noodle)
# Expected: ['Zack', 'Alice', 'Bob', 'Charlie']
# Current: ['Alice', 'Charlie', 'Zack', 'Bob']
await favorites(zack) # ['Noodle']
# Time passes and Zack doesn't return, so Zack gradually moves down Noodle's favorite list
#SPEC .move(fromIndex, toIndex) . This method behaves as if you removed an element from fromIndex, and inserted it at toIndex,
# except it doesn't alter the ordering on the opposite side of the relationship as doing so in two steps would.
await noodle.favoriteHumans.move(0,1) # favorites(noodle) Expected: ['Alice', 'Zack', 'Bob', 'Charlie']
await noodle.favoriteHumans.move(1,2) # favorites(noodle) Expected: ['Alice', 'Bob', 'Zack', 'Charlie']
await noodle.favoriteHumans.move(2,3) # favorites(noodle) Expected: ['Alice', 'Bob', 'Charlie', 'Zack']
# Note that none of the other favorites lists are changed by this behavior.
# Bob is reassigned from the cat enclosure, and Kitty forgets him.
await kitty.favoriteHumans.remove(bob) #SPEC This removes specifically the first instance of bob, should there be more than one instance in the list
await favorites(kitty)
# Expected: ['Alice', 'Charlie']
# Current: ['Alice', 'Charlie'] , coincidentally correct
# Related functions:
# (Remember, at this point in execution favorites(noodle) == ['Alice', 'Bob', 'Charlie', 'Zack'] )
await noodle.favoriteHumans.indexOf(bob) # == 1 #SPEC .indexOf(entity) Could support the normal .index(element, start, end) behavior
await noodle.favoriteHumans.removeIdx(2) # removes charlie from noodle, and noodle from charlie #SPEC .removeIdx(index) Removes element at index, removing also from the reverse relation. There's a few other acceptable ways of phrasing this, like .remove(index=2)
# A recap, if I didn't state it clearly already: functions that add elements at any index should also add the reverse relationship to the end of the reverse field.
# (Perhaps could have a method that specifies both indices. Not required.)
# Functions that remove elements at any index should also remove the corresponding reverse relationship from the appropriate reverse field.
# Functions that merely change an index, reordering one field, should not affect any other field or field's ordering, including the ordering of the reverse field.
# Note that I've written this with ManyToMany in mind. I expect this idea could be readily adapted to ForeignKey,
# with very few changes, but that's not (currently) important to me.Does this more clearly express the functionality I wish I could use? |
Beta Was this translation helpful? Give feedback.
-
|
So basically you want to order by additional column on through model (which is fine), but want Moreover your design specification is not well thought through and would fail in many cases. In example: alice = await Human(name="Alice").save()
spot = await Animal(name="Spot").save()
kitty = await Animal(name="Kitty").save()
noodle = await Animal(name="Noodle").save()
await alice.favoriteAnimals.add(noodle)
await alice.favoriteAnimals.add(spot)
await alice.favoriteAnimals.add(kitty)
# what if now user have animal that he hates, and will hate forever
# like a dog that attacted alice child and will be last forever
angry = await Animal(name="Angry Dog").save()
alice.favoriteAnimals.insert(99999, angry)
# Ops, python index out of bounds error (!)What if you loaded only selected animals and want to insert between them alice = await Human(name="Alice").save()
spot = await Animal(name="Spot").save()
kitty = await Animal(name="Kitty").save()
noodle = await Animal(name="Noodle").save()
max = await Animal(name="Max").save()
spike = await Animal(name="Spike").save()
await alice.favoriteAnimals.add(noodle)
await alice.favoriteAnimals.add(spot)
await alice.favoriteAnimals.add(kitty)
await alice.favoriteAnimals.add(max)
await alice.favoriteAnimals.add(spike)
# note that kitty has order 2 but index in list 0, and max has order 4 but index in list 1
await alice.favoriteAnimals.all(name__in=['Kitty', 'Spike'])
polly = await Animal(name="Polly").save()
# now you want to insert spike between them
alice.favoriteAnimals.insert(1, polly) # wrong order
alice.favoriteAnimals.insert(3, polly) # index out of boundsSelect subset of models alice = await Human(name="Alice").save()
spot = await Animal(name="Spot").save()
kitty = await Animal(name="Kitty").save()
noodle = await Animal(name="Noodle").save()
max = await Animal(name="Max").save()
spike = await Animal(name="Spike").save()
await alice.favoriteAnimals.add(noodle)
await alice.favoriteAnimals.add(spot)
await alice.favoriteAnimals.add(kitty)
await alice.favoriteAnimals.add(max)
await alice.favoriteAnimals.add(spike)
# what if you select subset of related items
await alice.favoriteAnimals.all(name__in=['Noodle', 'Spot'])
polly = await Animal(name="Polly").save()
# now what should be the default?
alice.favoriteAnimals.insert(polly) # list len() is 2 <- wrong order!It would actually have to be something like Even if passing index would not cause index out of bounds error it's misleading: # as a python developer when i see it i expect to have a list with index 99999 as it's
# mimicking python list API
angry = await Animal(name="Angry Dog").save()
alice.favoriteAnimals.insert(99999, angry) <= even if inserted at index 3
angry_dog = alice.favouriteAnimals[99999] #<- now failsNot to mention that reordering in db is expensive and in most cases you do not care about the actual value of the order column but about the order itself. That's why in production systems sort order columns are often scarse, i.e. # VERY simplified example
animals_x_humans = [{"name": "Test 1", "sort_order": 100},
{"name": "Test 2", "sort_order": 200},
{"name": "Test 3", "sort_order": 300},
{"name": "Test 4", "sort_order": 400},
{"name": "Test 5", "sort_order": 500}]
# and now when you move animal 5 between 1 and 2 you set it based on function
# something floor((test1.sort_order+test2.sort_order)/2) = 150
animals_x_humans_reordered = [{"name": "Test 1", "sort_order": 100},
{"name": "Test 5", "sort_order": 150},
{"name": "Test 2", "sort_order": 200},
{"name": "Test 3", "sort_order": 300},
{"name": "Test 4", "sort_order": 400}]
# that way you avoid reordering tests 2,3 and 4, just change 1 row
# (of course in real life it can be hundreds or thousands of rowsSo long answer short - I don't thinks it's a general functionality and I won't implement this. from typing import List
from uuid import UUID, uuid4
import databases
import pytest
import sqlalchemy
import ormar
from tests.settings import DATABASE_URL
database = databases.Database(DATABASE_URL)
metadata = sqlalchemy.MetaData()
class BaseMeta(ormar.ModelMeta):
metadata = metadata
database = database
class Animal(ormar.Model):
class Meta(BaseMeta):
tablename = "animals"
id: UUID = ormar.UUID(primary_key=True, default=uuid4)
name: str = ormar.Text(default="")
# favoriteHumans
# provide explicit through table
class Link(ormar.Model):
class Meta(BaseMeta):
tablename = "link_table"
# note that you cannot define your own relations as of now in through model
id: int = ormar.Integer(primary_key=True)
animal_order: int = ormar.Integer(nullable=True)
human_order: int = ormar.Integer(nullable=True)
class Human(ormar.Model):
class Meta(BaseMeta):
tablename = "humans"
id: UUID = ormar.UUID(primary_key=True, default=uuid4)
name: str = ormar.Text(default="")
favoriteAnimals: List[Animal] = ormar.ManyToMany(Animal, through=Link,
related_name="favoriteHumans",
)
@pytest.fixture(autouse=True, scope="module")
def create_test_database():
engine = sqlalchemy.create_engine(DATABASE_URL)
metadata.drop_all(engine)
metadata.create_all(engine)
yield
metadata.drop_all(engine)
# this will be redundant with either relation or load_all order by
async def favorites(entity):
if (type(entity) == Human):
return list(map(lambda entity: entity.name,
await entity.favoriteAnimals.order_by(
'link__animal_order').all()))
else:
return list(map(lambda entity: entity.name,
await entity.favoriteHumans.order_by(
'link__human_order').all()))
@pytest.mark.asyncio
async def test_ordering_by_through():
async with database:
alice = await Human(name="Alice").save()
bob = await Human(name="Bob").save()
charlie = await Human(name="Charlie").save()
spot = await Animal(name="Spot").save()
kitty = await Animal(name="Kitty").save()
noodle = await Animal(name="Noodle").save()
# you need to add them in order anyway so can provide order explicitly
# if you have a lot of them a list with enumerate might be an option
await alice.favoriteAnimals.add(noodle, animal_order=0, human_order=0)
await alice.favoriteAnimals.add(spot, animal_order=1, human_order=0)
await alice.favoriteAnimals.add(kitty, animal_order=2, human_order=0)
# you dont have to reload queries on queryset clears the existing related
# alice = await alice.reload()
await favorites(alice)
assert [x.name for x in alice.favoriteAnimals] == ['Noodle', 'Spot', 'Kitty']
await bob.favoriteAnimals.add(noodle, animal_order=0, human_order=1)
await bob.favoriteAnimals.add(kitty, animal_order=1, human_order=1)
await bob.favoriteAnimals.add(spot, animal_order=2, human_order=1)
await favorites(bob)
assert [x.name for x in bob.favoriteAnimals] == ['Noodle', 'Kitty', 'Spot']
await charlie.favoriteAnimals.add(kitty, animal_order=0, human_order=2)
await charlie.favoriteAnimals.add(noodle, animal_order=1, human_order=2)
await charlie.favoriteAnimals.add(spot, animal_order=2, human_order=2)
await favorites(charlie)
# Expected: ['Kitty', 'Noodle', 'Spot']
# Current: ['Kitty', 'Noodle', 'Spot'] , correct on accident
animals = [noodle, kitty, spot]
for animal in animals:
await favorites(animal)
assert [x.name for x in animal.favoriteHumans] == ['Alice', 'Bob',
'Charlie']
zack = await Human(name="Zack").save()
# in your example here you expect all other than zack be updated in db
# otherwise alice already has order = 0 and order between zack and alice is
# inconclusive without additional ordering, which would have to shift by one all
# following items which is one of the reasons I won't implement it
async def reorder_humans(animal, new_ordered_humans):
# update only through models - they are normal models anyway
# similar thing can be done for other side
noodle_links = await Link.objects.filter(animal=animal).all()
for link in noodle_links:
link.human_order = next((
i for i, x in enumerate(new_ordered_humans) if
x.pk == link.human.pk),
None)
await Link.objects.bulk_update(noodle_links, columns=['human_order'])
await noodle.favoriteHumans.add(zack, animal_order=0, human_order=0)
# note you can also update through model check the docs
await reorder_humans(noodle, [zack, alice, bob, charlie])
await favorites(noodle)
assert [x.name for x in noodle.favoriteHumans] == ['Zack', 'Alice', 'Bob',
'Charlie']
await favorites(zack)
assert [x.name for x in zack.favoriteAnimals] == ['Noodle']
humans = noodle.favoriteHumans
humans.insert(1, humans.pop(0))
await reorder_humans(noodle, humans)
await favorites(noodle)
assert [x.name for x in noodle.favoriteHumans] == ['Alice', 'Zack', 'Bob',
'Charlie']
humans.insert(2, humans.pop(1))
await reorder_humans(noodle, humans)
await favorites(noodle)
assert [x.name for x in noodle.favoriteHumans] == ['Alice', 'Bob', 'Zack',
'Charlie']
humans.insert(3, humans.pop(2))
await reorder_humans(noodle, humans)
await favorites(noodle)
assert [x.name for x in noodle.favoriteHumans] == ['Alice', 'Bob',
'Charlie', 'Zack']
await kitty.favoriteHumans.remove(bob)
await favorites(kitty)
assert [x.name for x in kitty.favoriteHumans] == ['Alice', 'Charlie']
bob = await noodle.favoriteHumans.get(pk=bob.pk)
assert bob.link.human_order == 1
# remove charlie by order
await noodle.favoriteHumans.remove(
await noodle.favoriteHumans.filter(link__human_order=2).get())
await favorites(noodle)
assert [x.name for x in noodle.favoriteHumans] == ['Alice', 'Bob', 'Zack']When writing specs for #129 I was already thinking about ordering through model, now I think also related_order_by should be on relation, and specified the order in which the order-by should be resolved |
Beta Was this translation helpful? Give feedback.
-
|
Here are my responses to the objections you have given above, consolidated as best I reasonably can.
I appreciate the example code - though it still looks more manual than is convenient. I'll have to read and consider it more closely. Overall, the existence of other implementations of this feature is probably my best argument that this is a reasonable request. Is your opinion at all changed from what it was at the beginning of the discussion? |
Beta Was this translation helpful? Give feedback.
-
|
All examples you provided are either external modules or extensions which kind of prove my point that it's not seen as a core functionality of an orm. Moreover Additionally all your examples are from sync work, where you can overwrite built in functions, you call them as normal and everything can work fine if done well. When you add async to the table now you cannot overwrite As you also mentioned, if you want to disallow editing on partial results you would have to check if all models were loaded for given relation, which is not trivial as there is no easy way to do this right now. And even then it still causes problems when you have two async calls and one adds new row before the other etc. so it has to use db anyway in the process. As pointed above that would require also new list API with async methods doing the same what sync ones are doing but with different names etc. That's a lot of code spread across several classes for quite easy to achieve (the other way) and not so common requirement. And that's why I don't like it and wont implement this in this way. I can think of allowing customization of collection class like But don't get me wrong, I agree this can be useful and should be easy to implement, but for you, not for me inside That's why I sped up some developments in order to allow you to easily implement more or less generic functionality the way you want it, and since it is your code you can customize it anyway you like. In next release I will implement 4 new signals for relations (pre/post add/remove to relation) and 4 new aggregated functions ( Note that although you can try do something similar already, cause To build a generic ordering for models you can use signals, here is an example of how you can do this. Note that you can register same signal for many models, that way you can order different relations with the same code. Note also that this can be done easier, I wrote a sample that is quite generic and can be easily applied to other relations based on column names. The way as it is now you have full control over what is happening, if want to customize the order column names, if you want to auto order descending, if you want to order only one side of relation but not the other, count from 1 or count from 0 etc. you can do whatever you like and need. Note the relation definition with default ordering and signals. Instead of from typing import Any, Dict, List, Tuple, Type, cast
from uuid import UUID, uuid4
import databases
import pytest
import sqlalchemy
import ormar
from ormar import Model, QuerySet, pre_update, pre_save
from tests.settings import DATABASE_URL
database = databases.Database(DATABASE_URL)
metadata = sqlalchemy.MetaData()
class BaseMeta(ormar.ModelMeta):
metadata = metadata
database = database
class Animal(ormar.Model):
class Meta(BaseMeta):
tablename = "animals"
id: UUID = ormar.UUID(primary_key=True, default=uuid4)
name: str = ormar.Text(default="")
# favoriteHumans
class Link(ormar.Model):
class Meta(BaseMeta):
tablename = "link_table"
id: UUID = ormar.UUID(primary_key=True, default=uuid4)
animal_order: int = ormar.Integer(nullable=True)
human_order: int = ormar.Integer(nullable=True)
class Human(ormar.Model):
class Meta(BaseMeta):
tablename = "humans"
id: UUID = ormar.UUID(primary_key=True, default=uuid4)
name: str = ormar.Text(default="")
favoriteAnimals: List[Animal] = ormar.ManyToMany(
Animal,
through=Link,
related_name="favoriteHumans",
orders_by=["link__animal_order"],
related_orders_by=["link__human_order"],
)
@pytest.fixture(autouse=True, scope="module")
def create_test_database():
engine = sqlalchemy.create_engine(DATABASE_URL)
metadata.drop_all(engine)
metadata.create_all(engine)
yield
metadata.drop_all(engine)
def _get_filtered_query(
sender: Type[Model], instance: Model, to_class: Type[Model]
) -> QuerySet:
"""
Helper function.
Gets the query filtered by the appropriate class name.
"""
pk = getattr(instance, f"{to_class.get_name()}").pk
filter_kwargs = {f"{to_class.get_name()}": pk}
query = sender.objects.filter(**filter_kwargs)
return query
def _get_through_model_relations(
sender: Type[Model], instance: Model
) -> Tuple[Type[Model], Type[Model]]:
relations = list(instance.extract_related_names())
rel_one = sender.Meta.model_fields[relations[0]].to
rel_two = sender.Meta.model_fields[relations[1]].to
return rel_one, rel_two
async def _populate_order_on_insert(
sender: Type[Model], instance: Model, from_class: Type[Model],
to_class: Type[Model]
):
"""
Helper function.
Get max values from database for both orders and adds 1 (0 if max is None) if the
order is not provided. If the order is provided it reorders the existing links
to match the newly defined order.
Assumes names f"{model.get_name()}_order" like for Animal: animal_order.
"""
order_column = f"{from_class.get_name()}_order"
if getattr(instance, order_column) is None:
query = _get_filtered_query(sender, instance, to_class)
max_order = await query.max(order_column)
max_order = max_order + 1 if max_order is not None else 0
setattr(instance, order_column, max_order)
else:
await _reorder_on_update(
sender=sender,
instance=instance,
from_class=from_class,
to_class=to_class,
passed_args={order_column: getattr(instance, order_column)},
)
async def _reorder_on_update(
sender: Type[Model],
instance: Model,
from_class: Type[Model],
to_class: Type[Model],
passed_args: Dict,
):
"""
Helper function.
Actually reorders links by given order passed in add/update query to the link
model.
Assumes names f"{model.get_name()}_order" like for Animal: animal_order.
"""
order = f"{from_class.get_name()}_order"
if order in passed_args:
query = _get_filtered_query(sender, instance, to_class)
to_reorder = await query.exclude(pk=instance.pk).order_by(order).all()
new_order = passed_args.get(order)
if to_reorder and new_order is not None:
# can be more efficient - here we renumber all even if not needed.
for ind, link in enumerate(to_reorder):
if ind < new_order:
setattr(link, order, ind)
else:
setattr(link, order, ind + 1)
await sender.objects.bulk_update(
cast(List[Model], to_reorder), columns=[order]
)
@pre_save(Link)
async def order_link_on_insert(sender: Type[Model], instance: Model, **kwargs: Any):
"""
Signal receiver registered on Link model, triggered every time before one is created
by calling save() on a model. Note that signal functions for pre_save signal accepts
sender class, instance and have to accept **kwargs even if it's empty as of now.
"""
rel_one, rel_two = _get_through_model_relations(sender, instance)
await _populate_order_on_insert(
sender=sender, instance=instance, from_class=rel_one, to_class=rel_two
)
await _populate_order_on_insert(
sender=sender, instance=instance, from_class=rel_two, to_class=rel_one
)
@pre_update(Link)
async def reorder_links_on_update(
sender: Type[ormar.Model], instance: ormar.Model, passed_args: Dict,
**kwargs: Any
):
"""
Signal receiver registered on Link model, triggered every time before one is updated
by calling update() on a model. Note that signal functions for pre_update signal
accepts sender class, instance, passed_args which is a dict of kwargs passed to
update and have to accept **kwargs even if it's empty as of now.
"""
rel_one, rel_two = _get_through_model_relations(sender, instance)
await _reorder_on_update(
sender=sender,
instance=instance,
from_class=rel_one,
to_class=rel_two,
passed_args=passed_args,
)
await _reorder_on_update(
sender=sender,
instance=instance,
from_class=rel_two,
to_class=rel_one,
passed_args=passed_args,
)
@pre_relation_remove([Animal, Human])
async def reorder_links_on_remove(
sender: Type[ormar.Model], instance: ormar.Model, child: ormar.Model,
relation_name: str, **kwargs: Any
):
"""
Signal receiver registered on Anima and Human models, triggered every time before
relation on a model is removed. Note that signal functions for pre_relation_remove
signal accepts sender class, instance, child, relation_name and have to accept
**kwargs even if it's empty as of now.
Note that if classes have many relations you need to check if current one is ordered
"""
through_class = sender.Meta.model_fields[relation_name].through
through_instance = getattr(instance, through_class.get_name())
if not through_instance:
parent_pk = instance.pk
child_pk = child.pk
filter_kwargs = {f"{sender.get_name()}": parent_pk, child.get_name(): child_pk}
through_instance = await through_class.objects.get(**filter_kwargs)
rel_one, rel_two = _get_through_model_relations(through_class, through_instance)
await _reorder_on_update(
sender=through_class,
instance=through_instance,
from_class=rel_one,
to_class=rel_two,
passed_args={f"{rel_one.get_name()}_order": 999999},
)
await _reorder_on_update(
sender=through_class,
instance=through_instance,
from_class=rel_two,
to_class=rel_one,
passed_args={f"{rel_two.get_name()}_order": 999999},
)
@pytest.mark.asyncio
async def test_ordering_by_through_on_m2m_field():
async with database:
def verify_order(instance, expected):
field_name = (
"favoriteAnimals" if isinstance(instance, Human)
else "favoriteHumans"
)
order_field_name = (
"animal_order" if isinstance(instance, Human)
else "human_order"
)
assert [x.name for x in getattr(instance, field_name)] == expected
assert [getattr(x.link, order_field_name)
for x in getattr(instance, field_name)] == [i for i in
range(len(expected))]
alice = await Human(name="Alice").save()
bob = await Human(name="Bob").save()
charlie = await Human(name="Charlie").save()
spot = await Animal(name="Spot").save()
kitty = await Animal(name="Kitty").save()
noodle = await Animal(name="Noodle").save()
await alice.favoriteAnimals.add(noodle)
await alice.favoriteAnimals.add(spot)
await alice.favoriteAnimals.add(kitty)
await alice.load_all()
verify_order(alice, ["Noodle", "Spot", "Kitty"])
await bob.favoriteAnimals.add(noodle)
await bob.favoriteAnimals.add(kitty)
await bob.favoriteAnimals.add(spot)
await bob.load_all()
verify_order(bob, ["Noodle", "Kitty", "Spot"])
await charlie.favoriteAnimals.add(kitty)
await charlie.favoriteAnimals.add(noodle)
await charlie.favoriteAnimals.add(spot)
await charlie.load_all()
verify_order(charlie, ["Kitty", "Noodle", "Spot"])
animals = [noodle, kitty, spot]
for animal in animals:
await animal.load_all()
verify_order(animal, ["Alice", "Bob", "Charlie"])
zack = await Human(name="Zack").save()
await noodle.favoriteHumans.add(zack, human_order=0)
await noodle.load_all()
verify_order(noodle, ["Zack", "Alice", "Bob", "Charlie"])
await zack.load_all()
verify_order(zack, ["Noodle"])
await noodle.favoriteHumans.filter(name="Zack").update(link=dict(human_order=1))
await noodle.load_all()
verify_order(noodle, ["Alice", "Zack", "Bob", "Charlie"])
await noodle.favoriteHumans.filter(name="Zack").update(link=dict(human_order=2))
await noodle.load_all()
verify_order(noodle, ["Alice", "Bob", "Zack", "Charlie"])
await noodle.favoriteHumans.filter(name="Zack").update(link=dict(human_order=3))
await noodle.load_all()
verify_order(noodle, ["Alice", "Bob", "Charlie", "Zack"])
await kitty.favoriteHumans.remove(bob)
await kitty.load_all()
assert [x.name for x in kitty.favoriteHumans] == ["Alice", "Charlie"]
bob = await noodle.favoriteHumans.get(pk=bob.pk)
assert bob.link.human_order == 1
await noodle.favoriteHumans.remove(
await noodle.favoriteHumans.filter(link__human_order=2).get()
)
await noodle.load_all()
verify_order(noodle, ["Alice", "Bob", "Zack"]) |
Beta Was this translation helpful? Give feedback.
-
Is there a convenient way to order lists? Like, I'm imagining a flag set on e.g. a ManyToMany, and each db entry tracks the two ends of the relationship as well as where in each list it is, and calls to
.add()and.remove()etc. would update the ordering appropriately. Would there happen to be such a thing? (I didn't see anything about it in the docs, but figured I'd ask before opening a feature request.)Beta Was this translation helpful? Give feedback.
All reactions