lilit-sql 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8055fa9bdd9f4c7dd21d9e1036ca22ebd423637994ec0aeda7894062a8c3b2fa
-  data.tar.gz: 2683c306cb68f4d0e7b2e17fd678e8951a67c92a28acdafc87ffbf0c2b466ba0
+  metadata.gz: 387d30110c85b2e4c85aef31d108675aaba18405d13f8b84984f3ce237a11caa
+  data.tar.gz: 342b105a73a26c3dc3507fddb2c3adccacc69ef23afea327a1f3fc9ba15c0671
 SHA512:
-  metadata.gz: 67a42477621655368a38a0ef15c55af70046b859b69f7bddd780546debd7bb8b81267112896a358effb95ae0b5820ec73618bd8f074412b0f10ebda78ff177b4
-  data.tar.gz: bab58672731d51626c65ee9855aa7fc7ba88c11bec2d917dbdfb6349923dc60424bbc9fee0e591e4b556224959a28315a0b259b68e956a5a51cab6899095b019
+  metadata.gz: f83a531e2aa9b9a1a03be86374555e21a1fff1115a06b36db492a3c56b3f2d398e91e8ea38b0bca0767b48b0861fe43cc5979f285bc52637cbccc218b09bd278
+  data.tar.gz: b2c571325ddc399f639c68b291f16df4db25cdadfa2d4320b2456f771aa2a9c4e8a4a95fb9b7d5a39858c27c715cb1e79e4f3721f32967acd426ded134464452

data/lib/lilit_sql.rb

@@ -4,10 +4,146 @@ require 'ruby2ruby'
 require 'ruby_parser'
 require 'sourcify'
 
+class Expr
+  def and(other)
+    BinaryOperation.new(self, :and, other)
+  end
+
+  def eq(other)
+    BinaryOperation.new(self, :'=', other)
+  end
+
+  def not
+    UnaryOperation.new(:not, self)
+  end
+
+  def minus
+    UnaryOperation.new(:-, self)
+  end
+
+  def plus
+    UnaryOperation.new(:+, self)
+  end
+
+  def ne(other)
+    BinaryOperation.new(self, :'!=', other)
+  end
+
+  def in(list)
+    BinaryOperation.new(self, :in, list)
+  end
+
+  def *(other)
+    BinaryOperation.new(self, :*, other)
+  end
+
+  def +(other)
+    BinaryOperation.new(self, :+, other)
+  end
+
+  def >=(other)
+    BinaryOperation.new(self, :'>=', other)
+  end
+
+  def <=(other)
+    BinaryOperation.new(self, :<=, other)
+  end
+
+  def >(other)
+    BinaryOperation.new(self, :'>', other)
+  end
+
+  def <(other)
+    BinaryOperation.new(self, :<, other)
+  end
+
+  def asc
+    OrderedByExpr.new(self, :asc)
+  end
+
+  def desc
+    OrderedByExpr.new(self, :desc)
+  end
+end
+
+class OrderedByExpr
+  attr_accessor :expr, :direction
+
+  def initialize(expr, direction = nil)
+    @expr = expr
+    @direction = direction
+  end
+
+  def sql
+    s = @expr.ref_sql
+
+    if @direction
+      s += " #{direction}"
+    end
+  end
+end
+
+class UnaryOperation < Expr
+  attr_accessor :op
+
+  def initialize(op, value)
+    @op = op
+    @value = value
+  end
+
+  def ref_sql
+    "#{@op} (#{@value.ref_sql})"
+  end
+
+  def ==(other)
+    other.class == self.class && other.state == state
+  end
+
+  def state
+    instance_variables.map { |variable| instance_variable_get variable }
+  end
+end
+
+class BinaryOperation < Expr
+  attr_accessor :left, :op, :right
+
+  def initialize(left, op, right)
+    @left = left
+    @op = op
+    @right = lit(right)
+  end
+
+  def ref_sql
+    if @right.is_a?(Literal) && @right.value.nil?
+      return (
+        if @op == :'='
+          "#{@left.ref_sql} is #{@right.ref_sql}"
+        elsif @op == :!=
+          "#{@left.ref_sql} is not #{@right.ref_sql}"
+        else
+          raise ArgumentError.new("Nil doesn't support the operator: #{@op}")
+        end
+      )
+    end
+
+    if @op == :in
+      return "#{@left.ref_sql} in (#{@right.map(&:ref_sql).join(', ')})"
+    end
+
+    "#{@left.ref_sql} #{@op} #{@right.ref_sql}"
+  end
+
+  def ==(other)
+    other.class == self.class && other.state == state
+  end
+
+  def state
+    instance_variables.map { |variable| instance_variable_get variable }
+  end
+end
+
 class From
