From bbfdb2e64b7dc3c90b465c91c5bbbea8dd81abbd Mon Sep 17 00:00:00 2001 From: Gregor Aisch Date: Tue, 30 Apr 2013 16:36:19 +0200 Subject: [PATCH] renamed filter args to _filter to avoid confusion with built in filter() --- dataset/persistence/table.py | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/dataset/persistence/table.py b/dataset/persistence/table.py index 898ebc7..fac32a6 100644 --- a/dataset/persistence/table.py +++ b/dataset/persistence/table.py @@ -147,7 +147,7 @@ class Table(object): if not self.update(row, keys, ensure=ensure, types=types): self.insert(row, ensure=ensure, types=types) - def delete(self, **filter): + def delete(self, **_filter): """ Delete rows from the table. Keyword arguments can be used to add column-based filters. The filter criterion will always be equality: @@ -159,8 +159,8 @@ class Table(object): If no arguments are given, all records are deleted. """ self._check_dropped() - if len(filter) > 0: - q = self._args_to_clause(filter) + if len(_filter) > 0: + q = self._args_to_clause(_filter) stmt = self.table.delete(q) else: stmt = self.table.delete() @@ -221,7 +221,7 @@ class Table(object): self.indexes[name] = idx return idx - def find_one(self, **filter): + def find_one(self, **_filter): """ Works just like :py:meth:`find() ` but returns only one result. :: @@ -229,7 +229,7 @@ class Table(object): row = table.find_one(country='United States') """ self._check_dropped() - res = list(self.find(_limit=1, **filter)) + res = list(self.find(_limit=1, **_filter)) if not len(res): return None return res[0] @@ -241,7 +241,7 @@ class Table(object): return self.table.c[order_by].asc() def find(self, _limit=None, _offset=0, _step=5000, - order_by='id', **filter): + order_by='id', **_filter): """ Performs a simple search on the table. Simply pass keyword arguments as ``filter``. :: @@ -262,6 +262,10 @@ class Table(object): # return all rows sorted by multiple columns (by year in descending order) results = table.find(order_by=['country', '-year']) + By default :py:meth:`find() ` will break the + query into chunks of ``_step`` rows to prevent huge tables + from being loaded into memory at once. + For more complex queries, please use :py:meth:`db.query() ` instead.""" self._check_dropped() @@ -270,13 +274,16 @@ class Table(object): order_by = filter(lambda o: o in self.table.columns, order_by) order_by = [self._args_to_order_by(o) for o in order_by] - args = self._args_to_clause(filter) + args = self._args_to_clause(_filter) # query total number of rows first count_query = self.table.count(whereclause=args, limit=_limit, offset=_offset) rp = self.database.engine.execute(count_query) total_row_count = rp.fetchone()[0] + if _step is None or _step is False or _step == 0: + _step = total_row_count + if total_row_count > _step and len(order_by) == 0: _step = total_row_count log.warn("query cannot be broken into smaller sections because it is unordered") @@ -303,7 +310,7 @@ class Table(object): d = self.database.query(self.table.count()).next() return d.values().pop() - def distinct(self, *columns, **filter): + def distinct(self, *columns, **_filter): """ Returns all rows of a table, but removes rows in with duplicate values in ``columns``. Interally this creates a `DISTINCT statement `_. @@ -320,7 +327,7 @@ class Table(object): qargs = [] try: columns = [self.table.c[c] for c in columns] - for col, val in filter.items(): + for col, val in _filter.items(): qargs.append(self.table.c[col] == val) except KeyError: return []