caruby-tissue 1.5.6 → 2.1.1

data/lib/catissue/database/annotation/id_generator.rb

@@ -45,7 +45,7 @@ module CaTissue
         
         logger.debug { "Work around caTissue DE EntityManagerUtil bug by fetching the maximum #{table} identifier directly from the database..." }
         sql = TABLE_MAX_ID_SQL_TMPL % table
-        result = @executor.execute { |dbh| dbh.select_one(sql) }
+        result = @executor.query(sql).first
         max = result ? result[0].to_i : 0
         next_id = max + 1
         # End of work-around

data/lib/catissue/database/annotation/integration_service.rb

@@ -35,6 +35,17 @@ module CaTissue
       # Creates an entity map record with content (annotation entity id, annotation id, form context id).
       # This record associates the static hook record to the annotation record qualified by the context.
       #
+      # @quirk caTissue 1.1.2 The caTissue 1.1.2 ClientDemo*.java examples do not set the entity map record
+      #   createdDate. This results in a caTissue 1.1.2 -> 1.2 migration error.
+      #   The entity map record in question is +edu.common.dynamicextensions.domain.integration.EntityMapRecord+.
+      #   However, that class is not referenced in the examples. Rather, the
+      #   referenced class is +deintegration.EntityMapRecord+, which does not have a createdDate property.
+      #   Therefore, there is no caRuby work-around for this caTissue bug. The only recourse is to set
+      #   the created_date SQL column directly to today() prior to performing a 1.1.2-to-1.2 migration.
+      #   1.2 uses a different mechanism, so this bug is specific to 1.1.2, although, of course, this does
+      #   not preclude the possibility of other obscure 1.2-to-2.0 caTissue migration bugs in a similar
+      #   vein.
+      #
       # @param (see #associate)
       # @return [EntityMapRecord] the new entity map record
       def create_entity_map_record(hook, annotation)
@@ -42,14 +53,12 @@ module CaTissue
         emr = EntityMapRecord.new
         emr.static_entity_record_id = hook.identifier
         emr.dynamic_entity_record_id = annotation.identifier
-        
         # the form context
         ctxt = form_context(hook, annotation)
         if ctxt then
           emr.form_context = ctxt
           emr.form_context_id = ctxt.id
         end
-        
         emr
       end
 
@@ -57,7 +66,6 @@ module CaTissue
       # @return [FormContent] an undocumented bit of caTissue presentation flotsam polluting the data layer
       def form_context(hook, annotation)
         map = entity_map(hook, annotation)
-        
         # the fetched form context
         ctxts = map.form_context_collection
         if ctxts.empty? then
@@ -69,7 +77,6 @@ module CaTissue
           ctxt = ctxts.first
           logger.debug { "#{hook} has form context id #{ctxt.id}." }
         end
-        
         ctxt
       end
       

data/lib/catissue/database/annotation/reference_writer.rb

@@ -5,20 +5,20 @@ module CaTissue
     # DYEXT tables of the introspected Java annotation class properties.
     class ReferenceWriter
       # @param [Integer] eid the referencing annotation entity id
-      # @param [CaRuby::Domain::Attribute] attr_md the annotation attribute metadata of the attribute to save
+      # @param [Jinx::Property] prop the annotation attribute metadata of the attribute to save
       # @param [Integer, nil] assn_eid the referenced annotation entity id
-      def initialize(eid, attr_md, assn_eid=nil)
-        logger.debug { "Mapping annotation #{attr_md.declarer.qp}.#{attr_md} role attributes to database columns..." }
+      def initialize(eid, prop, assn_eid=nil)
+        logger.debug { "Mapping annotation #{prop.declarer.qp}.#{prop} role attributes to database columns..." }
         efcd = EntityFacade.instance
         # the referenced annotation entity id
