conceptql 0.7.0 → 0.8.0

data/lib/conceptql/operators/vocabulary.rb

@@ -6,12 +6,13 @@ module ConceptQL
   module Operators
     class Vocabulary < Operator
       # The vocabulary operators share one reference section (spec_id
-      # vocabulary-operator): each generated vocabulary operator, read and
-      # the multiple vocabulary operators. So the section's texts are written
-      # on this class: `returns`, the meaning: of the codes argument, and each
-      # `example`. An operator of the section extends this module and serves
-      # the returns text, and only the examples whose statement starts with
-      # its own name, so no operator shows an example of another one.
+      # vocabulary-operator): each generated vocabulary operator (read is
+      # one) and the multiple vocabulary operators. So the section's texts
+      # are written on this class: `returns`, the meaning: of the codes
+      # argument, and each `example`. An operator of the section extends this
+      # module and serves the returns text, and only the examples whose
+      # statement starts with its own name, so no operator shows an example
+      # of another one.
       module SharedDocumentation
         def get_returns
           super || Vocabulary.returns
@@ -79,32 +80,46 @@ module ConceptQL
         "HCPCS" => { vocabulary_id: "CPT4_HCPCS", operator: "cpt_or_hcpcs" }
       }.freeze
       NO_RECORDS_IN_DATA = "the data has no records of this vocabulary"
+      NOT_PRESENT_IN_DATASET = "code(s) not present in this dataset"
 
       # MultipleVocabularies passes skip_merged_vocabulary_check to its
       # vocabulary operators. It reads the merged vocabulary itself, and it
-      # would drop this warning anyway (see #warn_about_merged_vocabulary).
+      # would drop these warnings anyway (see #warn_about_merged_vocabulary).
+      # The merged-vocabulary and the no-records checks read the data, so
+      # they need a data database. The code checks read only the lexicon.
+      # When the merged-vocabulary warning fires, it names the operator to
+      # use, so the no-records check does not add a second warning with the
+      # same text.
+      #
+      # Database#check_codes sorts the codes that the Database's lexicon does
+      # not know into "code(s) not present in this dataset" and "unknown
+      # code(s)", and applies the 2020 rule. Each warning lists every code.
+      # When the data has no records of the vocabulary at all, the no-records
+      # warning already says that every code is absent, so the not-present
+      # warning is not given. The unknown-code and reused-code warnings still
+      # are, so a typo is not hidden (bead conceptql-dufi).
       def additional_validation(db, opts = {})
-        return unless add_warnings?(db, opts)
-
-        warn_about_merged_vocabulary(db) unless opts[:skip_merged_vocabulary_check]
+        if add_warnings?(db, opts) && !opts[:skip_merged_vocabulary_check]
+          merged_warning = warn_about_merged_vocabulary(db)
+          check_for_records(db, warn: !merged_warning)
+        end
+        return unless lexicon_checks?(opts)
         return if select_all?
 
-        args = arguments.dup
-        args -= bad_arguments
-
-        # A statement warns about a code in another case than the stored one,
-        # so its lookups do not raise CodeCaseMismatchError (bead conceptql-rz8s).
-        missing_args = args - dm.known_codes(db, vocabulary_id, args, check_case: false)
-        add_warning(UNKNOWN_CODE, *missing_args) unless missing_args.empty?
+        args = arguments - bad_arguments
+        not_present, unknown = nodifier.cdb.check_codes(db, vocabulary_id, args)
+        add_warning(NOT_PRESENT_IN_DATASET, *not_present) unless not_present.empty? || @no_records_in_data
+        add_warning(UNKNOWN_CODE, *unknown) unless unknown.empty?
 
-        warn_about_reused_codes(db, args - missing_args)
+        warn_about_reused_codes(db, args - not_present - unknown)
       end
 
       # Warns when the data has no record of this vocabulary but has records
       # of the merged vocabulary that holds its codes, and the Database's
       # lexicon carries that merged vocabulary (bead conceptql-k5ho). The
       # warning names the operator to use instead. The test fixture keeps
