Skip to content

Commit

Permalink
Revert "Improvement/field private (#37)" (#39)
Browse files Browse the repository at this point in the history 
This reverts commit 8a81353.
  • Loading branch information
@FrancoLiberali
FrancoLiberali authored Jan 2, 2024
1 parent 946129c commit 710dcfe
Show file tree
Hide file tree
Showing 56 changed files with 516 additions and 545 deletions.
6 changes: 3 additions & 3 deletions condition/errors.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,14 +32,14 @@ func methodError(err error, method string) error {
func fieldModelNotConcernedError(field IField) error {
return fmt.Errorf("%w; not concerned model: %s",
ErrFieldModelNotConcerned,
field.getModelType(),
field.GetModelType(),
)
}

func joinMustBeSelectedError(field IField) error {
return fmt.Errorf("%w; joined multiple times model: %s",
ErrJoinMustBeSelected,
field.getModelType(),
field.GetModelType(),
)
}

Expand All @@ -56,7 +56,7 @@ func conditionOperatorError[TObject model.Model, TAtribute any](operatorErr erro
"%w; model: %T, field: %s",
operatorErr,
*new(TObject),
condition.FieldIdentifier.name,
condition.FieldIdentifier.Name,
)
}

Expand Down
95 changes: 25 additions & 70 deletions condition/field.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,91 +7,70 @@ import (
)

type IField interface {
columnName(query *GormQuery, table Table) string
fieldName() string
columnSQL(query *GormQuery, table Table) string
getModelType() reflect.Type
ColumnName(query *GormQuery, table Table) string
FieldName() string
ColumnSQL(query *GormQuery, table Table) string
GetModelType() reflect.Type
}

type FieldOfType[T any] interface {
IField
getType() T
GetType() T
}

type Field[TModel model.Model, TAttribute any] struct {
column string
name string
columnPrefix string
Column string
Name string
ColumnPrefix string
}

//nolint:unused // necessary for FieldOfType[T any]
func (field Field[TModel, TAttribute]) getType() TAttribute {
func (field Field[TModel, TAttribute]) GetType() TAttribute {
return *new(TAttribute)
}

func (field Field[TModel, TAttribute]) Is() FieldIs[TModel, TAttribute] {
return FieldIs[TModel, TAttribute]{field: field}
return FieldIs[TModel, TAttribute]{Field: field}
}

func (field Field[TModel, TAttribute]) getModelType() reflect.Type {
func (field Field[TModel, TAttribute]) GetModelType() reflect.Type {
return reflect.TypeOf(*new(TModel))
}

// Returns the name of the field identified
func (field Field[TModel, TAttribute]) fieldName() string {
return field.name
func (field Field[TModel, TAttribute]) FieldName() string {
return field.Name
}

// Returns the name of the column in which the field is saved in the table
func (field Field[TModel, TAttribute]) columnName(query *GormQuery, table Table) string {
columnName := field.column
func (field Field[TModel, TAttribute]) ColumnName(query *GormQuery, table Table) string {
columnName := field.Column
if columnName == "" {
columnName = query.ColumnName(table, field.name)
columnName = query.ColumnName(table, field.Name)
}

// add column prefix and table name once we know the column name
return field.columnPrefix + columnName
return field.ColumnPrefix + columnName
}

// Returns the SQL to get the value of the field in the table
func (field Field[TModel, TAttribute]) columnSQL(query *GormQuery, table Table) string {
return table.Alias + "." + field.columnName(query, table)
}

func NewField[TModel model.Model, TAttribute any](name, column, columnPrefix string) Field[TModel, TAttribute] {
return Field[TModel, TAttribute]{
name: name,
column: column,
columnPrefix: columnPrefix,
}
func (field Field[TModel, TAttribute]) ColumnSQL(query *GormQuery, table Table) string {
return table.Alias + "." + field.ColumnName(query, table)
}

type UpdatableField[TModel model.Model, TAttribute any] struct {
Field[TModel, TAttribute]
}

func (field UpdatableField[TModel, TAttribute]) Set() FieldSet[TModel, TAttribute] {
return FieldSet[TModel, TAttribute]{field: field}
}

func NewUpdatableField[TModel model.Model, TAttribute any](name, column, columnPrefix string) UpdatableField[TModel, TAttribute] {
return UpdatableField[TModel, TAttribute]{
Field: NewField[TModel, TAttribute](name, column, columnPrefix),
}
return FieldSet[TModel, TAttribute]{Field: field}
}

type NullableField[TModel model.Model, TAttribute any] struct {
UpdatableField[TModel, TAttribute]
}

func (field NullableField[TModel, TAttribute]) Set() NullableFieldSet[TModel, TAttribute] {
return NullableFieldSet[TModel, TAttribute]{FieldSet[TModel, TAttribute]{field: field.UpdatableField}}
}

func NewNullableField[TModel model.Model, TAttribute any](name, column, columnPrefix string) NullableField[TModel, TAttribute] {
return NullableField[TModel, TAttribute]{
UpdatableField: NewUpdatableField[TModel, TAttribute](name, column, columnPrefix),
}
return NullableFieldSet[TModel, TAttribute]{FieldSet[TModel, TAttribute]{Field: field.UpdatableField}}
}

type BoolField[TModel model.Model] struct {
Expand All @@ -100,13 +79,7 @@ type BoolField[TModel model.Model] struct {

func (boolField BoolField[TModel]) Is() BoolFieldIs[TModel] {
return BoolFieldIs[TModel]{
field: boolField.Field,
}
}

func NewBoolField[TModel model.Model](name, column, columnPrefix string) BoolField[TModel] {
return BoolField[TModel]{
UpdatableField: NewUpdatableField[TModel, bool](name, column, columnPrefix),
Field: boolField.Field,
}
}

Expand All @@ -116,13 +89,7 @@ type NullableBoolField[TModel model.Model] struct {

func (boolField NullableBoolField[TModel]) Is() BoolFieldIs[TModel] {
return BoolFieldIs[TModel]{
field: boolField.Field,
}
}

func NewNullableBoolField[TModel model.Model](name, column, columnPrefix string) NullableBoolField[TModel] {
return NullableBoolField[TModel]{
NullableField: NewNullableField[TModel, bool](name, column, columnPrefix),
Field: boolField.Field,
}
}

Expand All @@ -133,31 +100,19 @@ type StringField[TModel model.Model] struct {
func (stringField StringField[TModel]) Is() StringFieldIs[TModel] {
return StringFieldIs[TModel]{
FieldIs: FieldIs[TModel, string]{
field: stringField.Field,
Field: stringField.Field,
},
}
}

func NewStringField[TModel model.Model](name, column, columnPrefix string) StringField[TModel] {
return StringField[TModel]{
UpdatableField: NewUpdatableField[TModel, string](name, column, columnPrefix),
}
}

type NullableStringField[TModel model.Model] struct {
NullableField[TModel, string]
}

func (stringField NullableStringField[TModel]) Is() StringFieldIs[TModel] {
return StringFieldIs[TModel]{
FieldIs: FieldIs[TModel, string]{
field: stringField.Field,
Field: stringField.Field,
},
}
}

func NewNullableStringField[TModel model.Model](name, column, columnPrefix string) NullableStringField[TModel] {
return NullableStringField[TModel]{
NullableField: NewNullableField[TModel, string](name, column, columnPrefix),
}
}
4 changes: 2 additions & 2 deletions condition/field_condition.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -29,14 +29,14 @@ func (condition fieldCondition[TObject, TAtribute]) applyTo(query *GormQuery, ta

//nolint:unused // is used
func (condition fieldCondition[TObject, TAtribute]) affectsDeletedAt() bool {
return condition.FieldIdentifier.fieldName() == deletedAtField
return condition.FieldIdentifier.FieldName() == deletedAtField
}

//nolint:unused // is used
func (condition fieldCondition[TObject, TAtribute]) getSQL(query *GormQuery, table Table) (string, []any, error) {
sqlString, values, err := condition.Operator.ToSQL(
query,
condition.FieldIdentifier.columnSQL(query, table),
condition.FieldIdentifier.ColumnSQL(query, table),
)
if err != nil {
return "", nil, conditionOperatorError[TObject](err, condition)
Expand Down
56 changes: 30 additions & 26 deletions condition/field_is.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,11 +5,11 @@ import (
)

type FieldIs[TObject model.Model, TAttribute any] struct {
field Field[TObject, TAttribute]
Field Field[TObject, TAttribute]
}

type BoolFieldIs[TObject model.Model] struct {
field Field[TObject, bool]
Field[TObject, bool]
}

type StringFieldIs[TObject model.Model] struct {
Expand All @@ -19,91 +19,91 @@ type StringFieldIs[TObject model.Model] struct {
// EqualTo
// NotDistinct must be used in cases where value can be NULL
func (is FieldIs[TObject, TAttribute]) Eq(value TAttribute) WhereCondition[TObject] {
return NewFieldCondition(is.field, Eq[TAttribute](value))
return NewFieldCondition(is.Field, Eq[TAttribute](value))
}

// NotEqualTo
// Distinct must be used in cases where value can be NULL
func (is FieldIs[TObject, TAttribute]) NotEq(value TAttribute) WhereCondition[TObject] {
return NewFieldCondition(is.field, NotEq[TAttribute](value))
return NewFieldCondition(is.Field, NotEq[TAttribute](value))
}

// LessThan
func (is FieldIs[TObject, TAttribute]) Lt(value TAttribute) WhereCondition[TObject] {
return NewFieldCondition(is.field, Lt[TAttribute](value))
return NewFieldCondition(is.Field, Lt[TAttribute](value))
}

// LessThanOrEqualTo
func (is FieldIs[TObject, TAttribute]) LtOrEq(value TAttribute) WhereCondition[TObject] {
return NewFieldCondition(is.field, LtOrEq[TAttribute](value))
return NewFieldCondition(is.Field, LtOrEq[TAttribute](value))
}

// GreaterThan
func (is FieldIs[TObject, TAttribute]) Gt(value TAttribute) WhereCondition[TObject] {
return NewFieldCondition(is.field, Gt[TAttribute](value))
return NewFieldCondition(is.Field, Gt[TAttribute](value))
}

// GreaterThanOrEqualTo
func (is FieldIs[TObject, TAttribute]) GtOrEq(value TAttribute) WhereCondition[TObject] {
return NewFieldCondition(is.field, GtOrEq[TAttribute](value))
return NewFieldCondition(is.Field, GtOrEq[TAttribute](value))
}

// Equivalent to v1 < value < v2
func (is FieldIs[TObject, TAttribute]) Between(v1, v2 TAttribute) WhereCondition[TObject] {
return NewFieldCondition(is.field, Between[TAttribute](v1, v2))
return NewFieldCondition(is.Field, Between[TAttribute](v1, v2))
}

// Equivalent to NOT (v1 < value < v2)
func (is FieldIs[TObject, TAttribute]) NotBetween(v1, v2 TAttribute) WhereCondition[TObject] {
return NewFieldCondition(is.field, NotBetween[TAttribute](v1, v2))
return NewFieldCondition(is.Field, NotBetween[TAttribute](v1, v2))
}

func (is FieldIs[TObject, TAttribute]) Null() WhereCondition[TObject] {
return NewFieldCondition(is.field, IsNull[TAttribute]())
return NewFieldCondition(is.Field, IsNull[TAttribute]())
}

func (is FieldIs[TObject, TAttribute]) NotNull() WhereCondition[TObject] {
return NewFieldCondition(is.field, IsNotNull[TAttribute]())
return NewFieldCondition(is.Field, IsNotNull[TAttribute]())
}

func (is BoolFieldIs[TObject]) True() WhereCondition[TObject] {
return NewFieldCondition[TObject, bool](is.field, Eq[bool](true))
return NewFieldCondition[TObject, bool](is.Field, Eq[bool](true))
}

func (is BoolFieldIs[TObject]) NotTrue() WhereCondition[TObject] {
return NewFieldCondition[TObject, bool](is.field, IsDistinct[bool](true))
return NewFieldCondition[TObject, bool](is.Field, IsDistinct[bool](true))
}

func (is BoolFieldIs[TObject]) False() WhereCondition[TObject] {
return NewFieldCondition[TObject, bool](is.field, Eq[bool](false))
return NewFieldCondition[TObject, bool](is.Field, Eq[bool](false))
}

func (is BoolFieldIs[TObject]) NotFalse() WhereCondition[TObject] {
return NewFieldCondition[TObject, bool](is.field, IsDistinct[bool](false))
return NewFieldCondition[TObject, bool](is.Field, IsDistinct[bool](false))
}

func (is BoolFieldIs[TObject]) Unknown() WhereCondition[TObject] {
return NewFieldCondition[TObject, bool](is.field, IsNull[bool]())
return NewFieldCondition[TObject, bool](is.Field, IsNull[bool]())
}

func (is BoolFieldIs[TObject]) NotUnknown() WhereCondition[TObject] {
return NewFieldCondition[TObject, bool](is.field, IsNotNull[bool]())
return NewFieldCondition[TObject, bool](is.Field, IsNotNull[bool]())
}

func (is FieldIs[TObject, TAttribute]) Distinct(value TAttribute) WhereCondition[TObject] {
return NewFieldCondition(is.field, IsDistinct[TAttribute](value))
return NewFieldCondition(is.Field, IsDistinct[TAttribute](value))
}

func (is FieldIs[TObject, TAttribute]) NotDistinct(value TAttribute) WhereCondition[TObject] {
return NewFieldCondition(is.field, IsNotDistinct[TAttribute](value))
return NewFieldCondition(is.Field, IsNotDistinct[TAttribute](value))
}

func (is FieldIs[TObject, TAttribute]) In(values ...TAttribute) WhereCondition[TObject] {
return NewFieldCondition(is.field, In(values))
return NewFieldCondition(is.Field, In(values))
}

func (is FieldIs[TObject, TAttribute]) NotIn(values ...TAttribute) WhereCondition[TObject] {
return NewFieldCondition(is.field, NotIn(values))
return NewFieldCondition(is.Field, NotIn(values))
}

// Pattern in all databases:
Expand All @@ -125,20 +125,24 @@ func (is FieldIs[TObject, TAttribute]) NotIn(values ...TAttribute) WhereConditio
// - sqlserver: https://learn.microsoft.com/en-us/sql/t-sql/language-elements/like-transact-sql?view=sql-server-ver16
// - sqlite: https://www.sqlite.org/lang_expr.html#like
func (is StringFieldIs[TObject]) Like(pattern string) WhereCondition[TObject] {
return NewFieldCondition[TObject, string](is.field, Like(pattern))
return NewFieldCondition[TObject, string](is.Field, Like(pattern))
}

// Custom can be used to use other Operators, like database specific operators
func (is FieldIs[TObject, TAttribute]) Custom(op Operator[TAttribute]) WhereCondition[TObject] {
return NewFieldCondition(is.field, op)
return NewFieldCondition(is.Field, op)
}

// Dynamic transforms the FieldIs in a DynamicFieldIs to use dynamic operators
func (is FieldIs[TObject, TAttribute]) Dynamic() DynamicFieldIs[TObject, TAttribute] {
return DynamicFieldIs[TObject, TAttribute](is)
return DynamicFieldIs[TObject, TAttribute]{
field: is.Field,
}
}

// Unsafe transforms the FieldIs in an UnsafeFieldIs to use unsafe operators
func (is FieldIs[TObject, TAttribute]) Unsafe() UnsafeFieldIs[TObject, TAttribute] {
return UnsafeFieldIs[TObject, TAttribute](is)
return UnsafeFieldIs[TObject, TAttribute]{
field: is.Field,
}
}
Loading

0 comments on commit 710dcfe

Please sign in to comment.