go.etcd.io/etcd@v3.3.27+incompatible/clientv3/compare.go (about) 1 // Copyright 2016 The etcd Authors 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 package clientv3 16 17 import ( 18 pb "github.com/coreos/etcd/etcdserver/etcdserverpb" 19 ) 20 21 type CompareTarget int 22 type CompareResult int 23 24 const ( 25 CompareVersion CompareTarget = iota 26 CompareCreated 27 CompareModified 28 CompareValue 29 ) 30 31 type Cmp pb.Compare 32 33 func Compare(cmp Cmp, result string, v interface{}) Cmp { 34 var r pb.Compare_CompareResult 35 36 switch result { 37 case "=": 38 r = pb.Compare_EQUAL 39 case "!=": 40 r = pb.Compare_NOT_EQUAL 41 case ">": 42 r = pb.Compare_GREATER 43 case "<": 44 r = pb.Compare_LESS 45 default: 46 panic("Unknown result op") 47 } 48 49 cmp.Result = r 50 switch cmp.Target { 51 case pb.Compare_VALUE: 52 val, ok := v.(string) 53 if !ok { 54 panic("bad compare value") 55 } 56 cmp.TargetUnion = &pb.Compare_Value{Value: []byte(val)} 57 case pb.Compare_VERSION: 58 cmp.TargetUnion = &pb.Compare_Version{Version: mustInt64(v)} 59 case pb.Compare_CREATE: 60 cmp.TargetUnion = &pb.Compare_CreateRevision{CreateRevision: mustInt64(v)} 61 case pb.Compare_MOD: 62 cmp.TargetUnion = &pb.Compare_ModRevision{ModRevision: mustInt64(v)} 63 case pb.Compare_LEASE: 64 cmp.TargetUnion = &pb.Compare_Lease{Lease: mustInt64orLeaseID(v)} 65 default: 66 panic("Unknown compare type") 67 } 68 return cmp 69 } 70 71 func Value(key string) Cmp { 72 return Cmp{Key: []byte(key), Target: pb.Compare_VALUE} 73 } 74 75 func Version(key string) Cmp { 76 return Cmp{Key: []byte(key), Target: pb.Compare_VERSION} 77 } 78 79 func CreateRevision(key string) Cmp { 80 return Cmp{Key: []byte(key), Target: pb.Compare_CREATE} 81 } 82 83 func ModRevision(key string) Cmp { 84 return Cmp{Key: []byte(key), Target: pb.Compare_MOD} 85 } 86 87 // LeaseValue compares a key's LeaseID to a value of your choosing. The empty 88 // LeaseID is 0, otherwise known as `NoLease`. 89 func LeaseValue(key string) Cmp { 90 return Cmp{Key: []byte(key), Target: pb.Compare_LEASE} 91 } 92 93 // KeyBytes returns the byte slice holding with the comparison key. 94 func (cmp *Cmp) KeyBytes() []byte { return cmp.Key } 95 96 // WithKeyBytes sets the byte slice for the comparison key. 97 func (cmp *Cmp) WithKeyBytes(key []byte) { cmp.Key = key } 98 99 // ValueBytes returns the byte slice holding the comparison value, if any. 100 func (cmp *Cmp) ValueBytes() []byte { 101 if tu, ok := cmp.TargetUnion.(*pb.Compare_Value); ok { 102 return tu.Value 103 } 104 return nil 105 } 106 107 // WithValueBytes sets the byte slice for the comparison's value. 108 func (cmp *Cmp) WithValueBytes(v []byte) { cmp.TargetUnion.(*pb.Compare_Value).Value = v } 109 110 // WithRange sets the comparison to scan the range [key, end). 111 func (cmp Cmp) WithRange(end string) Cmp { 112 cmp.RangeEnd = []byte(end) 113 return cmp 114 } 115 116 // WithPrefix sets the comparison to scan all keys prefixed by the key. 117 func (cmp Cmp) WithPrefix() Cmp { 118 cmp.RangeEnd = getPrefix(cmp.Key) 119 return cmp 120 } 121 122 // mustInt64 panics if val isn't an int or int64. It returns an int64 otherwise. 123 func mustInt64(val interface{}) int64 { 124 if v, ok := val.(int64); ok { 125 return v 126 } 127 if v, ok := val.(int); ok { 128 return int64(v) 129 } 130 panic("bad value") 131 } 132 133 // mustInt64orLeaseID panics if val isn't a LeaseID, int or int64. It returns an 134 // int64 otherwise. 135 func mustInt64orLeaseID(val interface{}) int64 { 136 if v, ok := val.(LeaseID); ok { 137 return int64(v) 138 } 139 return mustInt64(val) 140 }