tiny tiny speed improvements....

2 files changed, 29 insertions, 30 deletions

diff --git a/lib/sqlalchemy/sql/compiler.py b/lib/sqlalchemy/sql/compiler.py
index 6d3769906..0117b96ff 100644
--- a/lib/sqlalchemy/sql/compiler.py
+++ b/lib/sqlalchemy/sql/compiler.py
@@ -470,18 +470,20 @@ class DefaultCompiler(engine.Compiled):
         self.stack.append({'from':correlate_froms, 'iswrapper':iswrapper})
 
         # the actual list of columns to print in the SELECT column list.
-        inner_columns = util.OrderedSet(
-            [c for c in [
+        inner_columns = util.unique_list(
+            c for c in [
                 self.process(
                     self.label_select_column(select, co, asfrom=asfrom), 
                     within_columns_clause=True,
                     **column_clause_args) 
                 for co in select.inner_columns
             ]
-            if c is not None]
+            if c is not None
         )
-
-        text = " ".join(["SELECT"] + [self.process(x) for x in select._prefixes]) + " "
+        
+        text = "SELECT "  # we're off to a good start !
+        if select._prefixes:
+            text += " ".join(self.process(x) for x in select._prefixes) + " "
         text += self.get_select_precolumns(select)
         text += ', '.join(inner_columns)
 
@@ -985,8 +987,8 @@ class IdentifierPreparer(object):
         self.initial_quote = initial_quote
         self.final_quote = final_quote or self.initial_quote
         self.omit_schema = omit_schema
-        self.__strings = {}
-
+        self._strings = {}
+        
     def _escape_identifier(self, value):
         """Escape an identifier.
 
@@ -1021,21 +1023,21 @@ class IdentifierPreparer(object):
                 or self.illegal_initial_characters.match(value[0])
                 or not self.legal_characters.match(unicode(value))
                 or (lc_value != value))
-
+    
     def quote(self, ident, force):
-        if force:
+        if force is None:
+            if ident in self._strings:
+                return self._strings[ident]
+            else:
+                if self._requires_quotes(ident):
+                    self._strings[ident] = self.quote_identifier(ident)
+                else:
+                    self._strings[ident] = ident
+                return self._strings[ident]
+        elif force:
             return self.quote_identifier(ident)
-        elif force is False:
-            return ident
-            
-        if ident in self.__strings:
-            return self.__strings[ident]
         else:
-            if self._requires_quotes(ident):
-                self.__strings[ident] = self.quote_identifier(ident)
-            else:
-                self.__strings[ident] = ident
-            return self.__strings[ident]
+            return ident
 
     def format_sequence(self, sequence, use_schema=True):
         name = self.quote(sequence.name, sequence.quote)
diff --git a/lib/sqlalchemy/sql/expression.py b/lib/sqlalchemy/sql/expression.py
index 2663c61a1..b721e5884 100644
--- a/lib/sqlalchemy/sql/expression.py
+++ b/lib/sqlalchemy/sql/expression.py
@@ -870,20 +870,17 @@ def _cloned_intersection(a, b):
     
     """
     all_overlap = set(_expand_cloned(a)).intersection(_expand_cloned(b))
-    return a.intersection(
-        [
-            elem for elem in a if all_overlap.intersection(elem._cloned_set)
-        ]
-    )
+    return a.intersection(elem for elem in a if all_overlap.intersection(elem._cloned_set))
 
 def _compound_select(keyword, *selects, **kwargs):
     return CompoundSelect(keyword, *selects, **kwargs)
 
 def _is_literal(element):
-    global schema
-    if not schema:
-        from sqlalchemy import schema
-    return not isinstance(element, (ClauseElement, Operators, schema.SchemaItem))
+    global _is_literal
+    from sqlalchemy import schema
+    def _is_literal(element):
+        return not isinstance(element, (ClauseElement, Operators, schema.SchemaItem))
+    return _is_literal(element)
 
 def _from_objects(*elements, **kwargs):
     return itertools.chain(*[element._get_from_objects(**kwargs) for element in elements])
@@ -2960,8 +2957,8 @@ class Select(_SelectBaseMixin, FromClause):
 
     Select statements support appendable clauses, as well as the
     ability to execute themselves and return a result set.
-    """
 
+    """
     def __init__(self, columns, whereclause=None, from_obj=None, distinct=False, having=None, correlate=True, prefixes=None, **kwargs):
         """Construct a Select object.
 
@@ -2971,8 +2968,8 @@ class Select(_SelectBaseMixin, FromClause):
 
         Additional generative and mutator methods are available on the
         [sqlalchemy.sql.expression#_SelectBaseMixin] superclass.
-        """
 
+        """
         self._should_correlate = correlate
         self._distinct = distinct