-      # CPT4 and HCPCS rows, so it never shows this warning.
+      # CPT4 and HCPCS rows, so it never shows this warning. It returns the
+      # warnings when it adds one, and nil otherwise.
       def warn_about_merged_vocabulary(db)
         merged = MERGED_VOCABULARIES[vocabulary_id]
         return unless merged && nodifier.operators.key?(merged[:vocabulary_id].downcase)
@@ -117,6 +132,40 @@ module ConceptQL
                     "the data stores #{vocabulary_id} codes as #{merged[:vocabulary_id]}, so use #{merged[:operator]}")
       end
 
+      # Warns when etl_vocabulary_ids lists the vocabularies of the data's
+      # clinical codes and this vocabulary is not among them (bead
+      # conceptql-d1bd). A count of 0 would then say that no patient has the
+      # codes, which the data cannot show, so #annotate reports null counts.
+      # With warn: false (the merged-vocabulary warning fired, with the same
+      # text), the counts are null and no second warning is added.
+      # etl_vocabulary_ids covers the clinical codes only, so an operator
+      # that reads another table (death type, observation period type) is
+      # not checked. Neither is a dataset without the table.
+      def check_for_records(db, warn: true)
+        return unless absent_from_data?(db)
+
+        @no_records_in_data = true
+        add_warning(NO_RECORDS_IN_DATA) if warn
+      end
+
+      # Whether etl_vocabulary_ids lists the vocabularies of the data's
+      # clinical codes and this vocabulary is not among them. See
+      # #check_for_records. MultipleVocabularies asks each of its vocabulary
+      # operators.
+      def absent_from_data?(db)
+        return false unless criterion_table == dm.table_by_domain(:clinical_codes)
+        return false unless (ids = nodifier.etl_vocabulary_ids(db))
+
+        !ids.include?(vocabulary_id)
+      end
+
+      # Whether the data has no records of this vocabulary at all, as
+      # #check_for_records found.
+      def no_records_in_data?(db, opts = {})
+        validate(db, opts)
+        @no_records_in_data || false
+      end
+
       # A code that the vocabulary reused for a new meaning selects records of
       # both meanings: DRG 410 selects chemotherapy stays before 2007-10-01 and
       # biliary tract procedures after it (conceptql-ttk). Each item names the
@@ -125,7 +174,7 @@ module ConceptQL
       def warn_about_reused_codes(db, codes)
         meanings = dm.code_meanings(db, vocabulary_id, codes, check_case: false)
         reused = codes.filter_map do |code|
-          names = meanings[code.downcase]
+          names = meanings[code]
           "#{code}: #{names.join(' | ')}" if names
         end
         add_warning("code(s) with more than one meaning", *reused) unless reused.empty?
@@ -157,6 +206,10 @@ module ConceptQL
         { clinical_code_vocabulary_id: vocabulary_id }
       end
 
+      def vocabulary_id
+        @vocabulary_id ||= translated_vocabulary_id
+      end
+
       private
 
       def query(db)
@@ -222,10 +275,6 @@ module ConceptQL
         vocab_entry.omopv5_id == "NDC" ? NDC_BAD_FORMAT : BAD_FORMAT
       end
 
-      def vocabulary_id
-        @vocabulary_id ||= translated_vocabulary_id
-      end
-
       def translated_vocabulary_id
         vocab_entry.omopv5_vocabulary_id || op_name
       end

data/lib/conceptql/query.rb

@@ -5,6 +5,7 @@ require "forwardable"
 require_relative "scope"
 require_relative "nodifier"
 require_relative "one_query_counts"
+require_relative "annotation"
 require "sequel/sqlformat"
 
 module ConceptQL
