[ENHANCEMENT] Create a proxy for where in the form of get about piccolo

[dantownsend]

Yeah, it's a good idea. I think there are two options.

Modifying the where method

The where method could be modified, so it accepts multiple arguments.

# What's currently possible (all of these are equivalent):
await MyModel.select().where((MyModel.a == 1) & (MyModel.b == 2))
await MyModel.select().where(And(MyModel.a == 1, MyModel.b == 2))
await MyModel.select().where(MyModel.a == 1).where(MyModel.b == 2)

# What could be added:

# 1. Multiple arguments would behave the same as an AND, which does clean up the syntax a bit.
await MyModel.select().where(MyModel.a == 1, MyModel.b == 2)

# 2. Could also accept kwargs, which are converted to `MyModel.a == 1`.
await MyModel.select().where(a=1, b=2)

Adding a get method

I like the idea of adding get.

await MyModel.get(id=1)

# It's the equivalent of:
await MyModel.objects().where(MyModel.id == 1).first()

So it does save quite a bit of boiler plate code. I think this method would be for returning a single matching row, in the same way as MyModel.objects.get(id=1) in Django. What do you think?

[coder3112]

I think the 2nd method is best since it does not break existing functionality.
I think it could be simply implemented by doing something along the lines of:

@classmethod
def get(cls, **kwargs):
    parsed_args = # Parse the args
    return  Objects().where(AND(parsed_args))

[dantownsend]

The first method could be implemented in a backwards compatible way. The where signature would just be changed from:

def where(self, where: Combinable):
    self.where_delegate.where(where)
    return self

To:

def where(self, *where: Combinable, **kwargs):
    for i in where:
        self.where_delegate.where(i)

    for key, value in kwargs.items():
         column = self._meta.get_column_by_name(key)
         self.where_delegate.where(Where(column=column, value=value, operator=Equal))

    return self

If implementing option 2, it would then just be:

@classmethod
def get(cls, *where: Combinable, **kwargs):
    return self.objects().where(*args, **kwargs).first()

What do you think?

[coder3112]

Hmmm, yes, I think this is exactly what we need although .first() can be potentially problematic. Why not just return the entire queryset?

[dantownsend]

It's just to mimic how get works in Django, and also in Python in general.

For example:

>>> foo = {'a': 1}
>>> foo.get('a')
1

>>> foo.get('b')
None

If all results are needed, it could be queried like await MyModel.objects().where(a=1). Or maybe a method name other than get to avoid confusion.

[coder3112]

Okay, sounds great. Do you need a PR? Working on one right now.

Okay, modified #83 to accomodate this as well

[dantownsend]

There are now get and get_or_create methods in master now - I'll close this for now, but feel free to reopen if you feel anything needs adding.