From 56a87ac58a5d19e38bb2cb34ba0e2a65a6984633 Mon Sep 17 00:00:00 2001 From: Jamess-Lucass <23193271+Jamess-Lucass@users.noreply.github.com> Date: Wed, 22 May 2024 19:45:19 +0100 Subject: [PATCH 01/14] wip --- app.go | 116 --------- app_test.go | 476 ------------------------------------- ast/ast.go | 31 +++ examples/fiber/go.mod | 30 --- examples/fiber/go.sum | 48 ---- examples/fiber/main.go | 154 ------------ go.mod | 12 +- go.sum | 12 - go.work.sum | 9 - lexer/lexer.go | 101 ++++++++ lexer/lexer_test.go | 46 ++++ module/gorm/go.mod | 29 +++ module/gorm/go.sum | 42 ++++ module/gorm/orderby.go | 11 + module/gorm/parser.go | 2 + module/gorm/parser_test.go | 33 +++ parser/parser.go | 61 +++++ parser/parser_test.go | 34 +++ query.go | 11 + response.go | 48 ---- response_test.go | 64 ----- token/token.go | 40 ++++ types.go | 21 -- utils.go | 79 ------ utils_test.go | 43 ---- 25 files changed, 443 insertions(+), 1110 deletions(-) delete mode 100644 app.go delete mode 100644 app_test.go create mode 100644 ast/ast.go delete mode 100644 examples/fiber/go.mod delete mode 100644 examples/fiber/go.sum delete mode 100644 examples/fiber/main.go delete mode 100644 go.work.sum create mode 100644 lexer/lexer.go create mode 100644 lexer/lexer_test.go create mode 100644 module/gorm/go.mod create mode 100644 module/gorm/go.sum create mode 100644 module/gorm/orderby.go create mode 100644 module/gorm/parser.go create mode 100644 module/gorm/parser_test.go create mode 100644 parser/parser.go create mode 100644 parser/parser_test.go create mode 100644 query.go delete mode 100644 response.go delete mode 100644 response_test.go create mode 100644 token/token.go delete mode 100644 types.go delete mode 100644 utils.go delete mode 100644 utils_test.go diff --git a/app.go b/app.go deleted file mode 100644 index a5dd6ca..0000000 --- a/app.go +++ /dev/null @@ -1,116 +0,0 @@ -package goatquery - -import ( - "fmt" - "reflect" - "strings" - - "gorm.io/gorm" - "gorm.io/gorm/schema" -) - -func Apply(db *gorm.DB, query Query, maxTop *int, searchFunc func(db *gorm.DB, searchTerm string) *gorm.DB, model interface{}) (*gorm.DB, *int64, error) { - if maxTop != nil && query.Top > *maxTop { - return nil, nil, fmt.Errorf("The value supplied for the query parameter 'Top' was greater than the maximum top allowed for this resource") - } - - if maxTop != nil && query.Top == 0 { - // If no top query was provided, set to max top. - query.Top = *maxTop - } - - // Filter - if query.Filter != "" { - filters := splitString(query.Filter) - where := strings.Builder{} - - namer := db.Statement.NamingStrategy - - v := reflect.ValueOf(model) - modelType := reflect.Indirect(v).Type().Elem() - - tableName := namer.TableName(modelType.Name()) - - for i, filter := range filters { - opts := splitStringByWhitespace(strings.TrimSpace(filter)) - - if len(opts) != 3 { - continue - } - - if i > 0 { - prev := filters[i-1] - where.WriteString(fmt.Sprintf(" %s ", strings.TrimSpace(prev))) - } - - property := opts[0] - operand := opts[1] - value := opts[2] - - property = GetGormColumnNameByJsonTag(namer, tableName, modelType, property) - - if strings.EqualFold(operand, "contains") { - valueWithoutQuotes := getValueBetweenQuotes(value) - where.WriteString(fmt.Sprintf("%s %s '%%%s%%'", property, filterOperations[operand], valueWithoutQuotes)) - } else { - where.WriteString(fmt.Sprintf("LOWER(%s) %s LOWER(%s)", property, filterOperations[operand], value)) - } - } - - db = db.Where(where.String()) - } - - // Search - if searchFunc != nil && query.Search != "" { - db = searchFunc(db, query.Search) - } - - // Count - var count int64 - if query.Count { - db.Count(&count) - } - - // Order by - if query.OrderBy != "" { - db = db.Order(query.OrderBy) - } - - // Select - if query.Select != "" { - db = db.Select(query.Select) - } - - // Skip - if query.Skip > 0 { - db = db.Offset(query.Skip) - } - - // Top - if query.Top > 0 { - db = db.Limit(query.Top) - } - - if query.Count { - return db, &count, nil - } - - return db, nil, nil -} - -func GetGormColumnNameByJsonTag(namer schema.Namer, tableName string, t reflect.Type, property string) string { - for i := 0; i < t.NumField(); i++ { - f := t.Field(i) - v := strings.Split(f.Tag.Get("json"), ",")[0] // use split to ignore tag "options" like omitempty, etc. - if v == property { - settings := schema.ParseTagSetting(f.Tag.Get("gorm"), ";") - if settings["COLUMN"] != "" { - return settings["COLUMN"] - } - - return namer.ColumnName(tableName, f.Name) - } - } - - return property -} diff --git a/app_test.go b/app_test.go deleted file mode 100644 index db35fa2..0000000 --- a/app_test.go +++ /dev/null @@ -1,476 +0,0 @@ -package goatquery - -import ( - "fmt" - "os" - "testing" - - "github.com/google/uuid" - "github.com/stretchr/testify/assert" - "gorm.io/driver/sqlite" - "gorm.io/gorm" - "gorm.io/gorm/logger" -) - -var DB *gorm.DB - -type Base struct { - Id uuid.UUID `json:"id"` -} - -type User struct { - Base - - Firstname string `json:"firstname"` - Lastname string `json:"lastname"` - Email string `json:"email"` - UserName string `gorm:"column:display_name" json:"userName"` - PersonSex string `json:"gender"` - Age uint `json:"age"` - Contributor bool `json:"contributor"` -} - -func TestMain(m *testing.M) { - setup() - code := m.Run() - os.Exit(code) -} - -func setup() { - db, err := gorm.Open(sqlite.Open("file::memory:?cache=shared"), &gorm.Config{ - Logger: logger.Default.LogMode(logger.Error), - }) - - if err != nil { - panic("failed to connect database") - } - DB = db - - db.AutoMigrate(&User{}) -} - -func Test_EmptyQuery(t *testing.T) { - query := Query{} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -// Top - -func Test_QueryWithTop(t *testing.T) { - query := Query{Top: 3} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Limit(query.Top).Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithTopGreaterThanMaxTop(t *testing.T) { - maxTop := 2 - query := Query{Top: 3} - - _, _, err := Apply(DB.Model(&User{}), query, &maxTop, nil, &[]User{}) - - assert.NotNil(t, err) -} - -func Test_QueryWithNilTopUsesMaxTop(t *testing.T) { - maxTop := 2 - query := Query{} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, &maxTop, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Limit(maxTop).Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -// Skip - -func Test_QueryWithSkip(t *testing.T) { - query := Query{Skip: 3} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Offset(query.Skip).Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -// Count - -func Test_QueryWithCount(t *testing.T) { - query := Query{Count: true} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - var count int64 - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Count(&count).Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -// Order by - -func Test_QueryWithOrderby(t *testing.T) { - query := Query{OrderBy: "firstname"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Order("firstname").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithOrderbyAsc(t *testing.T) { - query := Query{OrderBy: "firstname asc"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Order("firstname asc").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithOrderbyDesc(t *testing.T) { - query := Query{OrderBy: "firstname desc"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Order("firstname desc").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithOrderbyMultiple(t *testing.T) { - query := Query{OrderBy: "firstname asc, lastname desc"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Order("firstname asc, lastname desc").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -// Select - -func Test_QueryWithSelect(t *testing.T) { - query := Query{Select: "firstname, lastname"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Select("firstname, lastname").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithSelectInvalidColumn(t *testing.T) { - query := Query{Select: "firstname, invalid-col"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Select("firstname, invalid-col").Find(&[]User{}) - }) - - err := DB.Raw(expectedSql).Find(&[]User{}).Error - - assert.Error(t, err) - assert.Equal(t, expectedSql, sql) -} - -// Search - -func Test_QueryWithSearch(t *testing.T) { - query := Query{Search: "Goat"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, func(db *gorm.DB, searchTerm string) *gorm.DB { - t := fmt.Sprintf("%%%s%%", searchTerm) - - return db.Where("firstname like ? or lastname like ?", t, t) - }, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Where("firstname like \"%Goat%\" or lastname like \"%Goat%\"").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithSearchTermSpace(t *testing.T) { - query := Query{Search: "Goat Query"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, func(db *gorm.DB, searchTerm string) *gorm.DB { - t := fmt.Sprintf("%%%s%%", searchTerm) - - return db.Where("firstname like ? or lastname like ?", t, t) - }, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Where("firstname like \"%Goat Query%\" or lastname like \"%Goat Query%\"").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithSearchNilFunc(t *testing.T) { - query := Query{Search: "Goat"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -// Filter - -func Test_QueryWithFilterEquals(t *testing.T) { - query := Query{Filter: "firstname eq 'goat'"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Where("LOWER(firstname) = LOWER('goat')").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithFilterNotEquals(t *testing.T) { - query := Query{Filter: "firstname ne 'goat'"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Where("LOWER(firstname) <> LOWER('goat')").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithFilterEqualsAndEquals(t *testing.T) { - query := Query{Filter: "firstname eq 'goat' and lastname eq 'query'"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Where("LOWER(firstname) = LOWER('goat') and LOWER(lastname) = LOWER('query')").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithFilterEqualsAndNotEquals(t *testing.T) { - query := Query{Filter: "firstname eq 'goat' and lastname ne 'query'"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Where("LOWER(firstname) = LOWER('goat') and LOWER(lastname) <> LOWER('query')").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithFilterContains(t *testing.T) { - query := Query{Filter: "firstname contains 'goat'"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Where("firstname like '%goat%'").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithFilterContainsAndEquals(t *testing.T) { - query := Query{Filter: "firstname contains 'goat' and lastname eq 'query'"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Where("firstname like '%goat%' and LOWER(lastname) = LOWER('query')").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithFilterContainsOrEquals(t *testing.T) { - query := Query{Filter: "firstname contains 'goat' or lastname eq 'query'"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Where("firstname like '%goat%' or LOWER(lastname) = LOWER('query')").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithFilterEqualsWithConjunction(t *testing.T) { - query := Query{Filter: "firstname eq 'goatand'"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Where("LOWER(firstname) = LOWER('goatand')").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithFilterEqualsWithConjunctionAndSpaces(t *testing.T) { - query := Query{Filter: "firstname eq ' and ' or lastname eq ' and or '"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Where("LOWER(firstname) = LOWER(' and ') or LOWER(lastname) = LOWER(' and or ')").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithFilterGormColumnRename(t *testing.T) { - query := Query{Filter: "userName eq 'John'"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Where("LOWER(display_name) = LOWER('John')").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithFilterPropertyDoesntMatchJsonProperty(t *testing.T) { - query := Query{Filter: "gender eq 'Male'"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Where("LOWER(person_sex) = LOWER('Male')").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} - -func Test_QueryWithFilterAndOrInColumnName(t *testing.T) { - query := Query{Filter: "contributor eq 'true'"} - - sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - res, _, _ := Apply(tx.Model(&User{}), query, nil, nil, &[]User{}) - return res.Find(&[]User{}) - }) - - expectedSql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&User{}).Where("LOWER(contributor) = LOWER('true')").Find(&[]User{}) - }) - - assert.Equal(t, expectedSql, sql) -} diff --git a/ast/ast.go b/ast/ast.go new file mode 100644 index 0000000..42eb885 --- /dev/null +++ b/ast/ast.go @@ -0,0 +1,31 @@ +package ast + +import ( + "github.com/goatquery/goatquery-go/token" +) + +type Node interface { + TokenLiteral() string +} + +type Statement interface { + Node + statementNode() +} + +type OrderByDirection string + +const ( + Ascending OrderByDirection = "asc" + Descending OrderByDirection = "desc" +) + +type OrderByStatement struct { + Token token.Token + Direction OrderByDirection +} + +var _ Statement = (*OrderByStatement)(nil) + +func (s *OrderByStatement) statementNode() {} +func (s *OrderByStatement) TokenLiteral() string { return s.Token.Literal } diff --git a/examples/fiber/go.mod b/examples/fiber/go.mod deleted file mode 100644 index a7d2e6f..0000000 --- a/examples/fiber/go.mod +++ /dev/null @@ -1,30 +0,0 @@ -module github.com/goatquery/goatquery-go/examples/fiber - -go 1.21 - -require ( - github.com/brianvoe/gofakeit/v6 v6.23.2 - github.com/gofiber/fiber/v2 v2.49.1 - github.com/google/uuid v1.5.0 - gorm.io/driver/sqlite v1.5.4 - gorm.io/gorm v1.25.5 -) - -replace goatquery => ../.. - -require ( - github.com/andybalholm/brotli v1.0.5 // indirect - github.com/jinzhu/inflection v1.0.0 // indirect - github.com/jinzhu/now v1.1.5 // indirect - github.com/klauspost/compress v1.16.7 // indirect - github.com/mattn/go-colorable v0.1.13 // indirect - github.com/mattn/go-isatty v0.0.19 // indirect - github.com/mattn/go-runewidth v0.0.15 // indirect - github.com/mattn/go-sqlite3 v1.14.17 // indirect - github.com/rivo/uniseg v0.4.4 // indirect - github.com/valyala/bytebufferpool v1.0.0 // indirect - github.com/valyala/fasthttp v1.49.0 // indirect - github.com/valyala/tcplisten v1.0.0 // indirect - goatquery v0.0.0-00010101000000-000000000000 - golang.org/x/sys v0.12.0 // indirect -) diff --git a/examples/fiber/go.sum b/examples/fiber/go.sum deleted file mode 100644 index 6ae3a13..0000000 --- a/examples/fiber/go.sum +++ /dev/null @@ -1,48 +0,0 @@ -github.com/andybalholm/brotli v1.0.5 h1:8uQZIdzKmjc/iuPu7O2ioW48L81FgatrcpfFmiq/cCs= -github.com/andybalholm/brotli v1.0.5/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig= -github.com/brianvoe/gofakeit/v6 v6.23.2 h1:lVde18uhad5wII/f5RMVFLtdQNE0HaGFuBUXmYKk8i8= -github.com/brianvoe/gofakeit/v6 v6.23.2/go.mod h1:Ow6qC71xtwm79anlwKRlWZW6zVq9D2XHE4QSSMP/rU8= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/gofiber/fiber/v2 v2.49.1 h1:0W2DRWevSirc8pJl4o8r8QejDR8TV6ZUCawHxwbIdOk= -github.com/gofiber/fiber/v2 v2.49.1/go.mod h1:nPUeEBUeeYGgwbDm59Gp7vS8MDyScL6ezr/Np9A13WU= -github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU= -github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= -github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= -github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= -github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= -github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I= -github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= -github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= -github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= -github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= -github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA= -github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= -github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U= -github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= -github.com/mattn/go-sqlite3 v1.14.17 h1:mCRHCLDUBXgpKAqIKsaAaAsrAlbkeomtRFKXh2L6YIM= -github.com/mattn/go-sqlite3 v1.14.17/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= -github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis= -github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= -github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= -github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= -github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= -github.com/valyala/fasthttp v1.49.0 h1:9FdvCpmxB74LH4dPb7IJ1cOSsluR07XG3I1txXWwJpE= -github.com/valyala/fasthttp v1.49.0/go.mod h1:k2zXd82h/7UZc3VOdJ2WaUqt1uZ/XpXAfE9i+HBC3lA= -github.com/valyala/tcplisten v1.0.0 h1:rBHj/Xf+E1tRGZyWIWwJDiRY0zc1Js+CV5DqwacVSA8= -github.com/valyala/tcplisten v1.0.0/go.mod h1:T0xQ8SeCZGxckz9qRXTfG43PvQ/mcWh7FwZEA7Ioqkc= -golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o= -golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gorm.io/driver/sqlite v1.5.4 h1:IqXwXi8M/ZlPzH/947tn5uik3aYQslP9BVveoax0nV0= -gorm.io/driver/sqlite v1.5.4/go.mod h1:qxAuCol+2r6PannQDpOP1FP6ag3mKi4esLnB/jHed+4= -gorm.io/gorm v1.25.5 h1:zR9lOiiYf09VNh5Q1gphfyia1JpiClIWG9hQaxB/mls= -gorm.io/gorm v1.25.5/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8= diff --git a/examples/fiber/main.go b/examples/fiber/main.go deleted file mode 100644 index 881674e..0000000 --- a/examples/fiber/main.go +++ /dev/null @@ -1,154 +0,0 @@ -package main - -import ( - "errors" - "fmt" - - "github.com/brianvoe/gofakeit/v6" - "github.com/gofiber/fiber/v2" - "github.com/google/uuid" - "gorm.io/driver/sqlite" - "gorm.io/gorm" - "gorm.io/gorm/logger" - - "goatquery" -) - -type Base struct { - Id uuid.UUID `json:"id"` -} - -type User struct { - Base - - Firstname string `json:"firstname"` - Lastname string `json:"lastname"` - User_Name string `gorm:"column:display_name" json:"userName"` - PersonSex string `json:"gender"` - Email string `json:"email"` - AvatarUrl string `json:"avatarUrl"` - Age uint `json:"age"` - IsDeleted bool `json:"-"` - AddressId uuid.UUID `json:"-"` - Address Address `json:"addresses"` - Permissions []UserPermission `json:"permissions"` -} - -type UserPermission struct { - Base - - Name string `json:"name"` - UserId uuid.UUID `json:"-"` -} - -type Address struct { - Base - - Postcode string `json:"postcode"` -} - -type UserDto struct { - Base - - Firstname string `json:"firstname"` - Lastname string `json:"lastname"` - User_Name string `gorm:"column:display_name" json:"userName"` - PersonSex string `json:"gender"` - Email string `json:"email"` - AvatarUrl string `json:"-"` - Age uint `json:"age"` - AddressId uuid.UUID `json:"-"` - Address Address `json:"address"` - Permissions []UserPermission `json:"permissions" gorm:"foreignKey:UserId"` -} - -var DB *gorm.DB - -func main() { - db, err := gorm.Open(sqlite.Open("file::memory:?cache=shared"), &gorm.Config{ - Logger: logger.Default.LogMode(logger.Info), - }) - - if err != nil { - panic("failed to connect database") - } - DB = db - - db.AutoMigrate(&UserPermission{}, &Address{}, &User{}) - - gofakeit.Seed(123) - - if err := db.First(&User{}).Error; errors.Is(err, gorm.ErrRecordNotFound) { - items := []User{} - - for i := 1; i < 1_000; i++ { - person := gofakeit.Person() - userId := uuid.New() - - item := User{ - Base: Base{Id: userId}, - Firstname: person.FirstName, - Lastname: person.LastName, - User_Name: fmt.Sprintf("%s-%s", person.FirstName, userId.String()), - PersonSex: person.Gender, - Email: person.Contact.Email, - AvatarUrl: gofakeit.ImageURL(64, 64), - Age: gofakeit.UintRange(0, 100), - IsDeleted: gofakeit.Bool(), - Address: Address{Base: Base{Id: uuid.New()}, Postcode: person.Address.Zip}, - Permissions: []UserPermission{{Base: Base{Id: uuid.New()}, UserId: userId, Name: gofakeit.LoremIpsumWord()}}, - } - - items = append(items, item) - } - - if err := db.CreateInBatches(items, 1_000).Error; err != nil { - fmt.Printf("error occured while seeding data: %v\n", err) - return - } - - fmt.Printf("Seeded data...\n") - } - - app := fiber.New() - - app.Get("/users", getUsers) - - app.Listen(":8080") -} - -func getUsers(c *fiber.Ctx) error { - query := goatquery.Query{ - Top: c.QueryInt("top", 0), - Skip: c.QueryInt("skip", 0), - Count: c.QueryBool("count", false), - OrderBy: c.Query("orderby"), - Select: c.Query("select"), - Search: c.Query("search"), - Filter: c.Query("filter"), - } - - var users []UserDto - res, count, err := goatquery.Apply(GetAllUsers(DB), query, nil, nil, &users) - if err != nil { - return c.Status(400).JSON(goatquery.QueryErrorResponse{Status: 400, Message: err.Error()}) - } - - if err := res.Find(&users).Error; err != nil { - return c.Status(400).JSON(goatquery.QueryErrorResponse{Status: 400, Message: err.Error()}) - } - - response := goatquery.BuildPagedResponse(users, query, count) - - return c.JSON(response) -} - -func GetAllUsers(db *gorm.DB) *gorm.DB { - return db.Model(&User{}).Where("is_deleted <> ?", true).Preload("Address").Preload("Permissions") -} - -func UserDtoSearch(db *gorm.DB, searchTerm string) *gorm.DB { - t := fmt.Sprintf("%%%s%%", searchTerm) - - return db.Where("firstname like ? or lastname like ?", t, t) -} diff --git a/go.mod b/go.mod index 15f3ea4..08cf9da 100644 --- a/go.mod +++ b/go.mod @@ -1,19 +1,11 @@ module github.com/goatquery/goatquery-go -go 1.21 +go 1.22 -require ( - github.com/google/uuid v1.6.0 - github.com/stretchr/testify v1.9.0 - gorm.io/driver/sqlite v1.5.5 - gorm.io/gorm v1.25.9 -) +require github.com/stretchr/testify v1.9.0 require ( github.com/davecgh/go-spew v1.1.1 // indirect - github.com/jinzhu/inflection v1.0.0 // indirect - github.com/jinzhu/now v1.1.5 // indirect - github.com/mattn/go-sqlite3 v1.14.17 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 8b46e66..60ce688 100644 --- a/go.sum +++ b/go.sum @@ -1,13 +1,5 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= -github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= -github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= -github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= -github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= -github.com/mattn/go-sqlite3 v1.14.17 h1:mCRHCLDUBXgpKAqIKsaAaAsrAlbkeomtRFKXh2L6YIM= -github.com/mattn/go-sqlite3 v1.14.17/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= @@ -16,7 +8,3 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gorm.io/driver/sqlite v1.5.5 h1:7MDMtUZhV065SilG62E0MquljeArQZNfJnjd9i9gx3E= -gorm.io/driver/sqlite v1.5.5/go.mod h1:6NgQ7sQWAIFsPrJJl1lSNSu2TABh0ZZ/zm5fosATavE= -gorm.io/gorm v1.25.9 h1:wct0gxZIELDk8+ZqF/MVnHLkA1rvYlBWUMv2EdsK1g8= -gorm.io/gorm v1.25.9/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8= diff --git a/go.work.sum b/go.work.sum deleted file mode 100644 index 3d263b4..0000000 --- a/go.work.sum +++ /dev/null @@ -1,9 +0,0 @@ -github.com/philhofer/fwd v1.1.2 h1:bnDivRJ1EWPjUIRXV5KfORO897HTbpFAQddBdE8t7Gw= -github.com/philhofer/fwd v1.1.2/go.mod h1:qkPdfjR2SIEbspLqpe1tO4n5yICnr2DY7mqEx2tUTP0= -github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/tinylib/msgp v1.1.8 h1:FCXC1xanKO4I8plpHGH2P7koL/RzZs12l/+r7vakfm0= -github.com/tinylib/msgp v1.1.8/go.mod h1:qkpG+2ldGg4xRFmx+jfTvZPxfGFhi64BcnL9vkCm/Tw= -golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU= -golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc= -golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= -gorm.io/gorm v1.25.2-0.20230530020048-26663ab9bf55/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k= diff --git a/lexer/lexer.go b/lexer/lexer.go new file mode 100644 index 0000000..c80e2fe --- /dev/null +++ b/lexer/lexer.go @@ -0,0 +1,101 @@ +package lexer + +import "github.com/goatquery/goatquery-go/token" + +type Lexer struct { + input string + position int + readPosition int + character byte +} + +func NewLexer(input string) *Lexer { + l := &Lexer{input: input} + l.readCharacter() + + return l +} + +func (l *Lexer) readCharacter() { + if l.readPosition >= len(l.input) { + l.character = 0 // ASCII code for "NUL" + } else { + l.character = l.input[l.readPosition] + } + + l.position = l.readPosition + l.readPosition++ +} + +func (l *Lexer) NextToken() token.Token { + var tok token.Token + + l.skipWhitespace() + + switch l.character { + case 0: + tok.Literal = "" + tok.Type = token.EOF + default: + if isLetter(l.character) { + tok.Literal = l.readIdentifier() + tok.Type = token.LookupIdent(tok.Literal) + return tok + } else if isDigit(l.character) { + tok.Literal = l.readNumber() + tok.Type = token.INT + return tok + } else { + tok = token.NewToken(token.ILLEGAL, l.character) + } + } + + l.readCharacter() + + return tok +} + +func (l *Lexer) skipWhitespace() { + for l.character == ' ' || l.character == '\t' || l.character == '\n' || l.character == '\r' { + l.readCharacter() + } +} + +func (l *Lexer) readIdentifier() string { + currentPosition := l.position + for isLetter(l.character) { + l.readCharacter() + } + + return l.input[currentPosition:l.position] +} + +func (l *Lexer) readNumber() string { + currentPosition := l.position + for isDigit(l.character) { + l.readCharacter() + } + + return l.input[currentPosition:l.position] +} + +func (l *Lexer) readString() string { + currentPosition := l.position + 1 + + for { + l.readCharacter() + if l.character == '"' || l.character == 0 { + break + } + } + + return l.input[currentPosition:l.position] +} + +func isLetter(ch byte) bool { + return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' +} + +func isDigit(ch byte) bool { + return '0' <= ch && ch <= '9' +} diff --git a/lexer/lexer_test.go b/lexer/lexer_test.go new file mode 100644 index 0000000..863cf48 --- /dev/null +++ b/lexer/lexer_test.go @@ -0,0 +1,46 @@ +package lexer + +import ( + "testing" + + "github.com/goatquery/goatquery-go/token" + "github.com/stretchr/testify/assert" +) + +func Test_OrderByNextToken(t *testing.T) { + input := `id asc + iD desc + id aSc + id DeSc + id AsC + ` + + tests := []struct { + expectedType token.TokenType + expectedLiteral string + }{ + {token.IDENT, "id"}, + {token.ASC, "asc"}, + + {token.IDENT, "iD"}, + {token.DESC, "desc"}, + + {token.IDENT, "id"}, + {token.ASC, "aSc"}, + + {token.IDENT, "id"}, + {token.DESC, "DeSc"}, + + {token.IDENT, "id"}, + {token.ASC, "AsC"}, + } + + lexer := NewLexer(input) + + for _, test := range tests { + token := lexer.NextToken() + + assert.Equal(t, test.expectedType, token.Type) + assert.Equal(t, test.expectedLiteral, token.Literal) + } +} diff --git a/module/gorm/go.mod b/module/gorm/go.mod new file mode 100644 index 0000000..44a47b6 --- /dev/null +++ b/module/gorm/go.mod @@ -0,0 +1,29 @@ +module github.com/goatquery/goatquery-go/module/gorm + +go 1.22.0 + +require ( + github.com/glebarez/sqlite v1.11.0 + github.com/stretchr/testify v1.9.0 + gorm.io/gorm v1.25.10 +) + +require ( + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/dustin/go-humanize v1.0.1 // indirect + github.com/glebarez/go-sqlite v1.21.2 // indirect + github.com/google/uuid v1.3.0 // indirect + github.com/jinzhu/inflection v1.0.0 // indirect + github.com/jinzhu/now v1.1.5 // indirect + github.com/mattn/go-isatty v0.0.17 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect + golang.org/x/sys v0.7.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect + modernc.org/libc v1.22.5 // indirect + modernc.org/mathutil v1.5.0 // indirect + modernc.org/memory v1.5.0 // indirect + modernc.org/sqlite v1.23.1 // indirect +) + +replace github.com/goatquery/goatquery-go => ../.. diff --git a/module/gorm/go.sum b/module/gorm/go.sum new file mode 100644 index 0000000..508a694 --- /dev/null +++ b/module/gorm/go.sum @@ -0,0 +1,42 @@ +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/glebarez/go-sqlite v1.21.2 h1:3a6LFC4sKahUunAmynQKLZceZCOzUthkRkEAl9gAXWo= +github.com/glebarez/go-sqlite v1.21.2/go.mod h1:sfxdZyhQjTM2Wry3gVYWaW072Ri1WMdWJi0k6+3382k= +github.com/glebarez/sqlite v1.11.0 h1:wSG0irqzP6VurnMEpFGer5Li19RpIRi2qvQz++w0GMw= +github.com/glebarez/sqlite v1.11.0/go.mod h1:h8/o8j5wiAsqSPoWELDUdJXhjAhsVliSn7bWZjOhrgQ= +github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ= +github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26/go.mod h1:dDKJzRmX4S37WGHujM7tX//fmj1uioxKzKxz3lo4HJo= +github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= +github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= +github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= +github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= +github.com/mattn/go-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng= +github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= +github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= +github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU= +golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gorm.io/gorm v1.25.10 h1:dQpO+33KalOA+aFYGlK+EfxcI5MbO7EP2yYygwh9h+s= +gorm.io/gorm v1.25.10/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8= +modernc.org/libc v1.22.5 h1:91BNch/e5B0uPbJFgqbxXuOnxBQjlS//icfQEGmvyjE= +modernc.org/libc v1.22.5/go.mod h1:jj+Z7dTNX8fBScMVNRAYZ/jF91K8fdT2hYMThc3YjBY= +modernc.org/mathutil v1.5.0 h1:rV0Ko/6SfM+8G+yKiyI830l3Wuz1zRutdslNoQ0kfiQ= +modernc.org/mathutil v1.5.0/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E= +modernc.org/memory v1.5.0 h1:N+/8c5rE6EqugZwHii4IFsaJ7MUhoWX07J5tC/iI5Ds= +modernc.org/memory v1.5.0/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU= +modernc.org/sqlite v1.23.1 h1:nrSBg4aRQQwq59JpvGEQ15tNxoO5pX/kUjcRNwSAGQM= +modernc.org/sqlite v1.23.1/go.mod h1:OrDj17Mggn6MhE+iPbBNf7RGKODDE9NFT0f3EwDzJqk= diff --git a/module/gorm/orderby.go b/module/gorm/orderby.go new file mode 100644 index 0000000..4c1e24c --- /dev/null +++ b/module/gorm/orderby.go @@ -0,0 +1,11 @@ +package gorm + +import "gorm.io/gorm" + +func EvaluateOrderBy(db *gorm.DB, orderby string) *gorm.DB { + if orderby != "" { + db = db.Order(orderby) + } + + return db +} diff --git a/module/gorm/parser.go b/module/gorm/parser.go new file mode 100644 index 0000000..c3e14a4 --- /dev/null +++ b/module/gorm/parser.go @@ -0,0 +1,2 @@ +package gorm + diff --git a/module/gorm/parser_test.go b/module/gorm/parser_test.go new file mode 100644 index 0000000..a651e89 --- /dev/null +++ b/module/gorm/parser_test.go @@ -0,0 +1,33 @@ +package gorm + +import ( + "testing" + + "github.com/glebarez/sqlite" + "github.com/stretchr/testify/assert" + "gorm.io/gorm" + "gorm.io/gorm/logger" +) + +func Test_ParsingOrderBy(t *testing.T) { + type Test struct { + name string + } + + db, err := gorm.Open(sqlite.Open("file::memory:?cache=shared"), &gorm.Config{ + Logger: logger.Default.LogMode(logger.Error), + }) + + assert.NoError(t, err) + + expectedSql := db.ToSQL(func(tx *gorm.DB) *gorm.DB { + return tx.Model(&Test{}).Order("name").Find(&[]Test{}) + }) + + sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB { + res := EvaluateOrderBy(tx, "name") + return res.Find(&[]Test{}) + }) + + assert.Equal(t, expectedSql, sql) +} diff --git a/parser/parser.go b/parser/parser.go new file mode 100644 index 0000000..30a6530 --- /dev/null +++ b/parser/parser.go @@ -0,0 +1,61 @@ +package parser + +import ( + "github.com/goatquery/goatquery-go/ast" + "github.com/goatquery/goatquery-go/lexer" + "github.com/goatquery/goatquery-go/token" +) + +type Parser struct { + lexer *lexer.Lexer + + currentToken token.Token + peekToken token.Token +} + +func NewParser(lexer *lexer.Lexer) *Parser { + p := &Parser{lexer: lexer} + + p.NextToken() + p.NextToken() + + return p +} + +func (p *Parser) NextToken() { + p.currentToken = p.peekToken + p.peekToken = p.lexer.NextToken() +} + +func (p *Parser) ParseOrderBy() []ast.OrderByStatement { + statements := []ast.OrderByStatement{} + + for !p.currentTokenIs(token.EOF) { + if !p.currentTokenIs(token.IDENT) { + p.NextToken() + continue + } + + statement := &ast.OrderByStatement{Token: p.currentToken, Direction: ast.Ascending} + + if p.peekTokenIs(token.DESC) { + statement.Direction = ast.Descending + + p.NextToken() + } + + statements = append(statements, *statement) + + p.NextToken() + } + + return statements +} + +func (p *Parser) currentTokenIs(t token.TokenType) bool { + return p.currentToken.Type == t +} + +func (p *Parser) peekTokenIs(t token.TokenType) bool { + return p.peekToken.Type == t +} diff --git a/parser/parser_test.go b/parser/parser_test.go new file mode 100644 index 0000000..d2b3b53 --- /dev/null +++ b/parser/parser_test.go @@ -0,0 +1,34 @@ +package parser + +import ( + "testing" + + "github.com/goatquery/goatquery-go/ast" + "github.com/goatquery/goatquery-go/lexer" + "github.com/stretchr/testify/assert" +) + +func Test_ParsingOrderByStatement(t *testing.T) { + tests := []struct { + input string + expectedLiteral string + expectedDirection ast.OrderByDirection + }{ + {"id", "id", ast.Ascending}, + {"id asc", "id", ast.Ascending}, + {"id desc", "id", ast.Descending}, + } + + for _, test := range tests { + l := lexer.NewLexer(test.input) + p := NewParser(l) + + statements := p.ParseOrderBy() + assert.Len(t, statements, 1) + + stmt := statements[0] + + assert.Equal(t, test.expectedLiteral, stmt.TokenLiteral()) + assert.Equal(t, test.expectedDirection, stmt.Direction) + } +} diff --git a/query.go b/query.go new file mode 100644 index 0000000..dc65daf --- /dev/null +++ b/query.go @@ -0,0 +1,11 @@ +package goatquery + +type Query struct { + Top int + Skip int + Count bool + OrderBy string + Select string + Search string + Filter string +} diff --git a/response.go b/response.go deleted file mode 100644 index cc9e2f0..0000000 --- a/response.go +++ /dev/null @@ -1,48 +0,0 @@ -package goatquery - -import ( - "encoding/json" - "reflect" - "strings" -) - -func BuildPagedResponse[T any](res []T, query Query, totalCount *int64) PagedResponse[map[string]interface{}] { - result := make([]map[string]interface{}, len(res)) - - selectedProperties := strings.Split(strings.TrimSpace(query.Select), ",") - - if query.Select == "" { - bytes, _ := json.Marshal(res) - - if err := json.Unmarshal(bytes, &result); err != nil { - return PagedResponse[map[string]interface{}]{Value: result, Count: totalCount} - } - - return PagedResponse[map[string]interface{}]{Value: result, Count: totalCount} - } - - for i, obj := range res { - newObj := make(map[string]interface{}) - v := reflect.ValueOf(obj) - - // map over selected properties - for _, p := range selectedProperties { - property := strings.TrimSpace(p) - field, _ := v.Type().FieldByNameFunc(func(p string) bool { - return strings.EqualFold(property, p) - }) - name := field.Tag.Get("json") - - if name != "" && name != "-" { - // '-' in the json tag means to not return that property - newObj[name] = v.FieldByNameFunc(func(p string) bool { - return strings.EqualFold(property, p) - }).Interface() - } - } - - result[i] = newObj - } - - return PagedResponse[map[string]interface{}]{Value: result, Count: totalCount} -} diff --git a/response_test.go b/response_test.go deleted file mode 100644 index 2a6742f..0000000 --- a/response_test.go +++ /dev/null @@ -1,64 +0,0 @@ -package goatquery - -import ( - "testing" - - "github.com/google/uuid" - "github.com/stretchr/testify/assert" -) - -func Test_AllPropertiesAreReturned(t *testing.T) { - query := Query{} - - data := []User{ - { - Base: Base{Id: uuid.New()}, - Firstname: "John", - Lastname: "Doe", - Email: "John.Doe@email.com", - }, - } - - res := BuildPagedResponse(data, query, nil) - - assert.Contains(t, res.Value[0], "id") -} - -func Test_SelectUUIDTypeReturnsCorrectValue(t *testing.T) { - field := "id" - query := Query{Select: field} - uuid := uuid.New() - - data := []User{ - { - Base: Base{Id: uuid}, - Firstname: "John", - Lastname: "Doe", - Email: "John.Doe@email.com", - }, - } - - res := BuildPagedResponse(data, query, nil) - - assert.Equal(t, uuid, res.Value[0][field]) -} - -func Test_SelectIntTypeReturnsCorrectValue(t *testing.T) { - field := "age" - query := Query{Select: field} - age := uint(21) - - data := []User{ - { - Age: age, - Base: Base{Id: uuid.New()}, - Firstname: "John", - Lastname: "Doe", - Email: "John.Doe@email.com", - }, - } - - res := BuildPagedResponse(data, query, nil) - - assert.Equal(t, age, res.Value[0][field]) -} diff --git a/token/token.go b/token/token.go new file mode 100644 index 0000000..926fdec --- /dev/null +++ b/token/token.go @@ -0,0 +1,40 @@ +package token + +import "strings" + +const ( + ILLEGAL = "ILLEGAL" + EOF = "EOF" + + IDENT = "IDENT" + INT = "INT" + STRING = "STRING" + + // Keywords + ASC = "ASC" + DESC = "DESC" +) + +var keywords = map[string]TokenType{ + "asc": ASC, + "desc": DESC, +} + +func LookupIdent(identifier string) TokenType { + if tok, ok := keywords[strings.ToLower(identifier)]; ok { + return tok + } + + return IDENT +} + +type TokenType string + +type Token struct { + Type TokenType + Literal string +} + +func NewToken(tokenType TokenType, character byte) Token { + return Token{Type: tokenType, Literal: string(character)} +} diff --git a/types.go b/types.go deleted file mode 100644 index 15dcb86..0000000 --- a/types.go +++ /dev/null @@ -1,21 +0,0 @@ -package goatquery - -type PagedResponse[T any] struct { - Count *int64 `json:"count,omitempty"` - Value []T `json:"value"` -} - -type QueryErrorResponse struct { - Status uint `json:"status"` - Message string `json:"message"` -} - -type Query struct { - Top int - Skip int - Count bool - OrderBy string - Select string - Search string - Filter string -} diff --git a/utils.go b/utils.go deleted file mode 100644 index cc47e0f..0000000 --- a/utils.go +++ /dev/null @@ -1,79 +0,0 @@ -package goatquery - -import ( - "regexp" - "strings" -) - -var filterOperations = map[string]string{ - "eq": "=", - "ne": "<>", - "contains": "like", -} - -func splitString(input string) []string { - var result []string - var buffer strings.Builder - var singleQuote bool - - for i := 0; i < len(input); i++ { - char := input[i] - - if char == '\'' { - buffer.WriteRune(rune(char)) - singleQuote = !singleQuote - } else if !singleQuote && (char == 'a' || char == 'o') && i+1 < len(input) && (input[i-1:i+3] == " and" || input[i-1:i+2] == " or") { - if buffer.Len() > 0 { - result = append(result, strings.TrimSpace(buffer.String())) - buffer.Reset() - } - - result = append(result, strings.TrimSpace(input[i:i+3])) - i += 2 - } else { - buffer.WriteRune(rune(char)) - } - } - - if buffer.Len() > 0 { - result = append(result, strings.TrimSpace(buffer.String())) - } - - return result -} - -func splitStringByWhitespace(str string) []string { - var parts []string - var sb strings.Builder - singleQuote := false - - for _, char := range str { - switch char { - case ' ': - if singleQuote { - sb.WriteRune(char) - } else { - parts = append(parts, sb.String()) - sb.Reset() - } - case '\'': - singleQuote = !singleQuote - sb.WriteRune(char) - default: - sb.WriteRune(char) - } - } - - parts = append(parts, sb.String()) - - return parts -} - -func getValueBetweenQuotes(input string) string { - re := regexp.MustCompile(`'([^']*)'`) - match := re.FindStringSubmatch(input) - if len(match) > 1 { - return match[1] - } - return match[0] -} diff --git a/utils_test.go b/utils_test.go deleted file mode 100644 index 2720bf7..0000000 --- a/utils_test.go +++ /dev/null @@ -1,43 +0,0 @@ -package goatquery - -import ( - "testing" - - "github.com/stretchr/testify/assert" -) - -func Test_splitStringOnMultipleDelimiters(t *testing.T) { - filter := "firstname eq 'goat'" - - result := splitString(filter) - - assert.Equal(t, 1, len(result)) - assert.Equal(t, []string{"firstname eq 'goat'"}, result) -} - -func Test_splitStringOnMultipleDelimitersAnd(t *testing.T) { - filter := "firstname eq 'goat' and lastname eq 'query'" - - result := splitString(filter) - - assert.Equal(t, 3, len(result)) - assert.Equal(t, []string{"firstname eq 'goat'", "and", "lastname eq 'query'"}, result) -} - -func Test_splitStringOnMultipleDelimiterOr(t *testing.T) { - filter := "firstname eq 'and' or lastname eq 'and'" - - result := splitString(filter) - - assert.Equal(t, 3, len(result)) - assert.Equal(t, []string{"firstname eq 'and'", "or", "lastname eq 'and'"}, result) -} - -func Test_splitStringOnMultipleDelimiterOrWithSpace(t *testing.T) { - filter := "firstname eq ' and ' or lastname eq ' and or '" - - result := splitString(filter) - - assert.Equal(t, 3, len(result)) - assert.Equal(t, []string{"firstname eq ' and '", "or", "lastname eq ' and or '"}, result) -} From 231abb39761f6f889e7bd5d18589f04223f722a0 Mon Sep 17 00:00:00 2001 From: Jamess-Lucass <23193271+Jamess-Lucass@users.noreply.github.com> Date: Wed, 22 May 2024 23:35:16 +0100 Subject: [PATCH 02/14] wip --- module/gorm/apply.go | 63 +++++++++ module/gorm/apply_test.go | 275 +++++++++++++++++++++++++++++++++++++ module/gorm/go.mod | 1 + module/gorm/orderby.go | 11 -- module/gorm/parser.go | 2 - module/gorm/parser_test.go | 33 ----- query.go | 4 + response.go | 6 + 8 files changed, 349 insertions(+), 46 deletions(-) create mode 100644 module/gorm/apply.go create mode 100644 module/gorm/apply_test.go delete mode 100644 module/gorm/orderby.go delete mode 100644 module/gorm/parser.go delete mode 100644 module/gorm/parser_test.go create mode 100644 response.go diff --git a/module/gorm/apply.go b/module/gorm/apply.go new file mode 100644 index 0000000..b47bd95 --- /dev/null +++ b/module/gorm/apply.go @@ -0,0 +1,63 @@ +package gorm + +import ( + "fmt" + + "github.com/goatquery/goatquery-go" + "github.com/goatquery/goatquery-go/lexer" + "github.com/goatquery/goatquery-go/parser" + "gorm.io/gorm" +) + +type SearchFunc = func(db *gorm.DB, searchTerm string) *gorm.DB + +func Apply(db *gorm.DB, query goatquery.Query, model interface{}, searchFunc SearchFunc, options *goatquery.QueryOptions) (*gorm.DB, *int64, error) { + if options != nil && query.Top > options.MaxTop { + return nil, nil, fmt.Errorf("The value supplied for the query parameter 'Top' was greater than the maximum top allowed for this resource") + } + + // Order by + if query.OrderBy != "" { + l := lexer.NewLexer(query.OrderBy) + p := parser.NewParser(l) + + statements := p.ParseOrderBy() + + for _, statement := range statements { + sql := fmt.Sprintf("%s %s", statement.TokenLiteral(), statement.Direction) + + db = db.Order(sql) + } + } + + // Search + if searchFunc != nil && query.Search != "" { + db = searchFunc(db, query.Search) + } + + // Count + var count int64 + if query.Count { + db.Model(&model).Count(&count) + } + + // Skip + if query.Skip > 0 { + db = db.Offset(query.Skip) + } + + // Top + if query.Top > 0 { + db = db.Limit(query.Top) + } + + if query.Top <= 0 && options != nil && options.MaxTop > 0 { + db = db.Limit(options.MaxTop) + } + + if query.Count { + return db, &count, nil + } + + return db, nil, nil +} diff --git a/module/gorm/apply_test.go b/module/gorm/apply_test.go new file mode 100644 index 0000000..abcac91 --- /dev/null +++ b/module/gorm/apply_test.go @@ -0,0 +1,275 @@ +package gorm + +import ( + "fmt" + "os" + "testing" + + "github.com/glebarez/sqlite" + "github.com/goatquery/goatquery-go" + "github.com/stretchr/testify/assert" + "gorm.io/gorm" + "gorm.io/gorm/logger" +) + +type User struct { + Age uint + Firstname string +} + +var DB *gorm.DB + +func TestMain(m *testing.M) { + setup() + code := m.Run() + os.Exit(code) +} + +func setup() { + db, err := gorm.Open(sqlite.Open("file::memory:?cache=shared"), &gorm.Config{ + Logger: logger.Default.LogMode(logger.Info), + }) + + if err != nil { + panic("failed to connect database") + } + DB = db + + db.AutoMigrate(&User{}) + + if err := db.Model(&User{}).Create([]User{ + {2, "John"}, + {1, "Jane"}, + {2, "Apple"}, + {1, "Harry"}, + {3, "Doe"}, + {3, "Egg"}, + }).Error; err != nil { + panic("failed to seed") + } +} + +func Test_OrderBy(t *testing.T) { + tests := []struct { + input string + expected []User + }{ + {"age desc, firstname asc", []User{ + {3, "Doe"}, + {3, "Egg"}, + {2, "Apple"}, + {2, "John"}, + {1, "Harry"}, + {1, "Jane"}, + }}, + } + + for _, test := range tests { + query := goatquery.Query{ + OrderBy: test.input, + } + + var output []User + res, _, err := Apply(DB, query, &output, nil, nil) + assert.NoError(t, err) + + err = res.Find(&output).Error + assert.NoError(t, err) + + assert.Equal(t, test.expected, output) + } +} + +func Test_Count(t *testing.T) { + tests := []struct { + input bool + expectedCount *int64 + }{ + {true, makeIntPointer(6)}, + {false, nil}, + } + + for _, test := range tests { + query := goatquery.Query{ + Count: test.input, + } + + _, count, err := Apply(DB, query, &User{}, nil, nil) + assert.NoError(t, err) + + assert.Equal(t, test.expectedCount, count) + } +} + +func Test_Search(t *testing.T) { + tests := []struct { + input string + expectedCount int + }{ + {"john", 1}, + {"JOHN", 1}, + {"j", 2}, + {"e", 4}, + {"eg", 1}, + } + + searchFunc := func(db *gorm.DB, searchTerm string) *gorm.DB { + return db.Where("firstname like ?", fmt.Sprintf("%%%s%%", searchTerm)) // Escape % for LIKE + } + + for _, test := range tests { + query := goatquery.Query{ + Search: test.input, + } + + var output []User + res, _, err := Apply(DB, query, &output, searchFunc, nil) + assert.NoError(t, err) + + err = res.Find(&output).Error + assert.NoError(t, err) + + assert.Len(t, output, test.expectedCount) + } +} + +func Test_Skip(t *testing.T) { + tests := []struct { + input int + expected []User + }{ + {1, []User{ + {1, "Jane"}, + {2, "Apple"}, + {2, "John"}, + {3, "Doe"}, + {3, "Egg"}, + }}, + {2, []User{ + {2, "Apple"}, + {2, "John"}, + {3, "Doe"}, + {3, "Egg"}, + }}, + {3, []User{ + {2, "John"}, + {3, "Doe"}, + {3, "Egg"}, + }}, + {4, []User{ + {3, "Doe"}, + {3, "Egg"}, + }}, + {5, []User{ + {3, "Egg"}, + }}, + {6, []User{}}, + {10_000, []User{}}, + } + + for _, test := range tests { + query := goatquery.Query{ + Skip: test.input, + OrderBy: "age asc, firstname asc", + } + + var output []User + res, _, err := Apply(DB, query, &output, nil, nil) + assert.NoError(t, err) + + err = res.Find(&output).Error + assert.NoError(t, err) + + assert.Equal(t, test.expected, output) + } +} + +func Test_Top(t *testing.T) { + tests := []struct { + input int + expectedCount int + }{ + {-1, 6}, + {0, 6}, + {1, 1}, + {2, 2}, + {3, 3}, + {4, 4}, + {5, 5}, + {100, 6}, + {100_000, 6}, + } + + for _, test := range tests { + query := goatquery.Query{ + Top: test.input, + } + + var output []User + res, _, err := Apply(DB, query, &output, nil, nil) + assert.NoError(t, err) + + err = res.Find(&output).Error + assert.NoError(t, err) + + assert.Len(t, output, test.expectedCount) + } +} + +func Test_TopWithMaxTop(t *testing.T) { + tests := []struct { + input int + expectedCount int + }{ + {-1, 4}, + {0, 4}, + {1, 1}, + {2, 2}, + {3, 3}, + {4, 4}, + } + + for _, test := range tests { + query := goatquery.Query{ + Top: test.input, + } + + options := goatquery.QueryOptions{ + MaxTop: 4, + } + + var output []User + res, _, err := Apply(DB, query, &output, nil, &options) + assert.NoError(t, err) + + err = res.Find(&output).Error + assert.NoError(t, err) + + assert.Len(t, output, test.expectedCount) + } +} + +func Test_TopWithMaxTopReturnsError(t *testing.T) { + tests := []int{ + 5, + 100, + 100_000, + } + + for _, test := range tests { + query := goatquery.Query{ + Top: test, + } + + options := goatquery.QueryOptions{ + MaxTop: 4, + } + + _, _, err := Apply(DB, query, &User{}, nil, &options) + assert.Error(t, err) + } +} + +func makeIntPointer(v int64) *int64 { + return &v +} diff --git a/module/gorm/go.mod b/module/gorm/go.mod index 44a47b6..755902a 100644 --- a/module/gorm/go.mod +++ b/module/gorm/go.mod @@ -4,6 +4,7 @@ go 1.22.0 require ( github.com/glebarez/sqlite v1.11.0 + github.com/goatquery/goatquery-go v0.0.0-00010101000000-000000000000 github.com/stretchr/testify v1.9.0 gorm.io/gorm v1.25.10 ) diff --git a/module/gorm/orderby.go b/module/gorm/orderby.go deleted file mode 100644 index 4c1e24c..0000000 --- a/module/gorm/orderby.go +++ /dev/null @@ -1,11 +0,0 @@ -package gorm - -import "gorm.io/gorm" - -func EvaluateOrderBy(db *gorm.DB, orderby string) *gorm.DB { - if orderby != "" { - db = db.Order(orderby) - } - - return db -} diff --git a/module/gorm/parser.go b/module/gorm/parser.go deleted file mode 100644 index c3e14a4..0000000 --- a/module/gorm/parser.go +++ /dev/null @@ -1,2 +0,0 @@ -package gorm - diff --git a/module/gorm/parser_test.go b/module/gorm/parser_test.go deleted file mode 100644 index a651e89..0000000 --- a/module/gorm/parser_test.go +++ /dev/null @@ -1,33 +0,0 @@ -package gorm - -import ( - "testing" - - "github.com/glebarez/sqlite" - "github.com/stretchr/testify/assert" - "gorm.io/gorm" - "gorm.io/gorm/logger" -) - -func Test_ParsingOrderBy(t *testing.T) { - type Test struct { - name string - } - - db, err := gorm.Open(sqlite.Open("file::memory:?cache=shared"), &gorm.Config{ - Logger: logger.Default.LogMode(logger.Error), - }) - - assert.NoError(t, err) - - expectedSql := db.ToSQL(func(tx *gorm.DB) *gorm.DB { - return tx.Model(&Test{}).Order("name").Find(&[]Test{}) - }) - - sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB { - res := EvaluateOrderBy(tx, "name") - return res.Find(&[]Test{}) - }) - - assert.Equal(t, expectedSql, sql) -} diff --git a/query.go b/query.go index dc65daf..605ea07 100644 --- a/query.go +++ b/query.go @@ -9,3 +9,7 @@ type Query struct { Search string Filter string } + +type QueryOptions struct { + MaxTop int +} diff --git a/response.go b/response.go new file mode 100644 index 0000000..7a7b49e --- /dev/null +++ b/response.go @@ -0,0 +1,6 @@ +package goatquery + +type PagedResponse[T any] struct { + Count *int64 `json:"count,omitempty"` + Value []T `json:"value"` +} From e3bb6e6342f8dd7e586b4e1037be3e4363a8b224 Mon Sep 17 00:00:00 2001 From: Jamess-Lucass <23193271+Jamess-Lucass@users.noreply.github.com> Date: Wed, 22 May 2024 23:40:30 +0100 Subject: [PATCH 03/14] wip --- .github/workflows/test.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index d72f890..ed20a4b 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -16,9 +16,10 @@ jobs: - uses: actions/checkout@v3 - name: Setup Go ${{ matrix.go-version }} - uses: actions/setup-go@v4 + uses: actions/setup-go@v5 with: go-version: ${{ matrix.go-version }} + cache-dependency-path: '**/go.sum' - name: Install dependencies run: go get . From 50f3d153e34e0ea4d2713f08e8593e4e33b72c47 Mon Sep 17 00:00:00 2001 From: Jamess-Lucass <23193271+Jamess-Lucass@users.noreply.github.com> Date: Wed, 22 May 2024 23:43:40 +0100 Subject: [PATCH 04/14] wip --- .github/workflows/test.yml | 3 +-- module/gorm/go.mod | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index ed20a4b..5d42ab4 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -2,7 +2,6 @@ name: test on: push: - pull_request: workflow_dispatch: jobs: @@ -13,7 +12,7 @@ jobs: go-version: ["1.20.x", "1.21.x"] steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Setup Go ${{ matrix.go-version }} uses: actions/setup-go@v5 diff --git a/module/gorm/go.mod b/module/gorm/go.mod index 755902a..3262699 100644 --- a/module/gorm/go.mod +++ b/module/gorm/go.mod @@ -1,6 +1,6 @@ module github.com/goatquery/goatquery-go/module/gorm -go 1.22.0 +go 1.22 require ( github.com/glebarez/sqlite v1.11.0 From 1c1fcd1e90e31fa0b3683bd6c007bc5f47f3d41c Mon Sep 17 00:00:00 2001 From: Jamess-Lucass <23193271+Jamess-Lucass@users.noreply.github.com> Date: Wed, 22 May 2024 23:44:12 +0100 Subject: [PATCH 05/14] wip --- .github/workflows/test.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 5d42ab4..27e591b 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -9,7 +9,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - go-version: ["1.20.x", "1.21.x"] + go-version: ["1.20.x", "1.21.x", "1.22.x"] steps: - uses: actions/checkout@v4 From cc527c236c086d681d547a45885798eee8b4a01a Mon Sep 17 00:00:00 2001 From: Jamess-Lucass <23193271+Jamess-Lucass@users.noreply.github.com> Date: Wed, 22 May 2024 23:47:13 +0100 Subject: [PATCH 06/14] wip --- .github/workflows/test.yml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 27e591b..fa6a318 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -14,6 +14,11 @@ jobs: steps: - uses: actions/checkout@v4 + - uses: actions/setup-go@v5 + with: + go-version: '1.22' + cache: false + - name: Setup Go ${{ matrix.go-version }} uses: actions/setup-go@v5 with: From f1993a4101ec951d521e74caf749fb27ff838db8 Mon Sep 17 00:00:00 2001 From: Jamess-Lucass <23193271+Jamess-Lucass@users.noreply.github.com> Date: Wed, 22 May 2024 23:48:25 +0100 Subject: [PATCH 07/14] wip --- .github/workflows/test.yml | 5 ----- 1 file changed, 5 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index fa6a318..27e591b 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -14,11 +14,6 @@ jobs: steps: - uses: actions/checkout@v4 - - uses: actions/setup-go@v5 - with: - go-version: '1.22' - cache: false - - name: Setup Go ${{ matrix.go-version }} uses: actions/setup-go@v5 with: From 15a671b26340604e2e33e5db12195d7c79587734 Mon Sep 17 00:00:00 2001 From: Jamess-Lucass <23193271+Jamess-Lucass@users.noreply.github.com> Date: Tue, 28 May 2024 21:19:38 +0100 Subject: [PATCH 08/14] wip --- ast/ast.go | 57 ++++++++++++++++++++++++++++++ keywords/keyword.go | 9 +++++ lexer/lexer.go | 7 ++-- lexer/lexer_test.go | 52 +++++++++++++++++++++++++--- parser/parser.go | 80 +++++++++++++++++++++++++++++++++++++++++-- parser/parser_test.go | 73 +++++++++++++++++++++++++++++++++++++++ token/token.go | 19 ---------- 7 files changed, 268 insertions(+), 29 deletions(-) create mode 100644 keywords/keyword.go diff --git a/ast/ast.go b/ast/ast.go index 42eb885..d21284d 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -13,6 +13,11 @@ type Statement interface { statementNode() } +type Expression interface { + Node + expressionNode() +} + type OrderByDirection string const ( @@ -29,3 +34,55 @@ var _ Statement = (*OrderByStatement)(nil) func (s *OrderByStatement) statementNode() {} func (s *OrderByStatement) TokenLiteral() string { return s.Token.Literal } + +type Identifier struct { + Token token.Token + Value string +} + +var _ Expression = (*Identifier)(nil) + +func (i *Identifier) expressionNode() {} +func (i *Identifier) TokenLiteral() string { return i.Token.Literal } + +type ExpressionStatement struct { + Token token.Token + Expression InfixExpression +} + +var _ Statement = (*ExpressionStatement)(nil) + +func (s *ExpressionStatement) statementNode() {} +func (s *ExpressionStatement) TokenLiteral() string { return s.Token.Literal } + +type InfixExpression struct { + Token token.Token + Left Expression + Operator string + Right Expression +} + +var _ Expression = (*InfixExpression)(nil) + +func (s *InfixExpression) expressionNode() {} +func (s *InfixExpression) TokenLiteral() string { return s.Token.Literal } + +type StringLiteral struct { + Token token.Token + Value string +} + +var _ Expression = (*StringLiteral)(nil) + +func (s *StringLiteral) expressionNode() {} +func (s *StringLiteral) TokenLiteral() string { return s.Token.Literal } + +type IntegerLiteral struct { + Token token.Token + Value int64 +} + +var _ Expression = (*IntegerLiteral)(nil) + +func (s *IntegerLiteral) expressionNode() {} +func (s *IntegerLiteral) TokenLiteral() string { return s.Token.Literal } diff --git a/keywords/keyword.go b/keywords/keyword.go new file mode 100644 index 0000000..c17d9ee --- /dev/null +++ b/keywords/keyword.go @@ -0,0 +1,9 @@ +package keyword + +const ( + ASC = "ASC" + DESC = "DESC" + EQ = "EQ" + AND = "AND" + OR = "OR" +) diff --git a/lexer/lexer.go b/lexer/lexer.go index c80e2fe..ba93aae 100644 --- a/lexer/lexer.go +++ b/lexer/lexer.go @@ -36,10 +36,13 @@ func (l *Lexer) NextToken() token.Token { case 0: tok.Literal = "" tok.Type = token.EOF + case '\'': + tok.Type = token.STRING + tok.Literal = l.readString() default: if isLetter(l.character) { tok.Literal = l.readIdentifier() - tok.Type = token.LookupIdent(tok.Literal) + tok.Type = token.IDENT return tok } else if isDigit(l.character) { tok.Literal = l.readNumber() @@ -84,7 +87,7 @@ func (l *Lexer) readString() string { for { l.readCharacter() - if l.character == '"' || l.character == 0 { + if l.character == '\'' || l.character == 0 { break } } diff --git a/lexer/lexer_test.go b/lexer/lexer_test.go index 863cf48..bf7ff22 100644 --- a/lexer/lexer_test.go +++ b/lexer/lexer_test.go @@ -20,19 +20,61 @@ func Test_OrderByNextToken(t *testing.T) { expectedLiteral string }{ {token.IDENT, "id"}, - {token.ASC, "asc"}, + {token.IDENT, "asc"}, {token.IDENT, "iD"}, - {token.DESC, "desc"}, + {token.IDENT, "desc"}, {token.IDENT, "id"}, - {token.ASC, "aSc"}, + {token.IDENT, "aSc"}, {token.IDENT, "id"}, - {token.DESC, "DeSc"}, + {token.IDENT, "DeSc"}, {token.IDENT, "id"}, - {token.ASC, "AsC"}, + {token.IDENT, "AsC"}, + } + + lexer := NewLexer(input) + + for _, test := range tests { + token := lexer.NextToken() + + assert.Equal(t, test.expectedType, token.Type) + assert.Equal(t, test.expectedLiteral, token.Literal) + } +} + +func Test_FilterNextToken(t *testing.T) { + input := `Name eq 'John' + Id eq 1 + Name eq 'John' and Id eq 1 + eq eq 'John' + ` + + tests := []struct { + expectedType token.TokenType + expectedLiteral string + }{ + {token.IDENT, "Name"}, + {token.IDENT, "eq"}, + {token.STRING, "John"}, + + {token.IDENT, "Id"}, + {token.IDENT, "eq"}, + {token.INT, "1"}, + + {token.IDENT, "Name"}, + {token.IDENT, "eq"}, + {token.STRING, "John"}, + {token.IDENT, "and"}, + {token.IDENT, "Id"}, + {token.IDENT, "eq"}, + {token.INT, "1"}, + + {token.IDENT, "eq"}, + {token.IDENT, "eq"}, + {token.STRING, "John"}, } lexer := NewLexer(input) diff --git a/parser/parser.go b/parser/parser.go index 30a6530..4f6e79e 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -1,7 +1,11 @@ package parser import ( + "strconv" + "strings" + "github.com/goatquery/goatquery-go/ast" + keyword "github.com/goatquery/goatquery-go/keywords" "github.com/goatquery/goatquery-go/lexer" "github.com/goatquery/goatquery-go/token" ) @@ -38,12 +42,12 @@ func (p *Parser) ParseOrderBy() []ast.OrderByStatement { statement := &ast.OrderByStatement{Token: p.currentToken, Direction: ast.Ascending} - if p.peekTokenIs(token.DESC) { + if p.peekIdentiferIs(keyword.DESC) { statement.Direction = ast.Descending - - p.NextToken() } + p.NextToken() + statements = append(statements, *statement) p.NextToken() @@ -52,6 +56,68 @@ func (p *Parser) ParseOrderBy() []ast.OrderByStatement { return statements } +func (p *Parser) ParseFilter() *ast.ExpressionStatement { + statement := &ast.ExpressionStatement{Token: p.currentToken} + statement.Expression = p.ParseExpression() + + return statement +} + +func (p *Parser) ParseExpression() ast.InfixExpression { + left := p.ParseFilterStatement() + + p.NextToken() + + for p.currentIdentiferIs(keyword.AND) || p.currentIdentiferIs(keyword.OR) { + left = &ast.InfixExpression{Token: p.currentToken, Left: left, Operator: p.currentToken.Literal} + + p.NextToken() + + right := p.ParseFilterStatement() + left.Right = right + + p.NextToken() + } + + return *left +} + +func (p *Parser) ParseFilterStatement() *ast.InfixExpression { + identifer := ast.Identifier{Token: p.currentToken, Value: p.currentToken.Literal} + + if !p.peekIdentiferIs(keyword.EQ) { + return nil + } + + p.NextToken() + + statement := ast.InfixExpression{Token: p.currentToken, Left: &identifer, Operator: p.currentToken.Literal} + + if !p.peekTokenIs(token.STRING) && !p.peekTokenIs(token.INT) { + return nil + } + + p.NextToken() + + switch p.currentToken.Type { + case token.STRING: + statement.Right = &ast.StringLiteral{Token: p.currentToken, Value: p.currentToken.Literal} + case token.INT: + literal := &ast.IntegerLiteral{Token: p.currentToken} + + value, err := strconv.ParseInt(p.currentToken.Literal, 0, 64) + if err != nil { + return nil + } + + literal.Value = value + + statement.Right = literal + } + + return &statement +} + func (p *Parser) currentTokenIs(t token.TokenType) bool { return p.currentToken.Type == t } @@ -59,3 +125,11 @@ func (p *Parser) currentTokenIs(t token.TokenType) bool { func (p *Parser) peekTokenIs(t token.TokenType) bool { return p.peekToken.Type == t } + +func (p *Parser) peekIdentiferIs(identifier string) bool { + return p.peekToken.Type == token.IDENT && strings.EqualFold(p.peekToken.Literal, identifier) +} + +func (p *Parser) currentIdentiferIs(identifier string) bool { + return p.currentToken.Type == token.IDENT && strings.EqualFold(p.currentToken.Literal, identifier) +} diff --git a/parser/parser_test.go b/parser/parser_test.go index d2b3b53..c68afd4 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -32,3 +32,76 @@ func Test_ParsingOrderByStatement(t *testing.T) { assert.Equal(t, test.expectedDirection, stmt.Direction) } } + +func Test_ParsingFilterStatement(t *testing.T) { + tests := []struct { + input string + expectedLeft string + expectedOperator string + expectedRight string + }{ + {"Name eq 'John'", "Name", "eq", "John"}, + {"Firstname eq 'Jane'", "Firstname", "eq", "Jane"}, + {"Age eq 21", "Age", "eq", "21"}, + } + + for _, test := range tests { + l := lexer.NewLexer(test.input) + p := NewParser(l) + + statement := p.ParseFilter() + + expression := statement.Expression + assert.NotNil(t, expression) + + assert.Equal(t, test.expectedLeft, expression.Left.TokenLiteral()) + assert.Equal(t, test.expectedOperator, expression.Operator) + assert.Equal(t, test.expectedRight, expression.Right.TokenLiteral()) + } +} + +func Test_ParsingComplexFilterStatement(t *testing.T) { + input := `Name eq 'John' and Age eq 10 or Id eq 10` + + l := lexer.NewLexer(input) + p := NewParser(l) + + statement := p.ParseFilter() + + expression := statement.Expression + assert.NotNil(t, expression) + + //Left + left, ok := expression.Left.(*ast.InfixExpression) + assert.True(t, ok) + + // Inner left + innerLeft, ok := left.Left.(*ast.InfixExpression) + assert.True(t, ok) + + assert.Equal(t, "Name", innerLeft.Left.TokenLiteral()) + assert.Equal(t, "eq", innerLeft.Operator) + assert.Equal(t, "John", innerLeft.Right.TokenLiteral()) + + // inner operator + assert.Equal(t, "and", left.Operator) + + // inner right + innerRight, ok := left.Right.(*ast.InfixExpression) + assert.True(t, ok) + + assert.Equal(t, "Age", innerRight.Left.TokenLiteral()) + assert.Equal(t, "eq", innerRight.Operator) + assert.Equal(t, "10", innerRight.Right.TokenLiteral()) + + // operator + assert.Equal(t, "or", expression.Operator) + + // right + right, ok := expression.Right.(*ast.InfixExpression) + assert.True(t, ok) + + assert.Equal(t, "Id", right.Left.TokenLiteral()) + assert.Equal(t, "eq", right.Operator) + assert.Equal(t, "10", right.Right.TokenLiteral()) +} diff --git a/token/token.go b/token/token.go index 926fdec..4baff41 100644 --- a/token/token.go +++ b/token/token.go @@ -1,7 +1,5 @@ package token -import "strings" - const ( ILLEGAL = "ILLEGAL" EOF = "EOF" @@ -9,25 +7,8 @@ const ( IDENT = "IDENT" INT = "INT" STRING = "STRING" - - // Keywords - ASC = "ASC" - DESC = "DESC" ) -var keywords = map[string]TokenType{ - "asc": ASC, - "desc": DESC, -} - -func LookupIdent(identifier string) TokenType { - if tok, ok := keywords[strings.ToLower(identifier)]; ok { - return tok - } - - return IDENT -} - type TokenType string type Token struct { From 81c70e139a6b50a35ed58b3e335879baa333d037 Mon Sep 17 00:00:00 2001 From: Jamess-Lucass <23193271+Jamess-Lucass@users.noreply.github.com> Date: Fri, 28 Jun 2024 23:24:50 +0100 Subject: [PATCH 09/14] v2 --- keywords/keyword.go | 12 ++++--- lexer/lexer.go | 4 +++ lexer/lexer_test.go | 64 ++++++++++++++++++++++++++++++++++ parser/parser.go | 80 ++++++++++++++++++++++++++++++++++++------- parser/parser_test.go | 35 +++++++++++++------ query.go | 1 - token/token.go | 3 ++ 7 files changed, 171 insertions(+), 28 deletions(-) diff --git a/keywords/keyword.go b/keywords/keyword.go index c17d9ee..f2fd6c6 100644 --- a/keywords/keyword.go +++ b/keywords/keyword.go @@ -1,9 +1,13 @@ -package keyword +package keywords const ( ASC = "ASC" DESC = "DESC" - EQ = "EQ" - AND = "AND" - OR = "OR" + + EQ = "EQ" + NE = "NE" + CONTAINS = "CONTAINS" + + AND = "AND" + OR = "OR" ) diff --git a/lexer/lexer.go b/lexer/lexer.go index ba93aae..1f1d46b 100644 --- a/lexer/lexer.go +++ b/lexer/lexer.go @@ -36,6 +36,10 @@ func (l *Lexer) NextToken() token.Token { case 0: tok.Literal = "" tok.Type = token.EOF + case '(': + tok = token.NewToken(token.LPAREN, l.character) + case ')': + tok = token.NewToken(token.RPAREN, l.character) case '\'': tok.Type = token.STRING tok.Literal = l.readString() diff --git a/lexer/lexer_test.go b/lexer/lexer_test.go index bf7ff22..373dec4 100644 --- a/lexer/lexer_test.go +++ b/lexer/lexer_test.go @@ -13,6 +13,7 @@ func Test_OrderByNextToken(t *testing.T) { id aSc id DeSc id AsC + asc asc ` tests := []struct { @@ -33,6 +34,9 @@ func Test_OrderByNextToken(t *testing.T) { {token.IDENT, "id"}, {token.IDENT, "AsC"}, + + {token.IDENT, "asc"}, + {token.IDENT, "asc"}, } lexer := NewLexer(input) @@ -50,6 +54,12 @@ func Test_FilterNextToken(t *testing.T) { Id eq 1 Name eq 'John' and Id eq 1 eq eq 'John' + Name eq 'john' or Id eq 1 + Id eq 1 and Name eq 'John' or Id eq 2 + Id eq 1 or Name eq 'John' or Id eq 2 + Id ne 1 + Name contains 'John' + (Id eq 1 or Id eq 2) and Name eq 'John' ` tests := []struct { @@ -75,6 +85,60 @@ func Test_FilterNextToken(t *testing.T) { {token.IDENT, "eq"}, {token.IDENT, "eq"}, {token.STRING, "John"}, + + {token.IDENT, "Name"}, + {token.IDENT, "eq"}, + {token.STRING, "john"}, + {token.IDENT, "or"}, + {token.IDENT, "Id"}, + {token.IDENT, "eq"}, + {token.INT, "1"}, + + {token.IDENT, "Id"}, + {token.IDENT, "eq"}, + {token.INT, "1"}, + {token.IDENT, "and"}, + {token.IDENT, "Name"}, + {token.IDENT, "eq"}, + {token.STRING, "John"}, + {token.IDENT, "or"}, + {token.IDENT, "Id"}, + {token.IDENT, "eq"}, + {token.INT, "2"}, + + {token.IDENT, "Id"}, + {token.IDENT, "eq"}, + {token.INT, "1"}, + {token.IDENT, "or"}, + {token.IDENT, "Name"}, + {token.IDENT, "eq"}, + {token.STRING, "John"}, + {token.IDENT, "or"}, + {token.IDENT, "Id"}, + {token.IDENT, "eq"}, + {token.INT, "2"}, + + {token.IDENT, "Id"}, + {token.IDENT, "ne"}, + {token.INT, "1"}, + + {token.IDENT, "Name"}, + {token.IDENT, "contains"}, + {token.STRING, "John"}, + + {token.LPAREN, "("}, + {token.IDENT, "Id"}, + {token.IDENT, "eq"}, + {token.INT, "1"}, + {token.IDENT, "or"}, + {token.IDENT, "Id"}, + {token.IDENT, "eq"}, + {token.INT, "2"}, + {token.RPAREN, ")"}, + {token.IDENT, "and"}, + {token.IDENT, "Name"}, + {token.IDENT, "eq"}, + {token.STRING, "John"}, } lexer := NewLexer(input) diff --git a/parser/parser.go b/parser/parser.go index 4f6e79e..a811d35 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -5,7 +5,7 @@ import ( "strings" "github.com/goatquery/goatquery-go/ast" - keyword "github.com/goatquery/goatquery-go/keywords" + "github.com/goatquery/goatquery-go/keywords" "github.com/goatquery/goatquery-go/lexer" "github.com/goatquery/goatquery-go/token" ) @@ -42,7 +42,7 @@ func (p *Parser) ParseOrderBy() []ast.OrderByStatement { statement := &ast.OrderByStatement{Token: p.currentToken, Direction: ast.Ascending} - if p.peekIdentiferIs(keyword.DESC) { + if p.peekIdentiferIs(keywords.DESC) { statement.Direction = ast.Descending } @@ -58,34 +58,55 @@ func (p *Parser) ParseOrderBy() []ast.OrderByStatement { func (p *Parser) ParseFilter() *ast.ExpressionStatement { statement := &ast.ExpressionStatement{Token: p.currentToken} - statement.Expression = p.ParseExpression() + statement.Expression = p.ParseExpression(0) return statement } -func (p *Parser) ParseExpression() ast.InfixExpression { - left := p.ParseFilterStatement() +func (p *Parser) ParseExpression(precedence int) ast.InfixExpression { + var left *ast.InfixExpression - p.NextToken() + if p.currentTokenIs(token.LPAREN) { + left = p.ParseGroupedExpression() + } else { + left = p.ParseFilterStatement() + } - for p.currentIdentiferIs(keyword.AND) || p.currentIdentiferIs(keyword.OR) { - left = &ast.InfixExpression{Token: p.currentToken, Left: left, Operator: p.currentToken.Literal} + p.NextToken() - p.NextToken() + for !p.currentTokenIs(token.EOF) && precedence < p.GetPrecedence(p.currentToken.Type) { + if p.currentIdentiferIs(keywords.AND) || p.currentIdentiferIs(keywords.OR) { + left = &ast.InfixExpression{Token: p.currentToken, Left: left, Operator: p.currentToken.Literal} + currentPrecedence := p.GetPrecedence(p.currentToken.Type) - right := p.ParseFilterStatement() - left.Right = right + p.NextToken() - p.NextToken() + right := p.ParseExpression(currentPrecedence) + left.Right = &right + } else { + break + } } return *left } +func (p *Parser) ParseGroupedExpression() *ast.InfixExpression { + p.NextToken() + + exp := p.ParseExpression(0) + + if !p.currentTokenIs(token.RPAREN) { + return nil + } + + return &exp +} + func (p *Parser) ParseFilterStatement() *ast.InfixExpression { identifer := ast.Identifier{Token: p.currentToken, Value: p.currentToken.Literal} - if !p.peekIdentiferIs(keyword.EQ) { + if !p.peekIdentiferIn(keywords.EQ, keywords.NE, keywords.CONTAINS) { return nil } @@ -99,6 +120,10 @@ func (p *Parser) ParseFilterStatement() *ast.InfixExpression { p.NextToken() + if strings.EqualFold(statement.Operator, keywords.CONTAINS) && p.currentToken.Type != token.STRING { + return nil + } + switch p.currentToken.Type { case token.STRING: statement.Right = &ast.StringLiteral{Token: p.currentToken, Value: p.currentToken.Literal} @@ -118,6 +143,21 @@ func (p *Parser) ParseFilterStatement() *ast.InfixExpression { return &statement } +func (p *Parser) GetPrecedence(t token.TokenType) int { + switch t { + case token.IDENT: + if p.currentIdentiferIs(keywords.AND) { + return 2 + } + + if p.currentIdentiferIs(keywords.OR) { + return 1 + } + } + + return 0 +} + func (p *Parser) currentTokenIs(t token.TokenType) bool { return p.currentToken.Type == t } @@ -130,6 +170,20 @@ func (p *Parser) peekIdentiferIs(identifier string) bool { return p.peekToken.Type == token.IDENT && strings.EqualFold(p.peekToken.Literal, identifier) } +func (p *Parser) peekIdentiferIn(identifiers ...string) bool { + if p.peekToken.Type != token.IDENT { + return false + } + + for _, identifier := range identifiers { + if strings.EqualFold(p.peekToken.Literal, identifier) { + return true + } + } + + return false +} + func (p *Parser) currentIdentiferIs(identifier string) bool { return p.currentToken.Type == token.IDENT && strings.EqualFold(p.currentToken.Literal, identifier) } diff --git a/parser/parser_test.go b/parser/parser_test.go index c68afd4..88c9a17 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -5,18 +5,30 @@ import ( "github.com/goatquery/goatquery-go/ast" "github.com/goatquery/goatquery-go/lexer" + "github.com/goatquery/goatquery-go/token" "github.com/stretchr/testify/assert" ) func Test_ParsingOrderByStatement(t *testing.T) { tests := []struct { - input string - expectedLiteral string - expectedDirection ast.OrderByDirection + input string + expected []ast.OrderByStatement }{ - {"id", "id", ast.Ascending}, - {"id asc", "id", ast.Ascending}, - {"id desc", "id", ast.Descending}, + {"ID desc", []ast.OrderByStatement{{Token: token.Token{Type: token.IDENT, Literal: "ID"}, Direction: ast.Descending}}}, + {"id asc", []ast.OrderByStatement{{Token: token.Token{Type: token.IDENT, Literal: "id"}, Direction: ast.Ascending}}}, + {"Name", []ast.OrderByStatement{{Token: token.Token{Type: token.IDENT, Literal: "Name"}, Direction: ast.Ascending}}}, + {"id asc, name desc", []ast.OrderByStatement{ + {Token: token.Token{Type: token.IDENT, Literal: "id"}, Direction: ast.Ascending}, + {Token: token.Token{Type: token.IDENT, Literal: "name"}, Direction: ast.Descending}, + }}, + {"id asc, name desc, age, address asc, postcode desc", []ast.OrderByStatement{ + {Token: token.Token{Type: token.IDENT, Literal: "id"}, Direction: ast.Ascending}, + {Token: token.Token{Type: token.IDENT, Literal: "name"}, Direction: ast.Descending}, + {Token: token.Token{Type: token.IDENT, Literal: "age"}, Direction: ast.Ascending}, + {Token: token.Token{Type: token.IDENT, Literal: "address"}, Direction: ast.Ascending}, + {Token: token.Token{Type: token.IDENT, Literal: "postcode"}, Direction: ast.Descending}, + }}, + {"", []ast.OrderByStatement{}}, } for _, test := range tests { @@ -24,12 +36,13 @@ func Test_ParsingOrderByStatement(t *testing.T) { p := NewParser(l) statements := p.ParseOrderBy() - assert.Len(t, statements, 1) - stmt := statements[0] + for i, expected := range test.expected { + stmt := statements[i] - assert.Equal(t, test.expectedLiteral, stmt.TokenLiteral()) - assert.Equal(t, test.expectedDirection, stmt.Direction) + assert.Equal(t, expected.TokenLiteral(), stmt.TokenLiteral()) + assert.Equal(t, expected.Direction, stmt.Direction) + } } } @@ -43,6 +56,8 @@ func Test_ParsingFilterStatement(t *testing.T) { {"Name eq 'John'", "Name", "eq", "John"}, {"Firstname eq 'Jane'", "Firstname", "eq", "Jane"}, {"Age eq 21", "Age", "eq", "21"}, + {"Age ne 10", "Age", "ne", "10"}, + {"Name contains 'John'", "Name", "contains", "John"}, } for _, test := range tests { diff --git a/query.go b/query.go index 605ea07..4c250a5 100644 --- a/query.go +++ b/query.go @@ -5,7 +5,6 @@ type Query struct { Skip int Count bool OrderBy string - Select string Search string Filter string } diff --git a/token/token.go b/token/token.go index 4baff41..8f299bc 100644 --- a/token/token.go +++ b/token/token.go @@ -7,6 +7,9 @@ const ( IDENT = "IDENT" INT = "INT" STRING = "STRING" + + LPAREN = "LPAREN" + RPAREN = "RPAREN" ) type TokenType string From 110d08c10ad2ef994bbff197d75f5ed144944e38 Mon Sep 17 00:00:00 2001 From: Jamess-Lucass <23193271+Jamess-Lucass@users.noreply.github.com> Date: Thu, 15 Aug 2024 23:18:48 +0100 Subject: [PATCH 10/14] wip --- keywords/keyword.go | 14 +-- module/gorm/apply.go | 79 ++++++++++++-- module/gorm/apply_test.go | 220 +++++++++++++++++++++++++++++++++----- 3 files changed, 268 insertions(+), 45 deletions(-) diff --git a/keywords/keyword.go b/keywords/keyword.go index f2fd6c6..66a9b5d 100644 --- a/keywords/keyword.go +++ b/keywords/keyword.go @@ -1,13 +1,13 @@ package keywords const ( - ASC = "ASC" - DESC = "DESC" + ASC = "asc" + DESC = "desc" - EQ = "EQ" - NE = "NE" - CONTAINS = "CONTAINS" + EQ = "eq" + NE = "ne" + CONTAINS = "contains" - AND = "AND" - OR = "OR" + AND = "and" + OR = "or" ) diff --git a/module/gorm/apply.go b/module/gorm/apply.go index b47bd95..23edbe1 100644 --- a/module/gorm/apply.go +++ b/module/gorm/apply.go @@ -2,32 +2,38 @@ package gorm import ( "fmt" + "strings" "github.com/goatquery/goatquery-go" + "github.com/goatquery/goatquery-go/ast" + "github.com/goatquery/goatquery-go/keywords" "github.com/goatquery/goatquery-go/lexer" "github.com/goatquery/goatquery-go/parser" "gorm.io/gorm" + "gorm.io/gorm/logger" ) type SearchFunc = func(db *gorm.DB, searchTerm string) *gorm.DB +func LogQuery(db *gorm.DB) *gorm.DB { + db.Session(&gorm.Session{}).Logger.LogMode(logger.Info) + + return db +} + func Apply(db *gorm.DB, query goatquery.Query, model interface{}, searchFunc SearchFunc, options *goatquery.QueryOptions) (*gorm.DB, *int64, error) { if options != nil && query.Top > options.MaxTop { return nil, nil, fmt.Errorf("The value supplied for the query parameter 'Top' was greater than the maximum top allowed for this resource") } - // Order by - if query.OrderBy != "" { - l := lexer.NewLexer(query.OrderBy) + // Filter + if query.Filter != "" { + l := lexer.NewLexer(query.Filter) p := parser.NewParser(l) - statements := p.ParseOrderBy() - - for _, statement := range statements { - sql := fmt.Sprintf("%s %s", statement.TokenLiteral(), statement.Direction) + statements := p.ParseFilter() - db = db.Order(sql) - } + db = EvaluateFilter(&statements.Expression, db) } // Search @@ -41,6 +47,20 @@ func Apply(db *gorm.DB, query goatquery.Query, model interface{}, searchFunc Sea db.Model(&model).Count(&count) } + // Order by + if query.OrderBy != "" { + l := lexer.NewLexer(query.OrderBy) + p := parser.NewParser(l) + + statements := p.ParseOrderBy() + + for _, statement := range statements { + sql := fmt.Sprintf("%s %s", statement.TokenLiteral(), statement.Direction) + + db = db.Order(sql) + } + } + // Skip if query.Skip > 0 { db = db.Offset(query.Skip) @@ -61,3 +81,44 @@ func Apply(db *gorm.DB, query goatquery.Query, model interface{}, searchFunc Sea return db, nil, nil } + +func EvaluateFilter(exp ast.Expression, db *gorm.DB) *gorm.DB { + switch exp := exp.(type) { + case *ast.InfixExpression: + identifier, ok := exp.Left.(*ast.Identifier) + if ok { + + var value interface{} + + switch right := exp.Right.(type) { + case *ast.StringLiteral: + value = right.Value + case *ast.IntegerLiteral: + value = right.Value + } + + switch strings.ToLower(exp.Operator) { + case keywords.EQ: + return db.Where(fmt.Sprintf("%s = ?", identifier.TokenLiteral()), value) + case keywords.NE: + return db.Where(fmt.Sprintf("%s <> ?", identifier.TokenLiteral()), value) + case keywords.CONTAINS: + if str, ok := exp.Right.(*ast.StringLiteral); ok { + return db.Where(fmt.Sprintf("%s LIKE ?", identifier.TokenLiteral()), "%"+str.Value+"%") + } + } + } + + switch exp.Operator { + case keywords.AND: + return EvaluateFilter(exp.Right, EvaluateFilter(exp.Left, db)) + case keywords.OR: + left := EvaluateFilter(exp.Left, db) + right := EvaluateFilter(exp.Right, db) + + return left.Or(right) + } + } + + return db +} diff --git a/module/gorm/apply_test.go b/module/gorm/apply_test.go index abcac91..8626123 100644 --- a/module/gorm/apply_test.go +++ b/module/gorm/apply_test.go @@ -12,8 +12,13 @@ import ( "gorm.io/gorm/logger" ) +type Base struct { + Age uint `gorm:"column:user_age"` +} + type User struct { - Age uint + Base + Firstname string } @@ -27,7 +32,7 @@ func TestMain(m *testing.M) { func setup() { db, err := gorm.Open(sqlite.Open("file::memory:?cache=shared"), &gorm.Config{ - Logger: logger.Default.LogMode(logger.Info), + Logger: logger.Default.LogMode(logger.Error), }) if err != nil { @@ -38,12 +43,12 @@ func setup() { db.AutoMigrate(&User{}) if err := db.Model(&User{}).Create([]User{ - {2, "John"}, - {1, "Jane"}, - {2, "Apple"}, - {1, "Harry"}, - {3, "Doe"}, - {3, "Egg"}, + {Base{2}, "John"}, + {Base{1}, "Jane"}, + {Base{2}, "Apple"}, + {Base{1}, "Harry"}, + {Base{3}, "Doe"}, + {Base{3}, "Egg"}, }).Error; err != nil { panic("failed to seed") } @@ -55,13 +60,101 @@ func Test_OrderBy(t *testing.T) { expected []User }{ {"age desc, firstname asc", []User{ - {3, "Doe"}, - {3, "Egg"}, - {2, "Apple"}, - {2, "John"}, - {1, "Harry"}, - {1, "Jane"}, + {Base{3}, "Doe"}, + {Base{3}, "Egg"}, + {Base{2}, "Apple"}, + {Base{2}, "John"}, + {Base{1}, "Harry"}, + {Base{1}, "Jane"}, }}, + // {"age desc, firstname desc", []User{ + // {Base{3}, "Egg"}, + // {Base{3}, "Doe"}, + // {Base{2}, "John"}, + // {Base{2}, "Apple"}, + // {Base{1}, "Jane"}, + // {Base{1}, "Harry"}, + // }}, + // {"age desc", []User{ + // {Base{3}, "Doe"}, + // {Base{3}, "Egg"}, + // {Base{2}, "John"}, + // {Base{2}, "Apple"}, + // {Base{1}, "Jane"}, + // {Base{1}, "Harry"}, + // }}, + // {"Age asc", []User{ + // {Base{1}, "Jane"}, + // {Base{1}, "Harry"}, + // {Base{2}, "John"}, + // {Base{2}, "Apple"}, + // {Base{3}, "Doe"}, + // {Base{3}, "Egg"}, + // }}, + // {"age", []User{ + // {Base{1}, "Jane"}, + // {Base{1}, "Harry"}, + // {Base{2}, "John"}, + // {Base{2}, "Apple"}, + // {Base{3}, "Doe"}, + // {Base{3}, "Egg"}, + // }}, + // {"age asc", []User{ + // {Base{1}, "Jane"}, + // {Base{1}, "Harry"}, + // {Base{2}, "John"}, + // {Base{2}, "Apple"}, + // {Base{3}, "Doe"}, + // {Base{3}, "Egg"}, + // }}, + // {"Age asc", []User{ + // {Base{1}, "Jane"}, + // {Base{1}, "Harry"}, + // {Base{2}, "John"}, + // {Base{2}, "Apple"}, + // {Base{3}, "Doe"}, + // {Base{3}, "Egg"}, + // }}, + // {"aGE asc", []User{ + // {Base{1}, "Jane"}, + // {Base{1}, "Harry"}, + // {Base{2}, "John"}, + // {Base{2}, "Apple"}, + // {Base{3}, "Doe"}, + // {Base{3}, "Egg"}, + // }}, + // {"AGe asc", []User{ + // {Base{1}, "Jane"}, + // {Base{1}, "Harry"}, + // {Base{2}, "John"}, + // {Base{2}, "Apple"}, + // {Base{3}, "Doe"}, + // {Base{3}, "Egg"}, + // }}, + // {"aGE Asc", []User{ + // {Base{1}, "Jane"}, + // {Base{1}, "Harry"}, + // {Base{2}, "John"}, + // {Base{2}, "Apple"}, + // {Base{3}, "Doe"}, + // {Base{3}, "Egg"}, + // }}, + // {"age aSc", []User{ + // {Base{1}, "Jane"}, + // {Base{1}, "Harry"}, + // {Base{2}, "John"}, + // {Base{2}, "Apple"}, + // {Base{3}, "Doe"}, + // {Base{3}, "Egg"}, + // }}, + // {"", []User{ + // {Base{2}, "John"}, + // {Base{1}, "Jane"}, + // {Base{2}, "Apple"}, + // {Base{1}, "Harry"}, + // {Base{3}, "Doe"}, + // {Base{3}, "Egg"}, + // }}, } for _, test := range tests { @@ -139,29 +232,29 @@ func Test_Skip(t *testing.T) { expected []User }{ {1, []User{ - {1, "Jane"}, - {2, "Apple"}, - {2, "John"}, - {3, "Doe"}, - {3, "Egg"}, + {Base{1}, "Jane"}, + {Base{2}, "Apple"}, + {Base{2}, "John"}, + {Base{3}, "Doe"}, + {Base{3}, "Egg"}, }}, {2, []User{ - {2, "Apple"}, - {2, "John"}, - {3, "Doe"}, - {3, "Egg"}, + {Base{2}, "Apple"}, + {Base{2}, "John"}, + {Base{3}, "Doe"}, + {Base{3}, "Egg"}, }}, {3, []User{ - {2, "John"}, - {3, "Doe"}, - {3, "Egg"}, + {Base{2}, "John"}, + {Base{3}, "Doe"}, + {Base{3}, "Egg"}, }}, {4, []User{ - {3, "Doe"}, - {3, "Egg"}, + {Base{3}, "Doe"}, + {Base{3}, "Egg"}, }}, {5, []User{ - {3, "Egg"}, + {Base{3}, "Egg"}, }}, {6, []User{}}, {10_000, []User{}}, @@ -270,6 +363,75 @@ func Test_TopWithMaxTopReturnsError(t *testing.T) { } } +func Test_Filter(t *testing.T) { + tests := []struct { + input string + expected []User + }{ + {"firstname eq 'John'", []User{ + {Base{2}, "John"}, + }}, + {"firstname eq 'Random'", []User{}}, + {"Age eq 1", []User{ + {Base{1}, "Jane"}, + {Base{1}, "Harry"}, + }}, + {"Age eq 0", []User{}}, + {"firstname eq 'John' and Age eq 2", []User{ + {Base{2}, "John"}, + }}, + {"firstname eq 'John' or Age eq 3", []User{ + {Base{2}, "John"}, + {Base{3}, "Doe"}, + {Base{3}, "Egg"}, + }}, + {"Age eq 1 and firstName eq 'Harry' or Age eq 2", []User{ + {Base{2}, "John"}, + {Base{2}, "Apple"}, + {Base{1}, "Harry"}, + }}, + {"Age eq 1 or Age eq 2 or firstName eq 'Egg'", []User{ + {Base{2}, "John"}, + {Base{1}, "Jane"}, + {Base{2}, "Apple"}, + {Base{1}, "Harry"}, + {Base{3}, "Egg"}, + }}, + {"Age ne 3", []User{ + {Base{2}, "John"}, + {Base{1}, "Jane"}, + {Base{2}, "Apple"}, + {Base{1}, "Harry"}, + }}, + {"firstName contains 'a'", []User{ + {Base{1}, "Jane"}, + {Base{2}, "Apple"}, + {Base{1}, "Harry"}, + }}, + {"Age ne 1 and firstName contains 'a'", []User{ + {Base{2}, "Apple"}, + }}, + {"Age ne 1 and firstName contains 'a' or firstName eq 'Apple'", []User{ + {Base{2}, "Apple"}, + }}, + } + + for _, test := range tests { + query := goatquery.Query{ + Filter: test.input, + } + + var output []User + res, _, err := Apply(DB, query, &output, nil, nil) + assert.NoError(t, err) + + err = res.Find(&output).Error + assert.NoError(t, err) + + assert.Equal(t, test.expected, output) + } +} + func makeIntPointer(v int64) *int64 { return &v } From 70eaa3cb805b90aaf8ebd8515b64bf4cbc8a7731 Mon Sep 17 00:00:00 2001 From: Jamess-Lucass <23193271+Jamess-Lucass@users.noreply.github.com> Date: Mon, 4 Nov 2024 22:37:27 +0000 Subject: [PATCH 11/14] start of handling custom column names --- module/gorm/apply.go | 39 +++- module/gorm/apply_test.go | 372 +++++++++++++++++++++++--------------- 2 files changed, 265 insertions(+), 146 deletions(-) diff --git a/module/gorm/apply.go b/module/gorm/apply.go index 23edbe1..242f74d 100644 --- a/module/gorm/apply.go +++ b/module/gorm/apply.go @@ -2,6 +2,7 @@ package gorm import ( "fmt" + "reflect" "strings" "github.com/goatquery/goatquery-go" @@ -11,6 +12,7 @@ import ( "github.com/goatquery/goatquery-go/parser" "gorm.io/gorm" "gorm.io/gorm/logger" + "gorm.io/gorm/schema" ) type SearchFunc = func(db *gorm.DB, searchTerm string) *gorm.DB @@ -26,6 +28,10 @@ func Apply(db *gorm.DB, query goatquery.Query, model interface{}, searchFunc Sea return nil, nil, fmt.Errorf("The value supplied for the query parameter 'Top' was greater than the maximum top allowed for this resource") } + v := reflect.ValueOf(model) + t := reflect.Indirect(v).Type().Elem() + namer := db.Statement.NamingStrategy + // Filter if query.Filter != "" { l := lexer.NewLexer(query.Filter) @@ -55,7 +61,9 @@ func Apply(db *gorm.DB, query goatquery.Query, model interface{}, searchFunc Sea statements := p.ParseOrderBy() for _, statement := range statements { - sql := fmt.Sprintf("%s %s", statement.TokenLiteral(), statement.Direction) + property := GetGormColumnName(namer, namer.TableName(t.Name()), t, statement.TokenLiteral()) + + sql := fmt.Sprintf("%s %s", property, statement.Direction) db = db.Order(sql) } @@ -82,6 +90,35 @@ func Apply(db *gorm.DB, query goatquery.Query, model interface{}, searchFunc Sea return db, nil, nil } +func GetGormColumnName(namer schema.Namer, tableName string, t reflect.Type, property string) string { + for i := 0; i < t.NumField(); i++ { + field := t.Field(i) + + if field.Anonymous { + if columnName := GetGormColumnName(namer, tableName, field.Type, property); columnName != "" { + return columnName + } + continue + } + + propertyName := strings.Split(field.Tag.Get("json"), ",")[0] + if propertyName == "" { + propertyName = field.Name + } + + if strings.EqualFold(propertyName, property) { + settings := schema.ParseTagSetting(field.Tag.Get("gorm"), ";") + if settings["COLUMN"] != "" { + return settings["COLUMN"] + } + + return namer.ColumnName(tableName, field.Name) + } + } + + return namer.ColumnName(tableName, property) +} + func EvaluateFilter(exp ast.Expression, db *gorm.DB) *gorm.DB { switch exp := exp.(type) { case *ast.InfixExpression: diff --git a/module/gorm/apply_test.go b/module/gorm/apply_test.go index 8626123..31d37e1 100644 --- a/module/gorm/apply_test.go +++ b/module/gorm/apply_test.go @@ -4,9 +4,11 @@ import ( "fmt" "os" "testing" + "time" "github.com/glebarez/sqlite" "github.com/goatquery/goatquery-go" + "github.com/google/uuid" "github.com/stretchr/testify/assert" "gorm.io/gorm" "gorm.io/gorm/logger" @@ -19,7 +21,10 @@ type Base struct { type User struct { Base - Firstname string + UserId uuid.UUID + Firstname string + Balance *float64 + DateOfBirth time.Time } var DB *gorm.DB @@ -30,6 +35,29 @@ func TestMain(m *testing.M) { os.Exit(code) } +func timeMustParse(value string) time.Time { + val, err := time.Parse("2006-01-02 15:04:05", value) + if err == nil { + return val + } + + val, err = time.Parse("2006-01-02", value) + if err != nil { + panic("unable to parse date time") + } + + return val +} + +var users = map[string]User{ + "John": {Base: Base{Age: 2}, Firstname: "John", UserId: uuid.MustParse("58cdeca3-645b-457c-87aa-7d5f87734255"), DateOfBirth: timeMustParse("2004-01-31 23:59:59"), Balance: makePointer(1.50)}, + "Jane": {Base: Base{Age: 1}, Firstname: "Jane", UserId: uuid.MustParse("58cdeca3-645b-457c-87aa-7d5f87734255"), DateOfBirth: timeMustParse("2020-05-09 15:30:00"), Balance: makePointer(0.0)}, + "Apple": {Base: Base{Age: 2}, Firstname: "Apple", UserId: uuid.MustParse("58cdeca3-645b-457c-87aa-7d5f87734255"), DateOfBirth: timeMustParse("1980-12-31 00:00:01"), Balance: makePointer(1204050.98)}, + "Harry": {Base: Base{Age: 1}, Firstname: "Harry", UserId: uuid.MustParse("e4c7772b-8947-4e46-98ed-644b417d2a08"), DateOfBirth: timeMustParse("2002-08-01"), Balance: makePointer(0.5372958205929493)}, + "Doe": {Base: Base{Age: 3}, Firstname: "Doe", UserId: uuid.MustParse("58cdeca3-645b-457c-87aa-7d5f87734255"), DateOfBirth: timeMustParse("2023-07-26 12:00:30"), Balance: nil}, + "Egg": {Base: Base{Age: 3}, Firstname: "Egg", UserId: uuid.MustParse("58cdeca3-645b-457c-87aa-7d5f87734255"), DateOfBirth: timeMustParse("2000-01-01 00:00:00"), Balance: makePointer(1334534453453433.33435443343231235652)}, +} + func setup() { db, err := gorm.Open(sqlite.Open("file::memory:?cache=shared"), &gorm.Config{ Logger: logger.Default.LogMode(logger.Error), @@ -43,12 +71,12 @@ func setup() { db.AutoMigrate(&User{}) if err := db.Model(&User{}).Create([]User{ - {Base{2}, "John"}, - {Base{1}, "Jane"}, - {Base{2}, "Apple"}, - {Base{1}, "Harry"}, - {Base{3}, "Doe"}, - {Base{3}, "Egg"}, + users["John"], + users["Jane"], + users["Apple"], + users["Harry"], + users["Doe"], + users["Egg"], }).Error; err != nil { panic("failed to seed") } @@ -60,101 +88,101 @@ func Test_OrderBy(t *testing.T) { expected []User }{ {"age desc, firstname asc", []User{ - {Base{3}, "Doe"}, - {Base{3}, "Egg"}, - {Base{2}, "Apple"}, - {Base{2}, "John"}, - {Base{1}, "Harry"}, - {Base{1}, "Jane"}, - }}, - // {"age desc, firstname desc", []User{ - // {Base{3}, "Egg"}, - // {Base{3}, "Doe"}, - // {Base{2}, "John"}, - // {Base{2}, "Apple"}, - // {Base{1}, "Jane"}, - // {Base{1}, "Harry"}, - // }}, - // {"age desc", []User{ - // {Base{3}, "Doe"}, - // {Base{3}, "Egg"}, - // {Base{2}, "John"}, - // {Base{2}, "Apple"}, - // {Base{1}, "Jane"}, - // {Base{1}, "Harry"}, - // }}, - // {"Age asc", []User{ - // {Base{1}, "Jane"}, - // {Base{1}, "Harry"}, - // {Base{2}, "John"}, - // {Base{2}, "Apple"}, - // {Base{3}, "Doe"}, - // {Base{3}, "Egg"}, - // }}, - // {"age", []User{ - // {Base{1}, "Jane"}, - // {Base{1}, "Harry"}, - // {Base{2}, "John"}, - // {Base{2}, "Apple"}, - // {Base{3}, "Doe"}, - // {Base{3}, "Egg"}, - // }}, - // {"age asc", []User{ - // {Base{1}, "Jane"}, - // {Base{1}, "Harry"}, - // {Base{2}, "John"}, - // {Base{2}, "Apple"}, - // {Base{3}, "Doe"}, - // {Base{3}, "Egg"}, - // }}, - // {"Age asc", []User{ - // {Base{1}, "Jane"}, - // {Base{1}, "Harry"}, - // {Base{2}, "John"}, - // {Base{2}, "Apple"}, - // {Base{3}, "Doe"}, - // {Base{3}, "Egg"}, - // }}, - // {"aGE asc", []User{ - // {Base{1}, "Jane"}, - // {Base{1}, "Harry"}, - // {Base{2}, "John"}, - // {Base{2}, "Apple"}, - // {Base{3}, "Doe"}, - // {Base{3}, "Egg"}, - // }}, - // {"AGe asc", []User{ - // {Base{1}, "Jane"}, - // {Base{1}, "Harry"}, - // {Base{2}, "John"}, - // {Base{2}, "Apple"}, - // {Base{3}, "Doe"}, - // {Base{3}, "Egg"}, - // }}, - // {"aGE Asc", []User{ - // {Base{1}, "Jane"}, - // {Base{1}, "Harry"}, - // {Base{2}, "John"}, - // {Base{2}, "Apple"}, - // {Base{3}, "Doe"}, - // {Base{3}, "Egg"}, - // }}, - // {"age aSc", []User{ - // {Base{1}, "Jane"}, - // {Base{1}, "Harry"}, - // {Base{2}, "John"}, - // {Base{2}, "Apple"}, - // {Base{3}, "Doe"}, - // {Base{3}, "Egg"}, - // }}, - // {"", []User{ - // {Base{2}, "John"}, - // {Base{1}, "Jane"}, - // {Base{2}, "Apple"}, - // {Base{1}, "Harry"}, - // {Base{3}, "Doe"}, - // {Base{3}, "Egg"}, - // }}, + users["Doe"], + users["Egg"], + users["Apple"], + users["John"], + users["Harry"], + users["Jane"], + }}, + {"age desc, firstname desc", []User{ + users["Egg"], + users["Doe"], + users["John"], + users["Apple"], + users["Jane"], + users["Harry"], + }}, + {"age desc", []User{ + users["Doe"], + users["Egg"], + users["John"], + users["Apple"], + users["Jane"], + users["Harry"], + }}, + {"Age asc", []User{ + users["Jane"], + users["Harry"], + users["John"], + users["Apple"], + users["Doe"], + users["Egg"], + }}, + {"age", []User{ + users["Jane"], + users["Harry"], + users["John"], + users["Apple"], + users["Doe"], + users["Egg"], + }}, + {"age asc", []User{ + users["Jane"], + users["Harry"], + users["John"], + users["Apple"], + users["Doe"], + users["Egg"], + }}, + {"Age asc", []User{ + users["Jane"], + users["Harry"], + users["John"], + users["Apple"], + users["Doe"], + users["Egg"], + }}, + {"aGE asc", []User{ + users["Jane"], + users["Harry"], + users["John"], + users["Apple"], + users["Doe"], + users["Egg"], + }}, + {"AGe asc", []User{ + users["Jane"], + users["Harry"], + users["John"], + users["Apple"], + users["Doe"], + users["Egg"], + }}, + {"aGE Asc", []User{ + users["Jane"], + users["Harry"], + users["John"], + users["Apple"], + users["Doe"], + users["Egg"], + }}, + {"age aSc", []User{ + users["Jane"], + users["Harry"], + users["John"], + users["Apple"], + users["Doe"], + users["Egg"], + }}, + {"", []User{ + users["John"], + users["Jane"], + users["Apple"], + users["Harry"], + users["Doe"], + users["Egg"], + }}, } for _, test := range tests { @@ -178,7 +206,7 @@ func Test_Count(t *testing.T) { input bool expectedCount *int64 }{ - {true, makeIntPointer(6)}, + {true, makePointer(int64(6))}, {false, nil}, } @@ -232,29 +260,29 @@ func Test_Skip(t *testing.T) { expected []User }{ {1, []User{ - {Base{1}, "Jane"}, - {Base{2}, "Apple"}, - {Base{2}, "John"}, - {Base{3}, "Doe"}, - {Base{3}, "Egg"}, + users["Jane"], + users["Apple"], + users["John"], + users["Doe"], + users["Egg"], }}, {2, []User{ - {Base{2}, "Apple"}, - {Base{2}, "John"}, - {Base{3}, "Doe"}, - {Base{3}, "Egg"}, + users["Apple"], + users["John"], + users["Doe"], + users["Egg"], }}, {3, []User{ - {Base{2}, "John"}, - {Base{3}, "Doe"}, - {Base{3}, "Egg"}, + users["John"], + users["Doe"], + users["Egg"], }}, {4, []User{ - {Base{3}, "Doe"}, - {Base{3}, "Egg"}, + users["Doe"], + users["Egg"], }}, {5, []User{ - {Base{3}, "Egg"}, + users["Egg"], }}, {6, []User{}}, {10_000, []User{}}, @@ -262,8 +290,7 @@ func Test_Skip(t *testing.T) { for _, test := range tests { query := goatquery.Query{ - Skip: test.input, - OrderBy: "age asc, firstname asc", + Skip: test.input, } var output []User @@ -369,50 +396,105 @@ func Test_Filter(t *testing.T) { expected []User }{ {"firstname eq 'John'", []User{ - {Base{2}, "John"}, + users["John"], }}, {"firstname eq 'Random'", []User{}}, {"Age eq 1", []User{ - {Base{1}, "Jane"}, - {Base{1}, "Harry"}, + users["Jane"], + users["Harry"], }}, {"Age eq 0", []User{}}, {"firstname eq 'John' and Age eq 2", []User{ - {Base{2}, "John"}, + users["John"], }}, {"firstname eq 'John' or Age eq 3", []User{ - {Base{2}, "John"}, - {Base{3}, "Doe"}, - {Base{3}, "Egg"}, + users["John"], + users["Doe"], + users["Egg"], }}, {"Age eq 1 and firstName eq 'Harry' or Age eq 2", []User{ - {Base{2}, "John"}, - {Base{2}, "Apple"}, - {Base{1}, "Harry"}, + users["John"], + users["Apple"], + users["Harry"], }}, {"Age eq 1 or Age eq 2 or firstName eq 'Egg'", []User{ - {Base{2}, "John"}, - {Base{1}, "Jane"}, - {Base{2}, "Apple"}, - {Base{1}, "Harry"}, - {Base{3}, "Egg"}, + users["John"], + users["Jane"], + users["Apple"], + users["Harry"], + users["Egg"], }}, {"Age ne 3", []User{ - {Base{2}, "John"}, - {Base{1}, "Jane"}, - {Base{2}, "Apple"}, - {Base{1}, "Harry"}, + users["John"], + users["Jane"], + users["Apple"], + users["Harry"], }}, {"firstName contains 'a'", []User{ - {Base{1}, "Jane"}, - {Base{2}, "Apple"}, - {Base{1}, "Harry"}, + users["Jane"], + users["Apple"], + users["Harry"], }}, {"Age ne 1 and firstName contains 'a'", []User{ - {Base{2}, "Apple"}, + users["Apple"], }}, {"Age ne 1 and firstName contains 'a' or firstName eq 'Apple'", []User{ - {Base{2}, "Apple"}, + users["Apple"], + }}, + {"Firstname eq 'John' and Age eq 2 or Age eq 3", []User{ + users["John"], + users["Doe"], + users["Egg"], + }}, + {"(Firstname eq 'John' and Age eq 2) or Age eq 3", []User{ + users["John"], + users["Doe"], + users["Egg"], + }}, + {"Firstname eq 'John' and (Age eq 2 or Age eq 3)", []User{ + users["John"], + }}, + {"(Firstname eq 'John' and Age eq 2 or Age eq 3)", []User{ + users["John"], + users["Doe"], + users["Egg"], + }}, + {"(Firstname eq 'John') or (Age eq 3 and Firstname eq 'Egg') or Age eq 1 and (Age eq 2)", []User{ + users["John"], + users["Egg"], + }}, + {"UserId eq e4c7772b-8947-4e46-98ed-644b417d2a08", []User{ + users["Harry"], + }}, + {"age lt 3", []User{ + users["John"], + users["Jane"], + users["Apple"], + users["Harry"], + }}, + {"age lt 1", []User{}}, + {"age lte 2", []User{ + users["John"], + users["Jane"], + users["Apple"], + users["Harry"], + }}, + {"age gt 1", []User{ + users["John"], + users["Apple"], + users["Doe"], + users["Egg"], + }}, + {"age gte 3", []User{ + users["Doe"], + users["Egg"], + }}, + {"age lt 3 and age gt 1", []User{ + users["John"], + users["Apple"], + }}, + {"balanceDecimal eq 1.50m", []User{ + users["John"], }}, } @@ -432,6 +514,6 @@ func Test_Filter(t *testing.T) { } } -func makeIntPointer(v int64) *int64 { +func makePointer[T any](v T) *T { return &v } From e09542f1697abf8868e3042a2ac71532a800dff7 Mon Sep 17 00:00:00 2001 From: Jamess-Lucass <23193271+Jamess-Lucass@users.noreply.github.com> Date: Tue, 5 Nov 2024 23:12:42 +0000 Subject: [PATCH 12/14] wip --- ast/ast.go | 44 +++++++++++++++- go.mod | 5 +- go.sum | 2 + keywords/keyword.go | 5 ++ lexer/lexer.go | 71 +++++++++++++++++++------- lexer/lexer_test.go | 93 ++++++++++++++++++++++++++++++++++ module/gorm/apply.go | 50 ++++++++++++------ module/gorm/apply_test.go | 102 +++++++++++++++++++++++++++---------- module/gorm/go.mod | 7 +-- module/gorm/go.sum | 6 +++ parser/parser.go | 52 ++++++++++++++++--- parser/parser_test.go | 103 +++++++++++++++++++++++++++++++++++++- time.go | 20 ++++++++ token/token.go | 9 ++-- 14 files changed, 495 insertions(+), 74 deletions(-) create mode 100644 time.go diff --git a/ast/ast.go b/ast/ast.go index d21284d..848ba16 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -1,7 +1,10 @@ package ast import ( + "time" + "github.com/goatquery/goatquery-go/token" + "github.com/google/uuid" ) type Node interface { @@ -25,6 +28,7 @@ const ( Descending OrderByDirection = "desc" ) +// order type OrderByStatement struct { Token token.Token Direction OrderByDirection @@ -35,6 +39,7 @@ var _ Statement = (*OrderByStatement)(nil) func (s *OrderByStatement) statementNode() {} func (s *OrderByStatement) TokenLiteral() string { return s.Token.Literal } +// Identifier type Identifier struct { Token token.Token Value string @@ -45,9 +50,10 @@ var _ Expression = (*Identifier)(nil) func (i *Identifier) expressionNode() {} func (i *Identifier) TokenLiteral() string { return i.Token.Literal } +// Expression Statement type ExpressionStatement struct { Token token.Token - Expression InfixExpression + Expression *InfixExpression } var _ Statement = (*ExpressionStatement)(nil) @@ -55,6 +61,7 @@ var _ Statement = (*ExpressionStatement)(nil) func (s *ExpressionStatement) statementNode() {} func (s *ExpressionStatement) TokenLiteral() string { return s.Token.Literal } +// Infix type InfixExpression struct { Token token.Token Left Expression @@ -67,6 +74,7 @@ var _ Expression = (*InfixExpression)(nil) func (s *InfixExpression) expressionNode() {} func (s *InfixExpression) TokenLiteral() string { return s.Token.Literal } +// String type StringLiteral struct { Token token.Token Value string @@ -77,6 +85,7 @@ var _ Expression = (*StringLiteral)(nil) func (s *StringLiteral) expressionNode() {} func (s *StringLiteral) TokenLiteral() string { return s.Token.Literal } +// Int type IntegerLiteral struct { Token token.Token Value int64 @@ -86,3 +95,36 @@ var _ Expression = (*IntegerLiteral)(nil) func (s *IntegerLiteral) expressionNode() {} func (s *IntegerLiteral) TokenLiteral() string { return s.Token.Literal } + +// Float +type FloatLiteral struct { + Token token.Token + Value float64 +} + +var _ Expression = (*FloatLiteral)(nil) + +func (s *FloatLiteral) expressionNode() {} +func (s *FloatLiteral) TokenLiteral() string { return s.Token.Literal } + +// Guid +type GuidLiteral struct { + Token token.Token + Value uuid.UUID +} + +var _ Expression = (*GuidLiteral)(nil) + +func (s *GuidLiteral) expressionNode() {} +func (s *GuidLiteral) TokenLiteral() string { return s.Token.Literal } + +// Datetime +type DateTimeLiteral struct { + Token token.Token + Value time.Time +} + +var _ Expression = (*DateTimeLiteral)(nil) + +func (s *DateTimeLiteral) expressionNode() {} +func (s *DateTimeLiteral) TokenLiteral() string { return s.Token.Literal } diff --git a/go.mod b/go.mod index 08cf9da..a63154b 100644 --- a/go.mod +++ b/go.mod @@ -2,7 +2,10 @@ module github.com/goatquery/goatquery-go go 1.22 -require github.com/stretchr/testify v1.9.0 +require ( + github.com/google/uuid v1.6.0 + github.com/stretchr/testify v1.9.0 +) require ( github.com/davecgh/go-spew v1.1.1 // indirect diff --git a/go.sum b/go.sum index 60ce688..5697539 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,7 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= diff --git a/keywords/keyword.go b/keywords/keyword.go index 66a9b5d..8c11237 100644 --- a/keywords/keyword.go +++ b/keywords/keyword.go @@ -8,6 +8,11 @@ const ( NE = "ne" CONTAINS = "contains" + LT = "lt" + LTE = "lte" + GT = "gt" + GTE = "gte" + AND = "and" OR = "or" ) diff --git a/lexer/lexer.go b/lexer/lexer.go index 1f1d46b..66ee7cf 100644 --- a/lexer/lexer.go +++ b/lexer/lexer.go @@ -1,6 +1,12 @@ package lexer -import "github.com/goatquery/goatquery-go/token" +import ( + "strings" + "time" + + "github.com/goatquery/goatquery-go/token" + "github.com/google/uuid" +) type Lexer struct { input string @@ -44,17 +50,35 @@ func (l *Lexer) NextToken() token.Token { tok.Type = token.STRING tok.Literal = l.readString() default: - if isLetter(l.character) { + if isLetter(l.character) || isDigit(l.character) { tok.Literal = l.readIdentifier() + + if isGuid(tok.Literal) { + tok.Type = token.GUID + return tok + } + + if isDigit(tok.Literal[0]) { + + if isDateTime(tok.Literal) { + tok.Type = token.DATETIME + return tok + } + + if strings.HasSuffix(strings.ToLower(tok.Literal), "f") { + tok.Type = token.FLOAT + return tok + } + + tok.Type = token.INT + return tok + } + tok.Type = token.IDENT return tok - } else if isDigit(l.character) { - tok.Literal = l.readNumber() - tok.Type = token.INT - return tok - } else { - tok = token.NewToken(token.ILLEGAL, l.character) } + + tok = token.NewToken(token.ILLEGAL, l.character) } l.readCharacter() @@ -70,16 +94,7 @@ func (l *Lexer) skipWhitespace() { func (l *Lexer) readIdentifier() string { currentPosition := l.position - for isLetter(l.character) { - l.readCharacter() - } - - return l.input[currentPosition:l.position] -} - -func (l *Lexer) readNumber() string { - currentPosition := l.position - for isDigit(l.character) { + for isLetter(l.character) || isDigit(l.character) || l.character == '-' || l.character == ':' || l.character == '.' { l.readCharacter() } @@ -99,6 +114,12 @@ func (l *Lexer) readString() string { return l.input[currentPosition:l.position] } +func isGuid(value string) bool { + _, err := uuid.Parse(value) + + return err == nil +} + func isLetter(ch byte) bool { return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' } @@ -106,3 +127,17 @@ func isLetter(ch byte) bool { func isDigit(ch byte) bool { return '0' <= ch && ch <= '9' } + +func isDateTime(value string) bool { + _, err := time.Parse(time.RFC3339, value) + if err == nil { + return true + } + + _, err = time.Parse(time.DateOnly, value) + if err == nil { + return true + } + + return false +} diff --git a/lexer/lexer_test.go b/lexer/lexer_test.go index 373dec4..36a4dee 100644 --- a/lexer/lexer_test.go +++ b/lexer/lexer_test.go @@ -14,6 +14,8 @@ func Test_OrderByNextToken(t *testing.T) { id DeSc id AsC asc asc + address1Line asc + addASCress1Line desc ` tests := []struct { @@ -37,6 +39,12 @@ func Test_OrderByNextToken(t *testing.T) { {token.IDENT, "asc"}, {token.IDENT, "asc"}, + + {token.IDENT, "address1Line"}, + {token.IDENT, "asc"}, + + {token.IDENT, "addASCress1Line"}, + {token.IDENT, "desc"}, } lexer := NewLexer(input) @@ -60,6 +68,23 @@ func Test_FilterNextToken(t *testing.T) { Id ne 1 Name contains 'John' (Id eq 1 or Id eq 2) and Name eq 'John' + address1Line eq '1 Main Street' + addASCress1Line contains '10 Test Av' + id eq e4c7772b-8947-4e46-98ed-644b417d2a08 + id eq 10f + id ne 0.1121563052701180f + id ne 0.1121563052701180F + age lt 50 + age lte 50 + age gt 50 + age gte 50 + dateOfBirth eq 2000-01-01 + dateOfBirth lt 2000-01-01 + dateOfBirth lte 2000-01-01 + dateOfBirth gt 2000-01-01 + dateOfBirth gte 2000-01-01 + dateOfBirth eq 2023-01-01T15:30:00Z + dateOfBirth eq 2023-01-30T09:29:55.1750906Z ` tests := []struct { @@ -139,6 +164,74 @@ func Test_FilterNextToken(t *testing.T) { {token.IDENT, "Name"}, {token.IDENT, "eq"}, {token.STRING, "John"}, + + {token.IDENT, "address1Line"}, + {token.IDENT, "eq"}, + {token.STRING, "1 Main Street"}, + + {token.IDENT, "addASCress1Line"}, + {token.IDENT, "contains"}, + {token.STRING, "10 Test Av"}, + + {token.IDENT, "id"}, + {token.IDENT, "eq"}, + {token.GUID, "e4c7772b-8947-4e46-98ed-644b417d2a08"}, + + {token.IDENT, "id"}, + {token.IDENT, "eq"}, + {token.FLOAT, "10f"}, + + {token.IDENT, "id"}, + {token.IDENT, "ne"}, + {token.FLOAT, "0.1121563052701180f"}, + + {token.IDENT, "id"}, + {token.IDENT, "ne"}, + {token.FLOAT, "0.1121563052701180F"}, + + {token.IDENT, "age"}, + {token.IDENT, "lt"}, + {token.INT, "50"}, + + {token.IDENT, "age"}, + {token.IDENT, "lte"}, + {token.INT, "50"}, + + {token.IDENT, "age"}, + {token.IDENT, "gt"}, + {token.INT, "50"}, + + {token.IDENT, "age"}, + {token.IDENT, "gte"}, + {token.INT, "50"}, + + {token.IDENT, "dateOfBirth"}, + {token.IDENT, "eq"}, + {token.DATETIME, "2000-01-01"}, + + {token.IDENT, "dateOfBirth"}, + {token.IDENT, "lt"}, + {token.DATETIME, "2000-01-01"}, + + {token.IDENT, "dateOfBirth"}, + {token.IDENT, "lte"}, + {token.DATETIME, "2000-01-01"}, + + {token.IDENT, "dateOfBirth"}, + {token.IDENT, "gt"}, + {token.DATETIME, "2000-01-01"}, + + {token.IDENT, "dateOfBirth"}, + {token.IDENT, "gte"}, + {token.DATETIME, "2000-01-01"}, + + {token.IDENT, "dateOfBirth"}, + {token.IDENT, "eq"}, + {token.DATETIME, "2023-01-01T15:30:00Z"}, + + {token.IDENT, "dateOfBirth"}, + {token.IDENT, "eq"}, + {token.DATETIME, "2023-01-30T09:29:55.1750906Z"}, } lexer := NewLexer(input) diff --git a/module/gorm/apply.go b/module/gorm/apply.go index 242f74d..54ab9c1 100644 --- a/module/gorm/apply.go +++ b/module/gorm/apply.go @@ -23,14 +23,17 @@ func LogQuery(db *gorm.DB) *gorm.DB { return db } -func Apply(db *gorm.DB, query goatquery.Query, model interface{}, searchFunc SearchFunc, options *goatquery.QueryOptions) (*gorm.DB, *int64, error) { +func Apply[T any](db *gorm.DB, query goatquery.Query, searchFunc SearchFunc, options *goatquery.QueryOptions) (*gorm.DB, *int64, error) { if options != nil && query.Top > options.MaxTop { return nil, nil, fmt.Errorf("The value supplied for the query parameter 'Top' was greater than the maximum top allowed for this resource") } - v := reflect.ValueOf(model) - t := reflect.Indirect(v).Type().Elem() + var model T + + // v := reflect.ValueOf(model) + t := reflect.TypeOf(model) namer := db.Statement.NamingStrategy + tableName := namer.TableName(t.Name()) // Filter if query.Filter != "" { @@ -39,7 +42,7 @@ func Apply(db *gorm.DB, query goatquery.Query, model interface{}, searchFunc Sea statements := p.ParseFilter() - db = EvaluateFilter(&statements.Expression, db) + db = EvaluateFilter(statements.Expression, db, namer, tableName, t) } // Search @@ -61,7 +64,7 @@ func Apply(db *gorm.DB, query goatquery.Query, model interface{}, searchFunc Sea statements := p.ParseOrderBy() for _, statement := range statements { - property := GetGormColumnName(namer, namer.TableName(t.Name()), t, statement.TokenLiteral()) + property := GetGormColumnName(namer, tableName, t, statement.TokenLiteral()) sql := fmt.Sprintf("%s %s", property, statement.Direction) @@ -119,42 +122,59 @@ func GetGormColumnName(namer schema.Namer, tableName string, t reflect.Type, pro return namer.ColumnName(tableName, property) } -func EvaluateFilter(exp ast.Expression, db *gorm.DB) *gorm.DB { +func EvaluateFilter(exp ast.Expression, db *gorm.DB, namer schema.Namer, tableName string, t reflect.Type) *gorm.DB { switch exp := exp.(type) { case *ast.InfixExpression: identifier, ok := exp.Left.(*ast.Identifier) if ok { - var value interface{} switch right := exp.Right.(type) { - case *ast.StringLiteral: + case *ast.GuidLiteral: value = right.Value case *ast.IntegerLiteral: value = right.Value + case *ast.FloatLiteral: + value = right.Value + case *ast.StringLiteral: + value = right.Value + case *ast.DateTimeLiteral: + value = right.Value } + property := GetGormColumnName(namer, namer.TableName(t.Name()), t, identifier.TokenLiteral()) + switch strings.ToLower(exp.Operator) { case keywords.EQ: - return db.Where(fmt.Sprintf("%s = ?", identifier.TokenLiteral()), value) + return db.Where(fmt.Sprintf("%s = ?", property), value) case keywords.NE: - return db.Where(fmt.Sprintf("%s <> ?", identifier.TokenLiteral()), value) + return db.Where(fmt.Sprintf("%s <> ?", property), value) case keywords.CONTAINS: if str, ok := exp.Right.(*ast.StringLiteral); ok { - return db.Where(fmt.Sprintf("%s LIKE ?", identifier.TokenLiteral()), "%"+str.Value+"%") + return db.Where(fmt.Sprintf("%s LIKE ?", property), "%"+str.Value+"%") } + case keywords.LT: + return db.Where(fmt.Sprintf("%s < ?", property), value) + case keywords.LTE: + return db.Where(fmt.Sprintf("%s <= ?", property), value) + case keywords.GT: + return db.Where(fmt.Sprintf("%s > ?", property), value) + case keywords.GTE: + return db.Where(fmt.Sprintf("%s >= ?", property), value) } } + left := EvaluateFilter(exp.Left, db, namer, tableName, t) + right := EvaluateFilter(exp.Right, db, namer, tableName, t) + switch exp.Operator { case keywords.AND: - return EvaluateFilter(exp.Right, EvaluateFilter(exp.Left, db)) + return left.Where(right) case keywords.OR: - left := EvaluateFilter(exp.Left, db) - right := EvaluateFilter(exp.Right, db) - return left.Or(right) } + + break } return db diff --git a/module/gorm/apply_test.go b/module/gorm/apply_test.go index 31d37e1..231beac 100644 --- a/module/gorm/apply_test.go +++ b/module/gorm/apply_test.go @@ -190,10 +190,10 @@ func Test_OrderBy(t *testing.T) { OrderBy: test.input, } - var output []User - res, _, err := Apply(DB, query, &output, nil, nil) + res, _, err := Apply[User](DB, query, nil, nil) assert.NoError(t, err) + var output []User err = res.Find(&output).Error assert.NoError(t, err) @@ -215,7 +215,7 @@ func Test_Count(t *testing.T) { Count: test.input, } - _, count, err := Apply(DB, query, &User{}, nil, nil) + _, count, err := Apply[User](DB, query, nil, nil) assert.NoError(t, err) assert.Equal(t, test.expectedCount, count) @@ -243,10 +243,10 @@ func Test_Search(t *testing.T) { Search: test.input, } - var output []User - res, _, err := Apply(DB, query, &output, searchFunc, nil) + res, _, err := Apply[User](DB, query, searchFunc, nil) assert.NoError(t, err) + var output []User err = res.Find(&output).Error assert.NoError(t, err) @@ -262,18 +262,18 @@ func Test_Skip(t *testing.T) { {1, []User{ users["Jane"], users["Apple"], - users["John"], + users["Harry"], users["Doe"], users["Egg"], }}, {2, []User{ users["Apple"], - users["John"], + users["Harry"], users["Doe"], users["Egg"], }}, {3, []User{ - users["John"], + users["Harry"], users["Doe"], users["Egg"], }}, @@ -293,10 +293,10 @@ func Test_Skip(t *testing.T) { Skip: test.input, } - var output []User - res, _, err := Apply(DB, query, &output, nil, nil) + res, _, err := Apply[User](DB, query, nil, nil) assert.NoError(t, err) + var output []User err = res.Find(&output).Error assert.NoError(t, err) @@ -325,10 +325,10 @@ func Test_Top(t *testing.T) { Top: test.input, } - var output []User - res, _, err := Apply(DB, query, &output, nil, nil) + res, _, err := Apply[User](DB, query, nil, nil) assert.NoError(t, err) + var output []User err = res.Find(&output).Error assert.NoError(t, err) @@ -358,10 +358,10 @@ func Test_TopWithMaxTop(t *testing.T) { MaxTop: 4, } - var output []User - res, _, err := Apply(DB, query, &output, nil, &options) + res, _, err := Apply[User](DB, query, nil, &options) assert.NoError(t, err) + var output []User err = res.Find(&output).Error assert.NoError(t, err) @@ -385,7 +385,7 @@ func Test_TopWithMaxTopReturnsError(t *testing.T) { MaxTop: 4, } - _, _, err := Apply(DB, query, &User{}, nil, &options) + _, _, err := Apply[User](DB, query, nil, &options) assert.Error(t, err) } } @@ -412,12 +412,12 @@ func Test_Filter(t *testing.T) { users["Doe"], users["Egg"], }}, - {"Age eq 1 and firstName eq 'Harry' or Age eq 2", []User{ + {"Age eq 1 and firstname eq 'Harry' or Age eq 2", []User{ users["John"], users["Apple"], users["Harry"], }}, - {"Age eq 1 or Age eq 2 or firstName eq 'Egg'", []User{ + {"Age eq 1 or Age eq 2 or firstname eq 'Egg'", []User{ users["John"], users["Jane"], users["Apple"], @@ -430,28 +430,28 @@ func Test_Filter(t *testing.T) { users["Apple"], users["Harry"], }}, - {"firstName contains 'a'", []User{ + {"firstname contains 'a'", []User{ users["Jane"], users["Apple"], users["Harry"], }}, - {"Age ne 1 and firstName contains 'a'", []User{ + {"Age ne 1 and firstname contains 'a'", []User{ users["Apple"], }}, - {"Age ne 1 and firstName contains 'a' or firstName eq 'Apple'", []User{ + {"Age ne 1 and firstname contains 'a' or firstname eq 'Apple'", []User{ users["Apple"], }}, - {"Firstname eq 'John' and Age eq 2 or Age eq 3", []User{ + {"firstname eq 'John' and Age eq 2 or Age eq 3", []User{ users["John"], users["Doe"], users["Egg"], }}, - {"(Firstname eq 'John' and Age eq 2) or Age eq 3", []User{ + {"(firstname eq 'John' and Age eq 2) or Age eq 3", []User{ users["John"], users["Doe"], users["Egg"], }}, - {"Firstname eq 'John' and (Age eq 2 or Age eq 3)", []User{ + {"firstname eq 'John' and (Age eq 2 or Age eq 3)", []User{ users["John"], }}, {"(Firstname eq 'John' and Age eq 2 or Age eq 3)", []User{ @@ -493,9 +493,48 @@ func Test_Filter(t *testing.T) { users["John"], users["Apple"], }}, - {"balanceDecimal eq 1.50m", []User{ + {"balance eq 1.50f", []User{ users["John"], }}, + {"balance gt 1f", []User{ + users["John"], users["Apple"], users["Egg"], + }}, + {"balance gt 0.50f", []User{ + users["John"], users["Apple"], users["Harry"], users["Egg"], + }}, + {"balance eq 0.5372958205929493f", []User{ + users["Harry"], + }}, + {"balance eq 1334534453453433.33435443343231235652f", []User{ + users["Egg"], + }}, + {"balance eq 1204050.98f", []User{ + users["Apple"], + }}, + {"balance gt 2204050f", []User{ + users["Egg"], + }}, + {"dateOfBirth eq 2000-01-01", []User{ + users["Egg"], + }}, + {"dateOfBirth lt 2010-01-01", []User{ + users["John"], users["Apple"], users["Harry"], users["Egg"], + }}, + {"dateOfBirth lte 2002-08-01", []User{ + users["Apple"], users["Harry"], users["Egg"], + }}, + {"dateOfBirth gt 2000-08-01 and dateOfBirth lt 2023-01-01", []User{ + users["John"], users["Jane"], users["Harry"], + }}, + {"dateOfBirth eq 2023-07-26T12:00:30Z", []User{ + users["Doe"], + }}, + {"dateOfBirth gte 2000-01-01", []User{ + users["John"], users["Jane"], users["Harry"], users["Doe"], users["Egg"], + }}, + {"dateOfBirth gte 2000-01-01 and dateOfBirth lte 2020-05-09T15:29:59Z", []User{ + users["John"], users["Harry"], users["Egg"], + }}, } for _, test := range tests { @@ -503,10 +542,10 @@ func Test_Filter(t *testing.T) { Filter: test.input, } - var output []User - res, _, err := Apply(DB, query, &output, nil, nil) + res, _, err := Apply[User](DB, query, nil, nil) assert.NoError(t, err) + var output []User err = res.Find(&output).Error assert.NoError(t, err) @@ -514,6 +553,17 @@ func Test_Filter(t *testing.T) { } } +func Test_InvalidFilterReturnsError(t *testing.T) { + input := `NonExistentProperty eq 'John'` + + query := goatquery.Query{ + Filter: input, + } + + _, _, err := Apply[User](DB, query, nil, nil) + assert.Error(t, err) +} + func makePointer[T any](v T) *T { return &v } diff --git a/module/gorm/go.mod b/module/gorm/go.mod index 3262699..a12260c 100644 --- a/module/gorm/go.mod +++ b/module/gorm/go.mod @@ -4,22 +4,23 @@ go 1.22 require ( github.com/glebarez/sqlite v1.11.0 - github.com/goatquery/goatquery-go v0.0.0-00010101000000-000000000000 + github.com/goatquery/goatquery-go v0.5.0 github.com/stretchr/testify v1.9.0 - gorm.io/gorm v1.25.10 + gorm.io/gorm v1.25.12 ) require ( github.com/davecgh/go-spew v1.1.1 // indirect github.com/dustin/go-humanize v1.0.1 // indirect github.com/glebarez/go-sqlite v1.21.2 // indirect - github.com/google/uuid v1.3.0 // indirect + github.com/google/uuid v1.6.0 // indirect github.com/jinzhu/inflection v1.0.0 // indirect github.com/jinzhu/now v1.1.5 // indirect github.com/mattn/go-isatty v0.0.17 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect golang.org/x/sys v0.7.0 // indirect + golang.org/x/text v0.19.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect modernc.org/libc v1.22.5 // indirect modernc.org/mathutil v1.5.0 // indirect diff --git a/module/gorm/go.sum b/module/gorm/go.sum index 508a694..6e44c68 100644 --- a/module/gorm/go.sum +++ b/module/gorm/go.sum @@ -10,6 +10,8 @@ github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbu github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26/go.mod h1:dDKJzRmX4S37WGHujM7tX//fmj1uioxKzKxz3lo4HJo= github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= @@ -26,12 +28,16 @@ github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU= golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM= +golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gorm.io/gorm v1.25.10 h1:dQpO+33KalOA+aFYGlK+EfxcI5MbO7EP2yYygwh9h+s= gorm.io/gorm v1.25.10/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8= +gorm.io/gorm v1.25.12 h1:I0u8i2hWQItBq1WfE0o2+WuL9+8L21K9e2HHSTE/0f8= +gorm.io/gorm v1.25.12/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ= modernc.org/libc v1.22.5 h1:91BNch/e5B0uPbJFgqbxXuOnxBQjlS//icfQEGmvyjE= modernc.org/libc v1.22.5/go.mod h1:jj+Z7dTNX8fBScMVNRAYZ/jF91K8fdT2hYMThc3YjBY= modernc.org/mathutil v1.5.0 h1:rV0Ko/6SfM+8G+yKiyI830l3Wuz1zRutdslNoQ0kfiQ= diff --git a/parser/parser.go b/parser/parser.go index a811d35..31dc201 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -4,10 +4,12 @@ import ( "strconv" "strings" + "github.com/goatquery/goatquery-go" "github.com/goatquery/goatquery-go/ast" "github.com/goatquery/goatquery-go/keywords" "github.com/goatquery/goatquery-go/lexer" "github.com/goatquery/goatquery-go/token" + "github.com/google/uuid" ) type Parser struct { @@ -63,7 +65,7 @@ func (p *Parser) ParseFilter() *ast.ExpressionStatement { return statement } -func (p *Parser) ParseExpression(precedence int) ast.InfixExpression { +func (p *Parser) ParseExpression(precedence int) *ast.InfixExpression { var left *ast.InfixExpression if p.currentTokenIs(token.LPAREN) { @@ -82,13 +84,13 @@ func (p *Parser) ParseExpression(precedence int) ast.InfixExpression { p.NextToken() right := p.ParseExpression(currentPrecedence) - left.Right = &right + left.Right = right } else { break } } - return *left + return left } func (p *Parser) ParseGroupedExpression() *ast.InfixExpression { @@ -100,13 +102,13 @@ func (p *Parser) ParseGroupedExpression() *ast.InfixExpression { return nil } - return &exp + return exp } func (p *Parser) ParseFilterStatement() *ast.InfixExpression { identifer := ast.Identifier{Token: p.currentToken, Value: p.currentToken.Literal} - if !p.peekIdentiferIn(keywords.EQ, keywords.NE, keywords.CONTAINS) { + if !p.peekIdentiferIn(keywords.EQ, keywords.NE, keywords.CONTAINS, keywords.LT, keywords.LTE, keywords.GT, keywords.GTE) { return nil } @@ -114,7 +116,7 @@ func (p *Parser) ParseFilterStatement() *ast.InfixExpression { statement := ast.InfixExpression{Token: p.currentToken, Left: &identifer, Operator: p.currentToken.Literal} - if !p.peekTokenIs(token.STRING) && !p.peekTokenIs(token.INT) { + if !p.peekTokenIn(token.STRING, token.INT, token.GUID, token.DATETIME, token.FLOAT) { return nil } @@ -125,6 +127,11 @@ func (p *Parser) ParseFilterStatement() *ast.InfixExpression { } switch p.currentToken.Type { + case token.GUID: + val, err := uuid.Parse(p.currentToken.Literal) + if err == nil { + statement.Right = &ast.GuidLiteral{Token: p.currentToken, Value: val} + } case token.STRING: statement.Right = &ast.StringLiteral{Token: p.currentToken, Value: p.currentToken.Literal} case token.INT: @@ -137,6 +144,29 @@ func (p *Parser) ParseFilterStatement() *ast.InfixExpression { literal.Value = value + statement.Right = literal + case token.FLOAT: + literal := &ast.FloatLiteral{Token: p.currentToken} + + literalWithoutSuffix := strings.TrimSuffix(p.currentToken.Literal, "f") + value, err := strconv.ParseFloat(literalWithoutSuffix, 64) + if err != nil { + return nil + } + + literal.Value = value + + statement.Right = literal + case token.DATETIME: + literal := &ast.DateTimeLiteral{Token: p.currentToken} + + value, err := goatquery.ParseDateTime(p.currentToken.Literal) + if err != nil { + return nil + } + + literal.Value = *value + statement.Right = literal } @@ -166,6 +196,16 @@ func (p *Parser) peekTokenIs(t token.TokenType) bool { return p.peekToken.Type == t } +func (p *Parser) peekTokenIn(tokens ...token.TokenType) bool { + for _, token := range tokens { + if p.peekToken.Type == token { + return true + } + } + + return false +} + func (p *Parser) peekIdentiferIs(identifier string) bool { return p.peekToken.Type == token.IDENT && strings.EqualFold(p.peekToken.Literal, identifier) } diff --git a/parser/parser_test.go b/parser/parser_test.go index 88c9a17..1d4cbc0 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -28,6 +28,11 @@ func Test_ParsingOrderByStatement(t *testing.T) { {Token: token.Token{Type: token.IDENT, Literal: "address"}, Direction: ast.Ascending}, {Token: token.Token{Type: token.IDENT, Literal: "postcode"}, Direction: ast.Descending}, }}, + {"address1Line10 asc, asc asc, desc desc", []ast.OrderByStatement{ + {Token: token.Token{Type: token.IDENT, Literal: "address1Line10"}, Direction: ast.Ascending}, + {Token: token.Token{Type: token.IDENT, Literal: "asc"}, Direction: ast.Ascending}, + {Token: token.Token{Type: token.IDENT, Literal: "desc"}, Direction: ast.Descending}, + }}, {"", []ast.OrderByStatement{}}, } @@ -58,6 +63,18 @@ func Test_ParsingFilterStatement(t *testing.T) { {"Age eq 21", "Age", "eq", "21"}, {"Age ne 10", "Age", "ne", "10"}, {"Name contains 'John'", "Name", "contains", "John"}, + {"Id eq e4c7772b-8947-4e46-98ed-644b417d2a08", "Id", "eq", "e4c7772b-8947-4e46-98ed-644b417d2a08"}, + {"Id eq 3.14159265359f", "Id", "eq", "3.14159265359f"}, + {"Age lt 99", "Age", "lt", "99"}, + {"Age lte 99", "Age", "lte", "99"}, + {"Age gt 99", "Age", "gt", "99"}, + {"Age gte 99", "Age", "gte", "99"}, + {"dateOfBirth eq 2000-01-01", "dateOfBirth", "eq", "2000-01-01"}, + {"dateOfBirth lt 2000-01-01", "dateOfBirth", "lt", "2000-01-01"}, + {"dateOfBirth lte 2000-01-01", "dateOfBirth", "lte", "2000-01-01"}, + {"dateOfBirth gt 2000-01-01", "dateOfBirth", "gt", "2000-01-01"}, + {"dateOfBirth gte 2000-01-01", "dateOfBirth", "gte", "2000-01-01"}, + {"dateOfBirth eq 2023-01-30T09:29:55.1750906Z", "dateOfBirth", "eq", "2023-01-30T09:29:55.1750906Z"}, } for _, test := range tests { @@ -75,7 +92,91 @@ func Test_ParsingFilterStatement(t *testing.T) { } } -func Test_ParsingComplexFilterStatement(t *testing.T) { +func Test_ParsingInvalidFilterReturnsError(t *testing.T) { + inputs := []string{ + "Name", + "", + "eq nee", + "name nee 10", + "id contains 10", + "id contaiins '10'", + "id eq John'", + } + + for _, input := range inputs { + l := lexer.NewLexer(input) + p := NewParser(l) + + statement := p.ParseFilter() + + expression := statement.Expression + assert.Nil(t, expression) + } +} + +func Test_ParsingFilterStatementWithAnd(t *testing.T) { + input := `Name eq 'John' and Age eq 10` + + l := lexer.NewLexer(input) + p := NewParser(l) + + statement := p.ParseFilter() + + expression := statement.Expression + assert.NotNil(t, expression) + + //Left + left, ok := expression.Left.(*ast.InfixExpression) + assert.True(t, ok) + + assert.Equal(t, "Name", left.Left.TokenLiteral()) + assert.Equal(t, "eq", left.Operator) + assert.Equal(t, "John", left.Right.TokenLiteral()) + + // inner operator + assert.Equal(t, "and", expression.Operator) + + // inner right + right, ok := expression.Right.(*ast.InfixExpression) + assert.True(t, ok) + + assert.Equal(t, "Age", right.Left.TokenLiteral()) + assert.Equal(t, "eq", right.Operator) + assert.Equal(t, "10", right.Right.TokenLiteral()) +} + +func Test_ParsingFilterStatementWithOr(t *testing.T) { + input := `Name eq 'John' or Age eq 10` + + l := lexer.NewLexer(input) + p := NewParser(l) + + statement := p.ParseFilter() + + expression := statement.Expression + assert.NotNil(t, expression) + + //Left + left, ok := expression.Left.(*ast.InfixExpression) + assert.True(t, ok) + + assert.Equal(t, "Name", left.Left.TokenLiteral()) + assert.Equal(t, "eq", left.Operator) + assert.Equal(t, "John", left.Right.TokenLiteral()) + + // inner operator + assert.Equal(t, "or", expression.Operator) + + // inner right + right, ok := expression.Right.(*ast.InfixExpression) + assert.True(t, ok) + + assert.Equal(t, "Age", right.Left.TokenLiteral()) + assert.Equal(t, "eq", right.Operator) + assert.Equal(t, "10", right.Right.TokenLiteral()) +} + +func Test_ParsingFilterStatementWithAndAndOr(t *testing.T) { input := `Name eq 'John' and Age eq 10 or Id eq 10` l := lexer.NewLexer(input) diff --git a/time.go b/time.go new file mode 100644 index 0000000..687c506 --- /dev/null +++ b/time.go @@ -0,0 +1,20 @@ +package goatquery + +import ( + "fmt" + "time" +) + +func ParseDateTime(value string) (*time.Time, error) { + val, err := time.Parse(time.RFC3339, value) + if err == nil { + return &val, nil + } + + val, err = time.Parse(time.DateOnly, value) + if err == nil { + return &val, nil + } + + return nil, fmt.Errorf("could not parse datetime") +} diff --git a/token/token.go b/token/token.go index 8f299bc..8297c6c 100644 --- a/token/token.go +++ b/token/token.go @@ -4,9 +4,12 @@ const ( ILLEGAL = "ILLEGAL" EOF = "EOF" - IDENT = "IDENT" - INT = "INT" - STRING = "STRING" + IDENT = "IDENT" + INT = "INT" + STRING = "STRING" + GUID = "GUID" + FLOAT = "FLOAT" + DATETIME = "DATETIME" LPAREN = "LPAREN" RPAREN = "RPAREN" From 0331a83dcd1b56841cbf0d1ea94f5589ff1b1027 Mon Sep 17 00:00:00 2001 From: Jamess-Lucass <23193271+Jamess-Lucass@users.noreply.github.com> Date: Sat, 9 Nov 2024 23:26:17 +0000 Subject: [PATCH 13/14] wip --- module/gorm/apply.go | 66 +++++++++++++++++++++++++-------------- module/gorm/apply_test.go | 32 +++++++++++++++++-- 2 files changed, 73 insertions(+), 25 deletions(-) diff --git a/module/gorm/apply.go b/module/gorm/apply.go index 54ab9c1..e0c7c12 100644 --- a/module/gorm/apply.go +++ b/module/gorm/apply.go @@ -27,11 +27,13 @@ func Apply[T any](db *gorm.DB, query goatquery.Query, searchFunc SearchFunc, opt if options != nil && query.Top > options.MaxTop { return nil, nil, fmt.Errorf("The value supplied for the query parameter 'Top' was greater than the maximum top allowed for this resource") } + var err error var model T // v := reflect.ValueOf(model) t := reflect.TypeOf(model) + namer := db.Statement.NamingStrategy tableName := namer.TableName(t.Name()) @@ -42,7 +44,10 @@ func Apply[T any](db *gorm.DB, query goatquery.Query, searchFunc SearchFunc, opt statements := p.ParseFilter() - db = EvaluateFilter(statements.Expression, db, namer, tableName, t) + db, err = EvaluateFilter(statements.Expression, db, namer, tableName, t) + if err != nil { + return db, nil, err + } } // Search @@ -64,9 +69,12 @@ func Apply[T any](db *gorm.DB, query goatquery.Query, searchFunc SearchFunc, opt statements := p.ParseOrderBy() for _, statement := range statements { - property := GetGormColumnName(namer, tableName, t, statement.TokenLiteral()) + property, err := GetGormColumnName(namer, tableName, t, statement.TokenLiteral()) + if err != nil { + return db, &count, err + } - sql := fmt.Sprintf("%s %s", property, statement.Direction) + sql := fmt.Sprintf("%s %s", *property, statement.Direction) db = db.Order(sql) } @@ -93,13 +101,14 @@ func Apply[T any](db *gorm.DB, query goatquery.Query, searchFunc SearchFunc, opt return db, nil, nil } -func GetGormColumnName(namer schema.Namer, tableName string, t reflect.Type, property string) string { +func GetGormColumnName(namer schema.Namer, tableName string, t reflect.Type, property string) (*string, error) { for i := 0; i < t.NumField(); i++ { field := t.Field(i) if field.Anonymous { - if columnName := GetGormColumnName(namer, tableName, field.Type, property); columnName != "" { - return columnName + columnName, err := GetGormColumnName(namer, tableName, field.Type, property) + if err == nil && *columnName != "" { + return columnName, nil } continue } @@ -112,17 +121,19 @@ func GetGormColumnName(namer schema.Namer, tableName string, t reflect.Type, pro if strings.EqualFold(propertyName, property) { settings := schema.ParseTagSetting(field.Tag.Get("gorm"), ";") if settings["COLUMN"] != "" { - return settings["COLUMN"] + col := settings["COLUMN"] + return &col, nil } - return namer.ColumnName(tableName, field.Name) + col := namer.ColumnName(tableName, field.Name) + return &col, nil } } - return namer.ColumnName(tableName, property) + return nil, fmt.Errorf("Property doesn't exist") } -func EvaluateFilter(exp ast.Expression, db *gorm.DB, namer schema.Namer, tableName string, t reflect.Type) *gorm.DB { +func EvaluateFilter(exp ast.Expression, db *gorm.DB, namer schema.Namer, tableName string, t reflect.Type) (*gorm.DB, error) { switch exp := exp.(type) { case *ast.InfixExpression: identifier, ok := exp.Left.(*ast.Identifier) @@ -142,40 +153,49 @@ func EvaluateFilter(exp ast.Expression, db *gorm.DB, namer schema.Namer, tableNa value = right.Value } - property := GetGormColumnName(namer, namer.TableName(t.Name()), t, identifier.TokenLiteral()) + property, err := GetGormColumnName(namer, namer.TableName(t.Name()), t, identifier.TokenLiteral()) + if err != nil { + return db, err + } switch strings.ToLower(exp.Operator) { case keywords.EQ: - return db.Where(fmt.Sprintf("%s = ?", property), value) + return db.Where(fmt.Sprintf("%s = ?", *property), value), nil case keywords.NE: - return db.Where(fmt.Sprintf("%s <> ?", property), value) + return db.Where(fmt.Sprintf("%s <> ?", *property), value), nil case keywords.CONTAINS: if str, ok := exp.Right.(*ast.StringLiteral); ok { - return db.Where(fmt.Sprintf("%s LIKE ?", property), "%"+str.Value+"%") + return db.Where(fmt.Sprintf("%s LIKE ?", *property), "%"+str.Value+"%"), nil } case keywords.LT: - return db.Where(fmt.Sprintf("%s < ?", property), value) + return db.Where(fmt.Sprintf("%s < ?", *property), value), nil case keywords.LTE: - return db.Where(fmt.Sprintf("%s <= ?", property), value) + return db.Where(fmt.Sprintf("%s <= ?", *property), value), nil case keywords.GT: - return db.Where(fmt.Sprintf("%s > ?", property), value) + return db.Where(fmt.Sprintf("%s > ?", *property), value), nil case keywords.GTE: - return db.Where(fmt.Sprintf("%s >= ?", property), value) + return db.Where(fmt.Sprintf("%s >= ?", *property), value), nil } } - left := EvaluateFilter(exp.Left, db, namer, tableName, t) - right := EvaluateFilter(exp.Right, db, namer, tableName, t) + left, err := EvaluateFilter(exp.Left, db, namer, tableName, t) + if err != nil { + return db, err + } + right, err := EvaluateFilter(exp.Right, db, namer, tableName, t) + if err != nil { + return db, err + } switch exp.Operator { case keywords.AND: - return left.Where(right) + return left.Where(right), nil case keywords.OR: - return left.Or(right) + return left.Or(right), nil } break } - return db + return db, nil } diff --git a/module/gorm/apply_test.go b/module/gorm/apply_test.go index 231beac..aa8d1f9 100644 --- a/module/gorm/apply_test.go +++ b/module/gorm/apply_test.go @@ -25,6 +25,7 @@ type User struct { Firstname string Balance *float64 DateOfBirth time.Time + JsonProp string `json:"random_json_name"` } var DB *gorm.DB @@ -50,7 +51,7 @@ func timeMustParse(value string) time.Time { } var users = map[string]User{ - "John": {Base: Base{Age: 2}, Firstname: "John", UserId: uuid.MustParse("58cdeca3-645b-457c-87aa-7d5f87734255"), DateOfBirth: timeMustParse("2004-01-31 23:59:59"), Balance: makePointer(1.50)}, + "John": {Base: Base{Age: 2}, Firstname: "John", UserId: uuid.MustParse("58cdeca3-645b-457c-87aa-7d5f87734255"), DateOfBirth: timeMustParse("2004-01-31 23:59:59"), Balance: makePointer(1.50), JsonProp: "user_john"}, "Jane": {Base: Base{Age: 1}, Firstname: "Jane", UserId: uuid.MustParse("58cdeca3-645b-457c-87aa-7d5f87734255"), DateOfBirth: timeMustParse("2020-05-09 15:30:00"), Balance: makePointer(0.0)}, "Apple": {Base: Base{Age: 2}, Firstname: "Apple", UserId: uuid.MustParse("58cdeca3-645b-457c-87aa-7d5f87734255"), DateOfBirth: timeMustParse("1980-12-31 00:00:01"), Balance: makePointer(1204050.98)}, "Harry": {Base: Base{Age: 1}, Firstname: "Harry", UserId: uuid.MustParse("e4c7772b-8947-4e46-98ed-644b417d2a08"), DateOfBirth: timeMustParse("2002-08-01"), Balance: makePointer(0.5372958205929493)}, @@ -60,7 +61,7 @@ var users = map[string]User{ func setup() { db, err := gorm.Open(sqlite.Open("file::memory:?cache=shared"), &gorm.Config{ - Logger: logger.Default.LogMode(logger.Error), + Logger: logger.Default.LogMode(logger.Info), }) if err != nil { @@ -564,6 +565,33 @@ func Test_InvalidFilterReturnsError(t *testing.T) { assert.Error(t, err) } +func Test_Filter_WithCustomJsonTag(t *testing.T) { + tests := []struct { + input string + expected []User + }{ + {"random_json_name eq 'user_john'", []User{ + users["John"], + }}, + } + + for _, test := range tests { + + query := goatquery.Query{ + Filter: test.input, + } + + res, _, err := Apply[User](DB, query, nil, nil) + assert.NoError(t, err) + + var output []User + err = res.Find(&output).Error + assert.NoError(t, err) + + assert.Equal(t, test.expected, output) + } +} + func makePointer[T any](v T) *T { return &v } From dad68b4856ea7a487aecd83605d7412ec3b2a1bc Mon Sep 17 00:00:00 2001 From: Jamess-Lucass <23193271+Jamess-Lucass@users.noreply.github.com> Date: Mon, 25 Nov 2024 22:45:05 +0000 Subject: [PATCH 14/14] added gorm example --- module/gorm/apply.go | 1 - module/gorm/example/go.mod | 75 ++++++++++++ module/gorm/example/go.sum | 235 ++++++++++++++++++++++++++++++++++++ module/gorm/example/main.go | 101 ++++++++++++++++ 4 files changed, 411 insertions(+), 1 deletion(-) create mode 100644 module/gorm/example/go.mod create mode 100644 module/gorm/example/go.sum create mode 100644 module/gorm/example/main.go diff --git a/module/gorm/apply.go b/module/gorm/apply.go index e0c7c12..ab36bf4 100644 --- a/module/gorm/apply.go +++ b/module/gorm/apply.go @@ -31,7 +31,6 @@ func Apply[T any](db *gorm.DB, query goatquery.Query, searchFunc SearchFunc, opt var model T - // v := reflect.ValueOf(model) t := reflect.TypeOf(model) namer := db.Statement.NamingStrategy diff --git a/module/gorm/example/go.mod b/module/gorm/example/go.mod new file mode 100644 index 0000000..bb48936 --- /dev/null +++ b/module/gorm/example/go.mod @@ -0,0 +1,75 @@ +module github.com/goatquery/goatquery-go/module/gorm/example + +go 1.22 + +replace github.com/goatquery/goatquery-go => ../../.. + +replace github.com/goatquery/goatquery-go/module/gorm => .. + +require ( + github.com/brianvoe/gofakeit/v7 v7.1.2 + github.com/goatquery/goatquery-go v0.5.0 + github.com/goatquery/goatquery-go/module/gorm v0.0.0-00010101000000-000000000000 + github.com/google/uuid v1.6.0 + github.com/testcontainers/testcontainers-go v0.34.0 + github.com/testcontainers/testcontainers-go/modules/postgres v0.34.0 + gorm.io/driver/postgres v1.5.10 + gorm.io/gorm v1.25.12 +) + +require ( + dario.cat/mergo v1.0.0 // indirect + github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect + github.com/Microsoft/go-winio v0.6.2 // indirect + github.com/cenkalti/backoff/v4 v4.2.1 // indirect + github.com/containerd/containerd v1.7.18 // indirect + github.com/containerd/log v0.1.0 // indirect + github.com/containerd/platforms v0.2.1 // indirect + github.com/cpuguy83/dockercfg v0.3.2 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/distribution/reference v0.6.0 // indirect + github.com/docker/docker v27.1.1+incompatible // indirect + github.com/docker/go-connections v0.5.0 // indirect + github.com/docker/go-units v0.5.0 // indirect + github.com/felixge/httpsnoop v1.0.4 // indirect + github.com/go-logr/logr v1.4.1 // indirect + github.com/go-logr/stdr v1.2.2 // indirect + github.com/go-ole/go-ole v1.2.6 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect + github.com/jackc/pgx/v5 v5.7.1 // indirect + github.com/jackc/puddle/v2 v2.2.2 // indirect + github.com/jinzhu/inflection v1.0.0 // indirect + github.com/jinzhu/now v1.1.5 // indirect + github.com/klauspost/compress v1.17.4 // indirect + github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 // indirect + github.com/magiconair/properties v1.8.7 // indirect + github.com/moby/docker-image-spec v1.3.1 // indirect + github.com/moby/patternmatcher v0.6.0 // indirect + github.com/moby/sys/sequential v0.5.0 // indirect + github.com/moby/sys/user v0.1.0 // indirect + github.com/moby/term v0.5.0 // indirect + github.com/morikuni/aec v1.0.0 // indirect + github.com/opencontainers/go-digest v1.0.0 // indirect + github.com/opencontainers/image-spec v1.1.0 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c // indirect + github.com/shirou/gopsutil/v3 v3.23.12 // indirect + github.com/shoenig/go-m1cpu v0.1.6 // indirect + github.com/sirupsen/logrus v1.9.3 // indirect + github.com/stretchr/testify v1.9.0 // indirect + github.com/tklauser/go-sysconf v0.3.12 // indirect + github.com/tklauser/numcpus v0.6.1 // indirect + github.com/yusufpapurcu/wmi v1.2.3 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 // indirect + go.opentelemetry.io/otel v1.24.0 // indirect + go.opentelemetry.io/otel/metric v1.24.0 // indirect + go.opentelemetry.io/otel/trace v1.24.0 // indirect + golang.org/x/crypto v0.29.0 // indirect + golang.org/x/sync v0.9.0 // indirect + golang.org/x/sys v0.27.0 // indirect + golang.org/x/text v0.20.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect +) diff --git a/module/gorm/example/go.sum b/module/gorm/example/go.sum new file mode 100644 index 0000000..f927d99 --- /dev/null +++ b/module/gorm/example/go.sum @@ -0,0 +1,235 @@ +dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk= +dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= +github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24 h1:bvDV9vkmnHYOMsOr4WLk+Vo07yKIzd94sVoIqshQ4bU= +github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24/go.mod h1:8o94RPi1/7XTJvwPpRSzSUedZrtlirdB3r9Z20bi2f8= +github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 h1:UQHMgLO+TxOElx5B5HZ4hJQsoJ/PvUvKRhJHDQXO8P8= +github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= +github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= +github.com/brianvoe/gofakeit/v7 v7.1.2 h1:vSKaVScNhWVpf1rlyEKSvO8zKZfuDtGqoIHT//iNNb8= +github.com/brianvoe/gofakeit/v7 v7.1.2/go.mod h1:QXuPeBw164PJCzCUZVmgpgHJ3Llj49jSLVkKPMtxtxA= +github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM= +github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= +github.com/containerd/containerd v1.7.18 h1:jqjZTQNfXGoEaZdW1WwPU0RqSn1Bm2Ay/KJPUuO8nao= +github.com/containerd/containerd v1.7.18/go.mod h1:IYEk9/IO6wAPUz2bCMVUbsfXjzw5UNP5fLz4PsUygQ4= +github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I= +github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo= +github.com/containerd/platforms v0.2.1 h1:zvwtM3rz2YHPQsF2CHYM8+KtB5dvhISiXh5ZpSBQv6A= +github.com/containerd/platforms v0.2.1/go.mod h1:XHCb+2/hzowdiut9rkudds9bE5yJ7npe7dG/wG+uFPw= +github.com/cpuguy83/dockercfg v0.3.2 h1:DlJTyZGBDlXqUZ2Dk2Q3xHs/FtnooJJVaad2S9GKorA= +github.com/cpuguy83/dockercfg v0.3.2/go.mod h1:sugsbF4//dDlL/i+S+rtpIWp+5h0BHJHfjj5/jFyUJc= +github.com/creack/pty v1.1.18 h1:n56/Zwd5o6whRC5PMGretI4IdRLlmBXYNjScPaBgsbY= +github.com/creack/pty v1.1.18/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk= +github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E= +github.com/docker/docker v27.1.1+incompatible h1:hO/M4MtV36kzKldqnA37IWhebRA+LnqqcqDja6kVaKY= +github.com/docker/docker v27.1.1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= +github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c= +github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc= +github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4= +github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/glebarez/go-sqlite v1.21.2 h1:3a6LFC4sKahUunAmynQKLZceZCOzUthkRkEAl9gAXWo= +github.com/glebarez/go-sqlite v1.21.2/go.mod h1:sfxdZyhQjTM2Wry3gVYWaW072Ri1WMdWJi0k6+3382k= +github.com/glebarez/sqlite v1.11.0 h1:wSG0irqzP6VurnMEpFGer5Li19RpIRi2qvQz++w0GMw= +github.com/glebarez/sqlite v1.11.0/go.mod h1:h8/o8j5wiAsqSPoWELDUdJXhjAhsVliSn7bWZjOhrgQ= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ= +github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY= +github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.16.0 h1:YBftPWNWd4WwGqtY2yeZL2ef8rHAxPBD8KFhJpmcqms= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.16.0/go.mod h1:YN5jB8ie0yfIUg6VvR9Kz84aCaG7AsGZnLjhHbUqwPg= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.7.1 h1:x7SYsPBYDkHDksogeSmZZ5xzThcTgRz++I5E+ePFUcs= +github.com/jackc/pgx/v5 v5.7.1/go.mod h1:e7O26IywZZ+naJtWWos6i6fvWK+29etgITqrqHLfoZA= +github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= +github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= +github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= +github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= +github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/klauspost/compress v1.17.4 h1:Ej5ixsIri7BrIjBkRZLTo6ghwrEtHFk7ijlczPW4fZ4= +github.com/klauspost/compress v1.17.4/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= +github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0= +github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw= +github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= +github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 h1:6E+4a0GO5zZEnZ81pIr0yLvtUWk2if982qA3F3QD6H4= +github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0/go.mod h1:zJYVVT2jmtg6P3p1VtQj7WsuWi/y4VnjVBn7F8KPB3I= +github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY= +github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= +github.com/mattn/go-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng= +github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0= +github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo= +github.com/moby/patternmatcher v0.6.0 h1:GmP9lR19aU5GqSSFko+5pRqHi+Ohk1O69aFiKkVGiPk= +github.com/moby/patternmatcher v0.6.0/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc= +github.com/moby/sys/sequential v0.5.0 h1:OPvI35Lzn9K04PBbCLW0g4LcFAJgHsvXsRyewg5lXtc= +github.com/moby/sys/sequential v0.5.0/go.mod h1:tH2cOOs5V9MlPiXcQzRC+eEyab644PWKGRYaaV5ZZlo= +github.com/moby/sys/user v0.1.0 h1:WmZ93f5Ux6het5iituh9x2zAG7NFY9Aqi49jjE1PaQg= +github.com/moby/sys/user v0.1.0/go.mod h1:fKJhFOnsCN6xZ5gSfbM6zaHGgDJMrqt9/reuj4T7MmU= +github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0= +github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y= +github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A= +github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc= +github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= +github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= +github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug= +github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c h1:ncq/mPwQF4JjgDlrVEn3C11VoGHZN7m8qihwgMEtzYw= +github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= +github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= +github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= +github.com/rogpeppe/go-internal v1.8.1 h1:geMPLpDpQOgVyCg5z5GoRwLHepNdb71NXb67XFkP+Eg= +github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o= +github.com/shirou/gopsutil/v3 v3.23.12 h1:z90NtUkp3bMtmICZKpC4+WaknU1eXtp5vtbQ11DgpE4= +github.com/shirou/gopsutil/v3 v3.23.12/go.mod h1:1FrWgea594Jp7qmjHUUPlJDTPgcsb9mGnXDxavtikzM= +github.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFtM= +github.com/shoenig/go-m1cpu v0.1.6/go.mod h1:1JJMcUBvfNwpq05QDQVAnx3gUHr9IYF7GNg9SUEw2VQ= +github.com/shoenig/test v0.6.4 h1:kVTaSd7WLz5WZ2IaoM0RSzRsUD+m8wRR+5qvntpn4LU= +github.com/shoenig/test v0.6.4/go.mod h1:byHiCGXqrVaflBLAMq/srcZIHynQPQgeyvkvXnjqq0k= +github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= +github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/testcontainers/testcontainers-go v0.34.0 h1:5fbgF0vIN5u+nD3IWabQwRybuB4GY8G2HHgCkbMzMHo= +github.com/testcontainers/testcontainers-go v0.34.0/go.mod h1:6P/kMkQe8yqPHfPWNulFGdFHTD8HB2vLq/231xY2iPQ= +github.com/testcontainers/testcontainers-go/modules/postgres v0.34.0 h1:c51aBXT3v2HEBVarmaBnsKzvgZjC5amn0qsj8Naqi50= +github.com/testcontainers/testcontainers-go/modules/postgres v0.34.0/go.mod h1:EWP75ogLQU4M4L8U+20mFipjV4WIR9WtlMXSB6/wiuc= +github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= +github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= +github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= +github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yusufpapurcu/wmi v1.2.3 h1:E1ctvB7uKFMOJw3fdOW32DwGE9I7t++CRUEMKvFoFiw= +github.com/yusufpapurcu/wmi v1.2.3/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 h1:jq9TW8u3so/bN+JPT166wjOI6/vQPF6Xe7nMNIltagk= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0/go.mod h1:p8pYQP+m5XfbZm9fxtSKAbM6oIllS7s2AfxrChvc7iw= +go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo= +go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.19.0 h1:Mne5On7VWdx7omSrSSZvM4Kw7cS7NQkOOmLcgscI51U= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.19.0/go.mod h1:IPtUMKL4O3tH5y+iXVyAXqpAwMuzC1IrxVS81rummfE= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.19.0 h1:IeMeyr1aBvBiPVYihXIaeIZba6b8E1bYp7lbdxK8CQg= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.19.0/go.mod h1:oVdCUtjq9MK9BlS7TtucsQwUcXcymNiEDjgDD2jMtZU= +go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI= +go.opentelemetry.io/otel/metric v1.24.0/go.mod h1:VYhLe1rFfxuTXLgj4CBiyz+9WYBA8pNGJgDcSFRKBco= +go.opentelemetry.io/otel/sdk v1.19.0 h1:6USY6zH+L8uMH8L3t1enZPR3WFEmSTADlqldyHtJi3o= +go.opentelemetry.io/otel/sdk v1.19.0/go.mod h1:NedEbbS4w3C6zElbLdPJKOpJQOrGUJ+GfzpjUvI0v1A= +go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI= +go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU= +go.opentelemetry.io/proto/otlp v1.0.0 h1:T0TX0tmXU8a3CbNXzEKGeU5mIVOdf0oykP+u2lIVU/I= +go.opentelemetry.io/proto/otlp v1.0.0/go.mod h1:Sy6pihPLfYHkr3NkUbEhGHFhINUSI/v80hjKIs5JXpM= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ= +golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ= +golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ= +golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s= +golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.26.0 h1:WEQa6V3Gja/BhNxg540hBip/kkaYtRg3cxg4oXSw4AU= +golang.org/x/term v0.26.0/go.mod h1:Si5m1o57C5nBNQo5z1iq+XDijt21BDBDp2bK0QI8e3E= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug= +golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4= +golang.org/x/time v0.0.0-20220210224613-90d013bbcef8 h1:vVKdlvoWBphwdxWKrFZEuM0kGgGLxUOYcY4U/2Vjg44= +golang.org/x/time v0.0.0-20220210224613-90d013bbcef8/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/genproto v0.0.0-20230920204549-e6e6cdab5c13 h1:vlzZttNJGVqTsRFU9AmdnrcO1Znh8Ew9kCD//yjigk0= +google.golang.org/genproto/googleapis/api v0.0.0-20240318140521-94a12d6c2237 h1:RFiFrvy37/mpSpdySBDrUdipW/dHwsRwh3J3+A9VgT4= +google.golang.org/genproto/googleapis/api v0.0.0-20240318140521-94a12d6c2237/go.mod h1:Z5Iiy3jtmioajWHDGFk7CeugTyHtPvMHA4UTmUkyalE= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237 h1:NnYq6UN9ReLM9/Y01KWNOWyI5xQ9kbIms5GGJVwS/Yc= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237/go.mod h1:WtryC6hu0hhx87FDGxWCDptyssuo68sk10vYjF+T9fY= +google.golang.org/grpc v1.64.1 h1:LKtvyfbX3UGVPFcGqJ9ItpVWW6oN/2XqTxfAnwRRXiA= +google.golang.org/grpc v1.64.1/go.mod h1:hiQF4LFZelK2WKaP6W0L92zGHtiQdZxk8CrSdvyjeP0= +google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI= +google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gorm.io/driver/postgres v1.5.10 h1:7Lggqempgy496c0WfHXsYWxk3Th+ZcW66/21QhVFdeE= +gorm.io/driver/postgres v1.5.10/go.mod h1:DX3GReXH+3FPWGrrgffdvCk3DQ1dwDPdmbenSkweRGI= +gorm.io/gorm v1.25.12 h1:I0u8i2hWQItBq1WfE0o2+WuL9+8L21K9e2HHSTE/0f8= +gorm.io/gorm v1.25.12/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ= +gotest.tools/v3 v3.5.1 h1:EENdUnS3pdur5nybKYIh2Vfgc8IUNBjxDPSjtiJcOzU= +gotest.tools/v3 v3.5.1/go.mod h1:isy3WKz7GK6uNw/sbHzfKBLvlvXwUyV06n6brMxxopU= +modernc.org/libc v1.22.5 h1:91BNch/e5B0uPbJFgqbxXuOnxBQjlS//icfQEGmvyjE= +modernc.org/libc v1.22.5/go.mod h1:jj+Z7dTNX8fBScMVNRAYZ/jF91K8fdT2hYMThc3YjBY= +modernc.org/mathutil v1.5.0 h1:rV0Ko/6SfM+8G+yKiyI830l3Wuz1zRutdslNoQ0kfiQ= +modernc.org/mathutil v1.5.0/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E= +modernc.org/memory v1.5.0 h1:N+/8c5rE6EqugZwHii4IFsaJ7MUhoWX07J5tC/iI5Ds= +modernc.org/memory v1.5.0/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU= +modernc.org/sqlite v1.23.1 h1:nrSBg4aRQQwq59JpvGEQ15tNxoO5pX/kUjcRNwSAGQM= +modernc.org/sqlite v1.23.1/go.mod h1:OrDj17Mggn6MhE+iPbBNf7RGKODDE9NFT0f3EwDzJqk= diff --git a/module/gorm/example/main.go b/module/gorm/example/main.go new file mode 100644 index 0000000..9df4e69 --- /dev/null +++ b/module/gorm/example/main.go @@ -0,0 +1,101 @@ +package main + +import ( + "context" + "encoding/json" + "fmt" + "log" + "net/http" + "time" + + "github.com/brianvoe/gofakeit/v7" + goatquery "github.com/goatquery/goatquery-go" + gqGorm "github.com/goatquery/goatquery-go/module/gorm" + "github.com/google/uuid" + "github.com/testcontainers/testcontainers-go" + "github.com/testcontainers/testcontainers-go/modules/postgres" + "github.com/testcontainers/testcontainers-go/wait" + pg "gorm.io/driver/postgres" + "gorm.io/gorm" + "gorm.io/gorm/logger" +) + +type User struct { + Id uuid.UUID + Firstname string +} + +func main() { + gofakeit.Seed(8675309) + ctx := context.Background() + + postgresContainer, err := postgres.Run(ctx, + "postgres:15", + testcontainers.WithWaitStrategy( + wait.ForLog("database system is ready to accept connections"). + WithOccurrence(2). + WithStartupTimeout(5*time.Second)), + ) + defer func() { + if err := testcontainers.TerminateContainer(postgresContainer); err != nil { + log.Printf("failed to terminate container: %s", err) + } + }() + if err != nil { + log.Fatalf("failed to start container: %s", err) + } + + dsn := postgresContainer.MustConnectionString(ctx) + + db, err := gorm.Open(pg.Open(dsn), &gorm.Config{ + Logger: logger.Default.LogMode(logger.Info), + }) + if err != nil { + log.Fatalf("failed to start container: %s", err) + } + + if err := db.AutoMigrate(&User{}); err != nil { + log.Fatalf("failed to migrate database: %s", err) + } + + var users []User + for range 1_000 { + user := User{ + Id: uuid.New(), + Firstname: gofakeit.FirstName(), + } + + users = append(users, user) + } + + if err := db.Model(&User{}).Create(users).Error; err != nil { + log.Fatalf("failed to create seeded users: %s", err) + } + + http.HandleFunc("/hello", func(w http.ResponseWriter, req *http.Request) { + query := goatquery.Query{ + Filter: req.FormValue("filter"), + } + + var users []User + + res, _, err := gqGorm.Apply[User](db, query, nil, nil) + if err != nil { + w.Header().Set("Content-Type", "application/json") + fmt.Fprintf(w, err.Error()) + return + } + + if err := res.Find(&users).Error; err != nil { + fmt.Fprintf(w, err.Error()) + return + } + + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(users) + }) + + log.Println("Hosting http server on port :8080") + + http.ListenAndServe(":8080", nil) +}