code tidy up

logger tidy up

private serialize and deserialize func

redis_cacher.go

@@ -6,15 +6,16 @@ import (
 	"fmt"
 	"github.com/garyburd/redigo/redis"
 	//"github.com/go-xorm/core"
+	"hash/crc32"
 	"log"
 	"reflect"
-	"strconv"
+	// "strconv"
 	"time"
 )
 
 const (
-	DEFAULT = time.Duration(0)
+	DEFAULT_EXPIRATION = time.Duration(0)
-	FOREVER = time.Duration(-1)
+	FOREVER_EXPIRATION = time.Duration(-1)
 )
 
 // Wraps the Redis client to meet the Cache interface.
@@ -69,7 +70,9 @@ func (c *RedisCacher) getBeanKey(tableName string, id string) string {
 }
 
 func (c *RedisCacher) getSqlKey(tableName string, sql string) string {
-	return fmt.Sprintf("sql:%s:%s", tableName, sql)
+	// hash sql to minimize key length
+	crc := crc32.ChecksumIEEE([]byte(sql))
+	return fmt.Sprintf("sql:%s:%d", tableName, crc)
 }
 
 func (c *RedisCacher) Flush() error {
@@ -80,7 +83,6 @@ func (c *RedisCacher) Flush() error {
 }
 
 func (c *RedisCacher) getObject(key string) interface{} {
-
 	conn := c.pool.Get()
 	defer conn.Close()
 	raw, err := conn.Do("GET", key)
@@ -89,21 +91,23 @@ func (c *RedisCacher) getObject(key string) interface{} {
 	}
 	item, err := redis.Bytes(raw, err)
 	if err != nil {
-		log.Fatalf("xorm/cache: redis.Bytes failed: %s", err)
+		log.Fatalf("[xorm/redis_cacher] redis.Bytes failed: %s", err)
 		return nil
 	}
 
-	value, err := Deserialize(item)
+	value, err := deserialize(item)
 
 	return value
 }
 
 func (c *RedisCacher) GetIds(tableName, sql string) interface{} {
+	log.Printf("[xorm/redis_cacher] GetIds|tableName:%s|sql:%s", tableName, sql)
 
 	return c.getObject(c.getSqlKey(tableName, sql))
 }
 
 func (c *RedisCacher) GetBean(tableName string, id string) interface{} {
+	log.Printf("[xorm/redis_cacher] GetBean|tableName:%s|id:%s", tableName, id)
 	return c.getObject(c.getBeanKey(tableName, id))
 }
 
@@ -112,10 +116,13 @@ func (c *RedisCacher) putObject(key string, value interface{}) {
 }
 
 func (c *RedisCacher) PutIds(tableName, sql string, ids interface{}) {
-	c.putObject(c.getBeanKey(tableName, sql), ids)
+	log.Printf("[xorm/redis_cacher] PutIds|tableName:%s|sql:%s|type:%v", tableName, sql, reflect.TypeOf(ids))
+
+	c.putObject(c.getSqlKey(tableName, sql), ids)
 }
 
 func (c *RedisCacher) PutBean(tableName string, id string, obj interface{}) {
+	log.Printf("[xorm/redis_cacher] PutBean|tableName:%s|id:%s|type:%v", tableName, id, reflect.TypeOf(obj))
 	c.putObject(c.getBeanKey(tableName, id), obj)
 }
 
@@ -133,7 +140,6 @@ func (c *RedisCacher) delObject(key string) {
 
 func (c *RedisCacher) DelIds(tableName, sql string) {
 	c.delObject(c.getSqlKey(tableName, sql))
-	// TODO
 }
 
 func (c *RedisCacher) DelBean(tableName string, id string) {
@@ -165,13 +171,13 @@ func (c *RedisCacher) invoke(f func(string, ...interface{}) (interface{}, error)
 	key string, value interface{}, expires time.Duration) error {
 
 	switch expires {
-	case DEFAULT:
+	case DEFAULT_EXPIRATION:
 		expires = c.defaultExpiration
-	case FOREVER:
+	case FOREVER_EXPIRATION:
 		expires = time.Duration(0)
 	}
 
-	b, err := Serialize(value)
+	b, err := serialize(value)
 	if err != nil {
 		return err
 	}
@@ -186,72 +192,28 @@ func (c *RedisCacher) invoke(f func(string, ...interface{}) (interface{}, error)
 	}
 }
 
-// Serialize transforms the given value into bytes following these rules:
+func serialize(value interface{}) ([]byte, error) {
-//   - If value is a byte array, it is returned as-is.
-//   - If value is an int or uint type, it is returned as the ASCII representation
-//   - Else, encoding/gob is used to serialize
-func Serialize(value interface{}) ([]byte, error) {
-	if bytes, ok := value.([]byte); ok {
-		return bytes, nil
-	}
-
-	switch v := reflect.ValueOf(value); v.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return []byte(strconv.FormatInt(v.Int(), 10)), nil
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return []byte(strconv.FormatUint(v.Uint(), 10)), nil
-	}
 
 	RegisterGobConcreteType(value)
 
 	var b bytes.Buffer
 	encoder := gob.NewEncoder(&b)
 	if err := interfaceEncode(encoder, value); err != nil {
-		log.Fatalf("xorm/cache: gob encoding '%s' failed: %s", value, err)
+		log.Fatalf("[xorm/redis_cacher] gob encoding '%s' failed: %s", value, err)
 		return nil, err
 	}
 	return b.Bytes(), nil
 }
 
-// Deserialize transforms bytes produced by Serialize back into a Go object,
+func deserialize(byt []byte) (ptr interface{}, err error) {
-// storing it into "ptr", which must be a pointer to the value type.
-func Deserialize(byt []byte) (ptr interface{}, err error) {
-	if bytes, ok := ptr.(*[]byte); ok {
-		*bytes = byt
-		return
-	}
-
-	if v := reflect.ValueOf(ptr); v.Kind() == reflect.Ptr {
-		switch p := v.Elem(); p.Kind() {
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			var i int64
-			i, err = strconv.ParseInt(string(byt), 10, 64)
-			if err != nil {
-				log.Fatalf("xorm/cache: failed to parse int '%s': %s", string(byt), err)
-			} else {
-				p.SetInt(i)
-			}
-			return
-
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			var i uint64
-			i, err = strconv.ParseUint(string(byt), 10, 64)
-			if err != nil {
-				log.Fatalf("xorm/cache: failed to parse uint '%s': %s", string(byt), err)
-			} else {
-				p.SetUint(i)
-			}
-			return
-		}
-	}
-
 	b := bytes.NewBuffer(byt)
 	decoder := gob.NewDecoder(b)
 
 	if ptr, err = interfaceDecode(decoder); err != nil {
-		log.Fatalf("xorm/cache: gob decoding failed: %s", err)
+		log.Fatalf("[xorm/redis_cacher] gob decoding failed: %s", err)
 		return
 	}
+
 	return
 }
 
@@ -259,17 +221,17 @@ func RegisterGobConcreteType(value interface{}) {
 
 	t := reflect.TypeOf(value)
 
+	log.Printf("[xorm/redis_cacher] RegisterGobConcreteType:%v", t)
+
 	switch t.Kind() {
 	case reflect.Ptr:
 		v := reflect.ValueOf(value)
 		i := v.Elem().Interface()
 		gob.Register(i)
-	case reflect.Struct:
+	case reflect.Struct, reflect.Map, reflect.Slice:
 		gob.Register(value)
-	case reflect.Slice:
+	case reflect.String, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Bool, reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128:
-		fallthrough
+		// do nothing since already registered known type
-	case reflect.Map:
-		fallthrough
 	default:
 		panic(fmt.Errorf("unhandled type: %v", t))
 	}
@@ -283,9 +245,11 @@ func interfaceEncode(enc *gob.Encoder, p interface{}) error {
 	// Pass pointer to interface so Encode sees (and hence sends) a value of
 	// interface type.  If we passed p directly it would see the concrete type instead.
 	// See the blog post, "The Laws of Reflection" for background.
+
+	log.Printf("[xorm/redis_cacher] interfaceEncode type:%v", reflect.TypeOf(p))
 	err := enc.Encode(&p)
 	if err != nil {
-		log.Fatal("encode:", err)
+		log.Fatal("[xorm/redis_cacher] encode:", err)
 	}
 	return err
 }
@@ -297,7 +261,13 @@ func interfaceDecode(dec *gob.Decoder) (interface{}, error) {
 	var p interface{}
 	err := dec.Decode(&p)
 	if err != nil {
-		log.Fatal("decode:", err)
+		log.Fatal("[xorm/redis_cacher] decode:", err)
 	}
+	log.Printf("[xorm/redis_cacher] interfaceDecode type:%v", reflect.TypeOf(p))
+
+	if reflect.TypeOf(p).Kind() == reflect.Struct {
+		// TODO need to convert p to pointer of struct, however, encountered reflect.ValueOf(p).CanAddr() == false
+	}
+
 	return p, err
 }