openehr 1.2.999999 → 2.0.0

data/lib/openehr/aql/model/order_by_and_limit.rb

@@ -0,0 +1,50 @@
+module OpenEHR
+  module AQL
+    module Model
+      # orderByClause : ORDER BY orderByExpr (SYM_COMMA orderByExpr)* ;
+      class OrderByClause
+        attr_reader :items
+
+        def initialize(items:)
+          @items = items.freeze
+          freeze
+        end
+      end
+
+      # orderByExpr : identifiedPath order=(DESCENDING|DESC|ASCENDING|ASC)? ;
+      # `direction` is always :asc or :desc - the grammar's four spellings
+      # (ASC/ASCENDING/DESC/DESCENDING) collapse to one of these two.
+      class OrderByItem
+        attr_reader :path, :direction
+
+        def initialize(path:, direction: :asc)
+          @path = path
+          @direction = direction
+          freeze
+        end
+      end
+
+      # limitClause : LIMIT limit=INTEGER (OFFSET offset=INTEGER)? ;
+      class LimitClause
+        attr_reader :limit, :offset
+
+        def initialize(limit:, offset: 0)
+          @limit = limit
+          @offset = offset
+          freeze
+        end
+      end
+
+      # top : TOP INTEGER direction=(FORWARD|BACKWARD)? ; (deprecated)
+      class Top
+        attr_reader :count, :direction
+
+        def initialize(count:, direction: nil)
+          @count = count
+          @direction = direction
+          freeze
+        end
+      end
+    end
+  end
+end

data/lib/openehr/aql/model/predicate.rb

@@ -0,0 +1,84 @@
+module OpenEHR
+  module AQL
+    module Model
+      # standardPredicate : objectPath COMPARISON_OPERATOR pathPredicateOperand ;
+      # (nodePredicate's 4th alternative has this identical shape - see
+      # Parser#parse_standard_predicate's comment.)
+      class StandardPredicate
+        attr_reader :path, :operator, :operand
+
+        def initialize(path:, operator:, operand:)
+          @path = path
+          @operator = operator
+          @operand = operand
+          freeze
+        end
+      end
+
+      # archetypePredicate : ARCHETYPE_HRID (SYM_COMMA (STRING | PARAMETER | TERM_CODE | AT_CODE | ID_CODE))? | PARAMETER ;
+      # `value` is the optional SYM_COMMA suffix: a raw String (for
+      # STRING/AT_CODE/ID_CODE) or a Parameter. The bare-PARAMETER
+      # alternative (a whole predicate substituted at execution time,
+      # e.g. "[$archetypeId]") isn't needed by any current example and is
+      # deferred - see Parser#parse_predicate_primary.
+      class ArchetypePredicate
+        attr_reader :archetype_id, :value
+
+        def initialize(archetype_id:, value: nil)
+          @archetype_id = archetype_id
+          @value = value
+          freeze
+        end
+      end
+
+      # nodePredicate : (ID_CODE | AT_CODE) (SYM_COMMA (STRING | PARAMETER | TERM_CODE | AT_CODE | ID_CODE))? | ... ;
+      # `value` is the optional SYM_COMMA suffix, same shape as
+      # ArchetypePredicate#value.
+      class NodePredicate
+        attr_reader :code, :value
+
+        def initialize(code:, value: nil)
+          @code = code
+          @value = value
+          freeze
+        end
+      end
+
+      # nodePredicate : ... | nodePredicate AND nodePredicate | ... ;
+      # Combines any pathPredicate-body primaries (ArchetypePredicate,
+      # NodePredicate, Parameter, StandardPredicate). AND binds tighter
+      # than OR, same precedence-climbing convention used for whereExpr
+      # (M5) and containsExpr (M7).
+      class PredicateAnd
+        attr_reader :left, :right
+
+        def initialize(left:, right:)
+          @left = left
+          @right = right
+          freeze
+        end
+      end
+
+      # nodePredicate : ... | nodePredicate OR nodePredicate ;
+      class PredicateOr
+        attr_reader :left, :right
+
+        def initialize(left:, right:)
+          @left = left
+          @right = right
+          freeze
+        end
+      end
+
+      # PARAMETER: '$' IDENTIFIER_CHAR ;
+      class Parameter
+        attr_reader :name
+
+        def initialize(name:)
+          @name = name
+          freeze
+        end
+      end
+    end
+  end
+end

data/lib/openehr/aql/model/query.rb

