Include bookmarks when fetching routing table

fbiville · web-flow · commit b1d5332cff0a · 2021-04-12T10:29:33.000+02:00
This is only needed for 4.x.

Bookmarks are sent when calling the routing table procedure (4.0 to 4.2) and sending a ROUTE message (4.3).
diff --git a/neo4j/db/connection.go b/neo4j/db/connection.go
@@ -95,7 +95,7 @@ type Connection interface {
 	// Gets routing table for specified database name or the default database if
 	// database equals DefaultDatabase. If the underlying connection does not support
 	// multiple databases, DefaultDatabase should be used as database.
-	GetRoutingTable(database string, context map[string]string) (*RoutingTable, error)
+	GetRoutingTable(context map[string]string, bookmarks []string, database string) (*RoutingTable, error)
 }
 
 type RoutingTable struct {
diff --git a/neo4j/directrouter.go b/neo4j/directrouter.go
@@ -26,11 +26,11 @@ type directRouter struct {
 	address string
 }
 
-func (r *directRouter) Readers(ctx context.Context, database string) ([]string, error) {
+func (r *directRouter) Readers(ctx context.Context, bookmarks []string, database string) ([]string, error) {
 	return []string{r.address}, nil
 }
 
-func (r *directRouter) Writers(ctx context.Context, database string) ([]string, error) {
+func (r *directRouter) Writers(ctx context.Context, bookmarks []string, database string) ([]string, error) {
 	return []string{r.address}, nil
 }
 
diff --git a/neo4j/driver.go b/neo4j/driver.go
@@ -224,8 +224,8 @@ func routingContextFromUrl(useRouting bool, u *url.URL) (map[string]string, erro
 }
 
 type sessionRouter interface {
-	Readers(ctx context.Context, database string) ([]string, error)
-	Writers(ctx context.Context, database string) ([]string, error)
+	Readers(ctx context.Context, bookmarks []string, database string) ([]string, error)
+	Writers(ctx context.Context, bookmarks []string, database string) ([]string, error)
 	Invalidate(database string)
 	CleanUp()
 }
diff --git a/neo4j/internal/bolt/bolt3.go b/neo4j/internal/bolt/bolt3.go
@@ -682,7 +682,7 @@ func (b *bolt3) Reset() {
 	}
 }
 
-func (b *bolt3) GetRoutingTable(database string, context map[string]string) (*db.RoutingTable, error) {
+func (b *bolt3) GetRoutingTable(context map[string]string, bookmarks []string, database string) (*db.RoutingTable, error) {
 	if err := b.assertState(bolt3_ready); err != nil {
 		return nil, err
 	}
diff --git a/neo4j/internal/bolt/bolt4.go b/neo4j/internal/bolt/bolt4.go
@@ -847,25 +847,25 @@ func (b *bolt4) Reset() {
 	}
 }
 
-func (b *bolt4) GetRoutingTable(database string, context map[string]string) (*db.RoutingTable, error) {
+func (b *bolt4) GetRoutingTable(context map[string]string, bookmarks []string, database string) (*db.RoutingTable, error) {
 	if err := b.assertState(bolt4_ready); err != nil {
 		return nil, err
 	}
 
 	b.log.Infof(log.Bolt4, b.logId, "Retrieving routing table")
 	if b.minor > 2 {
-		b.out.appendRoute(database, context)
+		b.out.appendRoute(context, bookmarks, database)
 		b.out.send(b.conn)
 		succ := b.receiveSuccess()
 		if b.err != nil {
 			return nil, b.err
 		}
 		return succ.routingTable, nil
 	}
-	return b.callGetRoutingTable(database, context)
+	return b.callGetRoutingTable(context, bookmarks, database)
 }
 
-func (b *bolt4) callGetRoutingTable(database string, context map[string]string) (*db.RoutingTable, error) {
+func (b *bolt4) callGetRoutingTable(context map[string]string, bookmarks []string, database string) (*db.RoutingTable, error) {
 	// The query should run in system database, preserve current setting and restore it when
 	// done.
 	originalDatabaseName := b.databaseName
@@ -882,7 +882,7 @@ func (b *bolt4) callGetRoutingTable(database string, context map[string]string)
 		runCommand.Cypher = "CALL dbms.routing.getRoutingTable($context, $database)"
 		runCommand.Params["database"] = database
 	}
-	txConfig := db.TxConfig{Mode: db.ReadMode}
+	txConfig := db.TxConfig{Mode: db.ReadMode, Bookmarks: bookmarks}
 	streamHandle, err := b.Run(runCommand, txConfig)
 	if err != nil {
 		return nil, err
diff --git a/neo4j/internal/bolt/bolt4_test.go b/neo4j/internal/bolt/bolt4_test.go
@@ -820,7 +820,7 @@ func TestBolt4(ot *testing.T) {
 		defer cleanup()
 		defer bolt.Close()
 
-		rt, err := bolt.GetRoutingTable("thedb", map[string]string{"region": "space"})
+		rt, err := bolt.GetRoutingTable(map[string]string{"region": "space"}, nil, "thedb")
 		AssertNoError(t, err)
 		ert := &db.RoutingTable{Routers: []string{"router1"}, TimeToLive: 1000}
 		if !reflect.DeepEqual(rt, ert) {
diff --git a/neo4j/internal/bolt/outgoing.go b/neo4j/internal/bolt/outgoing.go
@@ -120,14 +120,18 @@ func (o *outgoing) appendPullAll() {
 	o.end()
 }
 
-func (o *outgoing) appendRoute(database string, context map[string]string) {
+func (o *outgoing) appendRoute(context map[string]string, bookmarks []string, database string) {
 	o.begin()
-	o.packer.StructHeader(byte(msgRoute), 2)
+	o.packer.StructHeader(byte(msgRoute), 3)
 	o.packer.MapHeader(len(context))
 	for k, v := range context {
 		o.packer.String(k)
 		o.packer.String(v)
 	}
+	o.packer.ArrayHeader(len(bookmarks))
+	for _, bookmark := range bookmarks {
+		o.packer.String(bookmark)
+	}
 	if database == db.DefaultDatabase {
 		o.packer.Nil()
 	} else {
diff --git a/neo4j/internal/bolt/outgoing_test.go b/neo4j/internal/bolt/outgoing_test.go
@@ -257,21 +257,41 @@ func TestOutgoing(ot *testing.T) {
 		{
 			name: "route",
 			build: func() {
-				out.appendRoute("adb", map[string]string{"key1": "val1", "key2": "val2"})
+				out.appendRoute(map[string]string{"key1": "val1", "key2": "val2"}, []string{"deutsch-mark", "mark-twain"}, "adb")
 			},
 			expect: &testStruct{
 				tag:    byte(msgRoute),
-				fields: []interface{}{map[string]interface{}{"key1": "val1", "key2": "val2"}, "adb"},
+				fields: []interface{}{map[string]interface{}{"key1": "val1", "key2": "val2"}, []interface{}{"deutsch-mark", "mark-twain"}, "adb"},
 			},
 		},
 		{
 			name: "route, default database",
 			build: func() {
-				out.appendRoute(db.DefaultDatabase, map[string]string{"key1": "val1", "key2": "val2"})
+				out.appendRoute(map[string]string{"key1": "val1", "key2": "val2"}, []string{"deutsch-mark", "mark-twain"}, db.DefaultDatabase)
 			},
 			expect: &testStruct{
 				tag:    byte(msgRoute),
-				fields: []interface{}{map[string]interface{}{"key1": "val1", "key2": "val2"}, nil},
+				fields: []interface{}{map[string]interface{}{"key1": "val1", "key2": "val2"}, []interface{}{"deutsch-mark", "mark-twain"}, nil},
+			},
+		},
+		{
+			name: "route, default bookmarks",
+			build: func() {
+				out.appendRoute(map[string]string{"key1": "val1", "key2": "val2"}, nil, "adb")
+			},
+			expect: &testStruct{
+				tag:    byte(msgRoute),
+				fields: []interface{}{map[string]interface{}{"key1": "val1", "key2": "val2"}, []interface{}{}, "adb"},
+			},
+		},
+		{
+			name: "route, default bookmarks and database",
+			build: func() {
+				out.appendRoute(map[string]string{"key1": "val1", "key2": "val2"}, nil, db.DefaultDatabase)
+			},
+			expect: &testStruct{
+				tag:    byte(msgRoute),
+				fields: []interface{}{map[string]interface{}{"key1": "val1", "key2": "val2"}, []interface{}{}, nil},
 			},
 		},
 	}
diff --git a/neo4j/internal/router/readtable.go b/neo4j/internal/router/readtable.go
@@ -27,7 +27,7 @@ import (
 
 // Tries to read routing table from any of the specified routers using new or existing connection
 // from the supplied pool.
-func readTable(ctx context.Context, pool Pool, database string, routers []string, routerContext map[string]string) (*db.RoutingTable, error) {
+func readTable(ctx context.Context, pool Pool, routers []string, routerContext map[string]string, bookmarks []string, database string) (*db.RoutingTable, error) {
 	// Preserve last error to be returned, set a default for case of no routers
 	var err error = &ReadRoutingTableError{}
 
@@ -47,7 +47,7 @@ func readTable(ctx context.Context, pool Pool, database string, routers []string
 
 		// We have a connection to the "router"
 		var table *db.RoutingTable
-		table, err = conn.GetRoutingTable(database, routerContext)
+		table, err = conn.GetRoutingTable(routerContext, bookmarks, database)
 		pool.Return(conn)
 		if err == nil {
 			return table, nil
diff --git a/neo4j/internal/router/readtable_test.go b/neo4j/internal/router/readtable_test.go
@@ -166,7 +166,7 @@ func TestReadTableTable(ot *testing.T) {
 		ot.Run(c.name, func(t *testing.T) {
 			ctx, cancel := context.WithCancel(context.Background())
 			c.pool.cancel = cancel
-			table, err := readTable(ctx, c.pool, "dbname", c.routers, nil)
+			table, err := readTable(ctx, c.pool, c.routers, nil, nil, "dbname")
 			c.assert(t, table, err)
 			if err != nil && c.assertErr != nil {
 				c.assertErr(t, err)
diff --git a/neo4j/internal/router/router.go b/neo4j/internal/router/router.go
@@ -72,7 +72,7 @@ func New(rootRouter string, getRouters func() []string, routerContext map[string
 	return r
 }
 
-func (r *Router) getTable(ctx context.Context, database string) (*db.RoutingTable, error) {
+func (r *Router) getTable(ctx context.Context, bookmarks []string, database string) (*db.RoutingTable, error) {
 	now := r.now()
 
 	r.dbRoutersMut.Lock()
@@ -92,20 +92,20 @@ func (r *Router) getTable(ctx context.Context, database string) (*db.RoutingTabl
 	if dbRouter != nil && len(dbRouter.table.Routers) > 0 {
 		routers := dbRouter.table.Routers
 		r.log.Infof(log.Router, r.logId, "Reading routing table for '%s' from previously known routers: %v", database, routers)
-		table, err = readTable(ctx, r.pool, database, routers, r.routerContext)
+		table, err = readTable(ctx, r.pool, routers, r.routerContext, bookmarks, database)
 	}
 
 	// Try initial router if no routers or failed
 	if table == nil {
 		r.log.Infof(log.Router, r.logId, "Reading routing table from initial router: %s", r.rootRouter)
-		table, err = readTable(ctx, r.pool, database, []string{r.rootRouter}, r.routerContext)
+		table, err = readTable(ctx, r.pool, []string{r.rootRouter}, r.routerContext, bookmarks, database)
 	}
 
 	// Use hook to retrieve possibly different set of routers and retry
 	if table == nil && r.getRouters != nil {
 		routers := r.getRouters()
 		r.log.Infof(log.Router, r.logId, "Reading routing table for '%s' from custom routers: %v", routers)
-		table, err = readTable(ctx, r.pool, database, routers, r.routerContext)
+		table, err = readTable(ctx, r.pool, routers, r.routerContext, bookmarks, database)
 	}
 
 	if err != nil {
@@ -130,8 +130,8 @@ func (r *Router) getTable(ctx context.Context, database string) (*db.RoutingTabl
 	return table, nil
 }
 
-func (r *Router) Readers(ctx context.Context, database string) ([]string, error) {
-	table, err := r.getTable(ctx, database)
+func (r *Router) Readers(ctx context.Context, bookmarks []string, database string) ([]string, error) {
+	table, err := r.getTable(ctx, bookmarks, database)
 	if err != nil {
 		return nil, err
 	}
@@ -146,7 +146,7 @@ func (r *Router) Readers(ctx context.Context, database string) ([]string, error)
 		r.log.Infof(log.Router, r.logId, "Invalidating routing table, no readers")
 		r.Invalidate(database)
 		r.sleep(100 * time.Millisecond)
-		table, err = r.getTable(ctx, database)
+		table, err = r.getTable(ctx, bookmarks, database)
 		if err != nil {
 			return nil, err
 		}
@@ -158,8 +158,8 @@ func (r *Router) Readers(ctx context.Context, database string) ([]string, error)
 	return table.Readers, nil
 }
 
-func (r *Router) Writers(ctx context.Context, database string) ([]string, error) {
-	table, err := r.getTable(ctx, database)
+func (r *Router) Writers(ctx context.Context, bookmarks []string, database string) ([]string, error) {
+	table, err := r.getTable(ctx, bookmarks, database)
 	if err != nil {
 		return nil, err
 	}
@@ -174,7 +174,7 @@ func (r *Router) Writers(ctx context.Context, database string) ([]string, error)
 		r.log.Infof(log.Router, r.logId, "Invalidating routing table, no writers")
 		r.Invalidate(database)
 		r.sleep(100 * time.Millisecond)
-		table, err = r.getTable(ctx, database)
+		table, err = r.getTable(ctx, bookmarks, database)
 		if err != nil {
 			return nil, err
 		}
diff --git a/neo4j/internal/router/router_test.go b/neo4j/internal/router/router_test.go
@@ -65,14 +65,14 @@ func TestMultithreading(t *testing.T) {
 	wg.Add(2)
 	consumer := func() {
 		for i := 0; i < 30; i++ {
-			readers, err := router.Readers(context.Background(), dbName)
+			readers, err := router.Readers(context.Background(), nil, dbName)
 			if len(readers) != 2 {
 				t.Error("Wrong number of readers")
 			}
 			if err != nil {
 				t.Error(err)
 			}
-			writers, err := router.Writers(context.Background(), dbName)
+			writers, err := router.Writers(context.Background(), nil, dbName)
 			if len(writers) != 1 {
 				t.Error("Wrong number of writers")
 			}
@@ -114,25 +114,25 @@ func TestRespectsTimeToLiveAndInvalidate(t *testing.T) {
 	dbName := "dbname"
 
 	// First access should trigger initial table read
-	router.Readers(context.Background(), dbName)
+	router.Readers(context.Background(), nil, dbName)
 	assertNum(t, numfetch, 1, "Should have fetched initial")
 
 	// Second access with time set to same should not trigger a read
-	router.Readers(context.Background(), dbName)
+	router.Readers(context.Background(), nil, dbName)
 	assertNum(t, numfetch, 1, "Should not have have fetched")
 
 	// Third access with time passed table due should trigger fetch
 	n = n.Add(2 * time.Second)
-	router.Readers(context.Background(), dbName)
+	router.Readers(context.Background(), nil, dbName)
 	assertNum(t, numfetch, 2, "Should have have fetched")
 
 	// Just another one to make sure we're cached
-	router.Readers(context.Background(), dbName)
+	router.Readers(context.Background(), nil, dbName)
 	assertNum(t, numfetch, 2, "Should not have have fetched")
 
 	// Invalidate should force fetching
 	router.Invalidate(dbName)
-	router.Readers(context.Background(), dbName)
+	router.Readers(context.Background(), nil, dbName)
 	assertNum(t, numfetch, 3, "Should have have fetched")
 }
 
@@ -160,13 +160,13 @@ func TestUsesRootRouterWhenPreviousRoutersFails(t *testing.T) {
 	dbName := "dbname"
 
 	// First access should trigger initial table read from root router
-	router.Readers(context.Background(), dbName)
+	router.Readers(context.Background(), nil, dbName)
 	if borrows[0][0] != "rootRouter" {
 		t.Errorf("Should have connected to root upon first router request")
 	}
 	// Next access should go to otherRouter
 	n = n.Add(2 * time.Second)
-	router.Readers(context.Background(), dbName)
+	router.Readers(context.Background(), nil, dbName)
 	if borrows[1][0] != "otherRouter" {
 		t.Errorf("Should have queried other router")
 	}
@@ -191,7 +191,7 @@ func TestUsesRootRouterWhenPreviousRoutersFails(t *testing.T) {
 		return &testutil.ConnFake{Table: &db.RoutingTable{TimeToLive: 1, Readers: []string{"aReader"}}}, nil
 	}
 	n = n.Add(2 * time.Second)
-	readers, err := router.Readers(context.Background(), dbName)
+	readers, err := router.Readers(context.Background(), nil, dbName)
 	if err != nil {
 		t.Error(err)
 	}
@@ -219,7 +219,7 @@ func TestUseGetRoutersHookWhenInitialRouterFails(t *testing.T) {
 	dbName := "dbname"
 
 	// Trigger read of routing table
-	router.Readers(context.Background(), dbName)
+	router.Readers(context.Background(), nil, dbName)
 
 	expected := []string{rootRouter}
 	expected = append(expected, backupRouters...)
@@ -247,7 +247,7 @@ func TestWritersFailAfterNRetries(t *testing.T) {
 	dbName := "dbname"
 
 	// Should trigger a lot of retries to get a writer until it finally fails
-	writers, err := router.Writers(context.Background(), dbName)
+	writers, err := router.Writers(context.Background(), nil, dbName)
 	if err == nil {
 		t.Error("Should have failed")
 	}
@@ -285,7 +285,7 @@ func TestWritersRetriesWhenNoWriters(t *testing.T) {
 
 	// Should trigger initial table read that contains no writers and a second table read
 	// that gets the writers
-	writers, err := router.Writers(context.Background(), dbName)
+	writers, err := router.Writers(context.Background(), nil, dbName)
 	if err != nil {
 		t.Errorf("Got error: %s", err)
 	}
@@ -323,7 +323,7 @@ func TestReadersRetriesWhenNoReaders(t *testing.T) {
 
 	// Should trigger initial table read that contains no readers and a second table read
 	// that gets the readers
-	readers, err := router.Readers(context.Background(), dbName)
+	readers, err := router.Readers(context.Background(), nil, dbName)
 	if err != nil {
 		t.Errorf("Got error: %s", err)
 	}
@@ -349,8 +349,8 @@ func TestCleanUp(t *testing.T) {
 	router := New("router", func() []string { return []string{} }, nil, pool, logger, "routerid")
 	router.now = func() time.Time { return now }
 
-	router.Readers(context.Background(), "db1")
-	router.Readers(context.Background(), "db2")
+	router.Readers(context.Background(), nil, "db1")
+	router.Readers(context.Background(), nil, "db2")
 
 	// Should be a router for each requested database
 	if len(router.dbRouters) != 2 {
diff --git a/neo4j/internal/testutil/connfake.go b/neo4j/internal/testutil/connfake.go
@@ -105,7 +105,7 @@ func (c *ConnFake) Consume(streamHandle db.StreamHandle) (*db.Summary, error) {
 	return c.ConsumeSum, c.ConsumeErr
 }
 
-func (c *ConnFake) GetRoutingTable(database string, context map[string]string) (*db.RoutingTable, error) {
+func (c *ConnFake) GetRoutingTable(context map[string]string, bookmarks []string, database string) (*db.RoutingTable, error) {
 	return c.Table, c.Err
 }
 
diff --git a/neo4j/internal/testutil/routerfake.go b/neo4j/internal/testutil/routerfake.go
diff --git a/neo4j/session.go b/neo4j/session.go
diff --git a/testkit-backend/backend.go b/testkit-backend/backend.go

Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ type Connection interface {`
`95`	`95`	`// Gets routing table for specified database name or the default database if`
`96`	`96`	`// database equals DefaultDatabase. If the underlying connection does not support`
`97`	`97`	`// multiple databases, DefaultDatabase should be used as database.`
`98`		`- GetRoutingTable(database string, context map[string]string) (*RoutingTable, error)`
	`98`	`+ GetRoutingTable(context map[string]string, bookmarks []string, database string) (*RoutingTable, error)`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`type RoutingTable struct {`
Original file line number	Diff line number	Diff line change
`@@ -26,11 +26,11 @@ type directRouter struct {`
`26`	`26`	`address string`
`27`	`27`	`}`
`28`	`28`
`29`		`-func (r *directRouter) Readers(ctx context.Context, database string) ([]string, error) {`
	`29`	`+func (r *directRouter) Readers(ctx context.Context, bookmarks []string, database string) ([]string, error) {`
`30`	`30`	`return []string{r.address}, nil`
`31`	`31`	`}`
`32`	`32`
`33`		`-func (r *directRouter) Writers(ctx context.Context, database string) ([]string, error) {`
	`33`	`+func (r *directRouter) Writers(ctx context.Context, bookmarks []string, database string) ([]string, error) {`
`34`	`34`	`return []string{r.address}, nil`
`35`	`35`	`}`
`36`	`36`
Original file line number	Diff line number	Diff line change
`@@ -224,8 +224,8 @@ func routingContextFromUrl(useRouting bool, u *url.URL) (map[string]string, erro`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`type sessionRouter interface {`
`227`		`- Readers(ctx context.Context, database string) ([]string, error)`
`228`		`- Writers(ctx context.Context, database string) ([]string, error)`
	`227`	`+ Readers(ctx context.Context, bookmarks []string, database string) ([]string, error)`
	`228`	`+ Writers(ctx context.Context, bookmarks []string, database string) ([]string, error)`
`229`	`229`	`Invalidate(database string)`
`230`	`230`	`CleanUp()`
`231`	`231`	`}`
Original file line number	Diff line number	Diff line change
`@@ -682,7 +682,7 @@ func (b *bolt3) Reset() {`
`682`	`682`	`}`
`683`	`683`	`}`
`684`	`684`
`685`		`-func (b bolt3) GetRoutingTable(database string, context map[string]string) (db.RoutingTable, error) {`
	`685`	`+func (b bolt3) GetRoutingTable(context map[string]string, bookmarks []string, database string) (db.RoutingTable, error) {`
`686`	`686`	`if err := b.assertState(bolt3_ready); err != nil {`
`687`	`687`	`return nil, err`
`688`	`688`	`}`
Original file line number	Diff line number	Diff line change
`@@ -847,25 +847,25 @@ func (b *bolt4) Reset() {`
`847`	`847`	`}`
`848`	`848`	`}`
`849`	`849`
`850`		`-func (b bolt4) GetRoutingTable(database string, context map[string]string) (db.RoutingTable, error) {`
	`850`	`+func (b bolt4) GetRoutingTable(context map[string]string, bookmarks []string, database string) (db.RoutingTable, error) {`
`851`	`851`	`if err := b.assertState(bolt4_ready); err != nil {`
`852`	`852`	`return nil, err`
`853`	`853`	`}`
`854`	`854`
`855`	`855`	`b.log.Infof(log.Bolt4, b.logId, "Retrieving routing table")`
`856`	`856`	`if b.minor > 2 {`
`857`		`- b.out.appendRoute(database, context)`
	`857`	`+ b.out.appendRoute(context, bookmarks, database)`
`858`	`858`	`b.out.send(b.conn)`
`859`	`859`	`succ := b.receiveSuccess()`
`860`	`860`	`if b.err != nil {`
`861`	`861`	`return nil, b.err`
`862`	`862`	`}`
`863`	`863`	`return succ.routingTable, nil`
`864`	`864`	`}`
`865`		`- return b.callGetRoutingTable(database, context)`
	`865`	`+ return b.callGetRoutingTable(context, bookmarks, database)`
`866`	`866`	`}`
`867`	`867`
`868`		`-func (b bolt4) callGetRoutingTable(database string, context map[string]string) (db.RoutingTable, error) {`
	`868`	`+func (b bolt4) callGetRoutingTable(context map[string]string, bookmarks []string, database string) (db.RoutingTable, error) {`
`869`	`869`	`// The query should run in system database, preserve current setting and restore it when`
`870`	`870`	`// done.`
`871`	`871`	`originalDatabaseName := b.databaseName`
`@@ -882,7 +882,7 @@ func (b *bolt4) callGetRoutingTable(database string, context map[string]string)`
`882`	`882`	`runCommand.Cypher = "CALL dbms.routing.getRoutingTable($context, $database)"`
`883`	`883`	`runCommand.Params["database"] = database`
`884`	`884`	`}`
`885`		`- txConfig := db.TxConfig{Mode: db.ReadMode}`
	`885`	`+ txConfig := db.TxConfig{Mode: db.ReadMode, Bookmarks: bookmarks}`
`886`	`886`	`streamHandle, err := b.Run(runCommand, txConfig)`
`887`	`887`	`if err != nil {`
`888`	`888`	`return nil, err`