通过GoCQL在ScyllaDB上进行阻塞/一致/可预测的回复/请求。

huangapple go评论85阅读模式
英文:

Make a blocking/consistent/predictable reply/request on ScyllaDB via GoCQL

问题

有时候运行命令时会显示超时错误(gocql: no response received from cassandra within timeout period),例如:

package main

import "fmt"
import "github.com/gocql/gocql"
import "time"
import "log"

func main() {
    clust := gocql.NewCluster(`172.17.0.2`) // docker@localhost
    clust.Keyspace = `test4`
    clust.RetryPolicy = &gocql.SimpleRetryPolicy{NumRetries: 3}
    db, err := clust.CreateSession()
    defer db.Close()
    if err != nil {
        log.Fatal(err)
        return
    }
    fmt.Println(`test4: scylladb`)

    if err := db.Query(`DROP TABLE test4`).Exec(); err != nil {
        log.Println(err)
    }
    if err := db.Query(`CREATE TABLE test4 (bucket text, k text, v TEXT, PRIMARY KEY(bucket,k))`).Exec(); err != nil {
        log.Fatal(err)
        return
    }

    const max = 999
    const jump = 40
    t := time.Now()
    for x := 1; x <= max; x++ {
        err = db.Query(fmt.Sprintf(`INSERT INTO test4(bucket,k,v)VALUES('foo','%05d','%05d')`, x, x)).Exec()
        if err != nil {
            log.Fatal(err)
            return
        }
        if x % 200 == 0 {
            fmt.Print(`.`)
        }
    }
    dur := time.Now().Sub(t)
    fmt.Printf("INSERT: %v (%.2f ms/op)\n", dur, float64(dur.Nanoseconds()) / 1000000 / max)

    t = time.Now()
    for x := 1; x <= max; x++ {
        err = db.Query(fmt.Sprintf(`UPDATE test4 SET v = '%06d' WHERE bucket = 'foo' AND k = '%05d'`, x, x)).Exec()
        if err != nil {
            log.Fatal(err)
            return
        }
        if x % 200 == 0 {
            fmt.Print(`.`)
        }
    }
    dur = time.Now().Sub(t)
    fmt.Printf("UPDATE: %v (%.2f ms/op)\n", dur, float64(dur.Nanoseconds()) / 1000000 / max)

    t = time.Now()
    ops := int64(0)
    for y := 2; y < jump; y++ {
        for x := max - 1; x > 0; x -= y {
            ops++
            iter := db.Query(fmt.Sprintf(`SELECT k, v FROM test4 WHERE bucket = 'foo' AND  k >= '%05d' ORDER BY k ASC LIMIT %d`, x, y * y)).Iter()
            for {
                m := map[string]interface{}{}
                if !iter.MapScan(m) {
                    break
                }
            }
            iter.Close()
            if ops % 500 == 0 {
                fmt.Print(`.`)
            }
        }
        for x := 1; x < max; x += y {
            ops++
            iter := db.Query(fmt.Sprintf(`SELECT k, v FROM test4 WHERE bucket = 'foo' AND k <= '%05d' ORDER BY k DESC LIMIT %d`, x, y * y)).Iter()
            for {
                m := map[string]interface{}{}
                if !iter.MapScan(m) {
                    break
                }
            }
            iter.Close()
            if ops % 500 == 0 {
                fmt.Print(`.`)
            }
        }
    }
    dur = time.Now().Sub(t)
    fmt.Printf("SELECT: %v (%.2f ms/op)\n", dur, float64(dur.Nanoseconds()) / 1000000 / float64(ops))

}

它显示不一致的输出:

$ go run scylla.go
test4: scylladb
2017/05/16 12:09:05 gocql: no response received from cassandra within timeout period
2017/05/16 12:09:05 gocql: no response received from cassandra within timeout period
exit status 1

$ go run scylla.go 
test4: scylladb
....INSERT: 188.277521ms (0.19 ms/op)
....UPDATE: 150.403282ms (0.15 ms/op)
.............SELECT: 5.357779756s (0.82 ms/op)

$ go run scylla.go 
test4: scylladb
2017/05/16 12:09:50 gocql: no response received from cassandra within timeout period
....INSERT: 142.91132ms (0.14 ms/op)
....UPDATE: 144.272872ms (0.14 ms/op)
.............SELECT: 5.268130283s (0.81 ms/op)

$ go run scylla.go 
test4: scylladb
2017/05/16 12:10:00 gocql: no response received from cassandra within timeout period
2017/05/16 12:10:00 gocql: no response received from cassandra within timeout period
exit status 1

$ go run scylla.go 
test4: scylladb
....INSERT: 184.402052ms (0.18 ms/op)
....UPDATE: 158.200184ms (0.16 ms/op)
.............SELECT: 5.345212835s (0.82 ms/op)

如何使其保持一致?我需要确保命令是否成功完成。或者我应该手动循环执行 DROP TABLE/CREATE TABLE 命令吗?

英文:

Sometimes when running a command it shows a timeout (gocql: no response received from cassandra within timeout period), for example:

