"SORT by nosort" (skip sorting) respect sorted set ordering.

[redis.git] / tests / unit / sort.tcl

diff --git a/tests/unit/sort.tcl b/tests/unit/sort.tcl
index 462463517cc8884546e9ac5839d9539f67e556fa..6c5644a798da85580f543e470a286bfbba36fd26 100644 (file)
--- a/tests/unit/sort.tcl
+++ b/tests/unit/sort.tcl
@@ -37,18 +37,25 @@ start_server {
 
     foreach {num cmd enc title} {
         16 lpush ziplist "Ziplist"
 
     foreach {num cmd enc title} {
         16 lpush ziplist "Ziplist"

-        64 lpush linkedlist "Linked list"
-        64 sadd hashtable "Hash table"
+        1000 lpush linkedlist "Linked list"
+        10000 lpush linkedlist "Big Linked list"
+        16 sadd intset "Intset"
+        1000 sadd hashtable "Hash table"
+        10000 sadd hashtable "Big Hash table"

     } {
         set result [create_random_dataset $num $cmd]
         assert_encoding $enc tosort
 
         test "$title: SORT BY key" {
     } {
         set result [create_random_dataset $num $cmd]
         assert_encoding $enc tosort
 
         test "$title: SORT BY key" {

-            assert_equal $result [r sort tosort {BY weight_*}]
+            assert_equal $result [r sort tosort BY weight_*]
+        }
+
+        test "$title: SORT BY key with limit" {
+            assert_equal [lrange $result 5 9] [r sort tosort BY weight_* LIMIT 5 5]

         }
 
         test "$title: SORT BY hash field" {
         }
 
         test "$title: SORT BY hash field" {

-            assert_equal $result [r sort tosort {BY wobj_*->weight}]
+            assert_equal $result [r sort tosort BY wobj_*->weight]

         }
     }
 
         }
     }
 


@@ -75,21 +82,21 @@ start_server {
     }
 
     test "SORT BY key STORE" {
     }
 
     test "SORT BY key STORE" {

-        r sort tosort {BY weight_*} store sort-res
+        r sort tosort BY weight_* store sort-res

         assert_equal $result [r lrange sort-res 0 -1]
         assert_equal 16 [r llen sort-res]
         assert_encoding ziplist sort-res
     }
 
     test "SORT BY hash field STORE" {
         assert_equal $result [r lrange sort-res 0 -1]
         assert_equal 16 [r llen sort-res]
         assert_encoding ziplist sort-res
     }
 
     test "SORT BY hash field STORE" {

-        r sort tosort {BY wobj_*->weight} store sort-res
+        r sort tosort BY wobj_*->weight store sort-res

         assert_equal $result [r lrange sort-res 0 -1]
         assert_equal 16 [r llen sort-res]
         assert_encoding ziplist sort-res
     }
 
     test "SORT DESC" {
         assert_equal $result [r lrange sort-res 0 -1]
         assert_equal 16 [r llen sort-res]
         assert_encoding ziplist sort-res
     }
 
     test "SORT DESC" {

-        assert_equal [lsort -decreasing -integer $result] [r sort tosort {DESC}]
+        assert_equal [lsort -decreasing -integer $result] [r sort tosort DESC]

     }
 
     test "SORT ALPHA against integer encoded strings" {
     }
 
     test "SORT ALPHA against integer encoded strings" {


@@ -111,6 +118,47 @@ start_server {
         r sort zset alpha desc
     } {e d c b a}
 
         r sort zset alpha desc
     } {e d c b a}
 

+    test "SORT sorted set BY nosort should retain ordering" {
+        r del zset
+        r zadd zset 1 a
+        r zadd zset 5 b
+        r zadd zset 2 c
+        r zadd zset 10 d
+        r zadd zset 3 e
+        r multi
+        r sort zset by nosort asc
+        r sort zset by nosort desc
+        r exec
+    } {{a c e b d} {d b e c a}}
+
+    test "SORT sorted set BY nosort + LIMIT" {
+        r del zset
+        r zadd zset 1 a
+        r zadd zset 5 b
+        r zadd zset 2 c
+        r zadd zset 10 d
+        r zadd zset 3 e
+        assert_equal [r sort zset by nosort asc limit 0 1] {a}
+        assert_equal [r sort zset by nosort desc limit 0 1] {d}
+        assert_equal [r sort zset by nosort asc limit 0 2] {a c}
+        assert_equal [r sort zset by nosort desc limit 0 2] {d b}
+        assert_equal [r sort zset by nosort limit 5 10] {}
+        assert_equal [r sort zset by nosort limit -10 100] {a c e b d}
+    }
+
+    test "SORT sorted set BY nosort works as expected from scripts" {
+        r del zset
+        r zadd zset 1 a
+        r zadd zset 5 b
+        r zadd zset 2 c
+        r zadd zset 10 d
+        r zadd zset 3 e
+        r eval {
+            return {redis.call('sort','zset','by','nosort','asc'),
+                    redis.call('sort','zset','by','nosort','desc')}
+        } 0
+    } {{a c e b d} {d b e c a}}
+

     test "SORT sorted set: +inf and -inf handling" {
         r del zset
         r zadd zset -100 a
     test "SORT sorted set: +inf and -inf handling" {
         r del zset
         r zadd zset -100 a


@@ -131,6 +179,65 @@ start_server {
         assert_equal [lsort -real $floats] [r sort mylist]
     }
 
         assert_equal [lsort -real $floats] [r sort mylist]
     }
 

+    test "SORT with STORE returns zero if result is empty (github isse 224)" {
+        r flushdb
+        r sort foo store bar
+    } {0}
+
+    test "SORT with STORE does not create empty lists (github issue 224)" {
+        r flushdb
+        r lpush foo bar
+        r sort foo alpha limit 10 10 store zap
+        r exists zap
+    } {0}
+
+    test "SORT with STORE removes key if result is empty (github issue 227)" {
+        r flushdb
+        r lpush foo bar
+        r sort emptylist store foo
+        r exists foo
+    } {0}
+
+    test "SORT with BY <constant> and STORE should still order output" {
+        r del myset mylist
+        r sadd myset a b c d e f g h i l m n o p q r s t u v z aa aaa azz
+        r sort myset alpha by _ store mylist
+        r lrange mylist 0 -1
+    } {a aa aaa azz b c d e f g h i l m n o p q r s t u v z}
+
+    test "SORT will complain with numerical sorting and bad doubles (1)" {
+        r del myset
+        r sadd myset 1 2 3 4 not-a-double
+        set e {}
+        catch {r sort myset} e
+        set e
+    } {*ERR*double*}
+
+    test "SORT will complain with numerical sorting and bad doubles (2)" {
+        r del myset
+        r sadd myset 1 2 3 4
+        r mset score:1 10 score:2 20 score:3 30 score:4 not-a-double
+        set e {}
+        catch {r sort myset by score:*} e
+        set e
+    } {*ERR*double*}
+
+    test "SORT BY sub-sorts lexicographically if score is the same" {
+        r del myset
+        r sadd myset a b c d e f g h i l m n o p q r s t u v z aa aaa azz
+        foreach ele {a aa aaa azz b c d e f g h i l m n o p q r s t u v z} {
+            set score:$ele 100
+        }
+        r sort myset by score:*
+    } {a aa aaa azz b c d e f g h i l m n o p q r s t u v z}
+
+    test "SORT GET with pattern ending with just -> does not get hash field" {
+        r del mylist
+        r lpush mylist a
+        r set x:a-> 100
+        r sort mylist by num get x:*->
+    } {100}
+

     tags {"slow"} {
         set num 100
         set res [create_random_dataset $num lpush]
     tags {"slow"} {
         set num 100
         set res [create_random_dataset $num lpush]


@@ -138,41 +245,49 @@ start_server {
         test "SORT speed, $num element list BY key, 100 times" {
             set start [clock clicks -milliseconds]
             for {set i 0} {$i < 100} {incr i} {
         test "SORT speed, $num element list BY key, 100 times" {
             set start [clock clicks -milliseconds]
             for {set i 0} {$i < 100} {incr i} {

-                set sorted [r sort tosort {BY weight_* LIMIT 0 10}]
+                set sorted [r sort tosort BY weight_* LIMIT 0 10]

             }
             set elapsed [expr [clock clicks -milliseconds]-$start]
             }
             set elapsed [expr [clock clicks -milliseconds]-$start]

-            puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
-            flush stdout
+            if {$::verbose} {
+                puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
+                flush stdout
+            }

         }
 
         test "SORT speed, $num element list BY hash field, 100 times" {
             set start [clock clicks -milliseconds]
             for {set i 0} {$i < 100} {incr i} {
         }
 
         test "SORT speed, $num element list BY hash field, 100 times" {
             set start [clock clicks -milliseconds]
             for {set i 0} {$i < 100} {incr i} {

-                set sorted [r sort tosort {BY wobj_*->weight LIMIT 0 10}]
+                set sorted [r sort tosort BY wobj_*->weight LIMIT 0 10]

             }
             set elapsed [expr [clock clicks -milliseconds]-$start]
             }
             set elapsed [expr [clock clicks -milliseconds]-$start]

-            puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
-            flush stdout
+            if {$::verbose} {
+                puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
+                flush stdout
+            }

         }
 
         test "SORT speed, $num element list directly, 100 times" {
             set start [clock clicks -milliseconds]
             for {set i 0} {$i < 100} {incr i} {
         }
 
         test "SORT speed, $num element list directly, 100 times" {
             set start [clock clicks -milliseconds]
             for {set i 0} {$i < 100} {incr i} {

-                set sorted [r sort tosort {LIMIT 0 10}]
+                set sorted [r sort tosort LIMIT 0 10]

             }
             set elapsed [expr [clock clicks -milliseconds]-$start]
             }
             set elapsed [expr [clock clicks -milliseconds]-$start]

-            puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
-            flush stdout
+            if {$::verbose} {
+                puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
+                flush stdout
+            }

         }
 
         test "SORT speed, $num element list BY <const>, 100 times" {
             set start [clock clicks -milliseconds]
             for {set i 0} {$i < 100} {incr i} {
         }
 
         test "SORT speed, $num element list BY <const>, 100 times" {
             set start [clock clicks -milliseconds]
             for {set i 0} {$i < 100} {incr i} {

-                set sorted [r sort tosort {BY nokey LIMIT 0 10}]
+                set sorted [r sort tosort BY nokey LIMIT 0 10]

             }
             set elapsed [expr [clock clicks -milliseconds]-$start]
             }
             set elapsed [expr [clock clicks -milliseconds]-$start]

-            puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
-            flush stdout
+            if {$::verbose} {
+                puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
+                flush stdout
+            }

         }
     }
 }
         }
     }
 }