TIL : "select" queries with ETS

The following notes are complementary to this ETS lesson with a focus on "ets.select / match_spec" and the Ex2ms library to use with ETS, the Erlang built-in in-memory database.

Suppose we have an ETS table that saves messages exchanged between two users. The records will be in the form:

{timestamp, user, receiver, msg}

We will use match_spec for .select based queries.

Remove "old" messages

We want to run periodical cleanups to limit the size of the table. We use the Erlang-ETS function :ets.select_delete/2 that takes the table name (we named it in the options) and a match_spec.

A record to be deleted should have a "match_spec" that returns true whenever this record matches. A match here is when the first element of the record - the timestamp - is lower than a given constant.
For example, if the constant is 1, a "match_spec" to be used in the function :ets.select_delete is:

ms = 
[{
  {:"$1", :"$2", :"$3", :"$4"},
  [
   {:<, :"$1", {:const, 1}}
  ], 
  [true]
}]

and use it: :ets.select_delete(:table, ms).

We can test this against the table with the function :ets.test_ms/2. It will detect errors if any.

We can advantageously use the package Ex2ms to rewrite this into a function form with Ex2ms.fun. It is more readable, but also allows you to use variables in the scope. Add the package to the MixProject.

With this package, the "match_spec" is built by passing a function to Ex2ms.fun that returns the same "match_spec":

ms = Ex2ms.fun do
  {t, _e, _u, _r, _m} when t < 1 -> true
end

you can use the built-in function fm2ms when you use constants, but when you want to use variables in scope, then you should use the Ex2ms package.

We can use a variable in scope and use this "match_spec" in the :ets.select_delete function:

# module MyApp.ChatCache
import Ex2ms, only: [fun: 1]

def clean_up(delay) do
  some_time_ago = System.os_time(:second) - delay * 60

    ms =
      fun do
        {t, _e, _u, _r, _m} when t < ^some_time_ago -> true
      end

    :ets.select_delete(:chat, ms)
end

This function returns the number of records deleted.

Another example

We want to :ets.select from our table all the messages exchanged between a couple of users. In other words, we want the records where the user and receiver - the second and third element (of the record) - are equal to some values, regardless of the order.
Given two constants values a and b that represent our couple of users, our constraint is:

($2 == "a" and  $3 == "b") or ($2 == "b" and $3 == "a")

Such a "match_spec" would be written (carefully!) in Erlang for our table:

[{
  {:"$1", :"$2", :"$3", :"$4"},
  [{
    :orelse,
      {:andalso, 
        {:==, :"$2", {:const, "a"}},
        {:==, :"$3", {:const, "b"}}
      },
      {:andalso, 
        {:==, :"$2", {:const, "b"}},
        {:==, :"$3", {:const, "a"}}
      }
  }], 
  [{
    {:"$1", :"$2", :"$3", :"$4"}
  }]
}]

The list of Erlang's allowed function descriptions is here. Not so easy? Ex2ms makes it easy:

import Ex2ms, only: [fun: 1]

def get_messages_by_channel(val_e, val_r) do

  ms = fun do {t, e, r, m} when
      (e == ^val_e and r == ^val_r) 
      or (e == ^val_r and r == ^val_e) 
    -> {t, e, r, m}

  :ets.select(:chat, ms)
end