-        assn_eid ||= associated_entity_id(eid, attr_md)
+        assn_eid ||= associated_entity_id(eid, prop)
         # the referenced entity database table
         @table = efcd.annotation_table_for_entity_id(assn_eid)
         # map the attribute => column
-        attr_col_hash = map_attributes(attr_md.type, assn_eid)
-        logger.debug { "Annotation #{attr_md.declarer.qp} #{attr_md} maps to #{@table} as #{attr_col_hash.qp}" }
+        attr_col_hash = map_attributes(prop.type, assn_eid)
+        logger.debug { "Annotation #{prop.declarer.qp} #{prop} reference type #{prop.type.qp} maps to #{@table} as #{attr_col_hash.qp}" }
         # the mapped attributes and columns
-        @attrs, cols = attr_col_hash.to_a.transpose
+        @attributes, cols = attr_col_hash.to_a.transpose
         # the SQL parameters clause
         params = Array.new(cols.size, '?').join(', ')
         # the create SQL
@@ -26,7 +26,7 @@ module CaTissue
         # the update SQL
         @upd_sql = UPDATE_SQL % [@table, cols.map { |col| "#{col} = ?" }.join(', ')]
         # the superclass writer for annotations with superclass DE forms
-        @parent = obtain_parent_writer(eid, attr_md)
+        @parent = obtain_parent_writer(eid, prop)
       end
       
       # @param [Annotation] annotation the referenced annotation value
@@ -37,11 +37,10 @@ module CaTissue
         annotation.identifier ||= next_identifier
         # the values to bind to the SQL parameters
         values = database_parameters(annotation)
-        logger.debug { "Saving #{annotation} to #{@table}..." }
+        logger.debug { "Saving annotation #{annotation} to #{@table}..." }
         # dispatch the SQL update or create statement
-        CaTissue::Database.instance.executor.execute do |dbh|
-          dbh.prepare(sql) { |sth| sth.execute(*values) }
-        end
+        Database.instance.executor.transact(sql, *values)
+        # Save the superclass attributes.
         if @parent then
           logger.debug { "Saving #{annotation} parent entity attributes..." }
           @parent.save(annotation)
@@ -60,53 +59,54 @@ module CaTissue
       # @param (see #initialize)
       # @return [Integer] the entity id for the given attribute role
       # @raise [AnnotationError] if the associated entity was not found
-      def associated_entity_id(eid, attr_md)
-        EntityFacade.instance.associated_entity_id(eid, attr_md.property_descriptor.name) or
-          raise AnnotationError.new("Associated entity not found for entity #{eid} attribute #{attr_md}")
+      def associated_entity_id(eid, prop)
+        EntityFacade.instance.associated_entity_id(eid, prop.property_descriptor.name) or
+          raise AnnotationError.new("Associated entity not found for entity #{eid} attribute #{prop}")
       end      
       
       # @param (see #initialize)
       # @return [Integer, nil] the superclass associated entity id for the given attribute role, or nil if none
-      def obtain_parent_writer(eid, attr_md)
+      def obtain_parent_writer(eid, prop)
         # the superclass entity id for annotations with superclass DE forms
         peid = EntityFacade.instance.parent_entity_id(eid) || return
         # the associated entity id
-        aeid = EntityFacade.instance.associated_entity_id(peid, attr_md.property_descriptor.name)
-        ReferenceWriter.new(peid, attr_md, aeid) if aeid
+        aeid = EntityFacade.instance.associated_entity_id(peid, prop.property_descriptor.name)
+        ReferenceWriter.new(peid, prop, aeid) if aeid
       end
       
       # @param annotation (see #save)
       # @return [Array] the save SQL call parameters 
       def database_parameters(annotation)
-        @attrs.map do |attr|
-          value = annotation.send(attr)
+        @attributes.map do |pa|
+          value = annotation.send(pa)
           Annotation === value ? value.identifier : value
         end
       end
       
       def map_attributes(klass, eid)
