tags

type AndFilterGroup ¶

type AndFilterGroup []Filterable

AndFilterGroup applies a group of filters using ands

func (afg AndFilterGroup) Apply(table *qp.Table, metadata *TableMetadata) squirrel.Sqlizer

type Association ¶

type Association struct {
	Name         string
	Associations []Association
	OrderBy      []qp.OrderByRequest
	SelectFields []string
	FieldFilters Filterable
}

Association represents a data model relationship in the form of hasOne, hasMany, belongsTo between parent and child structs.

Including Associations in FilterRequests will eager load the model relationship results in a single query with JOINs.

Name refers to the name of the struct field that will hold the filter results for the relationship. For belongsTo relationships, this is the `related` tag value on a `foreign_key“ field on the struct

Example:

type ChildModel struct {
	Metadata	metadata.Metadata	`picard:"tablename=child"`
	ID			string				`picard:"primary_key,column=id"`
	ParentID 	string				`picard:"foreign_key,required,related=Parent,column=parent_id
	Parent		ParentModel
}

p.FilterModel(picard.FilterRequest{
	FilterModel: ChildModel{},
	Associations: []tags.Association{
		{
			Name: "Parent",
		},
	},
})

For hasOne or hasMany relationships, this is the field with the `child` tag ¶

Example:

type ParentModel struct {
	Metadata	metadata.Metadata	`picard:"tablename=parent"`
	ID			string				`picard:"primary_key,column=id"`
	Children	[]ChildModel		`picard:"child,foreign_key=ParentID"`
}

p.FilterModel(picard.FilterRequest{
	FilterModel: ParentModel{},
	Associations: []tags.Association{
		{
			Name: "Children",
		},
	},
})

Each association may have nested relationships, like so:

type ParentModel struct {
	Metadata	metadata.Metadata	`picard:"tablename=parent"`
	ID			string				`picard:"primary_key,column=id"`
	Children	[]ChildModel		`picard:"child,foreign_key=ParentID"`
}

type ChildModel struct {
	Metadata	metadata.Metadata	`picard:"tablename=child"`
	ID			string				`picard:"primary_key,column=id"`
	Children	[]GrandChildModel	`picard:"child,foreign_key=ParentID"`
	ParentID 	string				`picard:"foreign_key,required,related=Parent,column=parent_id"``
	Parent		ParentModel
}

type GrandChild struct {
	Metadata	metadata.Metadata	`picard:"tablename=grandchild"`
	ID			string				`picard:"primary_key,column=id"`
	ParentID 	string				`picard:"foreign_key,required,related=Parent,column=parent_id
	Parent		ChildModel
}

p.FilterModel(picard.FilterRequest{
	FilterModel: ParentModel{},
	Associations: []tags.Association{
	{
		Name: "Children",
		Associations: []tags.Association{
			{
				Name: "Children",
			},
		},
	},
})

OrderBy lets you define the ordering of filter results by adding an ORDER BY clause with an OrderByRequest ¶

Example:

type ParentModel struct {
	Metadata	metadata.Metadata	`picard:"tablename=parent"`
	ID			string				`picard:"primary_key,column=id"`
	Children	[]ChildModel		`picard:"child,foreign_key=ParentID"`
}

type ChildModel struct {
	Metadata	metadata.Metadata	`picard:"tablename=child"`
	ID			string				`picard:"primary_key,column=id"`
	Name		string				`picard:"column=name"`
}
p.FilterModel(picard.FilterRequest{
	FilterModel: ParentModel{},
	Associations: []tags.Association{
			{
				Name: "Children",
				OrderBy: []qp.OrderByRequest{
				{
					Field:      "Name",
					Descending: true,
				},
			},
		},
})

// SELECT ... FROM parent AS t0 LEFT JOIN child AS t1 ON ...ORDER BY t1.name DESC

SelectFields lets you define the exact columns to query for. Without `SelectFields`, all the columns defined in the table will be included in the query.

From the example above for OrderBy:

p.FilterModel(picard.FilterRequest{
	FilterModel: ParentModel{},
	Associations: []tags.Association{
			{
				Name: "Children",
				SelectFields: []string{
					"Name",
				}
			},
		},
	}
})

// SELECT ... t1.name FROM parent AS t0 LEFT JOIN child AS t1 ON ...

FieldFilters generates a `WHERE` clause grouping with either an `OR` grouping via `tags.OrFilterGroup` or an `AND` grouping via `tags.AndFilterGroup`. The `tags.FieldFilter`

type ParentModel struct {
	Metadata	metadata.Metadata	`picard:"tablename=parent"`
	ID			string				`picard:"primary_key,column=id"`
	Children	[]ChildModel		`picard:"child,foreign_key=ParentID"`
}

type ChildModel struct {
	Metadata	metadata.Metadata	`picard:"tablename=child"`
	ID			string				`picard:"primary_key,column=id"`
	FieldA		string				`picard:"column=field_a"`
	FieldB		string				`picard:"column=field_b"`
}

import "github.com/skuid/picard/tags"

p.FilterModel(picard.FilterRequest{
		FilterModel: ParentModel{},
		Associations: []tags.Association{
			{
				Name: "Children",
				FieldFilters: tags.OrFilterGroup{
					tags.FieldFilter{
						FieldName:   "FieldA",
						FilterValue: "foo",
					},
					tags.FieldFilter{
						FieldName:   "FieldB",
						FilterValue: "bar",
					},
				},
			}
		},
	}
})

