def get_where_for_delete(self, queryset):
"""Generates a mapping to be used as the ``where`` parameter for a
``DELETE`` query
Used when ``mosql.query.delete`` is called. This implementation simply
generate a ``SELECT`` subquery so that the ``WHERE`` clause will be
of form ``<primary key> IN (<subquery>)``.
"""
pkcol = queryset.model._meta.pk.get_attname_column()[1]
key = '{pkcol} IN'.format(pkcol=pkcol)
value = raw(paren(queryset._get_select_query([pkcol])))
return {key: value}
def join(self, model, alias, on=None, using=None, join_type=None):
"""Create a ``JOIN`` clause in the query.
:param model: A model to be joined on. This can be a model class, or
a ``<appname>.<ModelName>`` string to lazy-load the model. For
joining a non-Django model, you can also provide a plain table
name.
:type model: `str` or `django.db.models.Model`
:param alias: The alias for the to-be-joined model. An ``AS`` clause
will be created automatically based on this value.
:param on: A mapping for fields to be joined on. Results in a
``JOIN ... ON`` query.
:type on: `dict`
:param using: A sequence of fields to be joined on. Results in a
``JOIN ... USING`` query.
:param join_type: The type of ``JOIN`` to be used. Possible values
include ``INNER``, ``LEFT``, ``CROSS`` and other standard SQL
``JOIN`` types. If ommited, a suitable type will be inferred
automatically.
"""
if isinstance(model, six.string_types): # Try to lazy-load the model
parts = model.split('.')
if len(parts) == 2 and all(parts):
model = get_model(*parts) or model
elif isinstance(model, MoQuerySet): # Handle subquery
model = raw(paren(model.query))
if inspect.isclass(model) and issubclass(model, Model):
table = model._meta.db_table
elif isinstance(model, six.string_types):
table = model
else:
raise TypeError('join() arg 1 must be a Django model or a str '
'subclass instance')
clone = self._clone()
join_info = {'table': (table, alias), 'on': on, 'using': using}
if join_type is not None:
join_info['type'] = join_type
clone._params['joins'].append(join_info)
return clone
