quality-measure-engine 0.1.2 → 0.2.0

data/lib/qme/importer/generic_importer.rb

@@ -0,0 +1,71 @@
+module QME
+  module Importer
+    # Class that can be used to create a HITSP C32 importer for any quality measure. This class will construct
+    # several SectionImporter for the various sections of the C32. When initialized with a JSON measure definition
+    # it can then be passed a C32 document and will return a Hash with all of the information needed to calculate the measure.
+    class GenericImporter
+
+      @@warnings = {}
+
+      # Creates a generic importer for any quality measure.
+      #
+      # @param [Hash] definition A measure definition described in JSON
+      def initialize(definition)
+        @definition = definition
+      end
+      
+      # Parses a HITSP C32 document and returns a Hash of information related to the measure
+      #
+      # @param [Hash] patient_hash representation of a patient
+      # @return [Hash] measure information
+      def parse(patient_hash)
+        measure_info = {}
+        
+        @definition['measure'].each_pair do |property, description|
+          raise "No standard_category for #{property}" if !description['standard_category']
+          matcher = PropertyMatcher.new(description)
+          entry_list = symbols_for_category(description['standard_category']).map do |section|
+            if patient_hash[section]
+              patient_hash[section]
+            else
+              []
+            end
+          end.flatten
+          if ! entry_list.empty?
+            matched_list = matcher.match(entry_list)
+            measure_info[property]=matched_list if matched_list.length>0
+          end
+        end
+        
+        measure_info
+      end
+      
+      private
+      
+      def symbols_for_category(standard_category)
+        # Currently unsupported categories:
+        # characteristic, substance_allergy, medication_allergy, negation_rationale,
+        # diagnostic_study
+        case standard_category
+        when 'encounter'; [:encounters]
+        when 'procedure'; [:procedures]
+        when 'communication'; [:procedures]
+        when 'laboratory_test'; [:results, :vital_signs]
+        when 'physical_exam'; [:vital_signs]
+        when 'medication'; [:medications]
+        when 'diagnosis_condition_problem'; [:conditions, :social_history]
+        when 'characteristic'; [:conditions, :social_history]
+        when 'device'; [:conditions, :procedures, :care_goals, :medical_equipment]
+        when 'care_goal'; [:care_goals]
+        when 'diagnostic_study'; [:procedures]
+        else
+          if !@@warnings[standard_category]
+            puts "Warning: Unsupported standard_category (#{standard_category})"
+            @@warnings[standard_category]=true
+          end
+          []
+        end
+      end
+    end
+  end
+end

data/lib/qme/importer/hl7_helper.rb

@@ -0,0 +1,27 @@
+module QME
+  module Importer
+    
+    # General helpers for working with HL7 data types
+    class HL7Helper
+      
+      # Converts an HL7 timestamp into an Integer
+      # @param [String] timestamp the HL7 timestamp. Expects YYYYMMDD format
+      # @return [Integer] Date in seconds since the epoch
+      def self.timestamp_to_integer(timestamp)
+        if timestamp && timestamp.length >= 4
+          year = timestamp[0..3].to_i
+          month = timestamp.length >= 6 ? timestamp[4..5].to_i : 1
+          day = timestamp.length >= 8 ? timestamp[6..7].to_i : 1
+          hour = timestamp.length >= 10 ? timestamp[8..9].to_i : 0
+          min = timestamp.length >= 12 ? timestamp[10..11].to_i : 0
+          sec = timestamp.length >= 14 ? timestamp[12..13].to_i : 0
+          
+          Time.gm(year, month, day, hour, min, sec).to_i
+        else
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/qme/importer/patient_importer.rb

