struct Tablo::Summary::UserProc(T)

Overview

The Summary::UserProc struct lets you define specific functions to be applied to source data, accessible either by column or directly from the source, in order to provide aggregated results.

Defined in:

summary.cr

Constructors

Instance Method Summary

Constructor Detail

def self.new(proc : Proc(Table(T), Hash(Symbol, CellType))) #

The constructor's only parameter is a Proc, which in turn expects a Table(T) as its only parameter.

The table parameter allows the user to access detailed data in two ways:

  1. by directly accessing the data source: table.sources.each ...
  2. by accessing data via column definition: table.column_data(column_label).each....

Note that access via column definition allows the use of data not directly present in the source, but has the disadvantage of indirect (and slower) access to data via the user-defined extractor in the Table#add_column method.

The Proc must return a hash of results (of type Tablo::CellType), which, when used inside a Summary table definition, are automatically saved for future use (see the Summary.use method in Summary::BodyRow).

Example of accessing data directly from source (note that, in this reduced example, we don't even need to define any columns):

require "tablo"

struct InvoiceItem
  getter product, quantity, price

  def initialize(@product : String, @quantity : Int32?, @price : Int32?)
  end
end

invoice = [
  InvoiceItem.new("Laptop", 3, 98000),
  InvoiceItem.new("Printer", 2, 15499),
  InvoiceItem.new("Router", 1, 9900),
  InvoiceItem.new("Switch", nil, 4500),
  InvoiceItem.new("Accessories", 5, 6450),
]

table = Tablo::Table.new(invoice)

userproc = Tablo::Summary::UserProc.new(
  proc: ->(tbl : Tablo::Table(InvoiceItem)) {
    total_sum = total_count = max_price = 0
    tbl.sources.each do |row|
      next unless row.quantity.is_a?(Int32) && row.price.is_a?(Int32)
      total_count += 1
      max_price = [max_price, row.price.as(Int32)].max
      total_sum += row.quantity.as(Int32) * row.price.as(Int32)
    end
    {
      :total_count => total_count.as(Tablo::CellType),
      :total_sum   => total_sum.as(Tablo::CellType),
      :max_price   => max_price.as(Tablo::CellType),
    }
  })

hash = userproc.proc.call(table)

puts hash[:total_sum]   # => 367148
puts hash[:total_count] # => 4
puts hash[:max_price]   # => 98000

Another example, this time using column access via Table#column_data, with iterators:

require "tablo"

struct InvoiceItem
  getter product, quantity, price

  def initialize(@product : String, @quantity : Int32?, @price : Int32?)
  end
end

invoice = [
  InvoiceItem.new("Laptop", 3, 98000),
  InvoiceItem.new("Printer", 2, 15499),
  InvoiceItem.new("Router", 1, 9900),
  InvoiceItem.new("Switch", nil, 4500),
  InvoiceItem.new("Accessories", 5, 6450),
]

table = Tablo::Table.new(invoice) do |t|
  t.add_column("Quantity", &.quantity)
  t.add_column("Price", &.price)
end

userproc = Tablo::Summary::UserProc.new(
  proc: ->(tbl : Tablo::Table(InvoiceItem)) {
    total_sum = total_count = max_price = 0
    iter_quantity = tbl.column_data("Quantity").each
    iter_price = tbl.column_data("Price").each
    iter = iter_quantity.zip(iter_price)
    iter.each do |q, p|
      next unless q.is_a?(Int32) && p.is_a?(Int32)
      total_sum += q * p
      total_count += 1
      max_price = [max_price, p].max
    end
    {
      :total_count => total_count.as(Tablo::CellType),
      :total_sum   => total_sum.as(Tablo::CellType),
      :max_price   => max_price.as(Tablo::CellType),
    }
  })

hash = userproc.proc.call(table)

puts hash[:total_sum]   # => 367148
puts hash[:total_count] # => 4
puts hash[:max_price]   # => 98000

[View source]

Instance Method Detail

def proc #

[View source]