func (suite *JoinsSuite) TestCases() {
suite.T().Log("Running JoinsSuite: Tests that manipulation data in tables")
messages := r.DB("test").Table("messages")
_ = messages // Prevent any noused variable errors
otbl := r.DB("test").Table("otbl")
_ = otbl // Prevent any noused variable errors
otbl2 := r.DB("test").Table("otbl2")
_ = otbl2 // Prevent any noused variable errors
receivers := r.DB("test").Table("receivers")
_ = receivers // Prevent any noused variable errors
senders := r.DB("test").Table("senders")
_ = senders // Prevent any noused variable errors
tbl := r.DB("test").Table("tbl")
_ = tbl // Prevent any noused variable errors
tbl2 := r.DB("test").Table("tbl2")
_ = tbl2 // Prevent any noused variable errors
{
// joins.yaml line #7
/* partial({'tables_created':1}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"tables_created": 1})
/* r.db('test').table_create('test3', primary_key='foo') */
suite.T().Log("About to run line #7: r.DB('test').TableCreate('test3').OptArgs(r.TableCreateOpts{PrimaryKey: 'foo', })")
runAndAssert(suite.Suite, expected_, r.DB("test").TableCreate("test3").OptArgs(r.TableCreateOpts{PrimaryKey: "foo"}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #7")
}
// joins.yaml line #11
// tbl3 = r.db('test').table('test3')
suite.T().Log("Possibly executing: var tbl3 r.Term = r.DB('test').Table('test3')")
tbl3 := r.DB("test").Table("test3")
_ = tbl3 // Prevent any noused variable errors
{
// joins.yaml line #13
/* partial({'errors':0, 'inserted':100}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"errors": 0, "inserted": 100})
/* tbl.insert(r.range(0, 100).map({'id':r.row, 'a':r.row % 4})) */
suite.T().Log("About to run line #13: tbl.Insert(r.Range(0, 100).Map(map[interface{}]interface{}{'id': r.Row, 'a': r.Row.Mod(4), }))")
runAndAssert(suite.Suite, expected_, tbl.Insert(r.Range(0, 100).Map(map[interface{}]interface{}{"id": r.Row, "a": r.Row.Mod(4)})), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #13")
}
{
// joins.yaml line #18
/* partial({'errors':0, 'inserted':100}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"errors": 0, "inserted": 100})
/* tbl2.insert(r.range(0, 100).map({'id':r.row, 'b':r.row % 4})) */
suite.T().Log("About to run line #18: tbl2.Insert(r.Range(0, 100).Map(map[interface{}]interface{}{'id': r.Row, 'b': r.Row.Mod(4), }))")
runAndAssert(suite.Suite, expected_, tbl2.Insert(r.Range(0, 100).Map(map[interface{}]interface{}{"id": r.Row, "b": r.Row.Mod(4)})), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #18")
}
{
// joins.yaml line #23
/* partial({'errors':0, 'inserted':100}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"errors": 0, "inserted": 100})
/* tbl3.insert(r.range(0, 100).map({'foo':r.row, 'b':r.row % 4})) */
suite.T().Log("About to run line #23: tbl3.Insert(r.Range(0, 100).Map(map[interface{}]interface{}{'foo': r.Row, 'b': r.Row.Mod(4), }))")
runAndAssert(suite.Suite, expected_, tbl3.Insert(r.Range(0, 100).Map(map[interface{}]interface{}{"foo": r.Row, "b": r.Row.Mod(4)})), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #23")
}
{
// joins.yaml line #28
/* AnythingIsFine */
var expected_ string = compare.AnythingIsFine
/* otbl.insert(r.range(1,100).map({'id': r.row, 'a': r.row})) */
suite.T().Log("About to run line #28: otbl.Insert(r.Range(1, 100).Map(map[interface{}]interface{}{'id': r.Row, 'a': r.Row, }))")
runAndAssert(suite.Suite, expected_, otbl.Insert(r.Range(1, 100).Map(map[interface{}]interface{}{"id": r.Row, "a": r.Row})), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #28")
}
{
// joins.yaml line #29
/* AnythingIsFine */
var expected_ string = compare.AnythingIsFine
/* otbl2.insert(r.range(1,100).map({'id': r.row, 'b': 2 * r.row})) */
suite.T().Log("About to run line #29: otbl2.Insert(r.Range(1, 100).Map(map[interface{}]interface{}{'id': r.Row, 'b': r.Mul(2, r.Row), }))")
runAndAssert(suite.Suite, expected_, otbl2.Insert(r.Range(1, 100).Map(map[interface{}]interface{}{"id": r.Row, "b": r.Mul(2, r.Row)})), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #29")
}
// joins.yaml line #34
// ij = tbl.inner_join(tbl2, lambda x,y:x['a'] == y['b']).zip()
suite.T().Log("Possibly executing: var ij r.Term = tbl.InnerJoin(tbl2, func(x r.Term, y r.Term) interface{} { return x.AtIndex('a').Eq(y.AtIndex('b'))}).Zip()")
ij := tbl.InnerJoin(tbl2, func(x r.Term, y r.Term) interface{} { return x.AtIndex("a").Eq(y.AtIndex("b")) }).Zip()
_ = ij // Prevent any noused variable errors
{
// joins.yaml line #37
/* 2500 */
var expected_ int = 2500
/* ij.count() */
suite.T().Log("About to run line #37: ij.Count()")
runAndAssert(suite.Suite, expected_, ij.Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #37")
}
{
// joins.yaml line #39
/* 0 */
var expected_ int = 0
/* ij.filter(lambda row:row['a'] != row['b']).count() */
suite.T().Log("About to run line #39: ij.Filter(func(row r.Term) interface{} { return row.AtIndex('a').Ne(row.AtIndex('b'))}).Count()")
runAndAssert(suite.Suite, expected_, ij.Filter(func(row r.Term) interface{} { return row.AtIndex("a").Ne(row.AtIndex("b")) }).Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #39")
}
// joins.yaml line #46
// oj = tbl.outer_join(tbl2, lambda x,y:x['a'] == y['b']).zip()
suite.T().Log("Possibly executing: var oj r.Term = tbl.OuterJoin(tbl2, func(x r.Term, y r.Term) interface{} { return x.AtIndex('a').Eq(y.AtIndex('b'))}).Zip()")
oj := tbl.OuterJoin(tbl2, func(x r.Term, y r.Term) interface{} { return x.AtIndex("a").Eq(y.AtIndex("b")) }).Zip()
_ = oj // Prevent any noused variable errors
{
// joins.yaml line #49
/* 2500 */
var expected_ int = 2500
/* oj.count() */
suite.T().Log("About to run line #49: oj.Count()")
runAndAssert(suite.Suite, expected_, oj.Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #49")
}
{
// joins.yaml line #51
/* 0 */
var expected_ int = 0
/* oj.filter(lambda row:row['a'] != row['b']).count() */
suite.T().Log("About to run line #51: oj.Filter(func(row r.Term) interface{} { return row.AtIndex('a').Ne(row.AtIndex('b'))}).Count()")
runAndAssert(suite.Suite, expected_, oj.Filter(func(row r.Term) interface{} { return row.AtIndex("a").Ne(row.AtIndex("b")) }).Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #51")
}
// joins.yaml line #57
// blah = otbl.order_by("id").eq_join(r.row['id'], otbl2, ordered=True).zip()
suite.T().Log("Possibly executing: var blah r.Term = otbl.OrderBy('id').EqJoin(r.Row.AtIndex('id'), otbl2).OptArgs(r.EqJoinOpts{Ordered: true, }).Zip()")
blah := maybeRun(otbl.OrderBy("id").EqJoin(r.Row.AtIndex("id"), otbl2).OptArgs(r.EqJoinOpts{Ordered: true}).Zip(), suite.session, r.RunOpts{})
_ = blah // Prevent any noused variable errors
// joins.yaml line #59
// blah = otbl.order_by(r.desc("id")).eq_join(r.row['id'], otbl2, ordered=True).zip()
suite.T().Log("Possibly executing: var blah r.Term = otbl.OrderBy(r.Desc('id')).EqJoin(r.Row.AtIndex('id'), otbl2).OptArgs(r.EqJoinOpts{Ordered: true, }).Zip()")
blah = maybeRun(otbl.OrderBy(r.Desc("id")).EqJoin(r.Row.AtIndex("id"), otbl2).OptArgs(r.EqJoinOpts{Ordered: true}).Zip(), suite.session, r.RunOpts{})
// joins.yaml line #61
// blah = otbl.order_by("id").eq_join(r.row['a'], otbl2, ordered=True).zip()
suite.T().Log("Possibly executing: var blah r.Term = otbl.OrderBy('id').EqJoin(r.Row.AtIndex('a'), otbl2).OptArgs(r.EqJoinOpts{Ordered: true, }).Zip()")
blah = maybeRun(otbl.OrderBy("id").EqJoin(r.Row.AtIndex("a"), otbl2).OptArgs(r.EqJoinOpts{Ordered: true}).Zip(), suite.session, r.RunOpts{})
{
// joins.yaml line #65
/* 100 */
var expected_ int = 100
/* tbl.eq_join('a', tbl2).zip().count() */
suite.T().Log("About to run line #65: tbl.EqJoin('a', tbl2).Zip().Count()")
runAndAssert(suite.Suite, expected_, tbl.EqJoin("a", tbl2).Zip().Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #65")
}
{
// joins.yaml line #68
/* 0 */
var expected_ int = 0
/* tbl.eq_join('fake', tbl2).zip().count() */
suite.T().Log("About to run line #68: tbl.EqJoin('fake', tbl2).Zip().Count()")
runAndAssert(suite.Suite, expected_, tbl.EqJoin("fake", tbl2).Zip().Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #68")
}
{
// joins.yaml line #71
/* 100 */
var expected_ int = 100
/* tbl.eq_join(lambda x:x['a'], tbl2).zip().count() */
suite.T().Log("About to run line #71: tbl.EqJoin(func(x r.Term) interface{} { return x.AtIndex('a')}, tbl2).Zip().Count()")
runAndAssert(suite.Suite, expected_, tbl.EqJoin(func(x r.Term) interface{} { return x.AtIndex("a") }, tbl2).Zip().Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #71")
}
{
// joins.yaml line #76
/* 0 */
var expected_ int = 0
/* tbl.eq_join(lambda x:x['fake'], tbl2).zip().count() */
suite.T().Log("About to run line #76: tbl.EqJoin(func(x r.Term) interface{} { return x.AtIndex('fake')}, tbl2).Zip().Count()")
runAndAssert(suite.Suite, expected_, tbl.EqJoin(func(x r.Term) interface{} { return x.AtIndex("fake") }, tbl2).Zip().Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #76")
}
{
// joins.yaml line #81
/* 0 */
var expected_ int = 0
/* tbl.eq_join(lambda x:null, tbl2).zip().count() */
suite.T().Log("About to run line #81: tbl.EqJoin(func(x r.Term) interface{} { return nil}, tbl2).Zip().Count()")
runAndAssert(suite.Suite, expected_, tbl.EqJoin(func(x r.Term) interface{} { return nil }, tbl2).Zip().Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #81")
}
{
// joins.yaml line #86
/* 100 */
var expected_ int = 100
/* tbl.eq_join(lambda x:x['a'], tbl2).count() */
suite.T().Log("About to run line #86: tbl.EqJoin(func(x r.Term) interface{} { return x.AtIndex('a')}, tbl2).Count()")
runAndAssert(suite.Suite, expected_, tbl.EqJoin(func(x r.Term) interface{} { return x.AtIndex("a") }, tbl2).Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #86")
}
{
// joins.yaml line #92
/* 100 */
var expected_ int = 100
/* tbl.eq_join('a', tbl3).zip().count() */
suite.T().Log("About to run line #92: tbl.EqJoin('a', tbl3).Zip().Count()")
runAndAssert(suite.Suite, expected_, tbl.EqJoin("a", tbl3).Zip().Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #92")
}
{
// joins.yaml line #95
/* 100 */
var expected_ int = 100
/* tbl.eq_join(lambda x:x['a'], tbl3).count() */
suite.T().Log("About to run line #95: tbl.EqJoin(func(x r.Term) interface{} { return x.AtIndex('a')}, tbl3).Count()")
runAndAssert(suite.Suite, expected_, tbl.EqJoin(func(x r.Term) interface{} { return x.AtIndex("a") }, tbl3).Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #95")
}
{
// joins.yaml line #101
/* 100 */
var expected_ int = 100
/* tbl.eq_join(r.row['a'], tbl2).count() */
suite.T().Log("About to run line #101: tbl.EqJoin(r.Row.AtIndex('a'), tbl2).Count()")
runAndAssert(suite.Suite, expected_, tbl.EqJoin(r.Row.AtIndex("a"), tbl2).Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #101")
}
// joins.yaml line #106
// left = r.expr([{'a':1},{'a':2},{'a':3}])
suite.T().Log("Possibly executing: var left r.Term = r.Expr([]interface{}{map[interface{}]interface{}{'a': 1, }, map[interface{}]interface{}{'a': 2, }, map[interface{}]interface{}{'a': 3, }})")
left := r.Expr([]interface{}{map[interface{}]interface{}{"a": 1}, map[interface{}]interface{}{"a": 2}, map[interface{}]interface{}{"a": 3}})
_ = left // Prevent any noused variable errors
// joins.yaml line #107
// right = r.expr([{'b':2},{'b':3}])
suite.T().Log("Possibly executing: var right r.Term = r.Expr([]interface{}{map[interface{}]interface{}{'b': 2, }, map[interface{}]interface{}{'b': 3, }})")
right := r.Expr([]interface{}{map[interface{}]interface{}{"b": 2}, map[interface{}]interface{}{"b": 3}})
_ = right // Prevent any noused variable errors
{
// joins.yaml line #109
/* [{'a':2,'b':2},{'a':3,'b':3}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 2, "b": 2}, map[interface{}]interface{}{"a": 3, "b": 3}}
/* left.inner_join(right, lambda l, r:l['a'] == r['b']).zip() */
suite.T().Log("About to run line #109: left.InnerJoin(right, func(l r.Term, r r.Term) interface{} { return l.AtIndex('a').Eq(r.AtIndex('b'))}).Zip()")
runAndAssert(suite.Suite, expected_, left.InnerJoin(right, func(l r.Term, r r.Term) interface{} { return l.AtIndex("a").Eq(r.AtIndex("b")) }).Zip(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #109")
}
{
// joins.yaml line #115
/* [{'a':1},{'a':2,'b':2},{'a':3,'b':3}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}, map[interface{}]interface{}{"a": 2, "b": 2}, map[interface{}]interface{}{"a": 3, "b": 3}}
/* left.outer_join(right, lambda l, r:l['a'] == r['b']).zip() */
suite.T().Log("About to run line #115: left.OuterJoin(right, func(l r.Term, r r.Term) interface{} { return l.AtIndex('a').Eq(r.AtIndex('b'))}).Zip()")
runAndAssert(suite.Suite, expected_, left.OuterJoin(right, func(l r.Term, r r.Term) interface{} { return l.AtIndex("a").Eq(r.AtIndex("b")) }).Zip(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #115")
}
{
// joins.yaml line #132
/* partial({'tables_dropped':1}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"tables_dropped": 1})
/* r.db('test').table_drop('test3') */
suite.T().Log("About to run line #132: r.DB('test').TableDrop('test3')")
runAndAssert(suite.Suite, expected_, r.DB("test").TableDrop("test3"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #132")
}
}
func (suite *ChangefeedsIdxcopySuite) TestCases() {
suite.T().Log("Running ChangefeedsIdxcopySuite: Test duplicate indexes with squashing")
tbl := r.DB("test").Table("tbl")
_ = tbl // Prevent any noused variable errors
{
// changefeeds/idxcopy.yaml line #4
/* partial({'created':1}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"created": 1})
/* tbl.index_create('a') */
suite.T().Log("About to run line #4: tbl.IndexCreate('a')")
runAndAssert(suite.Suite, expected_, tbl.IndexCreate("a"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #4")
}
{
// changefeeds/idxcopy.yaml line #6
/* AnythingIsFine */
var expected_ string = compare.AnythingIsFine
/* tbl.index_wait('a') */
suite.T().Log("About to run line #6: tbl.IndexWait('a')")
runAndAssert(suite.Suite, expected_, tbl.IndexWait("a"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #6")
}
// changefeeds/idxcopy.yaml line #8
// feed = tbl.order_by(index='a').limit(10).changes(squash=2).limit(9)
suite.T().Log("Possibly executing: var feed r.Term = tbl.OrderBy().OptArgs(r.OrderByOpts{Index: 'a', }).Limit(10).Changes().OptArgs(r.ChangesOpts{Squash: 2, }).Limit(9)")
feed := maybeRun(tbl.OrderBy().OptArgs(r.OrderByOpts{Index: "a"}).Limit(10).Changes().OptArgs(r.ChangesOpts{Squash: 2}).Limit(9), suite.session, r.RunOpts{
MaxBatchRows: 1,
})
_ = feed // Prevent any noused variable errors
{
// changefeeds/idxcopy.yaml line #15
/* partial({'inserted':12, 'errors':0}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"inserted": 12, "errors": 0})
/* tbl.insert(r.range(0, 12).map({'id':r.row, 'a':5})) */
suite.T().Log("About to run line #15: tbl.Insert(r.Range(0, 12).Map(map[interface{}]interface{}{'id': r.Row, 'a': 5, }))")
runAndAssert(suite.Suite, expected_, tbl.Insert(r.Range(0, 12).Map(map[interface{}]interface{}{"id": r.Row, "a": 5})), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #15")
}
{
// changefeeds/idxcopy.yaml line #20
/* partial({'deleted':3, 'errors':0}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"deleted": 3, "errors": 0})
/* tbl.get_all(1, 8, 9, index='id').delete() */
suite.T().Log("About to run line #20: tbl.GetAll(1, 8, 9).OptArgs(r.GetAllOpts{Index: 'id', }).Delete()")
runAndAssert(suite.Suite, expected_, tbl.GetAll(1, 8, 9).OptArgs(r.GetAllOpts{Index: "id"}).Delete(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #20")
}
{
// changefeeds/idxcopy.yaml line #26
/* AnythingIsFine */
var expected_ string = compare.AnythingIsFine
/* wait(2) */
suite.T().Log("About to run line #26: wait(2)")
actual := wait(2)
compare.Assert(suite.T(), expected_, actual)
suite.T().Log("Finished running line #26")
}
{
// changefeeds/idxcopy.yaml line #28
/* bag([
{"new_val":{"a":5, "id":0}, "old_val":nil},
{"new_val":{"a":5, "id":2}, "old_val":nil},
{"new_val":{"a":5, "id":3}, "old_val":nil},
{"new_val":{"a":5, "id":4}, "old_val":nil},
{"new_val":{"a":5, "id":5}, "old_val":nil},
{"new_val":{"a":5, "id":6}, "old_val":nil},
{"new_val":{"a":5, "id":7}, "old_val":nil},
{"new_val":{"a":5, "id":10}, "old_val":nil},
{"new_val":{"a":5, "id":11}, "old_val":nil}]) */
var expected_ compare.Expected = compare.UnorderedMatch([]interface{}{map[interface{}]interface{}{"new_val": map[interface{}]interface{}{"a": 5, "id": 0}, "old_val": nil}, map[interface{}]interface{}{"new_val": map[interface{}]interface{}{"a": 5, "id": 2}, "old_val": nil}, map[interface{}]interface{}{"new_val": map[interface{}]interface{}{"a": 5, "id": 3}, "old_val": nil}, map[interface{}]interface{}{"new_val": map[interface{}]interface{}{"a": 5, "id": 4}, "old_val": nil}, map[interface{}]interface{}{"new_val": map[interface{}]interface{}{"a": 5, "id": 5}, "old_val": nil}, map[interface{}]interface{}{"new_val": map[interface{}]interface{}{"a": 5, "id": 6}, "old_val": nil}, map[interface{}]interface{}{"new_val": map[interface{}]interface{}{"a": 5, "id": 7}, "old_val": nil}, map[interface{}]interface{}{"new_val": map[interface{}]interface{}{"a": 5, "id": 10}, "old_val": nil}, map[interface{}]interface{}{"new_val": map[interface{}]interface{}{"a": 5, "id": 11}, "old_val": nil}})
/* fetch(feed) */
suite.T().Log("About to run line #28: fetch(feed, 0)")
fetchAndAssert(suite.Suite, expected_, feed, 0)
suite.T().Log("Finished running line #28")
}
}
func (suite *TransformFoldSuite) TestCases() {
suite.T().Log("Running TransformFoldSuite: Tests for the fold term")
tbl := r.DB("test").Table("tbl")
_ = tbl // Prevent any noused variable errors
{
// transform/fold.yaml line #6
/* {'deleted':0,'replaced':0,'unchanged':0,'errors':0,'skipped':0,'inserted':100} */
var expected_ map[interface{}]interface{} = map[interface{}]interface{}{"deleted": 0, "replaced": 0, "unchanged": 0, "errors": 0, "skipped": 0, "inserted": 100}
/* tbl.insert(r.range(100).map(lambda i: {'id':i, 'a':i%4}).coerce_to("array")) */
suite.T().Log("About to run line #6: tbl.Insert(r.Range(100).Map(func(i r.Term) interface{} { return map[interface{}]interface{}{'id': i, 'a': r.Mod(i, 4), }}).CoerceTo('array'))")
runAndAssert(suite.Suite, expected_, tbl.Insert(r.Range(100).Map(func(i r.Term) interface{} { return map[interface{}]interface{}{"id": i, "a": r.Mod(i, 4)} }).CoerceTo("array")), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #6")
}
{
// transform/fold.yaml line #19
/* 10 */
var expected_ int = 10
/* r.range(0, 10).fold(0, lambda acc, row: acc.add(1)) */
suite.T().Log("About to run line #19: r.Range(0, 10).Fold(0, func(acc r.Term, row r.Term) interface{} { return acc.Add(1)})")
runAndAssert(suite.Suite, expected_, r.Range(0, 10).Fold(0, func(acc r.Term, row r.Term) interface{} { return acc.Add(1) }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #19")
}
{
// transform/fold.yaml line #23
/* 20 */
var expected_ int = 20
/* r.range(0, 10).fold(0, lambda acc, row: acc.add(1), final_emit=lambda acc: acc.mul(2)) */
suite.T().Log("About to run line #23: r.Range(0, 10).Fold(0, func(acc r.Term, row r.Term) interface{} { return acc.Add(1)}).OptArgs(r.FoldOpts{FinalEmit: func(acc r.Term) interface{} { return acc.Mul(2)}, })")
runAndAssert(suite.Suite, expected_, r.Range(0, 10).Fold(0, func(acc r.Term, row r.Term) interface{} { return acc.Add(1) }).OptArgs(r.FoldOpts{FinalEmit: func(acc r.Term) interface{} { return acc.Mul(2) }}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #23")
}
{
// transform/fold.yaml line #27
/* [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] */
var expected_ []interface{} = []interface{}{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
/* r.range(0, 10).fold(0, lambda acc, row: acc.add(1), emit=lambda old,row,acc: [row]).coerce_to("array") */
suite.T().Log("About to run line #27: r.Range(0, 10).Fold(0, func(acc r.Term, row r.Term) interface{} { return acc.Add(1)}).OptArgs(r.FoldOpts{Emit: func(old r.Term, row r.Term, acc r.Term) interface{} { return []interface{}{row}}, }).CoerceTo('array')")
runAndAssert(suite.Suite, expected_, r.Range(0, 10).Fold(0, func(acc r.Term, row r.Term) interface{} { return acc.Add(1) }).OptArgs(r.FoldOpts{Emit: func(old r.Term, row r.Term, acc r.Term) interface{} { return []interface{}{row} }}).CoerceTo("array"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #27")
}
{
// transform/fold.yaml line #31
/* [2, 5, 8, 10] */
var expected_ []interface{} = []interface{}{2, 5, 8, 10}
/* r.range(0, 10).fold(0, lambda acc, row: acc.add(1), emit=lambda old,row,acc: r.branch(acc.mod(3).eq(0),[row],[]),final_emit=lambda acc: [acc]).coerce_to("array") */
suite.T().Log("About to run line #31: r.Range(0, 10).Fold(0, func(acc r.Term, row r.Term) interface{} { return acc.Add(1)}).OptArgs(r.FoldOpts{Emit: func(old r.Term, row r.Term, acc r.Term) interface{} { return r.Branch(acc.Mod(3).Eq(0), []interface{}{row}, []interface{}{})}, FinalEmit: func(acc r.Term) interface{} { return []interface{}{acc}}, }).CoerceTo('array')")
runAndAssert(suite.Suite, expected_, r.Range(0, 10).Fold(0, func(acc r.Term, row r.Term) interface{} { return acc.Add(1) }).OptArgs(r.FoldOpts{Emit: func(old r.Term, row r.Term, acc r.Term) interface{} {
return r.Branch(acc.Mod(3).Eq(0), []interface{}{row}, []interface{}{})
}, FinalEmit: func(acc r.Term) interface{} { return []interface{}{acc} }}).CoerceTo("array"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #31")
}
{
// transform/fold.yaml line #35
/* [1, 2, 3, 5, 8, 13, 21, 34, 55, 89] */
var expected_ []interface{} = []interface{}{1, 2, 3, 5, 8, 13, 21, 34, 55, 89}
/* r.range(0, 10).fold([1, 1], lambda acc, row: [acc[1], acc[0].add(acc[1])], emit=lambda old,row,acc: [acc[0]]).coerce_to("array") */
suite.T().Log("About to run line #35: r.Range(0, 10).Fold([]interface{}{1, 1}, func(acc r.Term, row r.Term) interface{} { return []interface{}{acc.AtIndex(1), acc.AtIndex(0).Add(acc.AtIndex(1))}}).OptArgs(r.FoldOpts{Emit: func(old r.Term, row r.Term, acc r.Term) interface{} { return []interface{}{acc.AtIndex(0)}}, }).CoerceTo('array')")
runAndAssert(suite.Suite, expected_, r.Range(0, 10).Fold([]interface{}{1, 1}, func(acc r.Term, row r.Term) interface{} {
return []interface{}{acc.AtIndex(1), acc.AtIndex(0).Add(acc.AtIndex(1))}
}).OptArgs(r.FoldOpts{Emit: func(old r.Term, row r.Term, acc r.Term) interface{} { return []interface{}{acc.AtIndex(0)} }}).CoerceTo("array"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #35")
}
{
// transform/fold.yaml line #37
/* "STREAM" */
var expected_ string = "STREAM"
/* r.range(0, 10).fold(0, lambda acc, row: acc, emit=lambda old,row,acc: acc).type_of() */
suite.T().Log("About to run line #37: r.Range(0, 10).Fold(0, func(acc r.Term, row r.Term) interface{} { return acc}).OptArgs(r.FoldOpts{Emit: func(old r.Term, row r.Term, acc r.Term) interface{} { return acc}, }).TypeOf()")
runAndAssert(suite.Suite, expected_, r.Range(0, 10).Fold(0, func(acc r.Term, row r.Term) interface{} { return acc }).OptArgs(r.FoldOpts{Emit: func(old r.Term, row r.Term, acc r.Term) interface{} { return acc }}).TypeOf(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #37")
}
{
// transform/fold.yaml line #39
/* [{'a': 0, 'id': 20}, {'a': 3, 'id': 15}, {'a': 2, 'id': 46}, {'a': 2, 'id': 78}, {'a': 2, 'id': 90}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 0, "id": 20}, map[interface{}]interface{}{"a": 3, "id": 15}, map[interface{}]interface{}{"a": 2, "id": 46}, map[interface{}]interface{}{"a": 2, "id": 78}, map[interface{}]interface{}{"a": 2, "id": 90}}
/* tbl.filter("id").fold(0, lambda acc, row: acc.add(1), emit=lambda old,row,acc: r.branch(old.mod(20).eq(0),[row],[])).coerce_to("array") */
suite.T().Log("About to run line #39: tbl.Filter('id').Fold(0, func(acc r.Term, row r.Term) interface{} { return acc.Add(1)}).OptArgs(r.FoldOpts{Emit: func(old r.Term, row r.Term, acc r.Term) interface{} { return r.Branch(old.Mod(20).Eq(0), []interface{}{row}, []interface{}{})}, }).CoerceTo('array')")
runAndAssert(suite.Suite, expected_, tbl.Filter("id").Fold(0, func(acc r.Term, row r.Term) interface{} { return acc.Add(1) }).OptArgs(r.FoldOpts{Emit: func(old r.Term, row r.Term, acc r.Term) interface{} {
return r.Branch(old.Mod(20).Eq(0), []interface{}{row}, []interface{}{})
}}).CoerceTo("array"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #39")
}
{
// transform/fold.yaml line #42
/* [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] */
var expected_ []interface{} = []interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
/* r.range().fold(0, lambda acc, row: acc.add(1), emit=lambda old,row,acc: [acc]).limit(10) */
suite.T().Log("About to run line #42: r.Range().Fold(0, func(acc r.Term, row r.Term) interface{} { return acc.Add(1)}).OptArgs(r.FoldOpts{Emit: func(old r.Term, row r.Term, acc r.Term) interface{} { return []interface{}{acc}}, }).Limit(10)")
runAndAssert(suite.Suite, expected_, r.Range().Fold(0, func(acc r.Term, row r.Term) interface{} { return acc.Add(1) }).OptArgs(r.FoldOpts{Emit: func(old r.Term, row r.Term, acc r.Term) interface{} { return []interface{}{acc} }}).Limit(10), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #42")
}
{
// transform/fold.yaml line #45
/* err("ReqlQueryLogicError", "Cannot use an infinite stream with an aggregation function (`reduce`, `count`, etc.) or coerce it to an array.") */
var expected_ Err = err("ReqlQueryLogicError", "Cannot use an infinite stream with an aggregation function (`reduce`, `count`, etc.) or coerce it to an array.")
/* r.range().fold(0, lambda acc, row: acc.add(1), emit=lambda old,row,acc: [acc]).map(lambda doc: 1).reduce(lambda l, r: l+r) */
suite.T().Log("About to run line #45: r.Range().Fold(0, func(acc r.Term, row r.Term) interface{} { return acc.Add(1)}).OptArgs(r.FoldOpts{Emit: func(old r.Term, row r.Term, acc r.Term) interface{} { return []interface{}{acc}}, }).Map(func(doc r.Term) interface{} { return 1}).Reduce(func(l r.Term, r r.Term) interface{} { return r.Add(l, r)})")
runAndAssert(suite.Suite, expected_, r.Range().Fold(0, func(acc r.Term, row r.Term) interface{} { return acc.Add(1) }).OptArgs(r.FoldOpts{Emit: func(old r.Term, row r.Term, acc r.Term) interface{} { return []interface{}{acc} }}).Map(func(doc r.Term) interface{} { return 1 }).Reduce(func(l r.Term, r r.Term) interface{} { return r.Add(l, r) }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #45")
}
{
// transform/fold.yaml line #48
/* [x for x in range(1, 1001)] */
var expected_ []interface{} = (func() []interface{} {
res := []interface{}{}
for iterator_ := 1; iterator_ < 1001; iterator_++ {
x := iterator_
res = append(res, x)
}
return res
}())
/* r.range(0, 1000).fold(0, lambda acc, row: acc.add(1), emit=lambda old,row,acc: [acc]).coerce_to("array") */
suite.T().Log("About to run line #48: r.Range(0, 1000).Fold(0, func(acc r.Term, row r.Term) interface{} { return acc.Add(1)}).OptArgs(r.FoldOpts{Emit: func(old r.Term, row r.Term, acc r.Term) interface{} { return []interface{}{acc}}, }).CoerceTo('array')")
runAndAssert(suite.Suite, expected_, r.Range(0, 1000).Fold(0, func(acc r.Term, row r.Term) interface{} { return acc.Add(1) }).OptArgs(r.FoldOpts{Emit: func(old r.Term, row r.Term, acc r.Term) interface{} { return []interface{}{acc} }}).CoerceTo("array"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #48")
}
}
func (suite *TransformMapSuite) TestCases() {
suite.T().Log("Running TransformMapSuite: Tests the RQL `map` function")
{
// transform/map.yaml line #5
/* 'STREAM' */
var expected_ string = "STREAM"
/* r.range().map(r.range(), lambda x, y:(x, y)).type_of() */
suite.T().Log("About to run line #5: r.Range().Map(r.Range(), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y}}).TypeOf()")
runAndAssert(suite.Suite, expected_, r.Range().Map(r.Range(), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y} }).TypeOf(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #5")
}
{
// transform/map.yaml line #10
/* 'STREAM' */
var expected_ string = "STREAM"
/* r.range().map(r.expr([]), lambda x, y:(x, y)).type_of() */
suite.T().Log("About to run line #10: r.Range().Map(r.Expr([]interface{}{}), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y}}).TypeOf()")
runAndAssert(suite.Suite, expected_, r.Range().Map(r.Expr([]interface{}{}), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y} }).TypeOf(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #10")
}
{
// transform/map.yaml line #15
/* 'ARRAY' */
var expected_ string = "ARRAY"
/* r.expr([]).map(r.expr([]), lambda x, y:(x, y)).type_of() */
suite.T().Log("About to run line #15: r.Expr([]interface{}{}).Map(r.Expr([]interface{}{}), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y}}).TypeOf()")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{}).Map(r.Expr([]interface{}{}), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y} }).TypeOf(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #15")
}
{
// transform/map.yaml line #21
/* [0, 0, 0] */
var expected_ []interface{} = []interface{}{0, 0, 0}
/* r.range(3).map(lambda:0) */
suite.T().Log("About to run line #21: r.Range(3).Map(func() interface{} { return 0})")
runAndAssert(suite.Suite, expected_, r.Range(3).Map(func() interface{} { return 0 }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #21")
}
{
// transform/map.yaml line #26
/* [0, 0, 0] */
var expected_ []interface{} = []interface{}{0, 0, 0}
/* r.range(3).map(r.range(4), lambda x,y:0) */
suite.T().Log("About to run line #26: r.Range(3).Map(r.Range(4), func(x r.Term, y r.Term) interface{} { return 0})")
runAndAssert(suite.Suite, expected_, r.Range(3).Map(r.Range(4), func(x r.Term, y r.Term) interface{} { return 0 }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #26")
}
{
// transform/map.yaml line #31
/* [[1]] */
var expected_ []interface{} = []interface{}{[]interface{}{1}}
/* r.expr([1]).map(lambda x:(x,)) */
suite.T().Log("About to run line #31: r.Expr([]interface{}{1}).Map(func(x r.Term) interface{} { return []interface{}{x}})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1}).Map(func(x r.Term) interface{} { return []interface{}{x} }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #31")
}
{
// transform/map.yaml line #36
/* [[1, 1]] */
var expected_ []interface{} = []interface{}{[]interface{}{1, 1}}
/* r.expr([1]).map(r.expr([1]), lambda x, y:(x, y)) */
suite.T().Log("About to run line #36: r.Expr([]interface{}{1}).Map(r.Expr([]interface{}{1}), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y}})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1}).Map(r.Expr([]interface{}{1}), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y} }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #36")
}
{
// transform/map.yaml line #41
/* [[1, 1, 1]] */
var expected_ []interface{} = []interface{}{[]interface{}{1, 1, 1}}
/* r.expr([1]).map(r.expr([1]), r.expr([1]), lambda x, y, z:(x, y, z)) */
suite.T().Log("About to run line #41: r.Expr([]interface{}{1}).Map(r.Expr([]interface{}{1}), r.Expr([]interface{}{1}), func(x r.Term, y r.Term, z r.Term) interface{} { return []interface{}{x, y, z}})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1}).Map(r.Expr([]interface{}{1}), r.Expr([]interface{}{1}), func(x r.Term, y r.Term, z r.Term) interface{} { return []interface{}{x, y, z} }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #41")
}
{
// transform/map.yaml line #47
/* err("ReqlQueryLogicError", "The function passed to `map` expects 2 arguments, but 1 sequence was found.", []) */
var expected_ Err = err("ReqlQueryLogicError", "The function passed to `map` expects 2 arguments, but 1 sequence was found.")
/* r.expr([1]).map(lambda x, y:(x, y)) */
suite.T().Log("About to run line #47: r.Expr([]interface{}{1}).Map(func(x r.Term, y r.Term) interface{} { return []interface{}{x, y}})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1}).Map(func(x r.Term, y r.Term) interface{} { return []interface{}{x, y} }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #47")
}
{
// transform/map.yaml line #52
/* err("ReqlQueryLogicError", "The function passed to `map` expects 1 argument, but 2 sequences were found.", []) */
var expected_ Err = err("ReqlQueryLogicError", "The function passed to `map` expects 1 argument, but 2 sequences were found.")
/* r.expr([1]).map(r.expr([1]), lambda x:(x,)) */
suite.T().Log("About to run line #52: r.Expr([]interface{}{1}).Map(r.Expr([]interface{}{1}), func(x r.Term) interface{} { return []interface{}{x}})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1}).Map(r.Expr([]interface{}{1}), func(x r.Term) interface{} { return []interface{}{x} }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #52")
}
{
// transform/map.yaml line #58
/* [] */
var expected_ []interface{} = []interface{}{}
/* r.range().map(r.expr([]), lambda x, y:(x, y)) */
suite.T().Log("About to run line #58: r.Range().Map(r.Expr([]interface{}{}), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y}})")
runAndAssert(suite.Suite, expected_, r.Range().Map(r.Expr([]interface{}{}), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y} }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #58")
}
{
// transform/map.yaml line #63
/* [[1, 1], [2, 2]] */
var expected_ []interface{} = []interface{}{[]interface{}{1, 1}, []interface{}{2, 2}}
/* r.expr([1, 2]).map(r.expr([1, 2, 3, 4]), lambda x, y:(x, y)) */
suite.T().Log("About to run line #63: r.Expr([]interface{}{1, 2}).Map(r.Expr([]interface{}{1, 2, 3, 4}), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y}})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, 2}).Map(r.Expr([]interface{}{1, 2, 3, 4}), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y} }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #63")
}
{
// transform/map.yaml line #68
/* [[0, 0], [1, 1]] */
var expected_ []interface{} = []interface{}{[]interface{}{0, 0}, []interface{}{1, 1}}
/* r.range(2).map(r.range(4), lambda x, y:(x, y)) */
suite.T().Log("About to run line #68: r.Range(2).Map(r.Range(4), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y}})")
runAndAssert(suite.Suite, expected_, r.Range(2).Map(r.Range(4), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y} }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #68")
}
{
// transform/map.yaml line #73
/* [[0, 1], [1, 2], [2, 3], [3, 4]] */
var expected_ []interface{} = []interface{}{[]interface{}{0, 1}, []interface{}{1, 2}, []interface{}{2, 3}, []interface{}{3, 4}}
/* r.range().map(r.expr([1, 2, 3, 4]), lambda x, y:(x, y)) */
suite.T().Log("About to run line #73: r.Range().Map(r.Expr([]interface{}{1, 2, 3, 4}), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y}})")
runAndAssert(suite.Suite, expected_, r.Range().Map(r.Expr([]interface{}{1, 2, 3, 4}), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y} }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #73")
}
{
// transform/map.yaml line #78
/* [[0, 0], [1, 1], [2, 2]] */
var expected_ []interface{} = []interface{}{[]interface{}{0, 0}, []interface{}{1, 1}, []interface{}{2, 2}}
/* r.range(3).map(r.range(5), r.js("(function(x, y){return [x, y];})")) */
suite.T().Log("About to run line #78: r.Range(3).Map(r.Range(5), r.JS('(function(x, y){return [x, y];})'))")
runAndAssert(suite.Suite, expected_, r.Range(3).Map(r.Range(5), r.JS("(function(x, y){return [x, y];})")), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #78")
}
{
// transform/map.yaml line #83
/* err("ReqlQueryLogicError", "Cannot convert NUMBER to SEQUENCE", []) */
var expected_ Err = err("ReqlQueryLogicError", "Cannot convert NUMBER to SEQUENCE")
/* r.range().map(r.expr(1), lambda x, y:(x, y)) */
suite.T().Log("About to run line #83: r.Range().Map(r.Expr(1), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y}})")
runAndAssert(suite.Suite, expected_, r.Range().Map(r.Expr(1), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y} }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #83")
}
{
// transform/map.yaml line #89
/* err("ReqlQueryLogicError", "Cannot use an infinite stream with an aggregation function (`reduce`, `count`, etc.) or coerce it to an array.", []) */
var expected_ Err = err("ReqlQueryLogicError", "Cannot use an infinite stream with an aggregation function (`reduce`, `count`, etc.) or coerce it to an array.")
/* r.range().map(r.range(), lambda x, y:(x, y)).count() */
suite.T().Log("About to run line #89: r.Range().Map(r.Range(), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y}}).Count()")
runAndAssert(suite.Suite, expected_, r.Range().Map(r.Range(), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y} }).Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #89")
}
{
// transform/map.yaml line #95
/* [[0], [1], [2]] */
var expected_ []interface{} = []interface{}{[]interface{}{0}, []interface{}{1}, []interface{}{2}}
/* r.map(r.range(3), lambda x:(x,)) */
suite.T().Log("About to run line #95: r.Map(r.Range(3), func(x r.Term) interface{} { return []interface{}{x}})")
runAndAssert(suite.Suite, expected_, r.Map(r.Range(3), func(x r.Term) interface{} { return []interface{}{x} }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #95")
}
{
// transform/map.yaml line #100
/* [1, 2, 3] */
var expected_ []interface{} = []interface{}{1, 2, 3}
/* r.map(r.range(3), r.row + 1) */
suite.T().Log("About to run line #100: r.Map(r.Range(3), r.Row.Add(1))")
runAndAssert(suite.Suite, expected_, r.Map(r.Range(3), r.Row.Add(1)), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #100")
}
{
// transform/map.yaml line #104
/* [[0, 0], [1, 1], [2, 2]] */
var expected_ []interface{} = []interface{}{[]interface{}{0, 0}, []interface{}{1, 1}, []interface{}{2, 2}}
/* r.map(r.range(3), r.range(5), lambda x, y:(x, y)) */
suite.T().Log("About to run line #104: r.Map(r.Range(3), r.Range(5), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y}})")
runAndAssert(suite.Suite, expected_, r.Map(r.Range(3), r.Range(5), func(x r.Term, y r.Term) interface{} { return []interface{}{x, y} }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #104")
}
}
func (suite *SindexStatusSuite) TestCases() {
suite.T().Log("Running SindexStatusSuite: sindex status")
tbl2 := r.DB("test").Table("tbl2")
_ = tbl2 // Prevent any noused variable errors
{
// sindex/status.yaml line #7
/* ({'created':1}) */
var expected_ map[interface{}]interface{} = map[interface{}]interface{}{"created": 1}
/* tbl2.index_create("a") */
suite.T().Log("About to run line #7: tbl2.IndexCreate('a')")
runAndAssert(suite.Suite, expected_, tbl2.IndexCreate("a"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #7")
}
{
// sindex/status.yaml line #9
/* ({'created':1}) */
var expected_ map[interface{}]interface{} = map[interface{}]interface{}{"created": 1}
/* tbl2.index_create("b") */
suite.T().Log("About to run line #9: tbl2.IndexCreate('b')")
runAndAssert(suite.Suite, expected_, tbl2.IndexCreate("b"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #9")
}
{
// sindex/status.yaml line #12
/* 2 */
var expected_ int = 2
/* tbl2.index_status().count() */
suite.T().Log("About to run line #12: tbl2.IndexStatus().Count()")
runAndAssert(suite.Suite, expected_, tbl2.IndexStatus().Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #12")
}
{
// sindex/status.yaml line #14
/* 1 */
var expected_ int = 1
/* tbl2.index_status("a").count() */
suite.T().Log("About to run line #14: tbl2.IndexStatus('a').Count()")
runAndAssert(suite.Suite, expected_, tbl2.IndexStatus("a").Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #14")
}
{
// sindex/status.yaml line #16
/* 1 */
var expected_ int = 1
/* tbl2.index_status("b").count() */
suite.T().Log("About to run line #16: tbl2.IndexStatus('b').Count()")
runAndAssert(suite.Suite, expected_, tbl2.IndexStatus("b").Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #16")
}
{
// sindex/status.yaml line #18
/* 2 */
var expected_ int = 2
/* tbl2.index_status("a", "b").count() */
suite.T().Log("About to run line #18: tbl2.IndexStatus('a', 'b').Count()")
runAndAssert(suite.Suite, expected_, tbl2.IndexStatus("a", "b").Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #18")
}
{
// sindex/status.yaml line #21
/* ({'dropped':1}) */
var expected_ map[interface{}]interface{} = map[interface{}]interface{}{"dropped": 1}
/* tbl2.index_drop("a") */
suite.T().Log("About to run line #21: tbl2.IndexDrop('a')")
runAndAssert(suite.Suite, expected_, tbl2.IndexDrop("a"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #21")
}
{
// sindex/status.yaml line #23
/* ({'dropped':1}) */
var expected_ map[interface{}]interface{} = map[interface{}]interface{}{"dropped": 1}
/* tbl2.index_drop("b") */
suite.T().Log("About to run line #23: tbl2.IndexDrop('b')")
runAndAssert(suite.Suite, expected_, tbl2.IndexDrop("b"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #23")
}
{
// sindex/status.yaml line #28
/* partial({'inserted':5000}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"inserted": 5000})
/* tbl2.insert(r.range(0, 5000).map({'a':r.row})) */
suite.T().Log("About to run line #28: tbl2.Insert(r.Range(0, 5000).Map(map[interface{}]interface{}{'a': r.Row, }))")
runAndAssert(suite.Suite, expected_, tbl2.Insert(r.Range(0, 5000).Map(map[interface{}]interface{}{"a": r.Row})), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #28")
}
{
// sindex/status.yaml line #33
/* ({'created':1}) */
var expected_ map[interface{}]interface{} = map[interface{}]interface{}{"created": 1}
/* tbl2.index_create("foo") */
suite.T().Log("About to run line #33: tbl2.IndexCreate('foo')")
runAndAssert(suite.Suite, expected_, tbl2.IndexCreate("foo"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #33")
}
{
// sindex/status.yaml line #36
/* ({'created':1}) */
var expected_ map[interface{}]interface{} = map[interface{}]interface{}{"created": 1}
/* tbl2.index_create("bar", multi=True) */
suite.T().Log("About to run line #36: tbl2.IndexCreate('bar').OptArgs(r.IndexCreateOpts{Multi: true, })")
runAndAssert(suite.Suite, expected_, tbl2.IndexCreate("bar").OptArgs(r.IndexCreateOpts{Multi: true}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #36")
}
{
// sindex/status.yaml line #44
/* [true, true] */
var expected_ []interface{} = []interface{}{true, true}
/* tbl2.index_status().map(lambda x:x["progress"] < 1) */
suite.T().Log("About to run line #44: tbl2.IndexStatus().Map(func(x r.Term) interface{} { return x.AtIndex('progress').Lt(1)})")
runAndAssert(suite.Suite, expected_, tbl2.IndexStatus().Map(func(x r.Term) interface{} { return x.AtIndex("progress").Lt(1) }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #44")
}
{
// sindex/status.yaml line #49
/* ([true, true]) */
var expected_ []interface{} = []interface{}{true, true}
/* tbl2.index_wait()['ready'] */
suite.T().Log("About to run line #49: tbl2.IndexWait().AtIndex('ready')")
runAndAssert(suite.Suite, expected_, tbl2.IndexWait().AtIndex("ready"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #49")
}
{
// sindex/status.yaml line #54
/* bag([false, false]) */
var expected_ compare.Expected = compare.UnorderedMatch([]interface{}{false, false})
/* tbl2.index_wait()['geo'] */
suite.T().Log("About to run line #54: tbl2.IndexWait().AtIndex('geo')")
runAndAssert(suite.Suite, expected_, tbl2.IndexWait().AtIndex("geo"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #54")
}
{
// sindex/status.yaml line #57
/* bag([false, true]) */
var expected_ compare.Expected = compare.UnorderedMatch([]interface{}{false, true})
/* tbl2.index_wait()['multi'] */
suite.T().Log("About to run line #57: tbl2.IndexWait().AtIndex('multi')")
runAndAssert(suite.Suite, expected_, tbl2.IndexWait().AtIndex("multi"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #57")
}
{
// sindex/status.yaml line #60
/* ([false, false]) */
var expected_ []interface{} = []interface{}{false, false}
/* tbl2.index_wait()['outdated'] */
suite.T().Log("About to run line #60: tbl2.IndexWait().AtIndex('outdated')")
runAndAssert(suite.Suite, expected_, tbl2.IndexWait().AtIndex("outdated"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #60")
}
{
// sindex/status.yaml line #63
/* ({'created':1}) */
var expected_ map[interface{}]interface{} = map[interface{}]interface{}{"created": 1}
/* tbl2.index_create("quux") */
suite.T().Log("About to run line #63: tbl2.IndexCreate('quux')")
runAndAssert(suite.Suite, expected_, tbl2.IndexCreate("quux"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #63")
}
{
// sindex/status.yaml line #66
/* true */
var expected_ bool = true
/* tbl2.index_status("quux").do(lambda x:(x[0]["index"] == "quux") & (x[0]["progress"] < 1)) */
suite.T().Log("About to run line #66: tbl2.IndexStatus('quux').Do(func(x r.Term) interface{} { return x.AtIndex(0).AtIndex('index').Eq('quux').And(x.AtIndex(0).AtIndex('progress').Lt(1))})")
runAndAssert(suite.Suite, expected_, tbl2.IndexStatus("quux").Do(func(x r.Term) interface{} {
return x.AtIndex(0).AtIndex("index").Eq("quux").And(x.AtIndex(0).AtIndex("progress").Lt(1))
}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #66")
}
{
// sindex/status.yaml line #71
/* ([{'index':'quux', 'ready':true}]) */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"index": "quux", "ready": true}}
/* tbl2.index_wait("quux").pluck('index', 'ready') */
suite.T().Log("About to run line #71: tbl2.IndexWait('quux').Pluck('index', 'ready')")
runAndAssert(suite.Suite, expected_, tbl2.IndexWait("quux").Pluck("index", "ready"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #71")
}
{
// sindex/status.yaml line #74
/* ("PTYPE<BINARY>") */
var expected_ string = "PTYPE<BINARY>"
/* tbl2.index_wait("quux").nth(0).get_field('function').type_of() */
suite.T().Log("About to run line #74: tbl2.IndexWait('quux').Nth(0).Field('function').TypeOf()")
runAndAssert(suite.Suite, expected_, tbl2.IndexWait("quux").Nth(0).Field("function").TypeOf(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #74")
}
}
func (suite *RangeSuite) TestCases() {
suite.T().Log("Running RangeSuite: Tests RQL range generation")
{
// range.yaml line #3
/* 'STREAM' */
var expected_ string = "STREAM"
/* r.range().type_of() */
suite.T().Log("About to run line #3: r.Range().TypeOf()")
runAndAssert(suite.Suite, expected_, r.Range().TypeOf(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #3")
}
{
// range.yaml line #6
/* [0, 1, 2, 3] */
var expected_ []interface{} = []interface{}{0, 1, 2, 3}
/* r.range().limit(4) */
suite.T().Log("About to run line #6: r.Range().Limit(4)")
runAndAssert(suite.Suite, expected_, r.Range().Limit(4), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #6")
}
{
// range.yaml line #9
/* [0, 1, 2, 3] */
var expected_ []interface{} = []interface{}{0, 1, 2, 3}
/* r.range(4) */
suite.T().Log("About to run line #9: r.Range(4)")
runAndAssert(suite.Suite, expected_, r.Range(4), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #9")
}
{
// range.yaml line #12
/* [2, 3, 4] */
var expected_ []interface{} = []interface{}{2, 3, 4}
/* r.range(2, 5) */
suite.T().Log("About to run line #12: r.Range(2, 5)")
runAndAssert(suite.Suite, expected_, r.Range(2, 5), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #12")
}
{
// range.yaml line #15
/* [] */
var expected_ []interface{} = []interface{}{}
/* r.range(0) */
suite.T().Log("About to run line #15: r.Range(0)")
runAndAssert(suite.Suite, expected_, r.Range(0), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #15")
}
{
// range.yaml line #18
/* [] */
var expected_ []interface{} = []interface{}{}
/* r.range(5, 2) */
suite.T().Log("About to run line #18: r.Range(5, 2)")
runAndAssert(suite.Suite, expected_, r.Range(5, 2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #18")
}
{
// range.yaml line #21
/* [-5, -4, -3] */
var expected_ []interface{} = []interface{}{-5, -4, -3}
/* r.range(-5, -2) */
suite.T().Log("About to run line #21: r.Range(-5, -2)")
runAndAssert(suite.Suite, expected_, r.Range(-5, -2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #21")
}
{
// range.yaml line #24
/* [-5, -4, -3, -2, -1, 0, 1] */
var expected_ []interface{} = []interface{}{-5, -4, -3, -2, -1, 0, 1}
/* r.range(-5, 2) */
suite.T().Log("About to run line #24: r.Range(-5, 2)")
runAndAssert(suite.Suite, expected_, r.Range(-5, 2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #24")
}
{
// range.yaml line #30
/* err("ReqlQueryLogicError", "Expected type NUMBER but found STRING.", []) */
var expected_ Err = err("ReqlQueryLogicError", "Expected type NUMBER but found STRING.")
/* r.range("foo") */
suite.T().Log("About to run line #30: r.Range('foo')")
runAndAssert(suite.Suite, expected_, r.Range("foo"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #30")
}
{
// range.yaml line #34
/* err_regex("ReqlQueryLogicError", "Number not an integer \\(>2\\^53\\). 9007199254740994", []) */
var expected_ Err = err_regex("ReqlQueryLogicError", "Number not an integer \\(>2\\^53\\). 9007199254740994")
/* r.range(9007199254740994) */
suite.T().Log("About to run line #34: r.Range(9007199254740994)")
runAndAssert(suite.Suite, expected_, r.Range(9007199254740994), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #34")
}
{
// range.yaml line #37
/* err_regex("ReqlQueryLogicError", "Number not an integer \\(<-2\\^53\\). -9007199254740994", []) */
var expected_ Err = err_regex("ReqlQueryLogicError", "Number not an integer \\(<-2\\^53\\). -9007199254740994")
/* r.range(-9007199254740994) */
suite.T().Log("About to run line #37: r.Range(-9007199254740994)")
runAndAssert(suite.Suite, expected_, r.Range(-9007199254740994), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #37")
}
{
// range.yaml line #40
/* err_regex("ReqlQueryLogicError", "Number not an integer. 0\\.5", []) */
var expected_ Err = err_regex("ReqlQueryLogicError", "Number not an integer. 0\\.5")
/* r.range(0.5) */
suite.T().Log("About to run line #40: r.Range(0.5)")
runAndAssert(suite.Suite, expected_, r.Range(0.5), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #40")
}
{
// range.yaml line #43
/* err("ReqlQueryLogicError", "Cannot use an infinite stream with an aggregation function (`reduce`, `count`, etc.) or coerce it to an array.", []) */
var expected_ Err = err("ReqlQueryLogicError", "Cannot use an infinite stream with an aggregation function (`reduce`, `count`, etc.) or coerce it to an array.")
/* r.range().count() */
suite.T().Log("About to run line #43: r.Range().Count()")
runAndAssert(suite.Suite, expected_, r.Range().Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #43")
}
{
// range.yaml line #46
/* err("ReqlQueryLogicError", "Cannot use an infinite stream with an aggregation function (`reduce`, `count`, etc.) or coerce it to an array.", []) */
var expected_ Err = err("ReqlQueryLogicError", "Cannot use an infinite stream with an aggregation function (`reduce`, `count`, etc.) or coerce it to an array.")
/* r.range().coerce_to("ARRAY") */
suite.T().Log("About to run line #46: r.Range().CoerceTo('ARRAY')")
runAndAssert(suite.Suite, expected_, r.Range().CoerceTo("ARRAY"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #46")
}
{
// range.yaml line #49
/* err("ReqlQueryLogicError", "Cannot use an infinite stream with an aggregation function (`reduce`, `count`, etc.) or coerce it to an array.", []) */
var expected_ Err = err("ReqlQueryLogicError", "Cannot use an infinite stream with an aggregation function (`reduce`, `count`, etc.) or coerce it to an array.")
/* r.range().coerce_to("OBJECT") */
suite.T().Log("About to run line #49: r.Range().CoerceTo('OBJECT')")
runAndAssert(suite.Suite, expected_, r.Range().CoerceTo("OBJECT"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #49")
}
{
// range.yaml line #52
/* 4 */
var expected_ int = 4
/* r.range(4).count() */
suite.T().Log("About to run line #52: r.Range(4).Count()")
runAndAssert(suite.Suite, expected_, r.Range(4).Count(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #52")
}
}
func (suite *ChangefeedsEdgeSuite) TestCases() {
suite.T().Log("Running ChangefeedsEdgeSuite: Test edge cases of changefeed operations")
tbl := r.DB("test").Table("tbl")
_ = tbl // Prevent any noused variable errors
// changefeeds/edge.yaml line #5
// common_prefix = r.expr([0,1,2,3,4,5,6,7,8])
suite.T().Log("Possibly executing: var common_prefix r.Term = r.Expr([]interface{}{0, 1, 2, 3, 4, 5, 6, 7, 8})")
common_prefix := r.Expr([]interface{}{0, 1, 2, 3, 4, 5, 6, 7, 8})
_ = common_prefix // Prevent any noused variable errors
{
// changefeeds/edge.yaml line #8
/* ({'created':1}) */
var expected_ map[interface{}]interface{} = map[interface{}]interface{}{"created": 1}
/* tbl.index_create('sindex', lambda row:common_prefix.append(row['value'])) */
suite.T().Log("About to run line #8: tbl.IndexCreateFunc('sindex', func(row r.Term) interface{} { return common_prefix.Append(row.AtIndex('value'))})")
runAndAssert(suite.Suite, expected_, tbl.IndexCreateFunc("sindex", func(row r.Term) interface{} { return common_prefix.Append(row.AtIndex("value")) }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #8")
}
{
// changefeeds/edge.yaml line #11
/* AnythingIsFine */
var expected_ string = compare.AnythingIsFine
/* tbl.index_wait('sindex') */
suite.T().Log("About to run line #11: tbl.IndexWait('sindex')")
runAndAssert(suite.Suite, expected_, tbl.IndexWait("sindex"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #11")
}
// changefeeds/edge.yaml line #14
// pre = r.range(7).coerce_to('array').add(r.range(10,70).coerce_to('array')).append(100).map(r.row.coerce_to('string'))
suite.T().Log("Possibly executing: var pre r.Term = r.Range(7).CoerceTo('array').Add(r.Range(10, 70).CoerceTo('array')).Append(100).Map(r.Row.CoerceTo('string'))")
pre := maybeRun(r.Range(7).CoerceTo("array").Add(r.Range(10, 70).CoerceTo("array")).Append(100).Map(r.Row.CoerceTo("string")), suite.session, r.RunOpts{})
_ = pre // Prevent any noused variable errors
// changefeeds/edge.yaml line #16
// mid = r.range(2,9).coerce_to('array').add(r.range(20,90).coerce_to('array')).map(r.row.coerce_to('string'))
suite.T().Log("Possibly executing: var mid r.Term = r.Range(2, 9).CoerceTo('array').Add(r.Range(20, 90).CoerceTo('array')).Map(r.Row.CoerceTo('string'))")
mid := maybeRun(r.Range(2, 9).CoerceTo("array").Add(r.Range(20, 90).CoerceTo("array")).Map(r.Row.CoerceTo("string")), suite.session, r.RunOpts{})
_ = mid // Prevent any noused variable errors
// changefeeds/edge.yaml line #18
// post = r.range(3,10).coerce_to('array').add(r.range(30,100).coerce_to('array')).map(r.row.coerce_to('string'))
suite.T().Log("Possibly executing: var post r.Term = r.Range(3, 10).CoerceTo('array').Add(r.Range(30, 100).CoerceTo('array')).Map(r.Row.CoerceTo('string'))")
post := maybeRun(r.Range(3, 10).CoerceTo("array").Add(r.Range(30, 100).CoerceTo("array")).Map(r.Row.CoerceTo("string")), suite.session, r.RunOpts{})
_ = post // Prevent any noused variable errors
// changefeeds/edge.yaml line #21
// erroredres = r.range(2).coerce_to('array').add(r.range(10, 20).coerce_to('array')).append(100).map(r.row.coerce_to('string'))
suite.T().Log("Possibly executing: var erroredres r.Term = r.Range(2).CoerceTo('array').Add(r.Range(10, 20).CoerceTo('array')).Append(100).Map(r.Row.CoerceTo('string'))")
erroredres := maybeRun(r.Range(2).CoerceTo("array").Add(r.Range(10, 20).CoerceTo("array")).Append(100).Map(r.Row.CoerceTo("string")), suite.session, r.RunOpts{})
_ = erroredres // Prevent any noused variable errors
// changefeeds/edge.yaml line #26
// pre_changes = tbl.between(r.minval, common_prefix.append('7'), index='sindex').changes(squash=False).limit(len(pre))['new_val']['value']
suite.T().Log("Possibly executing: var pre_changes r.Term = tbl.Between(r.MinVal, common_prefix.Append('7')).OptArgs(r.BetweenOpts{Index: 'sindex', }).Changes().OptArgs(r.ChangesOpts{Squash: false, }).Limit(maybeLen(pre)).AtIndex('new_val').AtIndex('value')")
pre_changes := maybeRun(tbl.Between(r.MinVal, common_prefix.Append("7")).OptArgs(r.BetweenOpts{Index: "sindex"}).Changes().OptArgs(r.ChangesOpts{Squash: false}).Limit(maybeLen(pre)).AtIndex("new_val").AtIndex("value"), suite.session, r.RunOpts{})
_ = pre_changes // Prevent any noused variable errors
// changefeeds/edge.yaml line #29
// mid_changes = tbl.between(common_prefix.append('2'), common_prefix.append('9'), index='sindex').changes(squash=False).limit(len(post))['new_val']['value']
suite.T().Log("Possibly executing: var mid_changes r.Term = tbl.Between(common_prefix.Append('2'), common_prefix.Append('9')).OptArgs(r.BetweenOpts{Index: 'sindex', }).Changes().OptArgs(r.ChangesOpts{Squash: false, }).Limit(maybeLen(post)).AtIndex('new_val').AtIndex('value')")
mid_changes := maybeRun(tbl.Between(common_prefix.Append("2"), common_prefix.Append("9")).OptArgs(r.BetweenOpts{Index: "sindex"}).Changes().OptArgs(r.ChangesOpts{Squash: false}).Limit(maybeLen(post)).AtIndex("new_val").AtIndex("value"), suite.session, r.RunOpts{})
_ = mid_changes // Prevent any noused variable errors
// changefeeds/edge.yaml line #32
// post_changes = tbl.between(common_prefix.append('3'), r.maxval, index='sindex').changes(squash=False).limit(len(mid))['new_val']['value']
suite.T().Log("Possibly executing: var post_changes r.Term = tbl.Between(common_prefix.Append('3'), r.MaxVal).OptArgs(r.BetweenOpts{Index: 'sindex', }).Changes().OptArgs(r.ChangesOpts{Squash: false, }).Limit(maybeLen(mid)).AtIndex('new_val').AtIndex('value')")
post_changes := maybeRun(tbl.Between(common_prefix.Append("3"), r.MaxVal).OptArgs(r.BetweenOpts{Index: "sindex"}).Changes().OptArgs(r.ChangesOpts{Squash: false}).Limit(maybeLen(mid)).AtIndex("new_val").AtIndex("value"), suite.session, r.RunOpts{})
_ = post_changes // Prevent any noused variable errors
// changefeeds/edge.yaml line #38
// premap_changes1 = tbl.map(r.branch(r.row['value'].lt('2'), r.row, r.row["dummy"])).changes(squash=False).limit(len(erroredres))['new_val']['value']
suite.T().Log("Possibly executing: var premap_changes1 r.Term = tbl.Map(r.Branch(r.Row.AtIndex('value').Lt('2'), r.Row, r.Row.AtIndex('dummy'))).Changes().OptArgs(r.ChangesOpts{Squash: false, }).Limit(maybeLen(erroredres)).AtIndex('new_val').AtIndex('value')")
premap_changes1 := maybeRun(tbl.Map(r.Branch(r.Row.AtIndex("value").Lt("2"), r.Row, r.Row.AtIndex("dummy"))).Changes().OptArgs(r.ChangesOpts{Squash: false}).Limit(maybeLen(erroredres)).AtIndex("new_val").AtIndex("value"), suite.session, r.RunOpts{})
_ = premap_changes1 // Prevent any noused variable errors
// changefeeds/edge.yaml line #42
// postmap_changes1 = tbl.changes(squash=False).map(r.branch(r.row['new_val']['value'].lt('2'), r.row, r.row["dummy"])).limit(len(erroredres))['new_val']['value']
suite.T().Log("Possibly executing: var postmap_changes1 r.Term = tbl.Changes().OptArgs(r.ChangesOpts{Squash: false, }).Map(r.Branch(r.Row.AtIndex('new_val').AtIndex('value').Lt('2'), r.Row, r.Row.AtIndex('dummy'))).Limit(maybeLen(erroredres)).AtIndex('new_val').AtIndex('value')")
postmap_changes1 := maybeRun(tbl.Changes().OptArgs(r.ChangesOpts{Squash: false}).Map(r.Branch(r.Row.AtIndex("new_val").AtIndex("value").Lt("2"), r.Row, r.Row.AtIndex("dummy"))).Limit(maybeLen(erroredres)).AtIndex("new_val").AtIndex("value"), suite.session, r.RunOpts{})
_ = postmap_changes1 // Prevent any noused variable errors
// changefeeds/edge.yaml line #46
// prefilter_changes1 = tbl.filter(r.branch(r.row['value'].lt('2'), True, r.row["dummy"])).changes(squash=False).limit(len(erroredres))['new_val']['value']
suite.T().Log("Possibly executing: var prefilter_changes1 r.Term = tbl.Filter(r.Branch(r.Row.AtIndex('value').Lt('2'), true, r.Row.AtIndex('dummy'))).Changes().OptArgs(r.ChangesOpts{Squash: false, }).Limit(maybeLen(erroredres)).AtIndex('new_val').AtIndex('value')")
prefilter_changes1 := maybeRun(tbl.Filter(r.Branch(r.Row.AtIndex("value").Lt("2"), true, r.Row.AtIndex("dummy"))).Changes().OptArgs(r.ChangesOpts{Squash: false}).Limit(maybeLen(erroredres)).AtIndex("new_val").AtIndex("value"), suite.session, r.RunOpts{})
_ = prefilter_changes1 // Prevent any noused variable errors
// changefeeds/edge.yaml line #50
// postfilter_changes1 = tbl.changes(squash=False).filter(r.branch(r.row['new_val']['value'].lt('2'), True, r.row["dummy"])).limit(len(erroredres))['new_val']['value']
suite.T().Log("Possibly executing: var postfilter_changes1 r.Term = tbl.Changes().OptArgs(r.ChangesOpts{Squash: false, }).Filter(r.Branch(r.Row.AtIndex('new_val').AtIndex('value').Lt('2'), true, r.Row.AtIndex('dummy'))).Limit(maybeLen(erroredres)).AtIndex('new_val').AtIndex('value')")
postfilter_changes1 := maybeRun(tbl.Changes().OptArgs(r.ChangesOpts{Squash: false}).Filter(r.Branch(r.Row.AtIndex("new_val").AtIndex("value").Lt("2"), true, r.Row.AtIndex("dummy"))).Limit(maybeLen(erroredres)).AtIndex("new_val").AtIndex("value"), suite.session, r.RunOpts{})
_ = postfilter_changes1 // Prevent any noused variable errors
// changefeeds/edge.yaml line #56
// premap_changes2 = tbl.map(r.branch(r.row['value'].lt('2'), r.row, r.expr([])[1])).changes(squash=False).limit(len(erroredres))['new_val']['value']
suite.T().Log("Possibly executing: var premap_changes2 r.Term = tbl.Map(r.Branch(r.Row.AtIndex('value').Lt('2'), r.Row, r.Expr([]interface{}{}).AtIndex(1))).Changes().OptArgs(r.ChangesOpts{Squash: false, }).Limit(maybeLen(erroredres)).AtIndex('new_val').AtIndex('value')")
premap_changes2 := maybeRun(tbl.Map(r.Branch(r.Row.AtIndex("value").Lt("2"), r.Row, r.Expr([]interface{}{}).AtIndex(1))).Changes().OptArgs(r.ChangesOpts{Squash: false}).Limit(maybeLen(erroredres)).AtIndex("new_val").AtIndex("value"), suite.session, r.RunOpts{})
_ = premap_changes2 // Prevent any noused variable errors
// changefeeds/edge.yaml line #60
// postmap_changes2 = tbl.changes(squash=False).map(r.branch(r.row['new_val']['value'].lt('2'), r.row, r.expr([])[1])).limit(len(erroredres))['new_val']['value']
suite.T().Log("Possibly executing: var postmap_changes2 r.Term = tbl.Changes().OptArgs(r.ChangesOpts{Squash: false, }).Map(r.Branch(r.Row.AtIndex('new_val').AtIndex('value').Lt('2'), r.Row, r.Expr([]interface{}{}).AtIndex(1))).Limit(maybeLen(erroredres)).AtIndex('new_val').AtIndex('value')")
postmap_changes2 := maybeRun(tbl.Changes().OptArgs(r.ChangesOpts{Squash: false}).Map(r.Branch(r.Row.AtIndex("new_val").AtIndex("value").Lt("2"), r.Row, r.Expr([]interface{}{}).AtIndex(1))).Limit(maybeLen(erroredres)).AtIndex("new_val").AtIndex("value"), suite.session, r.RunOpts{})
_ = postmap_changes2 // Prevent any noused variable errors
// changefeeds/edge.yaml line #64
// prefilter_changes2 = tbl.filter(r.branch(r.row['value'].lt('2'), True, r.expr([])[1])).changes(squash=False).limit(len(erroredres))['new_val']['value']
suite.T().Log("Possibly executing: var prefilter_changes2 r.Term = tbl.Filter(r.Branch(r.Row.AtIndex('value').Lt('2'), true, r.Expr([]interface{}{}).AtIndex(1))).Changes().OptArgs(r.ChangesOpts{Squash: false, }).Limit(maybeLen(erroredres)).AtIndex('new_val').AtIndex('value')")
prefilter_changes2 := maybeRun(tbl.Filter(r.Branch(r.Row.AtIndex("value").Lt("2"), true, r.Expr([]interface{}{}).AtIndex(1))).Changes().OptArgs(r.ChangesOpts{Squash: false}).Limit(maybeLen(erroredres)).AtIndex("new_val").AtIndex("value"), suite.session, r.RunOpts{})
_ = prefilter_changes2 // Prevent any noused variable errors
// changefeeds/edge.yaml line #68
// postfilter_changes2 = tbl.changes(squash=False).filter(r.branch(r.row['new_val']['value'].lt('2'), True, r.expr([])[1])).limit(len(erroredres))['new_val']['value']
suite.T().Log("Possibly executing: var postfilter_changes2 r.Term = tbl.Changes().OptArgs(r.ChangesOpts{Squash: false, }).Filter(r.Branch(r.Row.AtIndex('new_val').AtIndex('value').Lt('2'), true, r.Expr([]interface{}{}).AtIndex(1))).Limit(maybeLen(erroredres)).AtIndex('new_val').AtIndex('value')")
postfilter_changes2 := maybeRun(tbl.Changes().OptArgs(r.ChangesOpts{Squash: false}).Filter(r.Branch(r.Row.AtIndex("new_val").AtIndex("value").Lt("2"), true, r.Expr([]interface{}{}).AtIndex(1))).Limit(maybeLen(erroredres)).AtIndex("new_val").AtIndex("value"), suite.session, r.RunOpts{})
_ = postfilter_changes2 // Prevent any noused variable errors
// changefeeds/edge.yaml line #73
// nondetermmap = r.branch(r.random().gt(0.5), r.row, r.error("dummy"))
suite.T().Log("Possibly executing: var nondetermmap r.Term = r.Branch(r.Random().Gt(0.5), r.Row, r.Error('dummy'))")
nondetermmap := r.Branch(r.Random().Gt(0.5), r.Row, r.Error("dummy"))
_ = nondetermmap // Prevent any noused variable errors
// changefeeds/edge.yaml line #77
// nondetermfilter = lambda row:r.random().gt(0.5)
suite.T().Log("Possibly executing: var nondetermfilter func() = func(row interface{}) interface{} { return r.Random().Gt(0.5)}")
nondetermfilter := func(row interface{}) interface{} { return r.Random().Gt(0.5) }
_ = nondetermfilter // Prevent any noused variable errors
{
// changefeeds/edge.yaml line #83
/* err('ReqlQueryLogicError', 'Cannot call `changes` after a non-deterministic function.') */
var expected_ Err = err("ReqlQueryLogicError", "Cannot call `changes` after a non-deterministic function.")
/* tbl.map(nondetermmap).changes(squash=False) */
suite.T().Log("About to run line #83: tbl.Map(nondetermmap).Changes().OptArgs(r.ChangesOpts{Squash: false, })")
runAndAssert(suite.Suite, expected_, tbl.Map(nondetermmap).Changes().OptArgs(r.ChangesOpts{Squash: false}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #83")
}
// changefeeds/edge.yaml line #88
// postmap_changes3 = tbl.changes(squash=False).map(nondetermmap).limit(100)
suite.T().Log("Possibly executing: var postmap_changes3 r.Term = tbl.Changes().OptArgs(r.ChangesOpts{Squash: false, }).Map(nondetermmap).Limit(100)")
postmap_changes3 := maybeRun(tbl.Changes().OptArgs(r.ChangesOpts{Squash: false}).Map(nondetermmap).Limit(100), suite.session, r.RunOpts{})
_ = postmap_changes3 // Prevent any noused variable errors
{
// changefeeds/edge.yaml line #92
/* err('ReqlQueryLogicError', 'Cannot call `changes` after a non-deterministic function.') */
var expected_ Err = err("ReqlQueryLogicError", "Cannot call `changes` after a non-deterministic function.")
/* tbl.filter(nondetermfilter).changes(squash=False) */
suite.T().Log("About to run line #92: tbl.Filter(nondetermfilter).Changes().OptArgs(r.ChangesOpts{Squash: false, })")
runAndAssert(suite.Suite, expected_, tbl.Filter(nondetermfilter).Changes().OptArgs(r.ChangesOpts{Squash: false}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #92")
}
// changefeeds/edge.yaml line #97
// postfilter_changes3 = tbl.changes(squash=False).filter(nondetermfilter).limit(4)
suite.T().Log("Possibly executing: var postfilter_changes3 r.Term = tbl.Changes().OptArgs(r.ChangesOpts{Squash: false, }).Filter(nondetermfilter).Limit(4)")
postfilter_changes3 := maybeRun(tbl.Changes().OptArgs(r.ChangesOpts{Squash: false}).Filter(nondetermfilter).Limit(4), suite.session, r.RunOpts{})
_ = postfilter_changes3 // Prevent any noused variable errors
{
// changefeeds/edge.yaml line #100
/* ({'skipped':0,'deleted':0,'unchanged':0,'errors':0,'replaced':0,'inserted':101}) */
var expected_ map[interface{}]interface{} = map[interface{}]interface{}{"skipped": 0, "deleted": 0, "unchanged": 0, "errors": 0, "replaced": 0, "inserted": 101}
/* tbl.insert(r.range(101).map({'id':r.uuid().coerce_to('binary').slice(0,r.random(4,24)).coerce_to('string'),'value':r.row.coerce_to('string')})) */
suite.T().Log("About to run line #100: tbl.Insert(r.Range(101).Map(map[interface{}]interface{}{'id': r.UUID().CoerceTo('binary').Slice(0, r.Random(4, 24)).CoerceTo('string'), 'value': r.Row.CoerceTo('string'), }))")
runAndAssert(suite.Suite, expected_, tbl.Insert(r.Range(101).Map(map[interface{}]interface{}{"id": r.UUID().CoerceTo("binary").Slice(0, r.Random(4, 24)).CoerceTo("string"), "value": r.Row.CoerceTo("string")})), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #100")
}
{
// changefeeds/edge.yaml line #105
/* bag(pre) */
var expected_ compare.Expected = compare.UnorderedMatch(pre)
/* pre_changes */
suite.T().Log("About to run line #105: pre_changes")
runAndAssert(suite.Suite, expected_, pre_changes, suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #105")
}
{
// changefeeds/edge.yaml line #108
/* bag(mid) */
var expected_ compare.Expected = compare.UnorderedMatch(mid)
/* mid_changes */
suite.T().Log("About to run line #108: mid_changes")
runAndAssert(suite.Suite, expected_, mid_changes, suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #108")
}
{
// changefeeds/edge.yaml line #111
/* bag(post) */
var expected_ compare.Expected = compare.UnorderedMatch(post)
/* post_changes */
suite.T().Log("About to run line #111: post_changes")
runAndAssert(suite.Suite, expected_, post_changes, suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #111")
}
{
// changefeeds/edge.yaml line #114
/* bag(erroredres) */
var expected_ compare.Expected = compare.UnorderedMatch(erroredres)
/* premap_changes1 */
suite.T().Log("About to run line #114: premap_changes1")
runAndAssert(suite.Suite, expected_, premap_changes1, suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #114")
}
{
// changefeeds/edge.yaml line #117
/* bag(erroredres) */
var expected_ compare.Expected = compare.UnorderedMatch(erroredres)
/* premap_changes2 */
suite.T().Log("About to run line #117: premap_changes2")
runAndAssert(suite.Suite, expected_, premap_changes2, suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #117")
}
{
// changefeeds/edge.yaml line #120
/* err('ReqlNonExistenceError', "No attribute `dummy` in object:") */
var expected_ Err = err("ReqlNonExistenceError", "No attribute `dummy` in object:")
/* postmap_changes1 */
suite.T().Log("About to run line #120: postmap_changes1")
runAndAssert(suite.Suite, expected_, postmap_changes1, suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #120")
}
{
// changefeeds/edge.yaml line #123
/* err('ReqlNonExistenceError', "Index out of bounds:" + " 1") */
var expected_ Err = err("ReqlNonExistenceError", "Index out of bounds:"+" 1")
/* postmap_changes2 */
suite.T().Log("About to run line #123: postmap_changes2")
runAndAssert(suite.Suite, expected_, postmap_changes2, suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #123")
}
{
// changefeeds/edge.yaml line #126
/* err('ReqlUserError', "dummy") */
var expected_ Err = err("ReqlUserError", "dummy")
/* postmap_changes3 */
suite.T().Log("About to run line #126: postmap_changes3")
runAndAssert(suite.Suite, expected_, postmap_changes3, suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #126")
}
{
// changefeeds/edge.yaml line #129
/* bag(erroredres) */
var expected_ compare.Expected = compare.UnorderedMatch(erroredres)
/* prefilter_changes1 */
suite.T().Log("About to run line #129: prefilter_changes1")
runAndAssert(suite.Suite, expected_, prefilter_changes1, suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #129")
}
{
// changefeeds/edge.yaml line #132
/* bag(erroredres) */
var expected_ compare.Expected = compare.UnorderedMatch(erroredres)
/* prefilter_changes2 */
suite.T().Log("About to run line #132: prefilter_changes2")
runAndAssert(suite.Suite, expected_, prefilter_changes2, suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #132")
}
{
// changefeeds/edge.yaml line #135
/* bag(erroredres) */
var expected_ compare.Expected = compare.UnorderedMatch(erroredres)
/* postfilter_changes1 */
suite.T().Log("About to run line #135: postfilter_changes1")
runAndAssert(suite.Suite, expected_, postfilter_changes1, suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #135")
}
{
// changefeeds/edge.yaml line #138
/* bag(erroredres) */
var expected_ compare.Expected = compare.UnorderedMatch(erroredres)
/* postfilter_changes2 */
suite.T().Log("About to run line #138: postfilter_changes2")
runAndAssert(suite.Suite, expected_, postfilter_changes2, suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #138")
}
}
func (suite *ChangefeedsTableSuite) TestCases() {
suite.T().Log("Running ChangefeedsTableSuite: Test changefeeds on a table")
tbl := r.DB("test").Table("tbl")
_ = tbl // Prevent any noused variable errors
// changefeeds/table.yaml line #9
// all = tbl.changes()
suite.T().Log("Possibly executing: var all r.Term = tbl.Changes()")
all := maybeRun(tbl.Changes(), suite.session, r.RunOpts{})
_ = all // Prevent any noused variable errors
{
// changefeeds/table.yaml line #15
/* partial({'errors':0, 'inserted':2}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"errors": 0, "inserted": 2})
/* tbl.insert([{'id':1}, {'id':2}]) */
suite.T().Log("About to run line #15: tbl.Insert([]interface{}{map[interface{}]interface{}{'id': 1, }, map[interface{}]interface{}{'id': 2, }})")
runAndAssert(suite.Suite, expected_, tbl.Insert([]interface{}{map[interface{}]interface{}{"id": 1}, map[interface{}]interface{}{"id": 2}}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #15")
}
{
// changefeeds/table.yaml line #17
/* bag([{'old_val':null, 'new_val':{'id':1}}, {'old_val':null, 'new_val':{'id':2}}]) */
var expected_ compare.Expected = compare.UnorderedMatch([]interface{}{map[interface{}]interface{}{"old_val": nil, "new_val": map[interface{}]interface{}{"id": 1}}, map[interface{}]interface{}{"old_val": nil, "new_val": map[interface{}]interface{}{"id": 2}}})
/* fetch(all, 2) */
suite.T().Log("About to run line #17: fetch(all, 2)")
fetchAndAssert(suite.Suite, expected_, all, 2)
suite.T().Log("Finished running line #17")
}
{
// changefeeds/table.yaml line #22
/* partial({'errors':0, 'replaced':1}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"errors": 0, "replaced": 1})
/* tbl.get(1).update({'version':1}) */
suite.T().Log("About to run line #22: tbl.Get(1).Update(map[interface{}]interface{}{'version': 1, })")
runAndAssert(suite.Suite, expected_, tbl.Get(1).Update(map[interface{}]interface{}{"version": 1}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #22")
}
{
// changefeeds/table.yaml line #24
/* [{'old_val':{'id':1}, 'new_val':{'id':1, 'version':1}}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"old_val": map[interface{}]interface{}{"id": 1}, "new_val": map[interface{}]interface{}{"id": 1, "version": 1}}}
/* fetch(all, 1) */
suite.T().Log("About to run line #24: fetch(all, 1)")
fetchAndAssert(suite.Suite, expected_, all, 1)
suite.T().Log("Finished running line #24")
}
{
// changefeeds/table.yaml line #29
/* partial({'errors':0, 'deleted':1}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"errors": 0, "deleted": 1})
/* tbl.get(1).delete() */
suite.T().Log("About to run line #29: tbl.Get(1).Delete()")
runAndAssert(suite.Suite, expected_, tbl.Get(1).Delete(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #29")
}
{
// changefeeds/table.yaml line #31
/* [{'old_val':{'id':1, 'version':1}, 'new_val':null}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"old_val": map[interface{}]interface{}{"id": 1, "version": 1}, "new_val": nil}}
/* fetch(all, 1) */
suite.T().Log("About to run line #31: fetch(all, 1)")
fetchAndAssert(suite.Suite, expected_, all, 1)
suite.T().Log("Finished running line #31")
}
// changefeeds/table.yaml line #36
// pluck = tbl.changes().pluck({'new_val':['version']})
suite.T().Log("Possibly executing: var pluck r.Term = tbl.Changes().Pluck(map[interface{}]interface{}{'new_val': []interface{}{'version'}, })")
pluck := maybeRun(tbl.Changes().Pluck(map[interface{}]interface{}{"new_val": []interface{}{"version"}}), suite.session, r.RunOpts{})
_ = pluck // Prevent any noused variable errors
{
// changefeeds/table.yaml line #37
/* partial({'errors':0, 'inserted':1}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"errors": 0, "inserted": 1})
/* tbl.insert([{'id':5, 'version':5}]) */
suite.T().Log("About to run line #37: tbl.Insert([]interface{}{map[interface{}]interface{}{'id': 5, 'version': 5, }})")
runAndAssert(suite.Suite, expected_, tbl.Insert([]interface{}{map[interface{}]interface{}{"id": 5, "version": 5}}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #37")
}
{
// changefeeds/table.yaml line #39
/* [{'new_val':{'version':5}}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"new_val": map[interface{}]interface{}{"version": 5}}}
/* fetch(pluck, 1) */
suite.T().Log("About to run line #39: fetch(pluck, 1)")
fetchAndAssert(suite.Suite, expected_, pluck, 1)
suite.T().Log("Finished running line #39")
}
{
// changefeeds/table.yaml line #44
/* err('ReqlQueryLogicError', "Cannot call a terminal (`reduce`, `count`, etc.) on an infinite stream (such as a changefeed).") */
var expected_ Err = err("ReqlQueryLogicError", "Cannot call a terminal (`reduce`, `count`, etc.) on an infinite stream (such as a changefeed).")
/* tbl.changes().order_by('id') */
suite.T().Log("About to run line #44: tbl.Changes().OrderBy('id')")
runAndAssert(suite.Suite, expected_, tbl.Changes().OrderBy("id"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #44")
}
// changefeeds/table.yaml line #59
// overflow = tbl.changes(changefeed_queue_size=100)
suite.T().Log("Possibly executing: var overflow r.Term = tbl.Changes().OptArgs(r.ChangesOpts{ChangefeedQueueSize: 100, })")
overflow := maybeRun(tbl.Changes().OptArgs(r.ChangesOpts{ChangefeedQueueSize: 100}), suite.session, r.RunOpts{})
_ = overflow // Prevent any noused variable errors
{
// changefeeds/table.yaml line #62
/* AnythingIsFine */
var expected_ string = compare.AnythingIsFine
/* tbl.insert(r.range(200).map(lambda x: {})) */
suite.T().Log("About to run line #62: tbl.Insert(r.Range(200).Map(func(x r.Term) interface{} { return map[interface{}]interface{}{}}))")
runAndAssert(suite.Suite, expected_, tbl.Insert(r.Range(200).Map(func(x r.Term) interface{} { return map[interface{}]interface{}{} })), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #62")
}
{
// changefeeds/table.yaml line #64
/* partial([{'error': regex('Changefeed cache over array size limit, skipped \d+ elements.')}]) */
var expected_ compare.Expected = compare.PartialMatch([]interface{}{map[interface{}]interface{}{"error": compare.MatchesRegexp("Changefeed cache over array size limit, skipped \\d+ elements.")}})
/* fetch(overflow, 90) */
suite.T().Log("About to run line #64: fetch(overflow, 90)")
fetchAndAssert(suite.Suite, expected_, overflow, 90)
suite.T().Log("Finished running line #64")
}
// changefeeds/table.yaml line #69
// vtbl = r.db('rethinkdb').table('_debug_scratch')
suite.T().Log("Possibly executing: var vtbl r.Term = r.DB('rethinkdb').Table('_debug_scratch')")
vtbl := r.DB("rethinkdb").Table("_debug_scratch")
_ = vtbl // Prevent any noused variable errors
// changefeeds/table.yaml line #70
// allVirtual = vtbl.changes()
suite.T().Log("Possibly executing: var allVirtual r.Term = vtbl.Changes()")
allVirtual := maybeRun(vtbl.Changes(), suite.session, r.RunOpts{})
_ = allVirtual // Prevent any noused variable errors
{
// changefeeds/table.yaml line #74
/* partial({'errors':0, 'inserted':2}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"errors": 0, "inserted": 2})
/* vtbl.insert([{'id':1}, {'id':2}]) */
suite.T().Log("About to run line #74: vtbl.Insert([]interface{}{map[interface{}]interface{}{'id': 1, }, map[interface{}]interface{}{'id': 2, }})")
runAndAssert(suite.Suite, expected_, vtbl.Insert([]interface{}{map[interface{}]interface{}{"id": 1}, map[interface{}]interface{}{"id": 2}}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #74")
}
{
// changefeeds/table.yaml line #76
/* bag([{'old_val':null, 'new_val':{'id':1}}, {'old_val':null, 'new_val':{'id':2}}]) */
var expected_ compare.Expected = compare.UnorderedMatch([]interface{}{map[interface{}]interface{}{"old_val": nil, "new_val": map[interface{}]interface{}{"id": 1}}, map[interface{}]interface{}{"old_val": nil, "new_val": map[interface{}]interface{}{"id": 2}}})
/* fetch(allVirtual, 2) */
suite.T().Log("About to run line #76: fetch(allVirtual, 2)")
fetchAndAssert(suite.Suite, expected_, allVirtual, 2)
suite.T().Log("Finished running line #76")
}
{
// changefeeds/table.yaml line #81
/* partial({'errors':0, 'replaced':1}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"errors": 0, "replaced": 1})
/* vtbl.get(1).update({'version':1}) */
suite.T().Log("About to run line #81: vtbl.Get(1).Update(map[interface{}]interface{}{'version': 1, })")
runAndAssert(suite.Suite, expected_, vtbl.Get(1).Update(map[interface{}]interface{}{"version": 1}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #81")
}
{
// changefeeds/table.yaml line #83
/* [{'old_val':{'id':1}, 'new_val':{'id':1, 'version':1}}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"old_val": map[interface{}]interface{}{"id": 1}, "new_val": map[interface{}]interface{}{"id": 1, "version": 1}}}
/* fetch(allVirtual, 1) */
suite.T().Log("About to run line #83: fetch(allVirtual, 1)")
fetchAndAssert(suite.Suite, expected_, allVirtual, 1)
suite.T().Log("Finished running line #83")
}
{
// changefeeds/table.yaml line #88
/* partial({'errors':0, 'deleted':1}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"errors": 0, "deleted": 1})
/* vtbl.get(1).delete() */
suite.T().Log("About to run line #88: vtbl.Get(1).Delete()")
runAndAssert(suite.Suite, expected_, vtbl.Get(1).Delete(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #88")
}
{
// changefeeds/table.yaml line #90
/* [{'old_val':{'id':1, 'version':1}, 'new_val':null}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"old_val": map[interface{}]interface{}{"id": 1, "version": 1}, "new_val": nil}}
/* fetch(allVirtual, 1) */
suite.T().Log("About to run line #90: fetch(allVirtual, 1)")
fetchAndAssert(suite.Suite, expected_, allVirtual, 1)
suite.T().Log("Finished running line #90")
}
// changefeeds/table.yaml line #95
// vpluck = vtbl.changes().pluck({'new_val':['version']})
suite.T().Log("Possibly executing: var vpluck r.Term = vtbl.Changes().Pluck(map[interface{}]interface{}{'new_val': []interface{}{'version'}, })")
vpluck := maybeRun(vtbl.Changes().Pluck(map[interface{}]interface{}{"new_val": []interface{}{"version"}}), suite.session, r.RunOpts{})
_ = vpluck // Prevent any noused variable errors
{
// changefeeds/table.yaml line #96
/* partial({'errors':0, 'inserted':1}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"errors": 0, "inserted": 1})
/* vtbl.insert([{'id':5, 'version':5}]) */
suite.T().Log("About to run line #96: vtbl.Insert([]interface{}{map[interface{}]interface{}{'id': 5, 'version': 5, }})")
runAndAssert(suite.Suite, expected_, vtbl.Insert([]interface{}{map[interface{}]interface{}{"id": 5, "version": 5}}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #96")
}
{
// changefeeds/table.yaml line #98
/* [{'new_val':{'version':5}}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"new_val": map[interface{}]interface{}{"version": 5}}}
/* fetch(vpluck, 1) */
suite.T().Log("About to run line #98: fetch(vpluck, 1)")
fetchAndAssert(suite.Suite, expected_, vpluck, 1)
suite.T().Log("Finished running line #98")
}
}
