rgviz 0.2 → 0.3

data/lib/rgviz/nodes.rb

@@ -0,0 +1,437 @@
+module Rgviz
+  class Query
+    attr_accessor :select
+    attr_accessor :where
+    attr_accessor :group_by
+    attr_accessor :pivot
+    attr_accessor :order_by
+    attr_accessor :limit
+    attr_accessor :offset
+    attr_accessor :labels
+    attr_accessor :formats
+    attr_accessor :options
+    
+    def accept(visitor)
+      if visitor.visitQuery self
+        select.accept visitor if select
+        where.accept visitor if where
+        group_by.accept visitor if group_by
+        pivot.accept visitor if pivot
+        order_by.accept visitor if order_by
+        labels.each{|x| x.accept visitor} if labels
+        formats.each{|x| x.accept visitor} if formats
+        options.each{|x| x.accept visitor} if options
+      end
+      visitor.endVisitQuery self
+    end
+    
+    def to_s
+      str = ''
+      if select
+        if select.empty?
+          str << "select * "
+        else
+          str << "select #{select.to_s} "
+        end
+      end
+      str << "where #{where} " if where
+      str << "group_by #{group_by} " if group_by
+      str << "pivot #{pivot} " if pivot
+      str << "order by #{order_by} " if order_by
+      str << "limit #{limit} " if limit
+      str << "offset #{offset} " if offset
+      str << "label #{labels.map(&:to_s).join(', ')} " if labels
+      str << "format #{formats.map(&:to_s).join(', ')} " if formats
+      str << "options #{options.map(&:to_s).join(', ')} " if options
+      str.strip
+    end
+  end
+
+  class ColumnsContainer
+    attr_accessor :columns
+    
+    def initialize
+      @columns = []
+    end
+    
+    def to_s
+      @columns.map(&:to_s).join(', ')
+    end
+  end
+
+  class Select < ColumnsContainer
+    def accept(visitor)
+      if visitor.visitSelect(self)
+        columns.each{|x| x.accept visitor}
+      end
+      visitor.endVisitSelect self
+    end
+  end
+
+  class GroupBy < ColumnsContainer
+    def accept(visitor)
+      if visitor.visitGroupBy(self)
+        columns.each{|x| x.accept visitor}
+      end
+      visitor.endVisitGroupBy self
+    end
+  end
+
+  class Pivot < ColumnsContainer
+    def accept(visitor)
+      if visitor.visitPivot(self)
+        columns.each{|x| x.accept visitor}
+      end
+      visitor.endVisitPivot self
+    end
+  end
+
+  class OrderBy
+    attr_accessor :sorts
+    
+    def initialize
+      @sorts = []
+    end
+    
+    def accept(visitor)
+      if visitor.visitOrderBy(self)
+        sorts.each{|x| x.accept visitor}
+      end
+      visitor.endVisitOrderBy self
+    end
+    
+    def to_s
+      @sorts.map(&:to_s).join(', ')
+    end
+  end
+
+  class Sort
+
+    Asc = :asc
+    Desc = :desc
+
+    attr_accessor :column
+    attr_accessor :order
+    
+    def initialize(column, order)
+      @column = column
+      @order = order
+    end
+    
+    def accept(visitor)
+      if visitor.visitSort(self)
+        column.accept visitor
+      end
+      visitor.endVisitSort self
+    end
+    
+    def to_s
+      "#{column} #{order}"
+    end
+  end
+
+  class Where
+    attr_accessor :expression
+    
+    def initialize(expression)
+      @expression = expression
+    end
+    
+    def accept(visitor)
+      if visitor.visitWhere(self)
+        expression.accept visitor
+      end
+      visitor.endVisitWhere self
+    end
+    
+    def to_s
+      @expression.to_s
+    end
+  end
+
+  class Label
+    attr_accessor :column
+    attr_accessor :label
+    
+    def initialize(column, label)
+      @column = column
+      @label = label
+    end
+    
+    def accept(visitor)
+      if visitor.visitLabel(self)
+        column.accept visitor
+      end
+      visitor.endVisitLabel self
+    end
+    
+    def to_s
+      "#{column} `#{label}`" 
+    end
+  end
+  
+  class Format
+    attr_accessor :column
+    attr_accessor :pattern
+    
+    def initialize(column, pattern)
+      @column = column
+      @pattern = pattern
+    end
+    
+    def accept(visitor)
+      if visitor.visitFormat(self)
+        column.accept visitor
+      end
+      visitor.endVisitFormat self
+    end
+    
+    def to_s
+      "#{column} `#{pattern}`" 
+    end
+  end
+
+  class Option
+
+    NoValues = :no_values
+    NoFormat = :no_format
+    
+    attr_accessor :option
+    
+    def initialize(option)
+      @option = option
+    end
+    
+    def accept(visitor)
+      visitor.visitOption(self)
+      visitor.endVisitOption self
+    end
+    
+    def to_s
+      @option.to_s
+    end
+
+  end
+
+  class BinaryExpression
+    And = :and
+    Contains = :contains
+    EndsWith = :ends_with
+    Eq = :EQ
+    Gt = :GT
+    Gte = :GTE
+    Like = :like
+    Lt = :LT
+    Lte = :LTE
+    Matches = :matches
+    Neq = :NEQ
+    Or = :or
+    StartsWith = :starts_with
+
+    attr_accessor :operator
+    attr_accessor :left
+    attr_accessor :right
+    
+    def initialize(left, operator, right)
+      @left = left
+      @operator = operator
+      @right = right
+    end
+    
+    def accept(visitor)
+      if visitor.visitBinaryExpression(self)
+        left.accept visitor
+        right.accept visitor
+      end
+      visitor.endVisitBinaryExpression self
+    end
+    
+    def to_s
+      "#{left} #{operator} #{right}"
+    end
+  end
+
+  class UnaryExpression
+    Not = :not
+    IsNull = :is_null
+    IsNotNull = :is_not_null
+    
+    attr_accessor :operand
+    attr_accessor :operator
+    
+    def initialize(operand, operator)
+      @operand = operand
+      @operator = operator
+    end
+    
+    def accept(visitor)
+      if visitor.visitUnaryExpression(self)
+        operand.accept visitor
+      end
+      visitor.endVisitUnaryExpression self
+    end
+    
+    def to_s
+      "#{operand} #{operator}"
+    end
+  end
+
+  class IdColumn
+    attr_accessor :name
+    
+    def initialize(name)
+      @name = name
+    end
+    
+    def accept(visitor)
+      visitor.visitIdColumn(self)
+      visitor.endVisitIdColumn self
+    end
+    
+    def to_s
+      @name
+    end
+  end
+
+  class ValueColumn
+    attr_accessor :value
+    
+    def initialize(value)
+      @value = value
+    end
+    
+    def to_s
+      value.to_s
+    end
+  end
+
+  class NumberColumn < ValueColumn
+    def accept(visitor)
+      visitor.visitNumberColumn(self)
+      visitor.endVisitNumberColumn self
+    end
+  end
+
+  class StringColumn < ValueColumn
+    def accept(visitor)
+      visitor.visitStringColumn(self)
+      visitor.endVisitStringColumn self
+    end
+    
+    def to_s
+      "'#{value}'"
+    end
+  end
+
+  class BooleanColumn < ValueColumn
+    def accept(visitor)
+      visitor.visitBooleanColumn(self)
+      visitor.endVisitBooleanColumn self
+    end
+  end
+
+  class DateColumn < ValueColumn
+    def accept(visitor)
+      visitor.visitDateColumn(self)
+      visitor.endVisitDateColumn self
+    end
+  end
+
+  class DateTimeColumn < ValueColumn
+    def accept(visitor)
+      visitor.visitDateTimeColumn(self)
+      visitor.endVisitDateTimeColumn self
+    end
+  end
+
+  class TimeOfDayColumn < ValueColumn
+    def accept(visitor)
+      visitor.visitTimeOfDayColumn(self)
+      visitor.endVisitTimeOfDayColumn self
+    end
+    
+    def to_s
+      "#{value.hour}:#{value.min}:#{value.sec}"
+    end
+  end
+
+  class ScalarFunctionColumn
+
+    DateDiff = :datediff
+    Day = :day
+    DayOfWeek = :dayofweek
+    Difference = :difference
+    Hour = :hour
+    Lower = :lower
+    Millisecond = :millisecond
+    Minute = :minute
+    Month = :month
+    Now = :now
+    Product = :product
+    Quarter = :quarter
+    Quotient = :quotient
+    Second = :second
+    Sum = :sum
+    ToDate = :todate
+    Upper = :upper
+    Year = :year
+
+    attr_accessor :function
+    attr_accessor :arguments
+    
+    def initialize(function, *arguments)
+      @function = function
+      @arguments = arguments
+    end
+    
+    def accept(visitor)
+      if visitor.visitScalarFunctionColumn(self)
+        arguments.each{|x| x.accept visitor}
+      end
+      visitor.endVisitScalarFunctionColumn self
+    end
+    
+    def to_s
+      case function
+      when Sum
+        "#{arguments[0].to_s} + #{arguments[1].to_s}"
+      when Difference
+        "#{arguments[0].to_s} + #{arguments[1].to_s}"
+      when Product
+        "#{arguments[0].to_s} * #{arguments[1].to_s}"
+      when Quotient
+        "#{arguments[0].to_s} / #{arguments[1].to_s}"
+      else
+        "#{function}(#{arguments.map(&:to_s).join(', ')})"
+      end
+    end
+  end
+
+  class AggregateColumn
+
+    Avg = :avg
+    Count = :count
+    Max = :max
+    Min = :min
+    Sum = :sum
+
+    attr_accessor :function
+    attr_accessor :argument
+    
+    def initialize(function, argument)
+      @function = function
+      @argument = argument
+    end
+    
+    def accept(visitor)
+      if visitor.visitAggregateColumn(self)
+        argument.accept visitor
+      end
+      visitor.endVisitAggregateColumn self
+    end
+
+    def to_s
+      "#{function}(#{argument})"
+    end
+  end
+end