if with_polymorphic == '*':
self.with_polymorphic = ('*', None)
elif isinstance(with_polymorphic, (tuple, list)):
- if isinstance(with_polymorphic[0], (str, tuple, list)):
+ if isinstance(with_polymorphic[0], util.string_types + (tuple, list)):
self.with_polymorphic = with_polymorphic
else:
self.with_polymorphic = (with_polymorphic, None)
if self.polymorphic_on is not None:
setter = True
- if isinstance(self.polymorphic_on, str):
+ if isinstance(self.polymorphic_on, util.string_types):
# polymorphic_on specified as as string - link
# it to mapped ColumnProperty
try:
visited_states = set()
prp, mpp = object(), object()
- visitables = deque([(deque(list(self._props.values())), prp,
+ visitables = deque([(deque(self._props.values()), prp,
state, state.dict)])
while visitables:
corresponding_dict = iterator.popleft()
yield instance, instance_mapper, \
corresponding_state, corresponding_dict
- visitables.append((deque(list(instance_mapper._props.values())),
+ visitables.append((deque(instance_mapper._props.values()),
prp, corresponding_state,
corresponding_dict))
table_to_mapper.setdefault(t, mapper)
extra_dependencies = []
- for table, mapper in list(table_to_mapper.items()):
+ for table, mapper in table_to_mapper.items():
super_ = mapper.inherits
if super_:
extra_dependencies.extend([
return fk.parent not in cols
return False
- sorted_ = sql_util.sort_tables(iter(table_to_mapper.keys()),
+ sorted_ = sql_util.sort_tables(table_to_mapper,
skip_fn=skip,
extra_dependencies=extra_dependencies)
"""
- if isinstance(criterion, str):
+ if isinstance(criterion, util.string_types):
criterion = sql.text(criterion)
if criterion is not None and \
kwargs.pop('from_joinpoint', False)
if kwargs:
raise TypeError("unknown arguments: %s" %
- ','.join(iter(kwargs.keys())))
+ ','.join(kwargs.keys))
return self._join(props,
outerjoin=False, create_aliases=aliased,
from_joinpoint=from_joinpoint)
kwargs.pop('from_joinpoint', False)
if kwargs:
raise TypeError("unknown arguments: %s" %
- ','.join(iter(kwargs.keys())))
+ ','.join(kwargs))
return self._join(props,
outerjoin=True, create_aliases=aliased,
from_joinpoint=from_joinpoint)
# is a little bit of legacy behavior still at work here
# which means they might be in either order. may possibly
# lock this down to (right_entity, onclause) in 0.6.
- if isinstance(arg1, (interfaces.PropComparator, str)):
+ if isinstance(arg1, (interfaces.PropComparator, util.string_types)):
right_entity, onclause = arg2, arg1
else:
right_entity, onclause = arg1, arg2
left_entity = prop = None
- if isinstance(onclause, str):
+ if isinstance(onclause, util.string_types):
left_entity = self._joinpoint_zero()
descriptor = _entity_descriptor(left_entity, onclause)
appropriate to the entity class represented by this ``Query``.
"""
- if isinstance(statement, str):
+ if isinstance(statement, util.string_types):
statement = sql.text(statement)
if not isinstance(statement,
use_labels=context.labels)
from_clause = inner
- for eager_join in list(context.eager_joins.values()):
+ for eager_join in context.eager_joins.values():
# EagerLoader places a 'stop_on' attribute on the join,
# giving us a marker as to where the "splice point" of
# the join should be
subtypes are selected from the total results.
"""
- for (ext_info, adapter) in list(self._mapper_adapter_map.values()):
+ for (ext_info, adapter) in self._mapper_adapter_map.values():
if ext_info in self._join_entities:
continue
single_crit = ext_info.mapper._single_table_criterion
def __new__(cls, *args, **kwargs):
if cls is _QueryEntity:
entity = args[1]
- if not isinstance(entity, str) and \
+ if not isinstance(entity, util.string_types) and \
_is_mapped_class(entity):
cls = _MapperEntity
else:
self.expr = column
self.namespace = namespace
- if isinstance(column, str):
+ if isinstance(column, util.string_types):
column = sql.literal_column(column)
self._label_name = column.name
elif isinstance(column, (
self.alias = alias
def process_query(self, query):
- if isinstance(self.alias, str):
+ if isinstance(self.alias, util.string_types):
alias = query._mapper_zero().mapped_table.alias(self.alias)
else:
alias = self.alias
colnames = util.OrderedSet()
colnamemaps = {}
types = {}
- for key in list(table_map.keys()):
+ for key in table_map:
table = table_map[key]
# mysql doesnt like selecting from a select;
"positional arguments, got %s" % len(args))
if kwargs:
raise sa_exc.ArgumentError("unknown keyword arguments: %s"
- % ", ".join(list(kwargs.keys())))
+ % ", ".join(kwargs))
mapper = class_mapper(class_)
if "ident" in locals():
return mapper.identity_key_from_primary_key(util.to_list(ident))
instance = kwargs.pop("instance")
if kwargs:
raise sa_exc.ArgumentError("unknown keyword arguments: %s"
- % ", ".join(list(kwargs.keys())))
+ % ", ".join(kwargs.keys))
mapper = object_mapper(instance)
return mapper.identity_key_from_instance(instance)
self._joined_from_info = right_info
- if isinstance(onclause, str):
+ if isinstance(onclause, util.string_types):
onclause = getattr(left_orm_info.entity, onclause)
if isinstance(onclause, attributes.QueryableAttribute):
parent/child relationship.
"""
- if isinstance(prop, str):
+ if isinstance(prop, util.string_types):
mapper = object_mapper(instance)
prop = getattr(mapper.class_, prop).property
elif isinstance(prop, attributes.QueryableAttribute):