From f4f07ec079a7151eff4930d05320da95acb1b376 Mon Sep 17 00:00:00 2001
From: Nash Tsai <nash.tsai@gmail.com>
Date: Sat, 17 May 2014 00:39:30 +0800
Subject: [PATCH]  #66 partial implement xorm_cache tag

add Engine.disableGlobalCache and explicit using cache via xorm_cache tag
---
 engine.go | 49 ++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 48 insertions(+), 1 deletion(-)

diff --git a/engine.go b/engine.go
index 107a9d69..66606b76 100644
--- a/engine.go
+++ b/engine.go
@@ -38,6 +38,14 @@ type Engine struct {
 
 	Logger     ILogger // io.Writer
 	TZLocation *time.Location
+
+	disableGlobalCache bool
+}
+
+func (engine *Engine) SetDisableGlobalCache(disable bool) {
+	if engine.disableGlobalCache != disable {
+		engine.disableGlobalCache = disable
+	}
 }
 
 func (engine *Engine) DriverName() string {
@@ -544,10 +552,39 @@ func addIndex(indexName string, table *core.Table, col *core.Column, indexType i
 
 func (engine *Engine) newTable() *core.Table {
 	table := core.NewEmptyTable()
-	table.Cacher = engine.Cacher
+
+	if !engine.disableGlobalCache {
+		table.Cacher = engine.Cacher
+	}
 	return table
 }
 
+func (engine *Engine) processCacherTag(table *core.Table, v reflect.Value, cacherTagStr string) {
+
+	for _, part := range strings.Split(cacherTagStr, ",") {
+		switch {
+		case part == "false": // even if engine has assigned cacher, this table will not have cache support
+			table.Cacher = nil
+			return
+
+		case part == "true": // use default 'read-write' cache
+			if engine.Cacher != nil { // !nash! use engine's cacher if provided
+				table.Cacher = engine.Cacher
+			} else {
+				table.Cacher = NewLRUCacher2(NewMemoryStore(), time.Hour, 10000) // !nashtsai! HACK use LRU cacher for now
+			}
+			return
+			// TODO
+			// case strings.HasPrefix(part, "usage:"):
+			// 	usageStr := part[len("usage:"):]
+
+			// case strings.HasPrefix(part, "include:"):
+			// 	includeStr := part[len("include:"):]
+		}
+
+	}
+}
+
 func (engine *Engine) mapType(v reflect.Value) *core.Table {
 	t := v.Type()
 	table := engine.newTable()
@@ -573,9 +610,19 @@ func (engine *Engine) mapType(v reflect.Value) *core.Table {
 	var idFieldColName string
 	var err error
 
+	hasProcessedCacheTag := false
+
 	for i := 0; i < t.NumField(); i++ {
 		tag := t.Field(i).Tag
 		ormTagStr := tag.Get(engine.TagIdentifier)
+		if !hasProcessedCacheTag {
+			cacheTagStr := tag.Get("xorm_cache")
+			if cacheTagStr != "" {
+				hasProcessedCacheTag = true
+				engine.processCacherTag(table, v, cacheTagStr)
+			}
+		}
+
 		var col *core.Column
 		fieldValue := v.Field(i)
 		fieldType := fieldValue.Type()