marty 1.2.4 → 1.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a63225a41641bfe7a573dd21373cef1746df111
-  data.tar.gz: 46359fc851683968330d72b02a5695072ea81eec
+  metadata.gz: 7de135b5a4bf224982326860d6741402abea2d23
+  data.tar.gz: c24dfff6a7c31694b37ef0e6f0d0cae4ef843db3
 SHA512:
-  metadata.gz: 456016ef7f36a7474dcf5ce564b5616c2616525701db782a6f6582e9e3d638627b41c027838c603c89bec34f723ccac9b7cc94a6e59768a8c24b762d62efa27a
-  data.tar.gz: d1ba3c2c1366c034d76629ab4643a85ffd11d2d06400111fb30f33cf974a9b6ff6c8d43a55dda9bee7a964fd3a684c4e33b1aa14c50aeac477e745d1597c0ba4
+  metadata.gz: 8a2649e6ea371e5dccc52aaa50ae0f9db245657f2ad0dc56ee65c8a7d1a823af0f2c97272dce953486f69a95420abe0e6ec5e42ab7604e57507e30f544202ffc
+  data.tar.gz: 298317fcd41ef5fee4d9687439a56e19c7f31ffe5cffbc55b4256f7f2adc2dcf67c558866d5a41cb69eb21969129f4fcf57047545dd383d96f5463d474be30dc

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    marty (1.2.3)
+    marty (1.2.5)
       axlsx (= 2.1.0pre)
       coderay
       delorean_lang (~> 0.3.33)
@@ -83,7 +83,7 @@ GEM
     delayed_job_active_record (4.1.2)
       activerecord (>= 3.0, < 5.2)
       delayed_job (>= 3.0, < 5)
-    delorean_lang (0.3.34)
+    delorean_lang (0.3.36)
       activerecord (>= 3.2)
       treetop (~> 1.5)
     diff-lcs (1.3)

data/app/models/marty/data_grid.rb

@@ -89,6 +89,13 @@ class Marty::DataGrid < Marty::Base
   gen_mcfly_lookup :lookup, [:name], cache: true
   gen_mcfly_lookup :get_all, [], mode: nil
 
+  cached_delorean_fn :lookup_h, sig: [2,3] do
+    |pt, name, fields = %w(id group_id created_dt metadata data_type)|
+
+    dga = get_all(pt).where(name: name).pluck(*fields).first
+    dga && Hash[fields.zip(dga)]
+  end
+
   cached_mcfly_lookup :lookup_id, sig: 2 do
     |pt, group_id|
     find_by_group_id group_id
@@ -157,15 +164,18 @@ class Marty::DataGrid < Marty::Base
 
   PLV_DT_FMT = "%Y-%m-%d %H:%M:%S.%N6"
 
-  def plv_lookup_grid_distinct(h_passed, ret_grid_data=false, distinct=true)
+  def self.plv_lookup_grid_distinct(h_passed, dgh, ret_grid_data=false,
+                                    distinct=true)
+    cd = dgh["created_dt"]
+    @@dtcache ||= {}
+    @@dtcache[cd] ||= cd.strftime(PLV_DT_FMT)
     row_info = {
-      "id"         => id,
-      "group_id"   => group_id,
-      "created_dt" => (
-        @@dtcache ||= {})[created_dt] ||= created_dt.strftime(PLV_DT_FMT)
+      "id"         => dgh["id"],
+      "group_id"   => dgh["group_id"],
+      "created_dt" => @@dtcache[cd]
     }
 
-    h = metadata.each_with_object({}) do |m, h|
+    h = dgh["metadata"].each_with_object({}) do |m, h|
       attr = m["attr"]
       inc = h_passed.fetch(attr, :__nf__)
       next if inc == :__nf__
@@ -196,7 +206,8 @@ class Marty::DataGrid < Marty::Base
     end
 
     if ret_grid_data
