arel_toolkit 0.2.0 → 0.4.3

data/lib/arel/middleware/database_executor.rb

@@ -0,0 +1,77 @@
+module Arel
+  module Middleware
+    class DatabaseExecutor
+      attr_reader :middleware
+
+      attr_accessor :index
+      attr_reader :context
+      attr_reader :final_block
+
+      def initialize(middleware)
+        @middleware = middleware
+      end
+
+      def run(arel, context, final_block)
+        @index = 0
+        @context = context
+        @final_block = final_block
+
+        result = call(arel)
+        check_return_type result
+        result
+      ensure
+        @index = 0
+        @context = nil
+        @final_block = nil
+      end
+
+      def call(next_arel)
+        check_argument_type next_arel
+
+        current_middleware = middleware[index]
+
+        return execute_sql(next_arel) if current_middleware.nil?
+
+        self.index += 1
+
+        case current_middleware.method(:call).arity
+        when 2
+          current_middleware.call(next_arel, self)
+        else
+          current_middleware.call(next_arel, self, context.dup)
+        end
+      end
+
+      private
+
+      def execute_sql(next_arel)
+        sql, binds = next_arel.to_sql_and_binds
+
+        context[:cache_accessor].write(
+          transformed_sql: sql,
+          transformed_binds: binds,
+          original_sql: context[:original_sql],
+          original_binds: context[:original_binds],
+        )
+
+        sql_result = final_block.call(sql, binds)
+
+        check_return_type sql_result
+        sql_result
+      end
+
+      def check_argument_type(next_arel)
+        return if next_arel.is_a?(Arel::Enhance::Node)
+
+        raise "Only `Arel::Enhance::Node` is valid for middleware, passed `#{next_arel.class}`"
+      end
+
+      def check_return_type(return_object)
+        return if return_object.is_a?(Arel::Middleware::Result)
+
+        raise 'Object returned from middleware needs to be wrapped in `Arel::Middleware::Result`' \
+              " for object `#{return_object}`"
+      end
+    end
+  end
+end

data/lib/arel/middleware/no_op_cache.rb

@@ -0,0 +1,9 @@
+module Arel
+  module Middleware
+    module NoOpCache
+      def self.read(key); end
+
+      def self.write(key, sql); end
+    end
+  end
+end

data/lib/arel/middleware/postgresql_adapter.rb