@@ -0,0 +1,150 @@
+module QME
+  module Importer
+    
+    # This class is the central location for taking a HITSP C32 XML document and converting it
+    # into the processed form we store in MongoDB. The class does this by running each measure
+    # independently on the XML document
+    #
+    # This class is a Singleton. It should be accessed by calling PatientImporter.instance
+    class PatientImporter
+      include Singleton
+      
+      # Creates a new PatientImporter with the following XPath expressions used to find content in 
+      # a HITSP C32:
+      #
+      # Encounter entries
+      #    //cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.127']/cda:entry/cda:encounter
+      #
+      # Procedure entries
+      #    //cda:procedure[cda:templateId/@root='2.16.840.1.113883.10.20.1.29']
+      #
+      # Result entries
+      #    //cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.15']
+      #
+      # Vital sign entries
+      #    //cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.14']
+      #
+      # Medication entries
+      #    //cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.112']/cda:entry/cda:substanceAdministration
+      #
+      # Codes for medications are found in the substanceAdministration with the following relative XPath
+      #    ./cda:consumable/cda:manufacturedProduct/cda:manufacturedMaterial/cda:code
+      #
+      # Condition entries
+      #    //cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.103']/cda:entry/cda:act/cda:entryRelationship/cda:observation
+      #
+      # Social History entries (non-C32 section, specified in the HL7 CCD)
+      #    //cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.19']
+      #
+      # Care Goal entries(non-C32 section, specified in the HL7 CCD)
+      #    //cda:observation[cda:templateId/@root='2.16.840.1.113883.10.20.1.25']
+      #
+      # Codes for conditions are determined by examining the value child element as opposed to the code child element
+      def initialize
+        @measure_importers = {}
+        
+        @section_importers = {}
+        @section_importers[:encounters] = SectionImporter.new("//cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.127']/cda:entry/cda:encounter")
+        @section_importers[:procedures] = SectionImporter.new("//cda:procedure[cda:templateId/@root='2.16.840.1.113883.10.20.1.29']")
+        @section_importers[:results] = SectionImporter.new("//cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.15']")
+        @section_importers[:vital_signs] = SectionImporter.new("//cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.14']")
+        @section_importers[:medications] = SectionImporter.new("//cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.112']/cda:entry/cda:substanceAdministration",
+                                                               "./cda:consumable/cda:manufacturedProduct/cda:manufacturedMaterial/cda:code")
+
+        @section_importers[:conditions] = SectionImporter.new("//cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.103']/cda:entry/cda:act/cda:entryRelationship/cda:observation",
+                                                              "./cda:value")
+                                                              
+        @section_importers[:social_history] = SectionImporter.new("//cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.19']")
+        @section_importers[:care_goals] = SectionImporter.new("//cda:observation[cda:templateId/@root='2.16.840.1.113883.10.20.1.25']")
+        @section_importers[:medical_equipment] = SectionImporter.new("//cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.128']/cda:entry/cda:supply",
+                                                                     "./cda:participant/cda:participantRole/cda:playingDevice/cda:code")
+      end
+            
+      # Parses a HITSP C32 document and returns a Hash of of the patient.
+      #
+      # @param [Nokogiri::XML::Document] doc It is expected that the root node of this document
+      #        will have the "cda" namespace registered to "urn:hl7-org:v3"
+      # @return [Hash] a representation of the patient that can be inserted into MongoDB
+      def parse_c32(doc)
+        patient_record = {}
+        c32_patient = create_c32_hash(doc)
+        get_demographics(patient_record, doc)
+        process_events(patient_record, c32_patient)
+      end
+      
+      # Parses a patient hash containing demongraphic and event information
+      #
+      # @param [Hash] patient_hash patient data
+      # @return [Hash] a representation of the patient that can be inserted into MongoDB
+      def parse_hash(patient_hash)
+        patient_record = {}
+        patient_record['first'] = patient_hash['first']
+        patient_record['last'] = patient_hash['last']
+        patient_record['gender'] = patient_hash['gender']
+        patient_record['birthdate'] = patient_hash['birthdate']
+        event_hash = {}
+        patient_hash['events'].each do |key, value|
+          event_hash[key.intern] = parse_events(value)
+        end
+        process_events(patient_record, event_hash)
+      end
+      
+      def process_events(patient_record, event_hash)
+        patient_record['measures'] = {}
+        @measure_importers.each_pair do |measure_id, importer|
+          patient_record['measures'][measure_id] = importer.parse(event_hash)
+        end
+        
+        patient_record
+      end
+      
+      # Parses a list of event hashes into an array of Entry objects
+      #
+      # @param [Array] event_list list of event hashes
+      # @return [Array] array of Entry objects
+      def parse_events(event_list)
+        event_list.collect do |event|
+          nil if event.class==String.class # skip
+          QME::Importer::Entry.from_event_hash(event)
+        end.compact
+      end
+      
+      # Adds a measure to run on a C32 that is passed in
+      #
+      # @param [MeasureBase] measure an Class that can extract information from a C32 that is necessary
+      #        to calculate the measure
+      def add_measure(measure_id, importer)
+        @measure_importers[measure_id] = importer
+      end
+      
+      # Create a simple representation of the patient from a HITSP C32
+      #
+      # @param [Nokogiri::XML::Document] doc It is expected that the root node of this document
+      #        will have the "cda" namespace registered to "urn:hl7-org:v3"
+      # @return [Hash] a represnetation of the patient with symbols as keys for each section
+      def create_c32_hash(doc)
+        c32_patient = {}
+        @section_importers.each_pair do |section, importer|
+          c32_patient[section] = importer.create_entries(doc)
+        end
+        
+        c32_patient
+      end
+      
+      # Inspects a C32 document and populates the patient Hash with first name, last name
+      # birth date and gender.
+      #
+      # @param [Hash] patient A hash that is used to represent the patient
+      # @param [Nokogiri::XML::Node] doc The C32 document parsed by Nokogiri
+      def get_demographics(patient, doc)
+        patient['first'] = doc.at_xpath('/cda:ClinicalDocument/cda:recordTarget/cda:patientRole/cda:patient/cda:name/cda:given').text
+        patient['last'] = doc.at_xpath('/cda:ClinicalDocument/cda:recordTarget/cda:patientRole/cda:patient/cda:name/cda:family').text
+        birthdate_in_hl7ts_node = doc.at_xpath('/cda:ClinicalDocument/cda:recordTarget/cda:patientRole/cda:patient/cda:birthTime')
+        birthdate_in_hl7ts = birthdate_in_hl7ts_node['value']
+        patient['birthdate'] = HL7Helper.timestamp_to_integer(birthdate_in_hl7ts)
+        gender_node = doc.at_xpath('/cda:ClinicalDocument/cda:recordTarget/cda:patientRole/cda:patient/cda:administrativeGenderCode')
+        patient['gender'] = gender_node['code']
+      end
+    end
+  end
+end

