github.com/insionng/yougam@v0.0.0-20170714101924-2bc18d833463/libraries/go-xorm/tidb/tidb_test.go (about)

     1  package tidb
     2  
     3  import (
     4  	"database/sql"
     5  	"os"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/insionng/yougam/libraries/go-xorm/core"
    10  	"github.com/insionng/yougam/libraries/tests"
    11  	"github.com/insionng/yougam/libraries/xorm"
    12  	_ "github.com/pingcap/tidb"
    13  )
    14  
    15  var showTestSql = true
    16  
    17  // [memory, goleveldb, boltdb]
    18  
    19  func newTidbEngine(storeType string) (*xorm.Engine, error) {
    20  	if storeType == "memory" {
    21  		return xorm.NewEngine("tidb", storeType+"://tidb/tidb?parseTime=true")
    22  	}
    23  
    24  	os.Remove("./tidb_" + storeType)
    25  	return xorm.NewEngine("tidb", storeType+"://./tidb_"+storeType+"/tidb?parseTime=true")
    26  }
    27  
    28  func newTidbDriverDB(storeType string) (*sql.DB, error) {
    29  	if storeType == "memory" {
    30  		return sql.Open("tidb", storeType+"://./tidb/tidb?parseTime=true")
    31  	}
    32  
    33  	os.Remove("./tidb_" + storeType)
    34  	return sql.Open("tidb", storeType+"://./tidb_"+storeType+"/tidb?parseTime=true")
    35  }
    36  
    37  func newCache() core.Cacher {
    38  	return xorm.NewLRUCacher2(xorm.NewMemoryStore(), time.Hour, 1000)
    39  }
    40  
    41  func setEngine(engine *xorm.Engine, useCache bool) {
    42  	if useCache {
    43  		engine.SetDefaultCacher(newCache())
    44  	}
    45  	engine.Logger().ShowSQL(showTestSql)
    46  	engine.Logger().SetLevel(core.LOG_DEBUG)
    47  }
    48  
    49  func TestTidbGoLevelDBNoCache(t *testing.T) {
    50  	engine, err := newTidbEngine("goleveldb")
    51  	if err != nil {
    52  		t.Error(err)
    53  		return
    54  	}
    55  	defer engine.Close()
    56  	setEngine(engine, false)
    57  
    58  	tests.BaseTestAll(engine, t)
    59  	tests.BaseTestAll2(engine, t)
    60  	tests.BaseTestAll3(engine, t)
    61  }
    62  
    63  func TestTidbGoLevelDBWithCache(t *testing.T) {
    64  	engine, err := newTidbEngine("goleveldb")
    65  	if err != nil {
    66  		t.Error(err)
    67  		return
    68  	}
    69  	defer engine.Close()
    70  
    71  	setEngine(engine, true)
    72  
    73  	tests.BaseTestAll(engine, t)
    74  	tests.BaseTestAll2(engine, t)
    75  }
    76  
    77  func TestTidbMemoryNoCache(t *testing.T) {
    78  	engine, err := newTidbEngine("memory")
    79  	if err != nil {
    80  		t.Error(err)
    81  		return
    82  	}
    83  	defer engine.Close()
    84  	setEngine(engine, false)
    85  
    86  	tests.BaseTestAll(engine, t)
    87  	tests.BaseTestAll2(engine, t)
    88  	tests.BaseTestAll3(engine, t)
    89  }
    90  
    91  func TestTidbMemoryWithCache(t *testing.T) {
    92  	engine, err := newTidbEngine("memory")
    93  	if err != nil {
    94  		t.Error(err)
    95  		return
    96  	}
    97  	defer engine.Close()
    98  
    99  	setEngine(engine, true)
   100  
   101  	tests.BaseTestAll(engine, t)
   102  	tests.BaseTestAll2(engine, t)
   103  }
   104  
   105  func TestTidbBoltDBNoCache(t *testing.T) {
   106  	engine, err := newTidbEngine("boltdb")
   107  	if err != nil {
   108  		t.Error(err)
   109  		return
   110  	}
   111  	defer engine.Close()
   112  	setEngine(engine, false)
   113  
   114  	tests.BaseTestAll(engine, t)
   115  	tests.BaseTestAll2(engine, t)
   116  	tests.BaseTestAll3(engine, t)
   117  }
   118  
   119  func TestTidbBoltDBWithCache(t *testing.T) {
   120  	engine, err := newTidbEngine("boltdb")
   121  	if err != nil {
   122  		t.Error(err)
   123  		return
   124  	}
   125  	defer engine.Close()
   126  
   127  	setEngine(engine, true)
   128  
   129  	tests.BaseTestAll(engine, t)
   130  	tests.BaseTestAll2(engine, t)
   131  }
   132  
   133  const (
   134  	createTableQl = "CREATE TABLE IF NOT EXISTS `big_struct` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NULL, `title` TEXT NULL, `age` TEXT NULL, `alias` TEXT NULL, `nick_name` TEXT NULL);"
   135  	dropTableQl   = "DROP TABLE IF EXISTS `big_struct`;"
   136  )
   137  
   138  func BenchmarkTidbDriverInsert(t *testing.B) {
   139  	tests.DoBenchDriver(func() (*sql.DB, error) {
   140  		return newTidbDriverDB("goleveldb")
   141  	}, createTableQl, dropTableQl,
   142  		tests.DoBenchDriverInsert, t)
   143  }
   144  
   145  func BenchmarkTidbDriverFind(t *testing.B) {
   146  	tests.DoBenchDriver(func() (*sql.DB, error) {
   147  		return newTidbDriverDB("goleveldb")
   148  	}, createTableQl, dropTableQl,
   149  		tests.DoBenchDriverFind, t)
   150  }
   151  
   152  func BenchmarkTidbNoCacheInsert(t *testing.B) {
   153  	t.StopTimer()
   154  	engine, err := newTidbEngine("goleveldb")
   155  	if err != nil {
   156  		t.Error(err)
   157  		return
   158  	}
   159  	defer engine.Close()
   160  
   161  	tests.DoBenchInsert(engine, t)
   162  }
   163  
   164  func BenchmarkTidbNoCacheFind(t *testing.B) {
   165  	t.StopTimer()
   166  	engine, err := newTidbEngine("goleveldb")
   167  	if err != nil {
   168  		t.Error(err)
   169  		return
   170  	}
   171  	defer engine.Close()
   172  
   173  	//engine.ShowSQL = true
   174  	tests.DoBenchFind(engine, t)
   175  }
   176  
   177  func BenchmarkTidbNoCacheFindPtr(t *testing.B) {
   178  	t.StopTimer()
   179  	engine, err := newTidbEngine("goleveldb")
   180  	if err != nil {
   181  		t.Error(err)
   182  		return
   183  	}
   184  	defer engine.Close()
   185  	//engine.ShowSQL = true
   186  	tests.DoBenchFindPtr(engine, t)
   187  }
   188  
   189  func BenchmarkTidbCacheInsert(t *testing.B) {
   190  	t.StopTimer()
   191  	engine, err := newTidbEngine("goleveldb")
   192  	if err != nil {
   193  		t.Error(err)
   194  		return
   195  	}
   196  	defer engine.Close()
   197  
   198  	engine.SetDefaultCacher(newCache())
   199  	tests.DoBenchInsert(engine, t)
   200  }
   201  
   202  func BenchmarkTidbCacheFind(t *testing.B) {
   203  	t.StopTimer()
   204  	engine, err := newTidbEngine("goleveldb")
   205  	if err != nil {
   206  		t.Error(err)
   207  		return
   208  	}
   209  	defer engine.Close()
   210  
   211  	engine.SetDefaultCacher(newCache())
   212  	tests.DoBenchFind(engine, t)
   213  }
   214  
   215  func BenchmarkTidbCacheFindPtr(t *testing.B) {
   216  	t.StopTimer()
   217  	engine, err := newTidbEngine("goleveldb")
   218  	if err != nil {
   219  		t.Error(err)
   220  		return
   221  	}
   222  	defer engine.Close()
   223  
   224  	engine.SetDefaultCacher(newCache())
   225  	tests.DoBenchFindPtr(engine, t)
   226  }