1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
package tests
import (
"fmt"
r "gopkg.in/rethinkdb/rethinkdb-go.v6"
)
// Return the first five squares.
func ExampleTerm_Map() {
cur, err := r.Expr([]int{1, 2, 3, 4, 5}).Map(func(val r.Term) r.Term {
return val.Mul(val)
}).Run(session)
if err != nil {
fmt.Print(err)
return
}
var res []int
err = cur.All(&res)
if err != nil {
fmt.Print(err)
return
}
fmt.Print(res)
// Output:
// [1 4 9 16 25]
}
// Sum the elements of three sequences.
func ExampleMap_multipleSequences() {
var sequence1 = []int{100, 200, 300, 400}
var sequence2 = []int{10, 20, 30, 40}
var sequence3 = []int{1, 2, 3, 4}
cur, err := r.Map(sequence1, sequence2, sequence3, func(val1, val2, val3 r.Term) r.Term {
return val1.Add(val2).Add(val3)
}).Run(session)
if err != nil {
fmt.Print(err)
return
}
var res []int
err = cur.All(&res)
if err != nil {
fmt.Print(err)
return
}
fmt.Print(res)
// Output:
// [111 222 333 444]
}
// Order all the posts using the index date.
func ExampleTerm_OrderBy_index() {
cur, err := r.DB("examples").Table("posts").OrderBy(r.OrderByOpts{
Index: "date",
}).Run(session)
if err != nil {
fmt.Print(err)
return
}
var res []interface{}
err = cur.All(&res)
if err != nil {
fmt.Print(err)
return
}
fmt.Print(res)
}
// Order all the posts using the index date in descending order.
func ExampleTerm_OrderBy_indexDesc() {
cur, err := r.DB("examples").Table("posts").OrderBy(r.OrderByOpts{
Index: r.Desc("date"),
}).Run(session)
if err != nil {
fmt.Print(err)
return
}
var res []interface{}
err = cur.All(&res)
if err != nil {
fmt.Print(err)
return
}
fmt.Print(res)
}
// You can efficiently order using multiple fields by using a compound index.
// For example order by date and title.
func ExampleTerm_OrderBy_compound() {
cur, err := r.DB("examples").Table("posts").OrderBy(r.OrderByOpts{
Index: r.Desc("dateAndTitle"),
}).Run(session)
if err != nil {
fmt.Print(err)
return
}
var res []interface{}
err = cur.All(&res)
if err != nil {
fmt.Print(err)
return
}
fmt.Print(res)
}
// If you have a sequence with fewer documents than the arrayLimit, you can order
// it by multiple fields without an index.
func ExampleTerm_OrderBy_multiple() {
cur, err := r.DB("examples").Table("posts").OrderBy(
"title",
r.OrderByOpts{Index: r.Desc("date")},
).Run(session)
if err != nil {
fmt.Print(err)
return
}
var res []interface{}
err = cur.All(&res)
if err != nil {
fmt.Print(err)
return
}
fmt.Print(res)
}
// Notice that an index ordering always has highest precedence. The following
// query orders posts by date, and if multiple posts were published on the same
// date, they will be ordered by title.
func ExampleTerm_OrderBy_multipleWithIndex() {
cur, err := r.DB("examples").Table("posts").OrderBy(
"title",
r.OrderByOpts{Index: r.Desc("date")},
).Run(session)
if err != nil {
fmt.Print(err)
return
}
var res []interface{}
err = cur.All(&res)
if err != nil {
fmt.Print(err)
return
}
fmt.Print(res)
}
|