-      md, mmd = modify_grid(h_passed)
+      dg = find(dgh["id"])
+      md, mmd = modify_grid(h_passed, dg.metadata, dg.data)
       res["data"] = md
       res["metadata"] = mmd
     end
@@ -206,12 +217,26 @@ class Marty::DataGrid < Marty::Base
   # FIXME: added for Apollo -- not sure where this belongs given that
   # DGs were moved to marty.  Should add documentation about callers
   # keeping the hash small.
+  # DEPRECATED: should use lookup_grid_h instead
   cached_delorean_fn :lookup_grid, sig: 4 do
     |pt, dg, h, distinct|
     raise "bad DataGrid #{dg}" unless Marty::DataGrid === dg
     raise "non-hash arg #{h}" unless Hash === h
 
-    res = dg.plv_lookup_grid_distinct(h, false, distinct)
+    warn "DEPRECATED: lookup_grid. Use lookup_grid_h instead"
+
+    dgh = dg.attributes.slice("id","group_id","created_dt",
+                              "metadata", "data_type")
+    res = plv_lookup_grid_distinct(h, dgh, false, distinct)
+    res["result"]
+  end
+
+  cached_delorean_fn :lookup_grid_h, sig: 4 do
+    |pt, dgh, h, distinct|
+    raise "bad DataGrid #{dgh}" unless Hash === dgh
+    raise "non-hash arg #{h}" unless Hash === h
+
+    res = plv_lookup_grid_distinct(h, dgh, false, distinct)
     res["result"]
   end
 
@@ -227,8 +252,8 @@ class Marty::DataGrid < Marty::Base
     end
   end
 
-  def lookup_grid_distinct_entry(pt, h, visited=nil, follow=true,
-                                 return_grid_data=false)
+  delorean_fn :lookup_grid_distinct_entry_h, sig: [3,6] do
+    |pt, h, dgh, visited=nil, follow=true, return_grid_data=false|
 
     # Perform grid lookup, if result is another data_grid, and follow is true,
     # then perform lookup on the resulting grid.  Allows grids to be nested
@@ -240,33 +265,50 @@ class Marty::DataGrid < Marty::Base
     #   "name"     => <grid name>
     #   "data"     => <grid's data array>
     #   "metadata" => <grid's metadata (array of hashes)>
+    vhash = plv_lookup_grid_distinct(h, dgh, return_grid_data)
 
-    vhash = plv_lookup_grid_distinct(h, return_grid_data)
-
-    return vhash if vhash["result"].nil? || !data_type
+    next vhash if vhash["result"].nil? || !dgh['data_type']
 
-    c_data_type = Marty::DataGrid.convert_data_type(data_type)
+    c_data_type = Marty::DataGrid.convert_data_type(dgh['data_type'])
 
-    return vhash if String === c_data_type
+    next vhash if String === c_data_type
 
     res = vhash["result"]
 
-    v =  Marty::PgEnum === res ?
-      c_data_type.find_by_name(res) :
-      Marty::DataConversion.find_row(c_data_type, {"name" => res}, pt)
+    v =  case
+             when Marty::PgEnum === res
+               c_data_type.find_by_name(res)
+             when Marty::DataGrid == c_data_type
+               follow ?
+                 Marty::DataGrid.lookup_h(pt, res) :
+                 Marty::DataGrid.lookup(pt, res)
+             else
+               Marty::DataConversion.find_row(c_data_type, {"name" => res}, pt)
+         end
 
-    return vhash.merge({"result" => v}) unless (Marty::DataGrid === v && follow)
+    next vhash.merge({"result" => v}) unless (Marty::DataGrid == c_data_type &&
+                                              follow)
 
     visited ||= []
 
-    visited << self.group_id
+    visited << dgh['group_id']
 
     raise "#{self.class} recursion loop detected -- #{visited}" if
-      visited.member?(v.group_id)
+      visited.member?(v['group_id'])
 
-    v.lookup_grid_distinct_entry(pt, h, visited, follow, return_grid_data)
+    lookup_grid_distinct_entry_h(pt, h, v, visited, follow, return_grid_data)
   end
 