data/lib/qme/importer/property_matcher.rb

@@ -0,0 +1,103 @@
+module QME
+  module Importer
+    # Compares Entry objects to measure definition properties.
+    class PropertyMatcher
+      
+      def initialize(property_description)
+        @property_description = property_description
+      end
+      
+      # Looks through an Array of Entry objects to see if any of them match the codes needed
+      # for a measure property. Will return different types of Arrays depending on the schema
+      # of the property
+      # @param [Array] entry_list an Array of Entry objects
+      # @return An Array of goodness that is ready to be inserted into a measure property on a patient record
+      def match(entry_list)
+        if is_date_list_property?
+          extract_date_list(entry_list)
+        elsif is_value_date_property?
+          extract_value_date_list(entry_list)
+        elsif is_date_range_property?
+          extract_date_range_list(entry_list)
+        else
+          raise "Unknown property schema for property #{@property_description['description']}"
+        end
+      end
+      
+      # Extracts the dates of any CDA entries that meet the code set defined for measure property.
+      #
+      # @param [Array] entry_list an Array of Entry objects
+      # @return [Array] Provides an Array of dates for entries that have codes inside of the measure code set
+      #         Dates will be represented as an Integer in seconds since the epoch
+      def extract_date_list(entry_list)
+        basic_extractor(entry_list) do |entry, matching_values|
+          matching_values << entry.as_point_in_time
+        end
+      end
+      
+      # Extracts the dates of any CDA entries that meet the code set defined for measure property.
+      #
+      # @param [Array] entry_list an Array of Entry objects
+      # @return [Array] Provides an Array of Hashes for entries that have codes inside of the measure code set
+      #         Hashes will have a "value" and "date" property containing the respective data
+      def extract_value_date_list(entry_list)
+        basic_extractor(entry_list) do |entry, matching_values|
+          if entry.value[:scalar]
+            matching_values << {'date' => entry.as_point_in_time, 'value' => entry.value[:scalar]}
+          end
+        end
+      end
+      
+      # Extracts the dates of any CDA entries that meet the code set defined for measure property.
+      #
+      # @param [Array] entry_list an Array of Entry objects
+      # @return [Array] Provides an Array of Hashes for entries that have codes inside of the measure code set
+      #         Hashes will have a "start" and "end" property containing the respective data
+      def extract_date_range_list(entry_list)
+        basic_extractor(entry_list) do |entry, matching_values|
+          if entry.is_date_range?
+            matching_values << {'start' => entry.start_time, 'end' => entry.end_time}
+          end
+        end
+      end
+      
+      # Determines if the property is a list of dates
+      # @return [Boolean] true of false depending on the property
+      def is_date_list_property?
+        @property_description['type'] == 'array' && @property_description['items']['type'] == 'number'
+      end
+
+      # Determines if the property is a list of date and value hashes
+      # @return [Boolean] true of false depending on the property
+      def is_value_date_property?
+        @property_description['type'] == 'array' && @property_description['items']['type'] == 'object' &&
+        @property_description['items']['properties']['value'] &&
+        @property_description['items']['properties']['date']
+      end
+      
+      # Determines if the property is a list of date ranges represented by a Hash with start and end
+      # keys
+      # @return [Boolean] true of false depending on the property
+      def is_date_range_property?
+        @property_description['type'] == 'array' && @property_description['items']['type'] == 'object' &&
+        @property_description['items']['properties']['start'] &&
+        @property_description['items']['properties']['end']
+      end
+      
+      private
+      
+      def basic_extractor(entry_list)
+        matching_values = []
+        entry_list.each do |entry|
+          if entry.usable?
+            if entry.is_in_code_set?(@property_description['codes'])
+              yield entry, matching_values
+            end
+          end
+        end
+        
+        matching_values
+      end
+    end
+  end
+end