-        # the non-domain columns
-        hash = klass.nondomain_attributes.to_compact_hash do |attr|
-          nondomain_attribute_column(klass, attr, eid)
+        # Fill in the attribute => column hash for non-domain attributes.
+        ach = klass.nondomain_attributes.to_compact_hash do |pas|
+          nondomain_attribute_column(klass, pas, eid)
         end
-        # the owner attribute columns
+        # Add the owner attribute => column entries.
         klass.owner_attributes.each do |oattr|
-          hash[oattr] = owner_attribute_column(klass, oattr, eid)
+          ach[oattr] = owner_attribute_column(klass, oattr, eid)
         end
-        hash
+        ach
       end
       
       def nondomain_attribute_column(klass, attribute, eid)
-        if attribute == :identifier then return IDENTIFIER_COL end
-        attr_md = klass.attribute_metadata(attribute)
+        return IDENTIFIER_COL if attribute == :identifier
+        prop = klass.property(attribute)
         # skip an attribute declared by the superclass
-        return unless attr_md.declarer == klass
-        xctr = CaTissue::Database.instance.executor
-        prop = attr_md.property_descriptor.name
+        return unless prop.declarer == klass
+        prop = prop.property_descriptor.name
         logger.debug { "Finding #{klass.qp} #{attribute} column for entity id #{eid} and property #{prop}..." }
-        result = xctr.execute { |dbh| dbh.select_one(NONDOMAIN_COLUMN_SQL, prop, eid) }
+        result = Database.instance.executor.query(NONDOMAIN_COLUMN_SQL, prop, eid).first
         col = result[0] if result
-        if col.nil? then raise AnnotationError.new("Column not found for #{klass.qp} #{attribute}") end
+        if col.nil? then
+          raise AnnotationError.new("Column not found for #{klass.qp} #{attribute}")
+        end
         col
       end
       
@@ -116,22 +116,22 @@ module CaTissue
       # @quirk caTissue The role can be a mutation of the demodulized class name as follows:
       #   * decapitalization, e.g. role +specimenCollectionGroup+ for class +SpecimenCollectionGroup+
       #
-      # @param [AnnotationClass] klass the annotation class
+      # @param [Metadata] klass the annotation class
       # @param [Symbol] attribute the owner attribute
       # @param [Integer] eid the annotation entity id
       # @return [String] the owner reference SQL column name
       def owner_attribute_column(klass, attribute, eid)
         logger.debug { "Finding #{klass.qp} #{attribute} column in the context of entity id #{eid}..." }
         # The referenced class name (confusingly called a source role in the caTissue schema).
-        tgt_nm = klass.attribute_metadata(attribute).type.name.demodulize
-        result = CaTissue::Database.instance.executor.execute { |dbh| dbh.select_one(OWNER_COLUMN_SQL, eid, tgt_nm) }
+        tgt_nm = klass.property(attribute).type.name.demodulize
+        result = Database.instance.executor.query(OWNER_COLUMN_SQL, eid, tgt_nm).first
         col = result[0] if result
         if col.nil? then
-          result = CaTissue::Database.instance.executor.execute { |dbh| dbh.select_one(OWNER_COLUMN_SQL, eid, tgt_nm.decapitalize) }
+          result = Database.instance.executor.query(OWNER_COLUMN_SQL, eid, tgt_nm.decapitalize).first
           col = result[0] if result
         end
         if col.nil? then
-          result = CaTissue::Database.instance.executor.execute { |dbh| dbh.select_one(ALT_1_1_OWNER_COLUMN_SQL, eid) }
+          result = Database.instance.executor.query(ALT_1_1_OWNER_COLUMN_SQL, eid).first
           col = result[0] if result
         end
         if col.nil? then raise AnnotationError.new("Column not found for #{klass.qp} owner attribute #{attribute}") end

data/lib/catissue/database/controlled_value_finder.rb