package main
import &quot;fmt&quot;
import &quot;github.com/gocql/gocql&quot;
import &quot;time&quot;
import &quot;log&quot;
func main() {
clust := gocql.NewCluster(`172.17.0.2`) // docker@localhost
clust.Keyspace = `test4`
clust.RetryPolicy = &amp;gocql.SimpleRetryPolicy{NumRetries: 3}
db, err := clust.CreateSession()
defer db.Close()
if err != nil {
log.Fatal(err)
return
}
fmt.Println(`test4: scylladb`)
if err := db.Query(`DROP TABLE test4`).Exec(); err != nil {
log.Println(err)
}
if err := db.Query(`CREATE TABLE test4 (bucket text, k text, v TEXT, PRIMARY KEY(bucket,k))`).Exec(); err != nil {
log.Fatal(err)
return
}
const max = 999
const jump = 40
t := time.Now()
for x := 1; x &lt;= max; x++ {
err = db.Query(fmt.Sprintf(`INSERT INTO test4(bucket,k,v)VALUES(&#39;foo&#39;,&#39;%05d&#39;,&#39;%05d&#39;)`, x, x)).Exec()
if err != nil {
log.Fatal(err)
return
}
if x % 200 == 0 {
fmt.Print(`.`)
}
}
dur := time.Now().Sub(t)
fmt.Printf(&quot;INSERT: %v (%.2f ms/op)\n&quot;, dur, float64(dur.Nanoseconds()) / 1000000 / max)
t = time.Now()
for x := 1; x &lt;= max; x++ {
err = db.Query(fmt.Sprintf(`UPDATE test4 SET v = &#39;%06d&#39; WHERE bucket = &#39;foo&#39; AND k = &#39;%05d&#39;`, x, x)).Exec()
if err != nil {
log.Fatal(err)
return
}
if x % 200 == 0 {
fmt.Print(`.`)
}
}
dur = time.Now().Sub(t)
fmt.Printf(&quot;UPDATE: %v (%.2f ms/op)\n&quot;, dur, float64(dur.Nanoseconds()) / 1000000 / max)
t = time.Now()
ops := int64(0)
for y := 2; y &lt; jump; y++ {
for x := max - 1; x &gt; 0; x -= y {
ops++
iter := db.Query(fmt.Sprintf(`SELECT k, v FROM test4 WHERE bucket = &#39;foo&#39; AND  k &gt;= &#39;%05d&#39; ORDER BY k ASC LIMIT %d`, x, y * y)).Iter()
for {
m := map[string]interface{}{}
if !iter.MapScan(m) {
break
}
}
iter.Close()
if ops % 500 == 0 {
fmt.Print(`.`)
}
}
for x := 1; x &lt; max; x += y {
ops++
iter := db.Query(fmt.Sprintf(`SELECT k, v FROM test4 WHERE bucket = &#39;foo&#39; AND k &lt;= &#39;%05d&#39; ORDER BY k DESC LIMIT %d`, x, y * y)).Iter()
for {
m := map[string]interface{}{}
if !iter.MapScan(m) {
break
}
}
iter.Close()
if ops % 500 == 0 {
fmt.Print(`.`)
}
}
}
dur = time.Now().Sub(t)
fmt.Printf(&quot;SELECT: %v (%.2f ms/op)\n&quot;, dur, float64(dur.Nanoseconds()) / 1000000 / float64(ops))
}

It shows inconsistent output:

$ go run scylla.go
test4: scylladb
2017/05/16 12:09:05 gocql: no response received from cassandra within timeout period
2017/05/16 12:09:05 gocql: no response received from cassandra within timeout period
exit status 1
$ go run scylla.go 
test4: scylladb
....INSERT: 188.277521ms (0.19 ms/op)
....UPDATE: 150.403282ms (0.15 ms/op)
.............SELECT: 5.357779756s (0.82 ms/op)
$ go run scylla.go 
test4: scylladb
2017/05/16 12:09:50 gocql: no response received from cassandra within timeout period
....INSERT: 142.91132ms (0.14 ms/op)
....UPDATE: 144.272872ms (0.14 ms/op)
.............SELECT: 5.268130283s (0.81 ms/op)
$ go run scylla.go 
test4: scylladb
2017/05/16 12:10:00 gocql: no response received from cassandra within timeout period
2017/05/16 12:10:00 gocql: no response received from cassandra within timeout period
exit status 1
$ go run scylla.go 
test4: scylladb
....INSERT: 184.402052ms (0.18 ms/op)
....UPDATE: 158.200184ms (0.16 ms/op)
.............SELECT: 5.345212835s (0.82 ms/op)

How to make it consistent? I need to be sure if a command completed successfully.. Or should I loop the DROP TABLE/CREATE TABLE command manually?

答案1

得分: 2

DROP TABLECREATE TABLE比普通查询要花费更长的时间。你可以尝试增加这些查询的超时时间。

例如:clust.Timeout = 8 * time.Second

英文:

DROP TABLE and CREATE TABLE can take a lot longer than ordinary queries. You can try to increase the timeouts for these queries.

For example: clust.Timeout = 8 * time.Second

huangapple
  • 本文由 发表于 2017年5月16日 13:13:10
  • 转载请务必保留本文链接:https://go.coder-hub.com/43992997.html
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定