RethinkDB native connector work, minor fixes.

5 files changed, 1572 insertions, 0 deletions

diff --git a/ext/librethinkdbxx/test/upstream/sindex/api.yaml b/ext/librethinkdbxx/test/upstream/sindex/api.yaml
new file mode 100644
index 00000000..c27a538b
--- /dev/null
+++ b/ext/librethinkdbxx/test/upstream/sindex/api.yaml
@@ -0,0 +1,1348 @@
+desc: sindex api (#602)
+table_variable_name: tbl
+tests:
+
+  - def: rows = [{'id':0, 'a':0, 'b':0, 'c':0, 'm':[1,2,3]},
+                 {'id':1, 'a':0, 'b':0, 'c':0, 'm':[4,5,6]},
+                 {'id':2, 'a':0, 'b':0, 'c':1, 'm':7},
+                 {'id':3, 'a':0, 'b':1, 'c':1, 'm':[10,11,12]},
+                 {'id':4, 'a':4, 'b':4, 'c':4, 'm':[14,15,16]}]
+
+  - cd: tbl.insert([{'id':0, 'a':0, 'b':0, 'c':0, 'm':[1,2,3]},
+                    {'id':1, 'a':0, 'b':0, 'c':0, 'm':[4,5,6]},
+                    {'id':2, 'a':0, 'b':0, 'c':1, 'm':7},
+                    {'id':3, 'a':0, 'b':1, 'c':1, 'm':[10,11,12]}])
+    ot: ({'deleted':0,'inserted':4,'skipped':0,'errors':0,'replaced':0,'unchanged':0})
+
+  # Test index renaming
+  - py: tbl.index_create('rename-foo', r.row['b'])
+    js: tbl.index_create('rename-foo', r.row('b'))
+    rb: tbl.index_create('rename-foo') {|x| x[:b]}
+    ot: {'created':1}
+
+  - py: tbl.index_create('rename-bar', r.row['c'])
+    js: tbl.index_create('rename-bar', r.row('c'))
+    rb: tbl.index_create('rename-bar') {|x| x[:c]}
+    ot: {'created':1}
+
+  - cd: tbl.index_rename('rename-foo','rename-bar')
+    ot: err_regex('ReqlOpFailedError','Index `rename-foo` does not exist or index `rename-bar` already exists on table `[a-zA-Z0-9_]+.[a-zA-Z0-9_]+`[.]',[])
+
+  - cd: tbl.index_rename('rename-fake','rename-stuff')
+    ot: err_regex('ReqlOpFailedError','Index `rename-fake` does not exist or index `rename-stuff` already exists on table `[a-zA-Z0-9_]+.[a-zA-Z0-9_]+`[.]',[])
+
+  - cd: tbl.index_rename('id','rename-stuff')
+    ot: err('ReqlQueryLogicError','Index name conflict:'+' `id` is the name of the primary key.',[])
+
+  - cd: tbl.index_rename('rename-stuff','id')
+    ot: err('ReqlQueryLogicError','Index name conflict:'+' `id` is the name of the primary key.',[])
+
+  - cd: tbl.index_rename('rename-foo','rename-foo')
+    ot: {'renamed':0}
+
+  - cd: tbl.index_rename('rename-foo','rename-foo',overwrite=True)
+    js: tbl.index_rename('rename-foo','rename-foo',{overwrite:true})
+    rb: tbl.index_rename('rename-foo','rename-foo',:overwrite => true)
+    ot: {'renamed':0}
+
+  - py: tbl.index_rename('rename-foo','rename-bar',overwrite=True)
+    js: tbl.index_rename('rename-foo','rename-bar',{overwrite:true})
+    rb: tbl.index_rename('rename-foo','rename-bar',:overwrite => true)
+    ot: {'renamed':1}
+
+  - py: tbl.index_rename('rename-bar','rename-stuff',overwrite=True)
+    js: tbl.index_rename('rename-bar','rename-stuff',{overwrite:true})
+    rb: tbl.index_rename('rename-bar','rename-stuff',:overwrite => true)
+    ot: {'renamed':1}
+
+  - cd: tbl.index_rename('rename-stuff','rename-last')
+    ot: {'renamed':1}
+
+  - rb: tbl.index_create('minval'){|x| r.minval}
+    py: tbl.index_create('minval', lambda:r.minval)
+    js: tbl.index_create('minval', function(row){ return r.minval; })
+    ot: {'created':1}
+
+  - rb: tbl.index_create('maxval'){|x| r.maxval}
+    py: tbl.index_create('maxval', lambda:r.maxval)
+    js: tbl.index_create('maxval', function(row){ return r.maxval; })
+    ot: {'created':1}
+
+  - cd: tbl.index_wait('rename-last', 'minval', 'maxval').pluck('index', 'ready')
+    ot: bag([{'index':'rename-last','ready':true},
+             {'index':'minval','ready':true},
+             {'index':'maxval','ready':true}])
+
+  - py: tbl.get_all(0, index='rename-last').count()
+    js: tbl.get_all(0, {index:'rename-last'}).count()
+    rb: tbl.get_all(0, :index => 'rename-last').count()
+    ot: 3
+
+  # minval and maxval should error, so the indexes should be empty
+  - py: tbl.get_all(r.minval, index='minval').count()
+    js: tbl.get_all(r.minval, {index:'minval'}).count()
+    rb: tbl.get_all(r.minval, :index => 'minval').count()
+    ot: 0
+
+  - py: tbl.get_all(r.maxval, index='maxval').count()
+    js: tbl.get_all(r.maxval, {index:'maxval'}).count()
+    rb: tbl.get_all(r.maxval, :index => 'maxval').count()
+    ot: 0
+
+  - py: tbl.between(r.minval, r.maxval, index='minval').count()
+    js: tbl.between(r.minval, r.maxval, {index:'minval'}).count()
+    rb: tbl.between(r.minval, r.maxval, :index => 'minval').count()
+    ot: 0
+
+  - cd: tbl.index_create('rename-last-dup', tbl.index_status('rename-last').nth(0).get_field('function'))
+    ot: {'created':1}
+
+  - cd: tbl.index_wait('rename-last-dup').pluck('index', 'ready')
+    ot: [{'index':'rename-last-dup','ready':true}]
+
+  - py: tbl.get_all(0, index='rename-last-dup').count()
+    js: tbl.get_all(0, {index:'rename-last-dup'}).count()
+    rb: tbl.get_all(0, :index => 'rename-last-dup').count()
+    ot: 3
+
+  - cd:
+      - tbl.index_drop('rename-last-dup')
+      - tbl.index_drop('minval')
+      - tbl.index_drop('maxval')
+    ot: {'dropped':1}
+
+  - cd: tbl.index_list()
+    ot: ['rename-last']
+
+  - cd: tbl.index_drop('rename-last')
+    ot: {'dropped':1}
+
+  - rb: tbl.index_create('ai') {|row| row[:a]}
+    py: tbl.index_create('ai', r.row['a'])
+    js: tbl.indexCreate('ai', r.row('a'))
+    ot: {'created':1}
+  - rb: tbl.index_create('ai') {|row| row[:a]}
+    py: tbl.index_create('ai', r.row['a'])
+    js: tbl.indexCreate('ai', r.row('a'))
+    ot: err_regex("ReqlOpFailedError", "Index `ai` already exists on table `[a-zA-Z0-9_]+.[a-zA-Z0-9_]+`[.]", [])
+  - rb: tbl.index_create('bi') {|row| row[:b]}
+    py: tbl.index_create('bi', r.row['b'])
+    js: tbl.indexCreate('bi', r.row('b'))
+    ot: {'created':1}
+  - rb: tbl.index_create('ci') {|row| row[:c]}
+    py: tbl.index_create('ci', r.row['c'])
+    js: tbl.indexCreate('ci', r.row('c'))
+    ot: {'created':1}
+  - rb: tbl.index_create('idi') {|row| row[:id]}
+    py: tbl.index_create('idi', r.row['id'])
+    js: tbl.indexCreate('idi', r.row('id'))
+    ot: {'created':1}
+  - rb: tbl.index_create('kdi') {|row| [row[:id]]}
+    py: tbl.index_create('kdi', [r.row['id']])
+    js: tbl.indexCreate('kdi', [r.row('id')])
+    ot: {'created':1}
+  - rb: tbl.index_create('mi', :multi => True) {|row| row[:m]}
+    py: tbl.index_create('mi', r.row['m'], multi=True)
+    js: tbl.indexCreate('mi', r.row('m'), {"multi":true})
+    ot: {'created':1}
+  - rb: tbl.index_create('brokeni') {|row| row[:broken]}
+    py: tbl.index_create('brokeni', r.row['broken'])
+    js: tbl.indexCreate('brokeni', r.row('broken'))
+    ot: {'created':1}
+
+  - cd: tbl.index_wait().pluck('index', 'ready')
+
+  - cd: tbl.get(true)
+    py: tbl.get(True)
+    # No error
+
+  - cd: tbl.get([])
+    ot: null
+  - cd: tbl.get(-1)
+    ot: null
+  - rb: tbl.get(1)[:id]
+    py: tbl.get(1)['id']
+    js: tbl.get(1)('id')
+    ot: 1
+  - rb: tbl.get(1).typeof
+    py: tbl.get(1).type_of()
+    js: tbl.get(1).typeOf()
+    ot: 'SELECTION<OBJECT>'
+  - rb: tbl.get(1).update{null}
+    py: tbl.get(1).update(lambda x:null)
+    js: tbl.get(1).update(function(x) { return null;})
+    ot: {'replaced':0,'skipped':0,'deleted':0,'unchanged':1,'errors':0,'inserted':0}
+  - rb: tbl.get(1, :ai)
+    cd: tbl.get(1, 'ai')
+    ot: err("ReqlCompileError", "Expected 2 arguments but found 3.", [])
+
+  - rb: tbl.get_all(true, :index => :id)
+    py: tbl.get_all(True, index='id')
+    js: tbl.getAll(true, {index:'id'})
+    # No error
+
+  - rb: tbl.get_all(-1, :index => :id)
+    py: tbl.get_all(-1, index='id')
+    js: tbl.getAll(-1, {index:'id'})
+    ot: []
+  - rb: tbl.get_all(-1)
+    py: tbl.get_all(-1)
+    js: tbl.getAll(-1)
+    ot: []
+  - rb: tbl.get_all([-1])
+    py: tbl.get_all([-1])
+    js: tbl.getAll([-1])
+    ot: []
+  - rb: tbl.get_all(1, :index => :id)[0][:id]
+    py: tbl.get_all(1, index='id')[0]['id']
+    js: tbl.getAll(1, {index:'id'}).nth(0)('id')
+    ot: 1
+  - rb: tbl.get_all(1)[0][:id]
+    py: tbl.get_all(1)[0]['id']
+    js: tbl.getAll(1).nth(0)('id')
+    ot: 1
+  - rb: tbl.get_all(1,2,3, :index => :id).map{|x| x[:id]}.coerce_to("ARRAY")
+    py: tbl.get_all(1,2,3, index='id').map(lambda x:x["id"]).coerce_to("ARRAY")
+    js: tbl.getAll(1,2,3, {index:'id'}).map(function (x) { return x("id"); }).coerce_to("ARRAY")
+    ot: bag([1,2,3])
+  - rb: tbl.get_all(1,2,3).map{|x| x[:id]}.coerce_to("ARRAY")
+    py: tbl.get_all(1,2,3).map(lambda x:x["id"]).coerce_to("ARRAY")
+    js: tbl.getAll(1,2,3).map(function (x) { return x("id"); }).coerce_to("ARRAY")
+    ot: bag([1,2,3])
+  - rb: tbl.get_all(1, :index => :id).typeof
+    py: tbl.get_all(1, index='id').type_of()
+    js: tbl.getAll(1, {index:'id'}).typeOf()
+    ot: 'SELECTION<STREAM>'
+  - rb: tbl.get_all(1).typeof
+    py: tbl.get_all(1).type_of()
+    js: tbl.getAll(1).typeOf()
+    ot: 'SELECTION<STREAM>'
+  - rb: tbl.get_all(1, :index => :id).update{null}
+    py: tbl.get_all(1, index='id').update(lambda x:null)
+    js: tbl.getAll(1, {index:'id'}).update(function(x) { return null; })
+    ot: {'replaced':0,'skipped':0,'deleted':0,'unchanged':1,'errors':0,'inserted':0}
+  - rb: tbl.get_all(1).update{null}
+    py: tbl.get_all(1).update(lambda x:null)
+    js: tbl.getAll(1).update(function(x) { return null; })
+    ot: {'replaced':0,'skipped':0,'deleted':0,'unchanged':1,'errors':0,'inserted':0}
+  - rb: tbl.get_all(1,2,3, :index => :id).update{null}
+    py: tbl.get_all(1,2,3, index='id').update(lambda x:null)
+    js: tbl.getAll(1,2,3, {index:'id'}).update(function(x) { return null; })
+    ot: {'replaced':0,'skipped':0,'deleted':0,'unchanged':3,'errors':0,'inserted':0}
+  - rb: tbl.get_all(1,2,3).update{null}
+    py: tbl.get_all(1,2,3).update(lambda x:null)
+    js: tbl.getAll(1,2,3).update(function(x) { return null; })
+    ot: {'replaced':0,'skipped':0,'deleted':0,'unchanged':3,'errors':0,'inserted':0}
+
+  - rb: tbl.get_all(0, :index => :fake)
+    py: tbl.get_all(0, index='fake')
+    js: tbl.getAll(0, {index:'fake'})
+    ot: err_regex("ReqlOpFailedError", "Index `fake` was not found on table `[a-zA-Z0-9_]+.[a-zA-Z0-9_]+`[.]", [])
+
+  - cd: tbl.get_all(r.point(0, 0))
+    ot: err("ReqlQueryLogicError", "Cannot use a geospatial index with `get_all`. Use `get_intersecting` instead.", [])
+
+  - rb: tbl.get_all(0, :index => false)
+    py: tbl.get_all(0, index=False)
+    js: tbl.getAll(0, {index:false})
+    ot: err("ReqlQueryLogicError", "Expected type STRING but found BOOL.", [])
+
+  - rb: tbl.get_all(true, :index => :id)
+    py: tbl.get_all(True, index='id')
+    js: tbl.getAll(true, {index:'id'})
+    # No error
+
+  - rb: tbl.get_all([], :index => :id)
+    py: tbl.get_all([], index='id')
+    js: tbl.getAll([], {index:'id'})
+    ot: []
+  - rb: tbl.get_all(true, :index => :idi)
+    py: tbl.get_all(True, index='idi')
+    js: tbl.getAll(true, {index:'idi'})
+    # No error
+
+  - rb: tbl.get_all([], :index => :idi)
+    py: tbl.get_all([], index='idi')
+    js: tbl.getAll([], {index:'idi'})
+    ot: []
+
+  - rb: tbl.get_all(1, :index => :id)[0][:id]
+    py: tbl.get_all(1, index='id')[0]['id']
+    js: tbl.getAll(1, {index:'id'}).nth(0)('id')
+    ot: 1
+  - rb: tbl.get_all(1, :index => :idi)[0][:id]
+    py: tbl.get_all(1, index='idi')[0]['id']
+    js: tbl.getAll(1, {index:'idi'}).nth(0)('id')
+    ot: 1
+  - rb: tbl.get_all(1, :index => :ai)
+    py: tbl.get_all(1, index='ai')
+    js: tbl.getAll(1, {index:'ai'})
+    ot: []
+  - rb: tbl.get_all(1, :index => :bi).orderby(:id).map{|x| x[:id]}
+    py: tbl.get_all(1, index='bi').order_by('id').map(lambda x:x['id'])
+    js: tbl.getAll(1, {index:'bi'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [3]
+  - rb: tbl.get_all(1, :index => :bi).orderby(:index => :id).map{|x| x[:id]}
+    py: tbl.get_all(1, index='bi').order_by(index='id').map(lambda x:x['id'])
+    js: tbl.getAll(1, {index:'bi'}).orderBy({index:'id'}).map(function(x) { return x('id'); })
+    ot: err('ReqlQueryLogicError', 'Indexed order_by can only be performed on a TABLE or TABLE_SLICE.', [0])
+  - rb: tbl.get_all(1, :index => :bi).between(1, 1, :index => :id).map{|x| x[:id]}
+    py: tbl.get_all(1, index='bi').between(1, 1, index='id').map(lambda x:x['id'])
+    js: tbl.getAll(1, {index:'bi'}).between(1, 1, {index:'id'}).map(function(x) { return x('id'); })
+    ot: err('ReqlQueryLogicError', 'Expected type TABLE_SLICE but found SELECTION:', [0])
+  - rb: tbl.get_all(1, :index => :ci).orderby(:id).map{|x| x[:id]}
+    py: tbl.get_all(1, index='ci').order_by('id').map(lambda x:x['id'])
+    js: tbl.getAll(1, {index:'ci'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2, 3]
+  - rb: tbl.get_all(1, :index => :ci).typeof
+    py: tbl.get_all(1, index='ci').type_of()
+    js: tbl.getAll(1, {index:'ci'}).typeOf()
+    ot: 'SELECTION<STREAM>'
+  - rb: tbl.get_all(1, :index => :ci).update{null}
+    py: tbl.get_all(1, index='ci').update(lambda x:null)
+    js: tbl.getAll(1, {index:'ci'}).update(function(x) { return null; })
+    ot: {'replaced':0,'skipped':0,'deleted':0,'unchanged':2,'errors':0,'inserted':0}
+  - rb: tbl.get_all(1, :index => :brokeni)
+    py: tbl.get_all(1, index='brokeni')
+    js: tbl.getAll(1, {index:'brokeni'})
+    ot: []
+
+  - rb: tbl.get_all(1, :index => :mi)
+    py: tbl.get_all(1, index='mi')
+    js: tbl.getAll(1, {index:'mi'})
+    ot: [rows[0]]
+
+  - rb: tbl.get_all(2, :index => :mi)
+    py: tbl.get_all(2, index='mi')
+    js: tbl.getAll(2, {index:'mi'})
+    ot: [rows[0]]
+
+  - rb: tbl.get_all(5, :index => :mi)
+    py: tbl.get_all(5, index='mi')
+    js: tbl.getAll(5, {index:'mi'})
+    ot: [rows[1]]
+
+  - rb: tbl.get_all(7, :index => :mi)
+    py: tbl.get_all(7, index='mi')
+    js: tbl.getAll(7, {index:'mi'})
+    ot: [rows[2]]
+
+  - rb: tbl.eq_join(:id, tbl, :index => :fake)
+    py: tbl.eq_join('id', tbl, index='fake')
+    js: tbl.eqJoin('id', tbl, {index:'fake'})
+    ot: err_regex("ReqlOpFailedError", "Index `fake` was not found on table `[a-zA-Z0-9_]+.[a-zA-Z0-9_]+`[.]", [])
+  - rb: tbl.eq_join(:id, tbl, :index => false)
+    py: tbl.eq_join('id', tbl, index=False)
+    js: tbl.eqJoin('id', tbl, {index:false})
+    ot: err("ReqlQueryLogicError", "Expected type STRING but found BOOL.", [])
+
+  - rb: tbl.filter({:id => 1}).eq_join(:id, tbl, :index => :mi)
+    py: tbl.filter({'id':1}).eq_join('id', tbl, index='mi')
+    js: tbl.filter({id:1}).eqJoin('id', tbl, {index:'mi'})
+    ot: [{'left':rows[1],'right':rows[0]}]
+
+  - rb: tbl.filter({:id => 0}).eq_join(:id, tbl)
+    py: tbl.filter({'id':0}).eq_join('id', tbl)
+    js: tbl.filter({'id':0}).eqJoin('id', tbl)
+    ot: [{'left':rows[0],'right':rows[0]}]
+
+  - rb: tbl.filter({:id => 0}).eq_join(lambda{|x| x[:id]}, tbl)
+    py: tbl.filter({'id':0}).eq_join(lambda x:x['id'], tbl)
+    js: tbl.filter({'id':0}).eqJoin(function (x) { return x('id'); }, tbl)
+    ot: [{'left':rows[0],'right':rows[0]}]
+
+  - rb: tbl.filter({:id => 0}).eq_join(:id, tbl, :index => :id)
+    py: tbl.filter({'id':0}).eq_join('id', tbl, index='id')
+    js: tbl.filter({'id':0}).eqJoin('id', tbl, {index:'id'})
+    ot: [{'left':rows[0],'right':rows[0]}]
+
+  - rb: tbl.filter({:id => 0}).eq_join(lambda {|x| x[:id]}, tbl, :index => :id)
+    py: tbl.filter({'id':0}).eq_join(lambda x:x['id'], tbl, index='id')
+    js: tbl.filter({'id':0}).eqJoin(function (x) { return x('id'); }, tbl, {index:'id'})
+    ot: [{'left':rows[0],'right':rows[0]}]
+
+  - rb: tbl.filter({:id => 0}).eq_join(:id, tbl, :index => :idi)
+    py: tbl.filter({'id':0}).eq_join('id', tbl, index='idi')
+    js: tbl.filter({'id':0}).eqJoin('id', tbl, {index:'idi'})
+    ot: [{'left':rows[0],'right':rows[0]}]
+
+  - rb: tbl.filter({:id => 0}).eq_join(lambda {|x| x[:id]}, tbl, :index => :idi)
+    py: tbl.filter({'id':0}).eq_join(lambda x:x['id'], tbl, index='idi')
+    js: tbl.filter({'id':0}).eqJoin(function (x) { return x('id'); }, tbl, {index:'idi'})
+    ot: [{'left':rows[0],'right':rows[0]}]
+
+  - rb: tbl.filter({:id => 0}).eq_join(:id, tbl, :index => :ai).orderby(:right)
+    py: tbl.filter({'id':0}).eq_join('id', tbl, index='ai').order_by('right')
+    js: tbl.filter({'id':0}).eqJoin('id', tbl, {index:'ai'}).orderBy('right')
+    ot: [{'right':rows[0],'left':rows[0]},
+          {'right':rows[1],'left':rows[0]},
+          {'right':rows[2],'left':rows[0]},
+          {'right':rows[3],'left':rows[0]}]
+  - rb: tbl.filter({:id => 0}).eq_join(:id, tbl, :index => :bi).orderby(:right)
+    py: tbl.filter({'id':0}).eq_join('id', tbl, index='bi').order_by('right')
+    js: tbl.filter({'id':0}).eqJoin('id', tbl, {index:'bi'}).orderBy('right')
+    ot: ([{'right':rows[0],'left':rows[0]},
+          {'right':rows[1],'left':rows[0]},
+          {'right':rows[2],'left':rows[0]}])
+  - rb: tbl.filter({:id => 0}).eq_join(:id, tbl, :index => :ci).orderby(:right)
+    py: tbl.filter({'id':0}).eq_join('id', tbl, index='ci').order_by('right')
+    js: tbl.filter({'id':0}).eqJoin('id', tbl, {index:'ci'}).orderBy('right')
+    ot: [{'right':rows[0],'left':rows[0]}, {'right':rows[1],'left':rows[0]}]
+  - rb: tbl.filter({:id => 0}).eq_join(:id, tbl, :index => :brokeni)
+    py: tbl.filter({'id':0}).eq_join('id', tbl, index='brokeni')
+    js: tbl.filter({'id':0}).eqJoin('id', tbl, {index:'brokeni'})
+    ot: []
+
+  - rb: tbl.eq_join(:c, tbl, :index => :bi).orderby(:right, :left)
+    py: tbl.eq_join('c', tbl, index='bi').order_by('right', 'left')
+    js: tbl.eqJoin('c', tbl, {index:'bi'}).orderBy('right', 'left')
+    ot: [{'left':rows[0],'right':rows[0]},
+         {'left':rows[1],'right':rows[0]},
+         {'left':rows[0],'right':rows[1]},
+         {'left':rows[1],'right':rows[1]},
+         {'left':rows[0],'right':rows[2]},
+         {'left':rows[1],'right':rows[2]},
+         {'left':rows[2],'right':rows[3]},
+         {'left':rows[3],'right':rows[3]}]
+
+  - cd: tbl.index_create('id')
+    ot: err("ReqlQueryLogicError", "Index name conflict: `id` is the name of the primary key.", [])
+
+  - cd: tbl.index_create('c')
+    ot: {'created':1}
+  - cd: tbl.index_create('broken')
+    ot: {'created':1}
+
+  - cd: tbl.index_wait('broken')
+
+  - rb: tbl.get_all(1, :index => 'c').orderby(:id).map{|x| x[:id]}
+    py: tbl.get_all(1, index='c').order_by('id').map(lambda x:x['id'])
+    js: tbl.getAll(1, {index:'c'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2, 3]
+  - rb: tbl.get_all(1, :index => 'broken').orderby(:broken).map{|x| x[:id]}
+    py: tbl.get_all(1, index='broken').order_by('broken').map(lambda x:x['id'])
+    js: tbl.getAll(1, {index:'broken'}).orderBy('broken').map(function(x) { return x('id'); })
+    ot: []
+
+  - rb: tbl.index_create('nil') {null}
+    py: tbl.index_create('nil', lambda x:null)
+    js: tbl.indexCreate('nil', function(x) { return null; })
+    ot: {'created':1}
+  - cd: tbl.index_wait().pluck('index', 'ready')
+
+  - rb: tbl.get_all(null, :index => :nil)
+    py: tbl.get_all(null, index='nil')
+    js: tbl.getAll(null, {index:'nil'})
+    ot: err("ReqlNonExistenceError", "Keys cannot be NULL.", [])
+
+  - rb: tbl.insert({:id => 4, :a => 4, :b => 4, :c => 4, :m => [14,15,16]})
+    cd: tbl.insert({'id':4, 'a':4, 'b':4, 'c':4, 'm':[14,15,16]})
+    ot: {'deleted':0,'inserted':1,'skipped':0,'errors':0,'replaced':0,'unchanged':0}
+
+  - def:
+
+  # We test to make sure that the other indexes were updated after the insert.
+  - rb: tbl.eq_join(:id, tbl, :index => :c).orderby(:left, :right).coerce_to("ARRAY")
+    py: tbl.eq_join('id', tbl, index='c').order_by('left', 'right').coerce_to("ARRAY")
+    js: tbl.eqJoin('id', tbl, {index:'c'}).orderBy('left', 'right').coerceTo("ARRAY")
+    ot: [{'right':rows[0],'left':rows[0]},
+         {'right':rows[1],'left':rows[0]},
+         {'right':rows[2],'left':rows[1]},
+         {'right':rows[3],'left':rows[1]},
+         {'right':rows[4],'left':rows[4]}]
+
+  - rb: tbl.eq_join(:id, tbl, :index => :ci).orderby(:left, :right)
+    py: tbl.eq_join('id', tbl, index='ci').order_by('left', 'right')
+    js: tbl.eqJoin('id', tbl, {index:'ci'}).orderBy('left', 'right')
+    ot: [{'right':rows[0],'left':rows[0]},
+         {'right':rows[1],'left':rows[0]},
+         {'right':rows[2],'left':rows[1]},
+         {'right':rows[3],'left':rows[1]},
+         {'right':rows[4],'left':rows[4]}]
+
+  # test between with null bounds (allowed in old versions, now an error)
+  - py:
+      - tbl.between(null, 2, index='id').count()
+      - tbl.between(2, null, index='id').count()
+      - tbl.between(null, null, index='id').count()
+    js:
+      - tbl.between(null, 2, {index:'id'}).count()
+      - tbl.between(2, null, {index:'id'}).count()
+      - tbl.between(r.minval, null, {index:'id'}).count()
+    rb:
+      - tbl.between(null, 2, :index => 'id').count()
+      - tbl.between(2, null, :index => 'id').count()
+      - tbl.between(null, null, :index => 'id').count()
+    ot: err('ReqlQueryLogicError', 'Cannot use `nu' + 'll` in BETWEEN, use `r.minval` or `r.maxval` to denote unboundedness.')
+
+  - rb: tbl.between(r.minval, r.maxval).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, r.maxval).order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, r.maxval).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(r.minval, r.maxval).orderby(:index => :id).map{|x| x[:id]}
+    py: tbl.between(r.minval, r.maxval).order_by(index='id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, r.maxval).orderBy({index:'id'}).map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(r.minval, r.maxval).between(r.minval, r.maxval).map{|x| x[:id]}
+    py: tbl.between(r.minval, r.maxval).between(r.minval, r.maxval).map(lambda x:x['id'])
+    js: tbl.between(r.minval, r.maxval).between(r.minval, r.maxval).map(function(x) { return x('id'); })
+    ot: err('ReqlQueryLogicError', 'Cannot perform multiple BETWEENs on the same table.', [0])
+  - rb: tbl.order_by(index:'id').between(r.minval, 3).map{|x| x[:id]}
+    py: tbl.order_by(index='id').between(r.minval, 3).map(lambda x:x['id'])
+    js: tbl.orderBy({index:'id'}).between(r.minval, 3).map(function(x) { return x('id'); })
+    ot: [0, 1, 2]
+  - rb: tbl.between(0, r.maxval).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, r.maxval).order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, r.maxval).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(r.minval, 4).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, 4).order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, 4).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(0, 4).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 4).order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 4).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(-1, 5).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, 5).order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, 5).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(5, 5).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(5, 5).order_by('id').map(lambda x:x['id'])
+    js: tbl.between(5, 5).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(5, r.maxval).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(5, r.maxval).order_by('id').map(lambda x:x['id'])
+    js: tbl.between(5, r.maxval).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(-1, -1).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, -1).order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, -1).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(r.minval, -1).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, -1).order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, -1).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+
+  - rb: tbl.between(r.minval, r.maxval, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, r.maxval, right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, r.maxval, {'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(0, r.maxval, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, r.maxval, right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, r.maxval, {'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(r.minval, 4, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, 4, right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, 4, {'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(0, 4, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 4, right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 4, {'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(-1, 5, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, 5, right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, 5, {'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(5, 5, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(5, 5, right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(5, 5, {'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(5, r.maxval, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(5, r.maxval, right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(5, r.maxval, {'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(-1, -1, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, -1, right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, -1, {'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(r.minval, -1, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, -1, right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, -1, {'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+
+  - rb: tbl.between(r.minval, r.maxval, :index => :id).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, r.maxval, index='id').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, r.maxval, {index:'id'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(0, r.maxval, :index => :id).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, r.maxval, index='id').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, r.maxval, {index:'id'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(r.minval, 4, :index => :id).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, 4, index='id').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, 4, {index:'id'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(0, 4, :index => :id).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 4, index='id').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 4, {index:'id'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(-1, 5, :index => :id).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, 5, index='id').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, 5, {index:'id'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(5, 5, :index => :id).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(5, 5, index='id').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(5, 5, {index:'id'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(5, r.maxval, :index => :id).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(5, r.maxval, index='id').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(5, r.maxval, {index:'id'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(-1, -1, :index => :id).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, -1, index='id').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, -1, {index:'id'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(r.minval, -1, :index => :id).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, -1, index='id').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, -1, {index:'id'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+
+  - rb: tbl.between(r.minval, r.maxval, :index => :id, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, r.maxval, index='id', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, r.maxval, {'index':'id', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(0, r.maxval, :index => :id, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, r.maxval, index='id', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, r.maxval, {'index':'id', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(r.minval, 4, :index => :id, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, 4, index='id', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, 4, {'index':'id', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(0, 4, :index => :id, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 4, index='id', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 4, {'index':'id', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(-1, 5, :index => :id, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, 5, index='id', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, 5, {'index':'id', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(5, 5, :index => :id, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(5, 5, index='id', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(5, 5, {'index':'id', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(5, r.maxval, :index => :id, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(5, r.maxval, index='id', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(5, r.maxval, {'index':'id', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(-1, -1, :index => :id, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, -1, index='id', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, -1, {'index':'id', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(r.minval, -1, :index => :id, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, -1, index='id', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, -1, {'index':'id', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+
+  - rb: tbl.between(r.minval, r.maxval, :index => :idi).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, r.maxval, index='idi').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, r.maxval, {index:'idi'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(0, r.maxval, :index => :idi).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, r.maxval, index='idi').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, r.maxval, {index:'idi'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(r.minval, 4, :index => :idi).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, 4, index='idi').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, 4, {index:'idi'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(0, 4, :index => :idi).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 4, index='idi').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 4, {index:'idi'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(-1, 5, :index => :idi).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, 5, index='idi').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, 5, {index:'idi'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(5, 5, :index => :idi).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(5, 5, index='idi').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(5, 5 , {index:'idi'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(5, r.maxval, :index => :idi).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(5, r.maxval, index='idi').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(5, r.maxval, {index:'idi'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(-1, -1, :index => :idi).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, -1, index='idi').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, -1, {index:'idi'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(r.minval, -1, :index => :idi).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, -1, index='idi').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, -1, {index:'idi'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+
+  - rb: tbl.between(r.minval, r.maxval, :index => :idi, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, r.maxval, index='idi', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, r.maxval, {'index':'idi', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(0, r.maxval, :index => :idi, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, r.maxval, index='idi', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, r.maxval, {'index':'idi', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(r.minval, 4, :index => :idi, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, 4, index='idi', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, 4, {'index':'idi', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(0, 4, :index => :idi, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 4, index='idi', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 4, {'index':'idi', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(-1, 5, :index => :idi, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, 5, index='idi', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, 5, {'index':'idi', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(5, 5, :index => :idi, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(5, 5, index='idi', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(5, 5 , {'index':'idi', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(5, r.maxval, :index => :idi, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(5, r.maxval, index='idi', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(5, r.maxval, {'index':'idi', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(-1, -1, :index => :idi, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, -1, index='idi', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, -1, {'index':'idi', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(r.minval, -1, :index => :idi, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, -1, index='idi', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, -1, {'index':'idi', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+
+  - rb: tbl.between(r.minval, r.maxval, :index => :ai).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, r.maxval, index='ai').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, r.maxval, {index:'ai'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(0, r.maxval, :index => :ai).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, r.maxval, index='ai').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, r.maxval, {index:'ai'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(r.minval, 4, :index => :ai).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, 4, index='ai').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, 4, {index:'ai'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(0, 4, :index => :ai).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 4, index='ai').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 4, {index:'ai'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(0, 5, :index => :ai).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 5, index='ai').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 5, {index:'ai'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+
+  - rb: tbl.between(r.minval, r.maxval, :index => :ai, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, r.maxval, index='ai', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, r.maxval, {'index':'ai', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(0, r.maxval, :index => :ai, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, r.maxval, index='ai', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, r.maxval, {'index':'ai', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(r.minval, 4, :index => :ai, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, 4, index='ai', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, 4, {'index':'ai', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(0, 4, :index => :ai, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 4, index='ai', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 4, {'index':'ai', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(0, 5, :index => :ai, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 5, index='ai', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 5, {'index':'ai', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+
+  - rb: tbl.between(0, 3, :index => :ai).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 3, index='ai').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 3, {index:'ai'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(0, 1, :index => :ai).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 1, index='ai').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 1, {index:'ai'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(0, 0, :index => :ai).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 0, index='ai').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 0, {index:'ai'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(-1, 2, :index => :ai).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, 2, index='ai').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, 2, {index:'ai'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+
+  - rb: tbl.between(0, 3, :index => :ai, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 3, index='ai', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 3, {'index':'ai', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(0, 1, :index => :ai, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 1, index='ai', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 1, {'index':'ai', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(0, 0, :index => :ai, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 0, index='ai', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 0, {'index':'ai', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(-1, 2, :index => :ai, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, 2, index='ai', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, 2, {'index':'ai', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+
+  - rb: tbl.between(1, 1, :index => :ai).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(1, 1, index='ai').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(1, 1, {index:'ai'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(1, r.maxval, :index => :ai).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(1, r.maxval, index='ai').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(1, r.maxval, {index:'ai'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [4]
+  - rb: tbl.between(5, r.maxval, :index => :ai).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(5, r.maxval, index='ai').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(5, r.maxval, {index:'ai'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(r.minval, 0, :index => :ai).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, 0, index='ai').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, 0, {index:'ai'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(-1, -1, :index => :ai).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, -1, index='ai').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, -1, {index:'ai'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(r.minval, -1, :index => :ai).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, -1, index='ai').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, -1, {index:'ai'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+
+  - rb: tbl.between(1, 1, :index => :ai, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(1, 1, index='ai', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(1, 1, {'index':'ai', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(1, r.maxval, :index => :ai, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(1, r.maxval, index='ai', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(1, r.maxval, {'index':'ai', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [4]
+  - rb: tbl.between(5, r.maxval, :index => :ai, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(5, r.maxval, index='ai', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(5, r.maxval, {'index':'ai', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(r.minval, 0, :index => :ai, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, 0, index='ai', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, 0, {'index':'ai', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(-1, -1, :index => :ai, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, -1, index='ai', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, -1, {'index':'ai', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(r.minval, -1, :index => :ai, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, -1, index='ai', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, -1, {'index':'ai', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+
+  - rb: tbl.between(0, 1, :index => :c).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 1, index='c').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 1, {index:'c'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1]
+  - rb: tbl.between(-1, 1, :index => :c).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, 1, index='c').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, 1, {index:'c'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1]
+  - rb: tbl.between(r.minval, 1, :index => :c).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, 1, index='c').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, 1, {index:'c'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1]
+  - rb: tbl.between(0, r.maxval, :index => :c).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, r.maxval, index='c').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, r.maxval, {index:'c'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(-1, r.maxval, :index => :c).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, r.maxval, index='c').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, r.maxval, {index:'c'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(r.minval, r.maxval, :index => :c).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, r.maxval, index='c').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, r.maxval, {index:'c'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(1, r.maxval, :index => :c).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(1, r.maxval, index='c').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(1, r.maxval, {index:'c'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2, 3, 4]
+  - rb: tbl.between(1, 1, :index => :c).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(1, 1, index='c').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(1, 1, {index:'c'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+
+  - rb: tbl.between(0, 1, :index => :c, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, 1, index='c', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, 1, {'index':'c', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(-1, 1, :index => :c, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, 1, index='c', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, 1, {'index':'c', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(r.minval, 1, :index => :c, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, 1, index='c', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, 1, {'index':'c', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(0, r.maxval, :index => :c, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(0, r.maxval, index='c', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(0, r.maxval, {'index':'c', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(-1, r.maxval, :index => :c, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(-1, r.maxval, index='c', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(-1, r.maxval, {'index':'c', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(r.minval, r.maxval, :index => :c, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, r.maxval, index='c', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, r.maxval, {'index':'c', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(1, r.maxval, :index => :c, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(1, r.maxval, index='c', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(1, r.maxval, {'index':'c', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2, 3, 4]
+  - rb: tbl.between(1, 1, :index => :c, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(1, 1, index='c', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(1, 1, {'index':'c', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2, 3]
+
+  - rb: tbl.index_create('bc') {|row| [row[:b], row[:c]]}
+    py: tbl.index_create('bc', lambda row:[row['b'], row['c']])
+    js: tbl.indexCreate('bc', function(row) { return [row('b'), row('c')]; })
+    ot: {'created':1}
+  - rb: tbl.index_create('cb') {|row| [row[:c], row[:b]]}
+    py: tbl.index_create('cb', lambda row:[row['c'], row['b']])
+    js: tbl.indexCreate('cb', function(row) { return [row('c'), row('b')]; })
+    ot: {'created':1}
+  - cd: tbl.index_wait().pluck('index', 'ready')
+
+  - rb: tbl.between(r.minval, [0, 0], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, [0, 0], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, [0, 0], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(r.minval, [0, 0], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, [0, 0], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, [0, 0], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between(r.minval, [0, 1], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, [0, 1], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, [0, 1], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1]
+  - rb: tbl.between(r.minval, [0, 1], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, [0, 1], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, [0, 1], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1]
+  - rb: tbl.between(r.minval, [1, 0], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, [1, 0], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, [1, 0], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2]
+  - rb: tbl.between(r.minval, [1, 0], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, [1, 0], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, [1, 0], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1]
+  - rb: tbl.between(r.minval, [1, 1], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, [1, 1], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, [1, 1], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2]
+  - rb: tbl.between(r.minval, [1, 1], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, [1, 1], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, [1, 1], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2]
+  - rb: tbl.between(r.minval, r.maxval, :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, r.maxval, index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, r.maxval, {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(r.minval, r.maxval, :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, r.maxval, index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, r.maxval, {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+
+  - rb: tbl.between(r.minval, [0, 0], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, [0, 0], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, [0, 0], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1]
+  - rb: tbl.between(r.minval, [0, 0], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, [0, 0], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, [0, 0], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1]
+  - rb: tbl.between(r.minval, [0, 1], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, [0, 1], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, [0, 1], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2]
+  - rb: tbl.between(r.minval, [0, 1], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, [0, 1], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, [0, 1], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1]
+  - rb: tbl.between(r.minval, [1, 0], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, [1, 0], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, [1, 0], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2]
+  - rb: tbl.between(r.minval, [1, 0], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, [1, 0], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, [1, 0], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2]
+  - rb: tbl.between(r.minval, [1, 1], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, [1, 1], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, [1, 1], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(r.minval, [1, 1], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, [1, 1], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, [1, 1], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between(r.minval, r.maxval, :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, r.maxval, index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, r.maxval, {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between(r.minval, r.maxval, :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between(r.minval, r.maxval, index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(r.minval, r.maxval, {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+
+  - rb: tbl.between([0, 0], [0, 0], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], [0, 0], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], [0, 0], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([0, 0], [0, 0], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], [0, 0], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], [0, 0], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([0, 0], [0, 1], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], [0, 1], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], [0, 1], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1]
+  - rb: tbl.between([0, 0], [0, 1], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], [0, 1], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], [0, 1], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1]
+  - rb: tbl.between([0, 0], [1, 0], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], [1, 0], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], [1, 0], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2]
+  - rb: tbl.between([0, 0], [1, 0], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], [1, 0], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], [1, 0], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1]
+  - rb: tbl.between([0, 0], [1, 1], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], [1, 1], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], [1, 1], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2]
+  - rb: tbl.between([0, 0], [1, 1], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], [1, 1], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], [1, 1], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2]
+  - rb: tbl.between([0, 0], r.maxval, :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], r.maxval, index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], r.maxval, {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between([0, 0], r.maxval, :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], r.maxval, index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], r.maxval, {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+
+  - rb: tbl.between([0, 0], [0, 0], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], [0, 0], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], [0, 0], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1]
+  - rb: tbl.between([0, 0], [0, 0], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], [0, 0], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], [0, 0], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1]
+  - rb: tbl.between([0, 0], [0, 1], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], [0, 1], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], [0, 2], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2]
+  - rb: tbl.between([0, 0], [0, 1], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], [0, 1], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], [0, 1], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1]
+  - rb: tbl.between([0, 0], [1, 0], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], [1, 0], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], [1, 0], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2]
+  - rb: tbl.between([0, 0], [1, 0], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], [1, 0], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], [1, 0], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2]
+  - rb: tbl.between([0, 0], [1, 1], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], [1, 1], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], [1, 1], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between([0, 0], [1, 1], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], [1, 1], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], [1, 1], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3]
+  - rb: tbl.between([0, 0], r.maxval, :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], r.maxval, index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], r.maxval, {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+  - rb: tbl.between([0, 0], r.maxval, :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 0], r.maxval, index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 0], r.maxval, {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0, 1, 2, 3, 4]
+
+  - rb: tbl.between([0, 1], [0, 0], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], [0, 0], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], [0, 0], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([0, 1], [0, 0], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], [0, 0], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], [0, 0], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([0, 1], [0, 1], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], [0, 1], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], [0, 1], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([0, 1], [0, 1], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], [0, 1], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], [0, 1], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([0, 1], [1, 0], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], [1, 0], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], [1, 0], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2]
+  - rb: tbl.between([0, 1], [1, 0], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], [1, 0], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], [1, 0], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([0, 1], [1, 1], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], [1, 1], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], [1, 1], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2]
+  - rb: tbl.between([0, 1], [1, 1], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], [1, 1], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], [1, 1], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2]
+  - rb: tbl.between([0, 1], r.maxval, :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], r.maxval, index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], r.maxval, {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2, 3, 4]
+  - rb: tbl.between([0, 1], r.maxval, :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], r.maxval, index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], r.maxval, {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2, 3, 4]
+
+  - rb: tbl.between([0, 1], [0, 0], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], [0, 0], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], [0, 0], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([0, 1], [0, 0], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], [0, 0], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], [0, 0], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([0, 1], [0, 1], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], [0, 1], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], [0, 1], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2]
+  - rb: tbl.between([0, 1], [0, 1], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], [0, 1], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], [0, 1], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([0, 1], [1, 0], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], [1, 0], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], [1, 0], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2]
+  - rb: tbl.between([0, 1], [1, 0], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], [1, 0], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], [1, 0], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2]
+  - rb: tbl.between([0, 1], [1, 1], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], [1, 1], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], [1, 1], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2, 3]
+  - rb: tbl.between([0, 1], [1, 1], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], [1, 1], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], [1, 1], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2, 3]
+  - rb: tbl.between([0, 1], r.maxval, :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], r.maxval, index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], r.maxval, {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2, 3, 4]
+  - rb: tbl.between([0, 1], r.maxval, :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([0, 1], r.maxval, index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([0, 1], r.maxval, {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2, 3, 4]
+
+  - rb: tbl.between([1, 0], [0, 0], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], [0, 0], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], [0, 0], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 0], [0, 0], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], [0, 0], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], [0, 0], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 0], [0, 1], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], [0, 1], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], [0, 1], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 0], [0, 1], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], [0, 1], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], [0, 1], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 0], [1, 0], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], [1, 0], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], [1, 0], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 0], [1, 0], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], [1, 0], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], [1, 0], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 0], [1, 1], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], [1, 1], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], [1, 1], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 0], [1, 1], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], [1, 1], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], [1, 1], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2]
+  - rb: tbl.between([1, 0], r.maxval, :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], r.maxval, index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], r.maxval, {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [3, 4]
+  - rb: tbl.between([1, 0], r.maxval, :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], r.maxval, index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], r.maxval, {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2, 3, 4]
+
+  - rb: tbl.between([1, 0], [0, 0], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], [0, 0], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], [0, 0], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 0], [0, 0], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], [0, 0], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], [0, 0], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 0], [0, 1], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], [0, 1], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], [0, 1], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 0], [0, 1], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], [0, 1], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], [0, 1], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 0], [1, 0], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], [1, 0], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], [1, 0], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 0], [1, 0], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], [1, 0], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], [1, 0], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2]
+  - rb: tbl.between([1, 0], [1, 1], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], [1, 1], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], [1, 1], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [3]
+  - rb: tbl.between([1, 0], [1, 1], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], [1, 1], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], [1, 1], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2, 3]
+  - rb: tbl.between([1, 0], r.maxval, :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], r.maxval, index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], r.maxval, {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [3, 4]
+  - rb: tbl.between([1, 0], r.maxval, :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 0], r.maxval, index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 0], r.maxval, {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [2, 3, 4]
+
+  - rb: tbl.between([1, 1], [0, 0], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], [0, 0], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], [0, 0], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 1], [0, 0], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], [0, 0], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], [0, 0], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 1], [0, 1], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], [0, 1], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], [0, 1], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 1], [0, 1], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], [0, 1], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], [0, 1], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 1], [1, 0], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], [1, 0], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], [1, 0], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 1], [1, 0], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], [1, 0], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], [1, 0], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 1], [1, 1], :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], [1, 1], index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], [1, 1], {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 1], [1, 1], :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], [1, 1], index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], [1, 1], {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 1], r.maxval, :index => :bc).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], r.maxval, index='bc').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], r.maxval, {index:'bc'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [3, 4]
+  - rb: tbl.between([1, 1], r.maxval, :index => :cb).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], r.maxval, index='cb').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], r.maxval, {index:'cb'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [3, 4]
+
+  - rb: tbl.between([1, 1], [0, 0], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], [0, 0], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], [0, 0], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 1], [0, 0], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], [0, 0], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], [0, 0], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 1], [0, 1], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], [0, 1], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], [0, 1], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 1], [0, 1], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], [0, 1], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], [0, 1], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 1], [1, 0], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], [1, 0], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], [1, 0], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 1], [1, 0], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], [1, 0], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], [1, 0], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: []
+  - rb: tbl.between([1, 1], [1, 1], :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], [1, 1], index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], [1, 1], {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [3]
+  - rb: tbl.between([1, 1], [1, 1], :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], [1, 1], index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], [1, 1], {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [3]
+  - rb: tbl.between([1, 1], r.maxval, :index => :bc, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], r.maxval, index='bc', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], r.maxval, {'index':'bc', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [3, 4]
+  - rb: tbl.between([1, 1], r.maxval, :index => :cb, :right_bound => :closed).orderby(:id).map{|x| x[:id]}
+    py: tbl.between([1, 1], r.maxval, index='cb', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between([1, 1], r.maxval, {'index':'cb', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [3, 4]
+
+  - rb: tbl.between(1, 3, :index => :mi, :right_bound => :closed).map{|x| x[:id]}
+    py: tbl.between(1, 3, index='mi', right_bound='closed').map(lambda x:x['id'])
+    js: tbl.between(1, 3, {'index':'mi', 'right_bound':'closed'}).map(function(x) { return x('id'); })
+    ot: [0,0,0]
+
+  - rb: tbl.between(1, 16, :index => :mi, :right_bound => :closed).order_by(:id).map{|x| x[:id]}
+    py: tbl.between(1, 16, index='mi', right_bound='closed').order_by('id').map(lambda x:x['id'])
+    js: tbl.between(1, 16, {'index':'mi', 'right_bound':'closed'}).orderBy('id').map(function(x) { return x('id'); })
+    ot: [0,0,0,1,1,1,2,3,3,3,4,4,4]
+
+  - rb: tbl.order_by(:index => :mi).map{|x| x[:id]}
+    py: tbl.order_by(index='mi').map(lambda x:x['id'])
+    js: tbl.orderBy({'index':'mi'}).map(function(x) { return x('id'); })
+    ot: [0,0,0,1,1,1,2,3,3,3,4,4,4]
+
+  # Test open left bounds with both the primary and a secondary index
+  - rb: tbl.between(0, 1, :index => :c, :right_bound => :closed, :left_bound => :open).orderby(:id)[:id]
+    py: tbl.between(0, 1, index='c', right_bound='closed', left_bound='open').order_by('id')['id']
+    js: tbl.between(0, 1, {index:'c', rightBound:'closed', leftBound:'open'}).orderBy('id')('id')
+    ot: [2, 3]
+  - rb: tbl.between(0, 1, :index => :id, :right_bound => :closed, :left_bound => :open).orderby(:id)[:id]
+    py: tbl.between(0, 1, index='id', right_bound='closed', left_bound='open').order_by('id')['id']
+    js: tbl.between(0, 1, {index:'id', rightBound:'closed', leftBound:'open'}).orderBy('id')('id')
+    ot: [1]
+
diff --git a/ext/librethinkdbxx/test/upstream/sindex/nullsinstrings.yaml b/ext/librethinkdbxx/test/upstream/sindex/nullsinstrings.yaml
new file mode 100644
index 00000000..81695bcf
--- /dev/null
+++ b/ext/librethinkdbxx/test/upstream/sindex/nullsinstrings.yaml
@@ -0,0 +1,21 @@
+desc: sindex nulls in strings
+table_variable_name: tbl
+tests:
+  - cd: tbl.index_create("key")
+    ot: ({"created":1})
+  - cd: tbl.index_wait().pluck("ready")
+    ot: ([{"ready":true}])
+
+  # if nulls aren't escaped properly, these two "key" arrays map to the same sindex btree key
+  - cd: tbl.insert([{"id":1,"key":["a","b"]},{"id":2,"key":["a\u0000Sb"]}]).pluck("inserted")
+    ot: ({"inserted":2})
+
+  - py: tbl.get_all(["a\u0000Sb"], index="key").pluck("id")
+    rb: tbl.get_all(["a\u0000Sb"], :index => "key").pluck("id")
+    js: tbl.get_all(["a\u0000Sb"], {"index":"key"}).pluck("id")
+    ot: ([{"id":2}])
+
+  - py: tbl.get_all(["a","b"], index="key").pluck("id")
+    rb: tbl.get_all(["a","b"], :index => "key").pluck("id")
+    js: tbl.get_all(["a","b"], {"index":"key"}).pluck("id")
+    ot: ([{"id":1}])
diff --git a/ext/librethinkdbxx/test/upstream/sindex/status.yaml b/ext/librethinkdbxx/test/upstream/sindex/status.yaml
new file mode 100644
index 00000000..401e3ff9
--- /dev/null
+++ b/ext/librethinkdbxx/test/upstream/sindex/status.yaml
@@ -0,0 +1,76 @@
+desc: sindex status
+table_variable_name: tbl2
+tests:
+
+# Index status test on an empty table with two indexes.
+# This is also a regression test for #4868
+  - cd: tbl2.index_create("a")
+    ot: ({'created':1})
+  - cd: tbl2.index_create("b")
+    ot: ({'created':1})
+
+  - cd: tbl2.index_status().count()
+    ot: 2
+  - cd: tbl2.index_status("a").count()
+    ot: 1
+  - cd: tbl2.index_status("b").count()
+    ot: 1
+  - cd: tbl2.index_status("a", "b").count()
+    ot: 2
+
+  - cd: tbl2.index_drop("a")
+    ot: ({'dropped':1})
+  - cd: tbl2.index_drop("b")
+    ot: ({'dropped':1})
+
+# Index status tests with bigger tables for a single index
+
+  - py: tbl2.insert(r.range(0, 5000).map({'a':r.row}))
+    rb: tbl2.insert(r.range(0, 5000).map{|row| {'a':row}})
+    js: tbl2.insert(r.range(0, 5000).map(function(row){ return {'a':row}; }))
+    ot: partial({'inserted':5000})
+
+  - cd: tbl2.index_create("foo")
+    ot: ({'created':1})
+
+  - py: tbl2.index_create("bar", multi=True)
+    js: tbl2.index_create("bar", {multi:true})
+    rb: tbl2.index_create("bar", :multi => true)
+    ot: ({'created':1})
+
+# notice this test is timing based, if it's failing then there's a good chance
+# the problem is just that the index creation finished before we could poll its
+# status.
+  - py: tbl2.index_status().map(lambda x:x["progress"] < 1)
+    rb: tbl2.index_status().map{|x| x["progress"] < 1}
+    js: tbl2.index_status().map(function (x) { return x("progress").lt(1); })
+    ot: [true, true]
+
+  - py: tbl2.index_wait()['ready']
+    rb: tbl2.index_wait()['ready']
+    js: tbl2.index_wait()('ready')
+    ot: ([true, true])
+
+  - py: tbl2.index_wait()['geo']
+    ot: bag([false, false])
+
+  - py: tbl2.index_wait()['multi']
+    ot: bag([false, true])
+
+  - py: tbl2.index_wait()['outdated']
+    ot: ([false, false])
+
+  - cd: tbl2.index_create("quux")
+    ot: ({'created':1})
+
+  - py: tbl2.index_status("quux").do(lambda x:(x[0]["index"] == "quux") & (x[0]["progress"] < 1))
+    rb: tbl2.index_status("quux").do{|x| x[0]["index"].eq("quux") & (x[0]["progress"] < 1)}
+    js: tbl2.index_status("quux").do(function (x) { return x.nth(0)("index").eq("quux").and(x.nth(0)("progress").lt(1)); })
+    ot: true
+
+  - cd: tbl2.index_wait("quux").pluck('index', 'ready')
+    ot: ([{'index':'quux', 'ready':true}])
+
+  - cd: tbl2.index_wait("quux").nth(0).get_field('function').type_of()
+    ot: ("PTYPE<BINARY>")
+
diff --git a/ext/librethinkdbxx/test/upstream/sindex/trunc_array.rb.yaml b/ext/librethinkdbxx/test/upstream/sindex/trunc_array.rb.yaml
new file mode 100644
index 00000000..1a193b1c
--- /dev/null
+++ b/ext/librethinkdbxx/test/upstream/sindex/trunc_array.rb.yaml
@@ -0,0 +1,70 @@
+desc: sindex truncation tests
+table_variable_name: tbl
+tests:
+
+  - rb: tbl.index_create('a')
+    ot: ({'created' => 1})
+  - rb: tbl.index_create('idi'){|row| row['id']}
+    ot: ({'created':1})
+  - rb: tbl.index_wait()
+
+# Create a mix of truncated and untruncated sindex keys.
+  - def:
+      rb: a = (0...100).map{|i| "a"*1000 + sprintf("1%02d", i)}
+  - def:
+      rb: b = (0...1).map{|i| "a"*10 + "b" + sprintf("2%02d", i)}
+  - def:
+      rb: c = (0...100).map{|i| "b"*100 + sprintf("3%02d", i)}
+  - def:
+      rb: d = (0...100).map{|i| "c"*1000 + sprintf("4%02d", i)}
+  - def:
+      rb: e = (0...1).map{|i| "c"*1000 + sprintf("5%02d", i)}
+  - def:
+      rb: f = (0...1).map{|i| "d"*1000 + sprintf("6%02d", i)}
+  - def:
+      rb: "vals = (a+b+c+d+e+f).map{|x| {a: x, num: x.match(/[0-9]+/).to_s.to_i}}"
+
+  - rb: tbl.insert(vals)['inserted']
+    ot: 303
+
+# Run tests with a batch configuration that guarantees some truncated
+# keys are split across batches.
+  - rb: tbl.orderby({:index => 'a'}).map{|x| x['num']}.coerce_to('array')
+    runopts:
+      max_batch_rows: 10
+    ot: vals.map{|x| x[:num]}
+
+  - rb: tbl.orderby({:index => r.desc('a')}).map{|x| x['num']}.coerce_to('array')
+    runopts:
+      max_batch_rows: 10
+    ot: vals.map{|x| x[:num]}.reverse
+
+  - rb: tbl.between("a"*1000+"150", 'c'*1000+"450", index:'a').orderby('a').map{|x| x['num']}.coerce_to('array')
+    runopts:
+      max_batch_rows: 10
+    ot: vals.map{|x| x[:num]}.select{|x| x >= 150 && x < 450}
+
+  - rb: tbl.between(r.minval, 'c'*1000+"450", index:'a').orderby('a').map{|x| x['num']}.coerce_to('array')
+    runopts:
+      max_batch_rows: 10
+    ot: vals.map{|x| x[:num]}.select{|x| x < 450}
+
+  - rb: tbl.between("a"*1000+"150", r.maxval, index:'a').orderby('a').map{|x| x['num']}.coerce_to('array')
+    runopts:
+      max_batch_rows: 10
+    ot: vals.map{|x| x[:num]}.select{|x| x >= 150}
+
+  - rb: tbl.orderby('id').coerce_to('array').eq(tbl.orderby(index:'id').coerce_to('array'))
+    ot: true
+
+  - rb: tbl.orderby(r.desc('id')).coerce_to('array').eq(tbl.orderby(index:r.desc('id')).coerce_to('array'))
+    ot: true
+
+  - rb: result = tbl.orderby('a', index:'idi').coerce_to('array')
+    runopts:
+      max_batch_rows: 100
+      first_batch_scaledown_factor: 1
+      max_batch_bytes: 1000000000000
+      max_batch_seconds: 86399
+  - rb: fetch(result).length
+    ot: 303
diff --git a/ext/librethinkdbxx/test/upstream/sindex/truncation.rb.yaml b/ext/librethinkdbxx/test/upstream/sindex/truncation.rb.yaml
new file mode 100644
index 00000000..dc58b18f
--- /dev/null
+++ b/ext/librethinkdbxx/test/upstream/sindex/truncation.rb.yaml
@@ -0,0 +1,57 @@
+desc: sindex truncation tests
+table_variable_name: tbl
+tests:
+
+  - rb: tbl.index_create('a')
+    ot: {'created' => 1}
+  - rb: tbl.index_create('idi'){|row| row['id']}
+    ot: {'created':1}
+  - rb: tbl.index_wait()
+
+# Create a mix of truncated and untruncated sindex keys.
+  - def: a = (0...100).map{|i| "a"*1000 + sprintf("1%02d", i)}
+  - def: b = (0...1).map{|i| "a"*10 + "b" + sprintf("2%02d", i)}
+  - def: c = (0...100).map{|i| "b"*100 + sprintf("3%02d", i)}
+  - def: d = (0...100).map{|i| "c"*1000 + sprintf("4%02d", i)}
+  - def: e = (0...1).map{|i| "c"*1000 + sprintf("5%02d", i)}
+  - def: f = (0...1).map{|i| "d"*1000 + sprintf("6%02d", i)}
+  - def: vals = (a+b+c+d+e+f).map{|x| {a: x, num: x.match(/[0-9]+/).to_s.to_i}}
+
+  - rb: tbl.insert(vals)['inserted']
+    ot: 303
+
+# Run tests with a batch configuration that guarantees some truncated
+# keys are split across batches.
+  - rb: tbl.orderby({:index => 'a'}).map{|x| x['num']}
+    runopts:
+      max_batch_rows: 10
+    ot: vals.map{|x| x[:num]}
+
+  - rb: tbl.orderby({:index => r.desc('a')}).map{|x| x['num']}
+    runopts:
+      max_batch_rows: 10
+    ot: vals.map{|x| x[:num]}.reverse
+
+  - rb: tbl.between("a"*1000+"150", 'c'*1000+"450", index:'a').orderby('a').map{|x| x['num']}
+    runopts:
+      max_batch_rows: 10
+    ot: vals.map{|x| x[:num]}.select{|x| x >= 150 && x < 450}
+
+  - rb: tbl.between(r.minval, 'c'*1000+"450", index:'a').orderby('a').map{|x| x['num']}
+    runopts:
+      max_batch_rows: 10
+    ot: vals.map{|x| x[:num]}.select{|x| x < 450}
+
+  - rb: tbl.between("a"*1000+"150", r.maxval, index:'a').orderby('a').map{|x| x['num']}
+    runopts:
+      max_batch_rows: 10
+    ot: vals.map{|x| x[:num]}.select{|x| x >= 150}
+
+  - rb: result = tbl.orderby('a', index:'idi')
+    runopts:
+      max_batch_rows: 100
+      first_batch_scaledown_factor: 1
+      max_batch_bytes: 1000000000000
+      max_batch_seconds: 86399
+  - rb: fetch(result).length
+    ot: 303