@@ -1,43 +1,28 @@
-require 'caruby/util/log'
 require 'catissue/database/controlled_values'
 
 module CaTissue
+  class ControlledValueError < RuntimeError; end
+  
   # Finds attribute controlled values.
   class ControlledValueFinder
     # Creates a new ControlledValueFinder for the given attribute.
     # The optional YAML properties file name maps input values to controlled values.
-    def initialize(attribute, file=nil)
+    #
+    # @param [Symbol] attribute the CV attribute
+    def initialize(attribute)
       @attribute = attribute
-      @remap_hash = load_controlled_value_hash(file)
     end
 
-    # Returns the CV value for the given source value.
-    # If the value is remapped, then that value is returned.
-    # Otherwise, if the value is a standard CV, then the CV value is returned.
-    # Otherwise, a warning message is printed to the log and this method returns nil.
+    # Returns the CV value for the given source value. A case-insensitive lookup
+    # is performed on the CV.
+    #
+    # @param [String, nil] value the CV string value to find
+    # @raise [ControlledValueError] if the CV was not found
+    # @see ControlledValues#find
     def controlled_value(value)
       return if value.blank?
-      remapped = remapped_controlled_value(value)
-      return remapped if remapped
-      cv = supported_controlled_value(value)
-      logger.warn("#{@attribute} value '#{value}' ignored since it is not a recognized controlled value.") if cv.nil?
-      cv.value if cv
-    end
-
-    private
-
-    def remapped_controlled_value(value)
-      @remap_hash[value]
-    end
-
-    def supported_controlled_value(value)
-      ControlledValues.instance.find(@attribute, value)
-    end
-
-    def load_controlled_value_hash(file)
-      return {} unless file and File.exists?(file)
-      logger.debug { "Loading controlled value map for #{@attribute} from #{file}..." }
-      YAML::load_file(file)
+      ControlledValues.instance.find(@attribute, value) or
+        raise ControlledValueError.new("#{@attribute} value '#{value}' is not a recognized controlled value.")
     end
   end
 end

data/lib/catissue/database/controlled_values.rb

@@ -1,25 +1,26 @@
 require 'singleton'
-require 'caruby/util/log'
-require 'caruby/util/collection'
-require 'caruby/util/options'
-require 'caruby/util/visitor'
-require 'catissue/resource'
+require 'jinx/helpers/collections'
+require 'jinx/helpers/lazy_hash'
+require 'jinx/helpers/case_insensitive_hash'
+require 'jinx/helpers/options'
+require 'jinx/helpers/visitor'
 require 'catissue/database'
-require 'catissue/util/controlled_value'
-require 'caruby/domain/properties'
+require 'catissue/helpers/controlled_value'
 
 module CaTissue
   # This ControlledValues class loads caTissue permissible values from the database.
-  # Use of this class requires the +dbi+ gem. See {CaRuby::SQLExecutor#initialize}
+  # Use of this class requires the +dbi+ gem. See +CaRuby::SQLExecutor.initialize+
   # for a description of the database access properties.
   class ControlledValues
     include Singleton
 
     def initialize
-      @executor = CaTissue::Database.instance.executor
-      @pid_loaded_hash = LazyHash.new { |pid| load_pid_cvs(pid) }
-      @pid_value_cv_hash = LazyHash.new do |pid|
-        CaseInsensitiveHash.new { |hash, value| hash[value] = load_cv(pid, value) unless value.nil? }
+      @executor = Database.instance.executor
+      # The pid => { value => CV } that associates each loaded parent CV to its children.
+      @pid_loaded_hash = Jinx::LazyHash.new { |pid| load_pid_cvs(pid) }
+      # The pid => { value => CV } that associates each fetched parent CV to its children.
+      @pid_value_cv_hash = Jinx::LazyHash.new do |pid|
+        Jinx::CaseInsensitiveHash.new { |hash, value| hash[value] = load_cv(pid, value) unless value.nil? }
       end
     end
 
