push code

Author: vanhop993

batch.go

@@ -8,10 +8,39 @@ import (
 	"strings"
 )
 
-func ExecuteStatements(ctx context.Context, db *sql.DB, sts []Statement) (int64, error) {
-	return ExecuteBatch(ctx, db, sts, true, false)
+func ExecuteStatements(ctx context.Context, tx *sql.Tx, commit bool, stmts ...Statement) (int64, error) {
+	if stmts == nil || len(stmts) == 0 {
+		return 0, nil
+	}
+	var count int64
+	count = 0
+	for _, stmt := range stmts {
+		r2, er3 := tx.ExecContext(ctx, stmt.Query, stmt.Params...)
+		if er3 != nil {
+			er4 := tx.Rollback()
+			if er4 != nil {
+				return count, er4
+			}
+			return count, er3
+		}
+		a2, er5 := r2.RowsAffected()
+		if er5 != nil {
+			tx.Rollback()
+			return count, er5
+		}
+		count = count + a2
+	}
+	if commit {
+		er6 := tx.Commit()
+		return count, er6
+	} else {
+		return count, nil
+	}
 }
-func ExecuteAll(ctx context.Context, db *sql.DB, stmts []Statement) (int64, error) {
+func ExecuteAll(ctx context.Context, db *sql.DB, stmts ...Statement) (int64, error) {
+	if stmts == nil || len(stmts) == 0 {
+		return 0, nil
+	}
 	tx, er1 := db.Begin()
 	if er1 != nil {
 		return 0, er1
@@ -127,9 +156,9 @@ type DefaultStatements struct {
 
 func (s *DefaultStatements) Exec(ctx context.Context, db *sql.DB) (int64, error) {
 	if s.SuccessFirst {
-		return ExecuteStatements(ctx, db, s.Statements)
+		return ExecuteBatch(ctx, db, s.Statements, true, false)
 	} else {
-		return ExecuteAll(ctx, db, s.Statements)
+		return ExecuteAll(ctx, db, s.Statements...)
 	}
 }
 func (s *DefaultStatements) Add(sql string, args []interface{}) Statements {
@@ -841,14 +870,14 @@ func UpdateBatch(ctx context.Context, db *sql.DB, tableName string, models inter
 	if er1 != nil {
 		return 0, er1
 	}
-	return ExecuteAll(ctx, db, stmts)
+	return ExecuteAll(ctx, db, stmts...)
 }
 func SaveBatch(ctx context.Context, db *sql.DB, tableName string, models interface{}) (int64, error) {
 	stmts, er1 := BuildToSaveBatch(db, tableName, models)
 	if er1 != nil {
 		return 0, er1
 	}
-	_, err := ExecuteAll(ctx, db, stmts)
+	_, err := ExecuteAll(ctx, db, stmts...)
 	total := int64(len(stmts))
 	return total, err
 }

cache/cache_config.go

@@ -0,0 +1,10 @@
+package cache
+
+import "time"
+
+// CacheConfig ...
+type CacheConfig struct {
+	Size             int64         `mapstructure:"size" json:"size,omitempty"` // byte
+	CleaningEnable   bool          `mapstructure:"cleaning_enable" json:"cleaningEnable,omitempty"`
+	CleaningInterval time.Duration `mapstructure:"cleaning_interval" json:"cleaningInterval,omitempty"` // nano-second
+}

cache/cache_service.go

@@ -0,0 +1,19 @@
+package cache
+
+import (
+	"database/sql"
+	"time"
+)
+
+type CacheService interface {
+	Put(key string, obj interface{}, timeToLive time.Duration) error
+	Expire(key string, timeToLive time.Duration) (bool, error)
+	Get(key string) (*sql.Tx, error)
+	ContainsKey(key string) (bool, error)
+	Remove(key string) (bool, error)
+	Clear() error
+	GetMany(keys []string) (map[string]sql.Tx, []string, error)
+	Keys() ([]string, error)
+	Count() (int64, error)
+	Size() (int64, error)
+}

cache/client.go

@@ -0,0 +1,242 @@
+package cache
+
+import (
+	"errors"
+	"sync"
+	"unsafe"
+)
+
+// LinearClient contains all attributes
+type Client struct {
+	items              sync.Map
+	keys               []string
+	cleaningEnable     bool
+	linearSizes        int64
+	linearCurrentSizes int64
+	rwMutex            sync.RWMutex
+}
+
+// NewClient return new instance
+func NewClient(linearSizes int64, cleaningEnable bool) *Client {
+	currentLinear := Client{
+		keys:               []string{},
+		items:              sync.Map{},
+		cleaningEnable:     cleaningEnable,
+		linearSizes:        linearSizes,
+		linearCurrentSizes: 0,
+		rwMutex:            sync.RWMutex{},
+	}
+
+	return &currentLinear
+}
+
+// Push item to the linear by key
+func (c *Client) Push(key string, value interface{}) error {
+	itemSize := int64(unsafe.Sizeof(key)) + int64(unsafe.Sizeof(value))
+	if itemSize > c.linearSizes || key == "" {
+		return errors.New("key is empty or linear not enough space")
+	}
+
+	// Clean space for new item
+	if c.cleaningEnable {
+		for c.linearCurrentSizes+itemSize > c.linearSizes {
+			c.Take()
+		}
+	}
+
+	c.rwMutex.Lock()
+	c.items.LoadOrStore(key, value)
+	c.linearCurrentSizes += int64(unsafe.Sizeof(value))
+	c.keys = append(c.keys, key)
+	c.rwMutex.Unlock()
+
+	return nil
+}
+
+// Pop return the last item from the linear and remove it
+func (c *Client) Pop() (interface{}, error) {
+	if c.IsEmpty() {
+		return nil, errors.New("the linear is empty")
+	}
+
+	lastItemIndex := len(c.keys) - 1
+	item, exits := c.items.Load(c.keys[lastItemIndex])
+	if !exits {
+		return nil, nil
+	}
+
+	c.rwMutex.Lock()
+	c.items.Delete(c.keys[lastItemIndex])
+	c.linearCurrentSizes -= int64(unsafe.Sizeof(item))
+	c.keys = removeItemByIndex(c.keys, lastItemIndex) //Update keys slice after remove that key from items map
+	c.rwMutex.Unlock()
+
+	return item, nil
+}
+
+// Take return the first item from the linear and remove it
+func (c *Client) Take() (interface{}, error) {
+	if c.IsEmpty() {
+		return nil, errors.New("the linear is empty")
+	}
+
+	c.rwMutex.Lock()
+	item, exits := c.items.Load(c.keys[0])
+	if !exits {
+		c.rwMutex.Unlock()
+		return nil, nil
+	}
+
+	c.items.Delete(c.keys[0])
+	c.linearCurrentSizes -= int64(unsafe.Sizeof(item))
+	c.keys = removeItemByIndex(c.keys, 0) //Update keys slice after remove that key from items map
+	c.rwMutex.Unlock()
+
+	return item, nil
+}
+
+// Get method return the item by key from linear and remove it
+// Goroutine: https://stackoverflow.com/questions/20945069/catching-return-values-from-goroutines
+func (c *Client) Get(key string) (interface{}, error) {
+	if c.IsEmpty() {
+		return nil, errors.New("linear is empty")
+	}
+
+	var (
+		wg             sync.WaitGroup
+		item           interface{}
+		itemExits      bool
+		itemIndex      int
+		itemIndexExits bool
+	)
+
+	wg.Add(2)
+	go func() {
+		item, itemExits = c.items.Load(key)
+		wg.Done()
+	}()
+
+	go func() {
+		itemIndex, itemIndexExits = findIndexByItem(key, c.keys)
+		wg.Done()
+	}()
+	wg.Wait()
+
+	if itemExits && itemIndexExits {
+		c.rwMutex.Lock()
+		c.items.Delete(key)
+		c.linearCurrentSizes -= int64(unsafe.Sizeof(item))
+		c.keys = removeItemByIndex(c.keys, itemIndex) //Update keys slice after remove that key from items map
+		c.rwMutex.Unlock()
+
+		return item, nil
+	}
+
+	return nil, nil
+}
+
+// Read method return the item by key from linear without remove it
+func (c *Client) Read(key string) (interface{}, error) {
+	if c.IsEmpty() {
+		return nil, errors.New("linear is empty")
+	}
+
+	item, exits := c.items.Load(key)
+	if !exits {
+		return nil, nil
+	}
+
+	return item, nil
+}
+
+// Update reassign value to the key
+func (c *Client) Update(key string, value interface{}) error {
+	newItemSize := int64(unsafe.Sizeof(key)) + int64(unsafe.Sizeof(value))
+	if newItemSize > c.linearSizes || c.IsEmpty() {
+		return errors.New("linear is empty or not enough space")
+	}
+
+	c.rwMutex.Lock()
+	currentSize, exits := c.IsExits(key)
+	if !exits {
+		c.rwMutex.Unlock()
+		return errors.New("key does not exit")
+	}
+	c.items.Store(key, value)
+	c.linearCurrentSizes += currentSize - newItemSize
+	c.rwMutex.Unlock()
+
+	return nil
+}
+
+// Range the LinearClient
+func (c *Client) Range(fn func(key, value interface{}) bool) {
+	c.items.Range(fn)
+}
+
+// IsExits check key exits or not
+func (c *Client) IsExits(key string) (int64, bool) {
+	value, exits := c.items.Load(key)
+	if !exits {
+		return 0, false
+	}
+
+	return int64(unsafe.Sizeof(key)) + int64(unsafe.Sizeof(value)), true
+}
+
+// IsEmpty check linear size
+func (c *Client) IsEmpty() bool {
+	return len(c.keys) == 0
+}
+
+// GetItems return the map contain items
+func (c *Client) GetItems() sync.Map {
+	return c.items
+}
+
+// Getkeys return the list of key
+func (c *Client) Getkeys() []string {
+	return c.keys
+}
+
+// GetNumberOfKeys return the number of keys
+func (c *Client) GetNumberOfKeys() int {
+	return len(c.keys)
+}
+
+// GetLinearSizes return the linear size
+func (c *Client) GetLinearSizes() int64 {
+	return c.linearSizes
+}
+
+// SetLinearSizes change the linear size with new value
+func (c *Client) SetLinearSizes(linearSizes int64) {
+	c.rwMutex.RLock()
+	c.linearSizes = linearSizes
+	c.rwMutex.RUnlock()
+}
+
+// GetLinearCurrentSize return the current linear size
+func (c *Client) GetLinearCurrentSize() int64 {
+	return c.linearCurrentSizes
+}
+
+// removeItemByIndex remove item out of []string by index but maintains order, and return the new one
+// Source: https://yourbasic.org/golang/delete-element-slice/
+func removeItemByIndex(s []string, idx int) []string {
+	copy(s[idx:], s[idx+1:]) // Shift s[idx+1:] left one index.
+	s[len(s)-1] = ""         // Erase last element (write zero value).
+	return s[:len(s)-1]      // Truncate s.
+}
+
+// findIndexByItem return index belong to the key
+// Source: https://stackoverflow.com/questions/46745043/performance-of-for-range-in-go
+func findIndexByItem(keyName string, items []string) (int, bool) {
+	for index := range items {
+		if keyName == items[index] {
+			return index, true
+		}
+	}
+
+	return -1, false
+}

cache/item.go

@@ -0,0 +1,7 @@
+package cache
+
+// Item ...
+type Item struct {
+	Data    interface{} `json:"data,omitempty"`
+	Expires int64       `json:"expires,omitempty"`
+}