ajust sotage struct

plugin/dapp/exchange/executor/kv.go

-package executor
-
-import (
-	"fmt"
-
-	"github.com/33cn/plugin/plugin/dapp/exchange/types"
-)
-
-/*
- * 用户合约存取kv数据时，key值前缀需要满足一定规范
- * 即key = keyPrefix + userKey
- * 需要字段前缀查询时，使用’-‘作为分割符号
- */
-
-var (
-	//KeyPrefixStateDB state db key必须前缀
-	KeyPrefixStateDB = "mavl-exchange-"
-	//KeyPrefixLocalDB local db的key必须前缀
-	KeyPrefixLocalDB = "LODB-exchange-"
-)
-
-//状态数据库中存储具体挂单信息
-func calcOrderKey(orderID string) []byte {
-	key := fmt.Sprintf("%s"+"orderID:%s", KeyPrefixStateDB, orderID)
-	return []byte(key)
-}
-func calcMarketDepthPrefix(left, right *types.Asset, op int32) []byte {
-	key := fmt.Sprintf("%s"+"depth-%s-%s-%d:", KeyPrefixLocalDB, left.GetSymbol(), right.GetSymbol(), op)
-	return []byte(key)
-}
-
-//市场深度
-func calcMarketDepthKey(left, right *types.Asset, op int32, price float64) []byte {
-	// 设置精度为1e8
-	key := fmt.Sprintf("%s"+"depth-%s-%s-%d:%016d", KeyPrefixLocalDB, left.GetSymbol(), right.GetSymbol(), op, int64(Truncate(price)*float64(1e8)))
-	return []byte(key)
-}
-
-func calcMarketDepthOrderPrefix(left, right *types.Asset, op int32, price float64) []byte {
-	// 设置精度为1e8
-	key := fmt.Sprintf("%s"+"order-%s-%s-%d:%016d", KeyPrefixLocalDB, left.GetSymbol(), right.GetSymbol(), op, int64(Truncate(price)*float64(1e8)))
-	return []byte(key)
-}
-
-// localdb中存储市场挂单ID
-func calcMarketDepthOrderKey(left, right *types.Asset, op int32, price float64, index int64) []byte {
-	// 设置精度为1e8
-	key := fmt.Sprintf("%s"+"order-%s-%s-%d:%016d:%022d", KeyPrefixLocalDB, left.GetSymbol(), right.GetSymbol(), op, int64(Truncate(price)*float64(1e8)), index)
-	return []byte(key)
-}
-
-//最新已经成交的订单，这里状态固定都是完成状态,这个主要给外部使用，可以查询最新得成交信息,存在多个情况
-//matchOrderIndex,是匹配order在数组中的index,这里预留4个0000，用来解决同一笔交易中存在key重复得情况，这样设计保证了key得唯一性
-func calcCompletedOrderKey(left, right *types.Asset, index int64) []byte {
-	// 设置精度为1e8
-	key := fmt.Sprintf("%s"+"completed-%s-%s-%d:%022d", KeyPrefixLocalDB, left.GetSymbol(), right.GetSymbol(), types.Completed, index)
-	return []byte(key)
-}
-func calcCompletedOrderPrefix(left, right *types.Asset) []byte {
-	// 设置精度为1e8
-	key := fmt.Sprintf("%s"+"completed-%s-%s-%d:", KeyPrefixLocalDB, left.GetSymbol(), right.GetSymbol(), types.Completed)
-	return []byte(key)
-}
-
-//根据地址和订单状态，去查询订单列表,包含所有交易对
-func calcUserOrderIDPrefix(status int32, addr string) []byte {
-	key := fmt.Sprintf("%s"+"addr:%s:%d:", KeyPrefixLocalDB, addr, status)
-	return []byte(key)
-}
-
-//matchOrderIndex,用来解决同一笔交易中存在key重复得情况，这样设计保证了key得唯一性
-func calcUserOrderIDKey(status int32, addr string, index int64) []byte {
-	key := fmt.Sprintf("%s"+"addr:%s:%d:%022d", KeyPrefixLocalDB, addr, status, index)
-	return []byte(key)
-}

plugin/dapp/exchange/executor/query.go

@@ -20,7 +20,7 @@ func (s *exchange) Query_QueryMarketDepth(in *et.QueryMarketDepth) (types.Messag
 	if !CheckOp(in.Op) {
 		return nil, et.ErrAssetOp
 	}
-	return QueryMarketDepth(s.GetLocalDB(), in.LeftAsset, in.RightAsset, in.Op, in.Price, in.Count)
+	return QueryMarketDepth(s.GetLocalDB(), in.LeftAsset, in.RightAsset, in.Op, in.PrimaryKey, in.Count)
 }
 
 //查询已经完成得订单
