Module: Supabase::Postgrest::FilterMixin

Included in:
FilterRequestBuilder, RPCFilterRequestBuilder
Defined in:
lib/supabase/postgrest/request_builder.rb

Overview

Mixin providing PostgREST filter operators (eq, neq, gt, lt, like, in_, contains, …). Methods return self so they’re chainable. Mirrors supabase-py’s BaseFilterRequestBuilder.

Instance Method Summary collapse

Instance Method Details

#adj(column, range) ⇒ Object 



304
 
# File 'lib/supabase/postgrest/request_builder.rb', line 304

def adj(column, range); filter(column, Types::Filters::ADJ, "(#{range[0]},#{range[1]})"); end

#cd(column, values) ⇒ Object 



256
257
258
259
 
# File 'lib/supabase/postgrest/request_builder.rb', line 256

def cd(column, values)
  joined = values.is_a?(Array) ? values.join(",") : values.to_s
  filter(column, Types::Filters::CD, "{#{joined}}")
end

#contained_by(column, value) ⇒ Object 



274
275
276
277
278
279
280
281
282
283
284
285
 
# File 'lib/supabase/postgrest/request_builder.rb', line 274

def contained_by(column, value)
  case value
  when String
    filter(column, Types::Filters::CD, value)
  when Hash
    filter(column, Types::Filters::CD, JSON.generate(value))
  when Enumerable
    filter(column, Types::Filters::CD, "{#{value.to_a.join(',')}}")
  else
    filter(column, Types::Filters::CD, JSON.generate(value))
  end
end

#contains(column, value) ⇒ Object 



261
262
263
264
265
266
267
268
269
270
271
272
 
# File 'lib/supabase/postgrest/request_builder.rb', line 261

def contains(column, value)
  case value
  when String
    filter(column, Types::Filters::CS, value)
  when Hash
    filter(column, Types::Filters::CS, JSON.generate(value))
  when Enumerable
    filter(column, Types::Filters::CS, "{#{value.to_a.join(',')}}")
  else
    filter(column, Types::Filters::CS, JSON.generate(value))
  end
end

#cs(column, values) ⇒ Object 



251
252
253
254
 
# File 'lib/supabase/postgrest/request_builder.rb', line 251

def cs(column, values)
  joined = values.is_a?(Array) ? values.join(",") : values.to_s
  filter(column, Types::Filters::CS, "{#{joined}}")
end

#eq(column, value) ⇒ Object 



221
 
# File 'lib/supabase/postgrest/request_builder.rb', line 221

def eq(column, value); filter(column, Types::Filters::EQ, value); end

#filter(column, operator, criteria) ⇒ Object 



210
211
212
213
214
215
216
217
218
219
 
# File 'lib/supabase/postgrest/request_builder.rb', line 210

def filter(column, operator, criteria)
  if @negate_next
    @negate_next = false
    operator = "#{Types::Filters::NOT}.#{operator}"
  end
  key = Utils.sanitize_param(column)
  val = "#{operator}.#{criteria}"
  @request.params = add_param(@request.params, key, val)
  self
end

#fts(column, query) ⇒ Object 



241
 
# File 'lib/supabase/postgrest/request_builder.rb', line 241

def fts(column, query); filter(column, Types::Filters::FTS, query); end

#gt(column, value) ⇒ Object 



223
 
# File 'lib/supabase/postgrest/request_builder.rb', line 223

def gt(column, value); filter(column, Types::Filters::GT, value); end

#gte(column, value) ⇒ Object 



224
 
# File 'lib/supabase/postgrest/request_builder.rb', line 224

def gte(column, value); filter(column, Types::Filters::GTE, value); end

#ilike(column, pattern) ⇒ Object 



234
 
# File 'lib/supabase/postgrest/request_builder.rb', line 234

def ilike(column, pattern); filter(column, Types::Filters::ILIKE, pattern); end

#ilike_all_of(column, pattern) ⇒ Object 



238
 
# File 'lib/supabase/postgrest/request_builder.rb', line 238

def ilike_all_of(column, pattern); filter(column, Types::Filters::ILIKE_ALL, "{#{pattern}}"); end

#ilike_any_of(column, pattern) ⇒ Object 



239
 
# File 'lib/supabase/postgrest/request_builder.rb', line 239

def ilike_any_of(column, pattern); filter(column, Types::Filters::ILIKE_ANY, "{#{pattern}}"); end

#in_(column, values) ⇒ Object 



246
247
248
249
 
# File 'lib/supabase/postgrest/request_builder.rb', line 246

def in_(column, values)
  sanitized = values.map { |v| Utils.sanitize_param(v) }.join(",")
  filter(column, Types::Filters::IN, "(#{sanitized})")
end

#is_(column, value) ⇒ Object 



228
229
230
231
 
# File 'lib/supabase/postgrest/request_builder.rb', line 228

def is_(column, value)
  v = value.nil? ? "null" : value
  filter(column, Types::Filters::IS, v)
end

#like(column, pattern) ⇒ Object 



233
 
# File 'lib/supabase/postgrest/request_builder.rb', line 233

def like(column, pattern); filter(column, Types::Filters::LIKE, pattern); end

#like_all_of(column, pattern) ⇒ Object 



236
 
# File 'lib/supabase/postgrest/request_builder.rb', line 236

def like_all_of(column, pattern); filter(column, Types::Filters::LIKE_ALL, "{#{pattern}}"); end