+  # DEPRECATED: use lookup_grid_distinct_entry_h instead
+  def lookup_grid_distinct_entry(pt, h, visited=nil, follow=true,
+                                 return_grid_data=false)
+    warn "DEPRECATED: instance method lookup_grid_distinct_entry. "\
+         "Use class method lookup_grid_distinct_entry_h instead"
+    dgh = self.attributes.slice("id","group_id","created_dt",
+                              "metadata", "data_type")
+    self.class.lookup_grid_distinct_entry_h(pt, h, dgh, visited, follow,
+                                            return_grid_data)
+  end
   delorean_instance_method :lookup_grid_distinct_entry,
                            [[Date, Time, ActiveSupport::TimeWithZone], Hash]
 
@@ -580,7 +622,7 @@ class Marty::DataGrid < Marty::Base
     end
   end
 
-  def modify_grid(params)
+  def self.modify_grid(params, metadata, data)
     removes = ["h", "v"].each_with_object({}) {|dir, hash| hash[dir] = Set.new}
 
     metadata_copy, data_copy = metadata.deep_dup, data.deep_dup
@@ -627,13 +669,13 @@ class Marty::DataGrid < Marty::Base
   end
 
   private
-  def remove_indices(orig_array, inds)
+  def self.remove_indices(orig_array, inds)
     orig_array.each_with_object([]).with_index do |(item, new_array), index|
       new_array.push(item) unless inds.include?(index)
     end
   end
 
-  def opposite_sign(op)  # toggle sign and inclusivity
+  def self.opposite_sign(op)  # toggle sign and inclusivity
     {
       :<  => :>=,
       :<= => :>,
@@ -642,7 +684,7 @@ class Marty::DataGrid < Marty::Base
     }[op]
   end
 
-  def compute_numeric_mods(keys, op, val)
+  def self.compute_numeric_mods(keys, op, val)
     @keyhash ||= {}
     prune_a, rewrite_a = [], []
 
@@ -695,7 +737,7 @@ class Marty::DataGrid < Marty::Base
   end
 
   # value is a list of what to keep
-  def compute_set_mods(keys, val)
+  def self.compute_set_mods(keys, val)
     prune_a, rewrite_a, value = [], [], Array(val)
 
     keys.each_with_index do |key, index|
@@ -718,7 +760,7 @@ class Marty::DataGrid < Marty::Base
     [prune_a, rewrite_a]
   end
 
-  def parse_range(key)
+  def self.parse_range(key)
     match = key.match(/\A(\[|\()([0-9\.-]*),([0-9\.-]*)(\]|\))\z/)
     raise "unrecognized pattern #{key}" unless match
 
@@ -730,7 +772,7 @@ class Marty::DataGrid < Marty::Base
     [lboundary == '(' ? :> : :>=, lhv, rhv, rboundary == ')' ? :< : :<=]
   end
 
-  def rewrite_range(lb, lhv, rhv, rb)
+  def self.rewrite_range(lb, lhv, rhv, rb)
     lboundary = lb == :> ? '(' : '['
 
     # even though numranges are float type, we don't want to output ".0"
@@ -742,7 +784,7 @@ class Marty::DataGrid < Marty::Base
     lboundary + lvalue + ',' + rvalue + rboundary
   end
 
-  def parse_bounds(key)
+  def self.parse_bounds(key)
     match = key.match(/\A *(<|>|<=|>=)? *([a-z_]+) *\z/)
     raise "unrecognized pattern #{key}" unless match
 

data/app/models/marty/delorean_rule.rb

@@ -100,8 +100,9 @@ class Marty::DeloreanRule < Marty::BaseRule
       grid_results = grids.each_with_object({}) do |(gvar, gname), h|
         usename = eclass.grid_final_name(gvar)
         next h[usename] = gres[gname] if gres[gname]