data/lib/qme/importer/section_importer.rb

@@ -0,0 +1,82 @@
+module QME
+  module Importer
+    # Class that can be used to create an importer for a section of a HITSP C32 document. It usually
+    # operates by selecting all CDA entries in a section and then creates entries for them.
+    class SectionImporter
+
+      # Creates a new SectionImporter
+      # @param [String] entry_xpath An XPath expression that can be used to find the desired entries
+      # @param [String] code_xpath XPath expression to find the code element as a child of the desired CDA entry.
+      #        Defaults to "./cda:code"
+      def initialize(entry_xpath, code_xpath="./cda:code")
+        @entry_xpath = entry_xpath
+        @code_xpath = code_xpath
+      end
+      
+      # Traverses that HITSP C32 document passed in using XPath and creates an Array of Entry
+      # objects based on what it finds
+      # @param [Nokogiri::XML::Document] doc It is expected that the root node of this document
+      #        will have the "cda" namespace registered to "urn:hl7-org:v3"
+      #        measure definition
+      # @return [Array] will be a list of Entry objects
+      def create_entries(doc)
+        entry_list = []
+        entry_elements = doc.xpath(@entry_xpath)
+        entry_elements.each do |entry_element|
+          entry = Entry.new
+          extract_codes(entry_element, entry)
+          extract_dates(entry_element, entry)
+          extract_value(entry_element, entry)
+          if entry.usable?
+            entry_list << entry
+          end
+        end
+        
+        entry_list
+      end
+      
+      private
+      
+      def extract_codes(parent_element, entry)
+        code_elements = parent_element.xpath(@code_xpath)
+        code_elements.each do |code_element|
+          add_code_if_present(code_element, entry)
+          
+          translations = code_element.xpath('cda:translation')
+          translations.each do |translation|
+            add_code_if_present(translation, entry)
+          end
+        end
+      end
+      
+      def add_code_if_present(code_element, entry)
+        if code_element['codeSystem'] && code_element['code']
+          entry.add_code(code_element['code'], CodeSystemHelper.code_system_for(code_element['codeSystem']))
+        end
+      end
+      
+      def extract_dates(parent_element, entry)
+        if parent_element.at_xpath('cda:effectiveTime')
+          entry.time = HL7Helper.timestamp_to_integer(parent_element.at_xpath('cda:effectiveTime')['value'])
+        end
+        if parent_element.at_xpath('cda:effectiveTime/cda:low')
+          entry.start_time = HL7Helper.timestamp_to_integer(parent_element.at_xpath('cda:effectiveTime/cda:low')['value'])
+        end
+        if parent_element.at_xpath('cda:effectiveTime/cda:high')
+          entry.end_time = HL7Helper.timestamp_to_integer(parent_element.at_xpath('cda:effectiveTime/cda:high')['value'])
+        end
+      end
+      
+      def extract_value(parent_element, entry)
+        value_element = parent_element.at_xpath('cda:value')
+        if value_element
+          value = value_element['value']
+          unit = value_element['unit']
+          if value
+            entry.set_value(value, unit)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qme/map/map_reduce_builder.rb