@@ -29,9 +30,10 @@ module ConceptQL
   # errors. An invalid statement can crash while it builds, or build SQL that
   # silently returns fewer rows. Warnings do not raise.
   #
-  # #errors is the errors hash that #scope_annotate reports (operator name =>
-  # list of [message, *details]), so it holds the errors that annotate shows.
-  # #statement is the statement that the Query holds.
+  # #errors is the list of every error that annotate shows, in the form of
+  # ConceptQL::Annotation#errors ({ operator:, id:, message:, details: }), so
+  # two operators with the same name keep their own errors. #statement is the
+  # statement that the Query holds.
   class InvalidStatementError < Query::QueryError
     attr_reader :statement, :errors
 
@@ -39,15 +41,15 @@ module ConceptQL
       @statement = statement
       @errors = errors
       super([ "Invalid ConceptQL statement. Validation errors:",
-             *errors.flat_map { |op, op_errors| op_errors.map { |e| "  #{op}: #{describe(e)}" } },
+             *errors.map { |error| "  #{error[:operator]}: #{describe(error)}" },
              "Statement: #{statement.inspect}" ].join("\n"))
     end
 
     private
 
     def describe(error)
-      message, *details = error
-      details.empty? ? message.to_s : "#{message} (#{details.flatten.map(&:to_s).join(', ')})"
+      details = error[:details]
+      details.empty? ? error[:message].to_s : "#{error[:message]} (#{details.flatten.map(&:to_s).join(', ')})"
     end
   end
 
@@ -63,6 +65,7 @@ module ConceptQL
 
     def initialize(cdb, statement, opts = {})
       @cdb = cdb
+      @given_statement = statement
       @statement, opts = extract_statement(statement, opts)
       @opts = opts
       opts[:algorithm_fetcher] ||= proc do |alg|
@@ -131,21 +134,43 @@ module ConceptQL
       raise QueryError, "Failed to generate SQL for #{statement.inspect}"
     end
 
-    # With counts on, DuckDB and Postgres count every operator with one SQL
-    # statement (OneQueryCounts). Operators memoize #annotate, so a later call
-    # with other opts returns the first result.
+    # The statement, with an annotation hash in each operator: its effective
+    # id (see Annotation.assign_ids), its counts, errors and warnings. With
+    # counts on, DuckDB and Postgres count every operator with one SQL
+    # statement (OneQueryCounts). ConceptQL::Annotation reads the result.
     #
-    # The errors of the window table's own statement are reported under
-    # "window_table" (see #window_table_errors). Then nothing is counted,
-    # because every count joins the window table, and building its SQL raises.
+    # The Query keeps one result for each opts hash, so a repeated call with
+    # the same opts annotates once. Operators memoize #annotate and write into
+    # their own options, so each opts hash gets a fresh operator tree, and a
+    # call with other opts gets its own correct result.
+    #
+    # A window statement keeps its window operator at the top, and a window
+    # table that is a ConceptQL statement is annotated in place, in the
+    # window_table option of the window operator, so each of its errors stays
+    # on its own operator. When the window table has errors, the outer
+    # statement is not counted, because every count joins the window table,
+    # and building its SQL raises.
     def annotate(opts = {})
-      window_errors = window_table_errors
-      unless window_errors.empty?
-        nodifier.scope.add_errors("window_table", window_errors)
-        opts = opts.merge(skip_counts: true)
-      end
-      nodifier.scope.one_query_counts = OneQueryCounts.new(operator, db, opts)
-      operator.annotate(db, opts)
+      annotated_tree(opts).annotated
+    end
+
+    # The errors of the statement, as ConceptQL::Annotation#errors gives them.
+    # They come from the kept annotation with skip_counts: true, so no count
+    # SQL runs.
+    def errors
+      annotation.errors
+    end
+
+    # The warnings of the statement, as ConceptQL::Annotation#warnings gives
+    # them, from the same kept annotation as #errors.
+    def warnings
+      annotation.warnings
+    end
+
+    # True when no operator has an error. Warnings do not make a statement
+    # invalid.
+    def valid?
+      annotation.valid?
     end
 
     def accept(visitor, _opts = {})
