types

Documentation

Index

• Constants
• Variables
• type AggQuery
  • func NewAggregationQuery(aggregation string, sqon *SQON, fields []Field) (AggQuery, error)
• type Aggregation
• type AggregationBody
• type AndNode
  • func (n *AndNode) GetChildren() []FilterNode
  • func (n *AndNode) ToSQL() (string, []interface{})
• type ComparisonNode
  • func (n *ComparisonNode) ToSQL() (string, []interface{})
• type CountBody
• type CountQuery
  • func NewCountQuery(sqon *SQON, fields []Field) (CountQuery, error)
• type Field
  • func (f *Field) GetAlias() string
  • func (f *Field) IsArray() bool
• type FilterNode
• type FilterNodeWithChildren
• type ListBody
• type ListQuery
  • func NewListQuery(selected []string, sqon *SQON, fields []Field, pagination *Pagination, ...) (ListQuery, error)
• type NotNode
  • func (n *NotNode) ToSQL() (string, []interface{})
• type Occurrence
• type OrNode
  • func (n *OrNode) GetChildren() []FilterNode
  • func (n *OrNode) ToSQL() (string, []interface{})
• type Pagination
• type Query
• type SQON
• type SortBody
• type SortField
• type Table

Constants

const (
	ArrayType = "array"
)

Variables

var AdRatioField = Field{
	Name:          "ad_ratio",
	CanBeSelected: true,
	CanBeFiltered: true,
	Table:         OccurrenceTable,
}

var AfField = Field{
	Name:          "af",
	CanBeSelected: true,
	CanBeFiltered: true,
	CanBeSorted:   true,
	Table:         VariantTable,
}

var ChromosomeField = Field{
	Name:            "chromosome",
	CanBeSelected:   true,
	CanBeFiltered:   true,
	CanBeSorted:     true,
	CanBeAggregated: true,
	Table:           OccurrenceTable,
}

var ClinvarField = Field{
	Name:            "clinvar_interpretation",
	Alias:           "clinvar",
	CanBeSelected:   true,
	CanBeFiltered:   true,
	CanBeSorted:     false,
	CanBeAggregated: true,
	Type:            ArrayType,
	Table:           VariantTable,
}

var ConsequenceFilterTable = Table{
	Name:  "consequences_filter",
	Alias: "cf",
}

var ConsequenceIdField = Field{
	Name:            "consequence_id",
	CanBeFiltered:   true,
	CanBeAggregated: true,
	Table:           ConsequenceFilterTable,
}

var FilterField = Field{
	Name:            "filter",
	CanBeSelected:   true,
	CanBeFiltered:   true,
	CanBeAggregated: true,
	Table:           OccurrenceTable,
}

var HgvsgField = Field{
	Name:          "hgvsg",
	CanBeSelected: true,
	CanBeFiltered: true,
	CanBeSorted:   true,
	Table:         VariantTable,
}

var ImpactScoreField = Field{
	Name:            "impact_score",
	CanBeFiltered:   true,
	CanBeAggregated: true,
	Table:           ConsequenceFilterTable,
}

var LocusIdField = Field{
	Name:          "locus_id",
	CanBeSelected: true,
	CanBeFiltered: true,
	CanBeSorted:   true,
	Table:         OccurrenceTable,
}

var OccurrenceTable = Table{
	Name:  "occurrences",
	Alias: "o",
}

var OccurrencesFields = []Field{
	SeqIdField,
	LocusIdField,
	FilterField,
	ZygosityField,
	QualityField,
	AdRatioField,
	PfField,
	AfField,
	VariantClassField,
	HgvsgField,
	ChromosomeField,
	ClinvarField,
	ConsequenceIdField,
	SymbolField,
	ImpactScoreField,
	SiftPredField,
}

var PfField = Field{
	Name:          "pf",
	CanBeSelected: true,
	CanBeFiltered: true,
	CanBeSorted:   true,
	Table:         VariantTable,
}

var QualityField = Field{
	Name:          "quality",
	CanBeSelected: true,
	CanBeFiltered: true,
	Table:         OccurrenceTable,
}

var SeqIdField = Field{
	Name:          "seq_id",
	CanBeSelected: true,
	CanBeFiltered: true,
	Table:         OccurrenceTable,
}

var SiftPredField = Field{
	Name:            "sift_pred",
	CanBeFiltered:   true,
	CanBeAggregated: true,
	Table:           ConsequenceFilterTable,
}

var SymbolField = Field{
	Name:            "symbol",
	CanBeFiltered:   true,
	CanBeAggregated: true,
	Table:           ConsequenceFilterTable,
}

var VariantClassField = Field{
	Name:            "variant_class",
	CanBeSelected:   true,
	CanBeFiltered:   true,
	CanBeSorted:     true,
	CanBeAggregated: true,
	Table:           VariantTable,
}

var VariantTable = Table{
	Name:  "variants",
	Alias: "v",
}

var ZygosityField = Field{
	Name:            "zygosity",
	CanBeSelected:   true,
	CanBeFiltered:   true,
	CanBeAggregated: true,
	Table:           OccurrenceTable,
}

Types

type AggQuery

type AggQuery interface {
	Filters() FilterNode
	GetAggregateField() Field
	HasFieldFromTable(table Table) bool
}

func NewAggregationQuery

