diff --git a/exec/exec.go b/exec/exec.go index 72bd1e9..a0c0d01 100644 --- a/exec/exec.go +++ b/exec/exec.go @@ -162,6 +162,8 @@ type Select[T any] struct { whereStmt string args []any results []T + Limit int64 + Offset int64 } func CreateSelect[T any](orm *simpleorm.ORM, whereStmt string, args ...any) (Select[T], error) { @@ -170,7 +172,7 @@ func CreateSelect[T any](orm *simpleorm.ORM, whereStmt string, args ...any) (Sel return Select[T]{}, errors.New("Failed to get table from schema cache") } - return Select[T]{target: *table, whereStmt: whereStmt, args: args}, nil + return Select[T]{target: *table, whereStmt: whereStmt, args: args, Limit: -1, Offset: -1}, nil } func (s *Select[T]) Results() []T { @@ -193,7 +195,18 @@ func (s *Select[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error { dml += " WHERE " + s.whereStmt } - log.LogDebug("Preparing sql: %s, with args: %s", dml, s.args) + var effectiveArgs []any = s.args + if s.Limit != -1 { + dml += " LIMIT ?" + effectiveArgs = append(effectiveArgs, s.Limit) + } + + if s.Offset != -1 { + dml += " OFFSET ?" + effectiveArgs = append(effectiveArgs, s.Offset) + } + + log.LogDebug("Preparing sql: %s, with args: %s", dml, effectiveArgs) var stmt *sql.Stmt if tx != nil { @@ -210,12 +223,12 @@ func (s *Select[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error { log.LogDebug("Executing statement: %s", stmt) var rows *sql.Rows - if len(s.args) == 0 { + if len(effectiveArgs) == 0 { rows, err = stmt.Query() } else { // Flattent args to make sure it can be parsed correctly var flatArgs []any - for _, a := range s.args { + for _, a := range effectiveArgs { if s, ok := a.([]any); ok { flatArgs = append(flatArgs, s...) } else { @@ -238,6 +251,79 @@ func (s *Select[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error { return nil } +type Count[T any] struct { + target schema.Table + whereStmt string + args []any + result int64 +} + +func CreateCount[T any](orm *simpleorm.ORM, whereStmt string, args ...any) (Count[T], error) { + table, ok := orm.Cache().Get(reflect.TypeFor[T]().Name()) + if !ok { + return Count[T]{}, errors.New("Failed to get table from schema cache") + } + + return Count[T]{target: *table, whereStmt: whereStmt, args: args}, nil +} + +func (c *Count[T]) Result() int64 { + return c.result +} + +func (c *Count[T]) Execute(conn *simpleorm.DBConnection) error { + return c.execute(conn, nil) +} + +func (c *Count[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error { + // Reinit the results, new execution + c.result = -1 + dml := c.target.GetCountDML() + + if c.whereStmt != "" { + dml += " WHERE " + c.whereStmt + } + + log.LogDebug("Preparing sql: %s, with args: %s", dml, c.args) + + var stmt *sql.Stmt + var err error + if tx != nil { + stmt, err = tx.Prepare(dml) + } else { + stmt, err = conn.Prepare(dml) + } + + if err != nil { + return err + } + defer stmt.Close() + + log.LogDebug("Executing statement: %s", stmt) + + if len(c.args) == 0 { + err = stmt.QueryRow().Scan(&c.result) + } else { + // Flattent args to make sure it can be parsed correctly + var flatArgs []any + for _, a := range c.args { + if s, ok := a.([]any); ok { + flatArgs = append(flatArgs, s...) + } else { + flatArgs = append(flatArgs, a) + } + } + + err = stmt.QueryRow(flatArgs...).Scan(&c.result) + + } + if err != nil { + return err + } + + return nil +} + type Insert[T any] struct { target schema.Table toInsert []T @@ -278,7 +364,7 @@ func (ins *Insert[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error { } } - log.LogInfo("%s [%s]", dml, params) + log.LogDebug("%s [%s]", dml, params) var stmt *sql.Stmt if tx != nil { @@ -347,7 +433,7 @@ func (u Update[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error { params = append(params, pk) } - log.LogInfo("%s [%s]", dml, params) + log.LogDebug("%s [%s]", dml, params) var stmt *sql.Stmt if tx != nil { @@ -405,7 +491,7 @@ func (d *Delete[T]) execute(conn *simpleorm.DBConnection, tx *sql.Tx) error { } } - log.LogInfo("%s [%s]", dml, params) + log.LogDebug("%s [%s]", dml, params) var stmt *sql.Stmt if tx != nil { diff --git a/schema/table.go b/schema/table.go index 83752c6..f16cf4b 100644 --- a/schema/table.go +++ b/schema/table.go @@ -58,6 +58,10 @@ func (t Table) GetSelectDML() (string, error) { return dml.String(), nil } +func (t Table) GetCountDML() string { + return "SELECT COUNT(*) FROM " + t.Name +} + func (t Table) GetInsertDML(count int) (string, error) { var dml strings.Builder dml.WriteString("INSERT INTO " + util.CamelToSnake(t.Type.Name()) + " (") diff --git a/test/exec_test.go b/test/exec_test.go index 76d1b31..8892190 100644 --- a/test/exec_test.go +++ b/test/exec_test.go @@ -1,6 +1,7 @@ package simpleorm_test import ( + "strconv" "testing" "time" @@ -681,3 +682,147 @@ func TestTransactionRollback(t *testing.T) { return } } + +func TestSelectWithLimitAndOffset(t *testing.T) { + // GIVEN + orm, conn := testSetup() + defer cleanUp("test.db", conn) + + testEntites := []Test{} + + for i := 0; i < 1000; i++ { + testEntites = append(testEntites, Test{Int64Field: -1, IntField: i, StringField: "Entity " + strconv.Itoa(i)}) + } + + insertExec, err := exec.NewInsert[Test](orm, testEntites...) + if err != nil { + log.LogError("TestSelectWithLimitAndOffset setup failed: %s", err) + t.Fail() + return + } + + err = insertExec.Execute(conn) + if err != nil { + log.LogError("TestSelectWithLimitAndOffset setup failed: %s", err) + t.Fail() + return + } + // WHEN + + selectExec, err := exec.CreateSelect[Test](orm, "") + if err != nil { + log.LogError("TestSelectWithLimitAndOffset failed: %s", err) + t.Fail() + return + } + selectExec.Limit = 100 + selectExec.Offset = 0 + + err = selectExec.Execute(conn) + if err != nil { + log.LogError("TestSelectWithLimitAndOffset failed: %s", err) + t.Fail() + return + } + + // THEN + + if len(selectExec.Results()) != 100 { + log.LogError("TestSelectWithLimitAndOffset expected result size 100, actual: %s", len(selectExec.Results())) + t.Fail() + } +} + +func TestCount(t *testing.T) { + // GIVEN + orm, conn := testSetup() + defer cleanUp("test.db", conn) + + testEntites := []Test{} + + for i := 0; i < 1000; i++ { + testEntites = append(testEntites, Test{Int64Field: -1, IntField: i, StringField: "Entity " + strconv.Itoa(i)}) + } + + insertExec, err := exec.NewInsert[Test](orm, testEntites...) + if err != nil { + log.LogError("TestSelectWithLimitAndOffset setup failed: %s", err) + t.Fail() + return + } + + err = insertExec.Execute(conn) + if err != nil { + log.LogError("TestSelectWithLimitAndOffset setup failed: %s", err) + t.Fail() + return + } + // WHEN + + countExec, err := exec.CreateCount[Test](orm, "") + if err != nil { + log.LogError("TestSelectWithLimitAndOffset failed: %s", err) + t.Fail() + return + } + err = countExec.Execute(conn) + if err != nil { + log.LogError("TestSelectWithLimitAndOffset failed: %s", err) + t.Fail() + return + } + + // THEN + + if countExec.Result() != 1000 { + log.LogError("TestSelectWithLimitAndOffset expected result size 1000, actual: %s", countExec.Result()) + t.Fail() + } +} + +func TestCountWithCondition(t *testing.T) { + // GIVEN + orm, conn := testSetup() + defer cleanUp("test.db", conn) + + testEntites := []Test{} + + for i := 0; i < 1000; i++ { + testEntites = append(testEntites, Test{Int64Field: -1, IntField: i, StringField: "Entity " + strconv.Itoa(i)}) + } + + insertExec, err := exec.NewInsert[Test](orm, testEntites...) + if err != nil { + log.LogError("TestSelectWithLimitAndOffset setup failed: %s", err) + t.Fail() + return + } + + err = insertExec.Execute(conn) + if err != nil { + log.LogError("TestSelectWithLimitAndOffset setup failed: %s", err) + t.Fail() + return + } + // WHEN + + countExec, err := exec.CreateCount[Test](orm, "id % 2 = 0") + if err != nil { + log.LogError("TestSelectWithLimitAndOffset failed: %s", err) + t.Fail() + return + } + err = countExec.Execute(conn) + if err != nil { + log.LogError("TestSelectWithLimitAndOffset failed: %s", err) + t.Fail() + return + } + + // THEN + + if countExec.Result() != 500 { + log.LogError("TestSelectWithLimitAndOffset expected result size 500, actual: %s", countExec.Result()) + t.Fail() + } +}