@@ -158,11 +183,6 @@ module ConceptQL
       visitor.results
     end
 
-    def scope_annotate(opts = {})
-      annotate(opts)
-      nodifier.scope.annotation
-    end
-
     def domains
       operator.domains(db)
     end
@@ -200,21 +220,55 @@ module ConceptQL
       operator.code_list(db).uniq
     end
 
-    # The errors that #scope_annotate reports, the same check that callers use
-    # to decide whether a statement is valid. A fresh query runs it, because
-    # operators memoize #annotate and #validate, and this query's later
-    # #annotate calls must not get those results.
+    # Every error of the statement, the check that callers use to decide
+    # whether a statement is valid. It is #errors: it reads the kept
+    # annotation with skip_counts: true, so it never runs count SQL. #sql
+    # calls it.
     def validation_errors
-      Query.new(cdb, statement, @opts).scope_annotate(skip_counts: true)[:errors]
+      errors
     end
 
     def drop_temp_tables(opts = {})
       query.drop_temp_tables(opts)
     end
 
+    protected
+
+    attr_reader :nodifier, :annotated
+
+    # Annotates this Query's own operator tree once. Only #annotated_tree
+    # calls it, on a fresh Query.
+    def annotate_own_tree(opts)
+      @annotated = Annotation.assign_ids(annotate_without_ids(opts))
+    end
+
+    # The annotated statement before Annotation.assign_ids, so that the ids
+    # of a window table statement are assigned with the ids of the statement
+    # around it. It annotates this Query's own operator tree, so only a fresh
+    # Query calls it.
+    def annotate_without_ids(opts)
+      opts = opts.merge(skip_counts: true) unless window_table_errors.empty?
+      nodifier.scope.one_query_counts = OneQueryCounts.new(operator, db, opts)
+      with_window(operator.annotate(db, opts), opts)
+    end
+
     private
 
-    attr_reader :cdb, :nodifier
+    attr_reader :cdb
+
+    # A fresh Query of the given statement (with its window operator) for
+    # each opts hash, with its own operator tree and scope, that has annotated
+    # its tree with those opts. This Query's own tree is never annotated, so
+    # #query and #sql do not depend on annotate calls.
+    def annotated_tree(opts)
+      (@annotated_trees ||= {})[opts.dup] ||= Query.new(cdb, @given_statement, @opts).tap do |tree|
+        tree.annotate_own_tree(opts)
+      end
+    end
+
+    def annotation
+      Annotation.new(annotate(skip_counts: true))
+    end
 
     # Raises InvalidStatementError if #validation_errors is not empty. The
     # statement and the opts of a Query do not change, so it checks once.
@@ -229,20 +283,39 @@ module ConceptQL
       @valid = true
     end
 
+    # The window table of the scope, as Window::Table reads it: a table name
+    # or a ConceptQL statement (an Array)
+    def window_table
+      scope_opts = nodifier.scope.opts
+      scope_opts.merge(scope_opts[:window_opts] || {})[:window_table]
+    end
+
     # The validation errors of the window table's statement, when the window
-    # table is a ConceptQL statement (an Array, as Window::Table reads it), as
-    # one list of [message, *details]. Each message starts with the name of
-    # the operator that reported it. A table name has no errors.
+    # table is a ConceptQL statement, as one list of [message, *details]. Each
+    # message starts with the name of the operator that reported it. A table
+    # name has no errors.
     def window_table_errors
-      scope_opts = nodifier.scope.opts
-      window_table = scope_opts.merge(scope_opts[:window_opts] || {})[:window_table]
       return [] unless window_table.is_a?(Array)
 