func NewAggregationQuery(aggregation string, sqon *SQON, fields []Field) (AggQuery, error)

type Aggregation

type Aggregation struct {
	Bucket string `json:"key"`
	Count  int64  `json:"count"`
}

type AggregationBody

type AggregationBody struct {
	Field string
	SQON  *SQON
	Size  int
}

type AndNode

type AndNode struct {
	Children []FilterNode
}

func (*AndNode) GetChildren

func (n *AndNode) GetChildren() []FilterNode

func (*AndNode) ToSQL

func (n *AndNode) ToSQL() (string, []interface{})

type ComparisonNode

type ComparisonNode struct {
	Operator string
	Value    interface{}
	Field    Field
}

func (*ComparisonNode) ToSQL

func (n *ComparisonNode) ToSQL() (string, []interface{})

type CountBody

type CountBody struct {
	SQON *SQON `json:"sqon"`
}

type CountQuery

type CountQuery interface {
	Filters() FilterNode
	HasFieldFromTable(table Table) bool
}

func NewCountQuery

func NewCountQuery(sqon *SQON, fields []Field) (CountQuery, error)

type Field

type Field struct {
	Name            string // Name of the field, correspond to column name
	Alias           string // Alias of the field to use in query
	CanBeSelected   bool   // Whether the field is authorized for selection
	CanBeFiltered   bool   // Whether the field is authorized for filtering
	CanBeSorted     bool   // Whether the field is authorized for sorting
	CanBeAggregated bool   // Whether the field is authorized for aggregation
	CustomOp        string // Custom operation, e.g., "array_contains"
	DefaultOp       string // Default operation to use if no custom one exists
	Table           Table  // Table to which the field belongs
	Type            string // Type of the field
}

func (*Field) GetAlias

func (f *Field) GetAlias() string

GetAlias returns the alias of the field if it is set, otherwise returns the name

func (*Field) IsArray

func (f *Field) IsArray() bool

type FilterNode

type FilterNode interface {
	ToSQL() (string, []interface{})
}

type FilterNodeWithChildren

type FilterNodeWithChildren interface {
	ToSQL() (string, []interface{})
	GetChildren() []FilterNode
}

type ListBody

type ListBody struct {
	SelectedFields []string   `json:"selected_fields"`
	SQON           *SQON      `json:"sqon"`
	Limit          int        `json:"limit"`
	Offset         int        `json:"offset"`
	Sort           []SortBody `json:"sort"`
}

type ListQuery

type ListQuery interface {
	SelectedFields() []Field
	Filters() FilterNode
	Pagination() *Pagination
	SortedFields() []SortField
	HasFieldFromTable(table Table) bool
}

func NewListQuery

func NewListQuery(selected []string, sqon *SQON, fields []Field, pagination *Pagination, sorted []SortBody) (ListQuery, error)

type NotNode

type NotNode struct {
	Child FilterNode
}

func (*NotNode) ToSQL

func (n *NotNode) ToSQL() (string, []interface{})

type Occurrence

type Occurrence struct {
	SeqId               int                     `json:"seq_id,omitempty"`
	Chromosome          string                  `json:"chromosome,omitempty"`
	LocusId             int64                   `json:"locus_id,omitempty"`
	Quality             float32                 `json:"quality,omitempty"`
	Filter              string                  `json:"filter,omitempty"`
	Zygosity            string                  `json:"zygosity,omitempty"`
	Pf                  float64                 `json:"pf,omitempty"`
	Af                  float64                 `json:"af,omitempty"`
	GnomadV3Af          float64                 `json:"gnomad_v3_af,omitempty"`
	Hgvsg               string                  `json:"hgvsg,omitempty"`
	OmimInheritanceCode string                  `json:"omim_inheritance_code,omitempty"`
	AdRatio             float64                 `json:"ad_ratio,omitempty"`
	VariantClass        string                  `json:"variant_class,omitempty"`
	VepImpact           string                  `json:"vep_impact,omitempty"`
	Symbol              string                  `json:"symbol,omitempty"`
	Clinvar             utils.JsonArray[string] `gorm:"type:json" json:"clinvar,omitempty"`
	ManeSelect          bool                    `json:"mane_select,omitempty"`
	Canonical           bool                    `json:"canonical,omitempty"`
}

type OrNode

type OrNode struct {
	Children []FilterNode
}

func (*OrNode) GetChildren

func (n *OrNode) GetChildren() []FilterNode

func (*OrNode) ToSQL

func (n *OrNode) ToSQL() (string, []interface{})

type Pagination

type Pagination struct {
	Limit  int //Limit the number of results
	Offset int //Offset the results
}

type Query

type Query interface {
	Filters() FilterNode
	HasFieldFromTable(table Table) bool
}

type SQON

type SQON struct {
	Field   string      `json:"field,omitempty"`   // Field to filter on (for leaf nodes)
	Value   interface{} `json:"value,omitempty"`   // Value(s) for the filter
	Content []SQON      `json:"content,omitempty"` // Nested SQON (for "not" or nested filters)
	Op      string      `json:"op,omitempty"`      // Operation at this node
}

type SortBody

type SortBody struct {
	Field string `json:"field"`
	Order string `json:"order"`
}

type SortField

type SortField struct {
	Field Field
	Order string
}

type Table

type Table struct {
	Name  string // Name of the table
	Alias string // Alias of the table to use in query
}