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, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void

-- | 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"