@@ -27,37 +28,48 @@ module CaTissue
     # The CVs are loaded from the database if necessary.
     #
     # The following public id aliases are supported:
-    # * :tissue_site
-    # * :clinical_diagnosis
+    # * +:tissue_site+
+    # * +:clinical_diagnosis+
     #
-    #@param [String,Symbol] public_id_or_alias the caTissue public id or an alias defined above
-    # @return [<ControlledValue>] instances for the given public_id_or_alias
+    # @param [String, Symbol] public_id_or_alias the caTissue public id or an alias defined above
+    # @return [<CaRuby::ControlledValue>] instances for the given public_id_or_alias
     def for_public_id(public_id_or_alias)
       pid = ControlledValue.standard_public_id(public_id_or_alias)
       @pid_loaded_hash[pid].values
     end
 
-    # Returns the ControlledValue with the given public_id_or_alias and value.
-    # Loads the CV if necessary from the database. The loaded CV does not have a parent or children.
+    # Returns the CV with the given public_id_or_alias and value. Loads the CV if necessary
+    # from the database. The loaded CV does not have a parent or children.
     #
-    #@param [String,Symbol] public_id_or_alias the supported for_public_id alias
-    # @see #for_public_id load the CV hierarchy with supported aliases
-    def find(public_id_or_alias, value)
+    # @param [String, Symbol] public_id_or_alias the caTissue public id or alias
+    # @param [String] value the CV value
+    # @param [Boolean] recursive whether to load the CV children as well.
+    # @return [CaRuby::ControlledValue, nil] the matching CV, or nil if no match
+    def find(public_id_or_alias, value, recursive=false)
       pid = ControlledValue.standard_public_id(public_id_or_alias)
-      @pid_value_cv_hash[pid][value]
+      value_cv_hash = @pid_value_cv_hash[pid]
+      cv = value_cv_hash[value]
+      if recursive then
+        fetch_descendants(cv, value_cv_hash)
+      end
+      cv
     end
 
     # Creates a new controlled value record in the database from the given ControlledValue cv.
     # The default identifier is the next identifier in the permissible values table.
     #
     # @param [ControlledValue] cv the controlled value to create
-    # @return cv
+    # @return [ControlledValue] the created CV
     def create(cv)
+      if cv.public_id.nil? then
+        raise ArgumentError.new("Controlled value create is missing a public id")
+      end
+      if cv.value.nil? then
+        raise ArgumentError.new("Controlled value create is missing a value")
+      end
       cv.identifier ||= next_id
-      raise ArgumentError.new("Controlled value create is missing a public id") if cv.public_id.nil?
-      raise ArgumentError.new("Controlled value create is missing a value") if cv.value.nil?
       logger.debug { "Creating controlled value #{cv} in the database..." }
-      @executor.execute { |dbh| dbh.prepare(INSERT_STMT).execute(cv.identifier, cv.parent_identifier, cv.public_id, cv.value) }
+      @executor.transact(INSERT_STMT, cv.identifier, cv.parent_identifier, cv.public_id, cv.value)
       logger.debug { "Controlled value #{cv.public_id} #{cv.value} created with identifier #{cv.identifier}" }
       @pid_value_cv_hash[cv.public_id][cv.value] = cv
     end
@@ -67,12 +79,16 @@ module CaTissue
     #
     # @param [ControlledValue] cv the controlled value to delete
     def delete(cv)
-      @executor.execute { |dbh| delete_recursive(cv, dbh.prepare(DELETE_STMT)) }
+      @executor.transact do |dbh|
+        sth = dbh.prepare(DELETE_STMT)
+        delete_recursive(cv, sth)
+        sth.finish
+      end
     end
 
     private
 
