Query.hs

-- Note: this is an automatically generated file. Do not edit.

-- | A model for language-agnostic graph pattern queries

module Hydra.Query where

import qualified Hydra.Core as Core
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.ByteString as B
import qualified Data.Int as I
import qualified Data.List as L
import qualified Data.Map as M
import qualified Data.Set as S

-- | One of several comparison operators
data ComparisonConstraint =
  ComparisonConstraintEqual  |
  ComparisonConstraintNotEqual  |
  ComparisonConstraintLessThan  |
  ComparisonConstraintGreaterThan  |
  ComparisonConstraintLessThanOrEqual  |
  ComparisonConstraintGreaterThanOrEqual
  deriving (Eq, Ord, Read, Show)

_ComparisonConstraint = Core.Name "hydra.query.ComparisonConstraint"

_ComparisonConstraint_equal = Core.Name "equal"

_ComparisonConstraint_notEqual = Core.Name "notEqual"

_ComparisonConstraint_lessThan = Core.Name "lessThan"

_ComparisonConstraint_greaterThan = Core.Name "greaterThan"

_ComparisonConstraint_lessThanOrEqual = Core.Name "lessThanOrEqual"

_ComparisonConstraint_greaterThanOrEqual = Core.Name "greaterThanOrEqual"

-- | An abstract edge based on a record type
data Edge =
  Edge {
    -- | The name of a record type, for which the edge also specifies an out- and an in- projection
    edgeType :: Core.Name,
    -- | The field representing the out-projection of the edge. Defaults to 'out'.
    edgeOut :: (Maybe Core.Name),
    -- | The field representing the in-projection of the edge. Defaults to 'in'.
    edgeIn :: (Maybe Core.Name)}
  deriving (Eq, Ord, Read, Show)

_Edge = Core.Name "hydra.query.Edge"

_Edge_type = Core.Name "type"

_Edge_out = Core.Name "out"

_Edge_in = Core.Name "in"

-- | A query pattern which matches within a designated component subgraph
data GraphPattern =
  GraphPattern {
    -- | The name of the component graph
    graphPatternGraph :: Core.Name,
    -- | The patterns to match within the subgraph
    graphPatternPatterns :: [Pattern]}
  deriving (Eq, Ord, Read, Show)

_GraphPattern = Core.Name "hydra.query.GraphPattern"

_GraphPattern_graph = Core.Name "graph"

_GraphPattern_patterns = Core.Name "patterns"

-- | A node in a query expression; it may be a term, a variable, or a wildcard
data Node =
  -- | A graph term; an expression which is valid in the graph being matched
  NodeTerm Core.Term |
  -- | A query variable, not to be confused with a variable term
  NodeVariable Variable |
  -- | An anonymous variable which we do not care to join across patterns
  NodeWildcard
  deriving (Eq, Ord, Read, Show)

_Node = Core.Name "hydra.query.Node"

_Node_term = Core.Name "term"

_Node_variable = Core.Name "variable"

_Node_wildcard = Core.Name "wildcard"

-- | A query path
data Path =
  -- | A path given by a single step
  PathStep Step |
  -- | A path given by a regular expression quantifier applied to another path
  PathRegex RegexSequence |
  -- | A path given by the inverse of another path
  PathInverse Path
  deriving (Eq, Ord, Read, Show)

_Path = Core.Name "hydra.query.Path"

_Path_step = Core.Name "step"

_Path_regex = Core.Name "regex"

_Path_inverse = Core.Name "inverse"

-- | A declared equivalence between two abstract paths in a graph
data PathEquation =
  PathEquation {
    -- | The left-hand side of the equation
    pathEquationLeft :: Path,
    -- | The right-hand side of the equation
    pathEquationRight :: Path}
  deriving (Eq, Ord, Read, Show)

_PathEquation = Core.Name "hydra.query.PathEquation"

_PathEquation_left = Core.Name "left"

_PathEquation_right = Core.Name "right"

-- | A query pattern
data Pattern =
  -- | A subject/predicate/object pattern
  PatternTriple TriplePattern |
  -- | The negation of another pattern
  PatternNegation Pattern |
  -- | The conjunction ('and') of several other patterns
  PatternConjunction [Pattern] |
  -- | The disjunction (inclusive 'or') of several other patterns
  PatternDisjunction [Pattern] |
  -- | A pattern which matches within a named subgraph
  PatternGraph GraphPattern
  deriving (Eq, Ord, Read, Show)

_Pattern = Core.Name "hydra.query.Pattern"

_Pattern_triple = Core.Name "triple"

_Pattern_negation = Core.Name "negation"

_Pattern_conjunction = Core.Name "conjunction"

