2f79f86b7c
Scylla does not support fractions. We need to make sure that time is formatted the following way: XmYsZms
118 lines
2.2 KiB
Go
118 lines
2.2 KiB
Go
// Copyright (C) 2017 ScyllaDB
|
|
// Use of this source code is governed by a ALv2-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package qb
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"time"
|
|
)
|
|
|
|
// TTL converts duration to format expected in USING TTL clause.
|
|
func TTL(d time.Duration) int64 {
|
|
return int64(d.Seconds())
|
|
}
|
|
|
|
// Timestamp converts time to format expected in USING TIMESTAMP clause.
|
|
func Timestamp(t time.Time) int64 {
|
|
return t.UnixNano() / 1000
|
|
}
|
|
|
|
type using struct {
|
|
ttlName string
|
|
timestampName string
|
|
timeoutName string
|
|
ttl int64
|
|
timestamp int64
|
|
timeout time.Duration
|
|
}
|
|
|
|
func (u *using) TTL(d time.Duration) *using {
|
|
u.ttl = TTL(d)
|
|
if u.ttl == 0 {
|
|
u.ttl = -1
|
|
}
|
|
u.timestampName = ""
|
|
return u
|
|
}
|
|
|
|
func (u *using) TTLNamed(name string) *using {
|
|
u.ttl = 0
|
|
u.ttlName = name
|
|
return u
|
|
}
|
|
|
|
func (u *using) Timestamp(t time.Time) *using {
|
|
u.timestamp = Timestamp(t)
|
|
u.timestampName = ""
|
|
return u
|
|
}
|
|
|
|
func (u *using) TimestampNamed(name string) *using {
|
|
u.timestamp = 0
|
|
u.timestampName = name
|
|
return u
|
|
}
|
|
|
|
func (u *using) Timeout(d time.Duration) *using {
|
|
u.timeout = d
|
|
u.timeoutName = ""
|
|
return u
|
|
}
|
|
|
|
func (u *using) TimeoutNamed(name string) *using {
|
|
u.timeout = 0
|
|
u.timeoutName = name
|
|
return u
|
|
}
|
|
|
|
func (u *using) writeCql(cql *bytes.Buffer) (names []string) {
|
|
writePreamble := u.preambleWriter()
|
|
|
|
if u.ttl != 0 {
|
|
if u.ttl == -1 {
|
|
u.ttl = 0
|
|
}
|
|
writePreamble(cql)
|
|
fmt.Fprintf(cql, "TTL %d ", u.ttl)
|
|
} else if u.ttlName != "" {
|
|
writePreamble(cql)
|
|
cql.WriteString("TTL ? ")
|
|
names = append(names, u.ttlName)
|
|
}
|
|
|
|
if u.timestamp != 0 {
|
|
writePreamble(cql)
|
|
fmt.Fprintf(cql, "TIMESTAMP %d ", u.timestamp)
|
|
} else if u.timestampName != "" {
|
|
writePreamble(cql)
|
|
cql.WriteString("TIMESTAMP ? ")
|
|
names = append(names, u.timestampName)
|
|
}
|
|
|
|
if u.timeout != 0 {
|
|
writePreamble(cql)
|
|
fmt.Fprintf(cql, "TIMEOUT %s ", formatDuration(u.timeout))
|
|
} else if u.timeoutName != "" {
|
|
writePreamble(cql)
|
|
cql.WriteString("TIMEOUT ? ")
|
|
names = append(names, u.timeoutName)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (u *using) preambleWriter() func(cql *bytes.Buffer) {
|
|
var hasPreamble bool
|
|
return func(cql *bytes.Buffer) {
|
|
if hasPreamble {
|
|
cql.WriteString("AND ")
|
|
return
|
|
}
|
|
cql.WriteString("USING ")
|
|
hasPreamble = true
|
|
}
|
|
}
|