Flatten params for Insert exec

Reviewed-on: #2

cache.go

@@ -1,45 +0,0 @@
-package simpleorm
-
-import (
-	"sync"
-)
-
-type OrmCache struct {
-	mu   sync.RWMutex
-	data map[string]*Table
-}
-
-func NewOrmCache(tables []*Table) *OrmCache {
-	cache := &OrmCache{
-		data: make(map[string]*Table),
-	}
-	for _, table := range tables {
-		cache.add(table)
-	}
-
-	return cache
-}
-
-func (o *OrmCache) add(table *Table) {
-	o.mu.Lock()
-	defer o.mu.Unlock()
-	o.data[table.Type.Name()] = table
-}
-
-func (o *OrmCache) Get(typeName string) (*Table, bool) {
-	o.mu.RLock()
-	defer o.mu.RUnlock()
-	table, ok := o.data[typeName]
-	return table, ok
-}
-
-func (o *OrmCache) GetAll() []*Table {
-	o.mu.RLock()
-	defer o.mu.RUnlock()
-	var result []*Table
-
-	for _, v := range o.data {
-		result = append(result, v)
-	}
-	return result
-}

cache/cache.go

@@ -0,0 +1,47 @@
+package cache
+
+import (
+	"sync"
+
+	"git.gdulai.com/gdulai/simpleorm/schema"
+)
+
+type SchemaCache struct {
+	mu   sync.RWMutex
+	data map[string]*schema.Table
+}
+
+func NewSchemaCache(tables []*schema.Table) *SchemaCache {
+	cache := &SchemaCache{
+		data: make(map[string]*schema.Table),
+	}
+	for _, table := range tables {
+		cache.add(table)
+	}
+
+	return cache
+}
+
+func (o *SchemaCache) add(table *schema.Table) {
+	o.mu.Lock()
+	defer o.mu.Unlock()
+	o.data[table.Type.Name()] = table
+}
+
+func (o *SchemaCache) Get(typeName string) (*schema.Table, bool) {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+	table, ok := o.data[typeName]
+	return table, ok
+}
+
+func (o *SchemaCache) GetAll() []*schema.Table {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+	var result []*schema.Table
+
+	for _, v := range o.data {
+		result = append(result, v)
+	}
+	return result
+}

column.go

@@ -1,65 +0,0 @@
-package simpleorm
-
-import (
-	"reflect"
-	"strings"
-)
-
-type Column struct {
-	Name      string
-	FieldName string
-	Type      string
-	Modifiers map[string]string
-}
-
-func NewColumn(name string, typ string, fieldName string, tag reflect.StructTag) Column {
-	return Column{name, typ, fieldName, determineModifiers(tag)}
-}
-
-func determineModifiers(tag reflect.StructTag) map[string]string {
-	modifiers := make(map[string]string)
-	sqlTag := tag.Get("sql")
-	if sqlTag == "" {
-		return modifiers
-	}
-
-	rawModifiers := strings.SplitSeq(sqlTag, ";")
-	for rawModifier := range rawModifiers {
-		if strings.Contains(rawModifier, "=") {
-			keyValue := strings.Split(rawModifier, "=")
-			modifiers[keyValue[0]] = keyValue[1]
-		} else {
-			modifiers[rawModifier] = ""
-		}
-	}
-	return modifiers
-}
-
-func (c *Column) ToDDL() string {
-	var ddlBuilder strings.Builder
-
-	ddlBuilder.WriteString(c.Name + " " + c.Type)
-
-	inlineMods := c.inlineModifiers()
-	for _, mod := range inlineMods {
-		ddlBuilder.WriteString(" " + mod)
-	}
-
-	return ddlBuilder.String()
-}
-
-func (c *Column) inlineModifiers() []string {
-	var mods []string
-	for k, _ := range c.Modifiers {
-		switch k {
-		case "nn":
-			mods = append(mods, "NOT NULL")
-		}
-	}
-	return mods
-}
-
-func (c *Column) IsPK() bool {
-	_, ok := c.Modifiers["pk"]
-	return ok
-}

dbconnection.go

@@ -22,6 +22,24 @@ func OpenConnection(driver string, dsn string) *DBConnection {
 	return &DBConnection{db: db, State: 1}
 }
 
+func (c *DBConnection) Exec(sql string) (sql.Result, error) {
+	// Force a real DB interaction
+	result, err := c.db.Exec(sql)
+	if err != nil {
+		log.LogFatalError("DB execution failed: %", err)
+		return nil, err
+	}
+	return result, nil
+}
+
+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

