Count exec & Select limit/offset

Reviewed-on: #2

.gitea/workflows/test.yml

@@ -10,24 +10,36 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
+      - name: Checkout repository
+        run: |
+          git clone \
+            "${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}.git" \
+            .
 
-      - name: Setup Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: "1.22"
+          git checkout "${GITHUB_SHA}"
 
-      - name: Cache Go modules
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cache/go-build
-            ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+      - name: Verify checkout
+        run: |
+          pwd
+          ls -la
+          test -f go.mod
+
+      - 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 .

dbconnection.go

@@ -36,6 +36,10 @@ func (c *DBConnection) Prepare(sql string) (*sql.Stmt, error) {
 	return c.db.Prepare(sql)
 }
 
+func (c *DBConnection) Begin() (*sql.Tx, error) {
+	return c.db.Begin()
+}
+
 func (c *DBConnection) Close() (bool, error) {
 	err := c.db.Close()
 	if err != nil {

exec/exec.go

@@ -10,6 +10,7 @@ import (
 	log "gitlab.com/gdulai/simpleloglvl"
 )
 
+// Created and executes the DDL created by [simpleorm.ORM]
 func ExecuteDDL(conn *simpleorm.DBConnection, orm *simpleorm.ORM) {
 	schema, err := orm.CreateSchema()
 	if err != nil {
@@ -24,14 +25,145 @@ func ExecuteDDL(conn *simpleorm.DBConnection, orm *simpleorm.ORM) {
 	}
 }
 
+// Wraps and represents a DB transaction.
+// Allows for all at once or separate execution of [exec.Exec] implementations.
+type Transaction struct {
+	conn       *simpleorm.DBConnection
+	executions []*Exec[any]
+	tx         *sql.Tx
+	finished   bool
+}
+
+// Creates a new [exec.Transaction].
+// Can be initialized with a set of [exec.Exec]s.
+func NewTransaction(conn *simpleorm.DBConnection, executions ...*Exec[any]) *Transaction {
+	return &Transaction{conn: conn, executions: executions, finished: false}
+}
+
+// The executions assigned to this transaction.
+func (t *Transaction) Executions() []*Exec[any] {
+	return t.executions
+}
+
+// Executes all the [exec.Exec] implementations assigned to this transactions.
+// Begins, commits or rollbacks the transaction.
+// This is a terminal operation, the [exec.Transaction] is considered finished after calling this.
+func (t *Transaction) ExecuteAtOnce() error {
+	if t.finished {
+		return errors.New("Transaction already finished.")
+	}
+
+	if t.tx == nil {
+		tx, err := t.conn.Begin()
+		t.tx = tx
+		if err != nil {
+			t.finished = true
+			return err
+		}
+	}
+
+	for _, exec := range t.executions {
+		err := (*exec).execute(nil, t.tx)
+		if err != nil {
+			rollbackErr := t.Rollback()
+			if rollbackErr != nil {
+				return rollbackErr
+			}
+			return err
+		}
+
+	}
+
+	err := t.tx.Commit()
+	if err != nil {
+		return err
+	}
+
+	t.finished = true
+	return nil
+}
+
+// Executes and assigns the passed [exec.Exec]s to the Transaction.
+// Calls rollback in case of an error.
+// This is NOT a terminal operation, transactions still has to be committed.
+func (t *Transaction) Execute(execs ...Exec[any]) error {
+	if t.finished {
+		return errors.New("Transaction already finished.")
+	}
+
+	for _, exec := range execs {
+		execPtr := &exec
+		t.executions = append(t.executions, execPtr)
+		if t.tx == nil {
+			tx, err := t.conn.Begin()
+			t.tx = tx
+			if err != nil {
+				t.finished = true
+				return err
+			}
+		}
+
+		err := (*execPtr).execute(nil, t.tx)
+		if err != nil {
+			rollbackErr := t.Rollback()
+			if rollbackErr != nil {
+				return rollbackErr
+			}
+			return err
+		}
+
+	}
+
+	return nil
+}
+
+// Finishes the transaction, commits the changes.
+// This is terminal operation.
+func (t *Transaction) Finish() error {
+	if t.finished {
+		return errors.New("Transaction already finished.")
+	}
+
+	if t.tx == nil {
+		return errors.New("Transaction is nil.")
+	}
+
+	t.tx.Commit()
+	t.finished = true
+	return nil
+}
+
+// Rollbacks and aborts the transaction.
+// This is a terminal operation.
+func (t *Transaction) Rollback() error {
+	if t.finished {
+		return errors.New("Transaction already finished.")
+	}
+
+	if t.tx == nil {
+		return errors.New("Transaction is nil.")
+	}
+
+	rollbackErr := t.tx.Rollback()
+	if rollbackErr != nil {
+		return rollbackErr
+	}
+	t.finished = true
+	return nil
+}
+
 type Exec[T any] interface {
-	Execute(conn *simpleorm.DBConnection) ([]T, error)
+	Execute(conn *simpleorm.DBConnection) error
+	execute(conn *simpleorm.DBConnection, tx *sql.Tx) error
 }
 
 type Select[T any] struct {
 	target    schema.Table
 	whereStmt string
 	args      []any
+	results   []T
+	Limit     int64
+	Offset    int64
 }
 
 func CreateSelect[T any](orm *simpleorm.ORM, whereStmt string, args ...any) (Select[T], error) {
@@ -40,36 +172,63 @@ 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]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
+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 []T{}, err
+		return err
 	}
 
 	if s.whereStmt != "" {
 		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 {
+		stmt, err = tx.Prepare(dml)
+	} else {
+		stmt, err = conn.Prepare(dml)
+	}
 
-	stmt, err := conn.Prepare(dml)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	defer stmt.Close()
 
 	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 {
@@ -81,40 +240,94 @@ func (s Select[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 	}
 
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	rowContainer := createSelectResultContainer(s.target)
-
-	var results []T
-
-	for rows.Next() {
-		err = rows.Scan(rowContainer...)
-		if err != nil {
-			return nil, err
-		}
-
-		targetType := s.target.Type
-		parsedResult := reflect.New(targetType)
-		for i, fieldVal := range rowContainer {
-			col := s.target.Columns[i]
-			targetField := parsedResult.Elem().Field(i)
-
-			rawValue := reflect.Indirect(reflect.ValueOf(fieldVal))
-			decoded := reflect.ValueOf(col.Decode(targetField.Type().Name(), rawValue))
-
-			targetField.Set(decoded)
-		}
-		parsedObj := reflect.Indirect(parsedResult).Interface().(T)
-		results = append(results, parsedObj)
+	s.results, err = readRows[T](s.target, rows)
+	if err != nil {
+		return err
 	}
 
-	return results, nil
+	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
+	results  []T
 }
 
 func NewInsert[T any](orm *simpleorm.ORM, toInsert ...T) (Insert[T], error) {
@@ -126,10 +339,18 @@ func NewInsert[T any](orm *simpleorm.ORM, toInsert ...T) (Insert[T], error) {
 	return Insert[T]{target: *table, toInsert: toInsert}, nil
 }
 
-func (ins Insert[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
+func (ins *Insert[T]) Results() []T {
+	return ins.results
+}
+
+func (ins *Insert[T]) Execute(conn *simpleorm.DBConnection) error {
+	return ins.execute(conn, nil)
+}
+
+func (ins *Insert[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
 	dml, err := ins.target.GetInsertDML(len(ins.toInsert))
 	if err != nil {
-		return []T{}, err
+		return err
 	}
 
 	var params []any
@@ -143,23 +364,38 @@ func (ins Insert[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 		}
 	}
 
-	log.LogInfo("%s [%s]", dml, params)
+	log.LogDebug("%s [%s]", dml, params)
 
-	stmt, err := conn.Prepare(dml)
-	if err != nil {
-		return []T{}, err
+	var stmt *sql.Stmt
+	if tx != nil {
+		stmt, err = tx.Prepare(dml)
+	} else {
+		stmt, err = conn.Prepare(dml)
 	}
 	defer stmt.Close()
 
-	result, err := stmt.Exec(params...)
-	if err != nil {
-	} else {
-		rowsAffected, _ := result.RowsAffected()
-		log.LogInfo("Inserted %s row", rowsAffected)
-		lastInsertId, _ := result.LastInsertId()
-		log.LogInfo("Last ID: %s", lastInsertId)
+	// Flattent args to make sure it can be parsed correctly
+	var flatParams []any
+	for _, param := range params {
+		if s, ok := param.([]any); ok {
+			flatParams = append(flatParams, s...)
+		} else {
+			flatParams = append(flatParams, param)
+		}
 	}
-	return []T{}, nil
+
+	rows, err := stmt.Query(flatParams...)
+
+	if err != nil {
+		return err
+	}
+
+	ins.results, err = readRows[T](ins.target, rows)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
 type Update[T any] struct {
@@ -176,39 +412,45 @@ func NewUpdate[T any](orm *simpleorm.ORM, toUpdate T) (Update[T], error) {
 	return Update[T]{target: *table, toUpdate: toUpdate}, nil
 }
 
-func (u Update[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
+func (u Update[T]) Execute(conn *simpleorm.DBConnection) error {
+	return u.execute(conn, nil)
+}
+
+func (u Update[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
 	dml, err := u.target.GetUpdateDML()
 	if err != nil {
-		return []T{}, err
+		return err
 	}
 
 	params := prepareParams(u.toUpdate, u.target)
 
 	pkCols, err := getPk(u.toUpdate, u.target)
 	if err != nil {
-		return []T{}, err
+		return err
 	}
 	// Put the pks back at the end
 	for _, pk := range pkCols {
 		params = append(params, pk)
 	}
 
-	log.LogInfo("%s [%s]", dml, params)
+	log.LogDebug("%s [%s]", dml, params)
 
-	stmt, err := conn.Prepare(dml)
-	if err != nil {
-		return []T{}, err
+	var stmt *sql.Stmt
+	if tx != nil {
+		stmt, err = tx.Prepare(dml)
+	} else {
+		stmt, err = conn.Prepare(dml)
 	}
 	defer stmt.Close()
 
 	result, err := stmt.Exec(params...)
 	if err != nil {
-		return []T{}, err
+		return err
 	} else {
 		rowsAffected, _ := result.RowsAffected()
 		log.LogInfo("Updated %s row", rowsAffected)
 	}
-	return []T{u.toUpdate}, nil
+	return nil
 }
 
 type Delete[T any] struct {
@@ -225,11 +467,15 @@ func NewDelete[T any](orm *simpleorm.ORM, toDelete []T) (Delete[T], error) {
 	return Delete[T]{target: *table, toDelete: toDelete}, nil
 }
 
-func (d Delete[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
+func (d *Delete[T]) Execute(conn *simpleorm.DBConnection) error {
+	return d.execute(conn, nil)
+}
+
+func (d *Delete[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
 	count := len(d.toDelete)
 	dml, err := d.target.GetDeleteDML(count)
 	if err != nil {
-		return []T{}, err
+		return err
 	}
 
 	var params []any
@@ -237,7 +483,7 @@ func (d Delete[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 	for _, del := range d.toDelete {
 		pkCols, err := getPk(del, d.target)
 		if err != nil {
-			return []T{}, err
+			return err
 		}
 
 		for _, pk := range pkCols {
@@ -245,23 +491,25 @@ func (d Delete[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 		}
 	}
 
-	log.LogInfo("%s [%s]", dml, params)
+	log.LogDebug("%s [%s]", dml, params)
 
-	stmt, err := conn.Prepare(dml)
-	if err != nil {
-		return []T{}, err
+	var stmt *sql.Stmt
+	if tx != nil {
+		stmt, err = tx.Prepare(dml)
+	} else {
+		stmt, err = conn.Prepare(dml)
 	}
 	defer stmt.Close()
 
 	result, err := stmt.Exec(params...)
 	if err != nil {
-		return []T{}, err
+		return err
 	} else {
 		rowsAffected, _ := result.RowsAffected()
 		log.LogInfo("Deleted %s row", rowsAffected)
 	}
 
-	return d.toDelete, nil
+	return nil
 
 }
 
@@ -287,7 +535,7 @@ func prepareParams(src any, t schema.Table) []any {
 	var params []any
 	for _, col := range t.Columns {
 		_, ok := col.Modifiers["pk"]
-		if ok {
+		if ok && t.IsPkAuto() {
 			continue
 		}
 		field, ok := t.Type.FieldByName(col.FieldName)
@@ -322,3 +570,31 @@ func getPk(src any, t schema.Table) ([]any, error) {
 
 	return values, nil
 }
+
+func readRows[T any](table schema.Table, rows *sql.Rows) ([]T, error) {
+	rowContainer := createSelectResultContainer(table)
+
+	var results []T
+
+	for rows.Next() {
+		err := rows.Scan(rowContainer...)
+		if err != nil {
+			return nil, err
+		}
+
+		targetType := table.Type
+		parsedResult := reflect.New(targetType)
+		for i, fieldVal := range rowContainer {
+			col := table.Columns[i]
+			targetField := parsedResult.Elem().Field(i)
+
+			rawValue := reflect.Indirect(reflect.ValueOf(fieldVal))
+			decoded := reflect.ValueOf(col.Decode(targetField.Type().Name(), rawValue))
+
+			targetField.Set(decoded)
+		}
+		parsedObj := reflect.Indirect(parsedResult).Interface().(T)
+		results = append(results, parsedObj)
+	}
+	return results, nil
+}

exec_test.go

@@ -1,431 +0,0 @@
-package simpleorm_test
-
-import (
-	"os"
-	"testing"
-	"time"
-
-	simpleorm "git.gdulai.com/gdulai/simpleorm"
-	"git.gdulai.com/gdulai/simpleorm/exec"
-	log "gitlab.com/gdulai/simpleloglvl"
-)
-
-func cleanUp(dbFile string, conn *simpleorm.DBConnection) {
-	conn.Close()
-	os.Remove(dbFile)
-}
-
-func TestSelectEmpty(t *testing.T) {
-	// GIVEN
-	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
-	defer cleanUp("test.db", conn)
-
-	orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
-		TestWithCompositePk{}, TestWithCompositeFk{})
-
-	exec.ExecuteDDL(conn, orm)
-
-	// WHEN
-	selectExec, err := exec.CreateSelect[Test](orm, "")
-
-	// THEN
-
-	if err != nil {
-		log.LogError("Failed to create select. %s", err)
-		t.Fail()
-		return
-	}
-
-	res, err := selectExec.Execute(conn)
-
-	if err != nil {
-		log.LogError("Select failure. %s", err)
-		t.Fail()
-		return
-	}
-	if len(res) > 0 {
-		log.LogError("Expected empty result.")
-		t.Fail()
-		return
-	}
-}
-
-func TestInsertAndSelectSingle(t *testing.T) {
-	// GIVEN
-	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
-	defer cleanUp("test.db", conn)
-	orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
-		TestWithCompositePk{}, TestWithCompositeFk{})
-
-	exec.ExecuteDDL(conn, orm)
-
-	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
-
-	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
-	}
-
-	// WHEN
-	_, err = insertExec.Execute(conn)
-	if err != nil {
-		log.LogError("TestInsertAndSelectSingle insert failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	res, err := selectExec.Execute(conn)
-
-	// THEN
-	if err != nil {
-		log.LogError("TestInsertAndSelectSingle failure. %s", err)
-		t.Fail()
-		return
-	}
-	if len(res) != 1 {
-		log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(res))
-		t.Fail()
-		return
-	}
-
-	singleRes := res[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 TestInsertMultipleAndSelectWithParam(t *testing.T) {
-	// GIVEN
-	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
-	defer cleanUp("test.db", conn)
-
-	orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
-		TestWithCompositePk{}, TestWithCompositeFk{})
-
-	exec.ExecuteDDL(conn, orm)
-
-	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
-	}
-
-	// WHEN
-
-	_, 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
-	}
-
-	res, err := selectExec.Execute(conn)
-
-	// THEN
-	if err != nil {
-		log.LogError("TestInsertMultipleAndSelectWithParam failure. %s", err)
-		t.Fail()
-		return
-	}
-	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
-	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
-	defer cleanUp("test.db", conn)
-	orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
-		TestWithCompositePk{}, TestWithCompositeFk{})
-
-	exec.ExecuteDDL(conn, orm)
-
-	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
-
-	insertExec, err := exec.NewInsert(orm, testObj)
-	if err != nil {
-		log.LogError("TestInsertAndUpdate setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	selectExec, err := exec.CreateSelect[Test](orm, "string_field = ?", "asdf")
-	if err != nil {
-		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	// WHEN
-
-	_, err = insertExec.Execute(conn)
-	if err != nil {
-		log.LogError("TestInsertAndUpdate insert failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	res, err := selectExec.Execute(conn)
-	if err != nil {
-		log.LogError("TestInsertAndUpdate re-select failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	testObj = res[0]
-
-	testObj.IntField = 42069
-	testObj.Int64Field = 69420
-
-	updateExec, err := exec.NewUpdate(orm, testObj)
-	if err != nil {
-		log.LogError("TestInsertAndUpdate setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	_, err = updateExec.Execute(conn)
-	res, selectErr := selectExec.Execute(conn)
-
-	// THEN
-	if err != nil {
-		log.LogError("TestInsertAndUpdate update failure. %s", err)
-		t.Fail()
-		return
-	}
-
-	if selectErr != nil {
-		log.LogError("TestInsertAndUpdate select failure. %s", err)
-		t.Fail()
-		return
-	}
-
-	if len(res) != 1 {
-		log.LogError("TestInsertAndUpdate test failed. Expected: 1, Actual: %s", len(res))
-		t.Fail()
-		return
-	}
-
-	singleRes := res[0]
-	if singleRes.ID != 1 || singleRes.Int64Field != 69420 || singleRes.IntField != 42069 || singleRes.StringField != "asdf" {
-		log.LogError("TestInsertAndUpdate invalid result. Expected: %s, Actual: %s", testObj, singleRes)
-		t.Fail()
-	}
-
-}
-
-func TestInsertAndDelete(t *testing.T) {
-	// GIVEN
-	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
-	defer cleanUp("test.db", conn)
-	orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
-		TestWithCompositePk{}, TestWithCompositeFk{})
-
-	exec.ExecuteDDL(conn, orm)
-
-	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
-
-	insertExec, err := exec.NewInsert(orm, testObj)
-	if err != nil {
-		log.LogError("TestInsertAndDelete setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	_, err = insertExec.Execute(conn)
-	if err != nil {
-		log.LogError("TestInsertAndDelete setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	selectExec, err := exec.CreateSelect[Test](orm, "")
-	if err != nil {
-		log.LogError("TestInsertAndDelete setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	selectRes, err := selectExec.Execute(conn)
-
-	if err != nil {
-		log.LogError("TestInsertAndDelete setup failed. %s", err)
-		t.Fail()
-		return
-	}
-
-	deleteExec, err := exec.NewDelete(orm, selectRes)
-
-	// WHEN
-	_, err = deleteExec.Execute(conn)
-
-	// THEN
-	if err != nil {
-		log.LogError("TestInsertAndDelete delete failure. %s", err)
-		t.Fail()
-		return
-	}
-
-	selectRes, err = selectExec.Execute(conn)
-	if len(selectRes) != 0 {
-		log.LogError("TestInsertAndDelete test failed. Expected: 0, Actual: %s", len(selectRes))
-		t.Fail()
-		return
-	}
-
-}
-
-func TestBoolInsertAndSelectSingle(t *testing.T) {
-	// GIVEN
-	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
-	defer cleanUp("test.db", conn)
-	orm := simpleorm.NewORM(TestWithBool{})
-
-	exec.ExecuteDDL(conn, orm)
-
-	testObj := TestWithBool{BoolField: true}
-
-	insertExec, err := exec.NewInsert(orm, testObj)
-	if err != nil {
-		log.LogError("TestBoolInsertAndSelectSingle setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	selectExec, err := exec.CreateSelect[TestWithBool](orm, "")
-	if err != nil {
-		log.LogError("TestBoolInsertAndSelectSingle setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	// WHEN
-	_, err = insertExec.Execute(conn)
-	if err != nil {
-		log.LogError("TestBoolInsertAndSelectSingle insert failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	res, err := selectExec.Execute(conn)
-
-	// THEN
-	if err != nil {
-		log.LogError("TestBoolInsertAndSelectSingle failure. %s", err)
-		t.Fail()
-		return
-	}
-	if len(res) != 1 {
-		log.LogError("TestBoolInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(res))
-		t.Fail()
-		return
-	}
-
-	singleRes := res[0]
-	if singleRes.ID != 1 || !singleRes.BoolField {
-		log.LogError("TestBoolInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
-		t.Fail()
-	}
-
-}
-
-func TestTimeInsertAndSelectSingle(t *testing.T) {
-	// GIVEN
-	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
-	defer cleanUp("test.db", conn)
-	orm := simpleorm.NewORM(TestWithTime{})
-
-	exec.ExecuteDDL(conn, orm)
-
-	now := time.Now().UnixMilli()
-	testObj := TestWithTime{TimeField: now}
-
-	insertExec, err := exec.NewInsert(orm, testObj)
-	if err != nil {
-		log.LogError("TestTimeInsertAndSelectSingle setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	selectExec, err := exec.CreateSelect[TestWithTime](orm, "")
-	if err != nil {
-		log.LogError("TestTimeInsertAndSelectSingle setup failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	// WHEN
-	_, err = insertExec.Execute(conn)
-	if err != nil {
-		log.LogError("TestTimeInsertAndSelectSingle insert failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	res, err := selectExec.Execute(conn)
-
-	// THEN
-	if err != nil {
-		log.LogError("TestTimeInsertAndSelectSingle failure. %s", err)
-		t.Fail()
-		return
-	}
-	if len(res) != 1 {
-		log.LogError("TestTimeInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(res))
-		t.Fail()
-		return
-	}
-
-	singleRes := res[0]
-	if singleRes.ID != 1 || singleRes.TimeField != now {
-		log.LogError("TestTimeInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
-		t.Fail()
-	}
-
-}

repository/repository.go

@@ -0,0 +1,132 @@
+package repository
+
+import (
+	"reflect"
+	"strings"
+
+	"git.gdulai.com/gdulai/simpleorm"
+	"git.gdulai.com/gdulai/simpleorm/exec"
+	log "gitlab.com/gdulai/simpleloglvl"
+)
+
+type HasPK interface {
+	IsInsertable() bool
+}
+
+type Repository[T HasPK] struct {
+	conn *simpleorm.DBConnection
+	orm  *simpleorm.ORM
+}
+
+func NewRepository[T HasPK](conn *simpleorm.DBConnection, orm *simpleorm.ORM) *Repository[T] {
+	return &Repository[T]{conn: conn, orm: orm}
+}
+
+func (r *Repository[T]) SelectAll() []*T {
+	selectExec, err := exec.CreateSelect[T](r.orm, "")
+	if err != nil {
+		log.LogError("Failed to create select execution: %s", err)
+		return []*T{}
+	}
+
+	err = selectExec.Execute(r.conn)
+	if err != nil {
+		log.LogError("Failed to load projects: %s", err)
+		return []*T{}
+	}
+
+	selectRes := selectExec.Results()
+	res := make([]*T, 0, len(selectRes))
+	for i := range selectRes {
+		res = append(res, &selectRes[i])
+	}
+
+	return res
+}
+
+func (r *Repository[T]) SelectByPk(pks ...any) *T {
+	table, ok := r.orm.Cache().Get(reflect.TypeFor[T]().Name())
+	if !ok {
+		log.LogError("Could not get cached Table!")
+		return nil
+	}
+
+	var whereStmtBuilder strings.Builder
+
+	for _, constr := range table.Constraints {
+		if constr.Type != "pk" {
+			continue
+		}
+
+		for i, col := range constr.Columns {
+			if i != 0 {
+				whereStmtBuilder.WriteString(" AND ")
+			}
+
+			whereStmtBuilder.WriteString(col.Name + " = ?")
+		}
+
+	}
+
+	selectExec, err := exec.CreateSelect[T](r.orm, whereStmtBuilder.String(), pks)
+	if err != nil {
+		log.LogError("Failed to create select execution: %s", err)
+		return nil
+	}
+
+	err = selectExec.Execute(r.conn)
+	if err != nil {
+		log.LogError("Failed to load entity: %s", err)
+		return nil
+	}
+	selectRes := selectExec.Results()
+	if len(selectRes) != 1 {
+		log.LogError("Invalid result number of results: %s", len(selectRes))
+		return nil
+	}
+
+	return &selectRes[0]
+}
+
+func (r *Repository[T]) Save(entity *T) error {
+	// Insert
+	if (*entity).IsInsertable() {
+		insertExec, err := exec.NewInsert[T](r.orm, *entity)
+		if err != nil {
+			return err
+		}
+		err = insertExec.Execute(r.conn)
+		if err != nil {
+			return err
+		}
+		result := insertExec.Results()
+		// Point to the new inserted result
+		*entity = result[0]
+		return nil
+	}
+
+	updateExec, err := exec.NewUpdate[T](r.orm, *entity)
+	if err != nil {
+		return err
+	}
+
+	err = updateExec.Execute(r.conn)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (r *Repository[T]) Delete(entity *T) {
+	deleteExec, err := exec.NewDelete[T](r.orm, []T{*entity})
+	if err != nil {
+		log.LogError("Failed to create delete execution: %s", err)
+		return
+	}
+	err = deleteExec.Execute(r.conn)
+	if err != nil {
+		log.LogError("Delete failed: %s", err)
+		return
+	}
+}

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()) + " (")
@@ -66,7 +70,7 @@ func (t Table) GetInsertDML(count int) (string, error) {
 	effectiveColumnsLen := 0
 	for i, col := range t.Columns {
 		_, ok := col.Modifiers["pk"]
-		if ok {
+		if ok && t.IsPkAuto() {
 			continue
 		}
 
@@ -100,6 +104,8 @@ func (t Table) GetInsertDML(count int) (string, error) {
 		}
 	}
 
+	dml.WriteString(" RETURNING *")
+
 	return dml.String(), nil
 }
 
@@ -116,7 +122,9 @@ func (t Table) GetUpdateDML() (string, error) {
 		_, ok := modifiers["pk"]
 		if ok {
 			pkColumns = append(pkColumns, col.Name)
-			continue
+			if t.IsPkAuto() {
+				continue
+			}
 		}
 
 		colDml, err := col.GetUpdateDML()
@@ -129,7 +137,6 @@ func (t Table) GetUpdateDML() (string, error) {
 		} else {
 			dml.WriteString(colDml + " ")
 		}
-
 	}
 
 	dml.WriteString("WHERE ")
@@ -174,3 +181,14 @@ func (t Table) GetDeleteDML(count int) (string, error) {
 
 	return dml.String(), nil
 }
+
+func (t Table) IsPkAuto() bool {
+	for _, constr := range t.Constraints {
+		if constr.Type != "pk" {
+			continue
+		}
+
+		return len(constr.Columns) == 1
+	}
+	return true
+}

test/exec_test.go

@@ -0,0 +1,828 @@
+package simpleorm_test
+
+import (
+	"strconv"
+	"testing"
+	"time"
+
+	"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 TestInsert(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
+	}
+
+	insertErr := insertExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestInsertAndSelectSingle insert failed: %s", err)
+		t.Fail()
+		return
+	}
+	insertRes := insertExec.Results()
+
+	// THEN
+	if insertErr != nil {
+		log.LogError("TestInsertAndSelectSingle failure. %s", err)
+		t.Fail()
+		return
+	}
+
+	if len(insertRes) != 1 {
+		log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(insertRes))
+		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()
+	}
+}
+
+func TestInsertMultiple(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
+	testObjSecond := Test{Int64Field: 12, IntField: 54, StringField: "fdsa"}
+
+	// WHEN
+	insertExec, err := exec.NewInsert[Test](orm, testObj, testObjSecond)
+	if err != nil {
+		log.LogError("TestInsertAndSelectSingle setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	insertErr := insertExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestInsertAndSelectSingle insert failed: %s", err)
+		t.Fail()
+		return
+	}
+	insertRes := insertExec.Results()
+
+	// THEN
+	if insertErr != nil {
+		log.LogError("TestInsertAndSelectSingle failure. %s", err)
+		t.Fail()
+		return
+	}
+
+	if len(insertRes) != 2 {
+		log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(insertRes))
+		t.Fail()
+		return
+	}
+
+	entity := insertRes[0]
+	if entity.ID != 1 || entity.Int64Field != 54 || entity.IntField != 12 || entity.StringField != "asdf" {
+		log.LogError("TestInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, entity)
+		t.Fail()
+	}
+
+	entity = insertRes[1]
+	if entity.ID != 2 || entity.Int64Field != 12 || entity.IntField != 54 || entity.StringField != "fdsa" {
+		log.LogError("TestInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObjSecond, entity)
+		t.Fail()
+	}
+
+}
+
+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()
+	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("TestInsertAndUpdate setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	selectExec, err := exec.CreateSelect[Test](orm, "string_field = ?", "asdf")
+	if err != nil {
+		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	err = insertExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestInsertAndUpdate insert failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	err = selectExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestInsertAndUpdate re-select failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	res := selectExec.Results()
+	testObj = res[0]
+
+	testObj.IntField = 42069
+	testObj.Int64Field = 69420
+
+	updateExec, err := exec.NewUpdate(orm, testObj)
+	if err != nil {
+		log.LogError("TestInsertAndUpdate setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	err = updateExec.Execute(conn)
+	selectErr := selectExec.Execute(conn)
+
+	// THEN
+	if err != nil {
+		log.LogError("TestInsertAndUpdate update failure. %s", err)
+		t.Fail()
+		return
+	}
+
+	if selectErr != nil {
+		log.LogError("TestInsertAndUpdate select failure. %s", err)
+		t.Fail()
+		return
+	}
+
+	res = selectExec.Results()
+	if len(res) != 1 {
+		log.LogError("TestInsertAndUpdate test failed. Expected: 1, Actual: %s", len(res))
+		t.Fail()
+		return
+	}
+
+	singleRes := res[0]
+	if singleRes.ID != 1 || singleRes.Int64Field != 69420 || singleRes.IntField != 42069 || singleRes.StringField != "asdf" {
+		log.LogError("TestInsertAndUpdate invalid result. Expected: %s, Actual: %s", testObj, singleRes)
+		t.Fail()
+	}
+
+}
+
+func TestInsertAndDelete(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("TestInsertAndDelete setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	err = insertExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestInsertAndDelete setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	selectExec, err := exec.CreateSelect[Test](orm, "")
+	if err != nil {
+		log.LogError("TestInsertAndDelete setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	err = selectExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestInsertAndDelete setup failed. %s", err)
+		t.Fail()
+		return
+	}
+
+	deleteExec, err := exec.NewDelete(orm, selectExec.Results())
+	err = deleteExec.Execute(conn)
+
+	// THEN
+	if err != nil {
+		log.LogError("TestInsertAndDelete delete failure. %s", err)
+		t.Fail()
+		return
+	}
+
+	err = selectExec.Execute(conn)
+	// THEN
+	if err != nil {
+		log.LogError("TestInsertAndDelete delete failure. %s", err)
+		t.Fail()
+		return
+	}
+
+	selectRes := selectExec.Results()
+	if len(selectRes) != 0 {
+		log.LogError("TestInsertAndDelete test failed. Expected: 0, Actual: %s", len(selectRes))
+		t.Fail()
+		return
+	}
+
+}
+
+func TestBoolInsertAndSelectSingle(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	testObj := TestWithBool{BoolField: true}
+
+	// WHEN
+	insertExec, err := exec.NewInsert(orm, testObj)
+	if err != nil {
+		log.LogError("TestBoolInsertAndSelectSingle setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	selectExec, err := exec.CreateSelect[TestWithBool](orm, "")
+	if err != nil {
+		log.LogError("TestBoolInsertAndSelectSingle setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	err = insertExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestBoolInsertAndSelectSingle insert failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	err = selectExec.Execute(conn)
+
+	// THEN
+	if err != nil {
+		log.LogError("TestBoolInsertAndSelectSingle failure. %s", err)
+		t.Fail()
+		return
+	}
+
+	res := selectExec.Results()
+	if len(res) != 1 {
+		log.LogError("TestBoolInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(res))
+		t.Fail()
+		return
+	}
+
+	singleRes := res[0]
+	if singleRes.ID != 1 || !singleRes.BoolField {
+		log.LogError("TestBoolInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
+		t.Fail()
+	}
+
+}
+
+func TestTimeInsertAndSelectSingle(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	now := time.Now().UnixMilli()
+	testObj := TestWithTime{TimeField: now}
+
+	// WHEN
+	insertExec, err := exec.NewInsert(orm, testObj)
+	if err != nil {
+		log.LogError("TestTimeInsertAndSelectSingle setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	selectExec, err := exec.CreateSelect[TestWithTime](orm, "")
+	if err != nil {
+		log.LogError("TestTimeInsertAndSelectSingle setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	err = insertExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestTimeInsertAndSelectSingle insert failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	err = selectExec.Execute(conn)
+
+	// THEN
+	if err != nil {
+		log.LogError("TestTimeInsertAndSelectSingle failure. %s", err)
+		t.Fail()
+		return
+	}
+
+	res := selectExec.Results()
+	if len(res) != 1 {
+		log.LogError("TestTimeInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(res))
+		t.Fail()
+		return
+	}
+
+	singleRes := res[0]
+	if singleRes.ID != 1 || singleRes.TimeField != now {
+		log.LogError("TestTimeInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
+		t.Fail()
+	}
+
+}
+
+func TestTransactionExecuteSimple(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	transaction := exec.NewTransaction(conn)
+
+	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
+
+	// WHEN
+	insertExec, err := exec.NewInsert[Test](orm, testObj)
+	if err != nil {
+		log.LogError("TestTransactionExecuteSimple failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	transErr := transaction.Execute(&insertExec)
+	if transErr != nil {
+		transErr = transaction.Finish()
+	}
+
+	// THEN
+	if transErr != nil {
+		log.LogError("TestTransactionExecuteSimple failed: %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
+	}
+
+	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()
+	}
+}
+
+func TestTransactionRollback(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	transaction := exec.NewTransaction(conn)
+
+	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
+
+	// WHEN
+	insertExec, err := exec.NewInsert[Test](orm, testObj)
+	if err != nil {
+		log.LogError("TestTransactionRollback WHEN failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	transErr := transaction.Execute(&insertExec)
+	if transErr != nil {
+		log.LogError("TestTransactionRollback WHEN failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	selectExec, err := exec.CreateSelect[Test](orm, "id = ?", insertExec.Results()[0].ID)
+	if err != nil {
+		log.LogError("TestTransactionRollback WHEN failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	transErr = transaction.Execute(&selectExec)
+	if transErr != nil {
+		log.LogError("TestTransactionRollback WHEN failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	beforeRollbackSelectRes := selectExec.Results()
+	rollbackErr := transaction.Rollback()
+	afterRollbackErr := selectExec.Execute(conn)
+	afterRollbackSelectRes := selectExec.Results()
+
+	// THEN
+	if len(beforeRollbackSelectRes) != 1 {
+		log.LogError("TestTransactionExecuteSimple-THEN: Expected 1, Actual: %s", len(beforeRollbackSelectRes))
+		t.Fail()
+		return
+	}
+
+	if rollbackErr != nil {
+		log.LogError("TestTransactionExecuteSimple-THEN: rollback error: %s", rollbackErr)
+		t.Fail()
+		return
+	}
+
+	if afterRollbackErr != nil {
+		log.LogError("TestTransactionExecuteSimple-THEN: after rollback select error: %s", rollbackErr)
+		t.Fail()
+		return
+	}
+
+	if len(afterRollbackSelectRes) != 0 {
+		log.LogError("TestTransactionExecuteSimple-THEN: Expected 0 after rollback select result")
+		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
+	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()
+	}
+}

test/main_test.go

@@ -4,6 +4,8 @@ import (
 	"os"
 	"testing"
 
+	simpleorm "git.gdulai.com/gdulai/simpleorm"
+	"git.gdulai.com/gdulai/simpleorm/exec"
 	_ "github.com/mattn/go-sqlite3"
 	log "gitlab.com/gdulai/simpleloglvl"
 )
@@ -15,6 +17,10 @@ type Test struct {
 	StringField string `sql:"nn"`
 }
 
+func (t Test) IsInsertable() bool {
+	return t.ID == 0
+}
+
 type TestWithFk struct {
 	ID     int `sql:"pk"`
 	TestID int `sql:"nn;fk=Test.ID"`
@@ -26,10 +32,14 @@ type TestWithFkAndFkId struct {
 }
 
 type TestWithCompositePk struct {
-	ID   int    `sql:"nn;pk"`
+	ID   int    `sql:"nn;pk;"`
 	Name string `sql:"nn;pk"`
 }
 
+func (t TestWithCompositePk) IsInsertable() bool {
+	return t.ID == 0 && t.Name == ""
+}
+
 type TestWithCompositeFk struct {
 	ID              int    `sql:"nn;pk"`
 	CompositeFkId   int    `sql:"nn;fk=TestWithCompositePk.ID;"`
@@ -53,3 +63,18 @@ func TestMain(m *testing.M) {
 
 	os.Exit(code)
 }
+
+func testSetup() (*simpleorm.ORM, *simpleorm.DBConnection) {
+	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
+
+	orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
+		TestWithCompositePk{}, TestWithCompositeFk{}, TestWithBool{}, TestWithTime{})
+	exec.ExecuteDDL(conn, orm)
+
+	return orm, conn
+}
+
+func cleanUp(dbFile string, conn *simpleorm.DBConnection) {
+	conn.Close()
+	os.Remove(dbFile)
+}

test/repository_test.go

@@ -0,0 +1,135 @@
+package simpleorm_test
+
+import (
+	"testing"
+
+	"git.gdulai.com/gdulai/simpleorm/exec"
+	"git.gdulai.com/gdulai/simpleorm/repository"
+	log "gitlab.com/gdulai/simpleloglvl"
+)
+
+func TestRepoSelectAll(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
+	insertExec, err := exec.NewInsert(orm, testObj)
+	if err != nil {
+		log.LogError("TestRepoSelectAll setup failed: %s", err)
+		t.Fail()
+		return
+	}
+	err = insertExec.Execute(conn)
+	repo := repository.NewRepository[Test](conn, orm)
+
+	// WHEN
+	res := repo.SelectAll()
+
+	// THEN
+	if len(res) != 1 {
+		log.LogError("TestRepoSelectAll test failed. Expected: 1, Actual: %s", len(res))
+		t.Fail()
+		return
+	}
+}
+
+func TestRepoSelectByPk(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
+	insertExec, err := exec.NewInsert(orm, testObj)
+	if err != nil {
+		log.LogError("TestRepoSelectByPk setup failed: %s", err)
+		t.Fail()
+		return
+	}
+	err = insertExec.Execute(conn)
+	repo := repository.NewRepository[Test](conn, orm)
+
+	// WHEN
+	res := repo.SelectByPk(1)
+
+	// THEN
+	if res == nil {
+		log.LogError("TestRepoSelectByPk test failed. Result is nil!")
+		t.Fail()
+		return
+	}
+}
+
+func TestRepoSelectByCompundPk(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	testObj := TestWithCompositePk{ID: 42069, Name: "Test"}
+	insertExec, err := exec.NewInsert(orm, testObj)
+	if err != nil {
+		log.LogError("TestRepoSelectByCompundPk setup failed: %s", err)
+		t.Fail()
+		return
+	}
+	err = insertExec.Execute(conn)
+	repo := repository.NewRepository[TestWithCompositePk](conn, orm)
+
+	// WHEN
+	res := repo.SelectByPk(42069, "Test")
+
+	// THEN
+	if res == nil {
+		log.LogError("TestRepoSelectByCompundPk test failed. Result is nil!")
+		t.Fail()
+		return
+	}
+}
+
+func TestRepoSave(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	testObj := &Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
+	repo := repository.NewRepository[Test](conn, orm)
+
+	// WHEN
+	err := repo.Save(testObj)
+
+	// THEN
+	if err != nil {
+		log.LogError("TestRepoSave failed: %s", err)
+	}
+	if testObj.ID == 0 {
+		log.LogError("TestRepoSave failed! testObj.ID is 0!")
+		t.Fail()
+	}
+}
+
+func TestRepoDelete(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	testObj := &Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
+	repo := repository.NewRepository[Test](conn, orm)
+
+	err := repo.Save(testObj)
+	if err != nil {
+		log.LogError("TestRepoDelete setup failed! Test data not saved!")
+		t.Fail()
+		return
+	}
+
+	// WHEN
+	repo.Delete(testObj)
+
+	// THEN
+	res := repo.SelectByPk(testObj.ID)
+	if res != nil {
+		log.LogError("TestRepoDelete test failed. Result is not nil!")
+		t.Fail()
+		return
+	}
+}