Behaviour of __in against foreign keys doesn't behave quite like one might expect
I think there are some problems with your examples -- in the first you're doing an __in on a single model instance -- modb.modela is a single model a associated with the given modb.  YOu could rewrite as:

```
moda = modb.modela
```

In the second, you want modela records with that aren't related to some given modb... I _believe_ this should work:

```
modas = ModelA.select().join(ModelB).where(~Q(id=modb.id))
```
 OK -- closing for now, reopen if you get more info.

Given the following models:

``` python
class ModelA(model):
    blah  = CharField()

class ModelB(model):
    modela = ForeignKeyField(ModelA)
    blah  = CharField()
```

Doing a query like this, gives results not quite expected:

``` python
modb = ModelB.get(id=1)
modas = ModelA.select().where(id__in=modb.modela)
```

The second query uses ModelB's primary key, instead of the modela_id column. The above example is sort of useless, as one could just use modb.modela, but when combined with Q():

``` python
modb = ModelB.get(id=1)
modas = ModelA.select().where(~Q(id__in=modb.modela))
```

The above would allow one to fetch all ModelA records that aren't related to ModelB.

Changing this would break the current behavior, but in my opinion it would make it behave more like the code actually reads.

What do you think?