-  attr_accessor :source
-  attr_accessor :join_type
-  attr_accessor :condition
+  attr_accessor :source, :join_type, :condition
 
   def initialize(source, join_type = nil, condition = nil, alias_name = nil)
     @source = source
@@ -16,9 +152,7 @@ class From
     @alias_name = alias_name
   end
 
-  def alias_name=(value)
-    @alias_name = value
-  end
+  attr_writer :alias_name
 
   def raw_alias_name
     @alias_name
@@ -33,9 +167,26 @@ class From
   end
 end
 
+class CrossJoinUnnest
+  attr_accessor :from, :row, :ordinality
+
+  def initialize(from, row, ordinality)
+    @from = from
+    @row = row
+    @ordinality = ordinality
+  end
+
+  def rows
+    [@row].map {|r| r.with_from(@from)}
+  end
+
+  def alias_name
+    @from.source.table_name
+  end
+end
+
 class GroupBy
-  attr_accessor :query
-  attr_accessor :keys
+  attr_accessor :query, :keys
 
   def initialize(query, keys)
     @query = query
@@ -43,12 +194,13 @@ class GroupBy
   end
 
   def aggregate(&blk)
-    result = blk.call(@keys, *@query.rows)
+    result = expr(&blk).call(@keys, *@query.rows)
 
     Query.new(
-      @query.froms + [],
-      @query.conditions + [],
+      @query.froms,
+      @query.conditions,
       @keys,
+      @query.order_bys,
       Row.new(result.class.members, result)
     )
   end
@@ -70,37 +222,44 @@ class Row
   end
 
   def col(name)
-    found = @columns.select {|c| c.name == name}.first
+    found = @columns.select { |c| c.name == name }.first
 
-    raise ArgumentError.new("#{name} is not found in the columns: #{@columns.map {|c|c.name}.inspect}") if found.nil?
+    raise ArgumentError, "#{name} is not found in the columns: #{@columns.map(&:name).inspect}" if found.nil?
 
     found
   end
 
   def with_from(from)
-    Row.new(@columns.map {|c| c.with_from(from)})
-  end
-
-  private def method_missing(symbol, *args)
-    begin
-      col(symbol)
-    rescue ArgumentError
-      super
-    end
+    Row.new(@columns.map { |c| c.with_from(from) })
   end
 
   def has?(name)
-    @columns.any? {|c| c.name == name}
+    @columns.any? { |c| c.name == name }
   end
 
   def decl_sql
-    @columns.map {|c|c.decl_sql}.join(', ')
+    @columns.map(&:decl_sql).join(', ')
+  end
+
+  private
+
+  def method_missing(symbol, *args)
+    col(symbol)
+  rescue ArgumentError
+    super
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    !col(method_name).nil?
+  rescue ArgumentError
+    super
   end
 end
 
-class Column
-  attr_accessor :name
-  attr_accessor :origin
+
+
+class Column < Expr
+  attr_accessor :name, :origin
 
   def initialize(name, origin = nil, from = nil)
     @name = name
@@ -112,22 +271,6 @@ class Column
     Column.new(@name, @origin, from)
   end
 
-  def eq(other)
-    Expr.new(self, :eq, other)
-  end
-
-  def in(list)
-    Expr.new(self, :in, list)
-  end
-
-  def *(other)
-    Expr.new(self, :*, other)
-  end
-
-  def <=(other)
-    Expr.new(self, :<=, other)
-  end
-
   def ref_sql
     "#{@from.alias_name}.#{@name}"
   end
@@ -140,25 +283,22 @@ class Column
                    else
                      origin.ref_sql
                    end
-      if origin_sql != @name.to_s
-        s += "#{origin_sql} as "
-      end
+      s += "#{origin_sql} as " if origin_sql != @name.to_s
     end
     s += @name.to_s
     s
   end
 
   def ==(other)
