From d20184a6f0fed65dc600dad5667a0909d76e37fb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gerg=C5=91=20Dulai?= Date: Fri, 5 Jun 2026 12:33:46 +0200 Subject: [PATCH] WIP: Refactor Exec implementations to be chainable --- exec/exec.go | 95 +----------- exec/select.go | 138 +++++++++++++++++ repository/repository.go | 6 +- test/exec_test.go | 281 ++------------------------------- test/select_test.go | 326 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 480 insertions(+), 366 deletions(-) create mode 100644 exec/select.go create mode 100644 test/select_test.go diff --git a/exec/exec.go b/exec/exec.go index a0c0d01..0d81d67 100644 --- a/exec/exec.go +++ b/exec/exec.go @@ -157,98 +157,9 @@ type Exec[T any] interface { execute(conn *simpleorm.DBConnection, tx *sql.Tx) error } -type Select[T any] struct { - target schema.Table - whereStmt string - args []any - results []T - Limit int64 - Offset int64 -} - -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, Limit: -1, Offset: -1}, 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 - } - - 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 { - 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(effectiveArgs) == 0 { - rows, err = stmt.Query() - } else { - // Flattent args to make sure it can be parsed correctly - var flatArgs []any - for _, a := range effectiveArgs { - 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 OrderBy struct { + Column string + Direction string } type Count[T any] struct { diff --git a/exec/select.go b/exec/select.go new file mode 100644 index 0000000..bb46f10 --- /dev/null +++ b/exec/select.go @@ -0,0 +1,138 @@ +package exec + +import ( + "database/sql" + "errors" + "reflect" + + "git.gdulai.com/gdulai/simpleorm" + "git.gdulai.com/gdulai/simpleorm/schema" + log "gitlab.com/gdulai/simpleloglvl" +) + +// Select execution which is translated to a select sql query. +type Select[T any] struct { + target schema.Table + whereStmt string + args []any + limit int64 + offset int64 + ordering []OrderBy + results []T +} + +// Creates the select query builder +func CreateSelect[T any](orm *simpleorm.ORM) (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, limit: -1, offset: -1}, nil +} + +// Sets the where part of the select query and the arguments +// Returns the pointer of the Select instance +func (s *Select[T]) Where(whereStmt string, args ...any) *Select[T] { + s.whereStmt = whereStmt + s.args = args + return s +} + +// Sets the limit part of the select query +// Returns the pointer of the Select instance +func (s *Select[T]) Limit(limit int64) *Select[T] { + s.limit = limit + return s +} + +// Sets the offset part of the select query +// Returns the pointer of the Select instance +func (s *Select[T]) Offset(offset int64) *Select[T] { + s.offset = offset + return s +} + +// Sets the order by part of the select query +// Returns the pointer of the Select instance +func (s *Select[T]) OrderBy(ordering ...OrderBy) *Select[T] { + s.ordering = ordering + return s +} + +// Returns the result of the select +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 + } + + 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 { + 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(effectiveArgs) == 0 { + rows, err = stmt.Query() + } else { + // Flattent args to make sure it can be parsed correctly + var flatArgs []any + for _, a := range effectiveArgs { + 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 +} diff --git a/repository/repository.go b/repository/repository.go index f14a08b..6349e02 100644 --- a/repository/repository.go +++ b/repository/repository.go @@ -23,7 +23,7 @@ func NewRepository[T HasPK](conn *simpleorm.DBConnection, orm *simpleorm.ORM) *R } func (r *Repository[T]) SelectAll() []*T { - selectExec, err := exec.CreateSelect[T](r.orm, "") + selectExec, err := exec.CreateSelect[T](r.orm) if err != nil { log.LogError("Failed to create select execution: %s", err) return []*T{} @@ -68,12 +68,14 @@ func (r *Repository[T]) SelectByPk(pks ...any) *T { } - selectExec, err := exec.CreateSelect[T](r.orm, whereStmtBuilder.String(), pks) + selectExec, err := exec.CreateSelect[T](r.orm) if err != nil { log.LogError("Failed to create select execution: %s", err) return nil } + selectExec.Where(whereStmtBuilder.String(), pks) + err = selectExec.Execute(r.conn) if err != nil { log.LogError("Failed to load entity: %s", err) diff --git a/test/exec_test.go b/test/exec_test.go index 8892190..b56f645 100644 --- a/test/exec_test.go +++ b/test/exec_test.go @@ -9,36 +9,6 @@ import ( 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() @@ -133,193 +103,6 @@ func TestInsertMultiple(t *testing.T) { } -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() @@ -335,13 +118,15 @@ func TestInsertAndUpdate(t *testing.T) { return } - selectExec, err := exec.CreateSelect[Test](orm, "string_field = ?", "asdf") + selectExec, err := exec.CreateSelect[Test](orm) if err != nil { log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err) t.Fail() return } + selectExec.Where("string_field = ?", "asdf") + err = insertExec.Execute(conn) if err != nil { log.LogError("TestInsertAndUpdate insert failed: %s", err) @@ -422,7 +207,7 @@ func TestInsertAndDelete(t *testing.T) { return } - selectExec, err := exec.CreateSelect[Test](orm, "") + selectExec, err := exec.CreateSelect[Test](orm) if err != nil { log.LogError("TestInsertAndDelete setup failed: %s", err) t.Fail() @@ -478,7 +263,7 @@ func TestBoolInsertAndSelectSingle(t *testing.T) { return } - selectExec, err := exec.CreateSelect[TestWithBool](orm, "") + selectExec, err := exec.CreateSelect[TestWithBool](orm) if err != nil { log.LogError("TestBoolInsertAndSelectSingle setup failed: %s", err) t.Fail() @@ -532,7 +317,7 @@ func TestTimeInsertAndSelectSingle(t *testing.T) { return } - selectExec, err := exec.CreateSelect[TestWithTime](orm, "") + selectExec, err := exec.CreateSelect[TestWithTime](orm) if err != nil { log.LogError("TestTimeInsertAndSelectSingle setup failed: %s", err) t.Fail() @@ -638,13 +423,15 @@ func TestTransactionRollback(t *testing.T) { return } - selectExec, err := exec.CreateSelect[Test](orm, "id = ?", insertExec.Results()[0].ID) + selectExec, err := exec.CreateSelect[Test](orm) if err != nil { log.LogError("TestTransactionRollback WHEN failed: %s", err) t.Fail() return } + selectExec.Where("id = ?", insertExec.Results()[0].ID) + transErr = transaction.Execute(&selectExec) if transErr != nil { log.LogError("TestTransactionRollback WHEN failed: %s", err) @@ -683,56 +470,6 @@ func TestTransactionRollback(t *testing.T) { } } -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() diff --git a/test/select_test.go b/test/select_test.go new file mode 100644 index 0000000..ce12c34 --- /dev/null +++ b/test/select_test.go @@ -0,0 +1,326 @@ +package simpleorm_test + +import ( + "strconv" + "testing" + + "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 TestSelectSingle(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 TestSelectWithCompositePk(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 TestSelectWithParam(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) + if err != nil { + log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err) + t.Fail() + return + } + + selectExec.Where("string_field = ?", "fdsa") + + 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 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).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 TestSelectOrderBy(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.OrderBy(exec.OrderBy{Column: "StringField", Direction: "ASC"}) + + 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() + } +}