Create & Init Project...

app/service/main/ugcpay-rank/internal/dao/BUILD

@@ -0,0 +1,70 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "grpc.go",
+        "localcache.go",
+        "mc.cache.go",
+        "mc.extra.go",
+        "mysql.go",
+    ],
+    importpath = "go-common/app/service/main/ugcpay-rank/internal/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/account/api:go_default_library",
+        "//app/service/main/account/model:go_default_library",
+        "//app/service/main/ugcpay-rank/internal/conf:go_default_library",
+        "//app/service/main/ugcpay-rank/internal/model:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log:go_default_library",
+        "//library/stat/prom:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/bluele/gcache:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "dao_test.go",
+        "grpc_test.go",
+        "localcache_test.go",
+        "mc.cache_test.go",
+        "mc.extra_test.go",
+        "mysql_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/main/ugcpay-rank/internal/conf:go_default_library",
+        "//app/service/main/ugcpay-rank/internal/model:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/service/main/ugcpay-rank/internal/dao/dao.go

@@ -0,0 +1,97 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	account "go-common/app/service/main/account/api"
+	"go-common/app/service/main/ugcpay-rank/internal/conf"
+	"go-common/app/service/main/ugcpay-rank/internal/model"
+	"go-common/library/cache/memcache"
+	xsql "go-common/library/database/sql"
+
+	"github.com/bluele/gcache"
+)
+
+// Dao dao
+type Dao struct {
+	mc         *memcache.Pool
+	db         *xsql.DB
+	accountAPI account.AccountClient
+	// local cache
+	elecAVRankLC gcache.Cache
+	elecUPRankLC gcache.Cache
+}
+
+// New init mysql db
+func New() (dao *Dao) {
+	dao = &Dao{
+		mc:           memcache.NewPool(conf.Conf.Memcache),
+		db:           xsql.NewMySQL(conf.Conf.MySQL),
+		elecAVRankLC: gcache.New(conf.Conf.LocalCache.ElecAVRankSize).LFU().Build(),
+		elecUPRankLC: gcache.New(conf.Conf.LocalCache.ElecUPRankSize).LFU().Build(),
+	}
+	var err error
+	if dao.accountAPI, err = account.NewClient(conf.Conf.AccountGRPC); err != nil {
+		panic(err)
+	}
+	return
+}
+
+// Close close the resource.
+func (d *Dao) Close() {
+	d.mc.Close()
+	d.db.Close()
+}
+
+// Ping dao ping
+func (d *Dao) Ping(ctx context.Context) error {
+	return nil
+}
+
+func elecUPRankKey(upMID int64, ver int64) string {
+	return fmt.Sprintf("ur_eur_%d_%d", ver, upMID)
+}
+
+func elecPrepUPRankKey(upMID int64, ver int64) string {
+	return fmt.Sprintf("ur_epur_%d_%d", ver, upMID)
+}
+
+func elecAVRankKey(avID int64, ver int64) string {
+	return fmt.Sprintf("ur_ear_%d_%d", ver, avID)
+}
+
+func elecPrepAVRankKey(avID int64, ver int64) string {
+	return fmt.Sprintf("ur_epar_%d_%d", ver, avID)
+}
+
+//go:generate $GOPATH/src/go-common/app/tool/cache/mc
+type _mc interface {
+	//mc: -key=elecUPRankKey -type=get
+	CacheElecUPRank(c context.Context, mid int64) (*model.RankElecUPProto, error)
+	//mc: -key=elecUPRankKey -expire=conf.Conf.CacheTTL.ElecUPRankTTL -encode=json
+	AddCacheElecUPRank(c context.Context, mid int64, value *model.RankElecUPProto) error
+	//mc: -key=elecUPRankKey
+	DelCacheElecUPRank(c context.Context, mid int64) error
+
+	//mc: -key=elecAVRankKey -type=get
+	CacheElecAVRank(c context.Context, avID int64) (*model.RankElecAVProto, error)
+	//mc: -key=elecAVRankKey -expire=conf.Conf.CacheTTL.ElecAVRankTTL -encode=json
+	AddCacheElecAVRank(c context.Context, avID int64, value *model.RankElecAVProto) error
+	//mc: -key=elecAVRankKey
+	DelCacheElecAVRank(c context.Context, avID int64) error
+
+	//mc: -key=elecPrepUPRankKey -type=get
+	CacheElecPrepUPRank(c context.Context, mid int64) (*model.RankElecPrepUPProto, error)
+	//mc: -key=elecPrepUPRankKey -expire=conf.Conf.CacheTTL.ElecPrepUPRankTTL -encode=json
+	AddCacheElecPrepUPRank(c context.Context, mid int64, value *model.RankElecPrepUPProto) error
+	//mc: -key=elecPrepUPRankKey
+	DelCacheElecPrepUPRank(c context.Context, mid int64) error
+
+	//mc: -key=elecPrepAVRankKey -type=get
+	CacheElecPrepAVRank(c context.Context, avID int64) (*model.RankElecPrepAVProto, error)
+	//mc: -key=elecPrepAVRankKey -expire=conf.Conf.CacheTTL.ElecPrepAVRankTTL -encode=json
+	AddCacheElecPrepAVRank(c context.Context, avID int64, value *model.RankElecPrepAVProto) error
+	//mc: -key=elecPrepAVRankKey
+	DelCacheElecPrepAVRank(c context.Context, avID int64) error
+}

app/service/main/ugcpay-rank/internal/dao/dao_test.go

@@ -0,0 +1,35 @@
+package dao
+
+import (
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/service/main/ugcpay-rank/internal/conf"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.account.ugcpay-rank-service")
+		flag.Set("conf_token", "af0015c6e9072270c243e43df817cebf")
+		flag.Set("tree_id", "81367")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../../cmd/test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New()
+	os.Exit(m.Run())
+}