-      cdb.query(window_table).validation_errors.flat_map do |op, op_errors|
-        op_errors.map { |message, *details| [ "#{op}: #{message}", *details ] }
+      cdb.query(window_table).validation_errors.map do |error|
+        [ "#{error[:operator]}: #{error[:message]}", *error[:details] ]
       end
     end
 
+    # The annotated statement inside its window operator, when the statement
+    # is a window statement or the scope's window table is a statement. The
+    # window operator has the options of the statement's window and an
+    # annotation hash, which holds only its id. A window table statement is
+    # annotated in place, with the same opts.
+    def with_window(annotated, opts)
+      table = window_table
+      return annotated unless @window_options || table.is_a?(Array)
+
+      options = (@window_options || {}).dup
+      options[:window_table] = cdb.query(table).annotate_without_ids(opts) if table.is_a?(Array)
+      [ "window", annotated, options.merge(annotation: {}) ]
+    end
+
     def extract_statement(stmt, opts)
       if !stmt.is_a?(Array)
         raise "Improper ConceptQL statement: Expected an Array, got a #{stmt.class}"
@@ -254,6 +327,7 @@ module ConceptQL
 
         opts[:scope_opts] = (opts[:scope_opts] || {})
         opts[:scope_opts].merge!(window_opts: stmt.last.merge(cdb: cdb))
+        @window_options = (@window_options || {}).merge(stmt.last)
         extract_statement(stmt[1], opts)
       elsif stmt.length == 1 && stmt.first.is_a?(Array)
         extract_statement(stmt.first, opts)

data/lib/conceptql/scope.rb

@@ -90,7 +90,7 @@ module ConceptQL
     # Query#annotate sets it.
     attr_accessor :one_query_counts
 
-    attr_reader :known_operators, :recall_stack, :recall_dependencies, :annotation, :opts, :query_columns
+    attr_reader :known_operators, :recall_stack, :recall_dependencies, :opts, :query_columns
 
     def initialize(opts = {})
       @known_operators = {}
@@ -98,11 +98,7 @@ module ConceptQL
       @recall_stack = []
       @label_cte_names = {}
       @operator_cte_names = {}.compare_by_identity
-      @annotation = {}
       @opts = opts.dup
-      @annotation[:errors] = @errors = {}
-      @annotation[:warnings] = @warnings = {}
-      @annotation[:counts] = @counts = {}
       @query_columns = DEFAULT_COLUMNS.keys
       @query_columns << :window_id if opts.dig(:window_opts, :window_table)
 
@@ -116,19 +112,6 @@ module ConceptQL
             "You must set the DOCKER_SCRATCH_DATABASE environment variable to the name of the scratch database if using the CONCEPTQL_FORCE_TEMP_TABLES environment variable"
     end
 
-    def add_errors(key, errors)
-      @errors[key] = errors
-    end
-
-    def add_warnings(key, errors)
-      @warnings[key] = errors
-    end
-
-    def add_counts(key, domain, counts)
-      c = @counts[key] ||= {}
-      c[domain] = counts
-    end
-
     # Operator#evaluate records the name of each CTE that holds an operator's
     # rows. An operator evaluated more than once has more than one name.
     def record_cte(op, name)

data/lib/conceptql/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConceptQL
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

data/lib/conceptql/vocabularies/drg_systems.rb

@@ -15,9 +15,9 @@ module ConceptQL
     # whatever the event date. So a statement names the system, and the system
     # decides by the event date. ["ms_drg", "010"] selects the DRG 010 events
     # from 2007-10-01, and ["cms_drg", "010"] selects the DRG 010 events before
-    # that day. The concept-ID lookup is the one that drg uses, so the
-    # operators work with the OHDSI and the GDM lexicons alike. They use no
-    # OHDSI validity date and no concept class to select events.
+    # that day. The concept-ID lookup is the one that drg uses. The
+    # operators use no OHDSI validity date and no concept class to select
+    # events.
     #
     # Each operator is a vocabulary operator of vocabulary DRG. So its code
     # format is the DRG row of vocabulary_formats (a vocabulary operator uses

