def validate_no_broken_transaction(self):
if self.needs_rollback:
raise TransactionManagementError(
"An error occurred in the current transaction. You can't "
"execute queries until the end of the 'atomic' block.")
def get_rollback(self):
"""Get the "needs rollback" flag -- for *advanced use* only."""
if not self.in_atomic_block:
raise TransactionManagementError(
"The rollback flag doesn't work outside of an 'atomic' block.")
return self.needs_rollback
def validate_no_atomic_block(self):
"""Raise an error if an atomic block is active."""
if self.in_atomic_block:
raise TransactionManagementError(
"This is forbidden when an 'atomic' block is active.")
def as_sql(self, with_limits=True, with_col_aliases=False):
"""
Create the SQL for this query. Return the SQL string and list of
parameters.
If 'with_limits' is False, any limit/offset information is not included
in the query.
"""
refcounts_before = self.query.alias_refcount.copy()
try:
extra_select, order_by, group_by = self.pre_sql_setup()
for_update_part = None
# Is a LIMIT/OFFSET clause needed?
with_limit_offset = with_limits and (
self.query.high_mark is not None or self.query.low_mark)
combinator = self.query.combinator
features = self.connection.features
# The do_offset flag indicates whether we need to construct
# the SQL needed to use limit/offset w/SQL Server.
high_mark = self.query.high_mark
low_mark = self.query.low_mark
do_limit = with_limits and high_mark is not None
do_offset = with_limits and low_mark != 0
# SQL Server 2012 or newer supports OFFSET/FETCH clause
supports_offset_clause = self.connection.sql_server_version >= 2012
do_offset_emulation = do_offset and not supports_offset_clause
if combinator:
if not getattr(features,
'supports_select_{}'.format(combinator)):
raise NotSupportedError(
'{} is not supported on this database backend.'.format(
combinator))
result, params = self.get_combinator_sql(
combinator, self.query.combinator_all)
else:
distinct_fields, distinct_params = self.get_distinct()
# This must come after 'select', 'ordering', and 'distinct' -- see
# docstring of get_from_clause() for details.
from_, f_params = self.get_from_clause()
where, w_params = self.compile(
self.where) if self.where is not None else ("", [])
having, h_params = self.compile(
self.having) if self.having is not None else ("", [])
params = []
result = ['SELECT']
if self.query.distinct:
distinct_result, distinct_params = self.connection.ops.distinct_sql(
distinct_fields,
distinct_params,
)
result += distinct_result
params += distinct_params
# SQL Server requires the keword for limitting at the begenning
if do_limit and not do_offset:
result.append('TOP %d' % high_mark)
out_cols = []
col_idx = 1
for _, (s_sql, s_params), alias in self.select + extra_select:
if alias:
s_sql = '%s AS %s' % (
s_sql, self.connection.ops.quote_name(alias))
elif with_col_aliases or do_offset_emulation:
s_sql = '%s AS %s' % (s_sql, 'Col%d' % col_idx)
col_idx += 1
params.extend(s_params)
out_cols.append(s_sql)
# SQL Server requires an order-by clause for offsetting
if do_offset:
meta = self.query.get_meta()
qn = self.quote_name_unless_alias
offsetting_order_by = '%s.%s' % (qn(
meta.db_table), qn(meta.pk.db_column
or meta.pk.column))
if do_offset_emulation:
if order_by:
ordering = []
for expr, (o_sql, o_params, _) in order_by:
# value_expression in OVER clause cannot refer to
# expressions or aliases in the select list. See:
# http://msdn.microsoft.com/en-us/library/ms189461.aspx
src = next(iter(expr.get_source_expressions()))
if isinstance(src, Ref):
src = next(
iter(src.get_source_expressions()))
o_sql, _ = src.as_sql(
self, self.connection)
odir = 'DESC' if expr.descending else 'ASC'
o_sql = '%s %s' % (o_sql, odir)
ordering.append(o_sql)
params.extend(o_params)
offsetting_order_by = ', '.join(ordering)
order_by = []
out_cols.append(
'ROW_NUMBER() OVER (ORDER BY %s) AS [rn]' %
offsetting_order_by)
elif not order_by:
order_by.append(
((None, ('%s ASC' % offsetting_order_by, [],
None))))
if self.query.select_for_update and self.connection.features.has_select_for_update:
if self.connection.get_autocommit():
raise TransactionManagementError(
'select_for_update cannot be used outside of a transaction.'
)
if with_limit_offset and not self.connection.features.supports_select_for_update_with_limit:
raise NotSupportedError(
'LIMIT/OFFSET is not supported with '
'select_for_update on this database backend.')
nowait = self.query.select_for_update_nowait
skip_locked = self.query.select_for_update_skip_locked
of = self.query.select_for_update_of
# If it's a NOWAIT/SKIP LOCKED/OF query but the backend
# doesn't support it, raise NotSupportedError to prevent a
# possible deadlock.
if nowait and not self.connection.features.has_select_for_update_nowait:
raise NotSupportedError(
'NOWAIT is not supported on this database backend.'
)
elif skip_locked and not self.connection.features.has_select_for_update_skip_locked:
raise NotSupportedError(
'SKIP LOCKED is not supported on this database backend.'
)
elif of and not self.connection.features.has_select_for_update_of:
raise NotSupportedError(
'FOR UPDATE OF is not supported on this database backend.'
)
for_update_part = self.connection.ops.for_update_sql(
nowait=nowait,
skip_locked=skip_locked,
of=self.get_select_for_update_of_arguments(),
)
if for_update_part and self.connection.features.for_update_after_from:
from_.insert(1, for_update_part)
result += [', '.join(out_cols), 'FROM', *from_]
params.extend(f_params)
if where:
result.append('WHERE %s' % where)
params.extend(w_params)
grouping = []
for g_sql, g_params in group_by:
grouping.append(g_sql)
params.extend(g_params)
if grouping:
if distinct_fields:
raise NotImplementedError(
'annotate() + distinct(fields) is not implemented.'
)
order_by = order_by or self.connection.ops.force_no_ordering(
)
result.append('GROUP BY %s' % ', '.join(grouping))
if having:
result.append('HAVING %s' % having)
params.extend(h_params)
explain = self.query.explain_info if django.VERSION >= (
4, 0) else self.query.explain_query
if explain:
result.insert(
0,
self.connection.ops.explain_query_prefix(
self.query.explain_format,
**self.query.explain_options))
if order_by:
ordering = []
for _, (o_sql, o_params, _) in order_by:
ordering.append(o_sql)
params.extend(o_params)
result.append('ORDER BY %s' % ', '.join(ordering))
# For subqueres with an ORDER BY clause, SQL Server also
# requires a TOP or OFFSET clause which is not generated for
# Django 2.x. See https://github.com/microsoft/mssql-django/issues/12
if django.VERSION < (3, 0, 0) and not (do_offset or do_limit):
result.append("OFFSET 0 ROWS")
# SQL Server requires the backend-specific emulation (2008 or earlier)
# or an offset clause (2012 or newer) for offsetting
if do_offset:
if do_offset_emulation:
# Construct the final SQL clause, using the initial select SQL
# obtained above.
result = [
'SELECT * FROM (%s) AS X WHERE X.rn' % ' '.join(result)
]
# Place WHERE condition on `rn` for the desired range.
if do_limit:
result.append('BETWEEN %d AND %d' %
(low_mark + 1, high_mark))
else:
result.append('>= %d' % (low_mark + 1))
if not self.query.subquery:
result.append('ORDER BY X.rn')
else:
result.append(
self.connection.ops.limit_offset_sql(
self.query.low_mark, self.query.high_mark))
if self.query.subquery and extra_select:
# If the query is used as a subquery, the extra selects would
# result in more columns than the left-hand side expression is
# expecting. This can happen when a subquery uses a combination
# of order_by() and distinct(), forcing the ordering expressions
# to be selected as well. Wrap the query in another subquery
# to exclude extraneous selects.
sub_selects = []
sub_params = []
for index, (select, _, alias) in enumerate(self.select,
start=1):
if not alias and with_col_aliases:
alias = 'col%d' % index
if alias:
sub_selects.append("%s.%s" % (
self.connection.ops.quote_name('subquery'),
self.connection.ops.quote_name(alias),
))
else:
select_clone = select.relabeled_clone(
{select.alias: 'subquery'})
subselect, subparams = select_clone.as_sql(
self, self.connection)
sub_selects.append(subselect)
sub_params.extend(subparams)
return 'SELECT %s FROM (%s) subquery' % (
', '.join(sub_selects),
' '.join(result),
), tuple(sub_params + params)
return ' '.join(result), tuple(params)
finally:
# Finally do cleanup - get rid of the joins we created above.
self.query.reset_refcounts(refcounts_before)
def as_sql(self, with_limits=True, with_col_aliases=False):
"""
Creates the SQL for this query. Returns the SQL string and list of
parameters.
If 'with_limits' is False, any limit/offset information is not included
in the query.
"""
refcounts_before = self.query.alias_refcount.copy()
try:
extra_select, order_by, group_by = self.pre_sql_setup()
for_update_part = None
combinator = self.query.combinator
features = self.connection.features
# The do_offset flag indicates whether we need to construct
# the SQL needed to use limit/offset w/SQL Server.
high_mark = self.query.high_mark
low_mark = self.query.low_mark
do_limit = with_limits and high_mark is not None
do_offset = with_limits and low_mark != 0
# SQL Server 2012 or newer supports OFFSET/FETCH clause
supports_offset_clause = self.connection.sql_server_version >= 2012
do_offset_emulation = do_offset and not supports_offset_clause
if combinator:
if not getattr(features,
'supports_select_{}'.format(combinator)):
raise DatabaseError(
'{} not supported on this database backend.'.format(
combinator))
result, params = self.get_combinator_sql(
combinator, self.query.combinator_all)
else:
distinct_fields = self.get_distinct()
# This must come after 'select', 'ordering', and 'distinct' -- see
# docstring of get_from_clause() for details.
from_, f_params = self.get_from_clause()
where, w_params = self.compile(
self.where) if self.where is not None else ("", [])
having, h_params = self.compile(
self.having) if self.having is not None else ("", [])
params = []
result = ['SELECT']
if self.query.distinct:
result.append(
self.connection.ops.distinct_sql(distinct_fields))
# SQL Server requires the keword for limitting at the begenning
if do_limit and not do_offset:
result.append('TOP %d' % high_mark)
out_cols = []
col_idx = 1
for _, (s_sql, s_params), alias in self.select + extra_select:
if alias:
s_sql = '%s AS %s' % (
s_sql, self.connection.ops.quote_name(alias))
elif with_col_aliases or do_offset_emulation:
s_sql = '%s AS %s' % (s_sql, 'Col%d' % col_idx)
col_idx += 1
params.extend(s_params)
out_cols.append(s_sql)
# SQL Server requires an order-by clause for offsetting
if do_offset:
meta = self.query.get_meta()
qn = self.quote_name_unless_alias
offsetting_order_by = '%s.%s' % (qn(
meta.db_table), qn(meta.pk.db_column
or meta.pk.column))
if do_offset_emulation:
if order_by:
ordering = []
for expr, (o_sql, o_params, _) in order_by:
# value_expression in OVER clause cannot refer to
# expressions or aliases in the select list. See:
# http://msdn.microsoft.com/en-us/library/ms189461.aspx
src = next(iter(expr.get_source_expressions()))
if isinstance(src, Ref):
src = next(
iter(src.get_source_expressions()))
o_sql, _ = src.as_sql(
self, self.connection)
odir = 'DESC' if expr.descending else 'ASC'
o_sql = '%s %s' % (o_sql, odir)
ordering.append(o_sql)
params.extend(o_params)
offsetting_order_by = ', '.join(ordering)
order_by = []
out_cols.append(
'ROW_NUMBER() OVER (ORDER BY %s) AS [rn]' %
offsetting_order_by)
elif not order_by:
order_by.append(
((None, ('%s ASC' % offsetting_order_by, [],
None))))
result.append(', '.join(out_cols))
if self.query.select_for_update and self.connection.features.has_select_for_update:
if self.connection.get_autocommit():
raise TransactionManagementError(
'select_for_update cannot be used outside of a transaction.'
)
nowait = self.query.select_for_update_nowait
skip_locked = self.query.select_for_update_skip_locked
# If it's a NOWAIT/SKIP LOCKED query but the backend
# doesn't support it, raise a DatabaseError to prevent a
# possible deadlock.
if nowait and not self.connection.features.has_select_for_update_nowait:
raise DatabaseError(
'NOWAIT is not supported on this database backend.'
)
elif skip_locked and not self.connection.features.has_select_for_update_skip_locked:
raise DatabaseError(
'SKIP LOCKED is not supported on this database backend.'
)
for_update_part = self.connection.ops.for_update_sql(
nowait=nowait, skip_locked=skip_locked)
if for_update_part and self.connection.features.for_update_after_from:
from_.insert(1, for_update_part)
result.append('FROM')
result.extend(from_)
params.extend(f_params)
if where:
result.append('WHERE %s' % where)
params.extend(w_params)
grouping = []
for g_sql, g_params in group_by:
grouping.append(g_sql)
params.extend(g_params)
if grouping:
if distinct_fields:
raise NotImplementedError(
"annotate() + distinct(fields) is not implemented."
)
if not order_by:
order_by = self.connection.ops.force_no_ordering()
result.append('GROUP BY %s' % ', '.join(grouping))
if having:
result.append('HAVING %s' % having)
params.extend(h_params)
if order_by:
ordering = []
for _, (o_sql, o_params, _) in order_by:
ordering.append(o_sql)
params.extend(o_params)
result.append('ORDER BY %s' % ', '.join(ordering))
# SQL Server requires the backend-specific emulation (2008 or earlier)
# or an offset clause (2012 or newer) for offsetting
if do_offset:
if do_offset_emulation:
# Construct the final SQL clause, using the initial select SQL
# obtained above.
result = [
'SELECT * FROM (%s) AS X WHERE X.rn' % ' '.join(result)
]
# Place WHERE condition on `rn` for the desired range.
if do_limit:
result.append('BETWEEN %d AND %d' %
(low_mark + 1, high_mark))
else:
result.append('>= %d' % (low_mark + 1))
if not self.query.subquery:
result.append('ORDER BY X.rn')
else:
result.append('OFFSET %d ROWS' % low_mark)
if do_limit:
result.append('FETCH FIRST %d ROWS ONLY' %
(high_mark - low_mark))
return ' '.join(result), tuple(params)
finally:
# Finally do cleanup - get rid of the joins we created above.
self.query.reset_refcounts(refcounts_before)
def side_effect(*args, **kwargs):
# This could occur if a slightly earlier POST or PUT still had
# the database locked during a DB transaction.
from django.db.transaction import TransactionManagementError
raise TransactionManagementError()
def as_sql(self, with_limits=True, with_col_aliases=False, subquery=False):
"""
Creates the SQL for this query. Returns the SQL string and list of
parameters.
If 'with_limits' is False, any limit/offset information is not included
in the query.
"""
if with_limits and self.query.low_mark == self.query.high_mark:
return '', ()
self.subquery = subquery
refcounts_before = self.query.alias_refcount.copy()
try:
extra_select, order_by, group_by = self.pre_sql_setup()
if with_limits and self.query.low_mark == self.query.high_mark:
return '', ()
distinct_fields = self.get_distinct()
# This must come after 'select', 'ordering', and 'distinct' -- see
# docstring of get_from_clause() for details.
from_, f_params = self.get_from_clause()
where, w_params = self.compile(self.where) if self.where is not None else ("", [])
having, h_params = self.compile(self.having) if self.having is not None else ("", [])
params = []
result = ['SELECT']
if self.query.distinct:
result.append(self.connection.ops.distinct_sql(distinct_fields))
out_cols = []
col_idx = 1
for _, (s_sql, s_params), alias in self.select + extra_select:
if alias:
s_sql = '%s AS %s' % (s_sql, self.connection.ops.quote_name(alias))
elif with_col_aliases:
s_sql = '%s AS %s' % (s_sql, 'Col%d' % col_idx)
col_idx += 1
params.extend(s_params)
out_cols.append(s_sql)
result.append(', '.join(out_cols))
result.append('FROM')
result.extend(from_)
params.extend(f_params)
if where:
result.append('WHERE %s' % where)
params.extend(w_params)
grouping = []
for g_sql, g_params in group_by:
grouping.append(g_sql)
params.extend(g_params)
if grouping:
if distinct_fields:
raise NotImplementedError(
"annotate() + distinct(fields) is not implemented.")
if not order_by:
order_by = self.connection.ops.force_no_ordering()
result.append('GROUP BY %s' % ', '.join(grouping))
if having:
result.append('HAVING %s' % having)
params.extend(h_params)
if order_by:
ordering = []
for _, (o_sql, o_params, _) in order_by:
ordering.append(o_sql)
params.extend(o_params)
result.append('ORDER BY %s' % ', '.join(ordering))
if with_limits:
if self.query.high_mark is not None:
result.append('LIMIT %d' % (self.query.high_mark - self.query.low_mark))
if self.query.low_mark:
if self.query.high_mark is None:
val = self.connection.ops.no_limit_value()
if val:
result.append('LIMIT %d' % val)
result.append('OFFSET %d' % self.query.low_mark)
if self.query.select_for_update and self.connection.features.has_select_for_update:
if self.connection.get_autocommit():
raise TransactionManagementError(
"select_for_update cannot be used outside of a transaction."
)
# If we've been asked for a NOWAIT query but the backend does
# not support it, raise a DatabaseError otherwise we could get
# an unexpected deadlock.
nowait = self.query.select_for_update_nowait
if nowait and not self.connection.features.has_select_for_update_nowait:
raise DatabaseError('NOWAIT is not supported on this database backend.')
result.append(self.connection.ops.for_update_sql(nowait=nowait))
return ' '.join(result), tuple(params)
finally:
# Finally do cleanup - get rid of the joins we created above.
self.query.reset_refcounts(refcounts_before)
def as_sql(self, with_limits=True, with_col_aliases=False): # pylint:disable=arguments-differ
# pylint:disable=too-many-locals,too-many-branches,too-many-statements
"""
Creates the SQL for this query. Returns the SQL string and list of
parameters.
If 'with_limits' is False, any limit/offset information is not included
in the query.
"""
# After executing the query, we must get rid of any joins the query
# setup created. So, take note of alias counts before the query ran.
# However we do not want to get rid of stuff done in pre_sql_setup(),
# as the pre_sql_setup will modify query state in a way that forbids
# another run of it.
if with_limits and self.query.low_mark == self.query.high_mark:
return '', ()
refcounts_before = self.query.alias_refcount.copy()
try:
extra_select, order_by, group_by = self.pre_sql_setup()
soql_trans = self.query_topology()
if with_limits and self.query.low_mark == self.query.high_mark:
return '', ()
distinct_fields = self.get_distinct()
# This must come after 'select', 'ordering', and 'distinct' -- see
# docstring of get_from_clause() for details.
from_, f_params = self.get_from_clause()
where, w_params = self.compile(
self.where) if self.where is not None else ("", [])
having, h_params = self.compile(
self.having) if self.having is not None else ("", [])
params = []
result = ['SELECT']
if self.query.distinct:
result.append(
self.connection.ops.distinct_sql(distinct_fields))
out_cols = []
col_idx = 1
for _, (s_sql, s_params), alias in self.select + extra_select:
if alias:
# fixed by removing 'AS'
s_sql = '%s %s' % (s_sql,
self.connection.ops.quote_name(alias))
elif with_col_aliases and not isinstance(
with_col_aliases,
salesforce.backend.base.DatabaseWrapper):
s_sql = '%s AS %s' % (s_sql, 'Col%d' % col_idx)
col_idx += 1
if soql_trans and re.match(r'^\w+\.\w+$', s_sql):
tab_name, col_name = s_sql.split('.')
s_sql = '%s.%s' % (soql_trans[tab_name], col_name)
params.extend(s_params)
out_cols.append(s_sql)
result.append(', '.join(out_cols))
result.append('FROM')
result.extend(from_)
params.extend(f_params)
if where:
result.append('WHERE %s' % where)
params.extend(w_params)
grouping = []
for g_sql, g_params in group_by:
grouping.append(g_sql)
params.extend(g_params)
if grouping:
if distinct_fields:
raise NotSupportedError(
"annotate() + distinct(fields) is not implemented.")
if not order_by:
order_by = self.connection.ops.force_no_ordering()
result.append('GROUP BY %s' % ', '.join(grouping))
if having:
result.append('HAVING %s' % having)
params.extend(h_params)
if order_by:
ordering = []
for _, (o_sql, o_params, _) in order_by:
ordering.append(o_sql)
params.extend(o_params)
result.append('ORDER BY %s' % ', '.join(ordering))
if with_limits:
if self.query.high_mark is not None:
result.append('LIMIT %d' %
(self.query.high_mark - self.query.low_mark))
if self.query.low_mark:
if self.query.high_mark is None:
val = self.connection.ops.no_limit_value()
if val:
result.append('LIMIT %d' % val)
result.append('OFFSET %d' % self.query.low_mark)
if self.query.select_for_update and self.connection.features.has_select_for_update:
if self.connection.get_autocommit():
raise TransactionManagementError(
"select_for_update cannot be used outside of a transaction."
)
# If we've been asked for a NOWAIT query but the backend does
# not support it, raise a DatabaseError otherwise we could get
# an unexpected deadlock.
nowait = self.query.select_for_update_nowait
if nowait and not self.connection.features.has_select_for_update_nowait:
raise DatabaseError(
'NOWAIT is not supported on this database backend.')
result.append(
self.connection.ops.for_update_sql(nowait=nowait))
return ' '.join(result), tuple(params)
finally:
# Finally do cleanup - get rid of the joins we created above.
self.query.reset_refcounts(refcounts_before)
def populate_tags(tag):
"""Evaluate `tag` for all nodes.
This returns a `Deferred` that will fire when all tags have been
evaluated. The return value is intended FOR TESTING ONLY because:
- You must not use the `Deferred` in the calling thread; it must only be
manipulated in the reactor thread. Pretending it's not there is safer
than chaining code onto it because it's easy to get wrong.
- The call may not finish for 10 minutes or more. It is therefore not a
good thing to be waiting for in a web request.
"""
# This function cannot be called inside a transaction. The function manages
# its own transaction.
if in_transaction():
raise TransactionManagementError(
"`populate_tags` cannot be called inside an existing transaction.")
logger.debug('Evaluating the "%s" tag for all nodes.', tag.name)
clients = getAllClients()
if len(clients) == 0:
# We have no clients so we need to do the work locally.
@transactional
def _populate_tag():
return populate_tag_for_multiple_nodes(tag, Node.objects.all())
return _populate_tag()
else:
# Split the work between the connected rack controllers.
@transactional
def _generate_work():
node_ids = Node.objects.all().values_list("system_id", flat=True)
node_ids = [{"system_id": node_id} for node_id in node_ids]
chunked_node_ids = list(chunk_list(node_ids, len(clients)))
connected_racks = []
for idx, client in enumerate(clients):
rack = RackController.objects.get(system_id=client.ident)
token = _get_or_create_auth_token(rack.owner)
creds = convert_tuple_to_string(get_creds_tuple(token))
if len(chunked_node_ids) > idx:
connected_racks.append({
"system_id":
rack.system_id,
"hostname":
rack.hostname,
"client":
client,
"tag_name":
tag.name,
"tag_definition":
tag.definition,
"tag_nsmap": [{
"prefix": prefix,
"uri": uri
} for prefix, uri in tag_nsmap.items()],
"credentials":
creds,
"nodes":
list(chunked_node_ids[idx]),
})
return connected_racks
return _do_populate_tags(_generate_work())
def as_sql(self, with_limits=True, with_col_aliases=False):
"""
Creates the SQL for this query. Returns the SQL string and list of
parameters.
If 'with_limits' is False, any limit/offset information is not included
in the query.
"""
if with_limits and self.query.low_mark == self.query.high_mark:
return '', ()
self.pre_sql_setup()
# After executing the query, we must get rid of any joins the query
# setup created. So, take note of alias counts before the query ran.
# However we do not want to get rid of stuff done in pre_sql_setup(),
# as the pre_sql_setup will modify query state in a way that forbids
# another run of it.
refcounts_before = self.query.alias_refcount.copy()
out_cols, s_params = self.get_columns(with_col_aliases)
ordering, o_params, ordering_group_by = self.get_ordering()
distinct_fields = self.get_distinct()
# This must come after 'select', 'ordering' and 'distinct' -- see
# docstring of get_from_clause() for details.
from_, f_params = self.get_from_clause()
where, w_params = self.compile(self.query.where)
having, h_params = self.compile(self.query.having)
having_group_by = self.query.having.get_group_by_cols()
params = []
for val in six.itervalues(self.query.extra_select):
params.extend(val[1])
result = ['SELECT']
if self.query.distinct:
result.append(self.connection.ops.distinct_sql(distinct_fields))
result.append(', '.join(out_cols + self.ordering_aliases))
params.extend(s_params)
params.extend(self.ordering_params)
result.append('FROM')
result.extend(from_)
params.extend(f_params)
if where:
result.append('WHERE %s' % where)
params.extend(w_params)
grouping, gb_params = self.get_grouping(having_group_by, ordering_group_by)
if grouping:
if distinct_fields:
raise NotImplementedError(
"annotate() + distinct(fields) not implemented.")
if not ordering:
ordering = self.connection.ops.force_no_ordering()
result.append('GROUP BY %s' % ', '.join(grouping))
params.extend(gb_params)
if having:
result.append('HAVING %s' % having)
params.extend(h_params)
if ordering:
result.append('ORDER BY %s' % ', '.join(ordering))
params.extend(o_params)
if with_limits:
if self.query.high_mark is not None:
result.append('LIMIT %d' % (self.query.high_mark - self.query.low_mark))
if self.query.low_mark:
if self.query.high_mark is None:
val = self.connection.ops.no_limit_value()
if val:
result.append('LIMIT %d' % val)
result.append('OFFSET %d' % self.query.low_mark)
if self.query.select_for_update and self.connection.features.has_select_for_update:
if self.connection.get_autocommit():
raise TransactionManagementError("select_for_update cannot be used outside of a transaction.")
# If we've been asked for a NOWAIT query but the backend does not support it,
# raise a DatabaseError otherwise we could get an unexpected deadlock.
nowait = self.query.select_for_update_nowait
if nowait and not self.connection.features.has_select_for_update_nowait:
raise DatabaseError('NOWAIT is not supported on this database backend.')
result.append(self.connection.ops.for_update_sql(nowait=nowait))
# Finally do cleanup - get rid of the joins we created above.
self.query.reset_refcounts(refcounts_before)
return ' '.join(result), tuple(params)
self.autocommit = autocommit
if autocommit and self.run_commit_hooks_on_set_autocommit_on:
self.run_and_clear_commit_hooks()
self.run_commit_hooks_on_set_autocommit_on = False
def get_rollback(self):
<<<<<<< HEAD
"""
Get the "needs rollback" flag -- for *advanced use* only.
"""
=======
"""Get the "needs rollback" flag -- for *advanced use* only."""
>>>>>>> 37c99181c9a6b95433d60f8c8ef9af5731096435
if not self.in_atomic_block:
raise TransactionManagementError(
"The rollback flag doesn't work outside of an 'atomic' block.")
return self.needs_rollback
def set_rollback(self, rollback):
"""
Set or unset the "needs rollback" flag -- for *advanced use* only.
"""
if not self.in_atomic_block:
raise TransactionManagementError(
"The rollback flag doesn't work outside of an 'atomic' block.")
self.needs_rollback = rollback
def validate_no_atomic_block(self):
<<<<<<< HEAD
"""
Raise an error if an atomic block is active.
def as_sql(self, with_limits=True, with_col_aliases=False):
"""
Create the SQL for this query. Return the SQL string and list of
parameters.
If 'with_limits' is False, any limit/offset information is not included
in the query.
"""
refcounts_before = self.query.alias_refcount.copy()
try:
extra_select, order_by, group_by = self.pre_sql_setup()
for_update_part = None
# Is a LIMIT/OFFSET clause needed?
with_limit_offset = with_limits and (
self.query.high_mark is not None or self.query.low_mark)
combinator = self.query.combinator
features = self.connection.features
# The do_offset flag indicates whether we need to construct
# the SQL needed to use limit/offset w/SQL Server.
high_mark = self.query.high_mark
low_mark = self.query.low_mark
do_limit = with_limits and high_mark is not None
do_offset = with_limits and low_mark != 0
if combinator:
if not getattr(features,
'supports_select_{}'.format(combinator)):
raise NotSupportedError(
'{} is not supported on this database backend.'.format(
combinator))
result, params = self.get_combinator_sql(
combinator, self.query.combinator_all)
else:
distinct_fields, distinct_params = self.get_distinct()
# This must come after 'select', 'ordering', and 'distinct' -- see
# docstring of get_from_clause() for details.
from_, f_params = self.get_from_clause()
where, w_params = self.compile(
self.where) if self.where is not None else ("", [])
having, h_params = self.compile(
self.having) if self.having is not None else ("", [])
params = []
result = ['SELECT']
if self.query.distinct:
distinct_result, distinct_params = self.connection.ops.distinct_sql(
distinct_fields,
distinct_params,
)
result += distinct_result
params += distinct_params
# SQL Server requires the keword for limitting at the begenning
if do_limit and not do_offset:
result.append('TOP %d' % high_mark)
out_cols = []
col_idx = 1
for _, (s_sql, s_params), alias in self.select + extra_select:
if alias:
s_sql = '%s AS %s' % (
s_sql, self.connection.ops.quote_name(alias))
elif with_col_aliases:
s_sql = '%s AS %s' % (s_sql, 'Col%d' % col_idx)
col_idx += 1
params.extend(s_params)
out_cols.append(s_sql)
# SQL Server requires an order-by clause for offsetting
if do_offset:
meta = self.query.get_meta()
qn = self.quote_name_unless_alias
offsetting_order_by = '%s.%s' % (qn(
meta.db_table), qn(meta.pk.db_column
or meta.pk.column))
if not order_by:
order_by.append(
((None, ('%s ASC' % offsetting_order_by, [],
None))))
if self.query.select_for_update and self.connection.features.has_select_for_update:
if self.connection.get_autocommit():
raise TransactionManagementError(
'select_for_update cannot be used outside of a transaction.'
)
if with_limit_offset and not self.connection.features.supports_select_for_update_with_limit:
raise NotSupportedError(
'LIMIT/OFFSET is not supported with '
'select_for_update on this database backend.')
nowait = self.query.select_for_update_nowait
skip_locked = self.query.select_for_update_skip_locked
of = self.query.select_for_update_of
# If it's a NOWAIT/SKIP LOCKED/OF query but the backend
# doesn't support it, raise NotSupportedError to prevent a
# possible deadlock.
if nowait and not self.connection.features.has_select_for_update_nowait:
raise NotSupportedError(
'NOWAIT is not supported on this database backend.'
)
elif skip_locked and not self.connection.features.has_select_for_update_skip_locked:
raise NotSupportedError(
'SKIP LOCKED is not supported on this database backend.'
)
elif of and not self.connection.features.has_select_for_update_of:
raise NotSupportedError(
'FOR UPDATE OF is not supported on this database backend.'
)
for_update_part = self.connection.ops.for_update_sql(
nowait=nowait,
skip_locked=skip_locked,
of=self.get_select_for_update_of_arguments(),
)
if for_update_part and self.connection.features.for_update_after_from:
from_.insert(1, for_update_part)
result += [', '.join(out_cols), 'FROM', *from_]
params.extend(f_params)
if where:
result.append('WHERE %s' % where)
params.extend(w_params)
grouping = []
for g_sql, g_params in group_by:
grouping.append(g_sql)
params.extend(g_params)
if grouping:
if distinct_fields:
raise NotImplementedError(
'annotate() + distinct(fields) is not implemented.'
)
order_by = order_by or self.connection.ops.force_no_ordering(
)
result.append('GROUP BY %s' % ', '.join(grouping))
if having:
result.append('HAVING %s' % having)
params.extend(h_params)
if self.query.explain_query:
result.insert(
0,
self.connection.ops.explain_query_prefix(
self.query.explain_format,
**self.query.explain_options))
if order_by:
ordering = []
for _, (o_sql, o_params, _) in order_by:
ordering.append(o_sql)
params.extend(o_params)
result.append('ORDER BY %s' % ', '.join(ordering))
if do_offset:
result.append(
self.connection.ops.limit_offset_sql(
self.query.low_mark, self.query.high_mark))
if self.query.subquery and extra_select:
# If the query is used as a subquery, the extra selects would
# result in more columns than the left-hand side expression is
# expecting. This can happen when a subquery uses a combination
# of order_by() and distinct(), forcing the ordering expressions
# to be selected as well. Wrap the query in another subquery
# to exclude extraneous selects.
sub_selects = []
sub_params = []
for index, (select, _, alias) in enumerate(self.select,
start=1):
if not alias and with_col_aliases:
alias = 'col%d' % index
if alias:
sub_selects.append("%s.%s" % (
self.connection.ops.quote_name('subquery'),
self.connection.ops.quote_name(alias),
))
else:
select_clone = select.relabeled_clone(
{select.alias: 'subquery'})
subselect, subparams = select_clone.as_sql(
self, self.connection)
sub_selects.append(subselect)
sub_params.extend(subparams)
return 'SELECT %s FROM (%s) subquery' % (
', '.join(sub_selects),
' '.join(result),
), tuple(sub_params + params)
return ' '.join(result), tuple(params)
finally:
# Finally do cleanup - get rid of the joins we created above.
self.query.reset_refcounts(refcounts_before)
def run_sql(self, sql, capture=False, execute=False):
"""Run (execute and/or capture) a list of SQL statements.
Args:
sql (list):
A list of SQL statements. Each entry might be a string, a
tuple consisting of a format string and formatting arguments,
or a subclass of :py:class:`BaseGroupedSQL`, or a callable
that returns a list of the above.
capture (bool, optional):
Whether to capture any processed SQL statements.
execute (bool, optional):
Whether to execute any executed SQL statements and return them.
Returns:
list of unicode:
The list of SQL statements executed, if passing
``capture=True``. Otherwise, this will just be an empty list.
Raises:
django.db.transaction.TransactionManagementError:
Could not execute a batch of SQL statements inside of an
existing transaction.
"""
qp = self._evolver_backend.quote_sql_param
cursor = self._cursor
statement = None
params = None
out_sql = []
try:
batches = self._prepare_transaction_batches(self._prepare_sql(sql))
if execute and self._connection.in_atomic_block:
# Check if there are any statements that must run outside of
# a transaction.
batches = list(batches)
for batch, use_transaction in batches:
if not use_transaction:
logging.error(
'Unable to execute the following SQL inside of a '
'transaction: %r', batch)
raise TransactionManagementError(
'Unable to execute SQL inside of an existing '
'transaction. See the logging for more '
'information.')
for i, (batch, use_transaction) in enumerate(batches):
if execute:
if use_transaction:
self.new_transaction()
else:
self.finish_transaction()
if capture and i > 0:
if use_transaction:
out_sql.append('-- Start of a new transaction:')
else:
out_sql.append('-- Run outside of a transaction:')
for statement, params in batch:
if capture:
if params:
out_sql.append(
statement %
tuple(qp(param) for param in params))
else:
out_sql.append(statement)
if execute:
cursor.execute(statement, params)
except Exception as e:
# Augment the exception so that callers can get the SQL statement
# that failed.
e.last_sql_statement = (statement, params)
raise
return out_sql
def get_from_clause(self):
"""
Returns a list of strings that are joined together to go after the
"FROM" part of the query, as well as a list any extra parameters that
need to be included. Sub-classes, can override this to create a
from-clause via a "select".
This should only be called after any SQL construction methods that
might change the tables we need. This means the select columns,
ordering and distinct must be done first.
overriden to add WITH (LOCK) modifiers
"""
result = []
qn = self.quote_name_unless_alias
qn2 = self.connection.ops.quote_name
first = True
from_params = []
# MODIFIED, added with modifier
with_modifier = ''
if self.query.select_for_update and self.connection.features.has_select_for_update:
if self.connection.get_autocommit():
raise TransactionManagementError(
"mssql_select_for_update cannot be used outside of a transaction."
)
# If we've been asked for a NOWAIT query but the backend does not support it,
# raise a DatabaseError otherwise we could get an unexpected deadlock.
nowait = self.query.select_for_update_nowait
if nowait and not self.connection.features.has_select_for_update_nowait:
raise DatabaseError(
'NOWAIT is not supported on this database backend.')
with_modifier = self.connection.ops.for_update_sql(nowait=nowait)
# END MODIFIED
for alias in self.query.tables:
if not self.query.alias_refcount[alias]:
continue
try:
name, alias, join_type, lhs, join_cols, _, join_field = self.query.alias_map[
alias]
except KeyError:
# Extra tables can end up in self.tables, but not in the
# alias_map if they aren't in a join. That's OK. We skip them.
continue
alias_str = '' if alias == name else (' %s' % alias)
if join_type and not first:
extra_cond = join_field.get_extra_restriction(
self.query.where_class, alias, lhs)
if extra_cond:
extra_sql, extra_params = self.compile(extra_cond)
extra_sql = 'AND (%s)' % extra_sql
from_params.extend(extra_params)
else:
extra_sql = ""
# MODIFIED, added with modifier
result.append('%s %s%s %s ON (' %
(join_type, qn(name), alias_str, with_modifier))
# END MODIFIED
for index, (lhs_col, rhs_col) in enumerate(join_cols):
if index != 0:
result.append(' AND ')
result.append(
'%s.%s = %s.%s' %
(qn(lhs), qn2(lhs_col), qn(alias), qn2(rhs_col)))
result.append('%s)' % extra_sql)
else:
connector = '' if first else ', '
# MODIFIED, added with modifier
result.append('%s%s%s %s' %
(connector, qn(name), alias_str, with_modifier))
# END MODIFIED
first = False
for t in self.query.extra_tables:
alias, unused = self.query.table_alias(t)
# Only add the alias if it's not already present (the table_alias()
# calls increments the refcount, so an alias refcount of one means
# this is the only reference.
if alias not in self.query.alias_map or self.query.alias_refcount[
alias] == 1:
connector = '' if first else ', '
result.append('%s%s' % (connector, qn(alias)))
first = False
return result, from_params
