Initial work on dynamic statement tokens

Author: solnic

lib/sql/composer/compiler.rb

@@ -1,24 +1,39 @@
 # frozen_string_literal: true
 
+require "sql/composer/statement"
+require "sql/composer/tokens"
+
 module SQL
   module Composer
     class Compiler
+      include ::Dry::Effects::Handler.State(:tokens)
+
       attr_reader :backend
 
       attr_reader :nodes
 
-      def initialize(backend)
+      attr_reader :options
+
+      attr_reader :tokens
+
+      def initialize(backend, options)
         @backend = backend
-        @nodes = []
+        @options = options
+        @nodes = options[:nodes] || []
+        @tokens = options[:tokens]
       end
 
       def call(ast)
-        ast.map { |node| visit(node) }
-        freeze
+        with_tokens(tokens) { ast.map { |node| visit(node) } }
+        Statement.new(compiler: freeze)
+      end
+
+      def with(new_options)
+        self.class.new(backend, options.merge(new_options).merge(nodes: nodes))
       end
 
       def to_s
-        nodes.map(&:to_s).join("\n")
+        with_tokens(tokens) { nodes.map(&:to_s).join("\n") }.last
       end
 
       def visit(node)

lib/sql/composer/dsl.rb

@@ -1,22 +1,33 @@
 # frozen_string_literal: true
 
+require "dry/effects"
+
 require "sql/composer/compiler"
+require "sql/composer/tokens"
 
 module SQL
   module Composer
     class DSL < BasicObject
+      include ::Dry::Effects::Handler.State(:tokens)
+
       attr_reader :options
 
       attr_reader :ast
 
+      attr_reader :tokens
+
       def initialize(options, &block)
-        @ast = []
         @options = options
-        instance_exec(*options[:args], &block)
+        @ast = []
+        @tokens = options[:tokens] || Tokens.new
+
+        with_tokens(tokens) do
+          instance_exec(*options[:args], &block)
+        end
       end
 
       def call
-        compiler = Compiler.new(options.fetch(:backend))
+        compiler = Compiler.new(options.fetch(:backend), tokens: tokens)
         compiler.(ast)
       end
 

lib/sql/composer/nodes/core.rb

@@ -1,17 +1,24 @@
 # frozen_string_literal: true
 
+require "dry/effects"
+
 module SQL
   module Composer
     module Nodes
       class Core
+        include Dry::Effects.State(:tokens)
+
+        attr_reader :id
+
         attr_reader :options
 
         def initialize(options)
           @options = options
+          @id = tokens.next_id
         end
 
-        def fetch(name)
-          @options.fetch(name)
+        def fetch(name, default = nil)
+          @options.fetch(name, default)
         end
 
         def backend

lib/sql/composer/nodes/identifier.rb

@@ -32,7 +32,15 @@ def qualify?
 
         # this is probably a stupid idea lol
         def ==(other)
-          Operations::Eql.new(self, Nodes::Value.new(input: other, backend: backend))
+          value = Nodes::Value.new(input: other, backend: backend)
+
+          operation = Operations::Eql.new(left: self, right: value)
+
+          if other.start_with?("%") && other.end_with?("%")
+            tokens.add(other, value)
+          end
+
+          operation
         end
       end
     end

lib/sql/composer/nodes/operations/eql.rb

@@ -1,18 +1,22 @@
 # frozen_string_literal: true
 
+require "sql/composer/nodes/core"
+
 module SQL
   module Composer
     module Nodes
       module Operations
-        class Eql
-          attr_reader :left, :right
+        class Eql < Core
+          def left
+            fetch(:left)
+          end
 
-          def initialize(left, right)
-            @left, @right = left, right
+          def right
+            fetch(:right)
           end
 
           def or(other)
-            Operations::Or.new(self, other)
+            Operations::Or.new(left: self, right: other)
           end
           alias_method :OR, :or
 

lib/sql/composer/nodes/operations/or.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
+require "sql/composer/nodes/core"
+
 module SQL
   module Composer
     module Nodes
       module Operations
-        class Or
-          attr_reader :left, :right
+        class Or < Core
+          def left
+            fetch(:left)
+          end
 
-          def initialize(left, right)
-            @left, @right = left, right
+          def right
+            fetch(:right)
           end
 
           def to_s

lib/sql/composer/nodes/value.rb

@@ -7,7 +7,7 @@ module Composer
     module Nodes
       class Value < Core
         def input
-          fetch(:input)
+          tokens.value(id, fetch(:input))
         end
 
         def to_s

lib/sql/composer/statement.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SQL
+  module Composer
+    class Statement
+      include Enumerable
+
+      attr_reader :options
+
+      def initialize(options)
+        @options = options
+      end
+
+      def each(&block)
+        nodes.each(&block)
+      end
+
+      def set(values)
+        tokens = compiler.tokens.new
+
+        values.each do |key, value|
+          tokens.set(key, value)
+        end
+
+        compiler.with(tokens: tokens)
+      end
+
+      def to_s
+        compiler.to_s
+      end
+
+      def compiler
+        options.fetch(:compiler)
+      end
+
+      def nodes
+        compiler.nodes
+      end
+    end
+  end
+end

lib/sql/composer/tokens.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SQL
+  module Composer
+    class Tokens
+      include Dry::Core::Constants
+
+      attr_reader :data
+
+      def initialize(data: {}, counter: 0)
+        @data = data
+        @counter = counter
+      end
+
+      def add(key, node)
+        data[key[1..-2].to_sym] = [node.id, Undefined]
+        self
+      end
+
+      def set(key, value)
+        tuple = [data[key][0], value]
+        data[key] = tuple
+        self
+      end
+
+      def new
+        self.class.new(data: data.dup, counter: @counter)
+      end
+
+      def value(id, default)
+        entry = data.detect { |_, (node_id, value)| node_id.equal?(id) }
+        entry ? entry[1][1] : default
+      end
+
+      def next_id
+        @counter += 1
+      end
+    end
+  end
+end

spec/integration/sql/compose_spec.rb

@@ -85,6 +85,30 @@ def compose(&block)
       end
     end
 
+    context "with a dynamic WHERE" do
+      let(:query) do
+        compose { |users|
+          SELECT users.id, users.name
+          FROM users.table
+          WHERE users.name == "%name%"
+        }
+      end
+
+      let(:result) do
+        query.set(name: "Jane").to_s
+      end
+
+      specify do
+        expect(result).to eql(
+          <<~SQL.strip
+            SELECT "users"."id", "users"."name"
+            FROM "users"
+            WHERE "users"."name" == 'Jane'
+          SQL
+        )
+      end
+    end
+
     context "without ORDER" do
       let(:query) do
         compose { |users|