data/lib/conceptql/vocabularies/dynamic_vocabularies.rb

@@ -3,15 +3,17 @@
 require "csv"
 require_relative "entry"
 require_relative "drg_systems"
+require_relative "read_codes"
 
 module ConceptQL
   module Vocabularies
     class DynamicVocabularies
-      # lexicon: the Lexicon whose vocabularies become operators, normally a
-      # ConceptQL::Database's own (Database#operators passes it). Without one,
-      # only the CSV vocabularies are used.
-      def initialize(lexicon = nil)
-        @lexicon = lexicon
+      # lexicons: the Lexicons whose vocabularies become operators, normally a
+      # ConceptQL::Database's own and its reference lexicon (Database#operators
+      # passes them). A nil one is left out. Without one, only the CSV
+      # vocabularies are used.
+      def initialize(*lexicons)
+        @lexicons = lexicons.compact
       end
 
       # Vocabulary operators for one data model, as name => operator class.
@@ -28,7 +30,8 @@ module ConceptQL
       end
 
       # Every vocabulary entry, as id => Entry, and the entries of ms_drg and
-      # cms_drg, which copy the entry of drg (DrgSystems).
+      # cms_drg, which copy the entry of drg (DrgSystems). The entry of read
+      # gets its preferred name (ReadCodes).
       def all_vocabs
         @all_vocabs ||= begin
           vocabs = each_vocab.each_with_object({}) do |row, h|
@@ -36,13 +39,14 @@ module ConceptQL
             h[entry.id] ||= entry
             h[entry.id] = h[entry.id].merge(entry)
           end
-          vocabs.merge(DrgSystems.entries(vocabs[DrgSystems::DRG_OPERATOR]))
+          vocabs.merge(DrgSystems.entries(vocabs[DrgSystems::DRG_OPERATOR]),
+                       ReadCodes.entries(vocabs[ReadCodes::OPERATOR]))
         end
       end
 
       private
 
-      attr_reader :lexicon
+      attr_reader :lexicons
 
       def each_vocab
         @each_vocab ||= get_all_vocabs
@@ -60,9 +64,10 @@ module ConceptQL
       end
 
       # A Database accepts any object as its lexicon (opts[:lexicon]); one that
-      # keeps no vocabulary list contributes no vocabulary operators.
+      # keeps no vocabulary list contributes no vocabulary operators. A
+      # vocabulary in two lexicons gets one entry (#all_vocabs merges them).
       def lexicon_vocabularies
-        lexicon.respond_to?(:vocabularies) ? lexicon.vocabularies : []
+        lexicons.flat_map { |lexicon| lexicon.respond_to?(:vocabularies) ? lexicon.vocabularies : [] }
       end
     end
   end

data/lib/conceptql/vocabularies/entry.rb

@@ -28,8 +28,8 @@ module ConceptQL
         predominant_domains
       ]
 
-      # A blank domain is no domain (bead conceptql-7azx). The GDM vocabulary
-      # table gives a vocabulary without a domain the domain '', and that
+      # A blank domain is no domain (bead conceptql-7azx). The removed GDM
+      # lexicon gave a vocabulary without a domain the domain '', and that
       # became the criterion_domain of its operators. Without the key, the
       # vocabulary selects condition_occurrence records (predominant_domains),
       # and a merge keeps the other entry's domain.

