sql-parser-tl 0.0.3

data/lib/sql-parser/statement.rb

@@ -0,0 +1,556 @@
+module SQLParser
+  
+  module Statement
+    
+    class Node
+      
+      def accept(visitor)
+        klass = self.class.ancestors.find do |ancestor|
+          visitor.respond_to?("visit_#{demodulize(ancestor.name)}")
+        end
+
+        if klass
+          visitor.__send__("visit_#{demodulize(klass.name)}", self)
+        else
+          raise "No visitor for #{self.class.name}"
+        end
+      end
+
+      def to_sql
+        SQLVisitor.new.visit(self)
+      end
+
+      private
+
+      def demodulize(str)
+        str.split('::')[-1]
+      end
+      
+    end
+    
+    class Insert < Node
+      
+      def initialize(table_reference, column_list, in_value_list)
+        @table_reference = table_reference
+        @column_list = column_list
+        @in_value_list = in_value_list
+      end
+
+      attr_reader :table_reference
+      attr_reader :column_list
+      attr_reader :in_value_list
+      
+    end
+    
+    class DirectSelect < Node
+      
+      def initialize(query_expression, order_by = nil, limit_clause = nil)
+        @query_expression = query_expression
+        @order_by = order_by
+        @limit_clause = limit_clause
+      end
+
+      attr_reader :query_expression
+      attr_reader :order_by
+      attr_reader :limit_clause
+      
+    end
+
+    class OrderBy < Node
+      
+      def initialize(sort_specification)
+        @sort_specification = Array(sort_specification)
+      end
+
+      attr_reader :sort_specification
+      
+    end
+
+    class Subquery < Node
+      
+      def initialize(query_specification)
+        @query_specification = query_specification
+      end
+
+      attr_reader :query_specification
+      
+    end
+
+    class Select < Node
+      def initialize(list, table_expression = nil)
+        @list = list
+        @table_expression = table_expression
+      end
+
+      attr_reader :list
+      attr_reader :table_expression
+      
+    end
+
+    class SelectList < Node
+      
+      def initialize(columns)
+        @columns = Array(columns)
+      end
+
+      attr_reader :columns
+      
+    end
+
+    class Distinct < Node
+      
+      def initialize(column)
+        @column = column
+      end
+
+      attr_reader :column
+      
+    end
+
+    class All < Node
+    end
+
+    class TableExpression < Node
+      
+      def initialize(from_clause, where_clause = nil, group_by_clause = nil, having_clause = nil)
+        @from_clause = from_clause
+        @where_clause = where_clause
+        @group_by_clause = group_by_clause
+        @having_clause = having_clause
+      end
+
+      attr_reader :from_clause
+      attr_reader :where_clause
+      attr_reader :group_by_clause
+      attr_reader :having_clause
+      
+    end
+
+    class FromClause < Node
+      
+      def initialize(tables)
+        @tables = Array(tables)
+      end
+
+      attr_reader :tables
+      
+    end
+
+    class OrderClause < Node
+      
+      def initialize(columns)
+        @columns = Array(columns)
+      end
+
+      attr_reader :columns
+      
+    end
+
+    class OrderSpecification < Node
+      
+      def initialize(column)
+        @column = column
+      end
+
+      attr_reader :column
+      
+    end
+
+    class Ascending < OrderSpecification
+    end
+
+    class Descending < OrderSpecification
+    end
+
+    class HavingClause < Node
+      
+      def initialize(search_condition)
+        @search_condition = search_condition
+      end
+
+      attr_reader :search_condition
+      
+    end
+
+    class GroupByClause < Node
+      
+      def initialize(columns)
+        @columns = Array(columns)
+      end
+
+      attr_reader :columns
+      
+    end
+
+    class WhereClause < Node
+      
+      def initialize(search_condition)
+        @search_condition = search_condition
+      end
+
+      attr_reader :search_condition
+      
+    end
+
+    class LimitClause < Node
+
+      def initialize(limit, offset)
+        @limit = limit
+        @offset = offset
+      end
+
+      attr_reader :limit
+      attr_reader :offset
+    end
+
+    class On < Node
+      
+      def initialize(search_condition)
+        @search_condition = search_condition
+      end
+
+      attr_reader :search_condition
+      
+    end
+
+    class SearchCondition < Node
+      
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      attr_reader :left
+      attr_reader :right
+      
+    end
+
+    class Using < Node
+      
+      def initialize(columns)
+        @columns = Array(columns)
+      end
+
+      attr_reader :columns
+      
+    end
+
+    class Or < SearchCondition
+    end
+
+    class And < SearchCondition
+    end
+
+    class Exists < Node
+      
+      def initialize(table_subquery)
+        @table_subquery = table_subquery
+      end
+
+      attr_reader :table_subquery
+      
+    end
+
+    class ComparisonPredicate < Node
+      
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      attr_reader :left
+      attr_reader :right
+      
+    end
+
+    class Is < ComparisonPredicate
+    end
+
+    class Like < ComparisonPredicate
+    end
+
+    class In < ComparisonPredicate
+    end
+
+    class InValueList < Node
+      
+      def initialize(values)
+        @values = values
+      end
+
+      attr_reader :values
+      
+    end
+    
+    class InColumnList < Node
+      
+      def initialize(columns)
+        @columns = columns
+      end
+
+      attr_reader :columns
+      
+    end
+
+    class Between < ComparisonPredicate
+    end
+
+    class BetweenRange < Node
+
+      def initialize(min, max)
+        @min = min
+        @max = max
+      end
+
+      attr_reader :min
+      attr_reader :max
+
+    end
+
+    class GreaterOrEquals < ComparisonPredicate
+    end
+
+    class LessOrEquals < ComparisonPredicate
+    end
+
+    class Greater < ComparisonPredicate
+    end
+
+    class Less < ComparisonPredicate
+    end
+
+    class Equals < ComparisonPredicate
+    end
+
+    class Aggregate < Node
+      
+      def initialize(column)
+        @column = column
+      end
+
+      attr_reader :column
+      
+    end
+
+    class Sum < Aggregate
+    end
+
+    class Minimum < Aggregate
+    end
+
+    class Maximum < Aggregate
+    end
+
+    class Average < Aggregate
+    end
+
+    class Count < Aggregate
+    end
+
+    class JoinedTable < Node
+      
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      attr_reader :left
+      attr_reader :right
+      
+    end
+
+    class CrossJoin < JoinedTable
+    end
+
+    class QualifiedJoin < JoinedTable
+      
+      def initialize(left, right, search_condition)
+        super(left, right)
+        @search_condition = search_condition
+      end
+
+      attr_reader :search_condition
+      
+    end
+
+    class InnerJoin < QualifiedJoin
+    end
+
+    class LeftJoin < QualifiedJoin
+    end
+
+    class LeftOuterJoin < QualifiedJoin
+    end
+
+    class RightJoin < QualifiedJoin
+    end
+
+    class RightOuterJoin < QualifiedJoin
+    end
+
+    class FullJoin < QualifiedJoin
+    end
+
+    class FullOuterJoin < QualifiedJoin
+    end
+
+    class QualifiedColumn < Node
+      
+      def initialize(table, column)
+        @table = table
+        @column = column
+      end
+
+      attr_reader :table
+      attr_reader :column
+      
+    end
+
+    class Identifier < Node
+      
+      def initialize(name)
+        @name = name
+      end
+
+      attr_reader :name
+      
+    end
+
+    class Table < Identifier
+    end
+
+    class Column < Identifier
+    end
+
+    class As < Node
+      
+      def initialize(original, _alias)
+        @original = original
+        @alias = _alias
+      end
+
+      attr_reader :original
+      attr_reader :alias
+
+    end
+
+    class IndexHint < Node
+
+      def initialize(table, index)
+        @table = table
+        @index = index
+      end
+
+      attr_reader :table
+      attr_reader :index
+
+    end
+
+    class ForceIndex < IndexHint
+    end
+
+    class UseIndex < IndexHint
+    end
+
+    class IgnoreIndex < IndexHint
+    end
+
+    class Arithmetic < Node
+      
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      attr_reader :left
+      attr_reader :right
+      
+    end
+
+    class Multiply < Arithmetic
+    end
+
+    class Divide < Arithmetic
+    end
+
+    class Add < Arithmetic
+    end
+
+    class Subtract < Arithmetic
+    end
+
+    class Unary < Node
+      
+      def initialize(value)
+        @value = value
+      end
+
+      attr_reader :value
+      
+    end
+
+    class Not < Unary
+    end
+
+    class UnaryPlus < Unary
+    end
+
+    class UnaryMinus < Unary
+    end
+
+    class CurrentUser < Node
+    end
+
+    class True < Node
+    end
+
+    class False < Node
+    end
+
+    class Null < Node
+    end
+
+    class Literal < Node
+      
+      def initialize(value)
+        @value = value
+      end
+
+      attr_reader :value
+      
+    end
+
+    class DateTime < Literal
+    end
+
+    class Date < Literal
+    end
+
+    class String < Literal
+
+      def +(other)
+        self.class.new(@value + other.value)
+      end
+
+    end
+
+    class ApproximateFloat < Node
+      
+      def initialize(mantissa, exponent)
+        @mantissa = mantissa
+        @exponent = exponent
+      end
+
+      attr_reader :mantissa
+      attr_reader :exponent
+      
+    end
+
+    class Float < Literal
+    end
+
+    class Integer < Literal
+    end
+    
+  end
+end

