Count exec & Select limit/offset

.gitea/workflows/test.yml

@@ -10,24 +10,36 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - name: Checkout code
+      - name: Checkout repository
-        uses: actions/checkout@v4
+        run: |
+          git clone \
+            "${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}.git" \
+            .
 
-      - name: Setup Go
+          git checkout "${GITHUB_SHA}"
-        uses: actions/setup-go@v5
-        with:
-          go-version: "1.22"
 
-      - name: Cache Go modules
+      - name: Verify checkout
-        uses: actions/cache@v4
+        run: |
-        with:
+          pwd
-          path: |
+          ls -la
-            ~/.cache/go-build
+          test -f go.mod
-            ~/go/pkg/mod
+
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+      - name: Install Go
+        run: |
+          rm -rf /usr/local/go
+          curl -LO https://go.dev/dl/go1.26.2.linux-amd64.tar.gz
+          tar -C /usr/local -xzf go1.26.2.linux-amd64.tar.gz
+          export PATH=/usr/local/go/bin:$PATH
+          go version
 
       - name: Download dependencies
-        run: go mod download
+        run: |
+          go mod download
 
       - name: Run tests
-        run: go test ./... -v
+        run: |
+          go test ./... -v
+    
+      - name: Build binary
+        run: |
+          go build -o app .

exec/exec.go