-    other.class == self.class && other.state == self.state
+    other.class == self.class && other.state == state
   end
 
   def state
-    self.instance_variables.map { |variable| self.instance_variable_get variable }
+    instance_variables.map { |variable| instance_variable_get variable }
   end
 end
 
 class Count < Column
-
   def initialize
     super(nil)
   end
@@ -168,12 +308,11 @@ class Count < Column
   end
 
   def decl_sql
-    "count(*)"
+    'count(*)'
   end
 end
 
 class Sum < Column
-
   def initialize(col)
     super(nil, col)
   end
@@ -197,7 +336,7 @@ module Aggregate
   end
 end
 
-class Literal
+class Literal < Expr
   attr_accessor :value
 
   def initialize(value)
@@ -210,78 +349,39 @@ class Literal
 
   def decl_sql
     if @value.nil?
-      "null"
+      'null'
     elsif @value.is_a?(Integer) || @value.is_a?(Float)
-      "#{@value}"
+      @value.to_s
     elsif @value.is_a?(String)
       "'#{@value}'"
     else
-      raise NotImplementedError.new("Literal doesn't support render #{@value.class} (#{@value})")
+      raise NotImplementedError, "Literal doesn't support render #{@value.class} (#{@value})"
     end
   end
 
   def ==(other)
-    other.class == self.class && other.state == self.state
+    other.class == self.class && other.state == state
   end
 
   def state
-    self.instance_variables.map { |variable| self.instance_variable_get variable }
+    instance_variables.map { |variable| instance_variable_get variable }
   end
 end
 
-class Expr
-  attr_accessor :left
-  attr_accessor :op
-  attr_accessor :right
-
-  def initialize(left, op, right)
-    @left = left
-    @op = op
-    @right = right
-  end
+def lit(value)
+  return value if value.is_a?(Literal)
 
-  def and(other)
-    Expr.new(self, :and, other)
-  end
-
-  def ref_sql
-    if op == :and
-      "#{left.ref_sql} and #{right.ref_sql}"
-    elsif op == :eq
-      if right.is_a?(Literal) && right.value.nil?
-        "#{left.ref_sql} is #{right.ref_sql}"
-      else
-        "#{left.ref_sql} = #{right.ref_sql}"
-      end
-    elsif op == :ne
-      if right.is_a?(Literal) && right.value.nil?
-        "#{left.ref_sql} is not #{right.ref_sql}"
-      else
-        "#{left.ref_sql} != #{right.ref_sql}"
-      end
-    elsif op == :*
-      "#{left.ref_sql} * #{right.ref_sql}"
-    elsif op == :<=
-      "#{left.ref_sql} <= #{right.ref_sql}"
-    elsif op == :in
-      "#{left.ref_sql} in (#{right.map {|r|r.ref_sql}.join(', ')})"
-    else
-      raise ArgumentError.new("#{op} is not supported by Expr")
-    end
-  end
-
-  def ==(other)
-    other.class == self.class && other.state == self.state
-  end
-
-  def state
-    self.instance_variables.map { |variable| self.instance_variable_get variable }
+  if value.is_a?(String) || value.is_a?(Integer) || value.is_a?(Float) || value.nil?
+    Literal.new(value)
+  elsif value.is_a?(Array)
+    value.map { |v| lit(v) }
+  else
+    value
   end
 end
 
 class Table
-  attr_accessor :table_name
-  attr_accessor :rows
+  attr_accessor :table_name, :rows
 
   def initialize(struct, table_name)
     @table_name = table_name
@@ -294,16 +394,16 @@ class Table
 end
 
 class Query
-  attr_accessor :froms
-  attr_accessor :conditions
-  attr_accessor :grouped_keys
-  attr_accessor :row
+  attr_accessor :froms, :conditions, :grouped_keys, :order_bys, :row, :_limit, :_offset
 
-  def initialize(froms, conditions = [], grouped_keys = [], row = nil)
+  def initialize(froms, conditions = [], grouped_keys = [], order_bys = [], row = nil, limit = nil, offset = nil)
     @froms = froms + []
     @conditions = conditions + []
     @grouped_keys = grouped_keys + []