_Pattern_disjunction = Core.Name "disjunction"

_Pattern_graph = Core.Name "graph"

-- | A pattern which, if it matches in a given graph, implies that another pattern must also match. Query variables are shared between the two patterns.
data PatternImplication =
  PatternImplication {
    -- | The pattern which, if it matches, triggers the constraint
    patternImplicationAntecedent :: Pattern,
    -- | The pattern which must also match when the antecedent matches
    patternImplicationConsequent :: Pattern}
  deriving (Eq, Ord, Read, Show)

_PatternImplication = Core.Name "hydra.query.PatternImplication"

_PatternImplication_antecedent = Core.Name "antecedent"

_PatternImplication_consequent = Core.Name "consequent"

-- | A SELECT-style graph pattern matching query
data Query =
  Query {
    -- | The variables selected by the query
    queryVariables :: [Variable],
    -- | The patterns to be matched
    queryPatterns :: [Pattern]}
  deriving (Eq, Ord, Read, Show)

_Query = Core.Name "hydra.query.Query"

_Query_variables = Core.Name "variables"

_Query_patterns = Core.Name "patterns"

-- | A range from min to max, inclusive
data Range =
  Range {
    -- | The minimum value (inclusive)
    rangeMin :: Int,
    -- | The maximum value (inclusive)
    rangeMax :: Int}
  deriving (Eq, Ord, Read, Show)

_Range = Core.Name "hydra.query.Range"

_Range_min = Core.Name "min"

_Range_max = Core.Name "max"

-- | A regular expression quantifier
data RegexQuantifier =
  -- | No quantifier; matches a single occurrence
  RegexQuantifierOne  |
  -- | The ? quanifier; matches zero or one occurrence
  RegexQuantifierZeroOrOne  |
  -- | The * quantifier; matches any number of occurrences
  RegexQuantifierZeroOrMore  |
  -- | The + quantifier; matches one or more occurrences
  RegexQuantifierOneOrMore  |
  -- | The {n} quantifier; matches exactly n occurrences
  RegexQuantifierExactly Int |
  -- | The {n,} quantifier; matches at least n occurrences
  RegexQuantifierAtLeast Int |
  -- | The {n, m} quantifier; matches between n and m (inclusive) occurrences
  RegexQuantifierRange Range
  deriving (Eq, Ord, Read, Show)

_RegexQuantifier = Core.Name "hydra.query.RegexQuantifier"

_RegexQuantifier_one = Core.Name "one"

_RegexQuantifier_zeroOrOne = Core.Name "zeroOrOne"

_RegexQuantifier_zeroOrMore = Core.Name "zeroOrMore"

_RegexQuantifier_oneOrMore = Core.Name "oneOrMore"

_RegexQuantifier_exactly = Core.Name "exactly"

_RegexQuantifier_atLeast = Core.Name "atLeast"

_RegexQuantifier_range = Core.Name "range"

-- | A path with a regex quantifier
data RegexSequence =
  RegexSequence {
    -- | The path to which the quantifier applies
    regexSequencePath :: Path,
    -- | The quantifier
    regexSequenceQuantifier :: RegexQuantifier}
  deriving (Eq, Ord, Read, Show)

_RegexSequence = Core.Name "hydra.query.RegexSequence"

_RegexSequence_path = Core.Name "path"

_RegexSequence_quantifier = Core.Name "quantifier"

-- | An atomic function as part of a query. When applied to a graph, steps are typed by function types.
data Step =
  -- | An out-to-in traversal of an abstract edge
  StepEdge Edge |
  -- | A projection from a record through one of its fields
  StepProject Core.Projection |
  -- | A comparison of two terms
  StepCompare ComparisonConstraint
  deriving (Eq, Ord, Read, Show)

_Step = Core.Name "hydra.query.Step"

_Step_edge = Core.Name "edge"

_Step_project = Core.Name "project"

_Step_compare = Core.Name "compare"

-- | A subject/predicate/object pattern
data TriplePattern =
  TriplePattern {
    -- | The subject of the pattern
    triplePatternSubject :: Node,
    -- | The predicate (property) of the pattern
    triplePatternPredicate :: Path,
    -- | The object of the pattern
    triplePatternObject :: Node}
  deriving (Eq, Ord, Read, Show)

_TriplePattern = Core.Name "hydra.query.TriplePattern"

_TriplePattern_subject = Core.Name "subject"

_TriplePattern_predicate = Core.Name "predicate"

_TriplePattern_object = Core.Name "object"

-- | A query variable
newtype Variable =
  Variable {
    unVariable :: String}
  deriving (Eq, Ord, Read, Show)

_Variable = Core.Name "hydra.query.Variable"