@@ -1,169 +1,99 @@
+require 'erb'
+require 'ostruct'
+
 module QME
   module MapReduce
+  
+    # Builds Map and Reduce functions for a particular measure
     class Builder
-      attr_reader :id, :parameters
-
-      YEAR_IN_SECONDS = 365*24*60*60
+      attr_reader :id, :params
 
-      def initialize(measure_def, params)
-        @measure_def = measure_def
-        @id = measure_def['id']
-        @parameters = {}
-        measure_def['parameters'] ||= {}
-        measure_def['parameters'].each do |parameter, value|
-          if !params.has_key?(parameter.intern)
-            raise "No value supplied for measure parameter: #{parameter}"
-          end
-          @parameters[parameter.intern] = params[parameter.intern]
-        end
-        ctx = V8::Context.new
-        ctx['year']=YEAR_IN_SECONDS
-        @parameters.each do |key, param|
-          ctx[key]=param
+      # Utility class used to supply a binding to Erb
+      class Context < OpenStruct
+        # Create a new context
+        # @param [Hash] vars a hash of parameter names (String) and values (Object). Each entry is added as an accessor of the new Context
+        def initialize(db, vars)
+          super(vars)
+          @db = db
         end
-        measure_def['calculated_dates'] ||= {}
-        measure_def['calculated_dates'].each do |parameter, value|
-          @parameters[parameter.intern]=ctx.eval(value)
+      
+        # Get a binding that contains all the instance variables
+        # @return [Binding]
+        def get_binding
+          binding
         end
-        @property_prefix = 'this.measures["'+@id+'"].'
-      end
-
-      def map_function
-        "function () {\n" +
-        "  var value = {i: 0, d: 0, n: 0, e: 0};\n" +
-        "  if #{population} {\n" +
-        "    value.i++;\n" +
-        "    if #{denominator} {\n" +
-        "      value.d++;\n" +
-        "      if #{numerator} {\n" +
-        "        value.n++;\n" +
-        "      } else if #{exception} {\n" +
-        "        value.e++;\n" +
-        "        value.d--;\n" +
-        "      }\n" +
-        "    }\n" +
-        "  }\n" +
-        "  emit(null, value);\n" +
-        "};\n"
-      end
-
-      REDUCE_FUNCTION = <<END_OF_REDUCE_FN
-function (key, values) {
-  var total = {i: 0, d: 0, n: 0, e: 0};
-  for (var i = 0; i < values.length; i++) {
-    total.i += values[i].i;
-    total.d += values[i].d;
-    total.n += values[i].n;
-    total.e += values[i].e;
-  }
-  return total;
-};
-END_OF_REDUCE_FN
-
-      def reduce_function
-        REDUCE_FUNCTION
-      end
-
-      def population
-        javascript(@measure_def['population'])
-      end
-
-      def denominator
-        javascript(@measure_def['denominator'])
-      end
-
-      def numerator
-        javascript(@measure_def['numerator'])
-      end
-
-      def exception
-        javascript(@measure_def['exception'])
-      end
-
-      def javascript(expr)
-        if expr.has_key?('query')
-          # leaf node
-          query = expr['query']
-          triple = leaf_expr(query)
-          property_name = munge_property_name(triple[0])
-          '('+property_name+triple[1]+triple[2]+')'
-        elsif expr.size==1
-          operator = expr.keys[0]
-          result = logical_expr(operator, expr[operator])
-          operator = result.shift
-          js = '('
-          result.each_with_index do |operand,index|
-            if index>0
-              js+=operator
+        
+        # Inserts any library code into the measure JS. JS library code is loaded from
+        # three locations: the js directory of the quality-measure-engine project, the
+        # js sub-directory of the current directory (e.g. measures/js), and the bundles
+        # collection of the current database (used by the Rails Web application).
+        def init_js_frameworks
+          result = ''
+          result << 'if (typeof(map)=="undefined") {'
+          result << "\n"
+          Dir.glob(File.join(File.dirname(__FILE__), '../../../js/*.js')).each do |js_file|
+            result << File.read(js_file)
+            result << "\n"
+          end
+          Dir.glob(File.join('./js/*.js')).each do |js_file|
+            result << File.read(js_file)
+            result << "\n"
+          end
+          @db['bundles'].find.each do |bundle|
+            (bundle['extensions'] || []).each do |ext|
+              result << ext
+              result << "\n"
             end