+    @order_bys = order_bys + []
     @row = row
+    @_limit = limit
+    @_offset = offset
     @subquery_name = nil
   end
 
@@ -316,36 +416,65 @@ class Query
   end
 
   def map(&blk)
-    if @row
-      return Query.from(self).map(&blk)
-    end
+    return Query.from(self).map(&blk) if @row
 
     result = expr(&blk).call(*get_from_rows)
     Query.new(
       @froms,
       @conditions,
       @grouped_keys,
-      Row.new(result.class.members, result)
+      @order_bys,
+      Row.new(result.class.members, result),
+      @_limit,
+      @_offset
     )
   end
 
   def has?(column_name)
-    rows.any? {|r| r.has?(column_name)}
+    rows.any? { |r| r.has?(column_name) }
   end
 
   def rows
-    if @row
-      return [@row]
-    end
+    return [@row] if @row
 
     get_from_rows
   end
 
-  def group_by(&blk)
-    if @row
-      return Query.from(self).group_by(&blk)
+  def order_by(&blk)
+    return Query.from(self).order_by(&blk) if @row
+
+    result = expr(&blk).call(*get_from_rows)
+
+    if result.is_a?(OrderedByExpr)
+      result = [result]
+    elsif result.is_a?(Expr)
+      result = OrderedByExpr.new(result)
     end
 
+    Query.new(
+      @froms,
+      @conditions,
+      @grouped_keys,
+      @order_bys + result,
+      @row,
+      @_limit,
+      @_offset
+    )
+  end
+
+  def limit(number)
+    @_limit = number
+    self
+  end
+
+  def offset(number)
+    @_offset = number
+    self
+  end
+
+  def group_by(&blk)
+    return Query.from(self).group_by(&blk) if @row
+
     result = expr(&blk).call(*get_from_rows)
 
     if result.is_a?(Column)
@@ -365,94 +494,125 @@ class Query
     perform_join(:left_join, other, &blk)
   end
 
+  def right_join(other, &blk)
+    perform_join(:right_join, other, &blk)
+  end
+
+  def cross_join(other)
+    perform_join(:cross_join, other)
+  end
+
+  def cross_join_unnest(ordinality = false, &blk)
+    return Query.from(self).cross_join_unnest(ordinality, &blk) if @row || @conditions.size.positive? || @order_bys.size.positive? || @_limit || @_offset
+
+    result = expr(&blk).call(*get_from_rows)
+    row = Row.new(result.class.members, result)
+    from = CrossJoinUnnest.new(From.new(Table.new(result.class, 't')), row, ordinality)
+    Query.new(
+      @froms + [from],
+      @conditions,
+      @grouped_keys,
+    )
+  end
+
   def where(&blk)
-    if @row
-      return Query.from(self).where(&blk)
-    end
+    return Query.from(self).where(&blk) if @row
 
     condition = expr(&blk).call(*get_from_rows)
     Query.new(
       @froms,
       @conditions + [condition],
       @grouped_keys,
-      @row
+      @order_bys,
+      @row,
+      @_limit,
+      @_offset
     )
   end
 
   def subquery_name
-    if is_vanilla
-      return @froms.first.source.subquery_name
-    end
+    return @froms.first.source.subquery_name if is_vanilla
 
-    if @subquery_name.nil?
-      raise ArgumentError.new("The query #{self.inspect} doesn't have a subquery name")
-    end
+    raise ArgumentError, "The query #{inspect} doesn't have a subquery name" if @subquery_name.nil?
 
     @subquery_name
   end
 
-  def subquery_name=(value)
-    @subquery_name = value
-  end
+  attr_writer :subquery_name
 
   def sql
-    s = "select "
-    s += rows.map {|r| r.decl_sql}.join(', ')
-    s += " from"
+    s = 'select '
+    s += rows.map(&:decl_sql).join(', ')
+    s += ' from'
 
     @froms.each_with_index do |from, index|