@@ -0,0 +1,514 @@
+package exec
+
+import (
+	"database/sql"
+	"errors"
+	"reflect"
+
+	"git.gdulai.com/gdulai/simpleorm"
+	"git.gdulai.com/gdulai/simpleorm/schema"
+	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 {
+		log.LogError("Failed to run DDL: %s", schema)
+		return
+	}
+
+	log.LogInfo("Executing DDL:\n%s", schema)
+
+	if _, err := conn.Exec(schema); err != nil {
+		log.LogFatalError("%", err)
+	}
+}
+
+// Wraps and represents a DB transaction.
+// Allows for all at once or separate execution of [exec.Exec] implementations.
+type Transaction struct {
+	conn       *simpleorm.DBConnection
+	executions []*Exec[any]
+	tx         *sql.Tx
+	finished   bool
+}
+
+// Creates a new [exec.Transaction].
+// Can be initialized with a set of [exec.Exec]s.
+func NewTransaction(conn *simpleorm.DBConnection, executions ...*Exec[any]) *Transaction {
+	return &Transaction{conn: conn, executions: executions, finished: false}
+}
+
+// The executions assigned to this transaction.
+func (t *Transaction) Executions() []*Exec[any] {
+	return t.executions
+}
+
+// Executes all the [exec.Exec] implementations assigned to this transactions.
+// Begins, commits or rollbacks the transaction.
+// This is a terminal operation, the [exec.Transaction] is considered finished after calling this.
+func (t *Transaction) ExecuteAtOnce() error {
+	if t.finished {
+		return errors.New("Transaction already finished.")
+	}
+
+	if t.tx == nil {
+		tx, err := t.conn.Begin()
+		t.tx = tx
+		if err != nil {
+			t.finished = true
+			return err
+		}
+	}
+
+	for _, exec := range t.executions {
+		err := (*exec).execute(nil, t.tx)
+		if err != nil {
+			rollbackErr := t.Rollback()
+			if rollbackErr != nil {
+				return rollbackErr
+			}
+			return err
+		}
+
+	}
+
+	err := t.tx.Commit()
+	if err != nil {
+		return err
+	}
+
+	t.finished = true
+	return nil
+}
+
+// Executes and assigns the passed [exec.Exec]s to the Transaction.
+// Calls rollback in case of an error.
+// This is NOT a terminal operation, transactions still has to be committed.
+func (t *Transaction) Execute(execs ...Exec[any]) error {
+	if t.finished {
+		return errors.New("Transaction already finished.")
+	}
+
+	for _, exec := range execs {
+		execPtr := &exec
+		t.executions = append(t.executions, execPtr)
+		if t.tx == nil {
+			tx, err := t.conn.Begin()
+			t.tx = tx
+			if err != nil {
+				t.finished = true
+				return err
+			}
+		}
+
+		err := (*execPtr).execute(nil, t.tx)
+		if err != nil {
+			rollbackErr := t.Rollback()
+			if rollbackErr != nil {
+				return rollbackErr
+			}
+			return err
+		}
+
+	}
+
+	return nil
+}
+
+// Finishes the transaction, commits the changes.
+// This is terminal operation.
+func (t *Transaction) Finish() error {
+	if t.finished {
+		return errors.New("Transaction already finished.")
+	}
+
+	if t.tx == nil {
+		return errors.New("Transaction is nil.")
+	}
+
+	t.tx.Commit()
+	t.finished = true
+	return nil
+}
+
+// Rollbacks and aborts the transaction.
+// This is a terminal operation.
+func (t *Transaction) Rollback() error {
+	if t.finished {
+		return errors.New("Transaction already finished.")
+	}
+
+	if t.tx == nil {
+		return errors.New("Transaction is nil.")
+	}
+
+	rollbackErr := t.tx.Rollback()
+	if rollbackErr != nil {
+		return rollbackErr
+	}
+	t.finished = true
+	return nil
+}
+
+type Exec[T any] interface {
+	Execute(conn *simpleorm.DBConnection) 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) {
+	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, whereStmt: whereStmt, args: args}, nil
+}
+
+func (s *Select[T]) Results() []T {
+	return s.results
+}
+
+func (s *Select[T]) Execute(conn *simpleorm.DBConnection) error {
+	return s.execute(conn, nil)
+}
+
+func (s *Select[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error {
+	// Reinit the results, new execution
+	s.results = []T{}
+	dml, err := s.target.GetSelectDML()
+	if err != nil {
+		return err
+	}
+
+	if s.whereStmt != "" {
+		dml += " WHERE " + s.whereStmt
+	}
+
+	log.LogDebug("Preparing sql: %s, with args: %s", dml, s.args)
+
+	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(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)
+			}
+		}
+		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
+}
+
+type Insert[T any] struct {
+	target   schema.Table
+	toInsert []T
+	results  []T
+}
+
+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
+}
+
+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 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)
+
+	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
+}
+
+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) 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 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.LogInfo("%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
+}
+
+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) 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 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.LogInfo("%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
+
+}
+
+func createSelectResultContainer(t schema.Table) []any {
+	vals := make([]any, t.Type.NumField())
+	for i := range vals {
+		switch t.Type.Field(i).Type.Kind().String() {
+		case "string":
+			var fieldContainer string
+			vals[i] = &fieldContainer
+		case "int", "bool":
+			var fieldContainer int
+			vals[i] = &fieldContainer
+		case "int64", "time.Time":
+			var fieldContainer int64
+			vals[i] = &fieldContainer
+		}
+	}
+	return vals
+}
+
+func prepareParams(src any, t schema.Table) []any {
+	var params []any
+	for _, col := range t.Columns {
+		_, ok := col.Modifiers["pk"]
+		if ok && t.IsPkAuto() {
+			continue
+		}
+		field, ok := t.Type.FieldByName(col.FieldName)
+		if !ok {
+			continue
+		}
+		fieldValue := reflect.ValueOf(src).FieldByIndex(field.Index)
+
+		params = append(params, col.Encode(fieldValue))
+	}
+	return params
+}
+
+func getPk(src any, t schema.Table) ([]any, error) {
+	var values []any
+	for _, constraint := range t.Constraints {
+		if constraint.Type == "pk" {
+			for _, col := range constraint.Columns {
+				field, ok := t.Type.FieldByName(col.FieldName)
+				if !ok {
+					continue
+
+				}
+				fieldValue := reflect.ValueOf(src).FieldByIndex(field.Index)
+				values = append(values, fieldValue.Interface())
+			}
+		}
+	}
+	if len(values) == 0 {
+		return nil, errors.New("Could not determine pk column!")
+	}
+
+	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
+}

main_test.go

@@ -1,45 +0,0 @@
-package simpleorm_test
-
-import (
-	"os"
-	"testing"
-
-	_ "github.com/mattn/go-sqlite3"
-	log "gitlab.com/gdulai/simpleloglvl"
-)
-
-type Test struct {
-	ID          int    `sql:"pk"`
-	Int64Field  int64  `sql:"nn"`
-	IntField    int    `sql:"nn"`
-	StringField string `sql:"nn"`
-}
-
-type TestWithFk struct {
-	ID     int `sql:"pk"`
-	TestID int `sql:"nn;fk=Test.ID"`
-}
-
-type TestWithFkAndFkId struct {
-	ID     int `sql:"pk"`
-	TestID int `sql:"nn;fk=Test.ID;fk_id=custom_fk"`
-}
-
-type TestWithCompositePk struct {
-	ID   int    `sql:"nn;pk"`
-	Name string `sql:"nn;pk"`
-}
-
-type TestWithCompositeFk struct {
-	ID              int    `sql:"nn;pk"`
-	CompositeFkId   int    `sql:"nn;fk=TestWithCompositePk.ID;"`
-	CompositeFkName string `sql:"nn;fk=TestWithCompositePk.Name;"`
-}
-
-func TestMain(m *testing.M) {
-	log.SetupLogs("Info")
-
-	code := m.Run()
-
-	os.Exit(code)
-}

orm.go

@@ -6,22 +6,26 @@ import (
 	"reflect"
 	"strings"
 
+	"git.gdulai.com/gdulai/simpleorm/cache"
+	"git.gdulai.com/gdulai/simpleorm/parser"
+	"git.gdulai.com/gdulai/simpleorm/schema"
+
 	log "gitlab.com/gdulai/simpleloglvl"
 )
 
 // Type to access the ORM functionalities in a structured manner-
 type ORM struct {
-	cache *OrmCache
+	cache *cache.SchemaCache
 }
 
 // Inits the ORM library.
 // Param objs is an array which should be an array of the types which describe the tables.
 func NewORM(objs ...any) *ORM {
-	var parsers []*Parser
+	var parsers []*parser.Parser
-	var tables []*Table
+	var tables []*schema.Table
 	for _, obj := range objs {
 		log.LogDebug("[ORM] Mapping type for: %s", reflect.TypeOf(obj).Name())
-		parser := NewParser(obj)
+		parser := parser.NewParser(obj)
 		parsers = append(parsers, parser)
 		tables = append(tables, parser.ParseColumns())
 	}
@@ -29,7 +33,7 @@ func NewORM(objs ...any) *ORM {
 	log.LogDebug("[ORM] Tables initiated, creating cache.")
 
 	// Create cache with the initialized tables
-	cache := NewOrmCache(tables)
+	cache := cache.NewSchemaCache(tables)
 
 	log.LogDebug("[ORM] Cache created.")
 
@@ -44,7 +48,7 @@ func NewORM(objs ...any) *ORM {
 }
 
 // Builds the DDL and returns it as a string
-func (orm ORM) CreateDDL() string {
+func (orm *ORM) CreateSchema() (string, error) {
 	var ddl strings.Builder
 
 	tables := orm.cache.GetAll()
@@ -53,8 +57,15 @@ func (orm ORM) CreateDDL() string {
 		if i != 0 {
 			ddl.WriteString("\n")
 		}
-		ddl.WriteString(table.ToDDL())
+		tableDdl, err := table.GetDDL()
+		if err != nil {
+			return "", err
 		}
+		ddl.WriteString(tableDdl)
+	}
+	return ddl.String(), nil
+}
 
-	return ddl.String()
+func (orm *ORM) Cache() *cache.SchemaCache {
+	return orm.cache
 }

ormexec.go

@@ -1,191 +0,0 @@
-package simpleorm
-
-import (
-	"database/sql"
-	"errors"
-	"reflect"
-
-	log "gitlab.com/gdulai/simpleloglvl"
-)
-
-type ORMExec[T any] struct {
-	orm  *ORM
-	conn *DBConnection
-}
-
-func CreateExecution[T any](orm *ORM, conn *DBConnection) ORMExec[T] {
-	return ORMExec[T]{orm: orm, conn: conn}
-}
-
-func InitDB(conn *DBConnection, orm *ORM) {
-	// Force a real DB interaction
-	if _, err := conn.db.Exec(orm.CreateDDL()); err != nil {
-		log.LogFatalError("%", err)
-	}
-}
-
-func (ormExec ORMExec[T]) Select(desc T, whereStmt string, args ...any) ([]T, error) {
-	lookup := reflect.TypeOf(desc).Name()
-	table, ok := ormExec.orm.cache.Get(lookup)
-	if !ok {
-		return []T{}, errors.New("Failed to get descriptor from cache! " + lookup)
-	}
-	sqlStr := table.ToSelectDML()
-	if whereStmt != "" {
-		sqlStr += " WHERE " + whereStmt
-	}
-	log.LogDebug("Preparing sql: %s, with args: %s", sqlStr, args)
-
-	stmt, err := ormExec.conn.db.Prepare(sqlStr)
-	if err != nil {
-		return nil, err
-	}
-	defer stmt.Close()
-
-	log.LogDebug("Executing statement: %s", stmt)
-
-	var rows *sql.Rows
-	if len(args) == 0 {
-		rows, err = stmt.Query()
-	} else {
-		// Flattent args to make sure it can be parsed correctly
-		var flatArgs []any
-		for _, a := range args {
-			if s, ok := a.([]any); ok {
-				flatArgs = append(flatArgs, s...)
-			} else {
-				flatArgs = append(flatArgs, a)
-			}
-		}
-		rows, err = stmt.Query(flatArgs...)
-
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	rowContainer := table.createSelectResultContainer()
-
-	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 {
-			parsedResult.Elem().Field(i).Set(reflect.Indirect(reflect.ValueOf(fieldVal)))
-		}
-		parsedObj := reflect.Indirect(parsedResult).Interface().(T)
-		results = append(results, parsedObj)
-	}
-
-	return results, nil
-}
-
-func (ormExec ORMExec[T]) Insert(src ...T) error {
-	typeName := reflect.TypeOf(src[0]).Name()
-	table, ok := ormExec.orm.cache.Get(typeName)
-	if !ok {
-		return errors.New("Could not find table for type " + typeName)
-	}
-
-	sql := table.ToInsertDML(len(src))
-	var params []any
-	for i := range len(src) {
-		actualParams := table.prepareParams(src[i])
-		if len(params) == 0 {
-			params = make([]any, len(src)*len(actualParams))
-		}
-		for j := range actualParams {
-			params[(i*len(actualParams))+j] = actualParams[j]
-		}
-	}
-
-	log.LogInfo("%s [%s]", sql, params)
-
-	stmt, err := ormExec.conn.db.Prepare(sql)
-	if err != nil {
-		return err
-	}
-	defer stmt.Close()
-
-	result, err := stmt.Exec(params...)
-	if err != nil {
-		return err
-	} else {
-		rowsAffected, _ := result.RowsAffected()
-		log.LogInfo("Inserted %s row", rowsAffected)
-	}
-	return nil
-}
-
-func (ormExec ORMExec[T]) Update(src T) error {
-	typeName := reflect.TypeOf(src).Name()
-	table, ok := ormExec.orm.cache.Get(reflect.TypeOf(src).Name())
-	if !ok {
-		return errors.New("Could not find table for type " + typeName)
-	}
-
-	sql := table.ToUpdateDML(src)
-	params := table.prepareParams(src)
-
-	pk, err := table.getPk(src)
-	if err != nil {
-		return err
-	}
-	// Put the pk back at the end
-	params = append(params, pk)
-
-	log.LogInfo("%s [%s]", sql, params)
-
-	stmt, err := ormExec.conn.db.Prepare(sql)
-	if err != nil {
-		return err
-	}
-	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
-}
-
-func (ormExec ORMExec[T]) Delete(src T) error {
-	typeName := reflect.TypeOf(src).Name()
-	table, ok := ormExec.orm.cache.Get(reflect.TypeOf(src).Name())
-	if !ok {
-		return errors.New("Could not find table for type " + typeName)
-	}
-
-	sql := table.ToDeleteDML(src)
-	pk, err := table.getPk(src)
-	if err != nil {
-		return err
-	}
-
-	log.LogInfo("%s [%s]", sql, pk)
-
-	stmt, err := ormExec.conn.db.Prepare(sql)
-	if err != nil {
-		return err
-	}
-	defer stmt.Close()
-
-	result, err := stmt.Exec(pk)
-	if err != nil {
-		return err
-	} else {
-		rowsAffected, _ := result.RowsAffected()
-		log.LogInfo("Deleted %s row", rowsAffected)
-	}
-	return nil
-}

ormexec_test.go

@@ -1,114 +0,0 @@
-package simpleorm_test
-
-import (
-	"os"
-	"simpleorm"
-	"testing"
-
-	log "gitlab.com/gdulai/simpleloglvl"
-)
-
-func TestSelectEmpty(t *testing.T) {
-	// GIVEN
-	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
-	defer cleanUp("test.db", conn)
-
-	orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
-		TestWithCompositePk{}, TestWithCompositeFk{})
-
-	simpleorm.InitDB(conn, orm)
-
-	exec := simpleorm.CreateExecution[Test](orm, conn)
-	// WHEN
-	res, err := exec.Select(Test{}, "")
-	// THEN
-	if err != nil {
-		log.LogError("Select failure. %s", err)
-		t.Fail()
-	}
-	if len(res) > 0 {
-		log.LogError("Expected empty result.")
-		t.Fail()
-	}
-}
-
-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{})
-
-	simpleorm.InitDB(conn, orm)
-
-	exec := simpleorm.CreateExecution[Test](orm, conn)
-
-	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
-	err := exec.Insert(testObj)
-	if err != nil {
-		log.LogError("Insert failure. %s", err)
-		t.Fail()
-	}
-	// WHEN
-	res, err := exec.Select(Test{}, "")
-	// THEN
-	if err != nil {
-		log.LogError("Select failure. %s", err)
-		t.Fail()
-	}
-	if len(res) != 1 {
-		log.LogError("Selec test failed. Expected: 1, Actual: %s", len(res))
-		t.Fail()
-	}
-
-	singleRes := res[0]
-	if singleRes.ID != 1 || singleRes.Int64Field != 54 || singleRes.IntField != 12 || singleRes.StringField != "asdf" {
-		log.LogError("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{})
-
-	simpleorm.InitDB(conn, orm)
-
-	exec := simpleorm.CreateExecution[Test](orm, conn)
-
-	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
-	testObjSecond := Test{Int64Field: 12, IntField: 54, StringField: "fdsa"}
-	err := exec.Insert(testObj, testObjSecond)
-	if err != nil {
-		log.LogError("Insert failure. %s", err)
-		t.Fail()
-	}
-	// WHEN
-	res, err := exec.Select(Test{}, "string_field = ?", "fdsa")
-	// THEN
-	if err != nil {
-		log.LogError("Select failure. %s", err)
-		t.Fail()
-	}
-	if len(res) != 1 {
-		log.LogError("Select test failed. Expected: 1, Actual: %s", len(res))
-		t.Fail()
-	}
-
-	singleRes := res[0]
-	if singleRes.ID != 2 || singleRes.Int64Field != 12 || singleRes.IntField != 54 || singleRes.StringField != "fdsa" {
-		log.LogError("Invalid result. Expected: %s, Actual: %s", testObjSecond, singleRes)
-		t.Fail()
-	}
-}
-
-func cleanUp(dbFile string, conn *simpleorm.DBConnection) {
-	conn.Close()
-	os.Remove(dbFile)
-}

parser/parser.go

@@ -1,16 +1,18 @@
-package simpleorm
+package parser
 
 import (
 	"reflect"
 	"strings"
-	"unicode"
 
+	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 *Table
+	Table *schema.Table
 }
 
 func NewParser[T any](obj T) *Parser {
@@ -19,13 +21,13 @@ func NewParser[T any](obj T) *Parser {
 }
 
 // This is step 1 of the parsing, it creates the table instance and
-func (p *Parser) ParseColumns() *Table {
+func (p *Parser) ParseColumns() *schema.Table {
-	table := Table{Name: camelToSnake(p.typ.Name()), Type: p.typ}
+	table := schema.Table{Name: util.CamelToSnake(p.typ.Name()), Type: p.typ}
 
-	var columns []Column
+	var columns []schema.Column
 	for field := range p.typ.Fields() {
 		field := field
-		col := NewColumn(camelToSnake((field.Name)), field.Name, determineType(field.Type), field.Tag)
+		col := schema.NewColumn(util.CamelToSnake((field.Name)), field.Name, determineType(field.Type), field.Tag)
 		columns = append(columns, col)
 	}
 
@@ -34,9 +36,9 @@ func (p *Parser) ParseColumns() *Table {
 	return p.Table
 }
 
-func (p *Parser) ParseConstraints(cache *OrmCache) {
+func (p *Parser) ParseConstraints(cache *cache.SchemaCache) {
-	pkConstraint := Constraint{Name: "pk_" + strings.ToLower(p.Table.Name), Type: "pk"}
+	pkConstraint := schema.Constraint{Name: "pk_" + strings.ToLower(p.Table.Name), Type: "pk"}
-	fkConstraints := make(map[string]Constraint)
+	fkConstraints := make(map[string]schema.Constraint)
 	for _, col := range p.Table.Columns {
 		_, ok := col.Modifiers["pk"]
 		if ok {
@@ -63,7 +65,7 @@ func (p *Parser) ParseConstraints(cache *OrmCache) {
 
 		fkConstraint, ok := fkConstraints[fkId]
 		if !ok {
-			fkConstraint = Constraint{Name: fkId, Type: "fk", RefTable: refTable}
+			fkConstraint = schema.Constraint{Name: fkId, Type: "fk", RefTable: refTable}
 		}
 
 		fkConstraint.Columns = append(fkConstraint.Columns, col)
@@ -89,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"
@@ -97,18 +99,3 @@ func determineType(typ reflect.Type) string {
 
 	return "VARCHAR(255)"
 }
-
-func camelToSnake(str string) string {
-	var snake strings.Builder
-	isPrevUpper := true
-	for _, c := range str {
-		if unicode.IsUpper(c) && !isPrevUpper {
-			snake.WriteString("_" + string(unicode.ToUpper(c)))
-			isPrevUpper = true
-		} else {
-			snake.WriteString(string(unicode.ToUpper(c)))
-			isPrevUpper = unicode.IsUpper(c)
-		}
-	}
-	return snake.String()
-}

repository/repository.go

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

schema/column.go

@@ -0,0 +1,126 @@
+package schema
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"time"
+)
+
+type Column struct {
+	Name      string
+	FieldName string
+	Type      string
+	Modifiers map[string]string
+}
+
+func NewColumn(name string, typ string, fieldName string, tag reflect.StructTag) Column {
+	return Column{name, typ, fieldName, determineModifiers(tag)}
+}
+
+func determineModifiers(tag reflect.StructTag) map[string]string {
+	modifiers := make(map[string]string)
+	sqlTag := tag.Get("sql")
+	if sqlTag == "" {
+		return modifiers
+	}
+
+	rawModifiers := strings.SplitSeq(sqlTag, ";")
+	for rawModifier := range rawModifiers {
+		if strings.Contains(rawModifier, "=") {
+			keyValue := strings.Split(rawModifier, "=")
+			modifiers[keyValue[0]] = keyValue[1]
+		} else {
+			modifiers[rawModifier] = ""
+		}
+	}
+	return modifiers
+}
+
+func (c *Column) GetDDL() (string, error) {
+	var ddlBuilder strings.Builder
+
+	ddlBuilder.WriteString(c.Name + " " + c.Type)
+
+	inlineMods := c.inlineModifiers()
+	for _, mod := range inlineMods {
+		ddlBuilder.WriteString(" " + mod)
+	}
+
+	return ddlBuilder.String(), nil
+}
+
+func (c *Column) inlineModifiers() []string {
+	var mods []string
+	for k := range c.Modifiers {
+		switch k {
+		case "nn":
+			mods = append(mods, "NOT NULL")
+		}
+	}
+	return mods
+}
+
+func (c Column) GetSelectDML() (string, error) {
+	return c.Name, nil
+}
+
+func (c Column) GetInsertDML() (string, error) {
+	return c.Name, nil
+}
+
+func (c Column) GetUpdateDML() (string, error) {
+	return c.Name + " = ?", nil
+}
+
+func (Column) GetDeleteDML() (string, error) {
+	return "", errors.New("No delete DML for columns")
+}
+
+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/constraint.go

@@ -1,6 +1,9 @@
-package simpleorm
+package schema
 
-import "strings"
+import (
+	"errors"
+	"strings"
+)
 
 type Constraint struct {
 	Name       string
@@ -10,18 +13,18 @@ type Constraint struct {
 	RefColumns []Column
 }
 
-func (c *Constraint) ToDDL() string {
+func (c *Constraint) GetDDL() (string, error) {
 	switch c.Type {
 	case "pk":
-		return c.toPkDDL()
+		return c.getPkDDL(), nil
 	case "fk":
-		return c.toFkDDL()
+		return c.getFkDDL(), nil
 	}
 
-	return ""
+	return "", errors.New("Unimplemented constraing: " + c.Type)
 }
 
-func (c *Constraint) toPkDDL() string {
+func (c *Constraint) getPkDDL() string {
 	var ddl strings.Builder
 	ddl.WriteString("CONSTRAINT " + c.Name + " PRIMARY KEY(")
 	for i, col := range c.Columns {
@@ -34,7 +37,7 @@ func (c *Constraint) toPkDDL() string {
 	return ddl.String()
 }
 
-func (c *Constraint) toFkDDL() string {
+func (c *Constraint) getFkDDL() string {
 	var ddl strings.Builder
 	ddl.WriteString("CONSTRAINT " + c.Name + " FOREIGN KEY(")
 
@@ -57,3 +60,19 @@ func (c *Constraint) toFkDDL() string {
 
 	return ddl.String()
 }
+
+func (Constraint) GetSelectDML() (string, error) {
+	return "", errors.New("No DML for constraints")
+}
+
+func (Constraint) GetInsertDML() (string, error) {
+	return "", errors.New("No DML for constraints")
+}
+
+func (Constraint) GetUpdateDML() (string, error) {
+	return "", errors.New("No DML for constraints")
+}
+
+func (Constraint) GetDeleteDML() (string, error) {
+	return "", errors.New("No DML for constraints")
+}

schema/schema.go

@@ -0,0 +1,11 @@
+package schema
+
+// Interface that descibes a DB schema descripotor part.
+// eg.: Table, Column, Constraints etc.
+type SchemaDescriptor interface {
+	getDDL() (string, error)
+	GetSelectDML() (string, error)
+	GetInsertDML(count int) (string, error)
+	GetUpdateDML() (string, error)
+	GetDeleteDML(count int) (string, error)
+}

schema/table.go

@@ -0,0 +1,190 @@
+package schema
+
+import (
+	"reflect"
+	"strings"
+
+	"git.gdulai.com/gdulai/simpleorm/util"
+)
+
+type Table struct {
+	Name        string
+	Type        reflect.Type
+	Columns     []Column
+	Constraints []Constraint
+}
+
+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 {
+		if i != 0 {
+			ddl.WriteString(", ")
+		}
+		colDdl, err := col.GetDDL()
+		if err != nil {
+			return "", err
+		}
+		ddl.WriteString(colDdl)
+	}
+	for _, constr := range t.Constraints {
+		constrDdl, err := constr.GetDDL()
+		if err != nil {
+			return "", err
+		}
+		ddl.WriteString(", " + constrDdl)
+	}
+
+	ddl.WriteString(");")
+	return ddl.String(), nil
+}
+
+func (t Table) GetSelectDML() (string, error) {
+	var dml strings.Builder
+	dml.WriteString("SELECT ")
+
+	for i, col := range t.Columns {
+		if i != 0 {
+			dml.WriteString(", ")
+		}
+		colDml, err := col.GetSelectDML()
+		if err != nil {
+			return "", err
+		}
+		dml.WriteString(colDml)
+	}
+
+	dml.WriteString(" FROM " + t.Name)
+	return dml.String(), nil
+}
+
+func (t Table) GetInsertDML(count int) (string, error) {
+	var dml strings.Builder
+	dml.WriteString("INSERT INTO " + util.CamelToSnake(t.Type.Name()) + " (")
+
+	columnsLen := len(t.Columns)
+	effectiveColumnsLen := 0
+	for i, col := range t.Columns {
+		_, ok := col.Modifiers["pk"]
+		if ok && t.IsPkAuto() {
+			continue
+		}
+
+		colDml, err := col.GetInsertDML()
+		if err != nil {
+			return "", err
+		}
+
+		dml.WriteString(colDml)
+		if i != columnsLen-1 {
+			dml.WriteString(", ")
+		}
+		effectiveColumnsLen++
+	}
+
+	dml.WriteString(") VALUES")
+
+	for i := range count {
+		if i != 0 {
+			dml.WriteString(", ")
+		}
+		for j := range effectiveColumnsLen {
+			if j == 0 {
+				dml.WriteString("(")
+			}
+			if j != effectiveColumnsLen-1 {
+				dml.WriteString("?, ")
+			} else {
+				dml.WriteString("?)")
+			}
+		}
+	}
+
+	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 ")
+
+	colLen := len(t.Columns)
+	var pkColumns []string
+	// Colum names
+	for i, col := range t.Columns {
+		modifiers := col.Modifiers
+
+		_, ok := modifiers["pk"]
+		if ok {
+			pkColumns = append(pkColumns, col.Name)
+			if t.IsPkAuto() {
+				continue
+			}
+		}
+
+		colDml, err := col.GetUpdateDML()
+		if err != nil {
+			return "", err
+		}
+
+		if i != colLen-1 {
+			dml.WriteString(colDml + ", ")
+		} else {
+			dml.WriteString(colDml + " ")
+		}
+	}
+
+	dml.WriteString("WHERE ")
+
+	for i, pkCol := range pkColumns {
+		if i != 0 {
+			dml.WriteString(" AND ")
+		}
+		dml.WriteString(pkCol + " = ?")
+	}
+
+	return dml.String(), nil
+}
+
+func (t Table) GetDeleteDML(count int) (string, error) {
+	var dml strings.Builder
+	dml.WriteString("DELETE FROM " + t.Name + " WHERE ")
+
+	for _, col := range t.Columns {
+		modifiers := col.Modifiers
+
+		_, ok := modifiers["pk"]
+		if ok {
+			if count > 1 {
+				dml.WriteString(col.Name + " IN (")
+			} else {
+				dml.WriteString(col.Name + " = ")
+			}
+		}
+	}
+
+	for i := range count {
+		if i != 0 {
+			dml.WriteString(", ")
+		}
+		dml.WriteString("?")
+	}
+
+	if count > 1 {
+		dml.WriteString(")")
+	}
+
+	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
+}

table.go

@@ -1,185 +0,0 @@
-package simpleorm
-
-import (
-	"errors"
-	"reflect"
-	"strings"
-	"time"
-)
-
-type Table struct {
-	Name        string
-	Type        reflect.Type
-	Columns     []Column
-	Constraints []Constraint
-}
-
-func (t Table) ToDDL() string {
-	var ddl strings.Builder
-	ddl.WriteString("CREATE TABLE IF NOT EXISTS " + t.Name + " (")
-	for i, col := range t.Columns {
-		if i != 0 {
-			ddl.WriteString(", ")
-		}
-		ddl.WriteString(col.ToDDL())
-	}
-	for _, constr := range t.Constraints {
-		ddl.WriteString(", " + constr.ToDDL())
-	}
-
-	ddl.WriteString(");")
-	return ddl.String()
-}
-
-func (t Table) ToSelectDML() string {
-	var dml strings.Builder
-	dml.WriteString("SELECT ")
-
-	for i, col := range t.Columns {
-		if i != 0 {
-			dml.WriteString(", ")
-		}
-		dml.WriteString(col.Name)
-	}
-
-	dml.WriteString(" FROM " + t.Name)
-	return dml.String()
-}
-
-func (t Table) ToInsertDML(count int) string {
-	var dml strings.Builder
-	dml.WriteString("INSERT INTO " + camelToSnake(t.Type.Name()) + " (")
-
-	columnsLen := len(t.Columns)
-	effectiveColumnsLen := 0
-	for i, col := range t.Columns {
-		_, ok := col.Modifiers["pk"]
-		if ok {
-			continue
-		}
-
-		dml.WriteString(col.Name)
-		if i != columnsLen-1 {
-			dml.WriteString(", ")
-		}
-		effectiveColumnsLen++
-	}
-
-	dml.WriteString(") VALUES")
-
-	for i := range count {
-		if i != 0 {
-			dml.WriteString(", ")
-		}
-		for j := range effectiveColumnsLen {
-			if j == 0 {
-				dml.WriteString("(")
-			}
-			if j != effectiveColumnsLen-1 {
-				dml.WriteString("?, ")
-			} else {
-				dml.WriteString("?)")
-			}
-		}
-	}
-
-	return dml.String()
-}
-
-func (t Table) ToUpdateDML(src any) string {
-	var dml strings.Builder
-	dml.WriteString("UPDATE  " + camelToSnake(t.Type.Name()) + " SET ")
-
-	var pkCol string
-	// Colum names
-	for i := 0; i < t.Type.NumField(); i++ {
-		field := t.Type.Field(i)
-		modifiers := determineModifiers(field.Tag)
-
-		_, ok := modifiers["pk"]
-		if ok {
-			pkCol = camelToSnake(field.Name)
-			continue
-		}
-
-		if i != t.Type.NumField()-1 {
-			dml.WriteString(camelToSnake(field.Name) + " = ?, ")
-		} else {
-			dml.WriteString(camelToSnake(field.Name) + " = ? ")
-		}
-
-	}
-
-	dml.WriteString("WHERE " + pkCol + " = ?")
-
-	return dml.String()
-}
-
-func (t Table) ToDeleteDML(src any) string {
-	var dml strings.Builder
-	dml.WriteString("DELETE FROM " + camelToSnake(t.Type.Name()) + " WHERE ")
-
-	for i := 0; i < t.Type.NumField(); i++ {
-		field := t.Type.Field(i)
-		modifiers := determineModifiers(field.Tag)
-		_, ok := modifiers["pk"]
-		if ok {
-			dml.WriteString(camelToSnake(field.Name) + " = ?")
-			return dml.String()
-		}
-	}
-
-	return ""
-}
-
-func (t Table) createSelectResultContainer() []any {
-	vals := make([]any, t.Type.NumField())
-	for i := range vals {
-		switch t.Type.Field(i).Type.Kind().String() {
-		case "string":
-			var fieldContainer string
-			vals[i] = &fieldContainer
-		case "int":
-			var fieldContainer int
-			vals[i] = &fieldContainer
-		case "int64", "time.Time":
-			var fieldContainer int64
-			vals[i] = &fieldContainer
-		}
-	}
-	return vals
-}
-
-func (t Table) prepareParams(src any) []any {
-	var params []any
-	for i := 0; i < t.Type.NumField(); i++ {
-		field := t.Type.Field(i)
-		modifiers := determineModifiers(field.Tag)
-		_, ok := modifiers["pk"]
-		if ok {
-			continue
-		}
-		typStr := field.Type.String()
-		switch typStr {
-		case "time.Time":
-			time := reflect.ValueOf(src).Field(i).Interface().(time.Time)
-			params = append(params, time.UnixMilli())
-		default:
-			params = append(params, reflect.ValueOf(src).Field(i).Interface())
-		}
-	}
-
-	return params
-}
-
-func (t Table) getPk(src any) (any, error) {
-	for i := 0; i < t.Type.NumField(); i++ {
-		field := t.Type.Field(i)
-		modifiers := determineModifiers(field.Tag)
-		_, ok := modifiers["pk"]
-		if ok {
-			return reflect.ValueOf(src).Field(i).Interface(), nil
-		}
-	}
-	return nil, errors.New("Could not determine pk column!")
-}

test/exec_test.go

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

test/main_test.go

@@ -0,0 +1,80 @@
+package simpleorm_test
+
+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"
+)
+
+type Test struct {
+	ID          int    `sql:"pk"`
+	Int64Field  int64  `sql:"nn"`
+	IntField    int    `sql:"nn"`
+	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"`
+}
+
+type TestWithFkAndFkId struct {
+	ID     int `sql:"pk"`
+	TestID int `sql:"nn;fk=Test.ID;fk_id=custom_fk"`
+}
+
+type TestWithCompositePk struct {
+	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")
+
+	code := m.Run()
+
+	os.Exit(code)
+}
+
+func testSetup() (*simpleorm.ORM, *simpleorm.DBConnection) {
+	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
+
+	orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
+		TestWithCompositePk{}, TestWithCompositeFk{}, TestWithBool{}, TestWithTime{})
+	exec.ExecuteDDL(conn, orm)
+
+	return orm, conn
+}
+
+func cleanUp(dbFile string, conn *simpleorm.DBConnection) {
+	conn.Close()
+	os.Remove(dbFile)
+}

test/repository_test.go

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

test/schema_test.go

@@ -1,10 +1,10 @@
 package simpleorm_test
 
 import (
-	"simpleorm"
 	"strconv"
 	"testing"
 
+	simpleorm "git.gdulai.com/gdulai/simpleorm"
 	log "gitlab.com/gdulai/simpleloglvl"
 )
 
@@ -13,8 +13,13 @@ func TestParseSimple(t *testing.T) {
 	// GIVEN
 	orm := simpleorm.NewORM(Test{})
 	// WHEN
-	ddl := orm.CreateDDL()
+	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 (ID INTEGER, INT64_FIELD BIGINT NOT NULL, INT_FIELD INTEGER NOT NULL, STRING_FIELD TEXT NOT NULL, CONSTRAINT pk_test PRIMARY KEY(ID));"
 	if ddl != expectedDdl {
 		log.LogError("Incorrect DDL.\nExpected\n%s\nActual\n%s", expectedDdl, ddl)
@@ -29,8 +34,13 @@ func TestParseFk(t *testing.T) {
 	// GIVEN
 	orm := simpleorm.NewORM(Test{}, TestWithFk{})
 	// WHEN
-	ddl := orm.CreateDDL()
+	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 (ID INTEGER, INT64_FIELD BIGINT NOT NULL, INT_FIELD INTEGER NOT NULL, STRING_FIELD TEXT NOT NULL, CONSTRAINT pk_test PRIMARY KEY(ID));\n" +
 			"CREATE TABLE IF NOT EXISTS TEST_WITH_FK (ID INTEGER, TEST_ID INTEGER NOT NULL, CONSTRAINT pk_test_with_fk PRIMARY KEY(ID), CONSTRAINT fk_test FOREIGN KEY(TEST_ID) REFERENCES TEST(ID));"
@@ -46,8 +56,14 @@ func TestParseFkAndFkId(t *testing.T) {
 	// GIVEN
 	orm := simpleorm.NewORM(Test{}, TestWithFkAndFkId{})
 	// WHEN
-	ddl := orm.CreateDDL()
+	// 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 (ID INTEGER, INT64_FIELD BIGINT NOT NULL, INT_FIELD INTEGER NOT NULL, STRING_FIELD TEXT NOT NULL, CONSTRAINT pk_test PRIMARY KEY(ID));\n" +
 			"CREATE TABLE IF NOT EXISTS TEST_WITH_FK_AND_FK_ID (ID INTEGER, TEST_ID INTEGER NOT NULL, CONSTRAINT pk_test_with_fk_and_fk_id PRIMARY KEY(ID), CONSTRAINT custom_fk FOREIGN KEY(TEST_ID) REFERENCES TEST(ID));"
@@ -62,8 +78,13 @@ func TestParseCompositePk(t *testing.T) {
 	// GIVEN
 	orm := simpleorm.NewORM(TestWithCompositePk{})
 	// WHEN
-	ddl := orm.CreateDDL()
+	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_COMPOSITE_PK (ID INTEGER NOT NULL, NAME TEXT NOT NULL, CONSTRAINT pk_test_with_composite_pk PRIMARY KEY(ID, NAME));"
 	if ddl != expectedDdl {
 		log.LogError("Incorrect DDL.\nExpected\n%s\nActual\n%s", expectedDdl, ddl)
@@ -76,8 +97,13 @@ func TestParseCompositeFk(t *testing.T) {
 	// GIVEN
 	orm := simpleorm.NewORM(TestWithCompositePk{}, TestWithCompositeFk{})
 	// WHEN
-	ddl := orm.CreateDDL()
+	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_COMPOSITE_PK (ID INTEGER NOT NULL, NAME TEXT NOT NULL, CONSTRAINT pk_test_with_composite_pk PRIMARY KEY(ID, NAME));\n" +
 			"CREATE TABLE IF NOT EXISTS TEST_WITH_COMPOSITE_FK (ID INTEGER NOT NULL, COMPOSITE_FK_ID INTEGER NOT NULL, COMPOSITE_FK_NAME TEXT NOT NULL, CONSTRAINT pk_test_with_composite_fk PRIMARY KEY(ID), CONSTRAINT fk_test_with_composite_pk FOREIGN KEY(COMPOSITE_FK_ID, COMPOSITE_FK_NAME) REFERENCES TEST_WITH_COMPOSITE_PK(ID, NAME));"

util/util.go

@@ -0,0 +1,21 @@
+package util
+
+import (
+	"strings"
+	"unicode"
+)
+
+func CamelToSnake(str string) string {
+	var snake strings.Builder
+	isPrevUpper := true
+	for _, c := range str {
+		if unicode.IsUpper(c) && !isPrevUpper {
+			snake.WriteString("_" + string(unicode.ToUpper(c)))
+			isPrevUpper = true
+		} else {
+			snake.WriteString(string(unicode.ToUpper(c)))
+			isPrevUpper = unicode.IsUpper(c)
+		}
+	}
+	return snake.String()
+}