Optimizar la resolucion de la proyeccion en OOQuery

ooquery/ooquery.py

@@ -12,6 +12,7 @@
 class OOQuery(object):
     def __init__(self, table, foreign_key=None):
         self._fields = []
+        self._resolved_fields = []
         self.table = Table(table)
         self.foreign_key = foreign_key
         self._select = self.table.select()
@@ -111,11 +112,16 @@ def select(self, fields=None, **kwargs):
                 kwargs['group_by'].append(
                     table_field
                 )
-        self._select = self.select_on.select(*self.fields, **self.select_opts)
+        self._resolved_fields = self.fields
+        self._select = self.select_on.select(
+            *self._resolved_fields, **self.select_opts
+        )
         return self
 
     def where(self, domain):
         where = self.parser.parse(domain)
-        self._select = self.select_on.select(*self.fields, **self.select_opts)
+        self._select = self.select_on.select(
+            *self._resolved_fields, **self.select_opts
+        )
         self._select.where = where
         return self._select

spec/ooquery_spec.py

@@ -2,6 +2,7 @@
 from ooquery import OOQuery
 from ooquery.expression import Field
 from ooquery.operators import *
+from ooquery.parser import Parser
 from sql import Table, Literal, NullsFirst, NullsLast
 from sql.operators import And, Concat
 from sql.aggregate import Max
@@ -29,6 +30,28 @@
             sel.where = And((t.field3 == 4,))
             expect(tuple(sql)).to(equal(tuple(sel)))
 
+        with it('should resolve projection fields only once'):
+            class CountingParser(Parser):
+                def __init__(self, *args, **kwargs):
+                    super(CountingParser, self).__init__(*args, **kwargs)
+                    self.resolved_fields = []
+
+                def get_table_field(self, table, field):
+                    self.resolved_fields.append(field)
+                    return super(CountingParser, self).get_table_field(
+                        table, field
+                    )
+
+            class CountingOOQuery(OOQuery):
+                def create_parser(self):
+                    return CountingParser(self.table, self.foreign_key)
+
+            q = CountingOOQuery('table')
+            q.select(['field1', 'field2']).where([('field3', '=', 4)])
+
+            expect(q.parser.resolved_fields.count('field1')).to(equal(1))
+            expect(q.parser.resolved_fields.count('field2')).to(equal(1))
+
         with it('should have where method and compare two fields of the table'):
             q = OOQuery('table')
             sql = q.select(['field1', 'field2']).where([('field3', '>', Field('field4'))])