-      if index >= 1
-        if from.join_type == :join
-          s += " join"
-        elsif from.join_type == :left_join
-          s += " left join"
-        else
-          raise ArgumentError.new("The join type #{from.join_type} is not supoprted.")
+      if from.is_a?(From)
+        if index >= 1
+          if from.join_type == :join
+            s += ' join'
+          elsif from.join_type == :left_join
+            s += ' left join'
+          elsif from.join_type == :right_join
+            s += ' right join'
+          elsif from.join_type == :cross_join
+            s += ' cross join'
+          else
+            raise ArgumentError, "The join type #{from.join_type} is not supoprted."
+          end
         end
-      end
 
-      s += " #{from.source.subquery_name}"
+        s += " #{from.source.subquery_name}"
 
-      if from.source.subquery_name != from.alias_name
-        s += " #{from.alias_name}"
-      end
+        s += " #{from.alias_name}" if from.source.subquery_name != from.alias_name
 
-      if from.condition
-        s += " on #{from.condition.ref_sql}"
+        s += " on #{from.condition.ref_sql}" if from.condition
+      elsif from.is_a?(CrossJoinUnnest)
+        origins, cols = from.rows.first.columns.map {|c| [c.origin.ref_sql, c.name]}.transpose
+        s += " cross join unnest (#{origins.join(', ')})"
+        if from.ordinality
+          s += ' with ordinality'
+          cols.push('ordinal')
+        end
+        s += " as #{from.from.source.table_name} (#{cols.join(', ')})"
+      else
+        raise ArgumentError.new("From doesn't support #{from.inspect}")
       end
     end
 
-    if @conditions.size > 0
-      s += " where #{@conditions.map {|c| c.ref_sql}.join(' and ')}"
+    s += " where #{@conditions.map(&:ref_sql).join(' and ')}" if @conditions.size.positive?
+
+    s += " group by #{@grouped_keys.map(&:ref_sql).join(', ')}" if @grouped_keys.size.positive?
+
+    s += " order by #{@order_bys.map(&:sql).join(', ')}" if @order_bys.size.positive?
+
+    if @_offset
+      s += " offset #{@_offset}"
     end
 
-    if @grouped_keys.size > 0
-      s += " group by #{@grouped_keys.map {|k| k.ref_sql}.join(', ')}"
+    if @_limit
+      s += " limit #{@_limit}"
     end
 
     s
   end
 
   private
+
   def get_from_rows
-    @froms.map {|f| f.rows.map {|r|r.with_from(f)}}.flatten
+    @froms.map { |f| f.rows.map { |r| r.with_from(f) } }.flatten
   end
 
   def get_next_alias
-    alias_names = @froms.map {|f|f.raw_alias_name}.compact
+    alias_names = @froms.map(&:raw_alias_name).compact
     index = 0
     alias_names.sort.each do |name|
-      if name == "alias#{index}"
-        index += 1
-      end
+      index += 1 if name == "alias#{index}"
     end
     "alias#{index}"
   end
 
   def perform_join(join_type, other, &blk)
-    if @row || @conditions.size > 0
-      return Query.from(self).send(:perform_join, join_type, other, &blk)
-    end
+    return Query.from(self).send(:perform_join, join_type, other, &blk) if @row || @conditions.size.positive? || @order_bys.size.positive? || @_limit || @_offset
 
     alias_name = nil
     @froms.each do |from|
@@ -463,13 +623,16 @@ class Query
     end
 
     other_from = From.new(other, join_type, nil, alias_name)
-    condition = expr(&blk).call(*(get_from_rows + other_from.rows.map {|r|r.with_from(other_from)}))
-    other_from.condition = condition
+    if blk
+      condition = expr(&blk).call(*(get_from_rows + other_from.rows.map { |r| r.with_from(other_from) }))
+      other_from.condition = condition
+    end
 
     Query.new(
       @froms + [other_from],
       @conditions,
       @grouped_keys,
+      @order_bys,
       @row
     )
   end
@@ -477,9 +640,9 @@ end
 
 class IfElse
   def initialize(cond, true_result, false_result)
-    @condition = cond
-    @true_result = true_result
-    @false_result = false_result
+    @condition = lit(cond)
+    @true_result = lit(true_result)
+    @false_result = lit(false_result)
   end
 
   def ref_sql
@@ -491,11 +654,11 @@ class IfElse
   end
 
   def ==(other)
-    other.class == self.class && other.state == self.state
+    other.class == self.class && other.state == state
   end
 
   def state