app/service/main/ugcpay-rank/internal/dao/grpc.go

@@ -0,0 +1,23 @@
+package dao
+
+import (
+	"context"
+
+	acc "go-common/app/service/main/account/api"
+	accmdl "go-common/app/service/main/account/model"
+)
+
+// AccountCards get cards by mids
+func (d *Dao) AccountCards(ctx context.Context, mids []int64) (cards map[int64]*accmdl.Card, err error) {
+	var (
+		req = &acc.MidsReq{
+			Mids: mids,
+		}
+		reply *acc.CardsReply
+	)
+	if reply, err = d.accountAPI.Cards3(ctx, req); err != nil {
+		return
+	}
+	cards = reply.Cards
+	return
+}

app/service/main/ugcpay-rank/internal/dao/grpc_test.go

@@ -0,0 +1,24 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoAccountCards(t *testing.T) {
+	convey.Convey("AccountCards", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			mids = []int64{46333}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			cards, err := d.AccountCards(c, mids)
+			ctx.Convey("Then err should be nil.cards should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(cards, convey.ShouldHaveLength, 1)
+			})
+		})
+	})
+}

app/service/main/ugcpay-rank/internal/dao/localcache.go

@@ -0,0 +1,65 @@
+package dao
+
+import (
+	"time"
+
+	"go-common/app/service/main/ugcpay-rank/internal/conf"
+	"go-common/app/service/main/ugcpay-rank/internal/model"
+
+	"github.com/bluele/gcache"
+	"github.com/pkg/errors"
+)
+
+// LCStoreElecUPRank .
+func (d *Dao) LCStoreElecUPRank(upMID, ver int64, rank *model.RankElecUPProto) (err error) {
+	key := elecUPRankKey(upMID, ver)
+	if err = d.elecUPRankLC.SetWithExpire(key, rank, time.Duration(conf.Conf.LocalCache.ElecUPRankTTL)); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+// LCStoreElecAVRank .
+func (d *Dao) LCStoreElecAVRank(avID, ver int64, rank *model.RankElecAVProto) (err error) {
+	key := elecAVRankKey(avID, ver)
+	if err = d.elecAVRankLC.SetWithExpire(key, rank, time.Duration(conf.Conf.LocalCache.ElecAVRankTTL)); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+// LCLoadElecUPRank .
+func (d *Dao) LCLoadElecUPRank(upMID, ver int64) (rank *model.RankElecUPProto, err error) {
+	key := elecUPRankKey(upMID, ver)
+	item, err := d.elecUPRankLC.Get(key)
+	if err != nil {
+		if err == gcache.KeyNotFoundError {
+			err = nil
+			rank = nil
+			return
+		}
+		err = errors.WithStack(err)
+		return
+	}
+	rank = item.(*model.RankElecUPProto)
+	return
+}
+
+// LCLoadElecAVRank .
+func (d *Dao) LCLoadElecAVRank(avID, ver int64) (rank *model.RankElecAVProto, err error) {
+	key := elecAVRankKey(avID, ver)
+	item, err := d.elecAVRankLC.Get(key)
+	if err != nil {
+		if err == gcache.KeyNotFoundError {
+			err = nil
+			rank = nil
+			return
+		}
+		err = errors.WithStack(err)
+		return
+	}
+	rank = item.(*model.RankElecAVProto)
+	return
+}

app/service/main/ugcpay-rank/internal/dao/localcache_test.go

@@ -0,0 +1,150 @@
+package dao
+
+import (
+	"testing"
+	"time"
+
+	"go-common/app/service/main/ugcpay-rank/internal/conf"
+	"go-common/app/service/main/ugcpay-rank/internal/model"
+	xtime "go-common/library/time"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoLCLoadElecAVRankFromNil(t *testing.T) {
+	convey.Convey("loadElecAVRank", t, func(ctx convey.C) {
+		var (
+			avID = int64(233)
+			ver  = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			rank, err := d.LCLoadElecAVRank(avID, ver)
+			ctx.Convey("Then err should be nil.rank should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(rank, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoLCStoreElecAVRank(t *testing.T) {
+	convey.Convey("storeElecAVRank", t, func(ctx convey.C) {
+		var (
+			avID = int64(233)
+			ver  = int64(0)
+			rank = &model.RankElecAVProto{
+				AVID: 233,
+			}
+		)
+		conf.Conf.LocalCache.ElecAVRankTTL = xtime.Duration(time.Second)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.LCStoreElecAVRank(avID, ver, rank)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoLCLoadElecAVRank(t *testing.T) {
+	convey.Convey("loadElecAVRank", t, func(ctx convey.C) {
+		var (
+			avID = int64(233)
+			ver  = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			rank, err := d.LCLoadElecAVRank(avID, ver)
+			ctx.Convey("Then err should be nil.rank should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(rank, convey.ShouldNotBeNil)
+				ctx.So(rank.AVID, convey.ShouldEqual, avID)
+			})
+		})
+	})
+}
+
+func TestDaoLCLoadElecAVRankAfterTTL(t *testing.T) {
+	convey.Convey("loadElecAVRankAfterTTL", t, func(ctx convey.C) {
+		var (
+			avID = int64(233)
+			ver  = int64(0)
+		)
+		<-time.After(time.Duration(conf.Conf.LocalCache.ElecAVRankTTL))
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			rank, err := d.LCLoadElecAVRank(avID, ver)
+			ctx.Convey("Then err should be nil.rank should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(rank, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoLCLoadElecUPRankFromNil(t *testing.T) {
+	convey.Convey("loadElecUPRank", t, func(ctx convey.C) {
+		var (
+			upMID = int64(4633)
+			ver   = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			rank, err := d.LCLoadElecUPRank(upMID, ver)
+			ctx.Convey("Then err should be nil.rank should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(rank, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoLCStoreElecUPRank(t *testing.T) {
+	convey.Convey("storeElecUPRank", t, func(ctx convey.C) {
+		var (
+			upMID = int64(4633)
+			ver   = int64(0)
+			rank  = &model.RankElecUPProto{
+				Count: 100,
+			}
+		)
+		conf.Conf.LocalCache.ElecUPRankTTL = xtime.Duration(time.Second)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.LCStoreElecUPRank(upMID, ver, rank)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoLCLoadElecUPRank(t *testing.T) {
+	convey.Convey("loadElecUPRank", t, func(ctx convey.C) {
+		var (
+			upMID = int64(4633)
+			ver   = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			rank, err := d.LCLoadElecUPRank(upMID, ver)
+			ctx.Convey("Then err should be nil.rank should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(rank, convey.ShouldNotBeNil)
+				ctx.So(rank.Count, convey.ShouldEqual, 100)
+			})
+		})
+	})
+}
+
+func TestDaoLCLoadElecUPRankAfterTTL(t *testing.T) {
+	convey.Convey("loadElecUPRankAfterTTL", t, func(ctx convey.C) {
+		var (
+			upMID = int64(4633)
+			ver   = int64(0)
+		)
+		<-time.After(time.Duration(conf.Conf.LocalCache.ElecUPRankTTL))
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			rank, err := d.LCLoadElecUPRank(upMID, ver)
+			ctx.Convey("Then err should be nil.rank should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(rank, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/service/main/ugcpay-rank/internal/dao/mc.cache.go

@@ -0,0 +1,332 @@
+// Code generated by $GOPATH/src/go-common/app/tool/cache/mc. DO NOT EDIT.
+
+/*
+  Package dao is a generated mc cache package.
+  It is generated from:
+  type _mc interface {
+		//mc: -key=elecUPRankKey -type=get
+		CacheElecUPRank(c context.Context, mid int64) (*model.ElecUPRank, error)
+		//mc: -key=elecUPRankKey -expire=conf.Conf.CacheTTL.ElecUPRankTTL
+		AddCacheElecUPRank(c context.Context, mid int64, value *model.ElecUPRank) error
+		//mc: -key=elecUPRankKey
+		DelCacheElecUPRank(c context.Context, mid int64) error
+
+		//mc: -key=elecAVRankKey -type=get
+		CacheElecAVRank(c context.Context, avID int64) (*model.ElecAVRank, error)
+		//mc: -key=elecAVRankKey -expire=conf.Conf.CacheTTL.ElecAVRankTTL
+		AddCacheElecAVRank(c context.Context, avID int64, value *model.ElecAVRank) error
+		//mc: -key=elecAVRankKey
+		DelCacheElecAVRank(c context.Context, avID int64) error
+
+		//mc: -key=elecPrepUPRankKey -type=get
+		CacheElecPrepUPRank(c context.Context, mid int64) (*model.ElecPrepUPRank, error)
+		//mc: -key=elecPrepUPRankKey -expire=conf.Conf.CacheTTL.ElecPrepUPRankTTL
+		AddCacheElecPrepUPRank(c context.Context, mid int64, value *model.ElecPrepUPRank) error
+		//mc: -key=elecPrepUPRankKey
+		DelCacheElecPrepUPRank(c context.Context, mid int64) error
+
+		//mc: -key=elecPrepAVRankKey -type=get
+		CacheElecPrepAVRank(c context.Context, avID int64) (*model.ElecPrepAVRank, error)
+		//mc: -key=elecPrepAVRankKey -expire=conf.Conf.CacheTTL.ElecPrepAVRankTTL
+		AddCacheElecPrepAVRank(c context.Context, avID int64, value *model.ElecPrepAVRank) error
+		//mc: -key=elecPrepAVRankKey
+		DelCacheElecPrepAVRank(c context.Context, avID int64) error
+	}
+*/
+
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/service/main/ugcpay-rank/internal/conf"
+	"go-common/app/service/main/ugcpay-rank/internal/model"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+	"go-common/library/stat/prom"
+)
+
+var _ _mc
+
+// CacheElecUPRank get data from mc
+func (d *Dao) CacheElecUPRank(c context.Context, upMID int64, ver int64) (res *model.RankElecUPProto, err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := elecUPRankKey(upMID, ver)
+	reply, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:CacheElecUPRank")
+		log.Errorv(c, log.KV("CacheElecUPRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	res = &model.RankElecUPProto{}
+	err = conn.Scan(reply, res)
+	if err != nil {
+		prom.BusinessErrCount.Incr("mc:CacheElecUPRank")
+		log.Errorv(c, log.KV("CacheElecUPRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// SetCacheElecUPRank Set data to mc
+func (d *Dao) SetCacheElecUPRank(c context.Context, upMID, ver int64, val *model.RankElecUPProto) (err error) {
+	if val == nil {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := elecUPRankKey(upMID, ver)
+	item := &memcache.Item{Key: key, Object: val, Expiration: conf.Conf.CacheTTL.ElecUPRankTTL, Flags: memcache.FlagProtobuf}
+	if err = conn.Set(item); err != nil {
+		prom.BusinessErrCount.Incr("mc:SetCacheElecUPRank")
+		log.Errorv(c, log.KV("SetCacheElecUPRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// DelCacheElecUPRank delete data from mc
+func (d *Dao) DelCacheElecUPRank(c context.Context, upMID, ver int64) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := elecUPRankKey(upMID, ver)
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:DelCacheElecUPRank")
+		log.Errorv(c, log.KV("DelCacheElecUPRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// CacheElecAVRank get data from mc
+func (d *Dao) CacheElecAVRank(c context.Context, avID, ver int64) (res *model.RankElecAVProto, err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := elecAVRankKey(avID, ver)
+	reply, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:CacheElecAVRank")
+		log.Errorv(c, log.KV("CacheElecAVRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	res = &model.RankElecAVProto{}
+	err = conn.Scan(reply, res)
+	if err != nil {
+		prom.BusinessErrCount.Incr("mc:CacheElecAVRank")
+		log.Errorv(c, log.KV("CacheElecAVRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// SetCacheElecAVRank Set data to mc
+func (d *Dao) SetCacheElecAVRank(c context.Context, avID, ver int64, val *model.RankElecAVProto) (err error) {
+	if val == nil {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := elecAVRankKey(avID, ver)
+	item := &memcache.Item{Key: key, Object: val, Expiration: conf.Conf.CacheTTL.ElecAVRankTTL, Flags: memcache.FlagProtobuf}
+	if err = conn.Set(item); err != nil {
+		prom.BusinessErrCount.Incr("mc:SetCacheElecAVRank")
+		log.Errorv(c, log.KV("SetCacheElecAVRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// DelCacheElecAVRank delete data from mc
+func (d *Dao) DelCacheElecAVRank(c context.Context, avID, ver int64) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := elecAVRankKey(avID, ver)
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:DelCacheElecAVRank")
+		log.Errorv(c, log.KV("DelCacheElecAVRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// CacheElecPrepUPRank get data from mc
+func (d *Dao) CacheElecPrepUPRank(c context.Context, upMID, ver int64) (res *model.RankElecPrepUPProto, item *memcache.Item, err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := elecPrepUPRankKey(upMID, ver)
+	item, err = conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:CacheElecPrepUPRank")
+		log.Errorv(c, log.KV("CacheElecPrepUPRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	res = &model.RankElecPrepUPProto{}
+	err = conn.Scan(item, res)
+	if err != nil {
+		prom.BusinessErrCount.Incr("mc:CacheElecPrepUPRank")
+		log.Errorv(c, log.KV("CacheElecPrepUPRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// SetCacheElecPrepUPRank Set data to mc
+func (d *Dao) SetCacheElecPrepUPRank(c context.Context, upMID, ver int64, val *model.RankElecPrepUPProto) (err error) {
+	if val == nil {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := elecPrepUPRankKey(upMID, ver)
+	item := &memcache.Item{Key: key, Object: val, Expiration: conf.Conf.CacheTTL.ElecPrepUPRankTTL, Flags: memcache.FlagProtobuf}
+	if err = conn.Set(item); err != nil {
+		prom.BusinessErrCount.Incr("mc:SetCacheElecPrepUPRank")
+		log.Errorv(c, log.KV("SetCacheElecPrepUPRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// DelCacheElecPrepUPRank delete data from mc
+func (d *Dao) DelCacheElecPrepUPRank(c context.Context, upMID, ver int64) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := elecPrepUPRankKey(upMID, ver)
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:DelCacheElecPrepUPRank")
+		log.Errorv(c, log.KV("DelCacheElecPrepUPRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// CacheElecPrepAVRank get data from mc
+func (d *Dao) CacheElecPrepAVRank(c context.Context, avID, ver int64) (res *model.RankElecPrepAVProto, item *memcache.Item, err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := elecPrepAVRankKey(avID, ver)
+	item, err = conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:CacheElecPrepAVRank")
+		log.Errorv(c, log.KV("CacheElecPrepAVRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	res = &model.RankElecPrepAVProto{}
+	err = conn.Scan(item, res)
+	if err != nil {
+		prom.BusinessErrCount.Incr("mc:CacheElecPrepAVRank")
+		log.Errorv(c, log.KV("CacheElecPrepAVRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// SetCacheElecPrepAVRank Set data to mc
+func (d *Dao) SetCacheElecPrepAVRank(c context.Context, avID, ver int64, val *model.RankElecPrepAVProto) (err error) {
+	if val == nil {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := elecPrepAVRankKey(avID, ver)
+	item := &memcache.Item{Key: key, Object: val, Expiration: conf.Conf.CacheTTL.ElecPrepAVRankTTL, Flags: memcache.FlagProtobuf}
+	if err = conn.Set(item); err != nil {
+		prom.BusinessErrCount.Incr("mc:SetCacheElecPrepAVRank")
+		log.Errorv(c, log.KV("SetCacheElecPrepAVRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// DelCacheElecPrepAVRank delete data from mc
+func (d *Dao) DelCacheElecPrepAVRank(c context.Context, avID, ver int64) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := elecPrepAVRankKey(avID, ver)
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:DelCacheElecPrepAVRank")
+		log.Errorv(c, log.KV("DelCacheElecPrepAVRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// AddCacheElecPrepAVRank Set data to mc
+func (d *Dao) AddCacheElecPrepAVRank(c context.Context, avID, ver int64, val *model.RankElecPrepAVProto) (ok bool, err error) {
+	ok = true
+	if val == nil {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := elecPrepAVRankKey(avID, ver)
+	item := &memcache.Item{Key: key, Object: val, Expiration: conf.Conf.CacheTTL.ElecPrepAVRankTTL, Flags: memcache.FlagProtobuf}
+	if err = conn.Add(item); err != nil {
+		if err == memcache.ErrNotStored {
+			ok = false
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:AddCacheElecPrepAVRank")
+		log.Errorv(c, log.KV("AddCacheElecPrepAVRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// AddCacheElecPrepUPRank Set data to mc
+func (d *Dao) AddCacheElecPrepUPRank(c context.Context, upMID, ver int64, val *model.RankElecPrepUPProto) (ok bool, err error) {
+	ok = true
+	if val == nil {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := elecPrepUPRankKey(upMID, ver)
+	item := &memcache.Item{Key: key, Object: val, Expiration: conf.Conf.CacheTTL.ElecPrepUPRankTTL, Flags: memcache.FlagProtobuf}
+	if err = conn.Set(item); err != nil {
+		if err == memcache.ErrNotStored {
+			ok = false
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:AddCacheElecPrepUPRank")
+		log.Errorv(c, log.KV("AddCacheElecPrepUPRank", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}

app/service/main/ugcpay-rank/internal/dao/mc.cache_test.go

@@ -0,0 +1,270 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/service/main/ugcpay-rank/internal/model"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoSetCacheElecUPRank(t *testing.T) {
+	convey.Convey("SetCacheElecUPRank", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(233)
+			ver = int64(0)
+			val = &model.RankElecUPProto{
+				CountUPTotalElec: 233,
+			}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.SetCacheElecUPRank(c, id, ver, val)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoCacheElecUPRank(t *testing.T) {
+	convey.Convey("CacheElecUPRank", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(233)
+			ver = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.CacheElecUPRank(c, id, ver)
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldNotBeNil)
+
+			res, err = d.CacheElecUPRank(c, 0, ver)
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoDelCacheElecUPRank(t *testing.T) {
+	convey.Convey("DelCacheElecUPRank", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(233)
+			ver = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.DelCacheElecUPRank(c, id, ver)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSetCacheElecAVRank(t *testing.T) {
+	convey.Convey("SetCacheElecAVRank", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(233)
+			val = &model.RankElecAVProto{
+				CountUPTotalElec: 233,
+			}
+			ver = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.SetCacheElecAVRank(c, id, ver, val)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoCacheElecAVRank(t *testing.T) {
+	convey.Convey("CacheElecAVRank", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(233)
+			ver = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.CacheElecAVRank(c, id, ver)
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldNotBeNil)
+
+			res, err = d.CacheElecAVRank(c, 0, ver)
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoDelCacheElecAVRank(t *testing.T) {
+	convey.Convey("DelCacheElecAVRank", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(233)
+			ver = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.DelCacheElecAVRank(c, id, ver)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSetCacheElecPrepUPRank(t *testing.T) {
+	convey.Convey("SetCacheElecPrepUPRank", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(233)
+			val = &model.RankElecPrepUPProto{
+				Count: 233,
+			}
+			ver = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.SetCacheElecPrepUPRank(c, id, ver, val)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoCacheElecPrepUPRank(t *testing.T) {
+	convey.Convey("CacheElecPrepUPRank", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(233)
+			ver = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, item, err := d.CacheElecPrepUPRank(c, id, ver)
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(item, convey.ShouldNotBeNil)
+			ctx.So(res, convey.ShouldNotBeNil)
+
+			res, item, err = d.CacheElecPrepUPRank(c, 0, ver)
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(item, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoDelCacheElecPrepUPRank(t *testing.T) {
+	convey.Convey("DelCacheElecPrepUPRank", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(233)
+			ver = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.DelCacheElecPrepUPRank(c, id, ver)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSetCacheElecPrepAVRank(t *testing.T) {
+	convey.Convey("SetCacheElecPrepAVRank", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(233)
+			val = &model.RankElecPrepAVProto{
+				AVID: 233,
+			}
+			ver = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.SetCacheElecPrepAVRank(c, id, ver, val)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoCacheElecPrepAVRank(t *testing.T) {
+	convey.Convey("CacheElecPrepAVRank", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(233)
+			ver = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, item, err := d.CacheElecPrepAVRank(c, id, ver)
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(item, convey.ShouldNotBeNil)
+			ctx.So(res, convey.ShouldNotBeNil)
+
+			res, item, err = d.CacheElecPrepAVRank(c, 0, ver)
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(item, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoDelCacheElecPrepAVRank(t *testing.T) {
+	convey.Convey("DelCacheElecPrepAVRank", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(233)
+			ver = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.DelCacheElecPrepAVRank(c, id, ver)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddCacheElecPrepAVRank(t *testing.T) {
+	convey.Convey("AddCacheElecPrepAVRank", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(233)
+			val = &model.RankElecPrepAVProto{
+				AVID: 233,
+			}
+			ver = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			ok, err := d.AddCacheElecPrepAVRank(c, id, ver, val)
+			ctx.Convey("Then err should be nil.ok should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(ok, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddCacheElecPrepUPRank(t *testing.T) {
+	convey.Convey("AddCacheElecPrepUPRank", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(233)
+			val = &model.RankElecPrepUPProto{
+				UPMID: 233,
+			}
+			ver = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			ok, err := d.AddCacheElecPrepUPRank(c, id, ver, val)
+			ctx.Convey("Then err should be nil.ok should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(ok, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/service/main/ugcpay-rank/internal/dao/mc.extra.go

@@ -0,0 +1,39 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/service/main/ugcpay-rank/internal/conf"
+	"go-common/library/cache/memcache"
+)
+
+// CASCacheElecPrepRank cas的方式存储预备榜单，防止分布式脏写
+func (d *Dao) CASCacheElecPrepRank(c context.Context, val interface{}, rawItem *memcache.Item) (ok bool, err error) {
+	var (
+		conn = d.mc.Get(c)
+	)
+	defer conn.Close()
+
+	rawItem.Object = val
+	rawItem.Expiration = conf.Conf.CacheTTL.ElecPrepAVRankTTL
+	rawItem.Flags = memcache.FlagProtobuf
+
+	if err = conn.CompareAndSwap(rawItem); err != nil {
+		if err == memcache.ErrCASConflict { // CAS冲突, 则返回ok == false, 准备重试
+			err = nil
+			return
+		}
+		if err == memcache.ErrNotStored { // 如果CAS中恰好失效，尝试Add
+			if err = conn.Add(rawItem); err != nil {
+				if err == memcache.ErrNotStored { // 在Add时恰好又被其他实例Add过, 则返回ok == false, 准备重试
+					err = nil
+					return
+				}
+				return // 在Add时发生未知错误
+			}
+		}
+		return // 在CAS时发生未知错误
+	}
+	ok = true
+	return
+}

app/service/main/ugcpay-rank/internal/dao/mc.extra_test.go

@@ -0,0 +1,44 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/service/main/ugcpay-rank/internal/model"
+	"go-common/library/cache/memcache"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoCASCacheElecPrepRank(t *testing.T) {
+	convey.Convey("CASCacheElecPrepRank", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			val = &model.RankElecPrepUPProto{
+				Count: 233,
+				UPMID: 233,
+				Size_: 10,
+			}
+			id      int64 = 233
+			rawItem *memcache.Item
+			err     error
+			ver     = int64(0)
+		)
+		_, rawItem, err = d.CacheElecPrepUPRank(c, id, ver)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(rawItem, convey.ShouldNotBeNil)
+
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			var ok bool
+			ok, err = d.CASCacheElecPrepRank(c, val, rawItem)
+			ctx.Convey("Then err should be nil.ok should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(ok, convey.ShouldNotBeNil)
+			})
+		})
+
+		data, _, err := d.CacheElecPrepUPRank(c, id, ver)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(data, convey.ShouldResemble, val)
+	})
+}

app/service/main/ugcpay-rank/internal/dao/mysql.go

@@ -0,0 +1,270 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"go-common/app/service/main/ugcpay-rank/internal/model"
+	xsql "go-common/library/database/sql"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_countElecUPRank      = "SELECT count(1) FROM rank_elec_up WHERE up_mid=? AND ver=? AND hidden=0"
+	_countUPTotalElec     = "SELECT count(1) FROM rank_elec_up WHERE up_mid=? AND ver<>0 AND hidden=0"
+	_selectElecUPRankList = "SELECT id,ver,up_mid,pay_mid,pay_amount,hidden,ctime,mtime FROM rank_elec_up WHERE up_mid=? AND ver=? AND hidden=0 ORDER BY pay_amount DESC,mtime ASC LIMIT ?"
+	_selectElecUPRank     = "SELECT id,ver,up_mid,pay_mid,pay_amount,hidden,ctime,mtime FROM rank_elec_up WHERE up_mid=? AND ver=? AND pay_mid=? LIMIT 1"
+
+	_countElecAVRank      = "SELECT count(1) FROM rank_elec_av WHERE avid=? AND ver=? AND hidden=0"
+	_selectElecAVRankList = "SELECT id,ver,avid,up_mid,pay_mid,pay_amount,hidden,ctime,mtime FROM rank_elec_av WHERE avid=? AND ver=? AND hidden=0 ORDER BY pay_amount DESC,mtime ASC LIMIT ?"
+	_selectElecAVRank     = "SELECT id,ver,avid,up_mid,pay_mid,pay_amount,hidden,ctime,mtime FROM rank_elec_av WHERE avid=? AND ver=? AND pay_mid=? LIMIT 1"
+
+	_selectElecUPMessages      = "SELECT id,ver,avid,up_mid,pay_mid,message,replied,hidden FROM elec_message WHERE pay_mid in (%s) AND up_mid=? AND ver=? ORDER BY ID ASC"
+	_selectElecAVMessagesByVer = "SELECT id,ver,avid,up_mid,pay_mid,message,replied,hidden FROM elec_message WHERE pay_mid in (%s) AND avid=? AND ver=? ORDER BY ID ASC"
+	_selectElecAVMessages      = "SELECT id,ver,avid,up_mid,pay_mid,message,replied,hidden FROM elec_message WHERE pay_mid in (%s) AND avid=? ORDER BY ID ASC"
+
+	_selectElecUPUserRank = "SELECT count(1) FROM rank_elec_up WHERE up_mid=? AND ver=? AND pay_amount>? AND mtime<? LIMIT 1"
+	_selectElecAVUserRank = "SELECT count(1) FROM rank_elec_av WHERE avid=? AND ver=? AND pay_amount>? AND mtime<? LIMIT 1"
+)
+
+// BeginTran begin transcation.
+func (d *Dao) BeginTran(c context.Context) (tx *xsql.Tx, err error) {
+	return d.db.Begin(c)
+}
+
+// RawElecUPRankList get elec up rank
+func (d *Dao) RawElecUPRankList(ctx context.Context, upMID int64, ver int64, limit int) (list []*model.DBElecUPRank, err error) {
+	rows, err := d.db.Query(ctx, _selectElecUPRankList, upMID, ver, limit)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		data := &model.DBElecUPRank{}
+		if err = rows.Scan(&data.ID, &data.Ver, &data.UPMID, &data.PayMID, &data.PayAmount, &data.Hidden, &data.CTime, &data.MTime); err != nil {
+			return
+		}
+		list = append(list, data)
+	}
+	err = rows.Err()
+	return
+}
+
+// RawElecUPRank get elec up rank
+func (d *Dao) RawElecUPRank(ctx context.Context, upMID int64, ver int64, payMID int64) (data *model.DBElecUPRank, err error) {
+	row := d.db.Master().QueryRow(ctx, _selectElecUPRank, upMID, ver, payMID)
+	if err != nil {
+		return
+	}
+	data = &model.DBElecUPRank{}
+	if err = row.Scan(&data.ID, &data.Ver, &data.UPMID, &data.PayMID, &data.PayAmount, &data.Hidden, &data.CTime, &data.MTime); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			data = nil
+		}
+		return
+	}
+	return
+}
+
+// RawCountElecUPRank .
+func (d *Dao) RawCountElecUPRank(ctx context.Context, upMID int64, ver int64) (count int64, err error) {
+	row := d.db.QueryRow(ctx, _countElecUPRank, upMID, ver)
+	if err = row.Scan(&count); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			count = 0
+		}
+		return
+	}
+	return
+}
+
+// RawCountUPTotalElec stupid bug from prod.
+func (d *Dao) RawCountUPTotalElec(ctx context.Context, upMID int64) (count int64, err error) {
+	row := d.db.QueryRow(ctx, _countUPTotalElec, upMID)
+	if err = row.Scan(&count); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			count = 0
+		}
+		return
+	}
+	return
+}
+
+// RawElecAVRankList .
+func (d *Dao) RawElecAVRankList(ctx context.Context, avID int64, ver int64, limit int) (list []*model.DBElecAVRank, err error) {
+	rows, err := d.db.Query(ctx, _selectElecAVRankList, avID, ver, limit)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		data := &model.DBElecAVRank{}
+		if err = rows.Scan(&data.ID, &data.Ver, &data.AVID, &data.UPMID, &data.PayMID, &data.PayAmount, &data.Hidden, &data.CTime, &data.MTime); err != nil {
+			return
+		}
+		list = append(list, data)
+	}
+	err = rows.Err()
+	return
+}
+
+// RawElecAVRank .
+func (d *Dao) RawElecAVRank(ctx context.Context, avID int64, ver int64, payMID int64) (data *model.DBElecAVRank, err error) {
+	rows := d.db.Master().QueryRow(ctx, _selectElecAVRank, avID, ver, payMID)
+	if err != nil {
+		return
+	}
+	data = &model.DBElecAVRank{}
+	if err = rows.Scan(&data.ID, &data.Ver, &data.AVID, &data.UPMID, &data.PayMID, &data.PayAmount, &data.Hidden, &data.CTime, &data.MTime); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			data = nil
+		}
+		return
+	}
+	return
+}
+
+// RawCountElecAVRank .
+func (d *Dao) RawCountElecAVRank(ctx context.Context, avID int64, ver int64) (count int64, err error) {
+	row := d.db.QueryRow(ctx, _countElecAVRank, avID, ver)
+	if err = row.Scan(&count); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			count = 0
+		}
+		return
+	}
+	return
+}
+
+// RawElecUPMessages .
+func (d *Dao) RawElecUPMessages(ctx context.Context, payMIDs []int64, upMID int64, ver int64) (dataMap map[int64]*model.DBElecMessage, err error) {
+	dataMap = make(map[int64]*model.DBElecMessage)
+	if len(payMIDs) <= 0 {
+		return
+	}
+	sql := fmt.Sprintf(_selectElecUPMessages, xstr.JoinInts(payMIDs))
+	rows, err := d.db.Query(ctx, sql, upMID, ver)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		data := &model.DBElecMessage{}
+		if err = rows.Scan(&data.ID, &data.Ver, &data.AVID, &data.UPMID, &data.PayMID, &data.Message, &data.Replied, &data.Hidden); err != nil {
+			return
+		}
+		dataMap[data.PayMID] = data
+	}
+	return
+}
+
+// RawElecAVMessagesByVer  .
+func (d *Dao) RawElecAVMessagesByVer(ctx context.Context, payMIDs []int64, avID int64, ver int64) (dataMap map[int64]*model.DBElecMessage, err error) {
+	dataMap = make(map[int64]*model.DBElecMessage)
+	if len(payMIDs) <= 0 {
+		return
+	}
+	sql := fmt.Sprintf(_selectElecAVMessagesByVer, xstr.JoinInts(payMIDs))
+	rows, err := d.db.Query(ctx, sql, avID, ver)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		data := &model.DBElecMessage{}
+		if err = rows.Scan(&data.ID, &data.Ver, &data.AVID, &data.UPMID, &data.PayMID, &data.Message, &data.Replied, &data.Hidden); err != nil {
+			return
+		}
+		dataMap[data.PayMID] = data
+	}
+	return
+}
+
+// RawElecAVMessages .
+func (d *Dao) RawElecAVMessages(ctx context.Context, payMIDs []int64, avID int64) (dataMap map[int64]*model.DBElecMessage, err error) {
+	dataMap = make(map[int64]*model.DBElecMessage)
+	if len(payMIDs) <= 0 {
+		return
+	}
+	sql := fmt.Sprintf(_selectElecAVMessages, xstr.JoinInts(payMIDs))
+	rows, err := d.db.Query(ctx, sql, avID)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		data := &model.DBElecMessage{}
+		if err = rows.Scan(&data.ID, &data.Ver, &data.AVID, &data.UPMID, &data.PayMID, &data.Message, &data.Replied, &data.Hidden); err != nil {
+			return
+		}
+		dataMap[data.PayMID] = data
+	}
+	return
+}
+
+// RawElecUPUserRank .
+func (d *Dao) RawElecUPUserRank(ctx context.Context, upMID int64, ver int64, payAmount int64, mtime time.Time) (rank int, err error) {
+	row := d.db.QueryRow(ctx, _selectElecUPUserRank, upMID, ver, payAmount, mtime)
+	if err = row.Scan(&rank); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			rank = 0
+		}
+		return
+	}
+	return
+}
+
+// RawElecAVUserRank .
+func (d *Dao) RawElecAVUserRank(ctx context.Context, avID int64, ver int64, payAmount int64, mtime time.Time) (rank int, err error) {
+	row := d.db.QueryRow(ctx, _selectElecAVUserRank, avID, ver, payAmount, mtime)
+	if err = row.Scan(&rank); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			rank = 0
+		}
+		return
+	}
+	return
+}
+
+const (
+	_elecUserSettingList = "SELECT id,mid,value FROM elec_user_setting WHERE id>? ORDER BY id ASC LIMIT ?"
+)
+
+// RawElecUserSettings .
+func (d *Dao) RawElecUserSettings(ctx context.Context, id int, limit int) (res map[int64]model.ElecUserSetting, maxID int, err error) {
+	rows, err := d.db.Master().Query(ctx, _elecUserSettingList, id, limit)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	res = make(map[int64]model.ElecUserSetting)
+	for rows.Next() {
+		var (
+			data model.ElecUserSetting
+			mid  int64
+			id   int
+		)
+		if err = rows.Scan(&id, &mid, &data); err != nil {
+			err = errors.WithStack(err)
+			return
+		}
+		res[mid] = data
+		if maxID < id {
+			maxID = id
+		}
+	}
+	if err = rows.Err(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}

app/service/main/ugcpay-rank/internal/dao/mysql_test.go

@@ -0,0 +1,254 @@
+package dao
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoBeginTran(t *testing.T) {
+	convey.Convey("BeginTran", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			tx, err := d.BeginTran(c)
+			ctx.Convey("Then err should be nil.tx should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(tx, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoRawElecUPRankList(t *testing.T) {
+	convey.Convey("RawElecUPRankList", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			upMID = int64(15555180)
+			ver   = int64(0)
+			limit = int(10)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			list, err := d.RawElecUPRankList(c, upMID, ver, limit)
+			ctx.Convey("Then err should be nil.list should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(list, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoRawElecUPRank(t *testing.T) {
+	convey.Convey("RawElecUPRank", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			upMID  = int64(15555180)
+			ver    = int64(0)
+			payMID = int64(14137123)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			data, err := d.RawElecUPRank(c, upMID, ver, payMID)
+			ctx.Convey("Then err should be nil.data should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(data, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoRawCountElecUPRank(t *testing.T) {
+	convey.Convey("RawCountElecUPRank", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			upMID = int64(15555180)
+			ver   = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			count, err := d.RawCountElecUPRank(c, upMID, ver)
+			ctx.Convey("Then err should be nil.count should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(count, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoRawElecAVRankList(t *testing.T) {
+	convey.Convey("RawElecAVRankList", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			avID  = int64(4052629)
+			ver   = int64(0)
+			limit = int(10)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			list, err := d.RawElecAVRankList(c, avID, ver, limit)
+			ctx.Convey("Then err should be nil.list should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(list, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoRawElecAVRank(t *testing.T) {
+	convey.Convey("RawElecAVRank", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			avID   = int64(4052629)
+			ver    = int64(0)
+			payMID = int64(4780461)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			data, err := d.RawElecAVRank(c, avID, ver, payMID)
+			ctx.Convey("Then err should be nil.data should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(data, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoRawCountElecAVRank(t *testing.T) {
+	convey.Convey("RawCountElecAVRank", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			avID = int64(4052629)
+			ver  = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			count, err := d.RawCountElecAVRank(c, avID, ver)
+			ctx.Convey("Then err should be nil.count should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(count, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoRawElecUPMessages(t *testing.T) {
+	convey.Convey("RawElecUPMessages", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			payMIDs = []int64{27515316}
+			upMID   = int64(27515241)
+			ver     = int64(201705)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			dataMap, err := d.RawElecUPMessages(c, payMIDs, upMID, ver)
+			ctx.Convey("Then err should be nil.dataMap should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(dataMap, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoRawElecAVMessagesByVer(t *testing.T) {
+	convey.Convey("RawElecAVMessages", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			payMIDs = []int64{27515316}
+			avID    = int64(123)
+			ver     = int64(201705)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			dataMap, err := d.RawElecAVMessagesByVer(c, payMIDs, avID, ver)
+			ctx.Convey("Then err should be nil.dataMap should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(dataMap, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoRawElecAVMessages(t *testing.T) {
+	convey.Convey("RawElecAVMessages", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			payMIDs = []int64{27515316}
+			avID    = int64(123)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			dataMap, err := d.RawElecAVMessages(c, payMIDs, avID)
+			ctx.Convey("Then err should be nil.dataMap should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(dataMap, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoRawElecUPUserRank(t *testing.T) {
+	convey.Convey("RawElecUPUserRank", t, func(ctx convey.C) {
+		var (
+			c         = context.Background()
+			upMID     = int64(15555180)
+			ver       = int64(0)
+			payAmount = int64(200)
+			mtime     = time.Now()
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			rank, err := d.RawElecUPUserRank(c, upMID, ver, payAmount, mtime)
+			ctx.Convey("Then err should be nil.rank should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(rank, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoRawElecAVUserRank(t *testing.T) {
+	convey.Convey("RawElecAVUserRank", t, func(ctx convey.C) {
+		var (
+			c         = context.Background()
+			avID      = int64(4052629)
+			ver       = int64(0)
+			payAmount = int64(200)
+			mtime     = time.Now()
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			rank, err := d.RawElecAVUserRank(c, avID, ver, payAmount, mtime)
+			ctx.Convey("Then err should be nil.rank should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(rank, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+func TestDaoRawCountUPTotalElec(t *testing.T) {
+	convey.Convey("RawCountUPTotalElec", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			upMID = int64(46333)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			count, err := d.RawCountUPTotalElec(c, upMID)
+			ctx.Convey("Then err should be nil.count should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(count, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+func TestDaoRawElecUserSettings(t *testing.T) {
+	convey.Convey("RawElecUserSetting", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			id    = 0
+			limit = 10
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			value, maxID, err := d.RawElecUserSettings(c, id, limit)
+			ctx.Convey("Then err should be nil.value should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(maxID, convey.ShouldBeGreaterThan, 0)
+				ctx.So(value, convey.ShouldNotBeNil)
+				ctx.So(value, convey.ShouldHaveLength, 10)
+			})
+		})
+	})
+}