@@ -35,15 +35,15 @@ func (s *exchange) Query_QueryCompletedOrderList(in *et.QueryCompletedOrderList)
 	if !CheckDirection(in.Direction) {
 		return nil, et.ErrDirection
 	}
-	return QueryCompletedOrderList(s.GetLocalDB(), s.GetStateDB(), in.LeftAsset, in.RightAsset, in.Index, in.Count, in.Direction)
+	return QueryCompletedOrderList(s.GetLocalDB(),  in.LeftAsset, in.RightAsset, in.PrimaryKey, in.Count, in.Direction)
 }
 
 //根据orderID查询订单信息
 func (s *exchange) Query_QueryOrder(in *et.QueryOrder) (types.Message, error) {
-	if in.OrderID == "" {
+	if in.OrderID == 0 {
 		return nil, et.ErrOrderID
 	}
-	return findOrderByOrderID(s.GetStateDB(), in.OrderID)
+	return findOrderByOrderID(s.GetStateDB(), s.GetLocalDB(), in.OrderID)
 }
 
 //根据订单状态，查询订单信息（这里面包含所有交易对）
@@ -62,5 +62,5 @@ func (s *exchange) Query_QueryOrderList(in *et.QueryOrderList) (types.Message, e
 	if in.Address == "" {
 		return nil, et.ErrAddr
 	}
-	return QueryOrderList(s.GetLocalDB(), s.GetStateDB(), in.Address, in.Status, in.Count, in.Direction, in.Index)
+	return QueryOrderList(s.GetLocalDB(), s.GetStateDB(), in.Address, in.Status, in.Count, in.Direction, in.PrimaryKey)
 }

plugin/dapp/exchange/executor/tables.go

+package executor
+
+import (
+	"fmt"
+
+	"github.com/33cn/chain33/common/db"
+	"github.com/33cn/chain33/common/db/table"
+	"github.com/33cn/chain33/types"
+	ety "github.com/33cn/plugin/plugin/dapp/exchange/types"
+)
+
+/*
+ * 用户合约存取kv数据时，key值前缀需要满足一定规范
+ * 即key = keyPrefix + userKey
+ * 需要字段前缀查询时，使用’-‘作为分割符号
+ */
+
+const (
+	//KeyPrefixStateDB state db key必须前缀
+	KeyPrefixStateDB = "mavl-exchange-"
+	//KeyPrefixLocalDB local db的key必须前缀
+	KeyPrefixLocalDB = "LODB-exchange"
+)
+
+//状态数据库中存储具体挂单信息
+func calcOrderKey(orderID int64) []byte {
+	key := fmt.Sprintf("%s"+"orderID:%022d", KeyPrefixStateDB, orderID)
+	return []byte(key)
+}
+
+var opt_exchange_depth = &table.Option{
+	Prefix:  KeyPrefixLocalDB,
+	Name:    "depth",
+	Primary: "price",
+	Index:   nil,
+}
+//重新设计表，list查询全部在订单信息localdb查询中
+var opt_exchange_order = &table.Option{
+	Prefix:  KeyPrefixLocalDB,
+	Name:    "order",
+	Primary: "orderID",
+	Index:   []string{"market_order"},
+}
+
+//根据地址和状态,index是实时在变化,要有先后顺序
+var opt_exchange_user_order = &table.Option{
+	Prefix:  KeyPrefixLocalDB,
+	Name:    "UserOrder",
+	Primary: "index",
+	Index:   nil,
+}
+
+var opt_exchange_completed = &table.Option{
+	Prefix:  KeyPrefixLocalDB,
+	Name:    "completed",
+	Primary: "index",
+	Index:   nil,
+}
+
+
+//NewTable 新建表
+func NewMarketDepthTable(kvdb db.KV) *table.Table {
+	rowmeta := NewMarketDepthRow()
+	table, err := table.NewTable(rowmeta, kvdb, opt_exchange_depth)
+	if err != nil {
+		panic(err)
+	}
+	return table
+}
+
+func NewMarketOrderTable(kvdb db.KV) *table.Table {
+	rowmeta := NewOrderRow()
+	table, err := table.NewTable(rowmeta, kvdb, opt_exchange_order)
+	if err != nil {
+		panic(err)
+	}
+	return table
+}
+
+func NewUserOrderTable(kvdb db.KV) *table.Table {
+	rowmeta := NewUserOrderRow()
+	table, err := table.NewTable(rowmeta, kvdb, opt_exchange_user_order)
+	if err != nil {
+		panic(err)
+	}
+	return table
+}
+func NewCompletedOrderTable(kvdb db.KV) *table.Table {
+	rowmeta := NewCompletedOrderRow()
+	table, err := table.NewTable(rowmeta, kvdb, opt_exchange_completed)
+	if err != nil {
+		panic(err)
+	}
+	return table
+}
+
+//OrderRow table meta 结构
+type OrderRow struct {
+	*ety.Order
+}
+
+//NewOrderRow 新建一个meta 结构
+func NewOrderRow() *OrderRow {
+	return &OrderRow{Order: &ety.Order{}}
+}
+
+//CreateRow
+func (r *OrderRow) CreateRow() *table.Row {
+	return &table.Row{Data: &ety.Order{}}
+}
+
+//SetPayload 设置数据
+func (r *OrderRow) SetPayload(data types.Message) error {
+	if txdata, ok := data.(*ety.Order); ok {
+		r.Order = txdata
+		return nil
+	}
+	return types.ErrTypeAsset
+}
+
+//Get 按照indexName 查询 indexValue
+func (r *OrderRow) Get(key string) ([]byte, error) {
+	if key == "orderID" {
+		return []byte(fmt.Sprintf("%022d",r.OrderID)), nil
+	}else if key == "market_order"{
+		return []byte(fmt.Sprintf("%s:%s:%d:%016d", r.GetLimitOrder().LeftAsset.GetSymbol(), r.GetLimitOrder().RightAsset.GetSymbol(), r.GetLimitOrder().Op, int64(Truncate(r.GetLimitOrder().Price*float64(1e8))))), nil
+	}
+	return nil, types.ErrNotFound
+}
+
+//UserOrderRow table meta 结构
+type UserOrderRow struct {
+	*ety.Order
+}
+
+//NewOrderRow 新建一个meta 结构
+func NewUserOrderRow() *UserOrderRow {
+	return &UserOrderRow{Order: &ety.Order{Value: &ety.Order_LimitOrder{LimitOrder: &ety.LimitOrder{}}}}
+}
+
+//CreateRow
+func (r *UserOrderRow) CreateRow() *table.Row {
+	return &table.Row{Data: &ety.Order{}}
+}
+
+//SetPayload 设置数据
+func (r *UserOrderRow) SetPayload(data types.Message) error {
+	if txdata, ok := data.(*ety.Order); ok {
+		r.Order = txdata
+		return nil
+	}
+	return types.ErrTypeAsset
+}
+
+//Get 按照indexName 查询 indexValue
+func (r *UserOrderRow) Get(key string) ([]byte, error) {
+    if key == "index" {
+		return []byte(fmt.Sprintf("%s:%d:%022d", r.Addr, r.Status, r.Index)), nil
+	}
+	return nil, types.ErrNotFound
+}
+
+//CompletedOrderRow table meta 结构
+type CompletedOrderRow struct {
+	*ety.Order
+}
+
+func NewCompletedOrderRow() *CompletedOrderRow {
+	return &CompletedOrderRow{Order: &ety.Order{Value: &ety.Order_LimitOrder{LimitOrder: &ety.LimitOrder{}}}}
+}
+
+
+func (m *CompletedOrderRow) CreateRow() *table.Row {
+	return &table.Row{Data: &ety.Order{Value: &ety.Order_LimitOrder{LimitOrder: &ety.LimitOrder{}}}}
+}
+
+//SetPayload 设置数据
+func (m *CompletedOrderRow) SetPayload(data types.Message) error {
+	if txdata, ok := data.(*ety.Order); ok {
+		m.Order = txdata
+		return nil
+	}
+	return types.ErrTypeAsset
+}
+
+//Get 按照indexName 查询 indexValue
+func (m *CompletedOrderRow) Get(key string) ([]byte, error) {
+	if key == "index" {
+		return []byte(fmt.Sprintf("%s:%s:%022d", m.GetLimitOrder().LeftAsset.GetSymbol(), m.GetLimitOrder().RightAsset.GetSymbol(), m.Index)), nil
+	}
+	return nil, types.ErrNotFound
+}
+
+//marketDepthRow table meta 结构
+type MarketDepthRow struct {
+	*ety.MarketDepth
+}
+
+//NewOracleRow 新建一个meta 结构
+func NewMarketDepthRow() *MarketDepthRow {
+	return &MarketDepthRow{MarketDepth: &ety.MarketDepth{}}
+}
+
+//CreateRow 新建数据行(注意index 数据一定也要保存到数据中,不能就保存eventid)
+func (m *MarketDepthRow) CreateRow() *table.Row {
+	return &table.Row{Data: &ety.MarketDepth{}}
+}
+
+//SetPayload 设置数据
+func (m *MarketDepthRow) SetPayload(data types.Message) error {
+	if txdata, ok := data.(*ety.MarketDepth); ok {
+		m.MarketDepth = txdata
+		return nil
+	}
+	return types.ErrTypeAsset
+}
+
+//Get 按照indexName 查询 indexValue
+func (m *MarketDepthRow) Get(key string) ([]byte, error) {
+	if key == "price" {
+		return []byte(fmt.Sprintf("%s:%s:%d:%016d", m.LeftAsset.GetSymbol(), m.RightAsset.GetSymbol(), m.Op, int64(Truncate(m.Price)*float64(1e8)))), nil
+	}
+	return nil, types.ErrNotFound
+}

plugin/dapp/exchange/proto/exchange.proto

@@ -41,7 +41,7 @@ message MarketOrder {
 //撤回订单
 message RevokeOrder {
     //订单号
-    string orderID   = 1;
+    int64 orderID   = 1;
 }
 //资产类型
 message asset {
@@ -51,7 +51,7 @@ message asset {
 
 //订单信息
 message Order {
-    string orderID   = 1;
+    int64 orderID   = 1;
     oneof value {
         LimitOrder limitOrder = 2;
         MarketOrder marketOrder = 3;
@@ -72,16 +72,6 @@ message Order {
     int64 index = 10;
 }
 
-//挂单价
-message OrderPrice {
-    double price  = 1;
-    int64  index = 2;
-}
-//单号
-message OrderID {
-    string ID   = 1;
-    int64  index = 2;
-}
 //查询接口
 message QueryMarketDepth {
     //资产1
@@ -91,7 +81,7 @@ message QueryMarketDepth {
     //操作， 1为买，2为卖
     int32 op = 3;
     // 这里用价格作为索引值
-    double price  = 4;
+    string primaryKey  = 4;
     //单页返回多少条记录，默认返回10条,为了系统安全最多单次只能返回20条
     int32 count = 5;
 }
@@ -111,6 +101,7 @@ message MarketDepth {
 //查询接口返回的市场深度列表
 message MarketDepthList {
     repeated MarketDepth list = 1;
+    string primaryKey = 2;
 }
 
 //查询最新得成交信息,外部接口
@@ -120,7 +111,7 @@ message QueryCompletedOrderList {
     //资产2
     asset rightAsset = 2;
     // 索引值
-    int64 index = 3;
+    string primaryKey = 3;
     //单页返回多少条记录，默认返回10条,为了系统安全最多单次只能返回20条
     int32 count = 4;
     // 0降序，1升序，默认降序
@@ -129,7 +120,7 @@ message QueryCompletedOrderList {
 
 //根据orderID去查询订单信息
 message QueryOrder {
-    string orderID   = 1;
+    int64 orderID   = 1;
 }
 //根据地址，状态查询用户自己的挂单信息
 message QueryOrderList {
@@ -137,8 +128,8 @@ message QueryOrderList {
     int32 status = 1;
     //用户地址信息，必填
     string address = 2;
-    // 索引值
-    int64 index = 3;
+    // 主键索引
+    string primaryKey = 3;
     //单页返回多少条记录，默认返回10条,为了系统安全最多单次只能返回20条
     int32 count = 4;
     // 0降序，1升序，默认降序
@@ -147,6 +138,7 @@ message QueryOrderList {
 //订单列表
 message OrderList {
     repeated Order list = 1;
+    string primaryKey = 2;
 }
 
 

plugin/dapp/exchange/types/exchange.go

@@ -2,6 +2,7 @@ package types
 
 import (
 	"github.com/33cn/chain33/types"
+	"reflect"
 )
 
 /*
@@ -73,7 +74,9 @@ var (
 	}
 	//定义log的id和具体log类型及名称，填入具体自定义log类型
 	logMap = map[int64]*types.LogInfo{
-		//LogID:	{Ty: reflect.TypeOf(LogStruct), Name: LogName},
+		TyLimitOrderLog:	{Ty: reflect.TypeOf(ReceiptExchange{}), Name: "TyLimitOrderLog"},
+		TyMarketOrderLog:	{Ty: reflect.TypeOf(ReceiptExchange{}), Name: "TyMarketOrderLog"},
+		TyRevokeOrderLog:	{Ty: reflect.TypeOf(ReceiptExchange{}), Name: "TyRevokeOrderLog"},
 	}
 	//tlog = log.New("module", "exchange.types")
 )