Merge lp:~jamesh/storm/result-randomisation into lp:storm

[James Henstridge]

[Gustavo Niemeyer (niemeyer)]

There are some comments on the bug about this one.

[lp:~jamesh/storm/result-randomisation]

217. By James Henstridge on 2008-11-04

merge from trunk

Unmerged revisions

217. By James Henstridge on 2008-11-04

merge from trunk

216. By James Henstridge on 2008-02-13

Add a few tests for various operations when run with result
randomisation turned on. Currently test_randomise_order_distinct()
fails for Postgres and test_randomise_order_union() fails for SQLite.

215. By James Henstridge on 2008-02-11

* Add Store.set_randomise_order() method to turn on select results
  randomisation.
* Add a test to verify that Random() is being added to the ORDER BY
  clause of select results when the above is turned on.

214. By James Henstridge on 2008-02-11

* Add Random() expression to storm.expr, compiling to "RANDOM()".
* Compile Random() to "RAND()" on MySQL.
* Add tests for same.

=== modified file 'storm/databases/mysql.py'
--- storm/databases/mysql.py	2008-08-16 07:47:33 +0000
+++ storm/databases/mysql.py	2009-08-13 20:21:08 +0000
@@ -32,7 +32,7 @@
 
 from storm.expr import (
     compile, Insert, Select, compile_select, Undef, And, Eq,
-    SQLRaw, SQLToken, is_safe_token)
+    Random, SQLRaw, SQLToken, is_safe_token)
 from storm.variables import Variable
 from storm.database import Database, Connection, Result
 from storm.exceptions import (
@@ -45,6 +45,11 @@
 
 compile = compile.create_child()
 
[e-mail](Random)
+def compile_random_mysql(compile, func, state):
+    """MySQL uses RAND() to produce random values."""
+    return 'RAND(%s)' % compile(func.args, state)
+
 @compile.when(Select)
 def compile_select_mysql(compile, select, state):
     if select.offset is not Undef and select.limit is Undef:
 
=== modified file 'storm/expr.py'
--- storm/expr.py	2009-07-31 01:53:08 +0000
+++ storm/expr.py	2009-08-13 20:21:08 +0000
@@ -1243,6 +1243,13 @@
     __slots__ = ()
     name = "UPPER"
 
+class Random(NamedFunc):
+    """Expression that returns a random value.
+
+    Can be used to randomise the order of a result set.
+    """
+    name = "RANDOM"
+
 
 class Coalesce(NamedFunc):
     __slots__ = ()
 
=== modified file 'storm/store.py'
--- storm/store.py	2009-07-31 01:53:08 +0000
+++ storm/store.py	2009-08-13 20:21:08 +0000
@@ -33,7 +33,7 @@
 from storm.expr import (
     Expr, Select, Insert, Update, Delete, Column, Count, Max, Min,
     Avg, Sum, Eq, And, Asc, Desc, compile_python, compare_columns, SQLRaw,
-    Union, Except, Intersect, Alias, SetExpr)
+    Union, Except, Intersect, Alias, Random, SetExpr)
 from storm.exceptions import (
     WrongStoreError, NotFlushedError, OrderLoopError, UnorderedError,
     NotOneError, FeatureError, CompileError, LostObjectError, ClassInfoError)
@@ -80,6 +80,17 @@
             self._cache = cache
         self._implicit_flush_block_count = 0
         self._sequence = 0 # Advisory ordering.
+        self._randomise_results = False
+
+    def set_randomise_order(self, value):
+        """Set whether the order of result sets should be randomised.
+
+        If enabled, RANDOM() will be appended to the ORDER BY clause
+        of SELECT statements.  This is intended to aid testing by
+        preventing tests from relying on the 'natural ordering' of
+        results.
+        """
+        self._randomise_results = bool(value)
 
     @staticmethod
     def of(obj):
@@ -946,9 +957,17 @@
         return self
 
     def _get_select(self):
+        # If results should be randomised, do so here:
+        if self._store._randomise_results:
+            if self._order_by is Undef:
+                order_by = [Random()]
+            else:
+                order_by = list(self._order_by) + [Random()]
+        else:
+            order_by = self._order_by
         if self._select is not Undef:
-            if self._order_by is not Undef:
-                self._select.order_by = self._order_by
+            if order_by is not Undef:
+                self._select.order_by = order_by
             if self._limit is not Undef: # XXX UNTESTED!
                 self._select.limit = self._limit
             if self._offset is not Undef: # XXX UNTESTED!
@@ -956,7 +975,7 @@
             return self._select
         columns, default_tables = self._find_spec.get_columns_and_tables()
         return Select(columns, self._where, self._tables, default_tables,
-                      self._order_by, offset=self._offset, limit=self._limit,
+                      order_by, offset=self._offset, limit=self._limit,
                       distinct=self._distinct, group_by=self._group_by,
                       having=self._having)
 
 
