func main() {
// Connect to Cluster
cluster, err := gocb.Connect("couchbase://127.0.0.1")
if err != nil {
fmt.Println("ERRROR CONNECTING TO CLUSTER:", err)
}
// Open Bucket
bucket, err = cluster.OpenBucket("travel-sample", "")
if err != nil {
fmt.Println("ERRROR OPENING BUCKET:", err)
}
// Setup a new query with a placeholder
myQuery := gocb.NewN1qlQuery("SELECT airportname, city, country FROM `travel-sample` " +
"WHERE type='airport' AND city=$1 ")
// Setup an array for parameters
var myParams []interface{}
myParams = append(myParams, "Reno")
// Execute Query
rows, err := bucket.ExecuteN1qlQuery(myQuery, myParams)
if err != nil {
fmt.Println("ERROR EXECUTING N1QL QUERY:", err)
}
// Iterate through rows and print output
var row interface{}
for rows.Next(&row) {
fmt.Printf("Results: %+v\n", row)
}
// Exiting
fmt.Println("Example Successful - Exiting")
}
func main() {
// Connect to Cluster
cluster, err := gocb.Connect("couchbase://127.0.0.1")
if err != nil {
fmt.Println("ERRROR CONNECTING TO CLUSTER:", err)
}
// Open Bucket
bucket, err = cluster.OpenBucket("travel-sample", "")
if err != nil {
fmt.Println("ERRROR OPENING BUCKET:", err)
}
// Create a document
key := "goDevguideExampleRetrieve"
val := "Retrieve Test Value"
_, err = bucket.Upsert(key, &val, 0)
if err != nil {
fmt.Println("ERRROR CREATING DOCUMENT:", err)
}
// Retrieve Document
var retValue interface{}
_, err = bucket.Get(key, &retValue)
if err != nil {
fmt.Println("ERRROR RETURNING DOCUMENT:", err)
}
fmt.Println("Document Retrieved:", retValue)
// Exiting
fmt.Println("Example Successful - Exiting")
}
func main() {
// Connect to Cluster
cluster, err := gocb.Connect("couchbase://127.0.0.1")
if err != nil {
fmt.Println("ERRROR CONNECTING TO CLUSTER:", err)
}
// Open Bucket
bucket, err = cluster.OpenBucket("travel-sample", "")
if err != nil {
fmt.Println("ERRROR OPENING BUCKET:", err)
}
// Setup a new query for building an index
myQuery := gocb.NewN1qlQuery("CREATE PRIMARY INDEX ON `travel-sample`")
rows, err := bucket.ExecuteN1qlQuery(myQuery, nil)
if err != nil {
fmt.Println("ERROR EXECUTING N1QL QUERY:", err)
}
// Iterate through rows and print output
var row interface{}
for rows.Next(&row) {
fmt.Printf("Results: %+v\n", row)
}
// Exiting
fmt.Println("Example Successful - Exiting")
}
// userById attempts to return a JSON response for the supplied userid
// couchbase errors are handled in the handleError middleware method
func userById(c *gin.Context) {
myCluster, _ := gocb.Connect("couchbase://localhost")
myBucket, _ := myCluster.OpenBucket("gamesim-sample", "")
var value interface{}
_, err := myBucket.Get(c.Params.ByName("userid"), &value)
if err != nil {
c.Error(err).SetType(gin.ErrorTypePublic)
} else {
c.JSON(http.StatusOK, &value)
}
}
func main() {
// Connect to Cluster
cluster, err := gocb.Connect("couchbase://127.0.0.1")
if err != nil {
fmt.Println("ERRROR CONNECTING TO CLUSTER:", err)
}
// Open Bucket
bucket, err = cluster.OpenBucket("travel-sample", "")
if err != nil {
fmt.Println("ERRROR OPENING BUCKET:", err)
}
// Create a JSON document
type Doc struct {
Item string `json:"item"`
}
key := "goDevguideExampleBulkInsert"
val := Doc{"A bulk insert test value"}
// Create Array of BulkOps for Insert, and one for Get
var items []gocb.BulkOp
var itemsGet []gocb.BulkOp
// Add 10 items to the array that will be performed as a bulk operation
for i := 0; i < 10; i++ {
items = append(items, &gocb.InsertOp{Key: key + "_" + strconv.Itoa(i), Value: &val})
}
// Perform the bulk operation to Insert
err = bucket.Do(items)
if err != nil {
fmt.Println("ERRROR PERFORMING BULK INSERT:", err)
}
// Retrieve 10 items to the array that will be performed as a bulk operation
for i := 0; i < 10; i++ {
itemsGet = append(itemsGet, &gocb.GetOp{Key: key + "_" + strconv.Itoa(i), Value: &Doc{}})
}
// Perform the bulk operation to Get
err = bucket.Do(itemsGet)
if err != nil {
fmt.Println("ERRROR PERFORMING BULK GET:", err)
}
// Print the output
for i := 0; i < len(itemsGet); i++ {
fmt.Println(itemsGet[i].(*gocb.GetOp).Key, itemsGet[i].(*gocb.GetOp).Value.(*Doc).Item)
}
// Exiting
fmt.Println("Example Successful - Exiting")
}
func deleteBucket(host string, bucket string, t *testing.T, noErr bool) {
connection, err := gocb.Connect(host)
if err != nil {
t.Fatal("Unable to connect to cluster: " + err.Error())
}
manager := connection.Manager("Administrator", "password")
if err := manager.RemoveBucket(bucket); err != nil && !noErr {
t.Fatalf("Error deleting bucket %s", bucket)
}
}
func main() {
// Connect to Cluster
cluster, err := gocb.Connect("couchbase://127.0.0.1")
if err != nil {
fmt.Println("ERRROR CONNECTING TO CLUSTER:", err)
}
// Open Bucket
bucket, err = cluster.OpenBucket("travel-sample", "")
if err != nil {
fmt.Println("ERRROR OPENING BUCKET:", err)
}
fmt.Println("Example Successful - Exiting")
}
func NewGoCBStorageEngine(couchbaseUrl, bucketName string) *GoCBStorageEngine {
cluster, err := gocb.Connect(couchbaseUrl)
if err != nil {
log.Panicf("Could not connect to %v. Err: %v", couchbaseUrl, err)
}
bucket, err := cluster.OpenBucket(bucketName, "")
if err != nil {
log.Panicf("Could not open bucket: %v. Err: %v", bucket, err)
}
return &GoCBStorageEngine{
Bucket: bucket,
}
}
func newGoCbClient(serverURL string, bucketName string) *goCbClient {
cluster, err := gocb.Connect(serverURL)
if err != nil {
log.Fatalf("Could not connect to %v. Err: %v", serverURL, err)
}
bucket, err := cluster.OpenBucket(bucketName, "")
if err != nil {
log.Fatalf("Could not open bucket: %v. Err: %v", bucketName, err)
}
return &goCbClient{
bucket: bucket,
}
}
// userlist queries the playerlist view from the gamesim bucket and returns
// a JSON response containing all documents returned by the view
func userList(c *gin.Context) {
myCluster, _ := gocb.Connect("couchbase://localhost")
myBucket, _ := myCluster.OpenBucket("gamesim-sample", "")
myQuery := gocb.NewViewQuery("players", "playerlist")
rows := myBucket.ExecuteViewQuery(myQuery)
var results = make([]map[string]interface{}, 0)
var row interface{}
for rows.Next(&row) {
results = append(results, row.(map[string]interface{}))
}
c.JSON(http.StatusOK, &results)
}
func main() {
// Cluster connection and bucket for couchbase
cluster, _ := gocb.Connect("couchbase://127.0.0.1")
bucket, _ = cluster.OpenBucket("travel-sample", "")
// Http Routing
http.Handle("/", http.FileServer(http.Dir("./static")))
http.HandleFunc("/api/airport/findAll", airportHandler)
http.HandleFunc("/api/flightPath/findAll", flightPathHandler)
http.HandleFunc("/api/user/login", loginHandler)
http.HandleFunc("/api/user/flights", userFlightsHandler)
fmt.Printf("Starting server on :3000\n")
http.ListenAndServe(":3000", nil)
}
func main() {
// Connect to Cluster
cluster, err := gocb.Connect("couchbase://127.0.0.1")
if err != nil {
fmt.Println("ERRROR CONNECTING TO CLUSTER:", err)
}
// Open Bucket
bucket, err = cluster.OpenBucket("travel-sample", "")
if err != nil {
fmt.Println("ERRROR OPENING BUCKET:", err)
}
// Create a document
key := "goDevguideExampleUpdate"
val := "Retrieve Test Value"
_, err = bucket.Upsert(key, &val, 0)
if err != nil {
fmt.Println("ERRROR CREATING DOCUMENT:", err)
}
// Retrieve Document
var retValue interface{}
_, err = bucket.Get(key, &retValue)
if err != nil {
fmt.Println("ERRROR RETURNING DOCUMENT:", err)
}
fmt.Println("Document Retrieved:", retValue)
// Add something to the value
retValue = retValue.(string) + " with Additional Test Value"
// Replace the existing document
_, err = bucket.Replace(key, &retValue, 0, 0)
if err != nil {
fmt.Println("ERRROR REPLACING DOCUMENT:", err)
}
// Retrieve updated document
_, err = bucket.Get(key, &retValue)
if err != nil {
fmt.Println("ERRROR RETURNING DOCUMENT:", err)
}
fmt.Println("Document Retrieved:", retValue)
// Exiting
fmt.Println("Example Successful - Exiting")
}
func deleteAllBuckets(host string, t *testing.T) {
connection, err := gocb.Connect(host)
if err != nil {
t.Fatal("Unable to connect to cluster: " + err.Error())
}
manager := connection.Manager("Administrator", "password")
buckets, err := manager.GetBuckets()
if err != nil {
t.Fatal("Unable to get all buckets: " + err.Error())
}
for _, bucket := range buckets {
if err := manager.RemoveBucket(bucket.Name); err != nil {
t.Fatalf("Error deleting bucket %s", bucket.Name)
}
}
}
func IndexHandler(w http.ResponseWriter, r *http.Request) {
cluster, _ := gocb.Connect("couchbase://localhost")
bucket, _ := cluster.OpenBucket("default", "")
value := "test"
cas, _ := bucket.Insert("snake", &value, 0)
fmt.Printf("Inserted document CAS is `%08x`\n", cas)
snake := lib.Snake{
Points: lib.Points{
lib.Point{
X: 1,
Y: 2,
},
},
}
json.NewEncoder(w).Encode(snake)
}
// Creates a Bucket that talks to a real live Couchbase server.
func GetCouchbaseBucketGoCB(spec BucketSpec) (bucket Bucket, err error) {
// Only wrap the gocb logging when the log key is set, to avoid the overhead of a log keys
// map lookup for every gocb log call
logKeys := GetLogKeys()
if logKeys["gocb"] {
EnableGoCBLogging()
}
cluster, err := gocb.Connect(spec.Server)
if err != nil {
return nil, err
}
password := ""
if spec.Auth != nil {
_, password, _ = spec.Auth.GetCredentials()
}
goCBBucket, err := cluster.OpenBucket(spec.BucketName, password)
if err != nil {
return nil, err
}
spec.MaxNumRetries = 10
spec.InitialRetrySleepTimeMS = 5
// Define channels to limit the number of concurrent single and bulk operations,
// to avoid gocb queue overflow issues
bucket = CouchbaseBucketGoCB{
goCBBucket,
spec,
make(chan struct{}, MaxConcurrentSingleOps),
make(chan struct{}, MaxConcurrentBulkOps),
}
return bucket, err
}
func BenchmarkCouchBaseInsertgocb(b *testing.B) {
var err error
insertUsers := make([]*User, len(couchBaseTestUsers))
copy(insertUsers, couchBaseTestUsers)
db_url, err := url.Parse(*couchBaseUrl)
mf(err, "parse", b)
cluster, err := gocb.Connect(db_url.String())
mf(err, "connect - "+db_url.String(), b)
bucket, err := cluster.OpenBucket(*couchBaseBucket, "")
mf(err, "bucket", b)
b.ResetTimer()
for i := 0; i < b.N; i++ {
user := getUser(i, uuid.NewV4().String(), &couchBaseTestUsers)
_, err := bucket.Insert(user.Id, user, 0)
mf(err, "Insert", b)
}
}
func main() {
// Connect to Cluster
cluster, err := gocb.Connect("couchbase://127.0.0.1")
if err != nil {
fmt.Println("ERRROR CONNECTING TO CLUSTER:", err)
}
// Open Bucket
bucket, err = cluster.OpenBucket("travel-sample", "")
if err != nil {
fmt.Println("ERRROR OPENING BUCKET:", err)
}
// Inbound http handlers
http.Handle("/", http.FileServer(http.Dir("./public")))
http.HandleFunc("/api/query/untyped", queryUntyped)
http.HandleFunc("/api/query/typed", queryTyped)
http.HandleFunc("/api/query/one", queryOne)
fmt.Printf("Starting server on :3000\n")
http.ListenAndServe(":3000", nil)
}
func BenchmarkCouchBaseGetgocb(b *testing.B) {
var err error
db_url, err := url.Parse(*couchBaseUrl)
mf(err, "parse", b)
cluster, err := gocb.Connect(db_url.String())
mf(err, "connect - "+db_url.String(), b)
bucket, err := cluster.OpenBucket(*couchBaseBucket, "")
mf(err, "bucket", b)
b.ResetTimer()
max := len(couchBaseTestUsers)
for i := 0; i < b.N; i++ {
user := &User{}
_, err := bucket.Get(couchBaseTestUsers[rand.Intn(max)].Id, *user)
mf(err, "Get", b)
}
}
func loadData(host string, bucket string, password string, items int,
prefix string, t *testing.T) {
connection, err := gocb.Connect(host)
if err != nil {
t.Fatal("Test data loader cannot connect to the cluster: " + err.Error())
}
b, err := connection.OpenBucket(bucket, password)
if err != nil {
t.Fatal("Test data loader cannot connect to the bucket: " + err.Error())
}
for i := 0; i < items; i++ {
key := prefix + strconv.Itoa(i)
_, err := b.Insert(key, map[string]interface{}{"x": i}, 0)
if err != nil {
t.Fatal("Error setting `" + key + "`, " + err.Error())
}
}
b.Close()
}
func main() {
// Connect to Cluster
cluster, err := gocb.Connect("couchbase://127.0.0.1")
if err != nil {
fmt.Println("ERRROR CONNECTING TO CLUSTER")
panic(err)
}
// Open Bucket
bucket, err = cluster.OpenBucket("default", "")
if err != nil {
fmt.Println("ERRROR OPENING BUCKET")
panic(err)
}
fmt.Println("==> Enter keyword(s):")
scanner := bufio.NewScanner(os.Stdin)
for scanner.Scan() {
word := strings.Replace(scanner.Text(), " ", "+", -1)
meaning, err := lib.GetURL(lib.URL + word)
if err != nil {
fmt.Println("Error fetching from urbandictionary.com")
panic(err)
}
cas, err2 := lib.Upsert(bucket, word, meaning)
if err2 != nil {
fmt.Println(err2)
}
fmt.Printf("Inserted document CAS is `%08x`\n", cas)
fmt.Println("==> Enter keyword(s):")
}
}
func createBucket(host string, settings *gocb.BucketSettings, t *testing.T) {
connection, err := gocb.Connect(host)
if err != nil {
t.Fatal("Unable to connect to cluster: " + err.Error())
}
manager := connection.Manager("Administrator", "password")
err = manager.InsertBucket(settings)
if err != nil {
t.Fatal("Bucket creation failed: " + err.Error())
}
for i := 0; i < 30; i++ {
if isBucketReady(host, settings.Name, t) {
return
}
time.Sleep(1 * time.Second)
}
t.Fatal("Bucket creation timed out")
}
func main() {
// Connect to Cluster
cluster, err := gocb.Connect("couchbase://127.0.0.1")
if err != nil {
fmt.Println("ERRROR CONNECTING TO CLUSTER")
panic(err)
}
// Open Bucket
bucket, err = cluster.OpenBucket("default", "")
if err != nil {
fmt.Println("ERRROR OPENING BUCKET")
panic(err)
}
fmt.Println("==> Enter a JSON document:")
scanner := bufio.NewScanner(os.Stdin)
for scanner.Scan() {
document := scanner.Text()
key, _ := uuid()
cas, err := bucket.Upsert(key, &document, 0)
if err != nil {
fmt.Println("ERROR:", err)
} else {
fmt.Printf("Inserted document CAS is `%08x`\n", cas)
}
fmt.Println("==> Enter a JSON document:")
}
}
func main() {
// Connect to Cluster
cluster, err := gocb.Connect("couchbase://127.0.0.1")
if err != nil {
fmt.Println("ERRROR CONNECTING TO CLUSTER:", err)
}
// Open Bucket
bucket, err = cluster.OpenBucket("travel-sample", "")
if err != nil {
fmt.Println("ERRROR OPENING BUCKET:", err)
}
// Create a document and assign it to 10 - counter works atomically by
// first creating a document if it doesn't exist. If it exists, the
// same method will increment/decrement per the "delta" parameter
key := "goDevguideExampleCounter"
curKeyValue, _, err := bucket.Counter(key, 2, 10, 0)
if err != nil {
fmt.Println("ERRROR CREATING KEY:", err)
}
// Should Print 10
fmt.Println("Initialized Counter:", curKeyValue)
// Issue same operation, increment value by 2, to 12
curKeyValue, _, err = bucket.Counter(key, 2, 10, 0)
if err != nil {
fmt.Println("ERRROR CREATING KEY:", err)
}
// Should Print 12
fmt.Println("Incremented Counter:", curKeyValue)
// Exiting
fmt.Println("Example Successful - Exiting")
}
func main() {
// Create a JSON document struct
type Doc struct {
FirstItem string `json:"firstItem"`
SecondItem string `json:"secondItem"`
ThirdItem string `json:"thirdItem"`
}
// Connect to Cluster
cluster, err := gocb.Connect("couchbase://127.0.0.1")
if err != nil {
fmt.Println("ERRROR CONNECTING TO CLUSTER:", err)
}
// Open Bucket
bucket, err = cluster.OpenBucket("travel-sample", "")
if err != nil {
fmt.Println("ERRROR OPENING BUCKET:", err)
}
// Create a document
key := "goDevguideExampleSubdoc"
val := Doc{"Some Test Field Data for firstItem", "Some Test Field Data for secondItem", "Some Test Field Data for thirdItem"}
_, err = bucket.Upsert(key, &val, 0)
if err != nil {
fmt.Println("ERRROR CREATING DOCUMENT:", err)
}
// Retrieve Full Document, Get operation
var retValue interface{}
_, err = bucket.Get(key, &retValue)
if err != nil {
fmt.Println("ERRROR RETURNING DOCUMENT:", err)
}
fmt.Println("Document Retrieved:", retValue)
// Subdoc Operation: Retrieve Document Fragment for two fields, using LookupIn
frag, err := bucket.LookupIn("goDevguideExampleSubdoc").Get("secondItem").Get("thirdItem").Execute()
if err != nil {
fmt.Println("ERRROR RETURNING DOCUMENT FRAGMENT:", err)
}
// Print results
frag.Content("firstItem", &retValue)
fmt.Println("Document Fragment Retrieved (secondItem):", retValue)
frag.Content("thirdItem", &retValue)
fmt.Println("Document Fragment Retrieved (thirdItem):", retValue)
// Subdoc Operation: Add a fourth item that is an array
frag, err = bucket.MutateIn("goDevguideExampleSubdoc", 0, 0).
Upsert("fourthItem", []string{"250 GT SWB", "250 GTO", "250 LM", "275 GTB"}, true).
Execute()
if err != nil {
fmt.Println("ERRROR ADDING DOCUMENT FRAGMENT:", err)
}
// LookupIn to retrieve the changes
frag, err = bucket.LookupIn("goDevguideExampleSubdoc").Get("fourthItem").Execute()
if err != nil {
fmt.Println("ERRROR RETURNING DOCUMENT FRAGMENT:", err)
}
frag.Content("fourthItem", &retValue)
fmt.Println("Document Fragment Retrieved (fourthItem):", retValue)
// Subdoc Operation: Add a value to a specific position, to the "front" of the fourthItem Array,
// to the "back" of the fourthItem Array, and another unique value to the back of the Array in one operation
frag, err = bucket.MutateIn("goDevguideExampleSubdoc", 0, 0).
ArrayInsert("fourthItem[2]", "250 GTO Series II").
PushFront("fourthItem", "250 GT Lusso", false).
PushBack("fourthItem", "275 GTB/4", false).
AddUnique("fourthItem", "288 GTO", false).
Execute()
if err != nil {
fmt.Println("ERRROR ADDING DOCUMENT FRAGMENT:", err)
}
// LookupIn to retrieve the changes
frag, err = bucket.LookupIn("goDevguideExampleSubdoc").Get("fourthItem").Execute()
if err != nil {
fmt.Println("ERRROR RETURNING DOCUMENT FRAGMENT:", err)
}
frag.Content("fourthItem", &retValue)
fmt.Println("Document Fragment Retrieved (fourthItem):", retValue)
// Subdoc Operation: Remove a value from the fourthItem Array
frag, err = bucket.MutateIn("goDevguideExampleSubdoc", 0, 0).Remove("fourthItem[3]").Execute()
if err != nil {
fmt.Println("ERRROR ADDING DOCUMENT FRAGMENT:", err)
}
// LookupIn to retrieve the changes
frag, err = bucket.LookupIn("goDevguideExampleSubdoc").Get("fourthItem").Execute()
if err != nil {
fmt.Println("ERRROR RETURNING DOCUMENT FRAGMENT:", err)
}
frag.Content("fourthItem", &retValue)
fmt.Println("Document Fragment Retrieved (fourthItem):", retValue)
// Exiting
fmt.Println("Example Successful - Exiting")
}
func listenCouchbase(params Params, state *State, handler func()) {
cluster, err := gocb.Connect(clusterURI)
if err != nil {
log.Printf("failed to connect to cluster: %v", err)
return
}
var connectionName string
if len(params.partitions) > 20 {
connectionName = fmt.Sprintf("DCPL[%d/%s]", rand.Int(), params.partitions[0:20])
} else {
connectionName = fmt.Sprintf("DCPL[%d/%s]", rand.Int(), params.partitions)
}
bucket, err := cluster.OpenStreamingBucket(connectionName, params.bucket, params.password)
if err != nil {
log.Printf("failed to open the bucket %q: %v", params.bucket, err)
return
}
state.bucket = bucket
type partitionState struct {
vbUuid gocbcore.VbUuid
startSeqNo gocbcore.SeqNo
endSeqNo gocbcore.SeqNo
snapStartSeqNo gocbcore.SeqNo
snapEndSeqNo gocbcore.SeqNo
}
direction := parseDirection(params.direction)
agent := bucket.IoRouter()
numServers := agent.NumServers()
partitionsRange := parseRange(params.partitions, bucket)
partitionsState := make([]partitionState, agent.NumVbuckets())
for i := 0; i < numServers; i++ {
_, err = agent.GetVbucketSeqnos(i, func(vbId uint16, lastSeqno gocbcore.SeqNo, err error) {
if err != nil {
log.Printf("failed to get last checkpoint for server %d: %v", i, err)
return
}
switch direction {
case DIRECTION_FROM_CURRENT:
partitionsState[vbId] = partitionState{
startSeqNo: lastSeqno,
endSeqNo: 0xffffffff,
snapStartSeqNo: lastSeqno,
snapEndSeqNo: 0xffffffff,
}
case DIRECTION_TO_CURRENT:
partitionsState[vbId] = partitionState{
startSeqNo: 0,
endSeqNo: lastSeqno,
snapStartSeqNo: 0,
snapEndSeqNo: lastSeqno,
}
}
})
}
for _, p := range partitionsRange {
pid := p
stream := state.NewStream(p)
ps := partitionState{
vbUuid: 0,
startSeqNo: 0,
endSeqNo: 0xffffffff,
snapStartSeqNo: 0,
snapEndSeqNo: 0,
}
if direction != DIRECTION_EVERYTHING {
ps = partitionsState[pid]
agent := bucket.IoRouter()
_, err = agent.GetFailoverLog(pid, func(flog []gocbcore.FailoverEntry, err error) {
if err != nil {
log.Printf("failed to get failover log for vbucket %d: %v", pid, err)
return
}
ps.vbUuid = flog[0].VbUuid
})
if err != nil {
log.Printf("failed to schedule get failover log for vbucket %d: %v", pid, err)
return
}
}
_, err = agent.OpenStream(pid,
ps.vbUuid,
ps.startSeqNo,
ps.endSeqNo,
ps.snapStartSeqNo,
ps.snapEndSeqNo,
stream, func(slog []gocbcore.FailoverEntry, err error) {
if err != nil {
log.Printf("failed to open DCP stream for vbucket %d: %v", pid, err)
// FIXME: close opened streams or just skip failures
return
}
})
if err != nil {
log.Printf("failed to schedule open DCP stream for vbucket %d: %v", pid, err)
// FIXME: close opened streams or just skip failures
return
}
}
handler()
}
func main() {
// Connect to Cluster
cluster, err := gocb.Connect("couchbase://127.0.0.1")
if err != nil {
fmt.Println("ERRROR CONNECTING TO CLUSTER:", err)
}
// Open Bucket
bucket, err = cluster.OpenBucket("travel-sample", "")
if err != nil {
fmt.Println("ERRROR OPENING BUCKET:", err)
}
// Create a document and assign an expiration of 2 seconds
key := "goDevguideExampleExpiration"
val := "Expiration Test Value"
_, err = bucket.Upsert(key, &val, 2)
if err != nil {
fmt.Println("ERRROR CREATING DOCUMENT:", err)
}
// Retrieve Value Right Away
var retValue interface{}
_, err = bucket.Get(key, &retValue)
if err != nil {
fmt.Println("ERRROR RETURNING DOCUMENT:", err)
}
fmt.Println("Document Not Yet Expired:", retValue)
// Sleep for 4 seconds
time.Sleep(4 * time.Second)
// Try to retrieve document when Expired
_, err = bucket.Get(key, &retValue)
if err != nil {
fmt.Println("Document Expired:", err)
}
// Create a document with no expiration, and add an expiry using
// touch after the document is created of 2 seconds
_, err = bucket.Upsert(key, &val, 2)
if err != nil {
fmt.Println("ERRROR CREATING DOCUMENT:", err)
}
// Add an expiry
_, err = bucket.Touch(key, 0, 2)
if err != nil {
fmt.Println("ERRROR TOUCHING DOCUMENT:", err)
}
// Retrieve Document
_, err = bucket.Get(key, &retValue)
if err != nil {
fmt.Println("ERRROR RETURNING DOCUMENT:", err)
}
fmt.Println("Document Not Yet Expired:", retValue)
// Sleep for 4 seconds
time.Sleep(4 * time.Second)
// Try to retrieve document when Expired
_, err = bucket.Get(key, &retValue)
if err != nil {
fmt.Println("Document Expired:", err)
}
// Exiting
fmt.Println("Example Successful - Exiting")
}
func testGet() {
// go func() {
// cluster1, e := gocb.Connect("couchbase://127.0.0.1")
// log.Debugf("connect e=%+v", e)
// if e != nil {
// fmt.Errorf("%+v", e.Error())
// }
// bucket1, e := cluster1.OpenBucket("travel-sample", "")
//
//
// N := 50000
// t1 := time.Now()
//
// for i := 0; i < N; i++ {
// var curUser User
// if _, err := bucket1.Get("*****@*****.**", &curUser); err != nil {
// fmt.Print("bucket get err=", err.Error())
// return
// }else {
// // fmt.Printf("%+v", curUser)
// }
// }
// t2 := time.Now()
// d := t2.Sub(t1)
//
// log.Infof("BenchmarkGo go, %+v times in %+v", N, d)
//
// }()
//
// go func() {
// cluster1, e := gocb.Connect("couchbase://127.0.0.1")
// log.Debugf("connect e=%+v", e)
// if e != nil {
// fmt.Errorf("%+v", e.Error())
// }
// bucket1, e := cluster1.OpenBucket("travel-sample", "")
//
//
// N := 50000
// t1 := time.Now()
//
// for i := 0; i < N; i++ {
// var curUser User
// if _, err := bucket1.Get("*****@*****.**", &curUser); err != nil {
// fmt.Print("bucket get err=", err.Error())
// return
// }else {
// // fmt.Printf("%+v", curUser)
// }
// }
// t2 := time.Now()
// d := t2.Sub(t1)
//
// log.Infof("BenchmarkGo go, %+v times in %+v", N, d)
//
// }()
//
// go func() {
// cluster1, e := gocb.Connect("couchbase://127.0.0.1")
// log.Debugf("connect e=%+v", e)
// if e != nil {
// fmt.Errorf("%+v", e.Error())
// }
// bucket1, e := cluster1.OpenBucket("travel-sample", "")
//
// N := 50000
// t1 := time.Now()
//
// for i := 0; i < N; i++ {
// var curUser User
// if _, err := bucket1.Get("*****@*****.**", &curUser); err != nil {
// fmt.Print("bucket get err=", err.Error())
// return
// }else {
// // fmt.Printf("%+v", curUser)
// }
// }
// t2 := time.Now()
// d := t2.Sub(t1)
//
// log.Infof("BenchmarkGo go, %+v times in %+v", N, d)
//
// }()
//
// go func() {
// cluster1, e := gocb.Connect("couchbase://127.0.0.1")
// log.Debugf("connect e=%+v", e)
// if e != nil {
// fmt.Errorf("%+v", e.Error())
// }
// bucket1, e := cluster1.OpenBucket("travel-sample", "")
//
//
// N := 50000
// t1 := time.Now()
//
//
// for i := 0; i < N; i++ {
// var curUser User
// if _, err := bucket1.Get("*****@*****.**", &curUser); err != nil {
// fmt.Print("bucket get err=", err.Error())
// return
// }else {
// // fmt.Printf("%+v", curUser)
// }
//
// }
// t2 := time.Now()
// d := t2.Sub(t1)
//
// log.Infof("BenchmarkGo go, %+v times in %+v", N, d)
//
// }()
cluster, e := gocb.Connect("couchbase://127.0.0.1")
// cluster, e := gocb.Connect("couchbase://42.62.101.136")
log.Debugf("connect e=%+v", e)
if e != nil {
fmt.Errorf("%+v", e.Error())
}
bucket, e = cluster.OpenBucket("travel-sample", "")
if e != nil {
fmt.Errorf("OpenBucket ERROR=%+v", e.Error())
}
//
// myQuery := gocb.NewN1qlQuery("select * from `travel-sample`")
myQuery := gocb.NewN1qlQuery("select * from `travel-sample` where airportname IS NOT NULL limit 1")
N := 100
t1 := time.Now()
// for i := 0; i < N; i++ {
rows, err := bucket.ExecuteN1qlQuery(myQuery, nil)
if err != nil {
fmt.Println("ERROR EXECUTING N1QL QUERY:", err)
}
var airports []AirportIntermediary
var row AirportIntermediary // 这里的查询结果要严格对应定义的格式,否则转出来的struct的内部值都是空值
log.Infof("rows=%#v", rows)
for rows.Next(&row) {
airports = append(airports, row)
log.Debugf("row=%+v", row)
}
log.Infof("airport = %+v", airports)
if err := rows.Close(); err != nil {
fmt.Printf("N1QL query error: %s\n", err)
}
// }
t2 := time.Now()
d := t2.Sub(t1)
log.Infof("BenchmarkGo, %+v times in %+v", N, d)
}
func testSet() {
buckValue := `this is the value`
// 同时写会出问题..
// go func() {
// cluster1, e := gocb.Connect("couchbase://127.0.0.1")
// log.Debugf("connect e=%+v", e)
// if e != nil {
// fmt.Errorf("%+v", e.Error())
// }
// bucket1, e := cluster1.OpenBucket("travel-sample", "")
//
//
// N := 50000
// t1 := time.Now()
//
// for i := 0; i < N; i++ {
// if _, err := bucket1.Upsert(string("*****@*****.**"), buckValue, 0); err != nil {
// fmt.Print("bucket get err=", err.Error())
// return
// }else {
// }
// }
// t2 := time.Now()
// d := t2.Sub(t1)
//
// log.Infof("BenchmarkGo go, %+v times in %+v", N, d)
//
// }()
//
// go func() {
// cluster1, e := gocb.Connect("couchbase://127.0.0.1")
// log.Debugf("connect e=%+v", e)
// if e != nil {
// fmt.Errorf("%+v", e.Error())
// }
// bucket1, e := cluster1.OpenBucket("travel-sample", "")
//
//
// N := 50000
// t1 := time.Now()
//
// for i := 0; i < N; i++ {
// if _, err := bucket1.Upsert(string("*****@*****.**"), buckValue, 0); err != nil {
// fmt.Print("bucket get err=", err.Error())
// return
// }else {
// }
// }
// t2 := time.Now()
// d := t2.Sub(t1)
//
// log.Infof("BenchmarkGo go, %+v times in %+v", N, d)
//
// }()
//
// go func() {
// cluster1, e := gocb.Connect("couchbase://127.0.0.1")
// log.Debugf("connect e=%+v", e)
// if e != nil {
// fmt.Errorf("%+v", e.Error())
// }
// bucket1, e := cluster1.OpenBucket("travel-sample", "")
//
//
// N := 50000
// t1 := time.Now()
//
// for i := 0; i < N; i++ {
// if _, err := bucket1.Upsert(string("*****@*****.**"), buckValue, 0); err != nil {
// fmt.Print("bucket get err=", err.Error())
// return
// }else {
// }
// }
// t2 := time.Now()
// d := t2.Sub(t1)
//
// log.Infof("BenchmarkGo go, %+v times in %+v", N, d)
//
// }()
//
// go func() {
// cluster1, e := gocb.Connect("couchbase://127.0.0.1")
// log.Debugf("connect e=%+v", e)
// if e != nil {
// fmt.Errorf("%+v", e.Error())
// }
// bucket1, e := cluster1.OpenBucket("travel-sample", "")
//
//
// N := 50000
// t1 := time.Now()
//
// for i := 0; i < N; i++ {
// if _, err := bucket1.Upsert(string("*****@*****.**"), buckValue, 0); err != nil {
// fmt.Print("bucket get err=", err.Error())
// return
// }else {
// }
// }
// t2 := time.Now()
// d := t2.Sub(t1)
//
// log.Infof("BenchmarkGo go, %+v times in %+v", N, d)
//
// }()
cluster1, e := gocb.Connect("couchbase://127.0.0.1")
log.Debugf("connect e=%+v", e)
if e != nil {
fmt.Errorf("%+v", e.Error())
}
bucket1, e := cluster1.OpenBucket("travel-sample", "")
N := 1
t1 := time.Now()
for i := 0; i < N; i++ {
if _, err := bucket1.Upsert(string("*****@*****.**"), buckValue, 0); err != nil {
fmt.Print("bucket get err=", err.Error())
return
} else {
}
}
t2 := time.Now()
d := t2.Sub(t1)
log.Infof("BenchmarkGo go, %+v times in %+v", N, d)
}
func main() {
// Connect to Cluster
cluster, err := gocb.Connect("couchbase://127.0.0.1")
if err != nil {
fmt.Println("ERRROR CONNECTING TO CLUSTER:", err)
}
// Open Bucket
bucket, err = cluster.OpenBucket("travel-sample", "")
if err != nil {
fmt.Println("ERRROR OPENING BUCKET:", err)
}
// Set Durability Timeout to 3 seconds, default is 40 seconds
bucket.SetDurabilityTimeout(3 * time.Second)
// Create a document and assign a "Persist To" value of 1 node.
// Should Always Succeed, even on single node cluster.
// NOTICE the function signature:
// Bucket.UpsertDura(key, value, expiry, replicateTo, _PERSIST_TO_)
key := "goDevguideExamplePersistTo"
val := "Durabilty PersistTo Test Value"
_, err = bucket.UpsertDura(key, &val, 0, 0, 1)
if err != nil {
fmt.Println("ERROR, DURABILITY Persist Example:", err)
}
// Retrieve Value Persist To
var retValue interface{}
_, err = bucket.Get(key, &retValue)
if err != nil {
fmt.Println("ERRROR RETURNING DOCUMENT:", err)
}
fmt.Println("Document Retrieved:", retValue)
// Create a document and assign a "Replicate To" value of 1 node.
// Should Fail on a single node cluster, succeed on a multi node
// cluster of 3 or more nodes with at least one replica enabled.
// NOTICE the function signature:
// Bucket.UpsertDura(key, value, expiry, _REPLICATE_TO_, persistTo)
key = "goDevguideExampleReplicateTo"
val = "Durabilty ReplicateTo Test Value"
_, err = bucket.UpsertDura(key, &val, 0, 1, 0)
if err != nil {
fmt.Println("ERROR, DURABILITY Replicate Example:", err)
}
// Retrieve Value Replicate To
// Should succeed even if durability fails, as the document was
// still written.
_, err = bucket.Get(key, &retValue)
if err != nil {
fmt.Println("ERRROR RETURNING DOCUMENT:", err)
}
fmt.Println("Document Retrieved:", retValue)
// Create a document and assign a "Replicate To" and a "Persist TO"
// value of 1 node. Should Fail on a single node cluster, succeed on
// a multi node cluster of 3 or more nodes with at least one replica
// enabled.
// NOTICE the function signature:
// Bucket.UpsertDura(key, value, expiry, _REPLICATE_TO_, _PERSIST_TO_)
key = "goDevguideExampleReplicateToAndPersistTo"
val = "Durabilty ReplicateTo and PersistTo Test Value"
_, err = bucket.UpsertDura(key, &val, 0, 1, 1)
if err != nil {
fmt.Println("ERROR, DURABILITY Replicate and Persist Example:", err)
}
// Retrieve Value Replicate To and Persist To
// Should succeed even if durability fails, as the document was
// still written.
_, err = bucket.Get(key, &retValue)
if err != nil {
fmt.Println("ERRROR RETURNING DOCUMENT:", err)
}
fmt.Println("Document Retrieved:", retValue)
// Exiting
fmt.Println("Example Complete - Exiting")
}