Pagination keyset2

platform/common/driver/pagination.go

@@ -6,9 +6,7 @@ SPDX-License-Identifier: Apache-2.0
 
 package driver
 
-import (
-	"github.com/hyperledger-labs/fabric-smart-client/platform/common/utils/collections/iterators"
-)
+import "github.com/hyperledger-labs/fabric-smart-client/platform/common/utils/collections/iterators"
 
 type Pagination interface {
 	Prev() (Pagination, error)

platform/view/services/db/driver/sql/common/vault.go

@@ -475,7 +475,7 @@ func (db *vaultReader) GetAllTxStatuses(ctx context.Context, p driver.Pagination
 	if err != nil {
 		return nil, err
 	}
-	return &driver.PageIterator[*driver.TxStatus]{Items: txStatusIterator, Pagination: p}, nil
+	return pagination.NewPage(txStatusIterator, p)
 }
 
 func (db *vaultReader) queryStatus(ctx context.Context, where cond.Condition, pagination driver.Pagination) (driver.TxStatusIterator, error) {

platform/view/services/db/driver/sql/query/common/field.go

@@ -8,6 +8,9 @@ package common
 
 type Field Serializable
 
+// FieldName is the name of the DB column
+type FieldName string
+
 func (n FieldName) WriteString(b Builder) {
 	b.WriteString(string(n))
 }

platform/view/services/db/driver/sql/query/common/types.go

@@ -12,8 +12,8 @@ import (
 	"github.com/hyperledger-labs/fabric-smart-client/platform/common/driver"
 )
 
-// FieldName is the name of the DB column
-type FieldName string
+type OrderBy Serializable
+type Condition ConditionSerializable
 
 // Tuple is a tuple of parameters
 type Tuple = []Param
@@ -30,10 +30,18 @@ type CondInterpreter interface {
 	InTuple(fields []Serializable, vals []Tuple, sb Builder)
 }
 
+type ModifiableQuery interface {
+	AddField(Field)
+	AddWhere(Condition)
+	AddOrderBy(OrderBy)
+	AddLimit(int)
+	AddOffset(int)
+}
+
 // PagInterpreter is the pagination interpreter
 type PagInterpreter interface {
-	// Interpret modifies the SQL query to add pagination support
-	Interpret(p driver.Pagination, sb Builder)
+	// PreProcess modifies the SQL query to add pagination support
+	PreProcess(driver.Pagination, ModifiableQuery)
 }
 
 // Builder is the string builder

platform/view/services/db/driver/sql/query/cond/andor.go

@@ -55,7 +55,7 @@ func Or(cs ...Condition) Condition {
 func newAndOr(conditions []Condition, trivialCondition Condition, operator string) Condition {
 	nonTrivial := make([]Condition, 0, len(conditions))
 	for _, c := range conditions {
-		if c != trivialCondition {
+		if c != nil && c != trivialCondition {
 			nonTrivial = append(nonTrivial, c)
 		}
 	}

platform/view/services/db/driver/sql/query/cond/condition.go

@@ -12,4 +12,4 @@ import (
 
 type Tuple = common.Tuple
 
-type Condition = common.ConditionSerializable
+type Condition = common.Condition

platform/view/services/db/driver/sql/query/pagination/interpreter.go

@@ -11,29 +11,51 @@ import (
 
 	"github.com/hyperledger-labs/fabric-smart-client/platform/common/driver"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/db/driver/sql/query/common"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/db/driver/sql/query/cond"
+	_select "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/db/driver/sql/query/select"
 )
 
 func NewDefaultInterpreter() *interpreter {
 	return &interpreter{}
 }
 
-type Interpreter = common.PagInterpreter
-
 type interpreter struct{}
 
-func (i *interpreter) Interpret(p driver.Pagination, sb common.Builder) {
+func (i *interpreter) PreProcess(p driver.Pagination, query common.ModifiableQuery) {
 	switch pagination := p.(type) {
 	case *none:
 		return
+
 	case *offset:
-		sb.WriteString(" LIMIT ").
-			WriteParam(pagination.pageSize).
-			WriteString(" OFFSET ").
-			WriteParam(pagination.offset)
+		query.AddLimit(pagination.pageSize)
+		query.AddOffset(pagination.offset)
+
+	case *keyset[string, any]:
+		query.AddField(pagination.sqlIdName)
+		query.AddOrderBy(_select.Asc(pagination.sqlIdName))
+		query.AddLimit(pagination.pageSize)
+		if pagination.firstId != pagination.nilElement() {
+			query.AddWhere(cond.CmpVal(pagination.sqlIdName, ">", pagination.firstId))
+		} else {
+			query.AddOffset(pagination.offset)
+		}
+
+	case *keyset[int, any]:
+		query.AddField(pagination.sqlIdName)
+		query.AddOrderBy(_select.Asc(pagination.sqlIdName))
+		query.AddLimit(pagination.pageSize)
+		if pagination.firstId != pagination.nilElement() {
+			query.AddWhere(cond.CmpVal(pagination.sqlIdName, ">", pagination.firstId))
+		} else {
+			query.AddOffset(pagination.offset)
+		}
+
 	case *empty:
-		sb.WriteString(" LIMIT 0 OFFSET 0")
-		return
+		query.AddLimit(0)
+		query.AddOffset(0)
+
 	default:
+		fmt.Printf("Type = %T\n", pagination)
 		panic(fmt.Sprintf("invalid pagination option %+v", pagination))
 	}
 }

platform/view/services/db/driver/sql/query/pagination/keyset.go

@@ -0,0 +1,125 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package pagination
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"github.com/hyperledger-labs/fabric-smart-client/platform/common/driver"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/db/driver/sql/query/common"
+)
+
+// PropertyName is the name of the field in the struct that is returned from the database
+// V is the type of the field
+type PropertyName[V comparable] string
+
+// ExtractField extracts the field from the given value
+func (p PropertyName[V]) ExtractField(v any) V {
+	return reflect.ValueOf(v).FieldByName(string(p)).Interface().(V)
+}
+
+type keyset[I comparable, V any] struct {
+	offset    int
+	pageSize  int
+	sqlIdName common.FieldName
+	idGetter  func(V) I
+	// the first and last id values in the page
+	firstId, lastId I
+}
+
+// KeysetWithField creates a keyset pagination where the id has field name idFieldName
+func KeysetWithField[I comparable](offset int, pageSize int, sqlIdName common.FieldName, idFieldName PropertyName[I]) (*keyset[I, any], error) {
+	if strings.ToUpper(string(idFieldName[0])) != string(idFieldName[0]) {
+		return nil, fmt.Errorf("must use exported field")
+	}
+	return Keyset(offset, pageSize, sqlIdName, idFieldName.ExtractField)
+}
+
+type id[I comparable] interface {
+	Id() I
+}
+
+// KeysetWithId creates a keyset pagination where the result object implements id[I]
+func KeysetWithId[I comparable, V id[I]](offset int, pageSize int, sqlIdName common.FieldName) (*keyset[I, V], error) {
+	return Keyset[I, V](offset, pageSize, sqlIdName, func(v V) I { return v.Id() })
+}
+
+// Keyset creates a keyset pagination
+func Keyset[I comparable, V any](offset int, pageSize int, sqlIdName common.FieldName, idGetter func(V) I) (*keyset[I, V], error) {
+	if offset < 0 {
+		return nil, fmt.Errorf("offset must be greater than zero. Offset: %d", offset)
+	}
+	if pageSize < 0 {
+		return nil, fmt.Errorf("page size must be greater than zero. pageSize: %d", pageSize)
+	}
+	return &keyset[I, V]{
+		offset:    offset,
+		pageSize:  pageSize,
+		sqlIdName: sqlIdName,
+		idGetter:  idGetter,
+		firstId:   nilElement[I](),
+		lastId:    nilElement[I](),
+	}, nil
+}
+
+func nilElement[I any]() I {
+	var zero I
+	switch any(zero).(type) {
+	case int:
+		return any(-1).(I)
+	case string:
+		return any("").(I)
+	default:
+		panic("unsupported type")
+	}
+}
+
+func (p *keyset[I, V]) nilElement() I {
+	return nilElement[I]()
+}
+
+func (p *keyset[I, V]) GoToOffset(offset int) (driver.Pagination, error) {
+	if offset < 0 {
+		return nil, fmt.Errorf("Offset must be greater than zero. pageSize: %d", pageSize)
+	}
+	if offset == p.offset+p.pageSize {
+		return &keyset[I, V]{
+			offset:    offset,
+			pageSize:  p.pageSize,
+			sqlIdName: p.sqlIdName,
+			idGetter:  p.idGetter,
+			firstId:   p.lastId,
+			lastId:    p.nilElement(),
+		}, nil
+	}
+	return &keyset[I, V]{
+		offset:    offset,
+		pageSize:  p.pageSize,
+		sqlIdName: p.sqlIdName,
+		idGetter:  p.idGetter,
+		firstId:   p.nilElement(),
+		lastId:    p.nilElement(),
+	}, nil
+}
+
+func (p *keyset[I, V]) GoToPage(pageNum int) (driver.Pagination, error) {
+	return p.GoToOffset(pageNum * p.pageSize)
+}
+
+func (p *keyset[I, V]) GoForward(numOfpages int) (driver.Pagination, error) {
+	return p.GoToOffset(p.offset + (numOfpages * p.pageSize))
+}
+
+func (p *keyset[I, V]) GoBack(numOfpages int) (driver.Pagination, error) {
+	return p.GoForward(-1 * numOfpages)
+}
+
+func (p *keyset[I, V]) Prev() (driver.Pagination, error) { return p.GoBack(1) }
+
+func (p *keyset[I, V]) Next() (driver.Pagination, error) { return p.GoForward(1) }