Repository impl & tests, move tests, comp. pk insert support

exec/exec.go

@@ -4,7 +4,6 @@ import (
 	"database/sql"
 	"errors"
 	"reflect"
-	"time"
 
 	"git.gdulai.com/gdulai/simpleorm"
 	"git.gdulai.com/gdulai/simpleorm/schema"
@@ -98,7 +97,13 @@ func (s Select[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 		targetType := s.target.Type
 		parsedResult := reflect.New(targetType)
 		for i, fieldVal := range rowContainer {
-			parsedResult.Elem().Field(i).Set(reflect.Indirect(reflect.ValueOf(fieldVal)))
+			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)
@@ -267,7 +272,7 @@ func createSelectResultContainer(t schema.Table) []any {
 		case "string":
 			var fieldContainer string
 			vals[i] = &fieldContainer
-		case "int":
+		case "int", "bool":
 			var fieldContainer int
 			vals[i] = &fieldContainer
 		case "int64", "time.Time":
@@ -282,7 +287,7 @@ func prepareParams(src any, t schema.Table) []any {
 	var params []any
 	for _, col := range t.Columns {
 		_, ok := col.Modifiers["pk"]
-		if ok {
+		if ok && t.IsPkAuto() {
 			continue
 		}
 		field, ok := t.Type.FieldByName(col.FieldName)
@@ -290,15 +295,8 @@ func prepareParams(src any, t schema.Table) []any {
 			continue
 		}
 		fieldValue := reflect.ValueOf(src).FieldByIndex(field.Index)
-		typStr := field.Type.String()
 
-		switch typStr {
+		params = append(params, col.Encode(fieldValue))
-		case "time.Time":
-			time := fieldValue.Interface().(time.Time)
-			params = append(params, time.UnixMilli())
-		default:
-			params = append(params, fieldValue.Interface())
-		}
 	}
 	return params
 }

parser/parser.go

@@ -91,7 +91,7 @@ func determineType(typ reflect.Type) string {
 	switch typStr {
 	case "string":
 		return "TEXT"
-	case "int":
+	case "int", "bool":
 		return "INTEGER"
 	case "time.Time", "int64":
 		return "BIGINT"

repository/repository.go

@@ -0,0 +1,129 @@
+package repository
+
+import (
+	"reflect"
+	"strings"
+
+	"git.gdulai.com/gdulai/simpleorm"
+	"git.gdulai.com/gdulai/simpleorm/exec"
+	log "gitlab.com/gdulai/simpleloglvl"
+)
+
+type HasPK interface {
+	IsInsertable() bool
+}
+
+type Repository[T HasPK] struct {
+	conn *simpleorm.DBConnection
+	orm  *simpleorm.ORM
+}
+
+func NewRepository[T HasPK](conn *simpleorm.DBConnection, orm *simpleorm.ORM) *Repository[T] {
+	return &Repository[T]{conn: conn, orm: orm}
+}
+
+func (r *Repository[T]) SelectAll() []*T {
+	selectExec, err := exec.CreateSelect[T](r.orm, "")
+	if err != nil {
+		log.LogError("Failed to create select execution: %s", err)
+		return []*T{}
+	}
+
+	selecRes, 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])
+	}
+
+	return res
+}
+
+func (r *Repository[T]) SelectByPk(pks ...any) *T {
+	table, ok := r.orm.Cache().Get(reflect.TypeFor[T]().Name())
+	if !ok {
+		log.LogError("Could not get cached Table!")
+		return nil
+	}
+
+	var whereStmtBuilder strings.Builder
+
+	for _, constr := range table.Constraints {
+		if constr.Type != "pk" {
+			continue
+		}
+
+		for i, col := range constr.Columns {
+			if i != 0 {
+				whereStmtBuilder.WriteString(" AND ")
+			}
+
+			whereStmtBuilder.WriteString(col.Name + " = ?")
+		}
+
+	}
+
+	selectExec, err := exec.CreateSelect[T](r.orm, whereStmtBuilder.String(), pks)
+	if err != nil {
+		log.LogError("Failed to create select execution: %s", err)
+		return nil
+	}
+
+	res, 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))
+		return nil
+	}
+
+	return &res[0]
+}
+
+func (r *Repository[T]) Save(entity T) {
+	// Insert
+	if entity.IsInsertable() {
+		insertExec, err := exec.NewInsert[T](r.orm, entity)
+		if err != nil {
+			log.LogError("Failed to create insert execution: %s", err)
+			return
+		}
+		if _, err := insertExec.Execute(r.conn); err != nil {
+			log.LogError("Insert failed for entity: %s", entity)
+		}
+
+		return
+	}
+
+	updateExec, err := exec.NewUpdate[T](r.orm, entity)
+	if err != nil {
+		log.LogError("Failed to create update execution: %s", err)
+		return
+	}
+
+	_, err = updateExec.Execute(r.conn)
+	if err != nil {
+		log.LogError("Update failed: %s", err)
+		return
+	}
+}
+
+func (r *Repository[T]) Delete(entity T) {
+	deleteExec, err := exec.NewDelete[T](r.orm, []T{entity})
+	if err != nil {
+		log.LogError("Failed to create delete execution: %s", err)
+		return
+	}
+	_, err = deleteExec.Execute(r.conn)
+	if err != nil {
+		log.LogError("Delete failed: %s", err)
+		return
+	}
+}

schema/column.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"reflect"
 	"strings"
+	"time"
 )
 
 type Column struct {
@@ -51,7 +52,7 @@ func (c *Column) GetDDL() (string, error) {
 
 func (c *Column) inlineModifiers() []string {
 	var mods []string
-	for k, _ := range c.Modifiers {
+	for k := range c.Modifiers {
 		switch k {
 		case "nn":
 			mods = append(mods, "NOT NULL")
@@ -80,3 +81,46 @@ func (c *Column) IsPK() bool {
 	_, ok := c.Modifiers["pk"]
 	return ok
 }
+
+// Encodes the value to be DB compatible
+func (c Column) Encode(value reflect.Value) any {
+	typ := value.Type().String()
+
+	var encoded any
+	switch typ {
+	case "time.Time":
+		timeVal := value.Interface().(time.Time)
+		encoded = timeVal.UnixMilli()
+	case "bool":
+		boolVal := value.Interface().(bool)
+		if boolVal {
+			encoded = 1
+		} else {
+			encoded = false
+		}
+	default:
+		encoded = value.Interface()
+	}
+
+	return encoded
+}
+
+// Decodes the raw value from the DBs
+func (c Column) Decode(expected string, rawValue reflect.Value) any {
+	var decoded any
+	switch expected {
+	case "time.Time":
+		decoded = time.UnixMilli(rawValue.Interface().(int64))
+	case "bool":
+		rawValue := rawValue.Interface().(int)
+		if rawValue > 0 {
+			decoded = true
+		} else {
+			decoded = false
+		}
+	default:
+		decoded = rawValue.Interface()
+	}
+
+	return decoded
+}

schema/table.go

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

test/exec_test.go

@@ -3,6 +3,7 @@ package simpleorm_test
 import (
 	"os"
 	"testing"
+	"time"
 
 	simpleorm "git.gdulai.com/gdulai/simpleorm"
 	"git.gdulai.com/gdulai/simpleorm/exec"
@@ -104,6 +105,61 @@ func TestInsertAndSelectSingle(t *testing.T) {
 
 }
 
+func TestInsertSelectWithCompositePk(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 := 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")
@@ -299,7 +355,7 @@ func TestInsertAndDelete(t *testing.T) {
 		return
 	}
 
-	deleteExec, err := exec.NewDelete[Test](orm, selectRes)
+	deleteExec, err := exec.NewDelete(orm, selectRes)
 
 	// WHEN
 	_, err = deleteExec.Execute(conn)
@@ -319,3 +375,112 @@ func TestInsertAndDelete(t *testing.T) {
 	}
 
 }
+
+func TestBoolInsertAndSelectSingle(t *testing.T) {
+	// GIVEN
+	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
+	defer cleanUp("test.db", conn)
+	orm := simpleorm.NewORM(TestWithBool{})
+
+	exec.ExecuteDDL(conn, orm)
+
+	testObj := TestWithBool{BoolField: true}
+
+	insertExec, err := exec.NewInsert(orm, testObj)
+	if err != nil {
+		log.LogError("TestBoolInsertAndSelectSingle setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	selectExec, err := exec.CreateSelect[TestWithBool](orm, "")
+	if err != nil {
+		log.LogError("TestBoolInsertAndSelectSingle setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	// WHEN
+	_, err = insertExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestBoolInsertAndSelectSingle insert failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	res, err := selectExec.Execute(conn)
+
+	// THEN
+	if err != nil {
+		log.LogError("TestBoolInsertAndSelectSingle failure. %s", err)
+		t.Fail()
+		return
+	}
+	if len(res) != 1 {
+		log.LogError("TestBoolInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(res))
+		t.Fail()
+		return
+	}
+
+	singleRes := res[0]
+	if singleRes.ID != 1 || !singleRes.BoolField {
+		log.LogError("TestBoolInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
+		t.Fail()
+	}
+
+}
+
+func TestTimeInsertAndSelectSingle(t *testing.T) {
+	// GIVEN
+	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
+	defer cleanUp("test.db", conn)
+	orm := simpleorm.NewORM(TestWithTime{})
+
+	exec.ExecuteDDL(conn, orm)
+
+	now := time.Now().UnixMilli()
+	testObj := TestWithTime{TimeField: now}
+
+	insertExec, err := exec.NewInsert(orm, testObj)
+	if err != nil {
+		log.LogError("TestTimeInsertAndSelectSingle setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	selectExec, err := exec.CreateSelect[TestWithTime](orm, "")
+	if err != nil {
+		log.LogError("TestTimeInsertAndSelectSingle setup failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	// WHEN
+	_, err = insertExec.Execute(conn)
+	if err != nil {
+		log.LogError("TestTimeInsertAndSelectSingle insert failed: %s", err)
+		t.Fail()
+		return
+	}
+
+	res, err := selectExec.Execute(conn)
+
+	// THEN
+	if err != nil {
+		log.LogError("TestTimeInsertAndSelectSingle failure. %s", err)
+		t.Fail()
+		return
+	}
+	if len(res) != 1 {
+		log.LogError("TestTimeInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(res))
+		t.Fail()
+		return
+	}
+
+	singleRes := res[0]
+	if singleRes.ID != 1 || singleRes.TimeField != now {
+		log.LogError("TestTimeInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
+		t.Fail()
+	}
+
+}

test/main_test.go

@@ -15,6 +15,10 @@ type Test struct {
 	StringField string `sql:"nn"`
 }
 
+func (t Test) IsInsertable() bool {
+	return t.ID == 0
+}
+
 type TestWithFk struct {
 	ID     int `sql:"pk"`
 	TestID int `sql:"nn;fk=Test.ID"`
@@ -26,16 +30,30 @@ type TestWithFkAndFkId struct {
 }
 
 type TestWithCompositePk struct {
-	ID   int    `sql:"nn;pk"`
+	ID   int    `sql:"nn;pk;"`
 	Name string `sql:"nn;pk"`
 }
 
+func (t TestWithCompositePk) IsInsertable() bool {
+	return t.ID == 0 && t.Name == ""
+}
+
 type TestWithCompositeFk struct {
 	ID              int    `sql:"nn;pk"`
 	CompositeFkId   int    `sql:"nn;fk=TestWithCompositePk.ID;"`
 	CompositeFkName string `sql:"nn;fk=TestWithCompositePk.Name;"`
 }
 
+type TestWithBool struct {
+	ID        int  `sql:"pk"`
+	BoolField bool `sql:"nn"`
+}
+
+type TestWithTime struct {
+	ID        int   `sql:"pk"`
+	TimeField int64 `sql:"nn"`
+}
+
 func TestMain(m *testing.M) {
 	log.SetupLogs("Info")
 

test/repository_test.go

@@ -0,0 +1,148 @@
+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()
+	defer cleanUp("test.db", conn)
+
+	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
+	insertExec, err := exec.NewInsert(orm, testObj)
+	if err != nil {
+		log.LogError("TestRepoSelectAll setup failed: %s", err)
+		t.Fail()
+		return
+	}
+	_, err = insertExec.Execute(conn)
+	repo := repository.NewRepository[Test](conn, orm)
+
+	// WHEN
+	res := repo.SelectAll()
+
+	// THEN
+	if len(res) != 1 {
+		log.LogError("TestRepoSelectAll test failed. Expected: 1, Actual: %s", len(res))
+		t.Fail()
+		return
+	}
+}
+
+func TestRepoSelectByPk(t *testing.T) {
+	// GIVEN
+	orm, conn := repoTestSetup()
+	defer cleanUp("test.db", conn)
+
+	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
+	insertExec, err := exec.NewInsert(orm, testObj)
+	if err != nil {
+		log.LogError("TestRepoSelectByPk setup failed: %s", err)
+		t.Fail()
+		return
+	}
+	_, err = insertExec.Execute(conn)
+	repo := repository.NewRepository[Test](conn, orm)
+
+	// WHEN
+	res := repo.SelectByPk(1)
+
+	// THEN
+	if res == nil {
+		log.LogError("TestRepoSelectByPk test failed. Result is nil!")
+		t.Fail()
+		return
+	}
+}
+
+func TestRepoSelectByCompundPk(t *testing.T) {
+	// GIVEN
+	orm, conn := repoTestSetup()
+	defer cleanUp("test.db", conn)
+
+	testObj := TestWithCompositePk{ID: 42069, Name: "Test"}
+	insertExec, err := exec.NewInsert(orm, testObj)
+	if err != nil {
+		log.LogError("TestRepoSelectByCompundPk setup failed: %s", err)
+		t.Fail()
+		return
+	}
+	_, err = insertExec.Execute(conn)
+	repo := repository.NewRepository[TestWithCompositePk](conn, orm)
+
+	// WHEN
+	res := repo.SelectByPk(42069, "Test")
+
+	// THEN
+	if res == nil {
+		log.LogError("TestRepoSelectByCompundPk test failed. Result is nil!")
+		t.Fail()
+		return
+	}
+}
+
+func TestRepoSave(t *testing.T) {
+	// GIVEN
+	orm, conn := repoTestSetup()
+	defer cleanUp("test.db", conn)
+
+	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
+	repo := repository.NewRepository[Test](conn, orm)
+
+	// WHEN
+	repo.Save(testObj)
+
+	// THEN
+	res := repo.SelectByPk(1)
+	if res == nil {
+		log.LogError("TestRepoSave test failed. Result is nil!")
+		t.Fail()
+		return
+	}
+}
+
+func TestRepoDelete(t *testing.T) {
+	// GIVEN
+	orm, conn := repoTestSetup()
+	defer cleanUp("test.db", conn)
+
+	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
+	repo := repository.NewRepository[Test](conn, orm)
+
+	repo.Save(testObj)
+
+	res := repo.SelectByPk(1)
+	if res == nil {
+		log.LogError("TestRepoDelete setup failed! Test data not saved!")
+		t.Fail()
+		return
+	}
+
+	// WHEN
+	repo.Delete(*res)
+
+	// THEN
+	res = repo.SelectByPk(1)
+	if res != nil {
+		log.LogError("TestRepoDelete test failed. Result is not nil!")
+		t.Fail()
+		return
+	}
+}