Best way to get multiple keys from static ETS table

Looked at this yet?

iex(13)> :ets.select(table, [{{:"$1", :_}, [{:or, {:==, :"$1", :a}, {:==, :"$1", :b}}], [:"$_"]}]) 
[
  b: [{:car, :moto, 1}, {:plane, :heli, 60}],
  a: [{:banana, :orange, 10}, {:tomato, :potato, 6}]
]

Boom! You can adjust the match body to what you’re interested in. Also note that the match head has to match the table format.

I have a weird fascination with match specs.

This sounds like a good use case for :persistent_term. The data will never change so there isn’t a write penalty and you get extremely fast reads.

I’m curious though, if the data doesn’t change why are you concerned about atomicity?

You can’t have a fully bound key in a match spec that checks for many keys. Either do one lookup per key and throw away atomicity (which might not be a great deal as @sorentwo already mentioned) or build a matchspec as shown by @jola (perhaps even use ex2ms and just write functions rather than weirdly nested tuples).

But you’ll need to give up either atomicity or O(1) reads…

I had no idea about persistent terms. You also make an excellent point about atomicity. What I want are extremely fast reads above all things, I thought atomicity could help with this.

The persistent_term module is a very recent addition. And a very useful one, too!

I’m in the same situation but with lots more keys (a few hundreds) and dets. From this post [erlang-questions] Fetching several ets keys it appears that I should not use jola’s approach but somehow feed my keys into a key. I wasn’t able to do this from elixir. Any suggestion?
:dets.select( :my_dets_table,
[ { { :Key, :_ }, , [ :“$_” ] } || :Key ← my_keys ] )
===> undefined function <-/2

The erlang code from that mailinglist could be translated into Elixir like this (using the sample code from the OP):

iex(5)> my_keys = [:b, :a]
[:b, :a]
iex(6)> :ets.select(table, (for key <- my_keys, do: {{key, :_}, [], [:"$_"]}))
[
  a: [{:banana, :orange, 10}, {:tomato, :potato, 6}],
  b: [{:car, :moto, 1}, {:plane, :heli, 60}]
]

Basically, it uses the comprehension to build a list of match specs, where each one has a fully bound key.

Confirmed, this works well and is indeed measurably faster than lookups in an Enum.map.
Thank you very much jola for the guidance!!

Having spent a few hours now on match specs, my head hurts. Very much hoping @jola is still weirdly fascinated by them

Dets Table layout

My dets/ets table has a key of the format {x_min, x_max, y_min, y_max} and value of a bunch of polygons. Basically the key describes a bounding box.

Objective

Return all the records that match the key with some guards

What I’ve tried

This is what I’ve been working on - until I realised this is likely doing a match on the value, not the key.

  # Match specification, which I assumed is matching only on the key
  # but probably isn't
  defp match_spec(%{coordinates: {lng, lat}}) do
    [
      {
        {:"$1", :"$2", :"$3", :"$4"},
        [
          {:andalso, {:>=, lng, :"$1"}, {:"=<", lng, :"$2"}},
          {:andalso, {:>=, lat, :"$3"}, {:"=<", lat, :"$4"}}
        ],
        [:"$_"]
      }
    ]
  end

# All keys are a 4-tuple {x_min, x_max, y_min, y_max}
iex> :dets.first TzWorld.Backend.Dets                                            
{-92.186268, -91.750739, 20.002558, 20.420965}
iex> :dets.select TzWorld.Backend.Dets, match_spec(%{coordinates: {3.2, 45.32}})
[]

Any and all help much appreciated!