data/lib/conceptql/vocabularies/read_codes.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../behaviors/labish"
+
+module ConceptQL
+  module Vocabularies
+    # The read operator: the vocabulary operator of the Read vocabulary (NHS UK
+    # Read Codes Version 2), built from its row of config/vocabularies.csv like
+    # every other vocabulary operator (bead conceptql-qdn9). Before, read was
+    # an operator class that wrapped one Vocabulary operator, so it got no
+    # vocabulary check. This module keeps the three things that the row
+    # cannot say: the preferred name READ, read's own description, and the
+    # lab columns (Labish). A Read code can carry a test result, so read
+    # selects the value columns although its domain is condition_occurrence.
+    #
+    # Read codes are case-sensitive: "13g4.00" (Born in Burkina Faso) and
+    # "13G4.00" (Social worker involved) are two codes. Every vocabulary
+    # operator compares codes case-exactly, so a code in another case selects
+    # nothing and is an unknown code.
+    module ReadCodes
+      OPERATOR = "read"
+      PREFERRED_NAME = "READ"
+      DESC = "Selects records based on the Read vocabulary."
+
+      # The entry of read: the entry of the Read vocabulary with the preferred
+      # name READ, as id => Entry. Without a Read entry there is none.
+      def self.entries(read_entry)
+        return {} unless read_entry
+
+        { OPERATOR => read_entry.merge(Entry.new(id: read_entry.omopv5_id, preferred_name: PREFERRED_NAME)) }
+      end
+
+      # The behavior of the read operator class
+      module OperatorBehavior
+        def self.included(base)
+          base.desc DESC
+          base.include ConceptQL::Behaviors::Labish
+        end
+      end
+    end
+  end
+end

data/lib/conceptql/vocabularies/vocabulary_class_factory.rb

@@ -4,6 +4,7 @@ require_relative "../behaviors/drugish"
 require_relative "../behaviors/labish"
 require_relative "behaviors/gdmish"
 require_relative "drg_systems"
+require_relative "read_codes"
 require_relative "../operators/vocabulary"
 
 module ConceptQL
@@ -66,6 +67,8 @@ module ConceptQL
 
           include DrgSystems::OperatorBehavior if DrgSystems.system(entry.id)
 
+          include ReadCodes::OperatorBehavior if entry.id == ReadCodes::OPERATOR
+
           deprecated DrgSystems::DRG_DEPRECATION if entry.id == DrgSystems::DRG_OPERATOR
 
           def vocab_entry

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: conceptql
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Ryan Duryea
@@ -390,6 +390,7 @@ files:
 - docs/spec/examples/union-operator.json
 - docs/spec/examples/vocabulary-operator.json
 - lib/conceptql.rb
+- lib/conceptql/annotation.rb
 - lib/conceptql/behaviors/code_lister.rb
 - lib/conceptql/behaviors/drugish.rb
 - lib/conceptql/behaviors/labish.rb
@@ -423,7 +424,6 @@ files:
 - lib/conceptql/diagram_renderer/svg.rb
 - lib/conceptql/diagram_renderer/tree_layout.rb
 - lib/conceptql/lexicon.rb
-- lib/conceptql/lexicon/lexicon_gdm.rb
 - lib/conceptql/lexicon/lexicon_no_db.rb
 - lib/conceptql/lexicon/lexicon_ohdsi.rb
 - lib/conceptql/lexicon/lexicon_strategy.rb
@@ -468,7 +468,6 @@ files:
 - lib/conceptql/operators/provenance.rb
 - lib/conceptql/operators/provider_filter.rb
 - lib/conceptql/operators/race.rb
-- lib/conceptql/operators/read.rb
 - lib/conceptql/operators/recall.rb
 - lib/conceptql/operators/snf.rb
 - lib/conceptql/operators/sum.rb
@@ -508,6 +507,7 @@ files:
 - lib/conceptql/vocabularies/dynamic_vocabularies.rb
 - lib/conceptql/vocabularies/entry.rb
 - lib/conceptql/vocabularies/formats.rb
+- lib/conceptql/vocabularies/read_codes.rb
 - lib/conceptql/vocabularies/vocabulary_class_factory.rb
 - lib/conceptql/window.rb
 - lib/conceptql/window/base.rb