Separate exec types into files, document code (#10)

Reviewed-on: #10

.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 .

cache/cache.go

@@ -25,7 +25,7 @@ func NewSchemaCache(tables []*schema.Table) *SchemaCache {
 func (o *SchemaCache) add(table *schema.Table) {
 	o.mu.Lock()
 	defer o.mu.Unlock()
-	o.data[table.Type.Name()] = table
+	o.data[table.Type().Name()] = table
 }
 
 func (o *SchemaCache) Get(typeName string) (*schema.Table, bool) {

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/count.go

@@ -0,0 +1,96 @@
+package exec
+
+import (
+	"database/sql"
+	"errors"
+	"reflect"
+
+	"git.gdulai.com/gdulai/simpleorm"
+	"git.gdulai.com/gdulai/simpleorm/schema"
+	log "gitlab.com/gdulai/simpleloglvl"
+)
+
+// Count represents a count query.
+type Count[T any] struct {
+	target    schema.Table
+	whereStmt string
+	args      []any
+	result    int64
+}
+
+// CreateCount returns a new instance of Count.
+//
+// orm is the simpleorm.ORM instance which connects, caches and manages the relations.
+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
+}
+
+// Result returns the result of the count query.
+func (c *Count[T]) Result() int64 {
+	return c.result
+}
+
+// Execute executes the parsed count query against a connection and returns an error if there was any during the execution.
+//
+// conn is the simpleorm.DBConnection which handles the database connection.
+func (c *Count[T]) Execute(conn *simpleorm.DBConnection) error {
+	return c.execute(conn, nil)
+}
+
+// execute executes the parsed count query against a connection and transaction and returns an error if there was any during the execution.
+//
+// conn is the simpleorm.DBConnection which handles the database connection.
+// tx is the sql.Tx transaction which the count query will be run in.
+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
+}

exec/delete.go

@@ -0,0 +1,90 @@
+package exec
+
+import (
+	"database/sql"
+	"errors"
+	"reflect"
+
+	"git.gdulai.com/gdulai/simpleorm"
+	"git.gdulai.com/gdulai/simpleorm/schema"
+	log "gitlab.com/gdulai/simpleloglvl"
+)
+
+// Delete represents a delete operation.
+type Delete[T any] struct {
+	target   schema.Table // The table from which records will be deleted.
+	toDelete []T          // A slice of model instances to be deleted.
+}
+
+// NewDelete creates a new instance of Delete.
+//
+// Parameters:
+// - orm: The ORM instance that manages the database connection and schema
+// - toDelete: A slice of model instances to delete
+//
+// Returns:
+// - Delete[T]: A new Delete operation instance
+// - error: An error if the table could not be found in the schema cache
+func NewDelete[T any](orm *simpleorm.ORM, toDelete []T) (Delete[T], error) {
+	table, ok := orm.Cache().Get(reflect.TypeFor[T]().Name())
+	if !ok {
+		return Delete[T]{}, errors.New("Failed to get table from schema cache")
+	}
+
+	return Delete[T]{target: *table, toDelete: toDelete}, nil
+}
+
+// Execute executes the delete operation.
+func (d *Delete[T]) Execute(conn *simpleorm.DBConnection) error {
+	return d.execute(conn, nil)
+}
+
+// execute constructs and executes the DELETE SQL statement.
+//
+// Parameters:
+// - conn: The database connection to use for executing the query
+// - tx: Optional transaction to use instead of a connection
+//
+// Returns:
+// - error: An error if the operation fails
+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 err
+	}
+
+	var params []any
+
+	for _, del := range d.toDelete {
+		pkCols, err := getPk(del, d.target)
+		if err != nil {
+			return err
+		}
+
+		for _, pk := range pkCols {
+			params = append(params, pk)
+		}
+	}
+
+	log.LogDebug("%s [%s]", dml, params)
+
+	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 err
+	} else {
+		rowsAffected, _ := result.RowsAffected()
+		log.LogInfo("Deleted %s row", rowsAffected)
+	}
+
+	return 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,251 +25,143 @@ func ExecuteDDL(conn *simpleorm.DBConnection, orm *simpleorm.ORM) {
 	}
 }
 
-type Exec[T any] interface {
-	Execute(conn *simpleorm.DBConnection) ([]T, error)
+// 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
 }
 
-type Select[T any] struct {
-	target    schema.Table
-	whereStmt string
-	args      []any
+// 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}
 }
 
-func CreateSelect[T any](orm *simpleorm.ORM, whereStmt string, args ...any) (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")
+// 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.")
 	}
 
-	return Select[T]{target: *table, whereStmt: whereStmt, args: args}, nil
-}
+	if t.tx == nil {
+		tx, err := t.conn.Begin()
+		t.tx = tx
+		if err != nil {
+			t.finished = true
+			return err
+		}
+	}
 