-        dg = Marty::DataGrid.lookup(pt,gname)
-        dgr = dg && dg.lookup_grid_distinct_entry(pt, dgparams)
+        dg = Marty::DataGrid.lookup_h(pt,gname)
+        dgr = dg && Marty::DataGrid.lookup_grid_distinct_entry_h(pt, dgparams,
+                                                                 dg)
         h[usename] = gres[gname] = dgr["result"] if dgr
       end
     end

data/app/models/marty/script.rb

@@ -141,8 +141,10 @@ class Marty::Script < Marty::Base
 
     engine = Marty::ScriptSet.new(tag).get_engine(script)
     # IMPORTANT: engine evals (e.g. eval_to_hash) modify the
-    # params. So, need to clone it.
-    engine.evaluate(node, attr, params.clone)
+    # params, but it is possible that we may be passing in
+    # a frozen hash. To avoid performance impacts, we should first check if
+    # params is frozen to decide whether to dup (frozen) or clone (not frozen).
+    engine.evaluate(node, attr, params.frozen? ? params.dup : params.clone)
   end
 
   delorean_fn :pretty_print, sig: 1 do

data/lib/marty/rule_script_set.rb

@@ -49,12 +49,12 @@ class Marty::RuleScriptSet < Delorean::AbstractContainer
     else
       h[dgid] = dgname
       h["#{dgid}_dg__"] = <<~EOS
