bitbucket.org/lygo/lygo_ext_dbbolt@v0.1.3/lygo_db_bolt_collection.go (about) 1 package lygo_ext_dbbolt 2 3 import ( 4 "bitbucket.org/lygo/lygo_commons/lygo_conv" 5 "bitbucket.org/lygo/lygo_commons/lygo_reflect" 6 "encoding/json" 7 "errors" 8 "go.etcd.io/bbolt" 9 ) 10 11 //---------------------------------------------------------------------------------------------------------------------- 12 // t y p e 13 //---------------------------------------------------------------------------------------------------------------------- 14 15 type BoltCollection struct { 16 17 //-- private --// 18 name string 19 db *BoltDatabase 20 boltdb *bbolt.DB 21 enableExpire bool 22 } 23 24 type ForEachCallback func(k, v []byte) bool 25 26 //---------------------------------------------------------------------------------------------------------------------- 27 // c o n s t r u c t o r 28 //---------------------------------------------------------------------------------------------------------------------- 29 30 func NewBoltCollection(db *BoltDatabase, boltdb *bbolt.DB, name string) *BoltCollection { 31 instance := new(BoltCollection) 32 instance.db = db 33 instance.boltdb = boltdb 34 instance.name = name 35 36 return instance 37 } 38 39 //---------------------------------------------------------------------------------------------------------------------- 40 // p u b l i c 41 //---------------------------------------------------------------------------------------------------------------------- 42 43 func (instance *BoltCollection) EnableExpire(value bool) { 44 if nil != instance { 45 instance.enableExpire = value 46 if value { 47 // start internal task to check expiration 48 instance.db.expire.Enable(instance.name) 49 } else { 50 instance.db.expire.Disable(instance.name) 51 } 52 } 53 } 54 55 func (instance *BoltCollection) Drop() error { 56 if nil != instance && nil != instance.boltdb { 57 err := instance.boltdb.Update(func(tx *bbolt.Tx) error { 58 b := tx.Bucket([]byte(instance.name)) 59 if nil != b { 60 return tx.DeleteBucket([]byte(instance.name)) 61 } 62 return nil 63 }) 64 return err 65 } 66 return ErrDatabaseIsNotConnected 67 } 68 69 func (instance *BoltCollection) Count() (int64, error) { 70 var response int64 71 response = 0 72 if nil != instance && nil != instance.boltdb { 73 err := instance.boltdb.View(func(tx *bbolt.Tx) error { 74 b := tx.Bucket([]byte(instance.name)) 75 if nil != b { 76 c := b.Cursor() 77 for k, _ := c.First(); k != nil; k, _ = c.Next() { 78 response++ 79 } 80 } else { 81 return ErrCollectionDoesNotExists 82 } 83 return nil 84 }) 85 return response, err 86 } 87 return response, ErrDatabaseIsNotConnected 88 } 89 90 func (instance *BoltCollection) CountByFieldValue(fieldName string, fieldValue interface{}) (int64, error) { 91 var response int64 92 response = 0 93 if nil != instance && nil != instance.boltdb { 94 err := instance.boltdb.View(func(tx *bbolt.Tx) error { 95 b := tx.Bucket([]byte(instance.name)) 96 if nil != b { 97 c := b.Cursor() 98 for k, v := c.First(); k != nil; k, v = c.Next() { 99 var entity interface{} 100 err := json.Unmarshal(v, &entity) 101 if nil == err { 102 value := lygo_reflect.Get(entity, fieldName) 103 if lygo_conv.Equals(fieldValue, value) { 104 response++ 105 } 106 } 107 } 108 } else { 109 return ErrCollectionDoesNotExists 110 } 111 return nil 112 }) 113 return response, err 114 } 115 return response, ErrDatabaseIsNotConnected 116 } 117 118 func (instance *BoltCollection) Get(key string) (interface{}, error) { 119 var response interface{} 120 if nil != instance && nil != instance.boltdb { 121 err := instance.boltdb.View(func(tx *bbolt.Tx) error { 122 b := tx.Bucket([]byte(instance.name)) 123 if nil != b { 124 buf := b.Get([]byte(key)) 125 if nil != buf { 126 err := json.Unmarshal(buf, &response) 127 return err 128 } 129 } else { 130 return ErrCollectionDoesNotExists 131 } 132 return nil 133 }) 134 return response, err 135 } 136 return nil, ErrDatabaseIsNotConnected 137 } 138 139 func (instance *BoltCollection) Upsert(entity interface{}) error { 140 if nil != instance { 141 return instance.update(entity, false) 142 } 143 return ErrDatabaseIsNotConnected 144 } 145 146 func (instance *BoltCollection) UpsertBatch(entity interface{}) error { 147 if nil != instance { 148 return instance.update(entity, true) 149 } 150 return ErrDatabaseIsNotConnected 151 } 152 153 func (instance *BoltCollection) Remove(key string) error { 154 if nil != instance { 155 return instance.remove(key, false) 156 } 157 return ErrDatabaseIsNotConnected 158 } 159 160 func (instance *BoltCollection) RemoveBatch(key string) error { 161 if nil != instance { 162 return instance.remove(key, true) 163 } 164 return ErrDatabaseIsNotConnected 165 } 166 167 func (instance *BoltCollection) GetByFieldValue(fieldName string, fieldValue interface{}) ([]interface{}, error) { 168 response := make([]interface{}, 0) 169 if nil != instance && nil != instance.boltdb { 170 err := instance.boltdb.View(func(tx *bbolt.Tx) error { 171 b := tx.Bucket([]byte(instance.name)) 172 if nil != b { 173 c := b.Cursor() 174 for k, v := c.First(); k != nil; k, v = c.Next() { 175 var entity interface{} 176 err := json.Unmarshal(v, &entity) 177 if nil == err { 178 value := lygo_reflect.Get(entity, fieldName) 179 if lygo_conv.Equals(fieldValue, value) { 180 response = append(response, entity) 181 } 182 } 183 } 184 } else { 185 return ErrCollectionDoesNotExists 186 } 187 return nil 188 }) 189 return response, err 190 } 191 return response, ErrDatabaseIsNotConnected 192 } 193 194 func (instance *BoltCollection) Find(query *BoltQuery) ([]interface{}, error) { 195 response := make([]interface{}, 0) 196 if nil != instance && nil != instance.boltdb { 197 err := instance.boltdb.View(func(tx *bbolt.Tx) error { 198 b := tx.Bucket([]byte(instance.name)) 199 if nil != b { 200 c := b.Cursor() 201 for k, v := c.First(); k != nil; k, v = c.Next() { 202 var entity map[string]interface{} 203 err := json.Unmarshal(v, &entity) 204 if nil == err { 205 if query.MatchFilter(entity) { 206 response = append(response, entity) 207 } 208 } 209 } 210 } else { 211 return ErrCollectionDoesNotExists 212 } 213 return nil 214 }) 215 return response, err 216 } 217 return response, ErrDatabaseIsNotConnected 218 } 219 220 func (instance *BoltCollection) ForEach(callback ForEachCallback) error { 221 if nil != instance && nil != instance.boltdb { 222 if nil != callback { 223 err := instance.boltdb.View(func(tx *bbolt.Tx) error { 224 b := tx.Bucket([]byte(instance.name)) 225 if nil != b { 226 _ = b.ForEach(func(k, v []byte) error { 227 exit := callback(k, v) 228 if exit { 229 return errors.New("exit") 230 } 231 return nil 232 }) 233 } else { 234 return ErrCollectionDoesNotExists 235 } 236 return nil 237 }) 238 return err 239 } else { 240 return nil 241 } 242 } 243 return ErrDatabaseIsNotConnected 244 } 245 246 //---------------------------------------------------------------------------------------------------------------------- 247 // p r i v a t e 248 //---------------------------------------------------------------------------------------------------------------------- 249 250 func unmarshal(v []byte, entity interface{}) (interface{}, error) { 251 if nil != entity { 252 err := json.Unmarshal(v, entity) 253 if nil != err { 254 return nil, err 255 } 256 //var resp struct{} 257 //lygo_reflect.Copy(reflect.ValueOf(entity).Elem().Interface(), &resp) 258 259 return entity, nil 260 } else { 261 var resp map[string]interface{} 262 err := json.Unmarshal(v, &resp) 263 if nil != err { 264 return nil, err 265 } 266 return resp, nil 267 } 268 } 269 270 func (instance *BoltCollection) remove(key string, batch bool) (err error) { 271 if nil != instance && nil != instance.boltdb { 272 if batch { 273 err = instance.boltdb.Batch(func(tx *bbolt.Tx) error { 274 b := tx.Bucket([]byte(instance.name)) 275 if nil != b { 276 err := b.Delete([]byte(key)) 277 return err 278 } else { 279 return ErrCollectionDoesNotExists 280 } 281 }) 282 } else { 283 err = instance.boltdb.Update(func(tx *bbolt.Tx) error { 284 b := tx.Bucket([]byte(instance.name)) 285 if nil != b { 286 err := b.Delete([]byte(key)) 287 return err 288 } else { 289 return ErrCollectionDoesNotExists 290 } 291 }) 292 } 293 } else { 294 err = ErrDatabaseIsNotConnected 295 } 296 return err 297 } 298 299 func (instance *BoltCollection) update(entity interface{}, batch bool) (err error) { 300 if nil != instance && nil != instance.boltdb { 301 // check key 302 key := []byte(lygo_reflect.GetString(entity, "_key")) 303 if len(key) == 0 { 304 return ErrMissingDocumentKey 305 } 306 // get array of bytes 307 buf, err := json.Marshal(entity) 308 if nil != err { 309 return err 310 } 311 if batch { 312 err = instance.boltdb.Batch(func(tx *bbolt.Tx) error { 313 b := tx.Bucket([]byte(instance.name)) 314 if nil != b { 315 return b.Put(key, buf) 316 } else { 317 return ErrCollectionDoesNotExists 318 } 319 }) 320 } else { 321 err = instance.boltdb.Update(func(tx *bbolt.Tx) error { 322 b := tx.Bucket([]byte(instance.name)) 323 if nil != b { 324 return b.Put(key, buf) 325 } else { 326 return ErrCollectionDoesNotExists 327 } 328 }) 329 } 330 } else { 331 err = ErrDatabaseIsNotConnected 332 } 333 return err 334 }