#like_any_of(column, pattern) ⇒ Object 



237
 
# File 'lib/supabase/postgrest/request_builder.rb', line 237

def like_any_of(column, pattern); filter(column, Types::Filters::LIKE_ANY, "{#{pattern}}"); end

#lt(column, value) ⇒ Object 



225
 
# File 'lib/supabase/postgrest/request_builder.rb', line 225

def lt(column, value); filter(column, Types::Filters::LT, value); end

#lte(column, value) ⇒ Object 



226
 
# File 'lib/supabase/postgrest/request_builder.rb', line 226

def lte(column, value); filter(column, Types::Filters::LTE, value); end

#match(query) ⇒ Object

Raises:

  • (ArgumentError) 


313
314
315
316
317
318
319
 
# File 'lib/supabase/postgrest/request_builder.rb', line 313

def match(query)
  raise ArgumentError, "query must contain at least one key-value pair" if query.nil? || query.empty?

  result = self
  query.each { |k, v| result = eq(k, v) }
  result
end

#max_affected(value) ⇒ Object 



327
328
329
330
331
332
333
334
335
336
337
 
# File 'lib/supabase/postgrest/request_builder.rb', line 327

def max_affected(value)
  existing = @request.headers["Prefer"] || ""
  prefer = existing.dup
  unless prefer.empty?
    prefer += ",handling=strict" unless prefer.include?("handling=strict")
  end
  prefer = "handling=strict" if prefer.empty?
  prefer += ",max-affected=#{value}"
  @request.headers["Prefer"] = prefer
  self
end

#neq(column, value) ⇒ Object 



222
 
# File 'lib/supabase/postgrest/request_builder.rb', line 222

def neq(column, value); filter(column, Types::Filters::NEQ, value); end

#not_ ⇒ Object 



205
206
207
208
 
# File 'lib/supabase/postgrest/request_builder.rb', line 205

def not_
  @negate_next = true
  self
end

#nxl(column, range) ⇒ Object 



302
 
# File 'lib/supabase/postgrest/request_builder.rb', line 302

def nxl(column, range); filter(column, Types::Filters::NXL, "(#{range[0]},#{range[1]})"); end

#nxr(column, range) ⇒ Object 



303
 
# File 'lib/supabase/postgrest/request_builder.rb', line 303

def nxr(column, range); filter(column, Types::Filters::NXR, "(#{range[0]},#{range[1]})"); end

#or_(filters, reference_table: nil) ⇒ Object 



321
322
323
324
325
 
# File 'lib/supabase/postgrest/request_builder.rb', line 321

def or_(filters, reference_table: nil)
  key = reference_table ? "#{Utils.sanitize_param(reference_table)}.or" : "or"
  @request.params = add_param(@request.params, key, "(#{filters})")
  self
end

#ov(column, value) ⇒ Object 



287
288
289
290
291
292
293
294
295
296
297
298
 
# File 'lib/supabase/postgrest/request_builder.rb', line 287

def ov(column, value)
  case value
  when String
    filter(column, Types::Filters::OV, value)
  when Hash
    filter(column, Types::Filters::OV, JSON.generate(value))
  when Enumerable
    filter(column, Types::Filters::OV, "{#{value.to_a.join(',')}}")
  else
    filter(column, Types::Filters::OV, JSON.generate(value))
  end
end

#overlaps(column, values) ⇒ Object 



311
 
# File 'lib/supabase/postgrest/request_builder.rb', line 311

def overlaps(column, values); ov(column, values); end

#phfts(column, query) ⇒ Object 



243
 
# File 'lib/supabase/postgrest/request_builder.rb', line 243

def phfts(column, query); filter(column, Types::Filters::PHFTS, query); end

#plfts(column, query) ⇒ Object 



242
 
# File 'lib/supabase/postgrest/request_builder.rb', line 242

def plfts(column, query); filter(column, Types::Filters::PLFTS, query); end

#range_adjacent(column, range) ⇒ Object 



310
 
# File 'lib/supabase/postgrest/request_builder.rb', line 310

def range_adjacent(column, range); adj(column, range); end

#range_gt(column, range) ⇒ Object 



307
 
# File 'lib/supabase/postgrest/request_builder.rb', line 307

def range_gt(column, range); sr(column, range); end

#range_gte(column, range) ⇒ Object 



308
 
# File 'lib/supabase/postgrest/request_builder.rb', line 308

def range_gte(column, range); nxl(column, range); end

#range_lt(column, range) ⇒ Object 



306
 
# File 'lib/supabase/postgrest/request_builder.rb', line 306

def range_lt(column, range); sl(column, range); end

#range_lte(column, range) ⇒ Object 



309
 
# File 'lib/supabase/postgrest/request_builder.rb', line 309

def range_lte(column, range); nxr(column, range); end

#sl(column, range) ⇒ Object 



300
 
# File 'lib/supabase/postgrest/request_builder.rb', line 300

def sl(column, range); filter(column, Types::Filters::SL, "(#{range[0]},#{range[1]})"); end

#sr(column, range) ⇒ Object 



301
 
# File 'lib/supabase/postgrest/request_builder.rb', line 301

def sr(column, range); filter(column, Types::Filters::SR, "(#{range[0]},#{range[1]})"); end

#wfts(column, query) ⇒ Object 



244
 
# File 'lib/supabase/postgrest/request_builder.rb', line 244

def wfts(column, query); filter(column, Types::Filters::WFTS, query); end