-      Marty::DataGrid.lookup(pt,#{dgid}) ||
+      Marty::DataGrid.lookup_h(pt,#{dgid}) ||
         ERR("grid '#{dgid}' ('%s') not found" % #{dgid})
       EOS
       h["#{dgid}_dgp__"] = "dgparams__ + \n" + self.class.indent(paramify_h(h))
-      lgde = "lookup_grid_distinct_entry"
-      h["#{dgid}_h__"] = "#{dgid}_dg__.#{lgde}(pt,#{dgid}_dgp__)"
+      lgde = "lookup_grid_distinct_entry_h"
+      h["#{dgid}_h__"] = "Marty::DataGrid.#{lgde}(pt,#{dgid}_dgp__,#{dgid}_dg__)"
       h[final_name] = "#{dgid}_h__ && #{dgid}_h__.result"
       cache[dgname] = final_name
     end

data/lib/marty/version.rb

@@ -1,3 +1,3 @@
 module Marty
-  VERSION = "1.2.4"
+  VERSION = "1.2.5"
 end

data/other/marty/diagnostic/aws/ec2_instance.rb

@@ -20,7 +20,6 @@ class Marty::Diagnostic::Aws::Ec2Instance
     @nodes   = get_private_ips
   end
 
-  private
   def self.get url
     uri = URI.parse(url)
     request = Net::HTTP.new(uri.host, uri.port)
@@ -90,11 +89,21 @@ class Marty::Diagnostic::Aws::Ec2Instance
   end
 
   def get_private_ips
-    get_instances['reservationSet']['item'].map{
-      |i|
-      item = i['instancesSet']['item']
-      item.is_a?(Array) ? item.map{|i| i['privateIpAddress']} :
-        item['privateIpAddress']
-    }.flatten
+    begin
+      reservation_set_item = get_instances['reservationSet']['item']
+      reservation_set_item = [reservation_set_item] unless
+        reservation_set_item.is_a?(Array)
+
+      reservation_set_item.map{
+        |i|
+        instances_set_item = i['instancesSet']['item']
+        instances_set_item = [instances_set_item] unless
+          instances_set_item.is_a?(Array)
+
+        instances_set_item.map{|j| j['privateIpAddress']}
+      }.flatten
+    rescue => e
+      raise "Unexpected result came back from AWS. Error: (#{e.message})"
+    end
   end
 end

data/spec/models/data_grid_spec.rb

@@ -177,8 +177,8 @@ EOS
     end
 
     def lookup_grid_helper(pt, gridname, params, follow=false)
-      dg=Marty::DataGrid.lookup(pt, gridname)
-      res=dg.lookup_grid_distinct_entry(pt, params, nil, follow)
+      dgh=Marty::DataGrid.lookup_h(pt, gridname)
+      res=Marty::DataGrid.lookup_grid_distinct_entry_h(pt, params, dgh, nil, follow)
       [res["result"], res["name"]]
     end
 
@@ -294,80 +294,80 @@ EOS
       end
 
       context "should handle NULL key values" do
-        let(:dg) { Marty::DataGrid.lookup(pt, "Gf") }
+        let(:dgh) { Marty::DataGrid.lookup_h(pt, "Gf") }
 
         it 'true returns Y' do
-          res = Marty::DataGrid.lookup_grid(pt, dg, {"b"=>true}, false)
+          res = Marty::DataGrid.lookup_grid_h(pt, dgh, {"b"=>true}, false)
           expect(res).to eq('Y')
         end
 
         it '13 returns N' do
-          res = Marty::DataGrid.lookup_grid(pt, dg, {"i"=>13}, true)
+          res = Marty::DataGrid.lookup_grid_h(pt, dgh, {"i"=>13}, true)
           expect(res).to eq('N')
         end
 
         it '13 & numrange 0 returns nil' do
-          res = Marty::DataGrid.lookup_grid(pt, dg, {"i"=>13, "n"=>0}, true)
+          res = Marty::DataGrid.lookup_grid_h(pt, dgh, {"i"=>13, "n"=>0}, true)
           expect(res).to eq('N')
         end
 
         it '13 & int4range 15 returns N' do
-          res = Marty::DataGrid.lookup_grid(pt, dg, {"i"=>13, "i4"=>15}, true)
+          res = Marty::DataGrid.lookup_grid_h(pt, dgh, {"i"=>13, "i4"=>15}, true)
           expect(res).to eq('N')
         end
 
         it '13 & int4range 1 returns nil' do
-          res = Marty::DataGrid.lookup_grid(pt, dg, {"i"=>13, "i4"=>1}, true)
+          res = Marty::DataGrid.lookup_grid_h(pt, dgh, {"i"=>13, "i4"=>1}, true)
           expect(res).to be_nil
         end
 
         it 'false, 3, numrange 15 returns N' do
           res = Marty::DataGrid.
-                lookup_grid(pt, dg, {"b"=>false, "i"=>3, "n"=>15}, true)
+                lookup_grid_h(pt, dgh, {"b"=>false, "i"=>3, "n"=>15}, true)
           expect(res).to eq('N')
         end
 
         it '13, numrange 15 returns N' do
-          res = Marty::DataGrid.lookup_grid(pt, dg, {"i"=>13, "n"=>15}, true)
+          res = Marty::DataGrid.lookup_grid_h(pt, dgh, {"i"=>13, "n"=>15}, true)
           expect(res).to eq('N')
         end
       end
 
       it "should handle ambiguous lookups" do
-        dg = Marty::DataGrid.lookup(pt, "Gh")
+        dgh = Marty::DataGrid.lookup_h(pt, "Gh")
 
         h1 = {
           "property_state" => "NY",
           "county_name"    => "R",
         }
 
-        res = Marty::DataGrid.lookup_grid(pt, dg, h1, false)
+        res = Marty::DataGrid.lookup_grid_h(pt, dgh, h1, false)
         expect(res).to eq(10)
       end
 
       it "should handle ambiguous lookups (2)" do
-        dg = Marty::DataGrid.lookup(pt, "Gg")
+        dgh = Marty::DataGrid.lookup_h(pt, "Gg")
         res = Marty::DataGrid.
-              lookup_grid(pt, dg, {"i1"=>2, "i2"=>1}, false)
+              lookup_grid_h(pt, dgh, {"i1"=>2, "i2"=>1}, false)
         expect(res).to eq(1)
 
         res = Marty::DataGrid.
-              lookup_grid(pt, dg, {"i1"=>3, "i2"=>1}, false)
+              lookup_grid_h(pt, dgh, {"i1"=>3, "i2"=>1}, false)
         expect(res).to eq(1)
 
         res = Marty::DataGrid.
-              lookup_grid(pt, dg, {"i1"=>2, "i2"=>3}, false)
+              lookup_grid_h(pt, dgh, {"i1"=>2, "i2"=>3}, false)
         expect(res).to eq(20)
       end
 
       it "should handle non-distinct lookups" do
-        dg = Marty::DataGrid.lookup(pt, "Ge")
-        res = Marty::DataGrid.lookup_grid(pt, dg, {"ltv"=>500}, false)
+        dgh = Marty::DataGrid.lookup_h(pt, "Ge")
+        res = Marty::DataGrid.lookup_grid_h(pt, dgh, {"ltv"=>500}, false)
 
         expect(res).to eq(1.1)
 
         expect {
-          Marty::DataGrid.lookup_grid(pt, dg, {"ltv"=>500}, true)
+          Marty::DataGrid.lookup_grid_h(pt, dgh, {"ltv"=>500}, true)
         }.to raise_error(RuntimeError)
       end
 
@@ -376,14 +376,14 @@ EOS
           "client_id" => 700127,
           "property_state" => "CA",
         }
-        dg = Marty::DataGrid.lookup(pt, "Gj")
-        res = Marty::DataGrid.lookup_grid(pt, dg, params, false)
+        dgh = Marty::DataGrid.lookup_h(pt, "Gj")
+        res = Marty::DataGrid.lookup_grid_h(pt, dgh, params, false)
 
         # should return the upper left corner match
         expect(res).to eq(0.25)
 
         expect {
-          Marty::DataGrid.lookup_grid(pt, dg, params, true)
+          Marty::DataGrid.lookup_grid_h(pt, dgh, params, true)
         }.to raise_error(RuntimeError)
       end
 
@@ -626,10 +626,10 @@ EOS
       it "should handle typed (enum) data lookup_grid" do
         pt = 'infinity'
         ca = Gemini::State.find_by_name("CA")
-        dg = Marty::DataGrid.lookup(pt, "Gb")
+        dgh = Marty::DataGrid.lookup_h(pt, "Gb")
 
         res = Marty::DataGrid.
-              lookup_grid(pt, dg, {"property_state" => ca}, false)
+              lookup_grid_h(pt, dgh, {"property_state" => ca}, false)
 
         expect(res).to eq 70
       end
@@ -654,8 +654,9 @@ EOS
                               "keys"=>["[600,700)", "[700,750)", "[750,]"],
                               "type"=>"numrange"}]
 
