summaryrefslogtreecommitdiff
path: root/ext/librethinkdbxx/test/upstream/transform/array.yaml
diff options
context:
space:
mode:
Diffstat (limited to 'ext/librethinkdbxx/test/upstream/transform/array.yaml')
-rw-r--r--ext/librethinkdbxx/test/upstream/transform/array.yaml303
1 files changed, 303 insertions, 0 deletions
diff --git a/ext/librethinkdbxx/test/upstream/transform/array.yaml b/ext/librethinkdbxx/test/upstream/transform/array.yaml
new file mode 100644
index 00000000..0f95b360
--- /dev/null
+++ b/ext/librethinkdbxx/test/upstream/transform/array.yaml
@@ -0,0 +1,303 @@
+desc: Tests manipulation operations on arrays
+tests:
+
+ # Define a sequence to work with
+ - def: arr = r.expr([1, 2, 3])
+ - def: dupe_arr = r.expr([1, 1, 2, 3])
+ - def: objArr = r.expr([{'a':1, 'b':'a'}, {'a':2, 'b':'b'}, {'a':3, 'b':'c'}])
+ - def: nestedObjArr = r.expr([{'a':1, 'b':{'c':1}}, {'a':2, 'b':{'c':2}}, {'a':3, 'b':{'c':3}}])
+
+ ## Append
+
+ - cd: arr.append(4)
+ ot: [1,2,3,4]
+ - cd: arr.append('a')
+ ot: [1,2,3,'a']
+
+ ## Prepend
+
+ - cd: arr.prepend(0)
+ ot: [0,1,2,3]
+ - cd: arr.prepend('a')
+ ot: ['a',1,2,3]
+
+ ## Difference
+
+ - cd: arr.difference([1,2,2])
+ ot: [3]
+ - cd: arr.difference([])
+ ot: [1,2,3]
+ - cd: arr.difference(["foo", "bar"])
+ ot: [1,2,3]
+
+ ## Set operations
+ - cd: dupe_arr.set_insert(1)
+ ot: [1,2,3]
+ - cd: dupe_arr.set_insert(4)
+ ot: [1,2,3,4]
+
+ - cd: dupe_arr.set_union([3,4,5,5])
+ ot: [1,2,3,4,5]
+ - cd: dupe_arr.set_union([5,6])
+ ot: [1,2,3,5,6]
+
+ - cd: dupe_arr.set_intersection([1,1,1,2,2])
+ ot: [1,2]
+ - cd: dupe_arr.set_intersection(["foo"])
+ ot: []
+
+ - cd: dupe_arr.set_difference([1,1,1,10])
+ ot: [2,3]
+ - cd: dupe_arr.set_difference([2])
+ ot: [1,3]
+
+ ## Slice
+
+ # Python uses the slice syntax
+ - py:
+ - arr[1:3]
+ - arr.slice(1, 3)
+ - arr.slice(1, 2, right_bound='closed')
+ js:
+ - arr.slice(1,3)
+ - arr.slice(1, 2, {right_bound:'closed'})
+ rb:
+ - arr[(1..2)]
+ - arr[(1...3)]
+ - arr.slice(1, 2, :right_bound => 'closed')
+ ot: [2, 3]
+
+ # One ended slices
+ - py:
+ - arr[:2]
+ - arr.slice(0,2)
+ js: arr.slice(0,2)
+ rb:
+ - arr[(0..1)]
+ - arr[(0...2)]
+ - arr.slice(0,2)
+ ot: [1,2]
+ - py:
+ - arr[1:]
+ - arr.slice(1)
+ js: arr.slice(1)
+ rb: arr.slice(1)
+ ot: [2,3]
+
+ # Negative indicies
+ # Python 2.x doesn't handle negative indicies properly
+ - cd: arr.slice(-2, -1)
+ rb: arr[(-2...-1)]
+ ot: [2]
+
+ ## Skip
+
+ - cd: arr.skip(1)
+ ot: [2,3]
+ - cd: arr.skip(2)
+ ot: [3]
+ - cd: arr.skip(12)
+ ot: []
+
+ ## Limit
+
+ - cd: arr.limit(2)
+ ot: [1,2]
+ - cd: arr.limit(0)
+ ot: []
+ - cd: arr.limit(12)
+ ot: [1,2,3]
+
+ ## Pluck
+
+ - cd: objArr.pluck('a', 'b')
+ ot: [{'a':1, 'b':'a'}, {'a':2, 'b':'b'}, {'a':3, 'b':'c'}]
+ - cd: objArr.pluck('a')
+ ot: [{'a':1}, {'a':2}, {'a':3}]
+ - cd: objArr.pluck()
+ ot: [{}, {}, {}]
+
+ ## With_Fields
+ - def: wftst = objArr.union(objArr.pluck('a')).union(objArr.pluck('b')).union([{'a':null}])
+ - cd: wftst.with_fields('a')
+ ot: ([{'a':1},{'a':2},{'a':3},{'a':1},{'a':2},{'a':3}])
+ - cd: wftst.with_fields('b')
+ ot: ([{'b':'a'},{'b':'b'},{'b':'c'},{'b':'a'},{'b':'b'},{'b':'c'}])
+ - cd: wftst.with_fields('a', 'b')
+ ot: ([{'a':1,'b':'a'},{'a':2,'b':'b'},{'a':3,'b':'c'}])
+ - cd: wftst.with_fields()
+ ot: [{}, {}, {}, {}, {}, {}, {}, {}, {}, {}]
+
+ - def: wftst2 = nestedObjArr.union(objArr.pluck({'b':'missing'})).union(nestedObjArr.pluck({'b':'c'}))
+ - cd: wftst2.with_fields({'b':'c'})
+ ot: ([{'b':{'c':1}}, {'b':{'c':2}}, {'b':{'c':3}}, {'b':{'c':1}}, {'b':{'c':2}}, {'b':{'c':3}}])
+
+ - cd: wftst.with_fields(1)
+ ot: err("ReqlQueryLogicError", "Invalid path argument `1`.", [])
+ - cd: r.expr(1).with_fields()
+ ot: err("ReqlQueryLogicError", "Cannot perform has_fields on a non-object non-sequence `1`.", [])
+
+ ## Without
+
+ - cd: objArr.without('a', 'b')
+ ot: [{}, {}, {}]
+ - cd: objArr.without('a')
+ ot: [{'b':'a'}, {'b':'b'}, {'b':'c'}]
+ - cd: objArr.without()
+ ot: [{'a':1, 'b':'a'}, {'a':2, 'b':'b'}, {'a':3, 'b':'c'}]
+
+ ## Map
+
+ - py: arr.map(lambda v: v + 1)
+ js: arr.map(function(v) { return v.add(1); })
+ rb: arr.map{ |v| v + 1 }
+ ot: [2,3,4]
+ #- py: objArr.map(r.row['b'])
+ # js: objArr.map(r.row('b'))
+ # ot: ['a', 'b', 'c']
+
+ ## Reduce
+
+ - py: arr.reduce(lambda a, b: a + b)
+ js: arr.reduce(function(a,b) { return a.add(b); })
+ rb: arr.reduce{ |a, b| a + b }
+ ot: 6
+
+ - py: arr.reduce(lambda a, b:a + b)
+ js: arr.reduce(function(a,b) { return a.add(b); })
+ rb: arr.reduce(){ |a, b| a + b }
+ ot: 6
+
+ - py: arr.union(arr).reduce(lambda a, b: a + b)
+ js: arr.union(arr).reduce(function(a,b) { return a.add(b); })
+ rb: arr.union(arr).reduce{ |a, b| a + b }
+ ot: 12
+
+ - py: arr.union(arr).reduce(lambda a, b:a + b)
+ js: arr.union(arr).reduce(function(a,b) { return a.add(b); })
+ rb: arr.union(arr).reduce(){ |a, b| a + b }
+ ot: 12
+
+ ## Filter
+
+ - py: objArr.filter(lambda row: row['b'] == 'b')
+ js: objArr.filter(function(row) { return row('b').eq('b'); })
+ rb: objArr.filter{ |row| row[:b].eq 'b' }
+ ot: [{'a':2, 'b':'b'}]
+
+ ## ConcatMap
+
+ - py: arr.concat_map(lambda v: [1,2])
+ js: arr.concatMap(function(v) { return [1,2]; })
+ rb: arr.concat_map{ |v| [1,2] }
+ ot: [1,2,1,2,1,2]
+ - py: arr.concat_map(lambda v: [{'v':v}, {'v2':v + 1}])
+ js: arr.concatMap(function(v) { return [{'v':v}, {'v2':v.add(1)}]; })
+ rb: arr.concat_map{ |v| [{:v => v}, {:v2 => v + 1}] }
+ ot: [{'v':1}, {'v2':2}, {'v':2}, {'v2':3}, {'v':3}, {'v2':4}]
+
+ ## OrderBy
+
+ - cd: objArr.order_by('b')
+ rb: objArr.order_by :b
+ ot: [{'a':1, 'b':'a'}, {'a':2, 'b':'b'}, {'a':3, 'b':'c'}]
+
+ - cd: objArr.order_by(r.desc('b'))
+ ot: [{'a':3, 'b':'c'}, {'a':2, 'b':'b'}, {'a':1, 'b':'a'}]
+
+ - cd: r.expr([{'-a':1},{'-a':2}]).order_by('-a')
+ rb: r.expr([{ '-a' => 1}, {'-a' => 2}]).order_by('-a')
+ ot:
+ cd: [{'-a':1},{'-a':2}]
+ rb: [{'-a'=>1},{'-a'=>2}]
+
+ ## Distinct
+
+ - cd: r.expr([1,1,2,2,2,3,4]).distinct()
+ ot: [1,2,3,4]
+
+ ## Count
+
+ - cd: arr.count()
+ ot: 3
+ cd: objArr.count()
+ ot: 3
+
+ ## Union
+
+ - cd: arr.union(objArr)
+ ot: [1, 2, 3, {'a':1, 'b':'a'}, {'a':2, 'b':'b'}, {'a':3, 'b':'c'}]
+
+ ## Nth
+
+ - cd:
+ - arr[1]
+ - arr.nth(1)
+ js: arr.nth(1)
+ ot: 2
+ - py: arr[0]
+ rb: arr[0]
+ js: arr.nth(0)
+ ot: 1
+
+ ## Is Empty
+
+ - cd: r.expr([]).is_empty()
+ ot: true
+ - cd: arr.is_empty()
+ ot: false
+
+ ## Contains
+ - cd: arr.contains(2)
+ ot: true
+ - cd: arr.contains(2, 3)
+ ot: true
+ - cd: arr.contains(4)
+ ot: false
+ - cd: arr.contains(2, 4)
+ ot: false
+ - cd: arr.contains(2, 2)
+ ot: false
+ - cd: arr.union(arr).contains(2, 2)
+ ot: true
+
+ - cd: arr.contains{|x| x.eq(2)}
+ py: arr.contains(lambda x:x == 2)
+ js: arr.contains(function(x){return x.eq(2);})
+ ot: true
+ - cd: arr.contains(lambda {|x| x.eq(2)}, lambda {|x| x.eq(3)})
+ py: arr.contains(lambda x:x == 2, lambda x:x==3)
+ js: arr.contains(function(x){return x.eq(2);}, function(x){return x.eq(3);})
+ ot: true
+ - cd: arr.contains{|x| x.eq(4)}
+ py: arr.contains(lambda x:x == 4)
+ js: arr.contains(function(x){return x.eq(4);})
+ ot: false
+ - cd: arr.contains(lambda {|x| x.eq(2)}, lambda {|x| x.eq(4)})
+ py: arr.contains(lambda x:x == 2, lambda x:x==4)
+ js: arr.contains(function(x){return x.eq(2);}, function(x){return x.eq(4);})
+ ot: false
+ - cd: arr.contains(lambda {|x| x.eq(2)}, lambda {|x| x.eq(2)})
+ py: arr.contains(lambda x:x == 2, lambda x:x==2)
+ js: arr.contains(function(x){return x.eq(2);}, function(x){return x.eq(2);})
+ ot: false
+ - cd: arr.union(arr).contains(lambda {|x| x.eq(2)}, lambda {|x| x.eq(2)})
+ py: arr.union(arr).contains(lambda x:x == 2, lambda x:x==2)
+ js: arr.union(arr).contains(function(x){return x.eq(2);}, function(x){return x.eq(2);})
+ ot: true
+
+ ## Get Field
+ - cd: r.expr([{'a':1},{'b':2},{'a':3,'c':4}])['a']
+ js: r.expr([{'a':1},{'b':2},{'a':3,'c':4}])('a')
+ ot: [1, 3]
+ - cd: r.expr([{'a':1},'a',{'b':2},{'a':3,'c':4}])['a']
+ js: r.expr([{'a':1},'a',{'b':2},{'a':3,'c':4}])('a')
+ ot: err("ReqlQueryLogicError", "Cannot perform bracket on a non-object non-sequence `\"a\"`.", [])
+
+ ## Grouped Map Reduce
+
+ ## Group by
+
+ ## Inner Join
+
+ ## Outer Join
generated by cgit v1.2.3 (git 2.39.1) at 2025-03-03 23:10:04 +0000