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

@@ -24,14 +24,109 @@ func ExecuteDDL(conn *simpleorm.DBConnection, orm *simpleorm.ORM) {
 	}
 }
 
+type Transaction struct {
+	conn       *simpleorm.DBConnection
+	executions []*Exec[any]
+	tx         *sql.Tx
+	finished   bool
+}
+
+func (t *Transaction) NewTransaction(conn *simpleorm.DBConnection, executions ...*Exec[any]) *Transaction {
+	return &Transaction{conn: conn, executions: executions, finished: false}
+}
+
+func (t *Transaction) Executions() []*Exec[any] {
+	return t.executions
+}
+
+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.tx.Rollback()
+			if rollbackErr != nil {
+				return rollbackErr
+			}
+			t.finished = true
+			return err
+		}
+
+	}
+
+	err := t.tx.Commit()
+	if err != nil {
+		return err
+	}
+
+	t.finished = true
+	return nil
+}
+
+func (t *Transaction) Execute(exec *Exec[any]) error {
+	if t.finished {
+		return errors.New("Transaction already finished.")
+	}
+
+	t.executions = append(t.executions, exec)
+	if t.tx == nil {
+		tx, err := t.conn.Begin()
+		t.tx = tx
+		if err != nil {
+			t.finished = true
+			return err
+		}
+	}
+
+	err := (*exec).execute(nil, t.tx)
+	if err != nil {
+		rollbackErr := t.tx.Rollback()
+		if rollbackErr != nil {
+			return rollbackErr
+		}
+		t.finished = true
+		return err
+	}
+
+	return nil
+}
+
+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
+}
+
 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
 }
 
 func CreateSelect[T any](orm *simpleorm.ORM, whereStmt string, args ...any) (Select[T], error) {
@@ -43,10 +138,20 @@ func CreateSelect[T any](orm *simpleorm.ORM, whereStmt string, args ...any) (Sel
 	return Select[T]{target: *table, whereStmt: whereStmt, args: args}, 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 != "" {
@@ -55,9 +160,15 @@ func (s Select[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 
 	log.LogDebug("Preparing sql: %s, with args: %s", dml, s.args)
 
-	stmt, err := conn.Prepare(dml)
+	var stmt *sql.Stmt
+	if tx != nil {
+		stmt, err = tx.Prepare(dml)
+	} else {
+		stmt, err = conn.Prepare(dml)
+	}
+
 	if err != nil {
-		return nil, err
+		return err
 	}
 	defer stmt.Close()
 
@@ -81,40 +192,21 @@ func (s Select[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 	}
 
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	rowContainer := createSelectResultContainer(s.target)
+	s.results, err = readRows[T](s.target, rows)
-
+	if err != nil {
-	var results []T
+		return err
-
-	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)
 	}
 
-	return results, nil
+	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 +218,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
@@ -145,21 +245,26 @@ func (ins Insert[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 
 	log.LogInfo("%s [%s]", dml, params)
 
-	stmt, err := conn.Prepare(dml)
+	var stmt *sql.Stmt
-	if err != nil {
+	if tx != nil {
-		return []T{}, err
+		stmt, err = tx.Prepare(dml)
+	} else {
+		stmt, err = conn.Prepare(dml)
 	}
 	defer stmt.Close()
 
-	result, err := stmt.Exec(params...)
+	rows, err := stmt.Query(params...)
+
 	if err != nil {
-	} else {
+		return err
-		rowsAffected, _ := result.RowsAffected()
-		log.LogInfo("Inserted %s row", rowsAffected)
-		lastInsertId, _ := result.LastInsertId()
-		log.LogInfo("Last ID: %s", lastInsertId)
 	}
-	return []T{}, nil
+
+	ins.results, err = readRows[T](ins.target, rows)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
 type Update[T any] struct {
@@ -176,17 +281,21 @@ 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 {
@@ -195,20 +304,22 @@ func (u Update[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 
 	log.LogInfo("%s [%s]", dml, params)
 
-	stmt, err := conn.Prepare(dml)
+	var stmt *sql.Stmt
-	if err != nil {
+	if tx != nil {
-		return []T{}, err
+		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 +336,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 +352,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 {
@@ -247,21 +362,23 @@ func (d Delete[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 
 	log.LogInfo("%s [%s]", dml, params)
 
-	stmt, err := conn.Prepare(dml)
+	var stmt *sql.Stmt
-	if err != nil {
+	if tx != nil {
-		return []T{}, err
+		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
 
 }
 
@@ -322,3 +439,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
+}

repository/repository.go

@@ -29,15 +29,16 @@ func (r *Repository[T]) SelectAll() []*T {
 		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))
+	selectRes := selectExec.Results()
-	for i := range selecRes {
+	res := make([]*T, 0, len(selectRes))
-		res = append(res, &selecRes[i])
+	for i := range selectRes {
+		res = append(res, &selectRes[i])
 	}
 
 	return res
@@ -73,55 +74,57 @@ func (r *Repository[T]) SelectByPk(pks ...any) *T {
 		return nil
 	}
 
-	res, err := selectExec.Execute(r.conn)
+	err = selectExec.Execute(r.conn)
 	if err != nil {
 		log.LogError("Failed to load entity: %s", err)
 		return nil
 	}
-
+	selectRes := selectExec.Results()
-	if len(res) != 1 {
+	if len(selectRes) != 1 {
-		log.LogError("Invalid result number of results: %s", len(res))
+		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() {
+	if (*entity).IsInsertable() {
-		insertExec, err := exec.NewInsert[T](r.orm, entity)
+		insertExec, err := exec.NewInsert[T](r.orm, *entity)
 		if err != nil {
-			log.LogError("Failed to create insert execution: %s", err)
+			return err
-			return
 		}
-		if _, err := insertExec.Execute(r.conn); err != nil {
+		err = insertExec.Execute(r.conn)
-			log.LogError("Insert failed for entity: %s", entity)
+		if err != nil {
+			return err
 		}
-
+		result := insertExec.Results()
-		return
+		// 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 err
-		return
 	}
 
-	_, err = updateExec.Execute(r.conn)
+	err = updateExec.Execute(r.conn)
 	if err != nil {
-		log.LogError("Update failed: %s", err)
+		return err
-		return
 	}
+
+	return nil
 }
 
-func (r *Repository[T]) Delete(entity T) {
+func (r *Repository[T]) Delete(entity *T) {
-	deleteExec, err := exec.NewDelete[T](r.orm, []T{entity})
+	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/table.go

@@ -100,6 +100,8 @@ func (t Table) GetInsertDML(count int) (string, error) {
 		}
 	}
 
+	dml.WriteString("RETURNING *")
+
 	return dml.String(), nil
 }
 

test/exec_test.go

@@ -36,13 +36,14 @@ func TestSelectEmpty(t *testing.T) {
 		return
 	}
 
-	res, err := selectExec.Execute(conn)
+	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()
@@ -50,6 +51,108 @@ func TestSelectEmpty(t *testing.T) {
 	}
 }
 
+func TestInsert(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
+	}
+
+	// WHEN
+	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
+	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[Test](orm, testObj, testObjSecond)
+	if err != nil {
+		log.LogError("TestInsertAndSelectSingle setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	// WHEN
+	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
 	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
@@ -76,28 +179,43 @@ func TestInsertAndSelectSingle(t *testing.T) {
 	}
 
 	// WHEN
-	_, err = insertExec.Execute(conn)
+	insertErr := insertExec.Execute(conn)
-	if err != nil {
+	selectErr := selectExec.Execute(conn)
+
+	// THEN
+	if insertErr != nil {
 		log.LogError("TestInsertAndSelectSingle insert failed: %s", err)
 		t.Fail()
 		return
 	}
 
-	res, err := selectExec.Execute(conn)
+	if selectErr != nil {
-
-	// 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))
+	insertRes := insertExec.Results()
+	if len(insertRes) != 1 {
+		log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(insertRes))
 		t.Fail()
 		return
 	}
 
-	singleRes := res[0]
+	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()
@@ -131,14 +249,14 @@ func TestInsertSelectWithCompositePk(t *testing.T) {
 	}
 
 	// WHEN
-	_, err = insertExec.Execute(conn)
+	err = insertExec.Execute(conn)
 	if err != nil {
 		log.LogError("TestInsertSelectWithCompositePk insert failed: %s", err)
 		t.Fail()
 		return
 	}
 
-	res, err := selectExec.Execute(conn)
+	err = selectExec.Execute(conn)
 
 	// THEN
 	if err != nil {
@@ -146,6 +264,8 @@ func TestInsertSelectWithCompositePk(t *testing.T) {
 		t.Fail()
 		return
 	}
+
+	res := selectExec.Results()
 	if len(res) != 1 {
 		log.LogError("TestInsertSelectWithCompositePk test failed. Expected: 1, Actual: %s", len(res))
 		t.Fail()
@@ -196,21 +316,21 @@ func TestInsertMultipleAndSelectWithParam(t *testing.T) {
 
 	// WHEN
 
-	_, err = insertExec.Execute(conn)
+	err = insertExec.Execute(conn)
 	if err != nil {
 		log.LogError("TestInsertMultipleAndSelectWithParam first insert failed: %s", err)
 		t.Fail()
 		return
 	}
 
-	_, err = insertSecond.Execute(conn)
+	err = insertSecond.Execute(conn)
 	if err != nil {
 		log.LogError("TestInsertMultipleAndSelectWithParam second insert failed: %s", err)
 		t.Fail()
 		return
 	}
 
-	res, err := selectExec.Execute(conn)
+	err = selectExec.Execute(conn)
 
 	// THEN
 	if err != nil {
@@ -218,6 +338,8 @@ func TestInsertMultipleAndSelectWithParam(t *testing.T) {
 		t.Fail()
 		return
 	}
+
+	res := selectExec.Results()
 	if len(res) != 1 {
 		log.LogError(" TestInsertMultipleAndSelectWithParam test failed. Expected: 1, Actual: %s", len(res))
 		t.Fail()
@@ -259,20 +381,21 @@ func TestInsertAndUpdate(t *testing.T) {
 
 	// WHEN
 
-	_, 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 +408,8 @@ func TestInsertAndUpdate(t *testing.T) {
 		return
 	}
 
-	_, err = updateExec.Execute(conn)
+	err = updateExec.Execute(conn)
-	res, selectErr := selectExec.Execute(conn)
+	selectErr := selectExec.Execute(conn)
 
 	// THEN
 	if err != nil {
@@ -301,6 +424,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()
@@ -333,7 +457,7 @@ 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()
@@ -347,18 +471,17 @@ func TestInsertAndDelete(t *testing.T) {
 		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)
+	deleteExec, err := exec.NewDelete(orm, selectExec.Results())
 
 	// WHEN
-	_, err = deleteExec.Execute(conn)
+	err = deleteExec.Execute(conn)
 
 	// THEN
 	if err != nil {
@@ -367,7 +490,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()
@@ -401,14 +532,14 @@ func TestBoolInsertAndSelectSingle(t *testing.T) {
 	}
 
 	// 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 +547,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()
@@ -456,14 +589,14 @@ func TestTimeInsertAndSelectSingle(t *testing.T) {
 	}
 
 	// 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 +604,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()

test/repository_test.go

@@ -32,7 +32,7 @@ func TestRepoSelectAll(t *testing.T) {
 		t.Fail()
 		return
 	}
-	_, err = insertExec.Execute(conn)
+	err = insertExec.Execute(conn)
 	repo := repository.NewRepository[Test](conn, orm)
 
 	// WHEN
@@ -58,7 +58,7 @@ func TestRepoSelectByPk(t *testing.T) {
 		t.Fail()
 		return
 	}
-	_, err = insertExec.Execute(conn)
+	err = insertExec.Execute(conn)
 	repo := repository.NewRepository[Test](conn, orm)
 
 	// WHEN
@@ -84,7 +84,7 @@ func TestRepoSelectByCompundPk(t *testing.T) {
 		t.Fail()
 		return
 	}
-	_, err = insertExec.Execute(conn)
+	err = insertExec.Execute(conn)
 	repo := repository.NewRepository[TestWithCompositePk](conn, orm)
 
 	// WHEN
@@ -103,18 +103,19 @@ func TestRepoSave(t *testing.T) {
 	orm, conn := repoTestSetup()
 	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 err != nil {
-	if res == nil {
+		log.LogError("TestRepoSave failed: %s", err)
-		log.LogError("TestRepoSave test failed. Result is nil!")
+	}
+	if testObj.ID == 0 {
+		log.LogError("TestRepoSave failed! testObj.ID is 0!")
 		t.Fail()
-		return
 	}
 }
 
@@ -123,23 +124,21 @@ func TestRepoDelete(t *testing.T) {
 	orm, conn := repoTestSetup()
 	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)
+	err := repo.Save(testObj)
-
+	if err != nil {
-	res := repo.SelectByPk(1)
-	if res == 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()