rossoc 0.9.0

data/lib/rossoc/frontend.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'rossoc'
+
+# Rossoc
+module Rossoc
+  # Frontend
+  # rubocop:disable Metrics/ClassLength
+  class Frontend
+    class FrontendError < StandardError; end
+
+    RESERVED_PINS = %w[
+      din0 din1 din2 din3 din4 din5 din6 din7 din8 din9 din10
+      din11 din12 din13 din14 din15 din16 din17 din18 din19 din20
+      ain0 ain1 ain2 ain3 ain4 ain5 ain6 ain7 ain8 ain9 ain10
+      ain11 ain12 ain13 ain14 ain15 ain16 ain17 ain18 ain19 ain20
+    ].freeze
+
+    def initialize(input)
+      @input = input
+      @out_pins = Set.new
+      @in_pins = Set.new
+      @table = nil
+      @where = nil
+      @ast = nil
+      @sleep_sec = 0
+      @speed = 9600
+    end
+
+    def ir
+      parser(@input)
+      check_columns
+      check_tables
+      check_condition
+      check_rsleep
+      check_rspeed
+
+      Rossoc::Ir.new(@in_pins, @out_pins, @table, @where, @ast,
+                     @sleep_sec, @speed).result
+    end
+
+    private
+
+    def parser(sql)
+      parser = SQLParser::Parser.new
+      @ast = parser.scan_str(sql)
+    rescue Racc::ParseError => e
+      raise FrontendError, e
+    end
+
+    def check_columns
+      columns = @ast.query_expression.list.columns
+      columns.each do |column|
+        name = column.name
+        index = RESERVED_PINS.index(name)
+        raise FrontendError, "unknown column value #{name}." if index.nil?
+
+        @in_pins.add(name)
+        @out_pins.add(name)
+      end
+    rescue StandardError
+      raise FrontendError, 'unsupported column.'
+    end
+
+    def check_tables
+      tables = @ast.query_expression.table_expression.from_clause.tables
+      tables.each do |table|
+        @table = table.name
+      end
+    rescue e
+      raise e
+    end
+
+    def check_condition
+      begin
+        condition = if @ast.query_expression.table_expression.where_clause.nil?
+                      nil
+                    else
+                      @ast.query_expression.table_expression.where_clause.search_condition
+                    end
+      rescue e
+        raise e
+      end
+
+      if condition.nil?
+        @where = 1
+      else
+        condition_parser(condition)
+
+        tokens = condition.to_sql.split
+        tokens.each_with_index do |token, index|
+          case token
+          when '='
+            token = '=='
+          when 'AND'
+            token = '&&'
+          when 'OR'
+            token = '||'
+          when '<>'
+            token = '!='
+          end
+          tokens[index] = token.gsub('`', '')
+        end
+
+        @where = tokens.join(' ')
+      end
+    end
+
+    def condition_parser(condition)
+      root_words = ['SQLParser::Statement::Equals',
+                    'SQLParser::Statement::Greater',
+                    'SQLParser::Statement::GreaterOrEquals',
+                    'SQLParser::Statement::Less',
+                    'SQLParser::Statement::LessOrEquals',
+                    'SQLParser::Statement::And',
+                    'SQLParser::Statement::Or']
+      not_words = ['SQLParser::Statement::Not']
+      value_words = ['SQLParser::Statement::Float',
+                     'SQLParser::Statement::Integer']
+      column_words = ['SQLParser::Statement::Column']
+
+      if root_words.include?(condition.class.to_s)
+        condition_parser(condition.left)
+        condition_parser(condition.right)
+      elsif not_words.include?(condition.class.to_s)
+        condition_parser(condition.value.left)
+        condition_parser(condition.value.right)
+      elsif column_words.include?(condition.class.to_s)
+        name = condition.name
+        index = RESERVED_PINS.index(name)
+        raise FrontendError, "unknown column value #{name}." if index.nil?
+
+        @in_pins.add(name)
+      elsif value_words.include?(condition.class.to_s)
+        # none
+      else
+        raise FrontendError, "unknown token value #{condition}."
+      end
+    end
+
+    def check_rsleep
+      return if @ast.rsleep.nil?
+
+      @sleep_sec = @ast.rsleep.rsleep_specification.value
+    end
+
+    def check_rspeed
+      return if @ast.rspeed.nil?
+
+      @speed = @ast.rspeed.rspeed_specification.value
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/rossoc/ir.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'rossoc'
+
+# Rossoc
+module Rossoc
+  # Ir
+  class Ir
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(in_pins, out_pins, table, where, ast,
+                   sleep_sec, speed)
+      @in_pins = in_pins
+      @out_pins = out_pins
+      @table = table
+      @where = where
+      @ast = ast
+      @sleep = Rsleep.new(sleep_sec)
+      @speed = speed
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    # rubocop:disable Metrics/MethodLength
+    def result
+      din_pins = Set.new
+      ain_pins = Set.new
+      dout_pins = Set.new
+      aout_pins = Set.new
+
+      [@in_pins, @out_pins].each_with_index do |pins, i|
+        pins.each do |pin|
+          n = pin.gsub(/din|ain/, '').to_i
+          if pin.start_with?('din')
+            if i.zero?
+              din_pins.add(n)
+            else
+              dout_pins.add(n)
+            end
+          elsif i.zero?
+            ain_pins.add(n)
+          else
+            aout_pins.add(n)
+          end
+        end
+      end
+
+      {
+        din_pins: din_pins,
+        ain_pins: ain_pins,
+        dout_pins: dout_pins,
+        aout_pins: aout_pins,
+        table: @table,
+        where: @where,
+        ast: @ast,
+        sleep: @sleep,
+        speed: @speed
+      }
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # RSLEEP
+    class Rsleep
+      def initialize(second)
+        @second = second
+      end
+
+      def positive?
+        @second.positive?
+      end
+
+      attr_reader :second
+
+      def millisecond
+        (@second * 1000).to_i
+      end
+    end
+  end
+end