-    self.instance_variables.map { |variable| self.instance_variable_get variable }
+    instance_variables.map { |variable| instance_variable_get variable }
   end
 end
 
@@ -509,16 +672,12 @@ def generate_sql(query)
 
   sql = ''
 
-  if queries.size > 0
-    sql += 'with '
-  end
+  sql += 'with ' if queries.size.positive?
 
-  queries.map.with_index do |query, index|
-    if index > 0
-      sql += ', '
-    end
-    query.subquery_name = "subquery#{index}"
-    sql += "#{query.subquery_name} as (\n#{query.sql}\n)\n"
+  queries.map.with_index do |q, index|
+    sql += ', ' if index.positive?
+    q.subquery_name = "subquery#{index}"
+    sql += "#{q.subquery_name} as (\n#{q.sql}\n)\n"
   end
 
   sql += last_query.sql
@@ -531,11 +690,12 @@ def fill(query)
 
   queries = []
   query.froms.each do |from|
-    if from.source.is_a?(Query)
-      subqueries = fill(from.source)
-      subqueries.each do |subquery|
-        queries.push(subquery)
-      end
+    next if from.is_a?(CrossJoinUnnest)
+    next unless from.source.is_a?(Query)
+
+    subqueries = fill(from.source)
+    subqueries.each do |subquery|
+      queries.push(subquery)
     end
   end
   queries.push(query)
@@ -544,22 +704,6 @@ end
 
 $ruby2ruby = Ruby2Ruby.new
 
-def search_for_expr_block(parsed)
-  # s(:iter, s(:call, nil, :expr)
-
-  if parsed[0] == :iter && parsed[1][0] == :call && parsed[1][1].nil? && parsed[1][2] == :expr
-    return parsed[3]
-  end
-
-  parsed.each do |component|
-    if component.is_a?(Sexp)
-      return search_for_expr_block(component)
-    end
-  end
-
-  nil
-end
-
 def rewrite(parsed)
   parsed = parsed.map do |component|
     if component.is_a?(Sexp)
@@ -569,8 +713,25 @@ def rewrite(parsed)
     end
   end
 
-  if parsed[0] == :call && parsed[2] == :==
-    parsed[2] = :eq
+  if parsed[0] == :call
+    if parsed[2] == :==
+      parsed[2] = :eq
+    elsif parsed[2] == :!=
+      parsed[2] = :ne
+    elsif parsed[2] == :!
+      parsed[2] = :not
+    elsif parsed[2] == :-@
+      parsed[2] = :minus
+    elsif parsed[2] == :+@
+      parsed[2] = :plus
+    elsif parsed[2] == :nil?
+      parsed = Sexp.new(
+        :call,
+        parsed[1],
+        :eq,
+        Sexp.new(:nil)
+      )
+    end
   elsif parsed[0] == :and
     parsed = Sexp.new(
       :call,
@@ -578,20 +739,6 @@ def rewrite(parsed)
       :and,
       parsed[2]
     )
-  elsif parsed[0] == :str
-    parsed = Sexp.new(
-      :call,
-      Sexp.new(:const, :Literal),
-      :new,
-      Sexp.new(:str, parsed[1])
-    )
-  elsif parsed[0] == :lit && (parsed[1].is_a?(Integer) || parsed[1].is_a?(Float))
-    parsed = Sexp.new(
-      :call,
-      Sexp.new(:const, :Literal),
-      :new,
-      Sexp.new(:lit, parsed[1])
-    )
   elsif parsed[0] == :case && parsed[2] && parsed[2][0] == :in
     parsed = Sexp.new(
       :call,
@@ -606,14 +753,7 @@ def rewrite(parsed)
       :ifElse,
       parsed[1],
       parsed[2],
-      parsed[3],
-    )
-  elsif parsed[0] == :nil
-    parsed = Sexp.new(
-      :call,
-      Sexp.new(:const, :Literal),
-      :new,
-      Sexp.new(:nil)
+      parsed[3]
     )
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lilit-sql
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Tanin Na Nakorn
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-27 00:00:00.000000000 Z
+date: 2023-06-29 00:00:00.000000000 Z
 dependencies: []
 description: |-
   lilit-sql is a Ruby DSL for composing production-grade analytical SQLs