curc = t[2][1]
if self.get_style(t[0], t[1]) != curstyle:
- if len(tokens):
+ if tokens:
self.colorize([(string.join(tokens, ''), curstyle)])
tokens = []
curstyle = self.get_style(t[0], t[1])
curl = t[3][0]
# any remaining content to output, output it
- if len(tokens):
+ if tokens:
self.colorize([(string.join(tokens, ''), curstyle)])
if trailingspace:
self.next = None
self.children = []
if parent:
- if len(parent.children):
+ if parent.children:
self.previous = parent.children[-1]
parent.children[-1].next = self
parent.children.append(self)
dump_mako_tag(elem, stream)
else:
if elem.tag != 'html':
- if len(elem.attrib):
+ if elem.attrib:
stream.write("<%s %s>" % (elem.tag, " ".join(["%s=%s" % (key, repr(val)) for key, val in elem.attrib.iteritems()])))
else:
stream.write("<%s>" % elem.tag)
def visit_label(self, label):
labelname = self._truncated_identifier("colident", label.name)
- if len(self.select_stack):
+ if self.select_stack:
self.typemap.setdefault(labelname.lower(), label.obj.type)
if isinstance(label.obj, sql._ColumnClause):
self.column_labels[label.obj._label] = labelname
else:
name = column.name
- if len(self.select_stack):
+ if self.select_stack:
# if we are within a visit to a Select, set up the "typemap"
# for this column which is used to translate result set values
self.typemap.setdefault(name.lower(), column.type)
return self.process(clause.clause_expr)
def visit_cast(self, cast, **kwargs):
- if len(self.select_stack):
+ if self.select_stack:
# not sure if we want to set the typemap here...
self.typemap.setdefault("CAST", cast.type)
return "CAST(%s AS %s)" % (self.process(cast.clause), self.process(cast.typeclause))
def visit_function(self, func, **kwargs):
- if len(self.select_stack):
+ if self.select_stack:
self.typemap.setdefault(func.name, func.type)
if not self.apply_function_parens(func):
return ".".join(func.packagenames + [func.name])
else:
whereclause = w
- if len(froms):
+ if froms:
text += " \nFROM "
text += string.join(from_strings, ', ')
else:
# On some DB order is significant: visit PK first, then the
# other constraints (engine.ReflectionTest.testbasic failed on FB2)
- if len(table.primary_key):
+ if table.primary_key:
self.traverse_single(table.primary_key)
for constraint in [c for c in table.constraints if c is not table.primary_key]:
self.traverse_single(constraint)
return self.process(alias.original, asfrom=True)
def visit_function(self, func):
- if len(func.clauses):
+ if func.clauses:
return super(FBCompiler, self).visit_function(func)
else:
return func.name
return ""
def __visit_label(self, label):
- if len(self.select_stack):
+ if self.select_stack:
self.typemap.setdefault(label.name.lower(), label.obj.type)
if self.strings[label.obj]:
self.strings[label] = self.strings[label.obj] + " AS " + label.name
ssl[key[4:]] = opts[key]
util.coerce_kw_type(ssl, key[4:], str)
del opts[key]
- if len(ssl):
+ if ssl:
opts['ssl'] = ssl
# FOUND_ROWS must be set in CLIENT_FLAGS to enable
if self.dialect.supports_cast:
return super(SQLiteCompiler, self).visit_cast(cast)
else:
- if len(self.select_stack):
+ if self.select_stack:
# not sure if we want to set the typemap here...
self.typemap.setdefault("CAST", cast.type)
return self.process(cast.clause)
engine_args[k] = kwargs.pop(k)
# all kwargs should be consumed
- if len(kwargs):
+ if kwargs:
raise TypeError("Invalid argument(s) %s sent to create_engine(), using configuration %s/%s/%s. Please check that the keyword arguments are appropriate for this combination of components." % (','.join(["'%s'" % k for k in kwargs]), dialect.__class__.__name__, pool.__class__.__name__, engineclass.__name__))
return engineclass(pool, dialect, u, **engine_args)
s += ':' + str(self.port)
if self.database is not None:
s += '/' + self.database
- if len(self.query):
+ if self.query:
keys = self.query.keys()
keys.sort()
s += '?' + "&".join(["%s=%s" % (k, self.query[k]) for k in keys])
uowcommit.attributes[(self, "manytomany", obj, child)] = True
secondary_delete.append(associationrow)
- if len(secondary_delete):
+ if secondary_delete:
secondary_delete.sort()
# TODO: precompile the delete/insert queries?
statement = self.secondary.delete(sql.and_(*[c == sql.bindparam(c.key, type_=c.type) for c in self.secondary.c if c.key in associationrow]))
if result.supports_sane_rowcount() and result.rowcount != len(secondary_delete):
raise exceptions.ConcurrentModificationError("Deleted rowcount %d does not match number of objects deleted %d" % (result.rowcount, len(secondary_delete)))
- if len(secondary_insert):
+ if secondary_insert:
statement = self.secondary.insert()
connection.execute(statement, secondary_insert)
if getattr(klass, key).hasparent(obj, optimistic=optimistic):
return False
else:
- if len(self.delete_orphans):
+ if self.delete_orphans:
if not has_identity(obj):
raise exceptions.FlushError("instance %s is an unsaved, pending instance and is an orphan (is not attached to %s)" %
(
history = prop.get_history(obj, passive=True)
if history:
a = history.added_items()
- if len(a):
+ if a:
if isinstance(a[0], sql.ClauseElement):
value_params[col] = a[0]
else:
else:
insert.append((obj, params, mapper, connection, value_params))
- if len(update):
+ if update:
mapper = table_to_mapper[table]
clause = sql.and_()
for col in mapper.pks_by_table[table]:
if c.supports_sane_rowcount() and rows != len(update):
raise exceptions.ConcurrentModificationError("Updated rowcount %d does not match number of objects updated %d" % (rows, len(update)))
- if len(insert):
+ if insert:
statement = table.insert()
def comparator(a, b):
return cmp(a[0]._sa_insert_order, b[0]._sa_insert_order)
elif v != params.get_original(c.key):
self.set_attr_by_column(obj, c, params.get_original(c.key))
- if len(deferred_props):
+ if deferred_props:
deferred_load(obj, props=deferred_props)
def delete_obj(self, objects, uowtransaction):
self.target.corresponding_column(col, raiseerr=False) is not None or \
self.secondary.corresponding_column(col, raiseerr=False) is not None
- if len(self.foreign_keys):
+ if self.foreign_keys:
self._opposite_side = util.Set()
def visit_binary(binary):
if binary.operator != operator.eq or not isinstance(binary.left, schema.Column) or not isinstance(binary.right, schema.Column):
else:
self.direction = sync.MANYTOONE
- elif len(self.remote_side):
+ elif self.remote_side:
for f in self.foreign_keys:
if f in self.remote_side:
self.direction = sync.ONETOMANY
global_extensions.append(_ScopedExt(self))
def __call__(self, **kwargs):
- if len(kwargs):
+ if kwargs:
scope = kwargs.pop('scope', False)
if scope is not None:
if self.registry.has():
if self.uselist:
return result
else:
- if len(result):
+ if result:
return result[0]
else:
return None
ret = False
elements = [getobj(elem) for elem in self.targettask.polymorphic_tosave_elements if elem.obj is not None and not elem.is_preprocessed(self)]
- if len(elements):
+ if elements:
ret = True
self.processor.preprocess_dependencies(self.targettask, elements, trans, delete=False)
elements = [getobj(elem) for elem in self.targettask.polymorphic_todelete_elements if elem.obj is not None and not elem.is_preprocessed(self)]
- if len(elements):
+ if elements:
ret = True
self.processor.preprocess_dependencies(self.targettask, elements, trans, delete=True)
return ret
self.headers = {}
try:
i = self._indent()
- if len(i):
+ if i:
i += "-"
#i = i[0:-1] + "-"
self.buf.write(self._indent() + "\n")
key = _get_table_key(name, schema)
try:
table = metadata.tables[key]
- if len(args):
+ if args:
if not useexisting:
raise exceptions.ArgumentError("Table '%s' is already defined for this MetaData instance." % key)
return table
self.constraints = util.Set()
self.__originating_column = self
self._foreign_keys = util.OrderedSet()
- if len(kwargs):
+ if kwargs:
raise exceptions.ArgumentError("Unknown arguments passed to Column: " + repr(kwargs.keys()))
primary_key = util.SimpleProperty('_primary_key')
whenlist = [ClauseList('WHEN', c, 'THEN', r, operator=None) for (c,r) in whens]
if not else_ is None:
whenlist.append(ClauseList('ELSE', else_, operator=None))
- if len(whenlist):
+ if whenlist:
type = list(whenlist[-1])[-1].type
else:
type = None
def execute(self, *multiparams, **params):
"""Compile and execute this ``ClauseElement``."""
- if len(multiparams):
+ if multiparams:
compile_params = multiparams[0]
else:
compile_params = params
""")
def _one_fkey(self):
- if len(self._foreign_keys):
+ if self._foreign_keys:
return list(self._foreign_keys)[0]
else:
return None
return [self.oid_column]
def count(self, whereclause=None, **params):
- if len(self.primary_key):
+ if self.primary_key:
col = list(self.primary_key)[0]
else:
col = list(self.columns)[0]
raise NotImplementedError()
def count(self, whereclause=None, **params):
- if len(self.primary_key):
+ if self.primary_key:
col = list(self.primary_key)[0]
else:
col = list(self.columns)[0]
# some DBs do not like ORDER BY in the inner queries of a UNION, etc.
for n, s in enumerate(selects):
- if len(s._order_by_clause):
+ if s._order_by_clause:
s = s.order_by(None)
# unions group from left to right, so don't group first select
if n:
session = create_session()
def append_child(parent, child):
- if len(parent.children):
+ if parent.children:
parent.children[-1].next_sibling = child
child.prev_sibling = parent.children[-1]
parent.children.append(child)
objects.append(item)
item.item_name = elem['item_name']
item.keywords = []
- if len(elem['keywords'][1]):
+ if elem['keywords'][1]:
klist = Session.query(keywordmapper).select(keywords.c.name.in_(*[e['name'] for e in elem['keywords'][1]]))
else:
klist = []
def main(suite=None):
if not suite:
- if len(sys.argv[1:]):
+ if sys.argv[1:]:
suite =unittest.TestLoader().loadTestsFromNames(
sys.argv[1:], __import__('__main__'))
else:
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
