Refactor for update kvql

kvcmds/cmd_explain.go

@@ -3,8 +3,8 @@ package kvcmds
 import (
 	"context"
 
-	"github.com/c4pt0r/tcli"
 	"github.com/c4pt0r/kvql"
+	"github.com/c4pt0r/tcli"
 	"github.com/c4pt0r/tcli/client"
 	"github.com/c4pt0r/tcli/query"
 	"github.com/c4pt0r/tcli/utils"
@@ -41,7 +41,7 @@ func (c ExplainCmd) Handler() func(ctx context.Context) {
 				return nil
 			}
 			sql := getQueryString(ic)
-			qtxn := query.NewQueryTxn(client.GetTiKVClient())
+			qtxn := query.NewQueryStorage(client.GetTiKVClient())
 			opt := kvql.NewOptimizer(sql)
 			plan, err := opt.BuildPlan(qtxn)
 			if err != nil {

kvcmds/cmd_query.go

@@ -7,9 +7,9 @@ import (
 	"strings"
 
 	"github.com/abiosoft/ishell"
+	"github.com/c4pt0r/kvql"
 	"github.com/c4pt0r/tcli"
 	"github.com/c4pt0r/tcli/client"
-	"github.com/c4pt0r/kvql"
 	"github.com/c4pt0r/tcli/query"
 	"github.com/c4pt0r/tcli/utils"
 )
@@ -79,7 +79,7 @@ func (c QueryCmd) Handler() func(ctx context.Context) {
 				return nil
 			}
 			sql := getQueryString(ic)
-			qtxn := query.NewQueryTxn(client.GetTiKVClient())
+			qtxn := query.NewQueryStorage(client.GetTiKVClient())
 			opt := kvql.NewOptimizer(sql)
 			plan, err := opt.BuildPlan(qtxn)
 			if err != nil {

query/query_txn.go

@@ -12,22 +12,22 @@ import (
 )
 
 var (
-	_ kvql.Txn    = (*queryTxn)(nil)
-	_ kvql.Cursor = (*queryCursor)(nil)
+	_ kvql.Storage = (*queryStorage)(nil)
+	_ kvql.Cursor  = (*queryCursor)(nil)
 )
 
-type queryTxn struct {
+type queryStorage struct {
 	client client.Client
 }
 
-func NewQueryTxn(client client.Client) kvql.Txn {
-	return &queryTxn{
+func NewQueryStorage(client client.Client) kvql.Storage {
+	return &queryStorage{
 		client: client,
 	}
 }
 
-func (t *queryTxn) Get(key []byte) ([]byte, error) {
-	kv, err := t.client.Get(context.TODO(), client.Key(key))
+func (s *queryStorage) Get(key []byte) ([]byte, error) {
+	kv, err := s.client.Get(context.TODO(), client.Key(key))
 	if err != nil {
 		if err.Error() == "not exist" {
 			return nil, nil
@@ -37,41 +37,41 @@ func (t *queryTxn) Get(key []byte) ([]byte, error) {
 	return kv.V, nil
 }
 
-func (t *queryTxn) Put(key []byte, value []byte) error {
-	return t.client.Put(context.TODO(), client.KV{K: key, V: value})
+func (s *queryStorage) Put(key []byte, value []byte) error {
+	return s.client.Put(context.TODO(), client.KV{K: key, V: value})
 }
 
-func (t *queryTxn) BatchPut(kvs []kvql.KVPair) error {
+func (s *queryStorage) BatchPut(kvs []kvql.KVPair) error {
 	tkvs := make([]client.KV, len(kvs))
 	for i, kv := range kvs {
 		tkvs[i] = client.KV{K: kv.Key, V: kv.Value}
 	}
-	return t.client.BatchPut(context.TODO(), tkvs)
+	return s.client.BatchPut(context.TODO(), tkvs)
 }
 
-func (t *queryTxn) Delete(key []byte) error {
-	return t.client.Delete(context.TODO(), key)
+func (s *queryStorage) Delete(key []byte) error {
+	return s.client.Delete(context.TODO(), key)
 }
 
-func (t *queryTxn) BatchDelete(keys [][]byte) error {
+func (s *queryStorage) BatchDelete(keys [][]byte) error {
 	tkvs := make([]client.KV, len(keys))
 	for i, key := range keys {
 		tkvs[i] = client.KV{K: key}
 	}
-	return t.client.BatchDelete(context.TODO(), tkvs)
+	return s.client.BatchDelete(context.TODO(), tkvs)
 }
 
-func (t *queryTxn) Cursor() (kvql.Cursor, error) {
+func (s *queryStorage) Cursor() (kvql.Cursor, error) {
 	return &queryCursor{
-		txn:     t,
+		storage: s,
 		batch:   nil,
 		prefix:  []byte{},
 		iterPos: 0,
 	}, nil
 }
 
 type queryCursor struct {
-	txn         *queryTxn
+	storage     *queryStorage
 	batch       client.KVS
 	batchSize   int
 	prefix      []byte
@@ -86,7 +86,7 @@ func (c *queryCursor) loadBatch() error {
 	scanOpt.Set(tcli.ScanOptCountOnly, "false")
 	scanOpt.Set(tcli.ScanOptStrictPrefix, "false")
 	qctx := utils.ContextWithProp(context.TODO(), scanOpt)
-	kvs, n, err := c.txn.client.Scan(qctx, c.prefix)
+	kvs, n, err := c.storage.client.Scan(qctx, c.prefix)
 	if err != nil {
 		return err
 	}