data/lib/rossoc/parser.racc

@@ -0,0 +1,346 @@
+#
+# Original source code
+# sql-parser
+# https://github.com/cryodex/sql-parser
+#
+
+class SQLParser::Parser
+
+rule
+# dynamic sql
+
+  direct_sql_statement
+    : direct_sql_data_statement
+
+  direct_sql_data_statement
+    : direct_select_statement_multiple_rows
+    | insert_specification
+
+  direct_select_statement_multiple_rows
+    : query_expression order_by_clause rsleep_clause rspeed_clause { result = SQLParser::Statement::DirectSelect.new(val[0], val[1], val[2], val[3]) }
+
+# module contents
+  rsleep_clause
+    : # no action
+    | RSLEEP unsigned_literal { result = SQLParser::Statement::Rsleep.new(val[1]) }
+
+  rspeed_clause
+    : # no action
+    | RSPEED unsigned_literal { result = SQLParser::Statement::Rspeed.new(val[1]) }
+
+  order_by_clause
+    : # no action
+    | ORDER BY sort_specification_list { result = SQLParser::Statement::OrderBy.new(val[2]) }
+
+  sort_specification_list
+    : sort_specification_list comma sort_specification { result = Array(val[0]) + Array(val[2]) }
+    | sort_specification
+
+  sort_specification
+    : sort_key ordering_specification { result = val[1].new(val[0]) }
+
+  sort_key
+    : column_name
+    | unsigned_integer { result = SQLParser::Statement::Integer.new(val[0]) }
+
+  ordering_specification
+    : { result = SQLParser::Statement::Ascending } # default
+    | ASC { result = SQLParser::Statement::Ascending }
+    | DESC { result = SQLParser::Statement::Descending }
+
+# queries
+  subquery
+    # FIXME: shortcut
+    : left_paren query_expression right_paren { result = SQLParser::Statement::Subquery.new(val[1]) }
+
+  query_expression
+    : query_specification
+
+  insert_specification 
+    : INSERT INTO table_reference value_list { result = SQLParser::Statement::Insert.new(val[2], nil, val[3]) }
+    | INSERT INTO table_reference column_list value_list { result = SQLParser::Statement::Insert.new(val[2], val[3], val[4]) }
+
+  column_list
+    : left_paren in_column_list right_paren { result = SQLParser::Statement::InColumnList.new(val[1]) }
+ 
+  in_column_list
+    : value_expression comma in_column_list { result = Array(val[0]) + Array(val[2]) }
+	  | value_expression
+  
+  value_list
+    : VALUES left_paren in_value_list right_paren { result = SQLParser::Statement::InValueList.new(val[2]) }
+
+  query_specification
+    : SELECT select_list table_expression { result = SQLParser::Statement::Select.new(val[1], val[2]) }
+    | SELECT select_list { result = SQLParser::Statement::Select.new(val[1]) }
+
+  select_list
+    : asterisk { result = SQLParser::Statement::All.new }
+    | select_sublist { result = SQLParser::Statement::SelectList.new(val[0]) }
+
+  select_sublist
+    : derived_column comma select_sublist { result = Array(val[0]) + Array(val[2]) }
+    | derived_column
+
+  derived_column
+    : value_expression AS column_name { result = SQLParser::Statement::As.new(val[0], val[2]) }
+    | value_expression column_name { result = SQLParser::Statement::As.new(val[0], val[1]) }
+    | value_expression
+
+  table_expression
+    : from_clause where_clause group_by_clause having_clause { result = SQLParser::Statement::TableExpression.new(val[0], val[1], val[2], val[3]) }
+
+  from_clause
+    : FROM table_reference { result = SQLParser::Statement::FromClause.new(val[1]) }
+
+  table_reference
+    : table_name AS column_name { result = SQLParser::Statement::As.new(val[0], val[2]) }
+    | table_name column_name { result = SQLParser::Statement::As.new(val[0], val[1]) }
+    | table_name
+    | joined_table
+
+  table_subquery
+    : subquery
+
+  joined_table
+    : cross_join
+    | qualified_join
+
+  cross_join
+    : table_reference comma table_name { result = SQLParser::Statement::CrossJoin.new(val[0], val[2]) }
+    | table_reference CROSS JOIN table_name { result = SQLParser::Statement::CrossJoin.new(val[0], val[3]) }
+
+  qualified_join
+    : table_reference join_type JOIN table_reference join_specification { result = val[1].new(val[0], val[3], val[4]) }
+
+  join_type
+    : INNER { result = SQLParser::Statement::InnerJoin }
+    | LEFT OUTER { result = SQLParser::Statement::LeftOuterJoin }
+    | LEFT { result = SQLParser::Statement::LeftJoin }
+    | RIGHT OUTER { result = SQLParser::Statement::RightOuterJoin }
+    | RIGHT { result = SQLParser::Statement::RightJoin }
+    | FULL { result = SQLParser::Statement::FullJoin }
+    | FULL OUTER { result = SQLParser::Statement::FullOuterJoin }
+
+  join_specification
+    : join_condition
+    | named_columns_join
+
+  join_condition
+    : ON search_condition { result = SQLParser::Statement::On.new(val[1]) }
+
+  named_columns_join
+    : USING left_paren join_column_list right_paren { result = SQLParser::Statement::Using.new(val[2]) }
+
+  join_column_list
+    : column_name_list
+
+  where_clause
+    : # no action
+    | WHERE search_condition { result = SQLParser::Statement::WhereClause.new(val[1]) }
+
+  group_by_clause
+    : # no action
+    | GROUP BY grouping_column_reference_list { result = SQLParser::Statement::GroupByClause.new(val[2]) }
+
+  grouping_column_reference_list
+    : grouping_column_reference_list comma grouping_column_reference { result = Array(val[0]) + Array(val[2]) }
+    | grouping_column_reference
+
+  grouping_column_reference
+    : column_reference
+
+  having_clause
+    : # no action
+    | HAVING search_condition { result = SQLParser::Statement::HavingClause.new(val[1]) }
+
+# query expression components
+  row_subquery
+    : subquery
+
+  between_predicate
+    : row_value_constructor NOT BETWEEN row_value_constructor AND row_value_constructor { result = SQLParser::Statement::Not.new(SQLParser::Statement::Between.new(val[0], val[3], val[5])) }
+    | row_value_constructor BETWEEN row_value_constructor AND row_value_constructor { result = SQLParser::Statement::Between.new(val[0], val[2], val[4]) }
+
+  in_predicate
+    : row_value_constructor NOT IN in_predicate_value { result = SQLParser::Statement::Not.new(SQLParser::Statement::In.new(val[0], val[3])) }
+    | row_value_constructor IN in_predicate_value { result = SQLParser::Statement::In.new(val[0], val[2]) }
+
+  in_predicate_value
+    : table_subquery
+    | left_paren in_value_list right_paren { result = SQLParser::Statement::InValueList.new(val[1]) }
+
+  in_value_list
+    : value_expression comma in_value_list { result = Array(val[0]) + Array(val[2]) }
+    | value_expression
+
+  like_predicate
+    # FIXME: the SQL-92 grammar indicates these should be
+    # character_value_expression nodes, but changing them causes reduce/reduce
+    # conflicts.
+    : row_value_constructor NOT LIKE row_value_constructor { result = SQLParser::Statement::Not.new(SQLParser::Statement::Like.new(val[0], val[3])) }
+    | row_value_constructor LIKE row_value_constructor { result = SQLParser::Statement::Like.new(val[0], val[2]) }
+
+  null_predicate
+    : row_value_constructor IS NOT NULL { result = SQLParser::Statement::Not.new(SQLParser::Statement::Is.new(val[0], SQLParser::Statement::Null.new)) }
+    | row_value_constructor IS NULL { result = SQLParser::Statement::Is.new(val[0], SQLParser::Statement::Null.new) }
+
+  exists_predicate
+    : EXISTS table_subquery { result = SQLParser::Statement::Exists.new(val[1]) }
+
+# constraints
+  table_name
+    : identifier { result = SQLParser::Statement::Table.new(val[0]) }
+
+  column_name_list
+    : column_name_list comma column_name { result = Array(val[0]) + Array(val[2]) }
+    | column_name
+
+# search condition
+  search_condition
+    : boolean_term
+    | search_condition OR boolean_term { result = SQLParser::Statement::Or.new(val[0], val[2]) }
+
+  boolean_term
+    : boolean_factor
+    | boolean_term AND boolean_factor { result = SQLParser::Statement::And.new(val[0], val[2]) }
+
+  boolean_factor:
+    : NOT boolean_test { result = SQLParser::Statement::Not.new(val[1]) }
+    | boolean_test
+
+  boolean_test
+    : boolean_primary
+
+  boolean_primary
+    : predicate
+    | left_paren search_condition right_paren { result = val[1] }
+
+  predicate
+    : comparison_predicate
+    | between_predicate
+    | in_predicate
+    | like_predicate
+    | null_predicate
+    | exists_predicate
+
+  comparison_predicate
+    : row_value_constructor equals_operator row_value_constructor { result = SQLParser::Statement::Equals.new(val[0], val[2]) }
+    | row_value_constructor not_equals_operator row_value_constructor { result = SQLParser::Statement::Not.new(SQLParser::Statement::Equals.new(val[0], val[2])) }
+    | row_value_constructor less_than_operator row_value_constructor { result = SQLParser::Statement::Less.new(val[0], val[2]) }
+    | row_value_constructor greater_than_operator row_value_constructor { result = SQLParser::Statement::Greater.new(val[0], val[2]) }
+    | row_value_constructor less_than_or_equals_operator row_value_constructor { result = SQLParser::Statement::LessOrEquals.new(val[0], val[2]) }
+    | row_value_constructor greater_than_or_equals_operator row_value_constructor { result = SQLParser::Statement::GreaterOrEquals.new(val[0], val[2]) }
+
+  row_value_constructor
+    : row_value_constructor_element
+    | row_subquery
+
+  row_value_constructor_element
+    : value_expression
+
+  value_expression
+    : numeric_value_expression
+    | general_literal
+
+  numeric_value_expression
+    : term plus_sign numeric_value_expression { result = SQLParser::Statement::Add.new(val[0], val[2]) }
+    | term minus_sign numeric_value_expression { result = SQLParser::Statement::Subtract.new(val[0], val[2]) }
+    | term
+
+  term
+    : factor asterisk term { result = SQLParser::Statement::Multiply.new(val[0], val[2]) }
+    | factor solidus term { result = SQLParser::Statement::Divide.new(val[0], val[2]) }
+    | factor
+
+  factor
+    : sign value_expression_primary { result = val[0].new(val[1]) }
+    | value_expression_primary
+
+  value_expression_primary
+    : unsigned_value_specification
+    | column_reference
+    | set_function_specification
+    | left_paren value_expression right_paren { result = val[1] }
+
+  unsigned_value_specification
+    : unsigned_literal
+    | general_value_specification
+
+  unsigned_literal
+    : unsigned_numeric_literal
+    | general_literal
+
+  general_value_specification
+    : CURRENT_USER { result = SQLParser::Statement::CurrentUser.new }
+
+  column_reference
+    : qualifier period column_name { result = SQLParser::Statement::QualifiedColumn.new(val[0], val[2]) }
+    | column_name
+
+  qualifier
+    : table_name
+
+  set_function_specification
+    : COUNT left_paren asterisk right_paren { result = SQLParser::Statement::Count.new(SQLParser::Statement::All.new) }
+    | general_set_function
+
+  general_set_function
+    : COUNT left_paren value_expression right_paren { result = SQLParser::Statement::Count.new(val[2]) }
+    | AVG left_paren value_expression right_paren { result = SQLParser::Statement::Average.new(val[2]) }
+    | MAX left_paren value_expression right_paren { result = SQLParser::Statement::Maximum.new(val[2]) }
+    | MIN left_paren value_expression right_paren { result = SQLParser::Statement::Minimum.new(val[2]) }
+    | SUM left_paren value_expression right_paren { result = SQLParser::Statement::Sum.new(val[2]) }
+
+# literal numbers, strings, dates and times
+  unsigned_numeric_literal
+    : exact_numeric_literal
+    | approximate_numeric_literal
+
+  exact_numeric_literal
+    : unsigned_integer period unsigned_integer { result = SQLParser::Statement::Float.new("#{val[0]}.#{val[2]}".to_f) }
+    | unsigned_integer period { result = SQLParser::Statement::Float.new(val[0]) }
+    | period unsigned_integer { result = SQLParser::Statement::Float.new("0.#{val[1]}".to_f) }
+    | unsigned_integer { result = SQLParser::Statement::Integer.new(val[0]) }
+
+  approximate_numeric_literal
+    : mantissa E exponent { result = SQLParser::Statement::ApproximateFloat.new(val[0], val[2]) }
+
+  mantissa
+    : exact_numeric_literal
+
+  exponent
+    : signed_integer
+
+  signed_integer
+    : sign unsigned_integer { result = val[0].new(SQLParser::Statement::Integer.new(val[1])) }
+    | unsigned_integer { result = SQLParser::Statement::Integer.new(val[0]) }
+
+  sign
+    : plus_sign { result = SQLParser::Statement::UnaryPlus }
+    | minus_sign { result = SQLParser::Statement::UnaryMinus }
+
+# sql module
+  column_name
+    : identifier { result = SQLParser::Statement::Column.new(val[0]) }
+
+# literals
+  general_literal
+    : quote character_string_literal quote { result = SQLParser::Statement::String.new(val[1]) }
+    | quote quote { result = SQLParser::Statement::String.new('') }
+    | datetime_literal
+
+  datetime_literal
+    : date_literal
+
+  date_literal
+    : DATE date_string { result = SQLParser::Statement::Date.new(val[1]) }
+
+---- header ----
+require File.dirname(__FILE__) + '/parser.rex.rb'
+
+---- inner ----
+
+def self.parse(sql)
+  new.scan_str(sql)
+end