// SELECT ... WHERE (t1.field_a = 'foo' OR t1.field_b = 'bar')

p.FilterModel(picard.FilterRequest{
		FilterModel: ParentModel{},
		Associations: []tags.Association{
			{
				Name: "Children",
				FieldFilters: tags.AndFilterGroup{
					tags.FieldFilter{
						FieldName:   "FieldA",
						FilterValue: "foo",
					},
					tags.FieldFilter{
						FieldName:   "FieldB",
						FilterValue: "bar",
					},
				},
			}
		},
	}
})

// SELECT ... WHERE (t1.field_a = 'foo' AND t1.field_b = 'bar')

type Child ¶

type Child struct {
	FieldName        string
	FieldType        reflect.Type
	FieldKind        reflect.Kind
	ForeignKey       string
	KeyMapping       string
	ValueMappings    map[string]string
	GroupingCriteria map[string]string
	DeleteOrphans    bool
}

Child structure

type FieldFilter ¶

type FieldFilter struct {
	FieldName      string
	FilterValue    interface{}
	FilterOperator string
}

FieldFilter defines an arbitrary filter on a FilterRequest

Specify the fields that should be added in a AndFilterGroup or a OrFilterGroup WHERE clause grouping.

Example:

import "github.com/skuid/picard/tags"

tags.FieldFilter{
	FieldName:   "FieldB",
	FilterValue: "bar",
},

SQL translation in WHERE clause grouping:

t0.field_B = "bar"

func (ff FieldFilter) Apply(table *qp.Table, metadata *TableMetadata) squirrel.Sqlizer

type FieldMetadata ¶

type FieldMetadata struct {
	// contains filtered or unexported fields
}

FieldMetadata structure

func (fm FieldMetadata) GetAudit() string

func (fm FieldMetadata) GetColumnName() string

func (fm FieldMetadata) GetFieldType() reflect.Type

func (fm FieldMetadata) GetName() string

func (fm FieldMetadata) GetRelatedName() string

func (fm FieldMetadata) GetRelatedType() reflect.Type

func (fm FieldMetadata) IncludeInUpdate() bool

func (fm FieldMetadata) IsEncrypted() bool

func (fm FieldMetadata) IsFK() bool

func (fm FieldMetadata) IsJSONB() bool

func (fm FieldMetadata) IsMultitenancyKey() bool

func (fm FieldMetadata) IsPrimaryKey() bool

type Filterable ¶

type Filterable interface {
	Apply(*qp.Table, *TableMetadata) squirrel.Sqlizer
}

Filterable interface allows filters to be specified in Filter Requests

type ForeignKey ¶

type ForeignKey struct {
	TableMetadata    *TableMetadata
	FieldName        string
	KeyColumn        string
	RelatedFieldName string
	Required         bool
	NeedsLookup      bool
	LookupResults    map[string]interface{}
	LookupsUsed      []Lookup
	KeyMapField      string
}

ForeignKey structure

type Lookup ¶

type Lookup struct {
	TableName           string
	MatchDBColumn       string
	MatchObjectProperty string
	JoinKey             string
	Value               interface{}
	SubQuery            []Lookup
	SubQueryForeignKey  string
	SubQueryMetadata    *TableMetadata
}

Lookup structure

type OrFilterGroup ¶

type OrFilterGroup []Filterable

OrFilterGroup applies a group of filters using ors

func (ofg OrFilterGroup) Apply(table *qp.Table, metadata *TableMetadata) squirrel.Sqlizer

type TableMetadata ¶

type TableMetadata struct {
	// contains filtered or unexported fields
}

TableMetadata structure

func GetTableMetadata(data interface{}) (*TableMetadata, error)

func TableMetadataFromType(t reflect.Type) *TableMetadata

func (tm TableMetadata) GetChildField(childName string) *Child

func (tm TableMetadata) GetChildFieldFromForeignKey(foreignKeyName string, foreignKeyType reflect.Type) *Child

func (tm TableMetadata) GetChildren() []Child

func (tm TableMetadata) GetColumnNames() []string

func (tm TableMetadata) GetColumnNamesForUpdate() []string

func (tm TableMetadata) GetColumnNamesWithoutPrimaryKey() []string

func (tm TableMetadata) GetEncryptedColumns() []string

func (tm TableMetadata) GetField(fieldName string) FieldMetadata

func (tm TableMetadata) GetFields() []FieldMetadata

func (tm TableMetadata) GetForeignKeyField(foreignKeyName string) *ForeignKey

func (tm TableMetadata) GetForeignKeyFieldFromRelation(relationName string) *ForeignKey

func (tm TableMetadata) GetForeignKeys() []ForeignKey

func (tm TableMetadata) GetJSONBColumns() []string

func (tm TableMetadata) GetLookups() []Lookup

func (tm TableMetadata) GetMultitenancyKeyColumnName() string

func (tm TableMetadata) GetMultitenancyKeyMetadata() *FieldMetadata

func (tm TableMetadata) GetPrimaryKeyColumnName() string

func (tm TableMetadata) GetPrimaryKeyFieldName() string

func (tm TableMetadata) GetPrimaryKeyMetadata() *FieldMetadata

func (tm TableMetadata) GetTableName() string