-        dg = Marty::DataGrid.lookup(pt, 'G2')
-        res = dg.lookup_grid_distinct_entry(pt, {}, nil, true, true)
+        dgh = Marty::DataGrid.lookup_h(pt, 'G2')
+        res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt, {}, dgh,
+                                                           nil, true, true)
         expect(res["data"]).to eq (expected_data)
         expect(res["metadata"]).to eq (expected_metadata)
       end
@@ -676,9 +677,11 @@ EOS
                               "attr"=>"fico",
                               "keys"=>["[600,700)", "[700,750)", "[750,]"],
                               "type"=>"numrange"}]
-        dg = Marty::DataGrid.lookup(pt, 'G8')
-        res = dg.lookup_grid_distinct_entry(pt, { "ltv" => 10,
-                                                  "state" => "RI" }, nil, true,
+        dgh = Marty::DataGrid.lookup_h(pt, 'G8')
+        res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt,
+                                                           { "ltv" => 10,
+                                                             "state" => "RI" },
+                                                           dgh, nil, true,
                                             true)
         expect(res["data"]).to eq (expected_data)
         expect(res["metadata"]).to eq (expected_metadata)
@@ -690,44 +693,47 @@ EOS
                               "attr"=>"ltv",
                               "keys"=>["[,115]", "(115,135]", "(135,140]"],
                               "type"=>"numrange"}]
