Module: RedisMemo::MemoizeQuery

Defined in:
lib/redis_memo/memoize_query.rb,
lib/redis_memo/memoize_query/memoize_table_column.rb

Overview

Hook into ActiveRecord to cache SQL queries and perform auto cache invalidation

Defined Under Namespace

Classes: CachedSelect, Invalidation, ModelCallback

Constant Summary collapse

@@memoized_columns = 
Hash.new { |h, k| h[k] = [Set.new, Set.new] }

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.create_memo(model_class, **extra_props) ⇒ Object

extra_props are considered as AND conditions on the model class



66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/redis_memo/memoize_query.rb', line 66

def self.create_memo(model_class, **extra_props)
  using_active_record!(model_class)

  keys = extra_props.keys.sort
  if !keys.empty? && !memoized_columns(model_class).include?(keys)
    raise(
      RedisMemo::ArgumentError,
      "'#{model_class.name}' has not memoized columns: #{keys}",
    )
  end

  extra_props.each do |key, value|
    # The data type is ensured by the database, thus we don't need to cast
    # types here for better performance
    column_name = key.to_s
    extra_props[key] =
      if model_class.defined_enums.include?(column_name)
        enum_mapping = model_class.defined_enums[column_name]
        # Assume a value is a converted enum if it does not exist in the
        # enum mapping
        (enum_mapping[value.to_s] || value).to_s
      else
        value.to_s
      end
  end

  RedisMemo::Memoizable.new(
    __redis_memo_memoize_query_table_name__: model_class.table_name,
    **extra_props,
  )
end

.invalidate(*records) ⇒ Object 



107
108
109
110
111
 
# File 'lib/redis_memo/memoize_query.rb', line 107

def self.invalidate(*records)
  RedisMemo::Memoizable.invalidate(
    records.map { |record| to_memos(record) }.flatten,
  )
end

.invalidate_all(model_class) ⇒ Object 



98
99
100
101
102
103
104
105
 
# File 'lib/redis_memo/memoize_query.rb', line 98

def self.invalidate_all(model_class)
  RedisMemo::Tracer.trace(
    'redis_memo.memoizable.invalidate_all',
    model_class.name,
  ) do
    RedisMemo::Memoizable.invalidate([model_class.redis_memo_class_memoizable])
  end
end

.memoized_columns(model_or_table, editable_only: false) ⇒ Object 



60
61
62
63
 
# File 'lib/redis_memo/memoize_query.rb', line 60

def self.memoized_columns(model_or_table, editable_only: false)
  table = model_or_table.is_a?(Class) ? model_or_table.table_name : model_or_table
  @@memoized_columns[table.to_sym][editable_only ? 1 : 0]
end

.to_memos(record) ⇒ Object 



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/redis_memo/memoize_query.rb', line 113

def self.to_memos(record)
  # Invalidate memos with current values
  memos_to_invalidate = memoized_columns(record.class).map do |columns|
    props = {}
    columns.each do |column|
      props[column] = record.send(column)
    end

    create_memo(record.class, **props)
  end

  # Create memos with previous values if
  #  - there are saved changes
  #  - this is not creating a new record
  if !record.saved_changes.empty? && !record.saved_changes.include?(record.class.primary_key)
    previous_values = {}
    record.saved_changes.each do |column, (previous_value, _)|
      previous_values[column.to_sym] = previous_value
    end

    memoized_columns(record.class, editable_only: true).each do |columns|
      props = previous_values.slice(*columns)
      next if props.empty?

      # Fill the column values that have not changed
      columns.each do |column|
        next if props.include?(column)

        props[column] = record.send(column)
      end

      memos_to_invalidate << create_memo(record.class, **props)
    end
  end

  memos_to_invalidate
end

.using_active_record!(model_class) ⇒ Object 



48
49
50
51
52
 
# File 'lib/redis_memo/memoize_query.rb', line 48

def self.using_active_record!(model_class)
  unless using_active_record?(model_class)
    raise RedisMemo::ArgumentError, "'#{model_class.name}' does not use ActiveRecord"
  end
end

.using_active_record?(model_class) ⇒ Boolean

Returns:

  • (Boolean) 


54
55
56
 
# File 'lib/redis_memo/memoize_query.rb', line 54

def self.using_active_record?(model_class)
  model_class.respond_to?(:<) && model_class < ActiveRecord::Base
end

Instance Method Details

#memoize_table_column(*raw_columns, editable: true) ⇒ Object

Only editable columns will be used to create memos that are invalidatable after each record save



14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/redis_memo/memoize_query.rb', line 14

def memoize_table_column(*raw_columns, editable: true)
  RedisMemo::MemoizeQuery.using_active_record!(self)
  return if ENV["REDIS_MEMO_DISABLE_#{self.table_name.upcase}"] == 'true'

  columns = raw_columns.map(&:to_sym).sort

  RedisMemo::MemoizeQuery.memoized_columns(self, editable_only: true) << columns if editable
  RedisMemo::MemoizeQuery.memoized_columns(self, editable_only: false) << columns

  RedisMemo::MemoizeQuery::ModelCallback.install(self)
  RedisMemo::MemoizeQuery::Invalidation.install(self)

  if ENV['REDIS_MEMO_DISABLE_CACHED_SELECT'] != 'true'
    RedisMemo::MemoizeQuery::CachedSelect.install(ActiveRecord::Base.connection)
  end

  # The code below might fail due to missing DB/table errors
  columns.each do |column|
    unless self.columns_hash.include?(column.to_s)
      raise(
        RedisMemo::ArgumentError,
        "'#{self.name}' does not contain column '#{column}'",
      )
    end
  end

  unless ENV["REDIS_MEMO_DISABLE_QUERY_#{self.table_name.upcase}"] == 'true'
    RedisMemo::MemoizeQuery::CachedSelect.enabled_models[self.table_name] = self
  end
rescue ActiveRecord::NoDatabaseError, ActiveRecord::StatementInvalid
  # no-opts: models with memoize_table_column decleared might be loaded in
  # rake tasks that are used to create databases
end