func (r *Rethinkdb) recreateTable() { if r.debug { fmt.Printf("dropping and creating table '%s' on database '%s'\n", r.table, r.database) } gorethink.DB(r.database).TableDrop(r.table).RunWrite(r.client) gorethink.DB(r.database).TableCreate(r.table).RunWrite(r.client) }
func subscribeHandler(c *echo.Context) (err error) { ws := c.Socket() if err = websocket.JSON.Send(ws, "connected"); err != nil { log.Println(err) return } res, err := r.DB("notifications").Table("notification").Changes().Run(session) if err != nil { log.Println(err) return } var value interface{} defer res.Close() for res.Next(&value) { websocket.JSON.Send(ws, value) } return }
func TableSetup(db, table string, optArgs ...r.TableCreateOpts) (r.WriteResponse, error) { wr, err := r.DBCreate(db).RunWrite(Session()) if err != nil { return wr, err } return r.DB(db).TableCreate(table, optArgs...).RunWrite(Session()) }
func main() { fmt.Println("Connecting to RethinkDB") session, err := r.Connect(r.ConnectOpts{ Address: "localhost:7704", Database: "players", }) session.SetMaxOpenConns(10) if err != nil { log.Fatal("Could not connect") } r.DBDrop("players").Exec(session) err = r.DBCreate("players").Exec(session) if err != nil { panic(err) } err = r.DB("players").TableDrop("scores").Exec(session) err = r.DB("players").TableCreate("scores").Exec(session) if err != nil { log.Fatal("Could not create table", err) } err = r.DB("players").Table("scores").IndexCreate("Score").Exec(session) if err != nil { log.Fatal("Could not create index") } fmt.Println("Inserting new records") for i := 0; i < 10000; i++ { player := new(ScoreEntry) player.ID = strconv.Itoa(i) player.PlayerName = fmt.Sprintf("Player %d", i) player.Score = rand.Intn(100) _, err := r.Table("scores").Insert(player).RunWrite(session) if err != nil { log.Fatal(err) } } }
func createNotificationHandler(response http.ResponseWriter, request *http.Request) { sent_value := request.FormValue("value") notif := new(Notification) notif.Value = sent_value err := r.DB("notifications").Table("notification").Insert(notif).Exec(session) if err != nil { http.Error(response, err.Error(), 500) log.Println(err) } }
func setupHandler(response http.ResponseWriter, request *http.Request) { err := r.DBCreate("notifications").Exec(session) if err != nil { http.Error(response, err.Error(), 500) log.Println(err) err = r.DB("notifications").TableCreate("notification").Exec(session) if err != nil { http.Error(response, err.Error(), 500) log.Println(err) } } }
func getAllHandler(response http.ResponseWriter, request *http.Request) { rows, err := r.DB("notifications").Table("notification").Run(session) if err == nil { defer rows.Close() var row Notification for rows.Next(&row) { response.Write([]byte(row.Value)) response.Write([]byte(" | ")) } } else { http.Error(response, err.Error(), 500) log.Println(err) } }
func (r *Rethinkdb) assertServerVersion(constraint version.Constraints) error { cursor, err := gorethink.DB("rethinkdb").Table("server_status").Run(r.client) if err != nil { return err } if cursor.IsNil() { return errors.New("could not determine the RethinkDB server version: no rows returned from the server_status table") } var serverStatus rethinkDbServerStatus cursor.Next(&serverStatus) if serverStatus.Process.Version == "" { return errors.New("could not determine the RethinkDB server version: process.version key missing") } pieces := strings.Split(serverStatus.Process.Version, " ") if len(pieces) < 2 { return fmt.Errorf("could not determine the RethinkDB server version: malformed version string (%v)", serverStatus.Process.Version) } versionString := rethinkDbVersionMatcher.FindString(pieces[1]) if versionString == "" { return fmt.Errorf("could not determine the RethinkDB server version: malformed version string (%v)", serverStatus.Process.Version) } if r.debug { fmt.Printf("RethinkDB version: %v\n", versionString) } serverVersion, err := version.NewVersion(versionString) if err != nil { return fmt.Errorf("could not determine the RethinkDB server version: malformed version string (%v)", serverStatus.Process.Version) } if !constraint.Check(serverVersion) { return fmt.Errorf("RethinkDB server version too old: expected %v, but was %v", constraint, serverVersion) } return nil }
// Start the adaptor as a source func (r *Rethinkdb) Start() error { tables, err := gorethink.DB(r.database).TableList().Run(r.client) if err != nil { return err } defer tables.Close() var ( wg sync.WaitGroup outerr error table string ) for tables.Next(&table) { if match := r.tableMatch.MatchString(table); !match { if r.debug { fmt.Printf("table, %s, didn't match\n", table) } continue } wg.Add(1) start := make(chan bool) if r.tail { go r.startupChangesForTable(table, start, &wg) } go func(table string) { defer wg.Done() if err := r.sendAllDocuments(table); err != nil { r.pipe.Err <- err outerr = err } else if r.tail { start <- true } close(start) }(table) } wg.Wait() return nil }
func Run(db, table string, run DBRun, optArgs ...r.RunOpts) (*r.Cursor, error) { tbl := r.DB(db).Table(table) term := run(tbl) return term.Run(Session(), optArgs...) }
func TableCreate(db, table string, optArgs ...r.TableCreateOpts) (r.WriteResponse, error) { return r.DB(db).TableCreate(table, optArgs...).RunWrite(Session()) }
func TestDial(t *testing.T) { Convey("Given rethinkdb host, db name, table name", t, func() { host := "localhost:28015" dbName := "rethinker_test" tableName := "contacts" Printf("host[%s] db[%s] table[%s] \n", host, dbName, tableName) Convey("Startup connection", func() { var err error err = Startup(r.ConnectOpts{ Address: host, }) So(err, ShouldBeNil) Convey("Create db", func() { _, err = r.DBCreate(dbName).RunWrite(Session()) So(err, ShouldBeNil) Convey("Create table", func() { _, err = r.DB(dbName).TableCreate(tableName).RunWrite(Session()) So(err, ShouldBeNil) Convey("Insert item", func() { _, err := RunWrite(dbName, tableName, func(table r.Term) r.Term { return table.Insert(map[string]interface{}{ "first_name": "tester", }) }) So(err, ShouldBeNil) }) // Convey("Find item", func() { // c, err := Run(dbName, tableName, func(table r.Term) r.Term { // return table.GetAllByIndex(0) // }) // So(err, ShouldBeNil) // item := make(map[string]interface{}) // c.One(&item) // So(item["first_name"], ShouldEqual, "tester") // }) // Convey("Delete item", func() { // _, err := RunWrite(dbName, tableName, func(table r.Term) r.Term { // return table.Delete() // }) // So(err, ShouldBeNil) // }) Reset(func() { r.DB(dbName).TableDrop(tableName).RunWrite(Session()) }) }) }) Reset(func() { r.DBDrop(dbName).RunWrite(Session()) }) }) }) }
func RunWrite(db, table string, run DBRun, optArgs ...r.RunOpts) (r.WriteResponse, error) { tbl := r.DB(db).Table(table) term := run(tbl) return term.RunWrite(Session(), optArgs...) }
func dropTable(name string) { r.DB(RethinkDBName).TableDrop(name).Exec(Rethink) }
func createTable(name string) { r.DB(RethinkDBName).TableCreate(name).Exec(Rethink) }
func IndexCreate(db, table string, name interface{}, optArgs ...r.IndexCreateOpts) (r.WriteResponse, error) { return r.DB(db).Table(table).IndexCreate(name, optArgs...).RunWrite(Session()) }
func TableDrop(db, table string) (r.WriteResponse, error) { return r.DB(db).TableDrop(table).RunWrite(Session()) }
func Table(db, table string) r.Term { return r.DB(db).Table(table) }