-        dg = Marty::DataGrid.lookup(pt, 'G8')
-        res = dg.lookup_grid_distinct_entry(pt, { "ltv" => 10,
-                                                  "state" => "RI" }, nil, false,
+        dgh = Marty::DataGrid.lookup_h(pt, 'G8')
+        res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt,
+                                                           { "ltv" => 10,
+                                                             "state" => "RI" },
+                                                           dgh, nil, false,
                                             true)
         expect(res["data"]).to eq (expected_data)
         expect(res["metadata"]).to eq (expected_metadata)
       end
 
       it "should handle all characters in grid inputs" do
-        dg = Marty::DataGrid.lookup(pt, 'G1')
+        dgh = Marty::DataGrid.lookup_h(pt, 'G1')
         5000.times do
           st = 30.times.map{rand(224)+32}.pack('U*')
-          res = dg.lookup_grid_distinct_entry(pt, { "ltv" => 10,
-                                                    "fico" => 690,
-                                                    "state" => st }, nil,
-                                              false, true)
+          res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt,
+                                                             { "ltv" => 10,
+                                                               "fico" => 690,
+                                                               "state" => st },
+                                                             dgh, nil, false, true)
         end
       end
       it "should handle all quote chars in grid inputs" do
-        dg = Marty::DataGrid.lookup(pt, 'G1')
+        dgh = Marty::DataGrid.lookup_h(pt, 'G1')
         # single, double, backslash, grave, acute, unicode quotes: left single,
         # right single, left double, right double
         quotes = ["'", '"', '\\', '`', "\u00b4", "\u2018", "\u2019",
                   "\u201C", "\u201D"]
         100.times do
           st = 30.times.map{quotes[rand(9)]}.join
-          res = dg.lookup_grid_distinct_entry(pt, { "ltv" => 10,
+          res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt, { "ltv" => 10,
                                                     "fico" => 690,
-                                                    "state" => st }, nil,
+                                                    "state" => st }, dgh, nil,
                                               false, true)
         end
       end
       it "should handle quote chars in object name" do
-        dg = Marty::DataGrid.lookup(pt, 'G1')
+        dgh = Marty::DataGrid.lookup_h(pt, 'G1')
         st = Gemini::State.new(name: "'\\")
-        res = dg.lookup_grid_distinct_entry(pt, { "ltv" => 10,
+        res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt, { "ltv" => 10,
                                                   "fico" => 690,
-                                                  "state" => st }, nil,
+                                                  "state" => st }, dgh, nil,
                                             false, true)
       end
     end
@@ -749,17 +755,19 @@ EOS
         dgb.update_from_import("Gb", Gb.sub(/70/, "333"), '1/1/2015')
         dgb.update_from_import("Gb", Gb.sub(/70/, "444"), '1/1/2016')
 
-        res = dgc.lookup_grid_distinct_entry('2/2/2014',
-                                             {"property_state" => "CA"})
+        dgch = dgc.attributes.
+               slice("id","group_id","created_dt",  "metadata", "data_type")
+        res = Marty::DataGrid.lookup_grid_distinct_entry_h('2/2/2014',
+                                             {"property_state" => "CA"}, dgch)
         expect(res["result"]).to eq(70)
 
-        res = dgc.lookup_grid_distinct_entry('2/2/2015',
-                                             {"property_state" => "CA"})
+        res = Marty::DataGrid.lookup_grid_distinct_entry_h('2/2/2015',
+                                             {"property_state" => "CA"}, dgch)
 
         expect(res["result"]).to eq(333)
 
-        res = dgc.lookup_grid_distinct_entry('2/2/2016',
-                                             {"property_state" => "CA"})
+        res = Marty::DataGrid.lookup_grid_distinct_entry_h('2/2/2016',
+                                             {"property_state" => "CA"}, dgch)
 
         expect(res["result"]).to eq(444)
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marty
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 1.2.5
 platform: ruby
 authors:
 - Arman Bostani
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-15 00:00:00.000000000 Z
+date: 2018-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg