WIP: Insert sets PK

WIP: Insert sets PK

exec/exec.go

@@ -25,13 +25,14 @@ func ExecuteDDL(conn *simpleorm.DBConnection, orm *simpleorm.ORM) {
 }
 
 type Exec[T any] interface {
-	Execute(conn *simpleorm.DBConnection) ([]T, error)
+	Execute(conn *simpleorm.DBConnection) error
 }
 
 type Select[T any] struct {
 	target    schema.Table
 	whereStmt string
 	args      []any
+	result    []T
 }
 
 func CreateSelect[T any](orm *simpleorm.ORM, whereStmt string, args ...any) (Select[T], error) {
@@ -43,10 +44,14 @@ 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]) GetResult() []T {
+	return s.result
+}
+
+func (s Select[T]) Execute(conn *simpleorm.DBConnection) error {
 	dml, err := s.target.GetSelectDML()
 	if err != nil {
-		return []T{}, err
+		return err
 	}
 
 	if s.whereStmt != "" {
@@ -57,7 +62,7 @@ func (s Select[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 
 	stmt, err := conn.Prepare(dml)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	defer stmt.Close()
 
@@ -81,17 +86,15 @@ func (s Select[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 	}
 
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	rowContainer := createSelectResultContainer(s.target)
 
-	var results []T
-
 	for rows.Next() {
 		err = rows.Scan(rowContainer...)
 		if err != nil {
-			return nil, err
+			return err
 		}
 
 		targetType := s.target.Type
@@ -106,15 +109,16 @@ func (s Select[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 			targetField.Set(decoded)
 		}
 		parsedObj := reflect.Indirect(parsedResult).Interface().(T)
-		results = append(results, parsedObj)
+		s.result = append(s.result, parsedObj)
 	}
 
-	return results, nil
+	return nil
 }
 
 type Insert[T any] struct {
-	target   schema.Table
-	toInsert []T
+	target       schema.Table
+	toInsert     []T
+	lastInsertId int64
 }
 
 func NewInsert[T any](orm *simpleorm.ORM, toInsert ...T) (Insert[T], error) {
@@ -126,10 +130,10 @@ 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]) Execute(conn *simpleorm.DBConnection) error {
 	dml, err := ins.target.GetInsertDML(len(ins.toInsert))
 	if err != nil {
-		return []T{}, err
+		return err
 	}
 
 	var params []any
@@ -147,7 +151,7 @@ func (ins Insert[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 
 	stmt, err := conn.Prepare(dml)
 	if err != nil {
-		return []T{}, err
+		return err
 	}
 	defer stmt.Close()
 
@@ -156,10 +160,14 @@ func (ins Insert[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 	} else {
 		rowsAffected, _ := result.RowsAffected()
 		log.LogInfo("Inserted %s row", rowsAffected)
-		lastInsertId, _ := result.LastInsertId()
-		log.LogInfo("Last ID: %s", lastInsertId)
+		ins.lastInsertId, _ = result.LastInsertId()
+		log.LogInfo("Last inserted ID: %s", ins.lastInsertId)
 	}
-	return []T{}, nil
+	return nil
+}
+
+func (ins Insert[T]) LastInsertId() int64 {
+	return ins.lastInsertId
 }
 
 type Update[T any] struct {
@@ -176,17 +184,17 @@ 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 {
 	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 {
@@ -197,18 +205,19 @@ func (u Update[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 
 	stmt, err := conn.Prepare(dml)
 	if err != nil {
-		return []T{}, err
+		return err
 	}
 	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)
+		result.LastInsertId()
 	}
-	return []T{u.toUpdate}, nil
+	return nil
 }
 
 type Delete[T any] struct {
@@ -216,7 +225,7 @@ type Delete[T any] struct {
 	toDelete []T
 }
 
-func NewDelete[T any](orm *simpleorm.ORM, toDelete []T) (Delete[T], error) {
+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")
@@ -225,11 +234,11 @@ 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 {
 	count := len(d.toDelete)
 	dml, err := d.target.GetDeleteDML(count)
 	if err != nil {
-		return []T{}, err
+		return err
 	}
 
 	var params []any
@@ -237,7 +246,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 {
@@ -249,19 +258,19 @@ func (d Delete[T]) Execute(conn *simpleorm.DBConnection) ([]T, error) {
 
 	stmt, err := conn.Prepare(dml)
 	if err != nil {
-		return []T{}, err
+		return err
 	}
 	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
 
 }