WIP: Refactor Exec implementations to be chainable

.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

@@ -157,45 +157,48 @@ type Exec[T any] interface {
 	execute(conn *simpleorm.DBConnection, tx *sql.Tx) error
 }
 
-type Select[T any] struct {
+type OrderBy struct {
+	Column    string
+	Direction string
+}
+
+type Count[T any] struct {
 	target    schema.Table
 	whereStmt string
 	args      []any
-	results   []T
+	result    int64
 }
 
-func CreateSelect[T any](orm *simpleorm.ORM, whereStmt string, args ...any) (Select[T], error) {
+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 Select[T]{}, errors.New("Failed to get table from schema cache")
+		return Count[T]{}, errors.New("Failed to get table from schema cache")
 	}
 
-	return Select[T]{target: *table, whereStmt: whereStmt, args: args}, nil
+	return Count[T]{target: *table, whereStmt: whereStmt, args: args}, nil
 }
 
-func (s *Select[T]) Results() []T {
+func (c *Count[T]) Result() int64 {
-	return s.results
+	return c.result
 }
 
-func (s *Select[T]) Execute(conn *simpleorm.DBConnection) error {
+func (c *Count[T]) Execute(conn *simpleorm.DBConnection) error {
-	return s.execute(conn, nil)
+	return c.execute(conn, nil)
 }
 
-func (s *Select[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
+func (c *Count[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
 	// Reinit the results, new execution
-	s.results = []T{}
+	c.result = -1
-	dml, err := s.target.GetSelectDML()
+	dml := c.target.GetCountDML()
-	if err != nil {
+
-		return err
+	if c.whereStmt != "" {
+		dml += " WHERE " + c.whereStmt
 	}
 
-	if s.whereStmt != "" {
+	log.LogDebug("Preparing sql: %s, with args: %s", dml, c.args)
-		dml += " WHERE " + s.whereStmt
-	}
-
-	log.LogDebug("Preparing sql: %s, with args: %s", dml, s.args)
 
 	var stmt *sql.Stmt
+	var err error
 	if tx != nil {
 		stmt, err = tx.Prepare(dml)
 	} else {
@@ -209,28 +212,22 @@ func (s *Select[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
 
 	log.LogDebug("Executing statement: %s", stmt)
 
-	var rows *sql.Rows
+	if len(c.args) == 0 {
-	if len(s.args) == 0 {
+		err = stmt.QueryRow().Scan(&c.result)
-		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 c.args {
 			if s, ok := a.([]any); ok {
 				flatArgs = append(flatArgs, s...)
 			} else {
 				flatArgs = append(flatArgs, a)
 			}
 		}
-		rows, err = stmt.Query(flatArgs...)
+
+		err = stmt.QueryRow(flatArgs...).Scan(&c.result)
 
 	}
-
-	if err != nil {
-		return err
-	}
-
-	s.results, err = readRows[T](s.target, rows)
 	if err != nil {
 		return err
 	}
@@ -278,7 +275,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 +344,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 +402,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 {

exec/select.go

@@ -0,0 +1,138 @@
+package exec
+
+import (
+	"database/sql"
+	"errors"
+	"reflect"
+
+	"git.gdulai.com/gdulai/simpleorm"
+	"git.gdulai.com/gdulai/simpleorm/schema"
+	log "gitlab.com/gdulai/simpleloglvl"
+)
+
+// Select execution which is translated to a select sql query.
+type Select[T any] struct {
+	target    schema.Table
+	whereStmt string
+	args      []any
+	limit     int64
+	offset    int64
+	ordering  []OrderBy
+	results   []T
+}
+
+// Creates the select query builder
+func CreateSelect[T any](orm *simpleorm.ORM) (Select[T], error) {
+	table, ok := orm.Cache().Get(reflect.TypeFor[T]().Name())
+	if !ok {
+		return Select[T]{}, errors.New("Failed to get table from schema cache")
+	}
+
+	return Select[T]{target: *table, limit: -1, offset: -1}, nil
+}
+
+// Sets the where part of the select query and the arguments
+// Returns the pointer of the Select instance
+func (s *Select[T]) Where(whereStmt string, args ...any) *Select[T] {
+	s.whereStmt = whereStmt
+	s.args = args
+	return s
+}
+
+// Sets the limit part of the select query
+// Returns the pointer of the Select instance
+func (s *Select[T]) Limit(limit int64) *Select[T] {
+	s.limit = limit
+	return s
+}
+
+// Sets the offset part of the select query
+// Returns the pointer of the Select instance
+func (s *Select[T]) Offset(offset int64) *Select[T] {
+	s.offset = offset
+	return s
+}
+
+// Sets the order by part of the select query
+// Returns the pointer of the Select instance
+func (s *Select[T]) OrderBy(ordering ...OrderBy) *Select[T] {
+	s.ordering = ordering
+	return s
+}
+
+// Returns the result of the select
+func (s *Select[T]) Results() []T {
+	return s.results
+}
+
+func (s *Select[T]) Execute(conn *simpleorm.DBConnection) error {
+	return s.execute(conn, nil)
+}
+
+func (s *Select[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
+	// Reinit the results, new execution
+	s.results = []T{}
+	dml, err := s.target.GetSelectDML()
+	if err != nil {
+		return err
+	}
+
+	if s.whereStmt != "" {
+		dml += " WHERE " + s.whereStmt
+	}
+
+	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 {
+		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)
+
+	var rows *sql.Rows
+	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 effectiveArgs {
+			if s, ok := a.([]any); ok {
+				flatArgs = append(flatArgs, s...)
+			} else {
+				flatArgs = append(flatArgs, a)
+			}
+		}
+		rows, err = stmt.Query(flatArgs...)
+
+	}
+
+	if err != nil {
+		return err
+	}
+
+	s.results, err = readRows[T](s.target, rows)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

repository/repository.go

@@ -23,7 +23,7 @@ func NewRepository[T HasPK](conn *simpleorm.DBConnection, orm *simpleorm.ORM) *R
 }
 
 func (r *Repository[T]) SelectAll() []*T {
-	selectExec, err := exec.CreateSelect[T](r.orm, "")
+	selectExec, err := exec.CreateSelect[T](r.orm)
 	if err != nil {
 		log.LogError("Failed to create select execution: %s", err)
 		return []*T{}
@@ -68,12 +68,14 @@ func (r *Repository[T]) SelectByPk(pks ...any) *T {
 
 	}
 
-	selectExec, err := exec.CreateSelect[T](r.orm, whereStmtBuilder.String(), pks)
+	selectExec, err := exec.CreateSelect[T](r.orm)
 	if err != nil {
 		log.LogError("Failed to create select execution: %s", err)
 		return nil
 	}
 
+	selectExec.Where(whereStmtBuilder.String(), pks)
+
 	err = selectExec.Execute(r.conn)
 	if err != nil {
 		log.LogError("Failed to load entity: %s", err)

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"
 
@@ -8,36 +9,6 @@ import (
 	log "gitlab.com/gdulai/simpleloglvl"
 )
 
-func TestSelectEmpty(t *testing.T) {
-	// GIVEN
-	orm, conn := testSetup()
-	defer cleanUp("test.db", conn)
-
-	// WHEN
-	selectExec, err := exec.CreateSelect[Test](orm, "")
-
-	// THEN
-	if err != nil {
-		log.LogError("Failed to create select. %s", err)
-		t.Fail()
-		return
-	}
-
-	err = selectExec.Execute(conn)
-	if err != nil {
-		log.LogError("Select failure. %s", err)
-		t.Fail()
-		return
-	}
-
-	res := selectExec.Results()
-	if len(res) > 0 {
-		log.LogError("Expected empty result.")
-		t.Fail()
-		return
-	}
-}
-
 func TestInsert(t *testing.T) {
 	// GIVEN
 	orm, conn := testSetup()
@@ -132,193 +103,6 @@ func TestInsertMultiple(t *testing.T) {
 
 }
 
-func TestInsertAndSelectSingle(t *testing.T) {
-	// GIVEN
-	orm, conn := testSetup()
-	defer cleanUp("test.db", conn)
-
-	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
-
-	// WHEN
-	insertExec, err := exec.NewInsert(orm, testObj)
-	if err != nil {
-		log.LogError("TestInsertAndSelectSingle setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	selectExec, err := exec.CreateSelect[Test](orm, "")
-	if err != nil {
-		log.LogError("TestInsertAndSelectSingle setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	insertErr := insertExec.Execute(conn)
-	selectErr := selectExec.Execute(conn)
-
-	// THEN
-	if insertErr != nil {
-		log.LogError("TestInsertAndSelectSingle insert failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	if selectErr != nil {
-		log.LogError("TestInsertAndSelectSingle failure. %s", err)
-		t.Fail()
-		return
-	}
-
-	insertRes := insertExec.Results()
-	if len(insertRes) != 1 {
-		log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(insertRes))
-		t.Fail()
-		return
-	}
-
-	selectRes := selectExec.Results()
-	if len(selectRes) != 1 {
-		log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(selectRes))
-		t.Fail()
-		return
-	}
-
-	singleRes := insertRes[0]
-	if singleRes.ID != 1 || singleRes.Int64Field != 54 || singleRes.IntField != 12 || singleRes.StringField != "asdf" {
-		log.LogError("TestInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
-		t.Fail()
-	}
-
-	singleRes = selectRes[0]
-	if singleRes.ID != 1 || singleRes.Int64Field != 54 || singleRes.IntField != 12 || singleRes.StringField != "asdf" {
-		log.LogError("TestInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
-		t.Fail()
-	}
-
-}
-
-func TestInsertSelectWithCompositePk(t *testing.T) {
-	// GIVEN
-	orm, conn := testSetup()
-	defer cleanUp("test.db", conn)
-
-	testObj := TestWithCompositePk{ID: 12, Name: "Test"}
-
-	// WHEN
-	insertExec, err := exec.NewInsert(orm, testObj)
-	if err != nil {
-		log.LogError("TestInsertSelectWithCompositePk setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	selectExec, err := exec.CreateSelect[TestWithCompositePk](orm, "")
-	if err != nil {
-		log.LogError("TestInsertSelectWithCompositePk setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	err = insertExec.Execute(conn)
-	if err != nil {
-		log.LogError("TestInsertSelectWithCompositePk insert failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	err = selectExec.Execute(conn)
-
-	// THEN
-	if err != nil {
-		log.LogError("TestInsertSelectWithCompositePk failure. %s", err)
-		t.Fail()
-		return
-	}
-
-	res := selectExec.Results()
-	if len(res) != 1 {
-		log.LogError("TestInsertSelectWithCompositePk test failed. Expected: 1, Actual: %s", len(res))
-		t.Fail()
-		return
-	}
-
-	singleRes := res[0]
-	if singleRes.ID != 12 || singleRes.Name != "Test" {
-		log.LogError("TestInsertSelectWithCompositePk invalid result. Expected: %s, Actual: %s", testObj, singleRes)
-		t.Fail()
-	}
-
-}
-
-func TestInsertMultipleAndSelectWithParam(t *testing.T) {
-	// GIVEN
-	orm, conn := testSetup()
-	defer cleanUp("test.db", conn)
-
-	// WHEN
-	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
-	testObjSecond := Test{Int64Field: 12, IntField: 54, StringField: "fdsa"}
-
-	insertExec, err := exec.NewInsert(orm, testObj)
-	if err != nil {
-		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	insertSecond, err := exec.NewInsert(orm, testObjSecond)
-	if err != nil {
-		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	selectExec, err := exec.CreateSelect[Test](orm, "string_field = ?", "fdsa")
-	if err != nil {
-		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	err = insertExec.Execute(conn)
-	if err != nil {
-		log.LogError("TestInsertMultipleAndSelectWithParam first insert failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	err = insertSecond.Execute(conn)
-	if err != nil {
-		log.LogError("TestInsertMultipleAndSelectWithParam second insert failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	err = selectExec.Execute(conn)
-
-	// THEN
-	if err != nil {
-		log.LogError("TestInsertMultipleAndSelectWithParam failure. %s", err)
-		t.Fail()
-		return
-	}
-
-	res := selectExec.Results()
-	if len(res) != 1 {
-		log.LogError(" TestInsertMultipleAndSelectWithParam test failed. Expected: 1, Actual: %s", len(res))
-		t.Fail()
-		return
-	}
-
-	singleRes := res[0]
-	if singleRes.ID != 2 || singleRes.Int64Field != 12 || singleRes.IntField != 54 || singleRes.StringField != "fdsa" {
-		log.LogError("TestInsertMultipleAndSelectWithParam invalid result. Expected: %s, Actual: %s", testObjSecond, singleRes)
-		t.Fail()
-		return
-	}
-}
-
 func TestInsertAndUpdate(t *testing.T) {
 	// GIVEN
 	orm, conn := testSetup()
@@ -334,13 +118,15 @@ func TestInsertAndUpdate(t *testing.T) {
 		return
 	}
 
-	selectExec, err := exec.CreateSelect[Test](orm, "string_field = ?", "asdf")
+	selectExec, err := exec.CreateSelect[Test](orm)
 	if err != nil {
 		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
 		t.Fail()
 		return
 	}
 
+	selectExec.Where("string_field = ?", "asdf")
+
 	err = insertExec.Execute(conn)
 	if err != nil {
 		log.LogError("TestInsertAndUpdate insert failed: %s", err)
@@ -421,7 +207,7 @@ func TestInsertAndDelete(t *testing.T) {
 		return
 	}
 
-	selectExec, err := exec.CreateSelect[Test](orm, "")
+	selectExec, err := exec.CreateSelect[Test](orm)
 	if err != nil {
 		log.LogError("TestInsertAndDelete setup failed: %s", err)
 		t.Fail()
@@ -477,7 +263,7 @@ func TestBoolInsertAndSelectSingle(t *testing.T) {
 		return
 	}
 
-	selectExec, err := exec.CreateSelect[TestWithBool](orm, "")
+	selectExec, err := exec.CreateSelect[TestWithBool](orm)
 	if err != nil {
 		log.LogError("TestBoolInsertAndSelectSingle setup failed: %s", err)
 		t.Fail()
@@ -531,7 +317,7 @@ func TestTimeInsertAndSelectSingle(t *testing.T) {
 		return
 	}
 
-	selectExec, err := exec.CreateSelect[TestWithTime](orm, "")
+	selectExec, err := exec.CreateSelect[TestWithTime](orm)
 	if err != nil {
 		log.LogError("TestTimeInsertAndSelectSingle setup failed: %s", err)
 		t.Fail()
@@ -637,13 +423,15 @@ func TestTransactionRollback(t *testing.T) {
 		return
 	}
 
-	selectExec, err := exec.CreateSelect[Test](orm, "id = ?", insertExec.Results()[0].ID)
+	selectExec, err := exec.CreateSelect[Test](orm)
 	if err != nil {
 		log.LogError("TestTransactionRollback WHEN failed: %s", err)
 		t.Fail()
 		return
 	}
 
+	selectExec.Where("id = ?", insertExec.Results()[0].ID)
+
 	transErr = transaction.Execute(&selectExec)
 	if transErr != nil {
 		log.LogError("TestTransactionRollback WHEN failed: %s", err)
@@ -681,3 +469,97 @@ func TestTransactionRollback(t *testing.T) {
 		return
 	}
 }
+
+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()
+	}
+}

test/select_test.go

@@ -0,0 +1,326 @@
+package simpleorm_test
+
+import (
+	"strconv"
+	"testing"
+
+	"git.gdulai.com/gdulai/simpleorm/exec"
+	log "gitlab.com/gdulai/simpleloglvl"
+)
+
+func TestSelectEmpty(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	// WHEN
+	selectExec, err := exec.CreateSelect[Test](orm)
+
+	// THEN
+	if err != nil {
+		log.LogError("Failed to create select. %s", err)
+		t.Fail()
+		return
+	}
+
+	err = selectExec.Execute(conn)
+	if err != nil {
+		log.LogError("Select failure. %s", err)
+		t.Fail()
+		return
+	}
+
+	res := selectExec.Results()
+	if len(res) > 0 {
+		log.LogError("Expected empty result.")
+		t.Fail()
+		return
+	}
+}
+
+func TestSelectSingle(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
+
+	// WHEN
+	insertExec, err := exec.NewInsert(orm, testObj)
+	if err != nil {
+		log.LogError("TestInsertAndSelectSingle setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	selectExec, err := exec.CreateSelect[Test](orm)
+	if err != nil {
+		log.LogError("TestInsertAndSelectSingle setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	insertErr := insertExec.Execute(conn)
+	selectErr := selectExec.Execute(conn)
+
+	// THEN
+	if insertErr != nil {
+		log.LogError("TestInsertAndSelectSingle insert failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	if selectErr != nil {
+		log.LogError("TestInsertAndSelectSingle failure. %s", err)
+		t.Fail()
+		return
+	}
+
+	insertRes := insertExec.Results()
+	if len(insertRes) != 1 {
+		log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(insertRes))
+		t.Fail()
+		return
+	}
+
+	selectRes := selectExec.Results()
+	if len(selectRes) != 1 {
+		log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(selectRes))
+		t.Fail()
+		return
+	}
+
+	singleRes := insertRes[0]
+	if singleRes.ID != 1 || singleRes.Int64Field != 54 || singleRes.IntField != 12 || singleRes.StringField != "asdf" {
+		log.LogError("TestInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
+		t.Fail()
+	}
+
+	singleRes = selectRes[0]
+	if singleRes.ID != 1 || singleRes.Int64Field != 54 || singleRes.IntField != 12 || singleRes.StringField != "asdf" {
+		log.LogError("TestInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
+		t.Fail()
+	}
+
+}
+
+func TestSelectWithCompositePk(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	testObj := TestWithCompositePk{ID: 12, Name: "Test"}
+
+	// WHEN
+	insertExec, err := exec.NewInsert(orm, testObj)
+	if err != nil {
+		log.LogError("TestInsertSelectWithCompositePk setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	selectExec, err := exec.CreateSelect[TestWithCompositePk](orm)
+	if err != nil {
+		log.LogError("TestInsertSelectWithCompositePk setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	err = insertExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestInsertSelectWithCompositePk insert failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	err = selectExec.Execute(conn)
+
+	// THEN
+	if err != nil {
+		log.LogError("TestInsertSelectWithCompositePk failure. %s", err)
+		t.Fail()
+		return
+	}
+
+	res := selectExec.Results()
+	if len(res) != 1 {
+		log.LogError("TestInsertSelectWithCompositePk test failed. Expected: 1, Actual: %s", len(res))
+		t.Fail()
+		return
+	}
+
+	singleRes := res[0]
+	if singleRes.ID != 12 || singleRes.Name != "Test" {
+		log.LogError("TestInsertSelectWithCompositePk invalid result. Expected: %s, Actual: %s", testObj, singleRes)
+		t.Fail()
+	}
+
+}
+
+func TestSelectWithParam(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	// WHEN
+	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
+	testObjSecond := Test{Int64Field: 12, IntField: 54, StringField: "fdsa"}
+
+	insertExec, err := exec.NewInsert(orm, testObj)
+	if err != nil {
+		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	insertSecond, err := exec.NewInsert(orm, testObjSecond)
+	if err != nil {
+		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	selectExec, err := exec.CreateSelect[Test](orm)
+	if err != nil {
+		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	selectExec.Where("string_field = ?", "fdsa")
+
+	err = insertExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestInsertMultipleAndSelectWithParam first insert failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	err = insertSecond.Execute(conn)
+	if err != nil {
+		log.LogError("TestInsertMultipleAndSelectWithParam second insert failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	err = selectExec.Execute(conn)
+
+	// THEN
+	if err != nil {
+		log.LogError("TestInsertMultipleAndSelectWithParam failure. %s", err)
+		t.Fail()
+		return
+	}
+
+	res := selectExec.Results()
+	if len(res) != 1 {
+		log.LogError(" TestInsertMultipleAndSelectWithParam test failed. Expected: 1, Actual: %s", len(res))
+		t.Fail()
+		return
+	}
+
+	singleRes := res[0]
+	if singleRes.ID != 2 || singleRes.Int64Field != 12 || singleRes.IntField != 54 || singleRes.StringField != "fdsa" {
+		log.LogError("TestInsertMultipleAndSelectWithParam invalid result. Expected: %s, Actual: %s", testObjSecond, singleRes)
+		t.Fail()
+		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).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 TestSelectOrderBy(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.OrderBy(exec.OrderBy{Column: "StringField", Direction: "ASC"})
+
+	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()
+	}
+}