-    PUBLIC_ID_ROOTS_STMT = "select identifier, value from catissue_permissible_value where public_id = ? and parent_identifier is null or parent_identifier = 0"
+    PID_ROOTS_STMT = "select identifier, value from catissue_permissible_value where public_id = ? and (parent_identifier is null or parent_identifier = 0)"
 
     CHILDREN_STMT = "select identifier, value from catissue_permissible_value where parent_identifier = ?"
 
@@ -90,7 +106,7 @@ module CaTissue
 
     def load_cv(public_id, value)
       logger.debug { "Loading controlled value #{public_id} #{value} from the database..." }
-      row = @executor.execute { |dbh| dbh.select_one(SEARCH_STMT, value) }
+      row = @executor.query(SEARCH_STMT, value).first
       logger.debug { "Controlled value #{public_id} #{value} not found." } and return if row.nil?
       identifier = row[0]
       logger.debug { "Controlled value #{public_id} #{value} loaded with identifier #{identifier}." }
@@ -98,7 +114,7 @@ module CaTissue
     end
 
     def next_id
-      @executor.execute { |dbh| dbh.select_one(MAX_ID_STMT)[0].to_i } + 1
+      @executor.query(MAX_ID_STMT).first[0].to_i + 1
     end
 
     def delete_recursive(cv, sth)
@@ -111,29 +127,41 @@ module CaTissue
       logger.debug { "Controlled value #{cv} deleted." }
     end
 
+    # @param [String] pid the public id to find
+    # @param [String => CaRuby::ControlledValue] the pid children value => CV hash
     def fetch_cvs_with_public_id(pid, value_cv_hash)
-      id_cv_hash = {}
       logger.debug { "Loading #{pid} controlled values from the database..." }
-      cvs = []
-      @executor.execute do |dbh|
-        dbh.select_all(PUBLIC_ID_ROOTS_STMT, pid) do |row|
-          identifier, value = row
-          cvs << value_cv_hash[value] ||= make_controlled_value(:identifier => identifier, :public_id => pid, :value => value)
-        end
-        # load the root CVs children
-        cvs.each { |cv| fetch_descendants(cv, dbh, value_cv_hash) }
+      cvs = @executor.query(PID_ROOTS_STMT, pid).map do |row|
+        identifier, value = row
+        cv = make_controlled_value(:identifier => identifier, :public_id => pid, :value => value)
+        value_cv_hash[value] ||= cv
+        cv
       end
+      cvs.each { |cv| fetch_descendants(cv, value_cv_hash) }
+      logger.debug { "Loaded #{value_cv_hash.size} #{pid} controlled values from the database." }
       value_cv_hash
     end
 
-    def fetch_descendants(cv, dbh, value_cv_hash)
-      children = []
-      dbh.select_all(CHILDREN_STMT, cv.identifier) do |row|
-         identifier, value = row
-         children << value_cv_hash[value] = make_controlled_value(:identifier => identifier, :public_id => pid, :parent => cv, :value => value)
+    def fetch_descendants(cv, value_cv_hash)
+      logger.debug { "Fetching #{cv} descendants..." }
+      # load the root CVs children
+      @executor.execute do |dbh|
+        sth = dbh.prepare(CHILDREN_STMT)
+        fetch_descendants_recursive(cv, value_cv_hash, sth)
+        sth.finish
+      end
+    end
+
+    def fetch_descendants_recursive(cv, value_cv_hash, sth)
+      pid = cv.public_id
+      # Collect the child CVs.
+      children = sth.execute(cv.identifier).map do |row|
+        identifier, value = row
+        child = make_controlled_value(:identifier => identifier, :public_id => pid, :parent => cv, :value => value)
+        value_cv_hash[value] = child
       end
       # recurse to chidren
-      children.each { |cv| fetch_descendants(cv, dbh, value_cv_hash) }
+      children.each { |cv| fetch_descendants_recursive(cv, value_cv_hash, sth) }
     end
     
     # Returns a new ControlledValue with attributes set by the given attribute => value hash.