@@ -0,0 +1,62 @@
+module Arel
+  module Middleware
+    module PostgreSQLAdapter
+      def initialize(*args)
+        Arel.middleware.none do
+          super(*args)
+        end
+      end
+
+      def execute(sql, name = nil)
+        super(sql, name)
+      end
+
+      alias parent_execute execute
+
+      # rubocop:disable Lint/DuplicateMethods
+      def execute(sql, name = nil)
+        Arel::Middleware.current_chain.execute(sql) do |processed_sql|
+          Arel::Middleware::Result.create(
+            data: parent_execute(processed_sql, name),
+            from: Arel::Middleware::PGResult,
+            to: Arel::Middleware::PGResult,
+          )
+        end
+      end
+      # rubocop:enable Lint/DuplicateMethods
+
+      def query(sql, name = nil)
+        Arel::Middleware.current_chain.execute(sql) do |processed_sql|
+          # NOTE: we're not calling `super` here, but execute.
+          # The `query` super does not return the columns, like the other methods.
+          # As we want the result objects to be the same, we call execute instead.
+          Arel::Middleware::Result.create(
+            data: parent_execute(processed_sql, name),
+            from: Arel::Middleware::PGResult,
+            to: Arel::Middleware::ArrayResult,
+          )
+        end
+      end
+
+      def exec_no_cache(sql, name, binds)
+        Arel::Middleware.current_chain.execute(sql, binds) do |processed_sql, processed_binds|
+          Arel::Middleware::Result.create(
+            data: super(processed_sql, name, processed_binds),
+            from: Arel::Middleware::PGResult,
+            to: Arel::Middleware::PGResult,
+          )
+        end
+      end
+
+      def exec_cache(sql, name, binds)
+        Arel::Middleware.current_chain.execute(sql, binds) do |processed_sql, processed_binds|
+          Arel::Middleware::Result.create(
+            data: super(processed_sql, name, processed_binds),
+            from: Arel::Middleware::PGResult,
+            to: Arel::Middleware::PGResult,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/arel/middleware/railtie.rb

@@ -0,0 +1,25 @@
+module Arel
+  module Middleware
+    if defined? Rails::Railtie
+      class Railtie < Rails::Railtie
+        initializer 'arel.middleware.insert' do
+          ActiveSupport.on_load :active_record do
+            Arel::Middleware::Railtie.insert
+          end
+        end
+      end
+    end
+
+    class Railtie
+      def self.insert
+        ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(
+          Arel::Middleware::PostgreSQLAdapter,
+        )
+
+        ActiveRecord::Base.singleton_class.prepend(
+          Arel::Middleware::ActiveRecordExtension,
+        )
+      end
+    end
+  end
+end

data/lib/arel/middleware/result.rb

@@ -0,0 +1,170 @@
+module Arel
+  module Middleware
+    class Column
+      attr_reader :name
+      attr_reader :metadata
+
+      def initialize(name, metadata)
+        @name = name
+        @metadata = metadata
+      end
+    end
+
+    # Class is very similar to ActiveRecord::Result
+    # activerecord/lib/active_record/result.rb
+    class Result
+      attr_reader :original_data
+
+      def self.create(from:, to:, data:)
+        Result.new from, to, data
+      end
+
+      def initialize(from_caster, to_caster, original_data)
+        @from_caster = from_caster
+        @to_caster = to_caster
+        @original_data = original_data
+        @modified = false
+      end
+
+      def columns
+        @columns ||= column_objects.map(&:name)
+      end
+
+      def column_objects
+        @column_objects ||= from_caster.column_objects(original_data)
+      end
+
+      def rows
+        @rows ||= from_caster.rows(original_data)
+      end
+
+      def remove_column(column_name)
+        column_index = columns.index(column_name)
+        raise "Unknown column `#{column_name}`. Existing columns: `#{columns}`" if column_index.nil?
+
+        @hash_rows = nil
+        @columns = nil
+        @modified = true
+
+        column_objects.delete_at(column_index)
+        deleted_rows = []
+
+        rows.map! do |row|
+          deleted_rows << row.delete_at(column_index)
+          row
+        end
+
+        deleted_rows
+      end
+
+      def hash_rows
+        @hash_rows ||=
+          begin
+            rows.map do |row|
+              hash = {}
+
+              index = 0
+              length = columns.length
+
+              while index < length
+                hash[columns[index]] = row[index]
+                index += 1
+              end
+
+              hash
+            end
+          end
+      end
+
+      def to_casted_result
+        to_caster.cast_to(self)
+      end
+
+      def modified?
+        @modified
+      end
+
+      private
+
+      attr_reader :to_caster, :from_caster
+    end
+
+    class PGResult
+      class << self
+        def column_objects(pg_result)
+          pg_result.fields.each_with_index.map do |field, index|
+            Column.new(
+              field,
+              tableid: pg_result.ftable(index),
+              columnid: pg_result.ftablecol(index),
+              format: pg_result.fformat(index),
+              typid: pg_result.ftype(index),
+              typlen: pg_result.fsize(index),
+              atttypmod: pg_result.fmod(index),
+            )
+          end
+        end
+
+        def rows(data)
+          data.values
+        end
+
+        def cast_to(result)
+          return result.original_data unless result.modified?
+
+          pg_columns = result_to_columns(result)
+          conn = ActiveRecord::Base.connection.raw_connection
+          new_result = PgResultInit.create(conn, result.original_data, pg_columns, result.rows)
+          result.original_data.clear
+          new_result
+        end
+
+        private
+
+        def result_to_columns(result)
+          result.column_objects.map do |column|
+            {
+              name: column.name,
+              tableid: column.metadata.fetch(:tableid, 0),
+              columnid: column.metadata.fetch(:columnid, 0),
+              format: column.metadata.fetch(:format, 0),
+              typid: column.metadata.fetch(:typid),
+              typlen: column.metadata.fetch(:typlen),
+              atttypmod: column.metadata.fetch(:atttypmod, -1),
+            }
+          end
+        end
+      end
+    end
+
+    class EmptyPGResult < PGResult
+      class << self
+        def cast_to(_result)
+          ActiveRecord::Base.connection.raw_connection.make_empty_pgresult(2)
+        end
+      end
+    end
+
+    class ArrayResult
+      def self.cast_to(result)
+        result.rows
+      end
+    end
+
+    class StringResult
+      class << self
+        def column_objects(_string)
+          []
+        end
+
+        def rows(_string)
+          []
+        end
+
+        def cast_to(result)
+          result.original_data
+        end
+      end
+    end
+  end
+end

data/lib/arel/middleware/to_sql_executor.rb

@@ -0,0 +1,15 @@
+module Arel
+  module Middleware
+    class ToSqlExecutor < DatabaseExecutor
+      private
+
+      def execute_sql(next_arel)
+        Arel::Middleware::Result.create(
+          data: next_arel.to_sql,
+          from: Arel::Middleware::StringResult,
+          to: Arel::Middleware::EmptyPGResult,
+        )
+      end
+    end
+  end
+end

data/lib/arel/middleware/to_sql_middleware.rb

@@ -0,0 +1,33 @@
+module Arel
+  module Middleware
+    class ToSqlMiddleware
+      attr_reader :sql, :type, :query_class
+
+      def initialize(type)
+        @sql = []
+        @type = type
+        @query_class = class_from_type
+      end
+
+      def call(next_arel, next_middleware)
+        sql << next_arel.to_sql unless next_arel.query(class: query_class).empty?
+        next_middleware.call(next_arel)
+      end
+
+      private
+
+      def class_from_type
+        case type
+        when :insert
+          Arel::Nodes::InsertStatement
+        when :select
+          Arel::Nodes::SelectStatement
+        when :update
+          Arel::Nodes::UpdateStatement
+        when :delete
+          Arel::Nodes::DeleteStatement
+        end
+      end
+    end
+  end
+end

data/lib/arel/sql_to_arel.rb

@@ -1,8 +1,12 @@
-require 'arel/sql_to_arel/pg_query_visitor'
-require 'arel/sql_to_arel/unbound_column_reference'
+require_relative './sql_to_arel/result'
+require_relative './sql_to_arel/error'
+require_relative './sql_to_arel/pg_query_visitor'
 
 module Arel
-  def self.sql_to_arel(sql)
-    SqlToArel::PgQueryVisitor.new.accept(sql)
+  module SqlToArel
+  end
+
+  def self.sql_to_arel(sql, binds: [])
+    SqlToArel::PgQueryVisitor.new.accept(sql, binds)
   end
 end

data/lib/arel/sql_to_arel/error.rb

@@ -0,0 +1,6 @@
+module Arel
+  module SqlToArel
+    class Error < StandardError
+    end
+  end
+end

data/lib/arel/sql_to_arel/pg_query_visitor.rb

@@ -6,7 +6,7 @@
 # rubocop:disable Metrics/ParameterLists
 
 require 'pg_query'
-require_relative './frame_options'
+require_relative './pg_query_visitor/frame_options'
 
 module Arel
   module SqlToArel
@@ -15,13 +15,24 @@ module Arel
       MIN_MAX_EXPR = 'MinMaxExpr'.freeze
 
       attr_reader :object
+      attr_reader :binds
+      attr_reader :sql
 
-      def accept(sql)
+      def accept(sql, binds = [])
         tree = PgQuery.parse(sql).tree
-        raise 'https://github.com/mvgijssel/arel_toolkit/issues/33' if tree.length > 1
 
-        @object = tree.first
-        visit object, :top
+        @object = tree
+        @binds = binds
+        @sql = sql
+
+        Result.new visit(object, :top)
+      rescue ::PgQuery::ParseError => e
+        new_error = ::PgQuery::ParseError.new(e.message, __FILE__, __LINE__, -1)
+        raise new_error, e.message, e.backtrace
+      rescue ::StandardError => e
+        raise e.class, e.message, e.backtrace if e.is_a?(Arel::SqlToArel::Error)
+
+        boom e.message, e.backtrace
       end
 
       private
@@ -72,7 +83,7 @@ module Arel
           Arel::Nodes::NullIf.new(left, right)
 
         when PgQuery::AEXPR_OF
-          raise 'https://github.com/mvgijssel/arel_toolkit/issues/34'
+          boom 'https://github.com/mvgijssel/arel_toolkit/issues/34'
 
         when PgQuery::AEXPR_IN
           left = visit(lexpr)
@@ -91,7 +102,7 @@ module Arel
           escape = nil
 
           if right.is_a?(Array)
-            raise "Don't know how to handle length `#{right.length}`" if right.length != 2
+            boom "Don't know how to handle length `#{right.length}`" if right.length != 2
 
             right, escape = right
           end
@@ -110,7 +121,7 @@ module Arel
           escape = nil
 
           if right.is_a?(Array)
-            raise "Don't know how to handle length `#{right.length}`" if right.length != 2
+            boom "Don't know how to handle length `#{right.length}`" if right.length != 2
 
             right, escape = right
           end
@@ -129,7 +140,7 @@ module Arel
           escape = nil
 
           if right.is_a?(Array)
-            raise "Don't know how to handle length `#{right.length}`" if right.length != 2
+            boom "Don't know how to handle length `#{right.length}`" if right.length != 2
 
             right, escape = right
           end
@@ -164,10 +175,10 @@ module Arel
           Arel::Nodes::NotBetweenSymmetric.new left, Arel::Nodes::And.new(right)
 
         when PgQuery::AEXPR_PAREN
-          raise 'https://github.com/mvgijssel/arel_toolkit/issues/35'
+          boom 'https://github.com/mvgijssel/arel_toolkit/issues/35'
 
         else
-          raise "Unknown Expr type `#{kind}`"
+          boom "Unknown Expr type `#{kind}`"
         end
       end
 
@@ -176,7 +187,7 @@ module Arel
       end
 
       def visit_A_Indirection(arg:, indirection:)
-        Arel::Nodes::Indirection.new(visit(arg, :operator), visit(indirection, :operator))
+        Arel::Nodes::Indirection.new(visit(arg), visit(indirection, :operator))
       end
 
       def visit_A_Star
@@ -184,7 +195,7 @@ module Arel
       end
 
       def visit_Alias(aliasname:)
-        aliasname
+        Arel.sql visit_String(nil, str: aliasname)
       end
 
       def visit_BitString(str:)
@@ -205,7 +216,7 @@ module Arel
                    Arel::Nodes::Not.new(args)
 
                  else
-                   raise "? Boolop -> #{boolop}"
+                   boom "? Boolop -> #{boolop}"
                  end
 
         if context
@@ -238,7 +249,7 @@ module Arel
           Arel::Nodes::NotEqual.new(arg, Arel::Nodes::Unknown.new)
 
         else
-          raise '?'
+          boom '?'
         end
       end
 
@@ -269,8 +280,21 @@ module Arel
         Arel::Nodes::Coalesce.new args
       end
 
-      def visit_ColumnRef(context = nil, fields:)
-        UnboundColumnReference.new visit(fields, context).join('.')
+      def visit_ColumnRef(fields:)
+        fields = fields.reverse
+        column = visit(fields[0], :operator)
+        table = visit(fields[1], :operator) if fields[1]
+        schema_name = visit(fields[2], :operator) if fields[2]
+        database = visit(fields[3], :operator) if fields[3]
+
+        table = Arel::Table.new(table) if table
+        attribute = Arel::Attribute.new(table, column)
+        attribute.schema_name = schema_name
+        attribute.database = database
+
+        return attribute if table
+
+        Arel::Nodes::UnqualifiedColumn.new Arel::Attribute.new(nil, column)
       end
 
       def visit_CommonTableExpr(ctename:, ctequery:)
@@ -283,6 +307,15 @@ module Arel
         Arel::Nodes::CurrentOfExpression.new(cursor_name)
       end
 
+      def visit_DefElem(defname:, arg:, defaction:)
+        case defname
+        when 'savepoint_name'
+          visit(arg)
+        else
+          boom "Unknown defname `#{defname}` with defaction `#{defaction}`"
+        end
+      end
+
       def visit_DeleteStmt(
         relation:,
         using_clause: nil,
@@ -332,15 +365,9 @@ module Arel
                when ['sum']
                  Arel::Nodes::Sum.new args
 
-               when ['rank']
-                 Arel::Nodes::Rank.new args
-
                when ['count']
                  Arel::Nodes::Count.new args
 
-               when ['generate_series']
-                 Arel::Nodes::GenerateSeries.new args
-
                when ['max']
                  Arel::Nodes::Max.new args
 
@@ -356,10 +383,55 @@ module Arel
                when [PG_CATALOG, 'similar_escape']
                  args
 
-               else
-                 raise "Don't know how to handle `#{function_names}`" if function_names.length > 1
+               when [PG_CATALOG, 'date_part']
+                 field, expression = args
+                 [Arel::Nodes::ExtractFrom.new(expression, field)]
+
+               when [PG_CATALOG, 'timezone']
+                 timezone, expression = args
+
+                 [Arel::Nodes::AtTimeZone.new(maybe_add_grouping(expression), timezone)]
+
+               # https://www.postgresql.org/docs/10/functions-string.html
+               when [PG_CATALOG, 'position']
+                 string, substring = args
+                 [Arel::Nodes::Position.new(substring, string)]
+
+               when [PG_CATALOG, 'overlay']
+                 string, substring, start, length = args
+                 [Arel::Nodes::Overlay.new(string, substring, start, length)]
+
+               when [PG_CATALOG, 'ltrim']
+                 string, substring = args
+                 [Arel::Nodes::Trim.new('leading', substring, string)]
+
+               when [PG_CATALOG, 'rtrim']
+                 string, substring = args
+                 [Arel::Nodes::Trim.new('trailing', substring, string)]
+
+               when [PG_CATALOG, 'btrim']
+                 string, substring = args
+                 [Arel::Nodes::Trim.new('both', substring, string)]
+
+               when [PG_CATALOG, 'substring']
+                 string, pattern, escape = args
+                 [Arel::Nodes::Substring.new(string, pattern, escape)]
+
+               when [PG_CATALOG, 'overlaps']
+                 start1, end1, start2, end2 = args
+                 [Arel::Nodes::Overlaps.new(start1, end1, start2, end2)]
 
-                 Arel::Nodes::NamedFunction.new(function_names.first, args)
+               else
+                 case function_names.length
+                 when 2
+                   func = Arel::Nodes::NamedFunction.new(function_names.last, args)
+                   func.schema_name = function_names.first
+                   func
+                 when 1
+                   Arel::Nodes::NamedFunction.new(function_names.first, args)
+                 else
+                   boom "Don't know how to handle function names length `#{function_names.length}`"
+                 end
                end
 
         func.distinct = (agg_distinct.nil? ? false : true) unless func.is_a?(::Array)
@@ -376,17 +448,16 @@ module Arel
       end
 
       def visit_InferClause(conname: nil, index_elems: nil)
-        infer = Arel::Nodes::Infer.new
-        infer.name = Arel.sql(conname) if conname
-        infer.indexes = visit(index_elems) if index_elems
-        infer
+        left = Arel.sql(conname) if conname
+        right = visit(index_elems) if index_elems
+        Arel::Nodes::Infer.new left, right
       end
 
       def visit_IndexElem(name:, ordering:, nulls_ordering:)
-        raise "Unknown ordering `#{ordering}`" unless ordering.zero?
-        raise "Unknown nulls ordering `#{ordering}`" unless nulls_ordering.zero?
+        boom "Unknown ordering `#{ordering}`" unless ordering.zero?
+        boom "Unknown nulls ordering `#{ordering}`" unless nulls_ordering.zero?
 
-        Arel.sql(name)
+        Arel.sql visit_String(str: name)
       end
 
       def visit_InsertStmt(
@@ -418,7 +489,7 @@ module Arel
         end
 
         insert_statement.returning = visit(returning_list, :select)
-        insert_statement.on_conflict = visit(on_conflict_clause) if on_conflict_clause
+        insert_statement.conflict = visit(on_conflict_clause) if on_conflict_clause
         insert_manager
       end
 
@@ -426,6 +497,12 @@ module Arel
         ival
       end
 
+      def visit_IntoClause(rel:, on_commit:)
+        raise "Unknown on_commit `#{on_commit}`" unless on_commit.zero?
+
+        Arel::Nodes::Into.new(visit(rel))
+      end
+
       def visit_JoinExpr(jointype:, is_natural: nil, larg:, rarg:, quals: nil)
         join_class = case jointype
                      when 0
@@ -463,12 +540,12 @@ module Arel
           1 => 'FOR KEY SHARE',
           2 => 'FOR SHARE',
           3 => 'FOR NO KEY UPDATE',
-          4 => 'FOR UPDATE'
+          4 => 'FOR UPDATE',
         }.fetch(strength)
         wait_policy_clause = {
           0 => '',
           1 => ' SKIP LOCKED',
-          2 => ' NOWAIT'
+          2 => ' NOWAIT',
         }.fetch(wait_policy)
 
         Arel::Nodes::Lock.new Arel.sql("#{strength_clause}#{wait_policy_clause}")
@@ -481,10 +558,17 @@ module Arel
         when 1
           Arel::Nodes::Least.new visit(args)
         else
-          raise "Unknown Op -> #{op}"
+          boom "Unknown Op -> #{op}"
         end
       end
 
+      def visit_NamedArgExpr(arg:, name:, argnumber:)
+        arg = visit(arg)
+        boom '' unless argnumber == -1
+
+        Arel::Nodes::NamedArgument.new(name, arg)
+      end
+
       def visit_Null(**_)
         Arel.sql 'NULL'
       end
@@ -509,29 +593,36 @@ module Arel
         conflict
       end
 
-      def visit_ParamRef(_args)
-        Arel::Nodes::BindParam.new(nil)
-      end
+      def visit_ParamRef(number: nil)
+        value = (binds[number - 1] unless binds.empty?)
 
-      def visit_RangeFunction(is_rowsfrom:, functions:, lateral: false, ordinality: false)
-        raise 'https://github.com/mvgijssel/arel_toolkit/issues/36' unless is_rowsfrom == true
+        Arel::Nodes::BindParam.new(value)
+      end
 
+      def visit_RangeFunction(
+        is_rowsfrom: nil,
+        functions:,
+        lateral: false,
+        ordinality: false,
+        aliaz: nil
+      )
         functions = functions.map do |function_array|
           function, empty_value = function_array
-          raise 'https://github.com/mvgijssel/arel_toolkit/issues/37' unless empty_value.nil?
+          boom 'https://github.com/mvgijssel/arel_toolkit/issues/37' unless empty_value.nil?
 
           visit(function)
         end
 
-        node = Arel::Nodes::RangeFunction.new functions
+        node = Arel::Nodes::RangeFunction.new functions, is_rowsfrom: is_rowsfrom
         node = lateral ? Arel::Nodes::Lateral.new(node) : node
-        ordinality ? Arel::Nodes::WithOrdinality.new(node) : node
+        node = ordinality ? Arel::Nodes::WithOrdinality.new(node) : node
+        aliaz.nil? ? node : Arel::Nodes::As.new(node, visit(aliaz))
       end
 
       def visit_RangeSubselect(aliaz:, subquery:, lateral: false)
         aliaz = visit(aliaz)
         subquery = visit(subquery)
-        node = Arel::Nodes::TableAlias.new(Arel::Nodes::Grouping.new(subquery), aliaz)
+        node = Arel::Nodes::As.new(Arel::Nodes::Grouping.new(subquery), aliaz)
         lateral ? Arel::Nodes::Lateral.new(node) : node
       end
 
@@ -545,8 +636,8 @@ module Arel
         )
       end
 
-      def visit_RawStmt(context, stmt:)
-        visit(stmt, context)
+      def visit_RawStmt(context, **args)
+        visit(args.fetch(:stmt), context)
       end
 
       def visit_ResTarget(context, val: nil, name: nil)
@@ -555,19 +646,21 @@ module Arel
           val = visit(val)
 
           if name
-            Arel::Nodes::As.new(val, Arel.sql(name))
+            aliaz = visit_Alias(aliasname: name)
+            Arel::Nodes::As.new(val, aliaz)
           else
             val
           end
         when :insert
           name
         when :update
-          Arel::Nodes::Equality.new(
-            Arel.sql(visit_String(str: name)),
-            visit(val),
-          )
+          relation = nil
+          column = Arel::Attribute.new(relation, name)
+          value = visit(val)
+
+          Nodes::Assignment.new(Nodes::UnqualifiedColumn.new(column), value)
         else
-          raise "Unknown context `#{context}`"
+          boom "Unknown context `#{context}`"
         end
       end
 
@@ -591,6 +684,7 @@ module Arel
         op:,
         window_clause: nil,
         values_lists: nil,
+        into_clause: nil,
         all: nil,
         larg: nil,
         rarg: nil
@@ -600,14 +694,32 @@ module Arel
         select_statement = select_manager.ast
 
         froms, join_sources = generate_sources(from_clause)
+        if froms
+          froms = froms.first if froms.length == 1
+          select_core.froms = froms
+        end
+
         select_core.from = froms if froms
         select_core.source.right = join_sources
 
         select_core.projections = visit(target_list, :select) if target_list
-        select_core.wheres = [visit(where_clause)] if where_clause
+
+        if where_clause
+          where_clause = visit(where_clause)
+          where_clause = if where_clause.is_a?(Arel::Nodes::And)
+                           where_clause
+                         else
+                           Arel::Nodes::And.new([where_clause])
+                         end
+
+          select_core.wheres = [where_clause]
+        end
+
         select_core.groups = visit(group_clause) if group_clause
         select_core.havings = [visit(having_clause)] if having_clause
         select_core.windows = visit(window_clause) if window_clause
+        select_core.into = visit(into_clause) if into_clause
+        select_core.top = ::Arel::Nodes::Top.new visit(limit_count) if limit_count
 
         if distinct_clause == [nil]
           select_core.set_quantifier = Arel::Nodes::Distinct.new
@@ -616,7 +728,7 @@ module Arel
         elsif distinct_clause.nil?
           select_core.set_quantifier = nil
         else
-          raise "Unknown distinct clause `#{distinct_clause}`"
+          boom "Unknown distinct clause `#{distinct_clause}`"
         end
 
         select_statement.limit = ::Arel::Nodes::Limit.new visit(limit_count) if limit_count
@@ -632,12 +744,14 @@ module Arel
                 value
               when Integer
                 Arel.sql(value.to_s)
-              when Arel::Nodes::TypeCast
+              when Arel::Nodes::TypeCast, Arel::Nodes::UnqualifiedColumn
                 Arel.sql(value.to_sql)
               when Arel::Nodes::BindParam
                 value
+              when Arel::Nodes::Quoted
+                value.value
               else
-                raise "Unknown value `#{value}`"
+                boom "Unknown value `#{value}`"
               end
             end
           end
@@ -667,7 +781,7 @@ module Arel
                   end
                 else
                   # https://www.postgresql.org/docs/10/queries-union.html
-                  raise "Unknown combining queries op `#{op}`"
+                  boom "Unknown combining queries op `#{op}`"
                 end
 
         unless union.nil?
@@ -723,7 +837,7 @@ module Arel
         when :operator
           str
         when :const
-          Arel.sql "'#{str}'"
+          Arel::Nodes.build_quoted str
         else
           "\"#{str}\""
         end
@@ -735,7 +849,7 @@ module Arel
         operator = if oper_name
                      operator = visit(oper_name, :operator)
                      if operator.length > 1
-                       raise 'https://github.com/mvgijssel/arel_toolkit/issues/39'
+                       boom 'https://github.com/mvgijssel/arel_toolkit/issues/39'
                      end
 
                      operator.first
@@ -744,24 +858,51 @@ module Arel
         generate_sublink(sub_link_type, subselect, testexpr, operator)
       end
 
+      def visit_TransactionStmt(kind:, options: nil)
+        Arel::Nodes::Transaction.new(
+          kind,
+          (visit(options) if options),
+        )
+      end
+
       def visit_TypeCast(arg:, type_name:)
         arg = visit(arg)
         type_name = visit(type_name)
 
-        Arel::Nodes::TypeCast.new(arg, type_name)
+        Arel::Nodes::TypeCast.new(maybe_add_grouping(arg), type_name)
       end
 
-      def visit_TypeName(names:, typemod:)
+      def visit_TypeName(names:, typemod:, array_bounds: [])
+        array_bounds = visit(array_bounds)
+
         names = names.map do |name|
           visit(name, :operator)
         end
 
         names = names.reject { |name| name == PG_CATALOG }
 
-        raise 'https://github.com/mvgijssel/arel_toolkit/issues/40' if typemod != -1
-        raise 'https://github.com/mvgijssel/arel_toolkit/issues/41' if names.length > 1
+        boom 'https://github.com/mvgijssel/arel_toolkit/issues/40' if typemod != -1
+        boom 'https://github.com/mvgijssel/arel_toolkit/issues/41' if names.length > 1
+        if array_bounds != [] && array_bounds != [-1]
+          boom 'https://github.com/mvgijssel/arel_toolkit/issues/86'
+        end
 
-        names.first
+        type_name = names.first
+        type_name = case type_name
+                    when 'int4'
+                      'integer'
+                    when 'float4'
+                      'real'
+                    when 'float8'
+                      'double precision'
+                    when 'timestamptz'
+                      'timestamp with time zone'
+                    else
+                      type_name
+                    end
+
+        type_name << '[]' if array_bounds == [-1]
+        type_name
       end
 
       def visit_UpdateStmt(
@@ -786,6 +927,19 @@ module Arel
         update_manager
       end
 
+      def visit_VariableSetStmt(kind:, name:, args: [], is_local: false)
+        Arel::Nodes::VariableSet.new(
+          kind,
+          visit(args),
+          name,
+          is_local,
+        )
+      end
+
+      def visit_VariableShowStmt(name:)
+        Arel::Nodes::VariableShow.new(name)
+      end
+
       def visit_WindowDef(
         partition_clause: [],
         order_clause: [],
@@ -794,8 +948,11 @@ module Arel
         start_offset: nil,
         end_offset: nil
       )
-        instance = name.nil? ? Arel::Nodes::Window.new : Arel::Nodes::NamedWindow.new(name)
+        if name.present? && partition_clause.empty? && order_clause.empty?
+          return Arel::Nodes::SqlLiteral.new(name)
+        end
 
+        instance = name.nil? ? Arel::Nodes::Window.new : Arel::Nodes::NamedWindow.new(name)
         instance.tap do |window|
           window.orders = visit order_clause
           window.partitions = visit partition_clause
@@ -819,13 +976,20 @@ module Arel
       end
 
       def generate_operator(left, right, operator)
+        left = maybe_add_grouping(left)
+        right = maybe_add_grouping(right)
+
         case operator
 
         # https://www.postgresql.org/docs/10/functions-math.html
         when '+'
           Arel::Nodes::Addition.new(left, right)
         when '-'
-          Arel::Nodes::Subtraction.new(left, right)
+          if left.nil?
+            Arel::Nodes::UnaryOperation.new(:'-', right)
+          else
+            Arel::Nodes::Subtraction.new(left, right)
+          end
         when '*'
           Arel::Nodes::Multiplication.new(left, right)
         when '/'
@@ -849,9 +1013,17 @@ module Arel
         when '|'
           Arel::Nodes::BitwiseOr.new(left, right)
         when '#'
-          Arel::Nodes::BitwiseXor.new(left, right)
+          if left.nil?
+            Arel::Nodes::UnaryOperation.new(:'#', right)
+          else
+            Arel::Nodes::BitwiseXor.new(left, right)
+          end
         when '~'
-          Arel::Nodes::BitwiseNot.new(right)
+          if left.nil?
+            Arel::Nodes::BitwiseNot.new(right)
+          else
+            Arel::Nodes::Regexp.new(left, right, true)
+          end
         when '<<'
           Arel::Nodes::BitwiseShiftLeft.new(left, right)
         when '>>'
@@ -881,11 +1053,59 @@ module Arel
         when '||'
           Arel::Nodes::Concat.new(left, right)
 
+        # https://www.postgresql.org/docs/9.3/functions-net.html
+        when '<<='
+          Arel::Nodes::ContainedWithinEquals.new(left, right)
+        when '>>='
+          Arel::Nodes::ContainsEquals.new(left, right)
+
+        # https://www.postgresql.org/docs/9.4/functions-json.html
+        when '->'
+          Arel::Nodes::JsonGetObject.new(left, right)
+        when '->>'
+          Arel::Nodes::JsonGetField.new(left, right)
+        when '#>'
+          Arel::Nodes::JsonPathGetObject.new(left, right)
+        when '#>>'
+          Arel::Nodes::JsonPathGetField.new(left, right)
+
+        # https://www.postgresql.org/docs/9.4/functions-json.html#FUNCTIONS-JSONB-OP-TABLE
+        when '?'
+          Arel::Nodes::JsonbKeyExists.new(left, right)
+        when '?|'
+          if left.nil?
+            Arel::Nodes::UnaryOperation.new(:'?|', right)
+          else
+            Arel::Nodes::JsonbAnyKeyExists.new(left, right)
+          end
+        when '?&'
+          Arel::Nodes::JsonbAllKeyExists.new(left, right)
+
+        # https://www.postgresql.org/docs/9.3/functions-matching.html#FUNCTIONS-POSIX-TABLE
+        when '~*'
+          Arel::Nodes::Regexp.new(left, right, false)
+        when '!~'
+          Arel::Nodes::NotRegexp.new(left, right, true)
+        when '!~*'
+          Arel::Nodes::NotRegexp.new(left, right, false)
+
         else
-          raise "Unknown operator `#{operator}`"
+          if left.nil?
+            Arel::Nodes::UnaryOperation.new(operator, right)
+          else
+            Arel::Nodes::InfixOperation.new(operator, left, right)
+          end
         end
       end
 
+      def visit_DeallocateStmt(name: nil)
+        Arel::Nodes::Dealocate.new name
+      end
+
+      def visit_PrepareStmt(name:, argtypes: nil, query:)
+        Arel::Nodes::Prepare.new name, argtypes && visit(argtypes), visit(query)
+      end
+
       def visit(attribute, context = nil)
         return attribute.map { |attr| visit(attr, context) } if attribute.is_a? Array
 
@@ -972,27 +1192,55 @@ module Arel
           generate_operator(testexpr, Arel::Nodes::All.new(subselect), operator)
 
         when PgQuery::SUBLINK_TYPE_ANY
-          generate_operator(testexpr, Arel::Nodes::Any.new(subselect), operator)
+          if operator.nil?
+            Arel::Nodes::In.new(testexpr, subselect)
+          else
+            generate_operator(testexpr, Arel::Nodes::Any.new(subselect), operator)
+          end
 
         when PgQuery::SUBLINK_TYPE_ROWCOMPARE
-          raise 'https://github.com/mvgijssel/arel_toolkit/issues/42'
+          boom 'https://github.com/mvgijssel/arel_toolkit/issues/42'
 
         when PgQuery::SUBLINK_TYPE_EXPR
           Arel::Nodes::Grouping.new(subselect)
 
         when PgQuery::SUBLINK_TYPE_MULTIEXPR
-          raise 'https://github.com/mvgijssel/arel_toolkit/issues/43'
+          boom 'https://github.com/mvgijssel/arel_toolkit/issues/43'
 
         when PgQuery::SUBLINK_TYPE_ARRAY
           Arel::Nodes::ArraySubselect.new(subselect)
 
         when PgQuery::SUBLINK_TYPE_CTE
-          raise 'https://github.com/mvgijssel/arel_toolkit/issues/44'
+          boom 'https://github.com/mvgijssel/arel_toolkit/issues/44'
 
         else
-          raise "Unknown sublinktype: #{type}"
+          boom "Unknown sublinktype: #{type}"
         end
       end
+
+      def maybe_add_grouping(node)
+        case node
+        when Arel::Nodes::Binary
+          Arel::Nodes::Grouping.new(node)
+        else
+          node
+        end
+      end
+
+      def boom(message, backtrace = nil)
+        new_message = <<~STRING
+
+
+          SQL: #{sql}
+          BINDS: #{binds}
+          message: #{message}
+
+        STRING
+
+        raise(Arel::SqlToArel::Error, new_message, backtrace) if backtrace
+
+        raise Arel::SqlToArel::Error, new_message
+      end
     end
   end
 end