@@ -0,0 +1,24 @@
+module OpenEHR
+  module AQL
+    module Model
+      # The parsed, immutable representation of an AQL selectQuery.
+      # Clauses that a milestone hasn't implemented yet are nil.
+      class Query
+        attr_reader :select_clause, :from_clause, :where_clause, :order_by_clause, :limit_clause
+
+        def initialize(select_clause:, from_clause:, where_clause: nil, order_by_clause: nil, limit_clause: nil)
+          @select_clause = select_clause
+          @from_clause = from_clause
+          @where_clause = where_clause
+          @order_by_clause = order_by_clause
+          @limit_clause = limit_clause
+          freeze
+        end
+
+        def execute(dataset, params: {})
+          OpenEHR::AQL::Engine.new(self).execute(dataset, params: params)
+        end
+      end
+    end
+  end
+end

data/lib/openehr/aql/model/select_clause.rb

@@ -0,0 +1,29 @@
+module OpenEHR
+  module AQL
+    module Model
+      # selectClause : SELECT DISTINCT? top? selectExpr (SYM_COMMA selectExpr)* ;
+      class SelectClause
+        attr_reader :columns, :distinct, :top
+        alias distinct? distinct
+
+        def initialize(columns:, distinct: false, top: nil)
+          @columns = columns.freeze
+          @distinct = distinct
+          @top = top
+          freeze
+        end
+      end
+
+      # selectExpr : columnExpr (AS aliasName=IDENTIFIER)? ;
+      class SelectColumn
+        attr_reader :expression, :alias_name
+
+        def initialize(expression:, alias_name: nil)
+          @expression = expression
+          @alias_name = alias_name
+          freeze
+        end
+      end
+    end
+  end
+end

data/lib/openehr/aql/model/where_clause.rb

@@ -0,0 +1,105 @@
+module OpenEHR
+  module AQL
+    module Model
+      # whereClause : WHERE whereExpr ;
+      class WhereClause
+        attr_reader :expression
+
+        def initialize(expression:)
+          @expression = expression
+          freeze
+        end
+      end
+
+      # whereExpr : ... | whereExpr AND whereExpr | ... ;
+      class AndExpr
+        attr_reader :left, :right
+
+        def initialize(left:, right:)
+          @left = left
+          @right = right
+          freeze
+        end
+      end
+
+      # whereExpr : ... | whereExpr OR whereExpr | ... ;
+      class OrExpr
+        attr_reader :left, :right
+
+        def initialize(left:, right:)
+          @left = left
+          @right = right
+          freeze
+        end
+      end
+
+      # whereExpr : ... | NOT whereExpr | ... ;
+      class NotExpr
+        attr_reader :operand
+
+        def initialize(operand:)
+          @operand = operand
+          freeze
+        end
+      end
+
+      # identifiedExpr : identifiedPath COMPARISON_OPERATOR terminal | functionCall COMPARISON_OPERATOR terminal ;
+      # The functionCall-on-the-left alternative is added by M8.
+      class Comparison
+        attr_reader :left, :operator, :right
+
+        def initialize(left:, operator:, right:)
+          @left = left
+          @operator = operator
+          @right = right
+          freeze
+        end
+      end
+
+      # identifiedExpr : EXISTS identifiedPath | ... ;
+      class ExistsExpr
+        attr_reader :path
+
+        def initialize(path:)
+          @path = path
+          freeze
+        end
+      end
+
+      # identifiedExpr : identifiedPath LIKE likeOperand | ... ;
+      class LikeExpr
+        attr_reader :path, :operand
+
+        def initialize(path:, operand:)
+          @path = path
+          @operand = operand
+          freeze
+        end
+      end
+
+      # identifiedExpr : identifiedPath MATCHES matchesOperand | ... ;
+      class MatchesExpr
+        attr_reader :path, :operand
+
+        def initialize(path:, operand:)
+          @path = path
+          @operand = operand
+          freeze
+        end
+      end
+
+      # matchesOperand's value-list alternative:
+      #   SYM_LEFT_CURLY valueListItem (SYM_COMMA valueListItem)* SYM_RIGHT_CURLY
+      # The terminologyFunction-item and bare-URI alternatives need a URI
+      # lexer token that doesn't exist yet, and are deferred.
+      class MatchesValueList
+        attr_reader :items
+
+        def initialize(items:)
+          @items = items.freeze
+          freeze
+        end
+      end
+    end
+  end
+end

data/lib/openehr/aql/model.rb

@@ -0,0 +1,14 @@
+# OpenEHR::AQL::Model holds the immutable object model that the Parser
+# builds and the execution Engine walks: one class per relevant
+# AqlParser.g4 rule (see lib/openehr/aql/parser.rb for the mapping).
+require_relative 'model/query'
+require_relative 'model/select_clause'
+require_relative 'model/from_clause'
+require_relative 'model/identified_path'
+require_relative 'model/literal'
+require_relative 'model/object_path'
+require_relative 'model/predicate'
+require_relative 'model/containment'
+require_relative 'model/where_clause'
+require_relative 'model/order_by_and_limit'
+require_relative 'model/function_call'