internal/cmds/gen_hash.go
// Code generated DO NOT EDIT
package cmds
import "strconv"
type Hdel Incomplete
func (b Builder) Hdel() (c Hdel) {
c = Hdel{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "HDEL")
return c
}
func (c Hdel) Key(key string) HdelKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HdelKey)(c)
}
type HdelField Incomplete
func (c HdelField) Field(field ...string) HdelField {
c.cs.s = append(c.cs.s, field...)
return c
}
func (c HdelField) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HdelKey Incomplete
func (c HdelKey) Field(field ...string) HdelField {
c.cs.s = append(c.cs.s, field...)
return (HdelField)(c)
}
type Hexists Incomplete
func (b Builder) Hexists() (c Hexists) {
c = Hexists{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "HEXISTS")
return c
}
func (c Hexists) Key(key string) HexistsKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HexistsKey)(c)
}
type HexistsField Incomplete
func (c HexistsField) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c HexistsField) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HexistsKey Incomplete
func (c HexistsKey) Field(field string) HexistsField {
c.cs.s = append(c.cs.s, field)
return (HexistsField)(c)
}
type Hexpire Incomplete
func (b Builder) Hexpire() (c Hexpire) {
c = Hexpire{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "HEXPIRE")
return c
}
func (c Hexpire) Key(key string) HexpireKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HexpireKey)(c)
}
type HexpireConditionGt Incomplete
func (c HexpireConditionGt) Fields() HexpireFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HexpireFields)(c)
}
type HexpireConditionLt Incomplete
func (c HexpireConditionLt) Fields() HexpireFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HexpireFields)(c)
}
type HexpireConditionNx Incomplete
func (c HexpireConditionNx) Fields() HexpireFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HexpireFields)(c)
}
type HexpireConditionXx Incomplete
func (c HexpireConditionXx) Fields() HexpireFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HexpireFields)(c)
}
type HexpireField Incomplete
func (c HexpireField) Field(field ...string) HexpireField {
c.cs.s = append(c.cs.s, field...)
return c
}
func (c HexpireField) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HexpireFields Incomplete
func (c HexpireFields) Numfields(numfields int64) HexpireNumfields {
c.cs.s = append(c.cs.s, strconv.FormatInt(numfields, 10))
return (HexpireNumfields)(c)
}
type HexpireKey Incomplete
func (c HexpireKey) Seconds(seconds int64) HexpireSeconds {
c.cs.s = append(c.cs.s, strconv.FormatInt(seconds, 10))
return (HexpireSeconds)(c)
}
type HexpireNumfields Incomplete
func (c HexpireNumfields) Field(field ...string) HexpireField {
c.cs.s = append(c.cs.s, field...)
return (HexpireField)(c)
}
type HexpireSeconds Incomplete
func (c HexpireSeconds) Nx() HexpireConditionNx {
c.cs.s = append(c.cs.s, "NX")
return (HexpireConditionNx)(c)
}
func (c HexpireSeconds) Xx() HexpireConditionXx {
c.cs.s = append(c.cs.s, "XX")
return (HexpireConditionXx)(c)
}
func (c HexpireSeconds) Gt() HexpireConditionGt {
c.cs.s = append(c.cs.s, "GT")
return (HexpireConditionGt)(c)
}
func (c HexpireSeconds) Lt() HexpireConditionLt {
c.cs.s = append(c.cs.s, "LT")
return (HexpireConditionLt)(c)
}
func (c HexpireSeconds) Fields() HexpireFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HexpireFields)(c)
}
type Hexpireat Incomplete
func (b Builder) Hexpireat() (c Hexpireat) {
c = Hexpireat{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "HEXPIREAT")
return c
}
func (c Hexpireat) Key(key string) HexpireatKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HexpireatKey)(c)
}
type HexpireatConditionGt Incomplete
func (c HexpireatConditionGt) Fields() HexpireatFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HexpireatFields)(c)
}
type HexpireatConditionLt Incomplete
func (c HexpireatConditionLt) Fields() HexpireatFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HexpireatFields)(c)
}
type HexpireatConditionNx Incomplete
func (c HexpireatConditionNx) Fields() HexpireatFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HexpireatFields)(c)
}
type HexpireatConditionXx Incomplete
func (c HexpireatConditionXx) Fields() HexpireatFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HexpireatFields)(c)
}
type HexpireatField Incomplete
func (c HexpireatField) Field(field ...string) HexpireatField {
c.cs.s = append(c.cs.s, field...)
return c
}
func (c HexpireatField) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HexpireatFields Incomplete
func (c HexpireatFields) Numfields(numfields int64) HexpireatNumfields {
c.cs.s = append(c.cs.s, strconv.FormatInt(numfields, 10))
return (HexpireatNumfields)(c)
}
type HexpireatKey Incomplete
func (c HexpireatKey) UnixTimeSeconds(unixTimeSeconds int64) HexpireatUnixTimeSeconds {
c.cs.s = append(c.cs.s, strconv.FormatInt(unixTimeSeconds, 10))
return (HexpireatUnixTimeSeconds)(c)
}
type HexpireatNumfields Incomplete
func (c HexpireatNumfields) Field(field ...string) HexpireatField {
c.cs.s = append(c.cs.s, field...)
return (HexpireatField)(c)
}
type HexpireatUnixTimeSeconds Incomplete
func (c HexpireatUnixTimeSeconds) Nx() HexpireatConditionNx {
c.cs.s = append(c.cs.s, "NX")
return (HexpireatConditionNx)(c)
}
func (c HexpireatUnixTimeSeconds) Xx() HexpireatConditionXx {
c.cs.s = append(c.cs.s, "XX")
return (HexpireatConditionXx)(c)
}
func (c HexpireatUnixTimeSeconds) Gt() HexpireatConditionGt {
c.cs.s = append(c.cs.s, "GT")
return (HexpireatConditionGt)(c)
}
func (c HexpireatUnixTimeSeconds) Lt() HexpireatConditionLt {
c.cs.s = append(c.cs.s, "LT")
return (HexpireatConditionLt)(c)
}
func (c HexpireatUnixTimeSeconds) Fields() HexpireatFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HexpireatFields)(c)
}
type Hexpiretime Incomplete
func (b Builder) Hexpiretime() (c Hexpiretime) {
c = Hexpiretime{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "HEXPIRETIME")
return c
}
func (c Hexpiretime) Key(key string) HexpiretimeKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HexpiretimeKey)(c)
}
type HexpiretimeField Incomplete
func (c HexpiretimeField) Field(field ...string) HexpiretimeField {
c.cs.s = append(c.cs.s, field...)
return c
}
func (c HexpiretimeField) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HexpiretimeFields Incomplete
func (c HexpiretimeFields) Numfields(numfields int64) HexpiretimeNumfields {
c.cs.s = append(c.cs.s, strconv.FormatInt(numfields, 10))
return (HexpiretimeNumfields)(c)
}
type HexpiretimeKey Incomplete
func (c HexpiretimeKey) Fields() HexpiretimeFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HexpiretimeFields)(c)
}
type HexpiretimeNumfields Incomplete
func (c HexpiretimeNumfields) Field(field ...string) HexpiretimeField {
c.cs.s = append(c.cs.s, field...)
return (HexpiretimeField)(c)
}
type Hget Incomplete
func (b Builder) Hget() (c Hget) {
c = Hget{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "HGET")
return c
}
func (c Hget) Key(key string) HgetKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HgetKey)(c)
}
type HgetField Incomplete
func (c HgetField) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c HgetField) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HgetKey Incomplete
func (c HgetKey) Field(field string) HgetField {
c.cs.s = append(c.cs.s, field)
return (HgetField)(c)
}
type Hgetall Incomplete
func (b Builder) Hgetall() (c Hgetall) {
c = Hgetall{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "HGETALL")
return c
}
func (c Hgetall) Key(key string) HgetallKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HgetallKey)(c)
}
type HgetallKey Incomplete
func (c HgetallKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c HgetallKey) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Hincrby Incomplete
func (b Builder) Hincrby() (c Hincrby) {
c = Hincrby{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "HINCRBY")
return c
}
func (c Hincrby) Key(key string) HincrbyKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HincrbyKey)(c)
}
type HincrbyField Incomplete
func (c HincrbyField) Increment(increment int64) HincrbyIncrement {
c.cs.s = append(c.cs.s, strconv.FormatInt(increment, 10))
return (HincrbyIncrement)(c)
}
type HincrbyIncrement Incomplete
func (c HincrbyIncrement) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HincrbyKey Incomplete
func (c HincrbyKey) Field(field string) HincrbyField {
c.cs.s = append(c.cs.s, field)
return (HincrbyField)(c)
}
type Hincrbyfloat Incomplete
func (b Builder) Hincrbyfloat() (c Hincrbyfloat) {
c = Hincrbyfloat{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "HINCRBYFLOAT")
return c
}
func (c Hincrbyfloat) Key(key string) HincrbyfloatKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HincrbyfloatKey)(c)
}
type HincrbyfloatField Incomplete
func (c HincrbyfloatField) Increment(increment float64) HincrbyfloatIncrement {
c.cs.s = append(c.cs.s, strconv.FormatFloat(increment, 'f', -1, 64))
return (HincrbyfloatIncrement)(c)
}
type HincrbyfloatIncrement Incomplete
func (c HincrbyfloatIncrement) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HincrbyfloatKey Incomplete
func (c HincrbyfloatKey) Field(field string) HincrbyfloatField {
c.cs.s = append(c.cs.s, field)
return (HincrbyfloatField)(c)
}
type Hkeys Incomplete
func (b Builder) Hkeys() (c Hkeys) {
c = Hkeys{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "HKEYS")
return c
}
func (c Hkeys) Key(key string) HkeysKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HkeysKey)(c)
}
type HkeysKey Incomplete
func (c HkeysKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c HkeysKey) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Hlen Incomplete
func (b Builder) Hlen() (c Hlen) {
c = Hlen{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "HLEN")
return c
}
func (c Hlen) Key(key string) HlenKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HlenKey)(c)
}
type HlenKey Incomplete
func (c HlenKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c HlenKey) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Hmget Incomplete
func (b Builder) Hmget() (c Hmget) {
c = Hmget{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "HMGET")
return c
}
func (c Hmget) Key(key string) HmgetKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HmgetKey)(c)
}
type HmgetField Incomplete
func (c HmgetField) Field(field ...string) HmgetField {
c.cs.s = append(c.cs.s, field...)
return c
}
func (c HmgetField) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c HmgetField) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HmgetKey Incomplete
func (c HmgetKey) Field(field ...string) HmgetField {
c.cs.s = append(c.cs.s, field...)
return (HmgetField)(c)
}
type Hmset Incomplete
func (b Builder) Hmset() (c Hmset) {
c = Hmset{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "HMSET")
return c
}
func (c Hmset) Key(key string) HmsetKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HmsetKey)(c)
}
type HmsetFieldValue Incomplete
func (c HmsetFieldValue) FieldValue(field string, value string) HmsetFieldValue {
c.cs.s = append(c.cs.s, field, value)
return c
}
func (c HmsetFieldValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HmsetKey Incomplete
func (c HmsetKey) FieldValue() HmsetFieldValue {
return (HmsetFieldValue)(c)
}
type Hpersist Incomplete
func (b Builder) Hpersist() (c Hpersist) {
c = Hpersist{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "HPERSIST")
return c
}
func (c Hpersist) Key(key string) HpersistKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HpersistKey)(c)
}
type HpersistField Incomplete
func (c HpersistField) Field(field ...string) HpersistField {
c.cs.s = append(c.cs.s, field...)
return c
}
func (c HpersistField) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HpersistFields Incomplete
func (c HpersistFields) Numfields(numfields int64) HpersistNumfields {
c.cs.s = append(c.cs.s, strconv.FormatInt(numfields, 10))
return (HpersistNumfields)(c)
}
type HpersistKey Incomplete
func (c HpersistKey) Fields() HpersistFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HpersistFields)(c)
}
type HpersistNumfields Incomplete
func (c HpersistNumfields) Field(field ...string) HpersistField {
c.cs.s = append(c.cs.s, field...)
return (HpersistField)(c)
}
type Hpexpire Incomplete
func (b Builder) Hpexpire() (c Hpexpire) {
c = Hpexpire{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "HPEXPIRE")
return c
}
func (c Hpexpire) Key(key string) HpexpireKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HpexpireKey)(c)
}
type HpexpireConditionGt Incomplete
func (c HpexpireConditionGt) Fields() HpexpireFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HpexpireFields)(c)
}
type HpexpireConditionLt Incomplete
func (c HpexpireConditionLt) Fields() HpexpireFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HpexpireFields)(c)
}
type HpexpireConditionNx Incomplete
func (c HpexpireConditionNx) Fields() HpexpireFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HpexpireFields)(c)
}
type HpexpireConditionXx Incomplete
func (c HpexpireConditionXx) Fields() HpexpireFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HpexpireFields)(c)
}
type HpexpireField Incomplete
func (c HpexpireField) Field(field ...string) HpexpireField {
c.cs.s = append(c.cs.s, field...)
return c
}
func (c HpexpireField) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HpexpireFields Incomplete
func (c HpexpireFields) Numfields(numfields int64) HpexpireNumfields {
c.cs.s = append(c.cs.s, strconv.FormatInt(numfields, 10))
return (HpexpireNumfields)(c)
}
type HpexpireKey Incomplete
func (c HpexpireKey) Milliseconds(milliseconds int64) HpexpireMilliseconds {
c.cs.s = append(c.cs.s, strconv.FormatInt(milliseconds, 10))
return (HpexpireMilliseconds)(c)
}
type HpexpireMilliseconds Incomplete
func (c HpexpireMilliseconds) Nx() HpexpireConditionNx {
c.cs.s = append(c.cs.s, "NX")
return (HpexpireConditionNx)(c)
}
func (c HpexpireMilliseconds) Xx() HpexpireConditionXx {
c.cs.s = append(c.cs.s, "XX")
return (HpexpireConditionXx)(c)
}
func (c HpexpireMilliseconds) Gt() HpexpireConditionGt {
c.cs.s = append(c.cs.s, "GT")
return (HpexpireConditionGt)(c)
}
func (c HpexpireMilliseconds) Lt() HpexpireConditionLt {
c.cs.s = append(c.cs.s, "LT")
return (HpexpireConditionLt)(c)
}
func (c HpexpireMilliseconds) Fields() HpexpireFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HpexpireFields)(c)
}
type HpexpireNumfields Incomplete
func (c HpexpireNumfields) Field(field ...string) HpexpireField {
c.cs.s = append(c.cs.s, field...)
return (HpexpireField)(c)
}
type Hpexpireat Incomplete
func (b Builder) Hpexpireat() (c Hpexpireat) {
c = Hpexpireat{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "HPEXPIREAT")
return c
}
func (c Hpexpireat) Key(key string) HpexpireatKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HpexpireatKey)(c)
}
type HpexpireatConditionGt Incomplete
func (c HpexpireatConditionGt) Fields() HpexpireatFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HpexpireatFields)(c)
}
type HpexpireatConditionLt Incomplete
func (c HpexpireatConditionLt) Fields() HpexpireatFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HpexpireatFields)(c)
}
type HpexpireatConditionNx Incomplete
func (c HpexpireatConditionNx) Fields() HpexpireatFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HpexpireatFields)(c)
}
type HpexpireatConditionXx Incomplete
func (c HpexpireatConditionXx) Fields() HpexpireatFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HpexpireatFields)(c)
}
type HpexpireatField Incomplete
func (c HpexpireatField) Field(field ...string) HpexpireatField {
c.cs.s = append(c.cs.s, field...)
return c
}
func (c HpexpireatField) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HpexpireatFields Incomplete
func (c HpexpireatFields) Numfields(numfields int64) HpexpireatNumfields {
c.cs.s = append(c.cs.s, strconv.FormatInt(numfields, 10))
return (HpexpireatNumfields)(c)
}
type HpexpireatKey Incomplete
func (c HpexpireatKey) UnixTimeMilliseconds(unixTimeMilliseconds int64) HpexpireatUnixTimeMilliseconds {
c.cs.s = append(c.cs.s, strconv.FormatInt(unixTimeMilliseconds, 10))
return (HpexpireatUnixTimeMilliseconds)(c)
}
type HpexpireatNumfields Incomplete
func (c HpexpireatNumfields) Field(field ...string) HpexpireatField {
c.cs.s = append(c.cs.s, field...)
return (HpexpireatField)(c)
}
type HpexpireatUnixTimeMilliseconds Incomplete
func (c HpexpireatUnixTimeMilliseconds) Nx() HpexpireatConditionNx {
c.cs.s = append(c.cs.s, "NX")
return (HpexpireatConditionNx)(c)
}
func (c HpexpireatUnixTimeMilliseconds) Xx() HpexpireatConditionXx {
c.cs.s = append(c.cs.s, "XX")
return (HpexpireatConditionXx)(c)
}
func (c HpexpireatUnixTimeMilliseconds) Gt() HpexpireatConditionGt {
c.cs.s = append(c.cs.s, "GT")
return (HpexpireatConditionGt)(c)
}
func (c HpexpireatUnixTimeMilliseconds) Lt() HpexpireatConditionLt {
c.cs.s = append(c.cs.s, "LT")
return (HpexpireatConditionLt)(c)
}
func (c HpexpireatUnixTimeMilliseconds) Fields() HpexpireatFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HpexpireatFields)(c)
}
type Hpexpiretime Incomplete
func (b Builder) Hpexpiretime() (c Hpexpiretime) {
c = Hpexpiretime{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "HPEXPIRETIME")
return c
}
func (c Hpexpiretime) Key(key string) HpexpiretimeKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HpexpiretimeKey)(c)
}
type HpexpiretimeField Incomplete
func (c HpexpiretimeField) Field(field ...string) HpexpiretimeField {
c.cs.s = append(c.cs.s, field...)
return c
}
func (c HpexpiretimeField) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HpexpiretimeFields Incomplete
func (c HpexpiretimeFields) Numfields(numfields int64) HpexpiretimeNumfields {
c.cs.s = append(c.cs.s, strconv.FormatInt(numfields, 10))
return (HpexpiretimeNumfields)(c)
}
type HpexpiretimeKey Incomplete
func (c HpexpiretimeKey) Fields() HpexpiretimeFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HpexpiretimeFields)(c)
}
type HpexpiretimeNumfields Incomplete
func (c HpexpiretimeNumfields) Field(field ...string) HpexpiretimeField {
c.cs.s = append(c.cs.s, field...)
return (HpexpiretimeField)(c)
}
type Hpttl Incomplete
func (b Builder) Hpttl() (c Hpttl) {
c = Hpttl{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "HPTTL")
return c
}
func (c Hpttl) Key(key string) HpttlKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HpttlKey)(c)
}
type HpttlField Incomplete
func (c HpttlField) Field(field ...string) HpttlField {
c.cs.s = append(c.cs.s, field...)
return c
}
func (c HpttlField) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HpttlFields Incomplete
func (c HpttlFields) Numfields(numfields int64) HpttlNumfields {
c.cs.s = append(c.cs.s, strconv.FormatInt(numfields, 10))
return (HpttlNumfields)(c)
}
type HpttlKey Incomplete
func (c HpttlKey) Fields() HpttlFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HpttlFields)(c)
}
type HpttlNumfields Incomplete
func (c HpttlNumfields) Field(field ...string) HpttlField {
c.cs.s = append(c.cs.s, field...)
return (HpttlField)(c)
}
type Hrandfield Incomplete
func (b Builder) Hrandfield() (c Hrandfield) {
c = Hrandfield{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "HRANDFIELD")
return c
}
func (c Hrandfield) Key(key string) HrandfieldKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HrandfieldKey)(c)
}
type HrandfieldKey Incomplete
func (c HrandfieldKey) Count(count int64) HrandfieldOptionsCount {
c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
return (HrandfieldOptionsCount)(c)
}
func (c HrandfieldKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HrandfieldOptionsCount Incomplete
func (c HrandfieldOptionsCount) Withvalues() HrandfieldOptionsWithvalues {
c.cs.s = append(c.cs.s, "WITHVALUES")
return (HrandfieldOptionsWithvalues)(c)
}
func (c HrandfieldOptionsCount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HrandfieldOptionsWithvalues Incomplete
func (c HrandfieldOptionsWithvalues) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Hscan Incomplete
func (b Builder) Hscan() (c Hscan) {
c = Hscan{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "HSCAN")
return c
}
func (c Hscan) Key(key string) HscanKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HscanKey)(c)
}
type HscanCount Incomplete
func (c HscanCount) Novalues() HscanNovalues {
c.cs.s = append(c.cs.s, "NOVALUES")
return (HscanNovalues)(c)
}
func (c HscanCount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HscanCursor Incomplete
func (c HscanCursor) Match(pattern string) HscanMatch {
c.cs.s = append(c.cs.s, "MATCH", pattern)
return (HscanMatch)(c)
}
func (c HscanCursor) Count(count int64) HscanCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (HscanCount)(c)
}
func (c HscanCursor) Novalues() HscanNovalues {
c.cs.s = append(c.cs.s, "NOVALUES")
return (HscanNovalues)(c)
}
func (c HscanCursor) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HscanKey Incomplete
func (c HscanKey) Cursor(cursor uint64) HscanCursor {
c.cs.s = append(c.cs.s, strconv.FormatUint(cursor, 10))
return (HscanCursor)(c)
}
type HscanMatch Incomplete
func (c HscanMatch) Count(count int64) HscanCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (HscanCount)(c)
}
func (c HscanMatch) Novalues() HscanNovalues {
c.cs.s = append(c.cs.s, "NOVALUES")
return (HscanNovalues)(c)
}
func (c HscanMatch) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HscanNovalues Incomplete
func (c HscanNovalues) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Hset Incomplete
func (b Builder) Hset() (c Hset) {
c = Hset{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "HSET")
return c
}
func (c Hset) Key(key string) HsetKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HsetKey)(c)
}
type HsetFieldValue Incomplete
func (c HsetFieldValue) FieldValue(field string, value string) HsetFieldValue {
c.cs.s = append(c.cs.s, field, value)
return c
}
func (c HsetFieldValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HsetKey Incomplete
func (c HsetKey) FieldValue() HsetFieldValue {
return (HsetFieldValue)(c)
}
type Hsetnx Incomplete
func (b Builder) Hsetnx() (c Hsetnx) {
c = Hsetnx{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "HSETNX")
return c
}
func (c Hsetnx) Key(key string) HsetnxKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HsetnxKey)(c)
}
type HsetnxField Incomplete
func (c HsetnxField) Value(value string) HsetnxValue {
c.cs.s = append(c.cs.s, value)
return (HsetnxValue)(c)
}
type HsetnxKey Incomplete
func (c HsetnxKey) Field(field string) HsetnxField {
c.cs.s = append(c.cs.s, field)
return (HsetnxField)(c)
}
type HsetnxValue Incomplete
func (c HsetnxValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Hstrlen Incomplete
func (b Builder) Hstrlen() (c Hstrlen) {
c = Hstrlen{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "HSTRLEN")
return c
}
func (c Hstrlen) Key(key string) HstrlenKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HstrlenKey)(c)
}
type HstrlenField Incomplete
func (c HstrlenField) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c HstrlenField) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HstrlenKey Incomplete
func (c HstrlenKey) Field(field string) HstrlenField {
c.cs.s = append(c.cs.s, field)
return (HstrlenField)(c)
}
type Httl Incomplete
func (b Builder) Httl() (c Httl) {
c = Httl{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "HTTL")
return c
}
func (c Httl) Key(key string) HttlKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HttlKey)(c)
}
type HttlField Incomplete
func (c HttlField) Field(field ...string) HttlField {
c.cs.s = append(c.cs.s, field...)
return c
}
func (c HttlField) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HttlFields Incomplete
func (c HttlFields) Numfields(numfields int64) HttlNumfields {
c.cs.s = append(c.cs.s, strconv.FormatInt(numfields, 10))
return (HttlNumfields)(c)
}
type HttlKey Incomplete
func (c HttlKey) Fields() HttlFields {
c.cs.s = append(c.cs.s, "FIELDS")
return (HttlFields)(c)
}
type HttlNumfields Incomplete
func (c HttlNumfields) Field(field ...string) HttlField {
c.cs.s = append(c.cs.s, field...)
return (HttlField)(c)
}
type Hvals Incomplete
func (b Builder) Hvals() (c Hvals) {
c = Hvals{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "HVALS")
return c
}
func (c Hvals) Key(key string) HvalsKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (HvalsKey)(c)
}
type HvalsKey Incomplete
func (c HvalsKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c HvalsKey) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}