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  }