-            js+=operand
           end
-          js+=')'
-          js
-        elsif expr.size==0
-          '(false)'
-        else
-          throw "Unexpected number of keys in: #{expr}"
+          result << "}\n"
+          result
         end
       end
 
-      def munge_property_name(name)
-        if name=='birthdate'
-          'this.'+name
-        else
-          @property_prefix+name
+      # Create a new Builder
+      # @param [Hash] measure_def a JSON hash of the measure, field values may contain Erb directives to inject the values of supplied parameters into the map function
+      # @param [Hash] params a hash of parameter names (String or Symbol) and their values
+      def initialize(db, measure_def, params)
+        @id = measure_def['id']
+        @params = {}
+        @db = db
+        
+        # normalize parameters hash to accept either symbol or string keys
+        params.each do |name, value|
+          @params[name.to_s] = value
+        end
+        @measure_def = measure_def
+        @measure_def['parameters'] ||= {}
+        @measure_def['parameters'].each do |parameter, value|
+          if !@params.has_key?(parameter)
+            raise "No value supplied for measure parameter: #{parameter}"
+          end
+        end
+        # if the map function is specified then replace any erb templates with their values
+        # taken from the supplied params
+        # always true for actual measures, not always true for unit tests
+        if (@measure_def['map_fn'])
+          template = ERB.new(@measure_def['map_fn'])
+          context = Context.new(@db, @params)
+          @measure_def['map_fn'] = template.result(context.get_binding)
         end
       end
 
-      def logical_expr(operator, args)
-        operands = args.collect { |arg| javascript(arg) }
-        [get_operator(operator)].concat(operands)
+      # Get the map function for the measure
+      # @return [String] the map function
+      def map_function
+        @measure_def['map_fn']
       end
 
-      def leaf_expr(query)
-        property_name = query.keys[0]
-        property_value_expression = query[property_name]
-        if property_value_expression.kind_of?(Hash)
-          operator = property_value_expression.keys[0]
-          value = property_value_expression[operator]
-          [property_name, get_operator(operator), get_value(value)]
-        else
-          [property_name, '==', get_value(property_value_expression)]
-        end
+      # Get the reduce function for the measure, this is a simple
+      # wrapper for the reduce utility function specified in
+      # map-reduce-utils.js
+      # @return [String] the reduce function
+      def reduce_function
+        'function (key, values) { return reduce(key, values);};'
       end
 
-      def get_operator(operator)
-        case operator
-        when '_eql'
-          '=='
-        when '_gt'
-          '>'
-        when '_gte'
-          '>='
-        when '_lt'
-          '<'
-        when '_lte'
-          '<='
-        when 'and'
-          '&&'
-        when 'or'
-          '||'
-        else
-          throw "Unknown operator: #{operator}"
-        end
-      end
 
-      def get_value(value)
-        if value.kind_of?(String) && value[0]=='@'
-          @parameters[value[1..-1].intern].to_s
-        elsif value.kind_of?(String)
-          '"'+value+'"'
-        elsif value==nil
-          'null'
-        else
-          value.to_s
-        end
-      end
     end
   end
 end