=== modified file 'tests/databases/mysql.py'
--- tests/databases/mysql.py	2008-08-16 07:47:33 +0000
+++ tests/databases/mysql.py	2009-08-13 20:21:08 +0000
@@ -20,9 +20,9 @@
 #
 import os
 
-from storm.databases.mysql import MySQL
+from storm.databases.mysql import MySQL, compile
 from storm.database import create_database
-from storm.expr import Column, Insert
+from storm.expr import Column, Insert, Random, State
 from storm.uri import URI
 from storm.variables import IntVariable, UnicodeVariable
 
@@ -75,6 +75,13 @@
         result = connection.execute("SELECT @@character_set_client")
         self.assertEquals(result.get_one(), ("ascii",))
 
+    def test_compile_random(self):
+        """Test that Random() compiles to RAND() with MySQL"""
+        expr = Random()
+        state = State()
+        statement = compile(expr, state)
+        self.assertEquals(statement, "RAND()")
+
     def test_get_insert_identity(self):
         # Primary keys are filled in during execute() for MySQL
         pass
 
=== modified file 'tests/expr.py'
--- tests/expr.py	2009-07-23 22:47:10 +0000
+++ tests/expr.py	2009-08-13 20:21:08 +0000
@@ -165,6 +165,11 @@
         self.assertEquals(expr.name, "myfunc")
         self.assertEquals(expr.args, (elem1, elem2))
 
+    def test_random(self):
+        expr = Random()
+        self.assertEquals(expr.name, "RANDOM")
+        self.assertEquals(expr.args, ())
+
     def test_like(self):
         expr = Like(elem1, elem2)
         self.assertEquals(expr.expr1, elem1)
 
=== modified file 'tests/store/base.py'
--- tests/store/base.py	2009-07-31 01:53:08 +0000
+++ tests/store/base.py	2009-08-13 20:21:08 +0000
@@ -24,14 +24,20 @@
 import operator
 import weakref
 
+from storm import Undef
 from storm.references import Reference, ReferenceSet, Proxy
 from storm.database import Result
 from storm.properties import Int, Float, RawStr, Unicode, Property, Pickle
 from storm.properties import PropertyPublisherMeta, Decimal
 from storm.variables import PickleVariable
 from storm.expr import (
+<<<<<<< TREE
     Asc, Desc, Select, Func, LeftJoin, SQL, Count, Sum, Avg, And, Or, Eq,
     Lower)
+=======
+    Asc, Desc, Select, Func, LeftJoin, SQL, Count, Sum, Avg, And, Or, Eq,
+    Random)
+>>>>>>> MERGE-SOURCE
 from storm.variables import Variable, UnicodeVariable, IntVariable
 from storm.info import get_obj_info, ClassAlias
 from storm.exceptions import *
@@ -5484,6 +5490,45 @@
                     " (ensure your database was created with CREATE DATABASE"
                     " ... CHARACTER SET utf8)")
 
+    def test_randomise_order(self):
+        self.store.set_randomise_order(True)
+        # With no order specified, Random() is used as the ordering.
+        result = self.store.find(Foo)
+        select = result._get_select()
+        self.assertNotEquals(select.order_by, Undef)
+        self.assertEquals(len(select.order_by), 1)
+        self.assertTrue(isinstance(select.order_by[0], Random))
+        # If the result already has an ordering, Random() is appended
+        result.order_by(Foo.title, Foo.id)
+        select = result._get_select()
+        self.assertNotEquals(select.order_by, Undef)
+        self.assertEquals(len(select.order_by), 3)
+        self.assertEquals(select.order_by[0].table, Foo)
+        self.assertEquals(select.order_by[0].name, 'title')
+        self.assertEquals(select.order_by[1].table, Foo)
+        self.assertEquals(select.order_by[1].name, 'id')
+        self.assertTrue(isinstance(select.order_by[2], Random))
+
+    def test_randomise_order_distinct(self):
+        self.store.set_randomise_order(True)
+        result = self.store.find(Foo)
+        result.config(distinct=True)
+        names = sorted(foo.title for foo in result)
+        self.assertEquals(names, ['Title 10', 'Title 20', 'Title 30'])
+
+    def test_randomise_order_count(self):
+        self.store.set_randomise_order(True)
+        result = self.store.find(Foo)
+        self.assertEquals(result.count(), 3)
+
+    def test_randomise_order_union(self):
+        self.store.set_randomise_order(True)
+        result1 = self.store.find(Foo, Foo.id < 20)
+        result2 = self.store.find(Foo, Foo.id >= 20)
+        result = result1.union(result2)
+        names = sorted(foo.title for foo in result)
+        self.assertEquals(names, ['Title 10', 'Title 20', 'Title 30'])
+
     def test_creation_order_is_preserved_when_possible(self):
         foos = [self.store.add(Foo()) for i in range(10)]
         self.store.flush()