-func (s Select[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
-	dml, err := s.target.GetSelectDML()
+	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 []T{}, err
+		return err
 	}
 
-	if s.whereStmt != "" {
-		dml += " WHERE " + s.whereStmt
+	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.")
 	}
 
-	log.LogDebug("Preparing sql: %s, with args: %s", dml, s.args)
-
-	stmt, err := conn.Prepare(dml)
-	if err != nil {
-		return nil, err
-	}
-	defer stmt.Close()
-
-	log.LogDebug("Executing statement: %s", stmt)
-
-	var rows *sql.Rows
-	if len(s.args) == 0 {
-		rows, err = stmt.Query()
-	} else {
-		// Flattent args to make sure it can be parsed correctly
-		var flatArgs []any
-		for _, a := range s.args {
-			if s, ok := a.([]any); ok {
-				flatArgs = append(flatArgs, s...)
-			} else {
-				flatArgs = append(flatArgs, a)
+	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
 			}
 		}
-		rows, err = stmt.Query(flatArgs...)
 
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	rowContainer := createSelectResultContainer(s.target)
-
-	var results []T
-
-	for rows.Next() {
-		err = rows.Scan(rowContainer...)
+		err := (*execPtr).execute(nil, t.tx)
 		if err != nil {
-			return nil, err
+			rollbackErr := t.Rollback()
+			if rollbackErr != nil {
+				return rollbackErr
+			}
+			return 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)
 	}
 
-	return results, nil
+	return nil
 }
 
-type Insert[T any] struct {
-	target   schema.Table
-	toInsert []T
+// 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
 }
 
-func NewInsert[T any](orm *simpleorm.ORM, toInsert ...T) (Insert[T], error) {
-	table, ok := orm.Cache().Get(reflect.TypeFor[T]().Name())
-	if !ok {
-		return Insert[T]{}, errors.New("Failed to get table from schema cache")
+// Rollbacks and aborts the transaction.
+// This is a terminal operation.
+func (t *Transaction) Rollback() error {
+	if t.finished {
+		return errors.New("Transaction already finished.")
 	}
 
-	return Insert[T]{target: *table, toInsert: toInsert}, nil
+	if t.tx == nil {
+		return errors.New("Transaction is nil.")
+	}
+
+	rollbackErr := t.tx.Rollback()
+	if rollbackErr != nil {
+		return rollbackErr
+	}
+	t.finished = true
+	return nil
 }
 
-func (ins Insert[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
-	dml, err := ins.target.GetInsertDML(len(ins.toInsert))
-	if err != nil {
-		return []T{}, err
-	}
-
-	var params []any
-	for i := range len(ins.toInsert) {
-		actualParams := prepareParams(ins.toInsert[i], ins.target)
-		if len(params) == 0 {
-			params = make([]any, len(ins.toInsert)*len(actualParams))
-		}
-		for j := range actualParams {
-			params[(i*len(actualParams))+j] = actualParams[j]
-		}
-	}
-
-	log.LogInfo("%s [%s]", dml, params)
-
-	stmt, err := conn.Prepare(dml)
-	if err != nil {
-		return []T{}, err
-	}
-	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)
-	}
-	return []T{}, nil
-}
-
-type Update[T any] struct {
-	target   schema.Table
-	toUpdate T
-}
-
-func NewUpdate[T any](orm *simpleorm.ORM, toUpdate T) (Update[T], error) {
-	table, ok := orm.Cache().Get(reflect.TypeFor[T]().Name())
-	if !ok {
-		return Update[T]{}, errors.New("Failed to get table from schema cache")
-	}
-
-	return Update[T]{target: *table, toUpdate: toUpdate}, nil
-}
-
-func (u Update[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
-	dml, err := u.target.GetUpdateDML()
-	if err != nil {
-		return []T{}, err
-	}
-
-	params := prepareParams(u.toUpdate, u.target)
-
-	pkCols, err := getPk(u.toUpdate, u.target)
-	if err != nil {
-		return []T{}, err
-	}
-	// Put the pks back at the end
-	for _, pk := range pkCols {
-		params = append(params, pk)
-	}
-
-	log.LogInfo("%s [%s]", dml, params)
-
-	stmt, err := conn.Prepare(dml)
-	if err != nil {
-		return []T{}, err
-	}
-	defer stmt.Close()
-
-	result, err := stmt.Exec(params...)
-	if err != nil {
-		return []T{}, err
-	} else {
-		rowsAffected, _ := result.RowsAffected()
-		log.LogInfo("Updated %s row", rowsAffected)
-	}
-	return []T{u.toUpdate}, nil
-}
-
-type Delete[T any] struct {
-	target   schema.Table
-	toDelete []T
-}
-
-func NewDelete[T any](orm *simpleorm.ORM, toDelete []T) (Delete[T], error) {
-	table, ok := orm.Cache().Get(reflect.TypeFor[T]().Name())
-	if !ok {
-		return Delete[T]{}, errors.New("Failed to get table from schema cache")
-	}
-
-	return Delete[T]{target: *table, toDelete: toDelete}, nil
-}
-
-func (d Delete[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
-	count := len(d.toDelete)
-	dml, err := d.target.GetDeleteDML(count)
-	if err != nil {
-		return []T{}, err
-	}
-
-	var params []any
-
-	for _, del := range d.toDelete {
-		pkCols, err := getPk(del, d.target)
-		if err != nil {
-			return []T{}, err
-		}
-
-		for _, pk := range pkCols {
-			params = append(params, pk)
-		}
-	}
-
-	log.LogInfo("%s [%s]", dml, params)
-
-	stmt, err := conn.Prepare(dml)
-	if err != nil {
-		return []T{}, err
-	}
-	defer stmt.Close()
-
-	result, err := stmt.Exec(params...)
-	if err != nil {
-		return []T{}, err
-	} else {
-		rowsAffected, _ := result.RowsAffected()
-		log.LogInfo("Deleted %s row", rowsAffected)
-	}
-
-	return d.toDelete, nil
-
+type Exec[T any] interface {
+	Execute(conn *simpleorm.DBConnection) error
+	execute(conn *simpleorm.DBConnection, tx *sql.Tx) error
 }
 
 func createSelectResultContainer(t schema.Table) []any {
-	vals := make([]any, t.Type.NumField())
+	typ := t.Type()
+	vals := make([]any, typ.NumField())
 	for i := range vals {
-		switch t.Type.Field(i).Type.Kind().String() {
+		switch typ.Field(i).Type.Kind().String() {
 		case "string":
 			var fieldContainer string
 			vals[i] = &fieldContainer
@@ -284,13 +177,14 @@ func createSelectResultContainer(t schema.Table) []any {
 }
 
 func prepareParams(src any, t schema.Table) []any {
+	typ := t.Type()
 	var params []any
-	for _, col := range t.Columns {
+	for _, col := range t.Columns() {
 		_, ok := col.Modifiers["pk"]
 		if ok && t.IsPkAuto() {
 			continue
 		}
-		field, ok := t.Type.FieldByName(col.FieldName)
+		field, ok := typ.FieldByName(col.FieldName)
 		if !ok {
 			continue
 		}
@@ -302,11 +196,12 @@ func prepareParams(src any, t schema.Table) []any {
 }
 
 func getPk(src any, t schema.Table) ([]any, error) {
+	typ := t.Type()
 	var values []any
-	for _, constraint := range t.Constraints {
+	for _, constraint := range t.Constraints() {
 		if constraint.Type == "pk" {
 			for _, col := range constraint.Columns {
-				field, ok := t.Type.FieldByName(col.FieldName)
+				field, ok := typ.FieldByName(col.FieldName)
 				if !ok {
 					continue
 
@@ -322,3 +217,32 @@ 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()
+		cols := table.Columns()
+		parsedResult := reflect.New(targetType)
+		for i, fieldVal := range rowContainer {
+			col := cols[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/insert.go

@@ -0,0 +1,122 @@
+package exec
+
+import (
+	"database/sql"
+	"errors"
+	"reflect"
+
+	"git.gdulai.com/gdulai/simpleorm"
+	"git.gdulai.com/gdulai/simpleorm/schema"
+	log "gitlab.com/gdulai/simpleloglvl"
+)
+
+// Insert represents an insert query operation.
+type Insert[T any] struct {
+	target   schema.Table
+	toInsert []T
+	results  []T
+}
+
+// Creates a new insert operation for the given model type.
+//
+// Parameters:
+// - orm: The ORM instance that manages the database connection and schema
+// - toInsert: A variadic list of model instances to insert
+//
+// Returns:
+// - Insert[T]: A new insert operation instance
+// - error: An error if the table could not be found in the schema cache
+
+func NewInsert[T any](orm *simpleorm.ORM, toInsert ...T) (Insert[T], error) {
+	table, ok := orm.Cache().Get(reflect.TypeFor[T]().Name())
+	if !ok {
+		return Insert[T]{}, errors.New("Failed to get table from schema cache")
+	}
+
+	return Insert[T]{target: *table, toInsert: toInsert}, nil
+}
+
+// Returns the results of the insert operation.
+//
+// Returns:
+// - []T: A slice of model instances representing the inserted rows
+
+func (ins *Insert[T]) Results() []T {
+	return ins.results
+}
+
+// Executes the insert operation using the provided database connection.
+//
+// Parameters:
+// - conn: The database connection to use for executing the query
+//
+// Returns:
+// - error: An error if the operation fails
+func (ins *Insert[T]) Execute(conn *simpleorm.DBConnection) error {
+
+	return ins.execute(conn, nil)
+}
+
+// Executes the insert operation using the provided database connection or transaction.
+//
+// Parameters:
+// - conn: The database connection to use for executing the query
+// - tx: Optional transaction to use instead of a connection
+//
+// Returns:
+// - error: An error if the operation fails
+//
+// Implementation Details:
+// 1. Constructs the SQL INSERT statement using GetInsertDML
+// 2. Prepares parameters by flattening nested any values
+// 3. Executes the statement and maps results to model instances
+func (ins *Insert[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
+	dml, err := ins.target.GetInsertDML(len(ins.toInsert))
+	if err != nil {
+		return err
+	}
+
+	var params []any
+	for i := range len(ins.toInsert) {
+		actualParams := prepareParams(ins.toInsert[i], ins.target)
+		if len(params) == 0 {
+			params = make([]any, len(ins.toInsert)*len(actualParams))
+		}
+		for j := range actualParams {
+			params[(i*len(actualParams))+j] = actualParams[j]
+		}
+	}
+
+	log.LogDebug("%s [%s]", dml, params)
+
+	var stmt *sql.Stmt
+	if tx != nil {
+		stmt, err = tx.Prepare(dml)
+	} else {
+		stmt, err = conn.Prepare(dml)
+	}
+	defer stmt.Close()
+
+	// 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)
+		}
+	}
+
+	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
+}

exec/select.go

@@ -0,0 +1,153 @@
+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  []schema.OrderBy
+	results   []T
+}
+
+// Creates the select query builder
+func NewSelect[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 ...schema.OrderBy) *Select[T] {
+	s.ordering = ordering
+	return s
+}
+
+// Returns the result of the select
+func (s *Select[T]) Results() []T {
+	return s.results
+}
+
+// Executes the select query based on the Select exec instance
+// Returns an error if theres any
+func (s *Select[T]) Execute(conn *simpleorm.DBConnection) error {
+	return s.execute(conn, nil)
+}
+
+// Executes the select query based on the Select exec instance
+// If tx is given, the transaction is used instead of the conn
+// Returns an error if theres any
+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
+	}
+
+	if len(s.ordering) > 0 {
+		orderBy, err := s.target.GetOrderByDML(s.ordering...)
+		if err != nil {
+			log.LogError("Failed to create ORDER BY part: %s", err)
+		} else {
+			dml += orderBy
+		}
+	}
+
+	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.LogInfo("Preparing sql: %s", dml)
+	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
+}

exec/update.go

@@ -0,0 +1,85 @@
+package exec
+
+import (
+	"database/sql"
+	"errors"
+	"reflect"
+
+	"git.gdulai.com/gdulai/simpleorm"
+	"git.gdulai.com/gdulai/simpleorm/schema"
+	log "gitlab.com/gdulai/simpleloglvl"
+)
+
+// Update represents an update operation.
+type Update[T any] struct {
+	target   schema.Table // The table where records will be updated.
+	toUpdate T            // A model instance with the new values.
+}
+
+// NewUpdate creates a new instance of Update.
+//
+// Parameters:
+// - orm: The ORM instance that manages the database connection and schema
+// - toUpdate: A model instance with new values
+//
+// Returns:
+// - Update[T]: A new Update operation instance
+// - error: An error if the table could not be found in the schema cache
+func NewUpdate[T any](orm *simpleorm.ORM, toUpdate T) (Update[T], error) {
+	table, ok := orm.Cache().Get(reflect.TypeFor[T]().Name())
+	if !ok {
+		return Update[T]{}, errors.New("Failed to get table from schema cache")
+	}
+
+	return Update[T]{target: *table, toUpdate: toUpdate}, nil
+}
+
+// Execute executes the update operation.
+func (u Update[T]) Execute(conn *simpleorm.DBConnection) error {
+	return u.execute(conn, nil)
+}
+
+// execute constructs and executes the UPDATE SQL statement.
+//
+// Parameters:
+// - conn: The database connection to use for executing the query
+// - tx: Optional transaction to use instead of a connection
+//
+// Returns:
+// - error: An error if the operation fails
+func (u Update[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
+	dml, err := u.target.GetUpdateDML()
+	if err != nil {
+		return err
+	}
+
+	params := prepareParams(u.toUpdate, u.target)
+
+	pkCols, err := getPk(u.toUpdate, u.target)
+	if err != nil {
+		return err
+	}
+	// Put the pks back at the end
+	for _, pk := range pkCols {
+		params = append(params, pk)
+	}
+
+	log.LogDebug("%s [%s]", dml, params)
+
+	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 err
+	} else {
+		rowsAffected, _ := result.RowsAffected()
+		log.LogInfo("Updated %s row", rowsAffected)
+	}
+	return nil
+}

orm.go

@@ -7,7 +7,6 @@ import (
 	"strings"
 
 	"git.gdulai.com/gdulai/simpleorm/cache"
-	"git.gdulai.com/gdulai/simpleorm/parser"
 	"git.gdulai.com/gdulai/simpleorm/schema"
 
 	log "gitlab.com/gdulai/simpleloglvl"
@@ -18,36 +17,48 @@ type ORM struct {
 	cache *cache.SchemaCache
 }
 
-// Inits the ORM library.
-// Param objs is an array which should be an array of the types which describe the tables.
+// NewOrm inits and creates an instance ORM library.
+//
+// obj is an array which should be an array of the types which describe the tables.
 func NewORM(objs ...any) *ORM {
-	var parsers []*parser.Parser
-	var tables []*schema.Table
+	typeParsers := make(map[string]*schema.Parser)
+
+	log.LogDebug("[ORM] Parsing entities to tables...")
+	log.LogDebug("[ORM] Step 1: Parsing table columns")
 	for _, obj := range objs {
-		log.LogDebug("[ORM] Mapping type for: %s", reflect.TypeOf(obj).Name())
-		parser := parser.NewParser(obj)
-		parsers = append(parsers, parser)
-		tables = append(tables, parser.ParseColumns())
+		typ := reflect.TypeOf(obj)
+		log.LogDebug("[ORM] Mapping type for: %s", typ.Name())
+
+		parser := schema.NewParser(obj)
+		parser.ParseColumns()
+
+		typeParsers[typ.Name()] = parser
 	}
 
-	log.LogDebug("[ORM] Tables initiated, creating cache.")
+	log.LogDebug("[ORM] Step 1: Finished parsing columns!")
+	log.LogDebug("[ORM] Step 2: Parsing constraints...")
+
+	for _, parser := range typeParsers {
+		parser.ParseConstraints(typeParsers)
+	}
+
+	log.LogDebug("[ORM] Step 2: Finished parsing contraints!")
+	log.LogDebug("[ORM] Step 3: Creating and caching schema...")
+
+	var tables []*schema.Table
+	for _, parser := range typeParsers {
+		tables = append(tables, parser.ParseTable())
+	}
 
 	// Create cache with the initialized tables
 	cache := cache.NewSchemaCache(tables)
 
-	log.LogDebug("[ORM] Cache created.")
-
-	// Finish the parsing with the constraints and add the to the tables
-	for _, parser := range parsers {
-		log.LogDebug("[ORM] Parsing constraing for: %s", parser.Table.Name)
-		parser.ParseConstraints(cache)
-		log.LogDebug("[ORM] Parsed constraints for: %s", parser.Table.Name)
-	}
+	log.LogDebug("[ORM] Step 3: Cache created.")
 
 	return &ORM{cache: cache}
 }
 
-// Builds the DDL and returns it as a string
+// CreateSchmea builds the DDL and returns it as a string
 func (orm *ORM) CreateSchema() (string, error) {
 	var ddl strings.Builder
 

parser/parser.go

@@ -1,101 +0,0 @@
-package parser
-
-import (
-	"reflect"
-	"strings"
-
-	cache "git.gdulai.com/gdulai/simpleorm/cache"
-	"git.gdulai.com/gdulai/simpleorm/schema"
-	"git.gdulai.com/gdulai/simpleorm/util"
-	log "gitlab.com/gdulai/simpleloglvl"
-)
-
-type Parser struct {
-	typ   reflect.Type
-	Table *schema.Table
-}
-
-func NewParser[T any](obj T) *Parser {
-	objType := reflect.TypeOf(obj)
-	return &Parser{typ: objType}
-}
-
-// This is step 1 of the parsing, it creates the table instance and
-func (p *Parser) ParseColumns() *schema.Table {
-	table := schema.Table{Name: util.CamelToSnake(p.typ.Name()), Type: p.typ}
-
-	var columns []schema.Column
-	for field := range p.typ.Fields() {
-		field := field
-		col := schema.NewColumn(util.CamelToSnake((field.Name)), field.Name, determineType(field.Type), field.Tag)
-		columns = append(columns, col)
-	}
-
-	table.Columns = columns
-	p.Table = &table
-	return p.Table
-}
-
-func (p *Parser) ParseConstraints(cache *cache.SchemaCache) {
-	pkConstraint := schema.Constraint{Name: "pk_" + strings.ToLower(p.Table.Name), Type: "pk"}
-	fkConstraints := make(map[string]schema.Constraint)
-	for _, col := range p.Table.Columns {
-		_, ok := col.Modifiers["pk"]
-		if ok {
-			pkConstraint.Columns = append(pkConstraint.Columns, col)
-			continue
-		}
-
-		fkMod, ok := col.Modifiers["fk"]
-		if !ok {
-			continue
-		}
-
-		fkModParts := strings.Split(fkMod, ".")
-		refTable, ok := cache.Get(fkModParts[0])
-		if !ok {
-			log.LogError("[ORM] Table %s not found in OrmCache!", fkModParts[0])
-			return
-		}
-
-		fkId, ok := col.Modifiers["fk_id"]
-		if fkId == "" {
-			fkId = "fk_" + strings.ToLower(refTable.Name)
-		}
-
-		fkConstraint, ok := fkConstraints[fkId]
-		if !ok {
-			fkConstraint = schema.Constraint{Name: fkId, Type: "fk", RefTable: refTable}
-		}
-
-		fkConstraint.Columns = append(fkConstraint.Columns, col)
-
-		refField := fkModParts[1]
-		for _, refC := range refTable.Columns {
-			if refC.FieldName == refField {
-				fkConstraint.RefColumns = append(fkConstraint.RefColumns, refC)
-			}
-		}
-
-		fkConstraints[fkId] = fkConstraint
-	}
-	p.Table.Constraints = append(p.Table.Constraints, pkConstraint)
-	for _, fkConstraint := range fkConstraints {
-		p.Table.Constraints = append(p.Table.Constraints, fkConstraint)
-	}
-
-}
-
-func determineType(typ reflect.Type) string {
-	typStr := typ.String()
-	switch typStr {
-	case "string":
-		return "TEXT"
-	case "int", "bool":
-		return "INTEGER"
-	case "time.Time", "int64":
-		return "BIGINT"
-	}
-
-	return "VARCHAR(255)"
-}

repository/repository.go

@@ -23,21 +23,22 @@ 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.NewSelect[T](r.orm)
 	if err != nil {
 		log.LogError("Failed to create select execution: %s", err)
 		return []*T{}
 	}
 
-	selecRes, err := selectExec.Execute(r.conn)
+	err = selectExec.Execute(r.conn)
 	if err != nil {
 		log.LogError("Failed to load projects: %s", err)
 		return []*T{}
 	}
 
-	res := make([]*T, 0, len(selecRes))
-	for i := range selecRes {
-		res = append(res, &selecRes[i])
+	selectRes := selectExec.Results()
+	res := make([]*T, 0, len(selectRes))
+	for i := range selectRes {
+		res = append(res, &selectRes[i])
 	}
 
 	return res
@@ -52,7 +53,7 @@ func (r *Repository[T]) SelectByPk(pks ...any) *T {
 
 	var whereStmtBuilder strings.Builder
 
-	for _, constr := range table.Constraints {
+	for _, constr := range table.Constraints() {
 		if constr.Type != "pk" {
 			continue
 		}
@@ -67,61 +68,65 @@ func (r *Repository[T]) SelectByPk(pks ...any) *T {
 
 	}
 
-	selectExec, err := exec.CreateSelect[T](r.orm, whereStmtBuilder.String(), pks)
+	selectExec, err := exec.NewSelect[T](r.orm)
 	if err != nil {
 		log.LogError("Failed to create select execution: %s", err)
 		return nil
 	}
 
-	res, err := selectExec.Execute(r.conn)
+	selectExec.Where(whereStmtBuilder.String(), pks)
+
+	err = selectExec.Execute(r.conn)
 	if err != nil {
 		log.LogError("Failed to load entity: %s", err)
 		return nil
 	}
-
-	if len(res) != 1 {
-		log.LogError("Invalid result number of results: %s", len(res))
+	selectRes := selectExec.Results()
+	if len(selectRes) != 1 {
+		log.LogError("Invalid result number of results: %s", len(selectRes))
 		return nil
 	}
 
-	return &res[0]
+	return &selectRes[0]
 }
 
-func (r *Repository[T]) Save(entity T) {
+func (r *Repository[T]) Save(entity *T) error {
 	// Insert
-	if entity.IsInsertable() {
-		insertExec, err := exec.NewInsert[T](r.orm, entity)
+	if (*entity).IsInsertable() {
+		insertExec, err := exec.NewInsert[T](r.orm, *entity)
 		if err != nil {
-			log.LogError("Failed to create insert execution: %s", err)
-			return
+			return err
 		}
-		if _, err := insertExec.Execute(r.conn); err != nil {
-			log.LogError("Insert failed for entity: %s", entity)
+		err = insertExec.Execute(r.conn)
+		if err != nil {
+			return err
 		}
-
-		return
+		result := insertExec.Results()
+		// Point to the new inserted result
+		*entity = result[0]
+		return nil
 	}
 
-	updateExec, err := exec.NewUpdate[T](r.orm, entity)
+	updateExec, err := exec.NewUpdate[T](r.orm, *entity)
 	if err != nil {
-		log.LogError("Failed to create update execution: %s", err)
-		return
+		return err
 	}
 
-	_, err = updateExec.Execute(r.conn)
+	err = updateExec.Execute(r.conn)
 	if err != nil {
-		log.LogError("Update failed: %s", err)
-		return
+		return err
 	}
+
+	return nil
 }
 
-func (r *Repository[T]) Delete(entity T) {
-	deleteExec, err := exec.NewDelete[T](r.orm, []T{entity})
+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)
+	err = deleteExec.Execute(r.conn)
 	if err != nil {
 		log.LogError("Delete failed: %s", err)
 		return

schema/column.go

@@ -40,11 +40,14 @@ func determineModifiers(tag reflect.StructTag) map[string]string {
 func (c *Column) GetDDL() (string, error) {
 	var ddlBuilder strings.Builder
 
-	ddlBuilder.WriteString(c.Name + " " + c.Type)
+	ddlBuilder.WriteString(c.Name)
+	ddlBuilder.WriteString(" ")
+	ddlBuilder.WriteString(c.Type)
 
 	inlineMods := c.inlineModifiers()
 	for _, mod := range inlineMods {
-		ddlBuilder.WriteString(" " + mod)
+		ddlBuilder.WriteString(" ")
+		ddlBuilder.WriteString(mod)
 	}
 
 	return ddlBuilder.String(), nil

schema/constraint.go

@@ -3,14 +3,16 @@ package schema
 import (
 	"errors"
 	"strings"
+
+	"git.gdulai.com/gdulai/simpleorm/util"
 )
 
 type Constraint struct {
-	Name       string
-	Type       string
-	Columns    []Column
-	RefTable   *Table
-	RefColumns []Column
+	Name        string
+	Type        string
+	Columns     []Column
+	RefTypeName string
+	RefColumns  []Column
 }
 
 func (c *Constraint) GetDDL() (string, error) {
@@ -26,7 +28,9 @@ func (c *Constraint) GetDDL() (string, error) {
 
 func (c *Constraint) getPkDDL() string {
 	var ddl strings.Builder
-	ddl.WriteString("CONSTRAINT " + c.Name + " PRIMARY KEY(")
+	ddl.WriteString("CONSTRAINT ")
+	ddl.WriteString(c.Name)
+	ddl.WriteString(" PRIMARY KEY(")
 	for i, col := range c.Columns {
 		if i != 0 {
 			ddl.WriteString(", ")
@@ -39,7 +43,9 @@ func (c *Constraint) getPkDDL() string {
 
 func (c *Constraint) getFkDDL() string {
 	var ddl strings.Builder
-	ddl.WriteString("CONSTRAINT " + c.Name + " FOREIGN KEY(")
+	ddl.WriteString("CONSTRAINT ")
+	ddl.WriteString(c.Name)
+	ddl.WriteString(" FOREIGN KEY(")
 
 	for i, col := range c.Columns {
 		if i != 0 {
@@ -47,7 +53,10 @@ func (c *Constraint) getFkDDL() string {
 		}
 		ddl.WriteString(col.Name)
 	}
-	ddl.WriteString(") REFERENCES " + c.RefTable.Name + "(")
+
+	ddl.WriteString(") REFERENCES ")
+	ddl.WriteString(util.CamelToSnake(c.RefTypeName))
+	ddl.WriteString("(")
 
 	for i, col := range c.RefColumns {
 		if i != 0 {

schema/parser.go

@@ -0,0 +1,103 @@
+package schema
+
+import (
+	"reflect"
+	"strings"
+
+	"git.gdulai.com/gdulai/simpleorm/util"
+	log "gitlab.com/gdulai/simpleloglvl"
+)
+
+type Parser struct {
+	typ         reflect.Type
+	columns     []Column
+	constraints []Constraint
+}
+
+func NewParser[T any](obj T) *Parser {
+	objType := reflect.TypeOf(obj)
+	return &Parser{typ: objType}
+}
+
+// Step 1 of the parsing, it creates the table instance and
+func (p *Parser) ParseColumns() {
+	var columns []Column
+	for field := range p.typ.Fields() {
+		field := field
+		col := NewColumn(util.CamelToSnake((field.Name)), field.Name, determineType(field.Type), field.Tag)
+		columns = append(columns, col)
+	}
+	p.columns = columns
+}
+
+// Step 2 of the parsing, it creates the constrains with the table references
+func (p *Parser) ParseConstraints(tableParsers map[string]*Parser) {
+	pkConstraint := Constraint{Name: "pk_" + strings.ToLower(util.CamelToSnake((p.typ.Name()))), Type: "pk"}
+	fkConstraints := make(map[string]Constraint)
+	for _, col := range p.columns {
+		_, ok := col.Modifiers["pk"]
+		if ok {
+			pkConstraint.Columns = append(pkConstraint.Columns, col)
+			continue
+		}
+
+		fkMod, ok := col.Modifiers["fk"]
+		if !ok {
+			continue
+		}
+
+		fkModParts := strings.Split(fkMod, ".")
+		refTypeName := fkModParts[0]
+		refTableName := util.CamelToSnake(refTypeName)
+		parser, ok := tableParsers[refTypeName]
+		if !ok {
+			log.LogError("[ORM] Reference table not found", refTypeName)
+		}
+
+		fkId, ok := col.Modifiers["fk_id"]
+		if fkId == "" {
+			fkId = "fk_" + strings.ToLower(refTableName)
+		}
+
+		fkConstraint, ok := fkConstraints[fkId]
+		if !ok {
+			fkConstraint = Constraint{Name: fkId, Type: "fk", RefTypeName: refTypeName}
+		}
+
+		fkConstraint.Columns = append(fkConstraint.Columns, col)
+
+		refField := fkModParts[1]
+		for _, refC := range parser.columns {
+			if refC.FieldName == refField {
+				fkConstraint.RefColumns = append(fkConstraint.RefColumns, refC)
+			}
+		}
+
+		fkConstraints[fkId] = fkConstraint
+	}
+
+	p.constraints = append(p.constraints, pkConstraint)
+	for _, fkConstraint := range fkConstraints {
+		p.constraints = append(p.constraints, fkConstraint)
+	}
+}
+
+// Step 3 of the paring, create the schema.Table instance
+// Returns the schema.Table pointer
+func (p Parser) ParseTable() *Table {
+	return &Table{name: util.CamelToSnake(p.typ.Name()), typ: p.typ, columns: p.columns, constraints: p.constraints}
+}
+
+func determineType(typ reflect.Type) string {
+	typStr := typ.String()
+	switch typStr {
+	case "string":
+		return "TEXT"
+	case "int", "bool":
+		return "INTEGER"
+	case "time.Time", "int64":
+		return "BIGINT"
+	}
+
+	return "VARCHAR(255)"
+}

schema/table.go

@@ -1,23 +1,47 @@
 package schema
 
 import (
+	"errors"
 	"reflect"
 	"strings"
 
 	"git.gdulai.com/gdulai/simpleorm/util"
 )
 
+type OrderBy struct {
+	Field     string
+	Direction string
+}
+
 type Table struct {
-	Name        string
-	Type        reflect.Type
-	Columns     []Column
-	Constraints []Constraint
+	name        string
+	typ         reflect.Type
+	columns     []Column
+	constraints []Constraint
+}
+
+func (t Table) Name() string {
+	return t.name
+}
+
+func (t Table) Type() reflect.Type {
+	return t.typ
+}
+
+func (t Table) Columns() []Column {
+	return t.columns
+}
+
+func (t Table) Constraints() []Constraint {
+	return t.constraints
 }
 
 func (t Table) GetDDL() (string, error) {
 	var ddl strings.Builder
-	ddl.WriteString("CREATE TABLE IF NOT EXISTS " + t.Name + " (")
-	for i, col := range t.Columns {
+	ddl.WriteString("CREATE TABLE IF NOT EXISTS ")
+	ddl.WriteString(t.name)
+	ddl.WriteString(" (")
+	for i, col := range t.columns {
 		if i != 0 {
 			ddl.WriteString(", ")
 		}
@@ -27,12 +51,13 @@ func (t Table) GetDDL() (string, error) {
 		}
 		ddl.WriteString(colDdl)
 	}
-	for _, constr := range t.Constraints {
+	for _, constr := range t.constraints {
 		constrDdl, err := constr.GetDDL()
 		if err != nil {
 			return "", err
 		}
-		ddl.WriteString(", " + constrDdl)
+		ddl.WriteString(", ")
+		ddl.WriteString(constrDdl)
 	}
 
 	ddl.WriteString(");")
@@ -43,7 +68,7 @@ func (t Table) GetSelectDML() (string, error) {
 	var dml strings.Builder
 	dml.WriteString("SELECT ")
 
-	for i, col := range t.Columns {
+	for i, col := range t.columns {
 		if i != 0 {
 			dml.WriteString(", ")
 		}
@@ -54,17 +79,24 @@ func (t Table) GetSelectDML() (string, error) {
 		dml.WriteString(colDml)
 	}
 
-	dml.WriteString(" FROM " + t.Name)
+	dml.WriteString(" FROM ")
+	dml.WriteString(t.name)
 	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()) + " (")
+	dml.WriteString("INSERT INTO ")
+	dml.WriteString(util.CamelToSnake(t.typ.Name()))
+	dml.WriteString(" (")
 
-	columnsLen := len(t.Columns)
+	columnsLen := len(t.columns)
 	effectiveColumnsLen := 0
-	for i, col := range t.Columns {
+	for i, col := range t.columns {
 		_, ok := col.Modifiers["pk"]
 		if ok && t.IsPkAuto() {
 			continue
@@ -100,17 +132,21 @@ func (t Table) GetInsertDML(count int) (string, error) {
 		}
 	}
 
+	dml.WriteString(" RETURNING *")
+
 	return dml.String(), nil
 }
 
 func (t Table) GetUpdateDML() (string, error) {
 	var dml strings.Builder
-	dml.WriteString("UPDATE  " + util.CamelToSnake(t.Type.Name()) + " SET ")
+	dml.WriteString("UPDATE  ")
+	dml.WriteString(util.CamelToSnake(t.typ.Name()))
+	dml.WriteString(" SET ")
 
-	colLen := len(t.Columns)
+	colLen := len(t.columns)
 	var pkColumns []string
 	// Colum names
-	for i, col := range t.Columns {
+	for i, col := range t.columns {
 		modifiers := col.Modifiers
 
 		_, ok := modifiers["pk"]
@@ -127,9 +163,11 @@ func (t Table) GetUpdateDML() (string, error) {
 		}
 
 		if i != colLen-1 {
-			dml.WriteString(colDml + ", ")
+			dml.WriteString(colDml)
+			dml.WriteString(", ")
 		} else {
-			dml.WriteString(colDml + " ")
+			dml.WriteString(colDml)
+			dml.WriteString(" ")
 		}
 	}
 
@@ -139,7 +177,8 @@ func (t Table) GetUpdateDML() (string, error) {
 		if i != 0 {
 			dml.WriteString(" AND ")
 		}
-		dml.WriteString(pkCol + " = ?")
+		dml.WriteString(pkCol)
+		dml.WriteString(" = ?")
 	}
 
 	return dml.String(), nil
@@ -147,17 +186,21 @@ func (t Table) GetUpdateDML() (string, error) {
 
 func (t Table) GetDeleteDML(count int) (string, error) {
 	var dml strings.Builder
-	dml.WriteString("DELETE FROM " + t.Name + " WHERE ")
+	dml.WriteString("DELETE FROM ")
+	dml.WriteString(t.name)
+	dml.WriteString(" WHERE ")
 
-	for _, col := range t.Columns {
+	for _, col := range t.columns {
 		modifiers := col.Modifiers
 
 		_, ok := modifiers["pk"]
 		if ok {
 			if count > 1 {
-				dml.WriteString(col.Name + " IN (")
+				dml.WriteString(col.Name)
+				dml.WriteString(" IN (")
 			} else {
-				dml.WriteString(col.Name + " = ")
+				dml.WriteString(col.Name)
+				dml.WriteString(" = ")
 			}
 		}
 	}
@@ -176,8 +219,33 @@ func (t Table) GetDeleteDML(count int) (string, error) {
 	return dml.String(), nil
 }
 
+func (t Table) GetOrderByDML(ordering ...OrderBy) (string, error) {
+	var dml strings.Builder
+	dml.WriteString(" ORDER BY")
+	for _, orderBy := range ordering {
+		col, err := t.getColumnByField(orderBy.Field)
+		if err != nil {
+			return "", err
+		}
+		dml.WriteString(" ")
+		dml.WriteString(col.Name)
+		dml.WriteString(" ")
+		dml.WriteString(orderBy.Direction)
+	}
+	return dml.String(), nil
+}
+
+func (t Table) getColumnByField(fieldName string) (Column, error) {
+	for _, col := range t.columns {
+		if col.FieldName == fieldName {
+			return col, nil
+		}
+	}
+	return Column{}, errors.New("No column for field " + fieldName + " in table " + t.name)
+}
+
 func (t Table) IsPkAuto() bool {
-	for _, constr := range t.Constraints {
+	for _, constr := range t.constraints {
 		if constr.Type != "pk" {
 			continue
 		}

test/exec_test.go

@@ -1,66 +1,22 @@
 package simpleorm_test
 
 import (
-	"os"
+	"strconv"
 	"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) {
+func TestInsert(t *testing.T) {
 	// GIVEN
-	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
+	orm, conn := testSetup()
 	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"}
 
+	// WHEN
 	insertExec, err := exec.NewInsert(orm, testObj)
 	if err != nil {
 		log.LogError("TestInsertAndSelectSingle setup failed: %s", err)
@@ -68,181 +24,93 @@ func TestInsertAndSelectSingle(t *testing.T) {
 		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)
+	insertErr := insertExec.Execute(conn)
 	if err != nil {
 		log.LogError("TestInsertAndSelectSingle insert failed: %s", err)
 		t.Fail()
 		return
 	}
-
-	res, err := selectExec.Execute(conn)
+	insertRes := insertExec.Results()
 
 	// THEN
-	if err != nil {
+	if insertErr != 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))
+
+	if len(insertRes) != 1 {
+		log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(insertRes))
 		t.Fail()
 		return
 	}
 
-	singleRes := res[0]
+	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 TestInsertSelectWithCompositePk(t *testing.T) {
+func TestInsertMultiple(t *testing.T) {
 	// GIVEN
-	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
+	orm, conn := testSetup()
 	defer cleanUp("test.db", conn)
-	orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
-		TestWithCompositePk{}, TestWithCompositeFk{})
-
-	exec.ExecuteDDL(conn, orm)
-
-	testObj := TestWithCompositePk{ID: 12, Name: "Test"}
-
-	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
-	}
-
-	// WHEN
-	_, err = insertExec.Execute(conn)
-	if err != nil {
-		log.LogError("TestInsertSelectWithCompositePk insert failed: %s", err)
-		t.Fail()
-		return
-	}
-
-	res, err := selectExec.Execute(conn)
-
-	// THEN
-	if err != nil {
-		log.LogError("TestInsertSelectWithCompositePk failure. %s", err)
-		t.Fail()
-		return
-	}
-	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
-	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)
+	insertExec, err := exec.NewInsert[Test](orm, testObj, testObjSecond)
 	if err != nil {
-		log.LogError("TestInsertMultipleAndSelectWithParam first insert failed: %s", err)
+		log.LogError("TestInsertAndSelectSingle setup failed: %s", err)
 		t.Fail()
 		return
 	}
 
-	_, err = insertSecond.Execute(conn)
+	insertErr := insertExec.Execute(conn)
 	if err != nil {
-		log.LogError("TestInsertMultipleAndSelectWithParam second insert failed: %s", err)
+		log.LogError("TestInsertAndSelectSingle insert failed: %s", err)
 		t.Fail()
 		return
 	}
-
-	res, err := selectExec.Execute(conn)
+	insertRes := insertExec.Results()
 
 	// 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))
+	if insertErr != nil {
+		log.LogError("TestInsertAndSelectSingle failure. %s", err)
 		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)
+	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 TestInsertAndUpdate(t *testing.T) {
 	// GIVEN
-	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
+	orm, conn := testSetup()
 	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"}
 
+	// WHEN
 	insertExec, err := exec.NewInsert(orm, testObj)
 	if err != nil {
 		log.LogError("TestInsertAndUpdate setup failed: %s", err)
@@ -250,29 +118,30 @@ func TestInsertAndUpdate(t *testing.T) {
 		return
 	}
 
-	selectExec, err := exec.CreateSelect[Test](orm, "string_field = ?", "asdf")
+	selectExec, err := exec.NewSelect[Test](orm)
 	if err != nil {
 		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
 		t.Fail()
 		return
 	}
 
-	// WHEN
+	selectExec.Where("string_field = ?", "asdf")
 
-	_, err = insertExec.Execute(conn)
+	err = insertExec.Execute(conn)
 	if err != nil {
 		log.LogError("TestInsertAndUpdate insert failed: %s", err)
 		t.Fail()
 		return
 	}
 
-	res, err := selectExec.Execute(conn)
+	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
@@ -285,8 +154,8 @@ func TestInsertAndUpdate(t *testing.T) {
 		return
 	}
 
-	_, err = updateExec.Execute(conn)
-	res, selectErr := selectExec.Execute(conn)
+	err = updateExec.Execute(conn)
+	selectErr := selectExec.Execute(conn)
 
 	// THEN
 	if err != nil {
@@ -301,6 +170,7 @@ func TestInsertAndUpdate(t *testing.T) {
 		return
 	}
 
+	res = selectExec.Results()
 	if len(res) != 1 {
 		log.LogError("TestInsertAndUpdate test failed. Expected: 1, Actual: %s", len(res))
 		t.Fail()
@@ -317,15 +187,12 @@ func TestInsertAndUpdate(t *testing.T) {
 
 func TestInsertAndDelete(t *testing.T) {
 	// GIVEN
-	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
+	orm, conn := testSetup()
 	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"}
 
+	// WHEN
 	insertExec, err := exec.NewInsert(orm, testObj)
 	if err != nil {
 		log.LogError("TestInsertAndDelete setup failed: %s", err)
@@ -333,32 +200,29 @@ func TestInsertAndDelete(t *testing.T) {
 		return
 	}
 
-	_, err = insertExec.Execute(conn)
+	err = insertExec.Execute(conn)
 	if err != nil {
 		log.LogError("TestInsertAndDelete setup failed: %s", err)
 		t.Fail()
 		return
 	}
 
-	selectExec, err := exec.CreateSelect[Test](orm, "")
+	selectExec, err := exec.NewSelect[Test](orm)
 	if err != nil {
 		log.LogError("TestInsertAndDelete setup failed: %s", err)
 		t.Fail()
 		return
 	}
 
-	selectRes, err := selectExec.Execute(conn)
-
+	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)
+	deleteExec, err := exec.NewDelete(orm, selectExec.Results())
+	err = deleteExec.Execute(conn)
 
 	// THEN
 	if err != nil {
@@ -367,7 +231,15 @@ func TestInsertAndDelete(t *testing.T) {
 		return
 	}
 
-	selectRes, err = selectExec.Execute(conn)
+	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()
@@ -378,14 +250,12 @@ func TestInsertAndDelete(t *testing.T) {
 
 func TestBoolInsertAndSelectSingle(t *testing.T) {
 	// GIVEN
-	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
+	orm, conn := testSetup()
 	defer cleanUp("test.db", conn)
-	orm := simpleorm.NewORM(TestWithBool{})
-
-	exec.ExecuteDDL(conn, orm)
 
 	testObj := TestWithBool{BoolField: true}
 
+	// WHEN
 	insertExec, err := exec.NewInsert(orm, testObj)
 	if err != nil {
 		log.LogError("TestBoolInsertAndSelectSingle setup failed: %s", err)
@@ -393,22 +263,21 @@ func TestBoolInsertAndSelectSingle(t *testing.T) {
 		return
 	}
 
-	selectExec, err := exec.CreateSelect[TestWithBool](orm, "")
+	selectExec, err := exec.NewSelect[TestWithBool](orm)
 	if err != nil {
 		log.LogError("TestBoolInsertAndSelectSingle setup failed: %s", err)
 		t.Fail()
 		return
 	}
 
-	// WHEN
-	_, err = insertExec.Execute(conn)
+	err = insertExec.Execute(conn)
 	if err != nil {
 		log.LogError("TestBoolInsertAndSelectSingle insert failed: %s", err)
 		t.Fail()
 		return
 	}
 
-	res, err := selectExec.Execute(conn)
+	err = selectExec.Execute(conn)
 
 	// THEN
 	if err != nil {
@@ -416,6 +285,8 @@ func TestBoolInsertAndSelectSingle(t *testing.T) {
 		t.Fail()
 		return
 	}
+
+	res := selectExec.Results()
 	if len(res) != 1 {
 		log.LogError("TestBoolInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(res))
 		t.Fail()
@@ -432,15 +303,13 @@ func TestBoolInsertAndSelectSingle(t *testing.T) {
 
 func TestTimeInsertAndSelectSingle(t *testing.T) {
 	// GIVEN
-	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
+	orm, conn := testSetup()
 	defer cleanUp("test.db", conn)
-	orm := simpleorm.NewORM(TestWithTime{})
-
-	exec.ExecuteDDL(conn, orm)
 
 	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)
@@ -448,22 +317,21 @@ func TestTimeInsertAndSelectSingle(t *testing.T) {
 		return
 	}
 
-	selectExec, err := exec.CreateSelect[TestWithTime](orm, "")
+	selectExec, err := exec.NewSelect[TestWithTime](orm)
 	if err != nil {
 		log.LogError("TestTimeInsertAndSelectSingle setup failed: %s", err)
 		t.Fail()
 		return
 	}
 
-	// WHEN
-	_, err = insertExec.Execute(conn)
+	err = insertExec.Execute(conn)
 	if err != nil {
 		log.LogError("TestTimeInsertAndSelectSingle insert failed: %s", err)
 		t.Fail()
 		return
 	}
 
-	res, err := selectExec.Execute(conn)
+	err = selectExec.Execute(conn)
 
 	// THEN
 	if err != nil {
@@ -471,6 +339,8 @@ func TestTimeInsertAndSelectSingle(t *testing.T) {
 		t.Fail()
 		return
 	}
+
+	res := selectExec.Results()
 	if len(res) != 1 {
 		log.LogError("TestTimeInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(res))
 		t.Fail()
@@ -484,3 +354,212 @@ func TestTimeInsertAndSelectSingle(t *testing.T) {
 	}
 
 }
+
+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.NewSelect[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)
+		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 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"
 )
@@ -54,6 +56,13 @@ type TestWithTime struct {
 	TimeField int64 `sql:"nn"`
 }
 
+type TestWithJsonStructTag struct {
+	ID          int    `json:"id" sql:"pk"`
+	Int64Field  int64  `json:"int64Field" sql:"nn"`
+	IntField    int    `json:"intField" sql:"nn"`
+	StringField string `json:"stringField" sql:"nn"`
+}
+
 func TestMain(m *testing.M) {
 	log.SetupLogs("Info")
 
@@ -61,3 +70,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

@@ -3,26 +3,14 @@ package simpleorm_test
 import (
 	"testing"
 
-	simpleorm "git.gdulai.com/gdulai/simpleorm"
 	"git.gdulai.com/gdulai/simpleorm/exec"
 	"git.gdulai.com/gdulai/simpleorm/repository"
 	log "gitlab.com/gdulai/simpleloglvl"
 )
 
-func repoTestSetup() (*simpleorm.ORM, *simpleorm.DBConnection) {
-	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
-
-	orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
-		TestWithCompositePk{}, TestWithCompositeFk{})
-
-	exec.ExecuteDDL(conn, orm)
-
-	return orm, conn
-}
-
 func TestRepoSelectAll(t *testing.T) {
 	// GIVEN
-	orm, conn := repoTestSetup()
+	orm, conn := testSetup()
 	defer cleanUp("test.db", conn)
 
 	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
@@ -32,7 +20,7 @@ func TestRepoSelectAll(t *testing.T) {
 		t.Fail()
 		return
 	}
-	_, err = insertExec.Execute(conn)
+	err = insertExec.Execute(conn)
 	repo := repository.NewRepository[Test](conn, orm)
 
 	// WHEN
@@ -48,7 +36,7 @@ func TestRepoSelectAll(t *testing.T) {
 
 func TestRepoSelectByPk(t *testing.T) {
 	// GIVEN
-	orm, conn := repoTestSetup()
+	orm, conn := testSetup()
 	defer cleanUp("test.db", conn)
 
 	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
@@ -58,7 +46,7 @@ func TestRepoSelectByPk(t *testing.T) {
 		t.Fail()
 		return
 	}
-	_, err = insertExec.Execute(conn)
+	err = insertExec.Execute(conn)
 	repo := repository.NewRepository[Test](conn, orm)
 
 	// WHEN
@@ -74,7 +62,7 @@ func TestRepoSelectByPk(t *testing.T) {
 
 func TestRepoSelectByCompundPk(t *testing.T) {
 	// GIVEN
-	orm, conn := repoTestSetup()
+	orm, conn := testSetup()
 	defer cleanUp("test.db", conn)
 
 	testObj := TestWithCompositePk{ID: 42069, Name: "Test"}
@@ -84,7 +72,7 @@ func TestRepoSelectByCompundPk(t *testing.T) {
 		t.Fail()
 		return
 	}
-	_, err = insertExec.Execute(conn)
+	err = insertExec.Execute(conn)
 	repo := repository.NewRepository[TestWithCompositePk](conn, orm)
 
 	// WHEN
@@ -100,46 +88,45 @@ func TestRepoSelectByCompundPk(t *testing.T) {
 
 func TestRepoSave(t *testing.T) {
 	// GIVEN
-	orm, conn := repoTestSetup()
+	orm, conn := testSetup()
 	defer cleanUp("test.db", conn)
 
-	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
+	testObj := &Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
 	repo := repository.NewRepository[Test](conn, orm)
 
 	// WHEN
-	repo.Save(testObj)
+	err := repo.Save(testObj)
 
 	// THEN
-	res := repo.SelectByPk(1)
-	if res == nil {
-		log.LogError("TestRepoSave test failed. Result is nil!")
+	if err != nil {
+		log.LogError("TestRepoSave failed: %s", err)
+	}
+	if testObj.ID == 0 {
+		log.LogError("TestRepoSave failed! testObj.ID is 0!")
 		t.Fail()
-		return
 	}
 }
 
 func TestRepoDelete(t *testing.T) {
 	// GIVEN
-	orm, conn := repoTestSetup()
+	orm, conn := testSetup()
 	defer cleanUp("test.db", conn)
 
-	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
+	testObj := &Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
 	repo := repository.NewRepository[Test](conn, orm)
 
-	repo.Save(testObj)
-
-	res := repo.SelectByPk(1)
-	if res == nil {
+	err := repo.Save(testObj)
+	if err != nil {
 		log.LogError("TestRepoDelete setup failed! Test data not saved!")
 		t.Fail()
 		return
 	}
 
 	// WHEN
-	repo.Delete(*res)
+	repo.Delete(testObj)
 
 	// THEN
-	res = repo.SelectByPk(1)
+	res := repo.SelectByPk(testObj.ID)
 	if res != nil {
 		log.LogError("TestRepoDelete test failed. Result is not nil!")
 		t.Fail()

test/schema_test.go

@@ -113,3 +113,23 @@ func TestParseCompositeFk(t *testing.T) {
 		t.Fail()
 	}
 }
+
+func TestParseStructWithJsonTag(t *testing.T) {
+	// GIVEN
+	orm := simpleorm.NewORM(TestWithJsonStructTag{})
+	// WHEN
+	ddl, err := orm.CreateSchema()
+	// THEN
+	if err != nil {
+		log.LogError("Failed to parse schema! %s", err)
+		t.Fail()
+	}
+
+	expectedDdl := "CREATE TABLE IF NOT EXISTS TEST_WITH_JSON_STRUCT_TAG (ID INTEGER, INT64_FIELD BIGINT NOT NULL, INT_FIELD INTEGER NOT NULL, STRING_FIELD TEXT NOT NULL, CONSTRAINT pk_test_with_json_struct_tag PRIMARY KEY(ID));"
+	if ddl != expectedDdl {
+		log.LogError("Incorrect DDL.\nExpected\n%s\nActual\n%s", expectedDdl, ddl)
+		log.LogError("\nExpected size: %s\nActual size: %s", strconv.Itoa(len(expectedDdl)), strconv.Itoa(len(ddl)))
+		t.Fail()
+	}
+	log.LogInfo("Test finished!")
+}

test/select_test.go

@@ -0,0 +1,419 @@
+package simpleorm_test
+
+import (
+	"strconv"
+	"testing"
+
+	simpleorm "git.gdulai.com/gdulai/simpleorm"
+	"git.gdulai.com/gdulai/simpleorm/exec"
+	"git.gdulai.com/gdulai/simpleorm/schema"
+	log "gitlab.com/gdulai/simpleloglvl"
+)
+
+func TestSelectEmpty(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	// WHEN
+	selectExec, err := exec.NewSelect[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.NewSelect[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.NewSelect[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.NewSelect[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.NewSelect[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 TestSelectOrderByDesc(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	err := orderBySetup(conn, orm)
+	if err != nil {
+		log.LogError("TestSelectOrderByAsc setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	// WHEN
+	selectExec, err := exec.NewSelect[Test](orm)
+	if err != nil {
+		log.LogError("TestSelectOrderByDesc failed: %s", err)
+		t.Fail()
+		return
+	}
+	selectExec.OrderBy(schema.OrderBy{Field: "StringField", Direction: "DESC"})
+
+	err = selectExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestSelectOrderByDesc failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	// THEN
+	var resultStr string
+	for _, obj := range selectExec.Results() {
+		resultStr += obj.StringField
+	}
+
+	if resultStr != "EDCBA" {
+		log.LogError("TestSelectOrderByDesc failed, epxected: EDCBA actual: %s", resultStr)
+		t.Fail()
+	}
+}
+
+func TestSelectOrderByAsc(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	err := orderBySetup(conn, orm)
+	if err != nil {
+		log.LogError("TestSelectOrderByAsc setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	// WHEN
+	selectExec, err := exec.NewSelect[Test](orm)
+	if err != nil {
+		log.LogError("TestSelectOrderByAsc failed: %s", err)
+		t.Fail()
+		return
+	}
+	selectExec.OrderBy(schema.OrderBy{Field: "StringField", Direction: "ASC"})
+
+	err = selectExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestSelectOrderByAsc failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	// THEN
+	var resultStr string
+	for _, obj := range selectExec.Results() {
+		resultStr += obj.StringField
+	}
+
+	if resultStr != "ABCDE" {
+		log.LogError("TestSelectOrderByAsc failed, epxected: ABCDE actual: %s", resultStr)
+		t.Fail()
+	}
+}
+
+func TestSelectOrderByAscWithLimitAndOffset(t *testing.T) {
+	// GIVEN
+	orm, conn := testSetup()
+	defer cleanUp("test.db", conn)
+
+	err := orderBySetup(conn, orm)
+	if err != nil {
+		log.LogError("TestSelectOrderByAsc setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	// WHEN
+	selectExec, err := exec.NewSelect[Test](orm)
+	if err != nil {
+		log.LogError("TestSelectOrderByAsc failed: %s", err)
+		t.Fail()
+		return
+	}
+	selectExec.OrderBy(schema.OrderBy{Field: "StringField", Direction: "ASC"}).Limit(3).Offset(0)
+
+	err = selectExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestSelectOrderByAsc failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	// THEN
+	var resultStr string
+	for _, obj := range selectExec.Results() {
+		resultStr += obj.StringField
+	}
+
+	if resultStr != "ABC" {
+		log.LogError("TestSelectOrderByAsc failed, epxected: ABC actual: %s", resultStr)
+		t.Fail()
+	}
+}
+
+func orderBySetup(conn *simpleorm.DBConnection, orm *simpleorm.ORM) error {
+	insertExec, err := exec.NewInsert[Test](orm,
+		Test{Int64Field: -1, IntField: 1, StringField: "C"},
+		Test{Int64Field: -1, IntField: 1, StringField: "D"},
+		Test{Int64Field: -1, IntField: 1, StringField: "E"},
+		Test{Int64Field: -1, IntField: 1, StringField: "A"},
+		Test{Int64Field: -1, IntField: 1, StringField: "B"},
+	)
+	if err != nil {
+		return err
+	}
+
+	err = insertExec.Execute(conn)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}