@@ -162,6 +162,8 @@ type Select[T any] struct {
 	whereStmt string
 	args      []any
 	results   []T
+	Limit     int64
+	Offset    int64
 }
 
 func CreateSelect[T any](orm *simpleorm.ORM, whereStmt string, args ...any) (Select[T], error) {
@@ -170,7 +172,7 @@ func CreateSelect[T any](orm *simpleorm.ORM, whereStmt string, args ...any) (Sel
 		return Select[T]{}, errors.New("Failed to get table from schema cache")
 	}
 
-	return Select[T]{target: *table, whereStmt: whereStmt, args: args}, nil
+	return Select[T]{target: *table, whereStmt: whereStmt, args: args, Limit: -1, Offset: -1}, nil
 }
 
 func (s *Select[T]) Results() []T {
@@ -193,7 +195,18 @@ func (s *Select[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
 		dml += " WHERE " + s.whereStmt
 	}
 
-	log.LogDebug("Preparing sql: %s, with args: %s", dml, s.args)
+	var effectiveArgs []any = s.args
+	if s.Limit != -1 {
+		dml += " LIMIT ?"
+		effectiveArgs = append(effectiveArgs, s.Limit)
+	}
+
+	if s.Offset != -1 {
+		dml += " OFFSET ?"
+		effectiveArgs = append(effectiveArgs, s.Offset)
+	}
+
+	log.LogDebug("Preparing sql: %s, with args: %s", dml, effectiveArgs)
 
 	var stmt *sql.Stmt
 	if tx != nil {
@@ -210,12 +223,12 @@ func (s *Select[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
 	log.LogDebug("Executing statement: %s", stmt)
 
 	var rows *sql.Rows
-	if len(s.args) == 0 {
+	if len(effectiveArgs) == 0 {
 		rows, err = stmt.Query()
 	} else {
 		// Flattent args to make sure it can be parsed correctly
 		var flatArgs []any
-		for _, a := range s.args {
+		for _, a := range effectiveArgs {
 			if s, ok := a.([]any); ok {
 				flatArgs = append(flatArgs, s...)
 			} else {
@@ -238,6 +251,79 @@ func (s *Select[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
 	return nil
 }
 
+type Count[T any] struct {
+	target    schema.Table
+	whereStmt string
+	args      []any
+	result    int64
+}
+
+func CreateCount[T any](orm *simpleorm.ORM, whereStmt string, args ...any) (Count[T], error) {
+	table, ok := orm.Cache().Get(reflect.TypeFor[T]().Name())
+	if !ok {
+		return Count[T]{}, errors.New("Failed to get table from schema cache")
+	}
+
+	return Count[T]{target: *table, whereStmt: whereStmt, args: args}, nil
+}
+
+func (c *Count[T]) Result() int64 {
+	return c.result
+}
+
+func (c *Count[T]) Execute(conn *simpleorm.DBConnection) error {
+	return c.execute(conn, nil)
+}
+
+func (c *Count[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
+	// Reinit the results, new execution
+	c.result = -1
+	dml := c.target.GetCountDML()
+
+	if c.whereStmt != "" {
+		dml += " WHERE " + c.whereStmt
+	}
+
+	log.LogDebug("Preparing sql: %s, with args: %s", dml, c.args)
+
+	var stmt *sql.Stmt
+	var err error
+	if tx != nil {
+		stmt, err = tx.Prepare(dml)
+	} else {
+		stmt, err = conn.Prepare(dml)
+	}
+
+	if err != nil {
+		return err
+	}
+	defer stmt.Close()
+
+	log.LogDebug("Executing statement: %s", stmt)
+
+	if len(c.args) == 0 {
+		err = stmt.QueryRow().Scan(&c.result)
+	} else {
+		// Flattent args to make sure it can be parsed correctly
+		var flatArgs []any
+		for _, a := range c.args {
+			if s, ok := a.([]any); ok {
+				flatArgs = append(flatArgs, s...)
+			} else {
+				flatArgs = append(flatArgs, a)
+			}
+		}
+
+		err = stmt.QueryRow(flatArgs...).Scan(&c.result)
+
+	}
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 type Insert[T any] struct {
 	target   schema.Table
 	toInsert []T
@@ -278,7 +364,7 @@ func (ins *Insert[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
 		}
 	}
 
-	log.LogInfo("%s [%s]", dml, params)
+	log.LogDebug("%s [%s]", dml, params)
 
 	var stmt *sql.Stmt
 	if tx != nil {
@@ -347,7 +433,7 @@ func (u Update[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
 		params = append(params, pk)
 	}
 
-	log.LogInfo("%s [%s]", dml, params)
+	log.LogDebug("%s [%s]", dml, params)
 
 	var stmt *sql.Stmt
 	if tx != nil {
@@ -405,7 +491,7 @@ func (d *Delete[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
 		}
 	}
 
-	log.LogInfo("%s [%s]", dml, params)
+	log.LogDebug("%s [%s]", dml, params)
 
 	var stmt *sql.Stmt
 	if tx != nil {

schema/table.go

@@ -58,6 +58,10 @@ func (t Table) GetSelectDML() (string, error) {
 	return dml.String(), nil
 }
 
+func (t Table) GetCountDML() string {
+	return "SELECT COUNT(*) FROM " + t.Name
+}
+
 func (t Table) GetInsertDML(count int) (string, error) {
 	var dml strings.Builder
 	dml.WriteString("INSERT INTO " + util.CamelToSnake(t.Type.Name()) + " (")

test/exec_test.go

@@ -1,6 +1,7 @@
 package simpleorm_test
 
 import (
+	"strconv"
 	"testing"
 	"time"
 
@@ -681,3 +682,147 @@ func TestTransactionRollback(t *testing.T) {
 		return
 	}
 }
+
+func TestSelectWithLimitAndOffset(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	testEntites := []Test{}
+
+	for i := 0; i < 1000; i++ {
+		testEntites = append(testEntites, Test{Int64Field: -1, IntField: i, StringField: "Entity " + strconv.Itoa(i)})
+	}
+
+	insertExec, err := exec.NewInsert[Test](orm, testEntites...)
+	if err != nil {
+		log.LogError("TestSelectWithLimitAndOffset setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	err = insertExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestSelectWithLimitAndOffset setup failed: %s", err)
+		t.Fail()
+		return
+	}
+	// WHEN
+
+	selectExec, err := exec.CreateSelect[Test](orm, "")
+	if err != nil {
+		log.LogError("TestSelectWithLimitAndOffset failed: %s", err)
+		t.Fail()
+		return
+	}
+	selectExec.Limit = 100
+	selectExec.Offset = 0
+
+	err = selectExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestSelectWithLimitAndOffset failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	// THEN
+
+	if len(selectExec.Results()) != 100 {
+		log.LogError("TestSelectWithLimitAndOffset expected result size 100, actual: %s", len(selectExec.Results()))
+		t.Fail()
+	}
+}
+
+func TestCount(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	testEntites := []Test{}
+
+	for i := 0; i < 1000; i++ {
+		testEntites = append(testEntites, Test{Int64Field: -1, IntField: i, StringField: "Entity " + strconv.Itoa(i)})
+	}
+
+	insertExec, err := exec.NewInsert[Test](orm, testEntites...)
+	if err != nil {
+		log.LogError("TestSelectWithLimitAndOffset setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	err = insertExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestSelectWithLimitAndOffset setup failed: %s", err)
+		t.Fail()
+		return
+	}
+	// WHEN
+
+	countExec, err := exec.CreateCount[Test](orm, "")
+	if err != nil {
+		log.LogError("TestSelectWithLimitAndOffset failed: %s", err)
+		t.Fail()
+		return
+	}
+	err = countExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestSelectWithLimitAndOffset failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	// THEN
+
+	if countExec.Result() != 1000 {
+		log.LogError("TestSelectWithLimitAndOffset expected result size 1000, actual: %s", countExec.Result())
+		t.Fail()
+	}
+}
+
+func TestCountWithCondition(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	testEntites := []Test{}
+
+	for i := 0; i < 1000; i++ {
+		testEntites = append(testEntites, Test{Int64Field: -1, IntField: i, StringField: "Entity " + strconv.Itoa(i)})
+	}
+
+	insertExec, err := exec.NewInsert[Test](orm, testEntites...)
+	if err != nil {
+		log.LogError("TestSelectWithLimitAndOffset setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	err = insertExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestSelectWithLimitAndOffset setup failed: %s", err)
+		t.Fail()
+		return
+	}
+	// WHEN
+
+	countExec, err := exec.CreateCount[Test](orm, "id % 2 = 0")
+	if err != nil {
+		log.LogError("TestSelectWithLimitAndOffset failed: %s", err)
+		t.Fail()
+		return
+	}
+	err = countExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestSelectWithLimitAndOffset failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	// THEN
+
+	if countExec.Result() != 500 {
+		log.LogError("TestSelectWithLimitAndOffset expected result size 500, actual: %s", countExec.Result())
+		t.Fail()
+	}
+}