data/lib/sql-parser/version.rb

@@ -0,0 +1,5 @@
+module SQLParser
+
+  VERSION = '0.0.3'
+
+end

data/lib/sql-parser.rb

@@ -0,0 +1,13 @@
+module SQLParser
+
+  require 'strscan'
+  require 'date'
+
+  require 'racc/parser'
+
+  require_relative 'sql-parser/version'
+  require_relative 'sql-parser/statement'
+  require_relative 'sql-parser/sql_visitor'
+  require_relative 'sql-parser/parser.racc.rb'
+
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: sql-parser-tl
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Tony Liu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-11-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: racc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.12
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.12
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rexical
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: " A Racc-based Ruby parser for SQL statements; forked from https://github.com/cryodex/sql-parser "
+email: tony.liu@servicenow.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sql-parser.rb
+- lib/sql-parser/parser.racc
+- lib/sql-parser/parser.racc.rb
+- lib/sql-parser/parser.rex
+- lib/sql-parser/parser.rex.rb
+- lib/sql-parser/sql_visitor.rb
+- lib/sql-parser/statement.rb
+- lib/sql-parser/version.rb
+homepage: https://gitlab.servicenow.net/SWAT/dev/sql-parser
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.22
+signing_key: 
+specification_version: 4
+summary: Ruby library for parsing SQL statements
+test_files: []