quote-sql 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e32e2e164efd0cfb007de82abb8870b13d5b432856d21af6f75faed9d2d1107
-  data.tar.gz: 141ef285fbb563e649d5c4b71faa8b1d9d67066d1c600dd9d85c7dd5ee017edc
+  metadata.gz: 70f787b04560e3b297b4a392eb72c0e85be57e349a0533366056fe485f339401
+  data.tar.gz: ad8a2e347c97e12b78a264e67d0e12649e838127a0079d8ff96bf5ac51764b40
 SHA512:
-  metadata.gz: 8e13010de0021284de07a99e33822e54b530d3d5dfbc5986028327c903b5c3ab55ceadcf0042eb7207eea8245f31f57db5811a0f902fe8f68eb9a435c02ff255
-  data.tar.gz: f178c03540bdea0b38c8278ace489954d9efff1786fa76b804950c11bf60f2ac3162f6ca3ac9f142f08dc62d830e10cd8835786618175a922b7eb183e71c89bc
+  metadata.gz: 7d2a6819ad0d7fc752a70a04efb48c7583759a1b6cd07eb93c0bacd5deec9845b4abf578ae902c94aaf68ba4cf41720b1f05aea8dc6950b468c8cc8f42c34c42
+  data.tar.gz: e84a311154ef05f71b8af81c17cac1b4923f067fb48556f501aa075ab8fca1c112d494c8b0b58f1c8350d7d7467c10ba99f74591755beb206415dbe78756c7ff

data/README.md

@@ -127,7 +127,11 @@ with optional array dimension
 ## Debug and dump
 If you have pg_format installed you can get the resulting query inspected: 
   `QuoteSql.new("select %abc").quote(abc: 1).dsql`
-  
+
+# Test
+Minimal tests you can run by
+`QuoteSql.test.all`
+You can find them in /lib/quote_sql/test.rb
 
 ## Installing
 `gem install quote-sql`

data/lib/quote_sql/error.rb

@@ -0,0 +1,47 @@
+class QuoteSql
+  class Error < ::RuntimeError
+    def initialize(quote_sql, errors)
+      @object = quote_sql
+      @errors = errors
+    end
+
+    attr_reader :object, :errors
+
+    def original
+      @object.original.dsql
+    end
+
+    def sql
+      @object.sql.dsql
+    end
+
+    def tables
+      @object.tables.inspect
+    end
+
+    def columns
+      @object.columns.inspect
+    end
+
+    def quotes
+      @object.quotes.inspect
+    end
+
+    def message
+
+      errors = @object.errors.map do |quote, error|
+        error => {exc:, backtrace:, **transformations}
+
+        "#{quote}: #{exc.class} #{exc.message} #{transformations.inspect}\n#{backtrace.join("\n")}"
+      end
+      <<~ERROR
+                Original: #{original}
+                Tables:  
+                Quotes: #{quotes} 
+                Processed: #{sql}
+        #{errors.join("\n\n")}
+        #{'*' * 40}
+      ERROR
+    end
+  end
+end

data/lib/quote_sql/formater.rb

@@ -9,11 +9,13 @@ class QuoteSql
 
     def to_formatted_sql
       sql = respond_to?(:to_sql) ? to_sql : to_s
-      IO.popen(PG_FORMAT_BIN, "r+", err: "/dev/null") do |f|
-        f.write(sql)
-        f.close_write
-        f.read
-      end
+      Niceql::Prettifier.prettify_sql(sql)
+
+      # IO.popen(PG_FORMAT_BIN, "r+", err: "/dev/null") do |f|
+      #   f.write(sql)
+      #   f.close_write
+      #   f.read
+      # end
     rescue
       sql
     end

data/lib/quote_sql/quoter.rb

@@ -3,48 +3,131 @@ class QuoteSql
     def initialize(qsql, key, quotable)
       @qsql = qsql
       @key, @quotable = key, quotable
+      @name = key.sub(/_[^_]+$/, '') if key["_"]
     end
 
-    attr_reader :key, :quotable
+    attr_reader :key, :quotable, :name
+
+    def quotes
+      @qsql.quotes
+    end
+
+    def table(name = nil)
+      @qsql.table(name || self.name)
+    end
+
+    def ident_table(i = nil)
+      Raw.sql(Array(self.table(name)).compact[0..i].map do |table|
+        if table.respond_to? :table_name
+          QuoteSql.quote_column_name table.table_name
+        elsif table.present?
+          QuoteSql.quote_column_name table
+        end
+      end.join(","))
+    end
+
+    def columns(name = nil)
+      @qsql.columns(name || self.name)
+    end
+
+    def casts(name = nil)
+      @qsql.casts(name || self.name)
+    end
+
+    def ident_columns(name = nil)
+      item = columns(name || self.name)
+      unless item
+        table = self.table(name || self.name)
+        raise ArgumntError, "No columns or table given" unless table&.respond_to? :column_names
+        item = table.column_names
+      end
+      if item.is_a?(Array)
+        if item.all? { _1.respond_to?(:name) }
+          item = item.map(&:name)
+        end
+      end
+      _ident(item)
+    end
+
+    def _quote_ident(item)
+      Raw.sql case item.class.to_s
+              when "QuoteSql::Raw", "Arel::Nodes::SqlLiteral" then item
+              when "Hash" then json_hash_ident(item)
+              when "Array" then json_array_ident(item)
+              when "Proc" then item.call(self)
+              when "Integer" then "$#{item}"
+              when "Symbol" then [ident_table(0).presence, _quote_ident(item.to_s)].compact.join(".")
+              when "String" then item.scan(/(?:^|")?([^."]+)/).flatten.map { QuoteSql.quote_column_name _1 }.join(".")
+              else raise ArgumentError, "just Hash, Array, Arel::Nodes::SqlLiteral, QuoteSql::Raw, String, Symbol, Proc, Integer, or responding to #to_sql"
+              end
+    end
+
+    def _ident(item = @quotable)
+      return Raw.sql(item) if item.respond_to?(:to_sql)
+      rv = case item.class.to_s
+           when "Array"
+             item.map { _1.is_a?(Hash) ? _ident(_1) : _quote_ident(_1) }.join(",")
+           when "Hash"
+             item.map { "#{_quote_ident(_2)} AS \"#{_1}\"" }.join(",")
+           else
+             _quote_ident(item)
+             # _quote_column_name(item)
+           end
+      Raw.sql rv
+    end
 
     def to_sql
       return @quotable.call(self) if @quotable.is_a? Proc
       case key.to_s
       when /(?:^|(.*)_)table$/i
-        table
-      when /(?:^|(.*)_)columns?$/i
-        columns
-      when /(?:^|(.*)_)(table_name?s?)$/i
-        table_name
-      when /(?:^|(.*)_)(column_name?s?)$/i
-        ident_name
-      when /(?:^|(.*)_)(ident|args)$/i
-        ident_name
+        ident_table
+      when /(?:^|(.*)_)columns$/i
+        ident_columns
+      when /(?:^|(.*)_)(ident)$/i
+        _ident
       when /(?:^|(.*)_)constraints?$/i
-        quotable.to_s
+        quotable
       when /(?:^|(.*)_)(raw|sql)$/i
-        quotable.to_s
-      when /(?:^|(.*)_)(values?)$/i
-        values
+        quotable
+      when /^(.+)_json$/i
+        data_json
+      when /^(.+)_values$/i
+        data_values
+      when /values$/i
+        insert_values
       else
         quote
       end
     end
 
-    private def value(ary)
-      column_names = @qsql.column_names
-      if ary.is_a?(Hash) and column_names.present?
-        ary = @qsql.column_names.map do |column_name|
-          if ary.key? column_name&.to_sym
-            ary[column_name.to_sym]
-          elsif column_name[/^(created|updated)_at$/]
-            :current_timestamp
-          else
-            :default
-          end
-        end
-      end
-      "(" + ary.map do |i|
+    ###############
+
+    private def value(values)
+      # case values.class.to_s
+      # when "QuoteSql::Raw", "Arel::Nodes::SqlLiteral" then rv = values
+      # when "Array"
+      # when "Hash"
+      #   columns = self.columns(name)&.flat_map { _1.is_a?(Hash) ? _1.values : _1 }
+      #   if columns.nil?
+      #     values = values.values
+      #   elsif columns.all? { _1.is_a? Symbol }
+      #     raise ArgumentError, "Columns just Symbols"
+      #   else
+      #     values = columns.map do |column|
+      #       if values.key?(column&.to_sym) or !defaults
+      #         values[column.to_sym]
+      #       elsif column[/^(created|updated)_at$/]
+      #         :current_timestamp
+      #       else
+      #         :default
+      #       end
+      #     end
+      #   end
+      # else
+      #   raise ArgumentError, "value just Array, Hash, QuoteSql::Raw, Arel::Nodes::SqlLiteral"
+      # end
+
+      rv ||= values.map do |i|
         case i
         when :default, :current_timestamp
           next i.to_s.upcase
@@ -52,28 +135,87 @@ class QuoteSql
           i = i.to_json
         end
         _quote(i)
-      end.join(",") + ")"
+      end
+      Raw.sql "(#{rv.join(",")})"
+    end
 
+    def data_json(item = @quotable)
+      casts = self.casts(name)
+      columns = self.columns(name) || casts&.keys
+      column_cast = columns&.map { "#{QuoteSql.quote_column_name(_1)} #{casts&.dig(_1) || "TEXT"}" }
+      item = [item].flatten.compact.as_json.map{_1.slice(*columns.map(&:to_s))}
+      Raw.sql "json_to_recordset('#{item.to_json.gsub(/'/,"''")}') AS #{QuoteSql.quote_column_name name}(#{column_cast.join(',')})"
     end
 
-    def values(item = @quotable)
+
+    def data_values(item = @quotable)
+      item = Array(item).compact
+      column_names = columns(name)
+      if column_names.is_a? Hash
+        types = column_names.values.map { "::#{_1.upcase}" if _1 }
+        column_names = column_names.keys
+      end
+      if item.all? { _1.is_a?(Hash) }
+        column_names ||= item.flat_map { _1.keys.sort }.uniq
+        item.map! { _1.fetch_values(*column_names) {} }
+      end
+      if item.all? { _1.is_a?(Array) }
+        length, overflow = item.map { _1.length }.uniq
+        raise ArgumentError, "all values need to have the same length" if overflow
+        column_names ||= (1..length).map { "column#{_1}" }
+        raise ArgumentError, "#{name}_columns and value lengths need to be the same" if column_names.length != length
+        values = item.map { value(_1) }
+      else
+        raise ArgumentError, "Either all type Hash or Array"
+      end
+      if types.present?
+        value = values[0][1..-2].split(/\s*,\s*/)
+        types.each_with_index { value[_2] << _1 || "" }
+        values[0] = "(" + value.join(",") + ")"
+      end
+      # values[0] { _1 << types[_1] || ""}
+      Raw.sql "(VALUES #{values.join(",")}) AS #{_ident name} (#{_ident column_names})"
+    end
+
+    def insert_values(item = @quotable)
       case item
       when Arel::Nodes::SqlLiteral
-        item = Arel.sql("(#{item})") unless item[/^\s*\(/] and item[/\)\s*$/]
+        item = Raw.sql("(#{item})") unless item[/^\s*\(/] and item[/\)\s*$/]
         return item
       when Array
+        item.compact!
+        column_names = (@qsql.quotes[:columns] || @qsql.quotes[:column_names]).dup
+        types = []
+        if column_names.is_a? Hash
+          types = column_names.values.map { "::#{_1.upcase}" if _1 }
+          column_names = column_names.keys
+        elsif column_names.is_a? Array
+          column_names = column_names.map do |column|
+            types << column.respond_to?(:sql_type) ? "::#{column.sql_type}" : nil
+            column.respond_to?(:name) ? column.name : column
+          end
+        end
 
-        differences = item.map { _1.is_a?(Array) && _1.length }.uniq
-        if differences.length == 1
-          item.compact.map { value(_1) }.join(", ")
+        if item.all? { _1.is_a?(Hash) }
+          column_names ||= item.flat_map { _1.keys.sort }.uniq
+          item.map! { _1.fetch_values(*column_names) {} }
+        end
+
+        if item.all? { _1.is_a?(Array) }
+          length, overflow = item.map { _1.length }.uniq
+          raise ArgumentError, "all values need to have the same length" if overflow
+          raise ArgumentError, "#{name}_columns and value lengths need to be the same" if column_names and column_names.length != length
+          values = item.map { value(_1) }
         else
-          value([item])
+          raise ArgumentError, "Either all type Hash or Array"
+        end
+        if column_names.present?
+          Raw.sql "(#{_ident column_names}) VALUES #{values.join(",")}"
+        else
+          Raw.sql "VALUES #{values.join(",")}"
         end
       when Hash
         value([item])
-      else
-        return item.to_sql if item.respond_to? :to_sql
-        "(" + _quote(item) + ")"
       end
     end
 
@@ -90,51 +232,31 @@ class QuoteSql
     private def _quote(item = @quotable, cast = self.cast)
       rv = QuoteSql.quote(item)
       if cast
-        rv << "::#{cast}"
+        rv << "::#{cast.upcase}"
         rv << "[]" * rv.depth if rv[/^ARRAY/]
       end
-      rv
+      Raw.sql rv
     end
 
-    private def _quote_column_name(name, column = nil)
-      name, column = name.to_s.split(".") if column.nil?
-      rv = QuoteSql.quote_column_name(name)
-      return rv unless column.present?
-      rv + "." + QuoteSql.quote_column_name(column)
+    private def _quote_column_name(name)
+      Raw.sql name.scan(/(?:^|")?([^."]+)/).map { QuoteSql.quote_column_name _1 }.join(".")
     end
 
     def quote(item = @quotable)
-      case item
-      when Arel::Nodes::SqlLiteral
-        return item
-      when Array
+      case item.class.to_s
+      when "Arel::Nodes::SqlLiteral", "QuoteSql::Raw"
+        return Raw.sql(item)
+      when "Array"
         return _quote(item.to_json) if json?
         _quote(item)
-      when Hash
-        return _quote(item.to_json) if json?
-        item.map do |as, item|
-          "#{_quote(item)} AS #{as}"
-        end.join(",")
+      when "Hash"
+        _quote(item.to_json, :jsonb)
       else
-        return item.to_sql if item.respond_to? :to_sql
+        return Raw.sql item.to_sql if item.respond_to? :to_sql
         _quote(item)
       end
     end
 
-    def columns(item = @quotable)
-      if item.respond_to?(:column_names)
-        item = item.column_names
-      elsif item.class.respond_to?(:column_names)
-        item = item.class.column_names
-      elsif item.is_a?(Array)
-        if item[0].respond_to?(:name)
-          item = item.map(&:name)
-        end
-      end
-      @qsql.column_names ||= item
-      ident_name(item)
-    end
-
     def column_names(item = @quotable)
       if item.respond_to?(:column_names)
         item = item.column_names
@@ -144,70 +266,50 @@ class QuoteSql
         item = item.map(&:name)
       end
       @qsql.column_names ||= item
-      ident_name(item)
+      _ident(item)
     end
 
-    def json_build_object(h)
-      compact = h.delete(nil) == false
-      rv = "jsonb_build_object(" + h.map { "'#{_1}',#{_2}" }.join(",") + ")"
-      return rv unless compact
-      "jsonb_strip_nulls(#{rv})"
+    def json_array_values(h)
+      Raw.sql "'#{h.to_json.gsub(/'/, "''")}'::JSONB"
     end
 
-    def ident_name(item = @quotable)
-      case item
-      when Array
-        item.map do |item|
-          case item
-          when Hash
-            ident_name(item)
-          when String, Symbol
-            _quote_column_name(item)
-          when Proc
-            item.call(self)
-          end
-        end.join(",")
-      when Hash
-        item.map do |k,v|
-          case v
-          when Symbol
-            _quote_column_name(k, v)
-          when String
-            "#{v} AS #{k}"
-          when Proc
-            item.call(self)
-          when Hash
-            "#{json_build_object(v)} AS #{k}"
-          else
-            raise ArgumentError
-          end
-        end.join(",")
-      else
-        _quote_column_name(item)
-      end
+    def json_hash_values(h)
+      compact = h.delete(nil) == false
+      rv = json_array_values(h)
+      Raw.sql(compact ? "jsonb_strip_nulls(#{rv})" : rv)
     end
 
-    def table(item = @quotable)
-      @qsql.table_name ||= if item.respond_to?(:table_name)
-                             item = item.table_name
-                           elsif item.class.respond_to?(:table_name)
-                             item = item.class.table_name
-                           end
-      table_name(item || @qsql.table_name)
+    def json_hash_ident(h)
+      compact = h.delete(nil) == false
+      rv = "jsonb_build_object(" + h.map { "'#{_1.to_s.gsub(/'/, "''")}', #{_ident(_2)}" }.join(",") + ")"
+      Raw.sql(compact ? "jsonb_strip_nulls(#{rv})" : rv)
     end
 
-    def table_name(item = @quotable)
-      case item
-      when Array
-        item.map do |item|
-          item.is_a?(Hash) ? table_name(item) : _quote_column_name(item)
-        end.join(",")
-      when Hash
-        raise NotImplementedError, "table name is a Hash"
-        # perhaps as ...
-      else
-        _quote_column_name(item)
-      end
+    def json_array_ident(h)
+      Raw.sql "jsonb_build_array(#{h.map { _ident(_2) }.join(",")})"
     end
+
+    # def table(item = @quotable)
+    #   @qsql.table_name ||= if item.respond_to?(:table_name)
+    #                          item = item.table_name
+    #                        elsif item.class.respond_to?(:table_name)
+    #                          item = item.class.table_name
+    #                        end
+    #   table_name(item || @qsql.table_name)
+    # end
+    #
+    # def table_name(item = @quotable)
+    #   case item
+    #   when Array
+    #     item.map do |item|
+    #       item.is_a?(Hash) ? table_name(item) : _quote_column_name(item)
+    #     end.join(",")
+    #   when Hash
+    #     raise NotImplementedError, "table name is a Hash"
+    #     # perhaps as ...
+    #   else
+    #     _quote_column_name(item)
+    #   end
+    # end
   end
 end

data/lib/quote_sql/test.rb

@@ -1,28 +1,40 @@
-module QuoteSql::Test
-  def self.all
-    methods(false).grep(/^test_/).each do |name|
-      run(name)
-      puts
-    end
+class QuoteSql::Test
 
+  def all
+    @success = []
+    @fail = []
+    private_methods(false).grep(/^test_/).each { run(_1, true) }
+    @success.each { STDOUT.puts(*_1, nil) }
+    @fail.each { STDOUT.puts(*_1, nil) }
+    puts
   end
 
-  def self.run(name)
+  def run(name, all = false)
     name = name.to_s.sub(/^test_/, "")
+    rv = ["🧪 #{name}"]
     @expected = nil
     @test = send("test_#{name}")
-    if sql.gsub(/\s+/, "") == expected&.gsub(/\s+/, "")
-      STDOUT.puts name, @test.original, @test.quotes.inspect, "✅ #{expected}"
+    if sql.gsub(/\s+/, "")&.downcase&.strip == expected&.gsub(/\s+/, "")&.downcase&.strip
+      tables = @test.tables.to_h { [[_1, "table"].compact.join("_"), _2] }
+      columns = @test.instance_variable_get(:@columns).to_h { [[_1, "columns"].compact.join("_"), _2] }
+      rv += [@test.original, { **tables, **columns, **@test.quotes }.inspect, "🎯 #{expected}", "✅ #{sql}"]
+      @success << rv if @success
     else
-      STDOUT.puts name, @test.inspect, sql, "❌ #{expected}"
+      rv += [@test.inspect, "🎯 #{expected}", "❌ #{sql}"]
+      @fail << rv if @fail
     end
+  rescue => exc
+    rv += [@test.inspect, "🎯 #{expected}", "❌ #{sql}", exc.message]
+    @fail << rv if @fail
+  ensure
+    STDOUT.puts(*rv) unless @fail or @success
   end
 
-  def self.expected(v = nil)
+  def expected(v = nil)
     @expected ||= v
   end
 
-  def self.sql
+  def sql
     @test.to_sql
   end
 
@@ -39,73 +51,165 @@ module QuoteSql::Test
       "SELECT * FROM #{self.class.table_name}"
     end
   end
-  class << self
-    def test_columns_and_table_name_simple
-      expected Arel.sql(%(SELECT "a","b"."c" FROM "my_table"))
-      QuoteSql.new("SELECT %columns FROM %table_name").quote(
-        columns: [:a, b: :c],
-        table_name: "my_table"
-      )
-    end
 
-    def test_columns_and_table_name_complex
-      expected Arel.sql(%(SELECT "a","b"."c" FROM "table1","table2"))
-      QuoteSql.new("SELECT %columns FROM %table_names").quote(
-        columns: [:a, b: :c],
-        table_names: ["table1", "table2"]
-      )
-    end
+  private
 
-    def test_recursive_injects
-      expected Arel.sql(%(SELECT TRUE FROM "table1"))
-      QuoteSql.new("SELECT %raw FROM %table_names").quote(
-        raw: "%recurse1_raw",
-        recurse1_raw: "%recurse2",
-        recurse2: true,
-        table_names: "table1"
-      )
-    end
+  def test_columns
+    expected <<~SQL
+      SELECT x, "a", "b", "c", "d"
+    SQL
+    "SELECT x, %x_columns ".quote_sql(x_columns: %i[a b c d])
+  end
 
-    def test_values
-      expected Arel.sql(%(SELECT 'a text', 123, 'text' AS abc FROM "my_table"))
-      QuoteSql.new("SELECT %text, %{number}, %aliased_with_hash FROM %table_name").quote(
-        text: "a text",
-        number: 123,
-        aliased_with_hash: {
-          abc: "text"
-        },
-        table_name: "my_table"
-      )
-    end
+  def test_columns_and_table_name_simple
+    expected <<~SQL
+      SELECT "my_table"."a", "b", "gaga"."c", "my_table"."e" AS "d", "gaga"."d" AS "f", 1 + 2 AS "g", whatever AS raw FROM "my_table"
+    SQL
+    QuoteSql.new("SELECT %columns FROM %table").quote(
+      columns: [:a, "b", "gaga.c", { d: :e, f: "gaga.d", g: Arel.sql("1 + 2") }, Arel.sql("whatever AS raw")],
+      table: "my_table"
+    )
+  end
 
-    def test_binds
-      expected Arel.sql(%(SELECT $1, $2, $1 AS get_bind_1_again FROM "my_table"))
-      QuoteSql.new("SELECT %bind, %bind__uuid, %bind1 AS get_bind_1_again FROM %table_name").quote(
-        table_name: "my_table"
-      )
-    end
+  def test_columns_and_table_name_complex
+    expected <<~SQL
+      SELECT "table1"."a","table1"."c" as "b" FROM "table1","table2"
+    SQL
+    QuoteSql.new("SELECT %columns FROM %table").quote(
+      columns: [:a, b: :c],
+      table: ["table1", "table2"]
+    )
+  end
 
-    def test_q3
-      expected Arel.sql(<<-SQL)
-            INSERT INTO "responses" ("id","type","task_id","index","data","parts","value","created_at","updated_at") 
-            VALUES (NULL,TRUE,'A','[5,5]','{"a":1}'),
-                   (1,FALSE,'B','[]','{"a":2}'),
-                   (2,NULL,'c','[1,2,3]','{"a":3}')
-            ON CONFLICT (responses_task_id_index_unique) DO NOTHING;
-        SQL
-
-      QuoteSql.new(<<-SQL).
-          INSERT INTO %table (%columns) VALUES %values
-            ON CONFLICT (responses_task_id_index_unique) DO NOTHING;
-        SQL
-        quote(
-          table: Response,
-          values: [
-            [nil, true, "A", [5, 5], { a: 1 }],
-            [1, false, "B", [], { a: 2 }],
-            [2, nil, "c", [1, 2, 3], { a: 3 }]
-          ]
-        )
-    end
+  def test_recursive_injects
+    expected %(SELECT TRUE FROM "table1")
+    QuoteSql.new("SELECT %raw FROM %table").quote(
+      raw: "%recurse1_raw",
+      recurse1_raw: "%recurse2",
+      recurse2: true,
+      table: "table1"
+    )
+  end
+
+  def test_values
+    expected <<~SQL
+      SELECT 'a text', 123, '{"abc":"don''t"}'::jsonb FROM "my_table"
+    SQL
+    QuoteSql.new("SELECT %text, %{number}, %hash FROM %table").quote(
+      text: "a text",
+      number: 123,
+      hash: { abc: "don't" },
+      table: "my_table"
+    )
+  end
+
+  def test_binds
+    expected <<~SQL
+      SELECT $1, $2::UUID, $1 AS get_bind_1_again FROM "my_table"
+    SQL
+    QuoteSql.new("SELECT %bind, %bind__uuid, %bind1 AS get_bind_1_again FROM %table").quote(
+      table: "my_table"
+    )
+  end
+
+  def test_from_values_array
+    expected <<~SQL
+      SELECT * FROM (VALUES ('a',1,TRUE,NULL)) AS "x" ("column1","column2","column3","column4")
+    SQL
+    "SELECT * FROM %x_values".quote_sql(x_values: [['a', 1, true, nil]])
   end
+
+  def test_from_values_hash_no_columns
+    expected <<~SQL
+      SELECT * FROM (VALUES ('a', 1, true, NULL), ('a', 1, true, NULL), (NULL, 1, NULL, 2)) AS "y" ("a", "b", "c", "d")
+    SQL
+    "SELECT * FROM %y_values".quote_sql(y_values: [
+      { a: 'a', b: 1, c: true, d: nil },
+      { d: nil, a: 'a', c: true, b: 1 },
+      { d: 2, b: 1 }
+    ])
+  end
+
+  def test_from_values_hash_with_columns
+    expected <<~SQL
+      SELECT * FROM (VALUES (NULL, true, 1, 'a')) AS "x" ("d","c","b","a")
+    SQL
+    "SELECT * FROM %x_values".quote_sql(x_columns: %i[d c b a], x_values: [{ a: 'a', b: 1, c: true, d: nil }])
+  end
+
+  def test_from_values_hash_with_type_columns
+    expected <<~SQL
+      SELECT * 
+            FROM (VALUES 
+                        ('a'::TEXT, 1::INTEGER, true::BOOLEAN, NULL::FLOAT), 
+                        ('a', 1, true, NULL), 
+                        (NULL, 1, NULL, 2)
+                  ) AS "x" ("a", "b", "c", "d")
+    SQL
+    "SELECT * FROM %x_values".quote_sql(
+      x_columns: {
+        a: "text",
+        b: "integer",
+        c: "boolean",
+        d: "float"
+      },
+      x_values: [
+        { a: 'a', b: 1, c: true, d: nil },
+        { d: nil, a: 'a', c: true, b: 1 },
+        { d: 2, b: 1 }
+      ])
+  end
+
+  def test_insert_values_array
+    expected <<~SQL
+      INSERT INTO x VALUES ('a', 1, true, NULL)
+    SQL
+    "INSERT INTO x %values".quote_sql(values: [['a', 1, true, nil]])
+  end
+
+  def test_insert_values_hash
+    expected <<~SQL
+      INSERT INTO x ("a", "b", "c", "d") VALUES ('a', 1, true, NULL)
+    SQL
+    "INSERT INTO x %values".quote_sql(values: [{ a: 'a', b: 1, c: true, d: nil }])
+  end
+
+  def test_from_json
+    expected <<~SQL
+      SELECT * FROM json_to_recordset('[{"a":1,"b":"foo"},{"a":"2"}]') as "x" ("a" int, "b" text)
+    SQL
+    "SELECT * FROM %x_json".quote_sql(x_casts: {a: "int", b: "text"}, x_json: [{ a: 1, b: 'foo'}, {a: '2', c: 'bar'}])
+  end
+
+  def test_json_insert
+    expected <<~SQL
+        INSERT INTO users (name, color) SELECT * from json_to_recordset('[{"name":"auge","color":"#611333"}]') AS "x"("name" text,"color" text)
+    SQL
+    x_json = {"first_name"=>nil, "last_name"=>nil, "stripe_id"=>nil, "credits"=>nil, "avatar"=>nil, "name"=>"auge", "color"=>"#611333", "founder"=>nil, "language"=>nil, "country"=>nil, "data"=>{}, "created_at"=>"2020-11-19T09:30:18.670Z", "updated_at"=>"2020-11-19T09:40:00.063Z"}
+    "INSERT INTO users (name, color) SELECT * from %x_json".quote_sql(x_casts: {name: "text", color: "text"}, x_json:)
+  end
+
+  # def test_q3
+  #   expected Arel.sql(<<-SQL)
+  #         INSERT INTO "responses" ("id","type","task_id","index","data","parts","value","created_at","updated_at")
+  #         VALUES (NULL,TRUE,'A','[5,5]','{"a":1}'),
+  #                (1,FALSE,'B','[]','{"a":2}'),
+  #                (2,NULL,'c','[1,2,3]','{"a":3}')
+  #         ON CONFLICT (responses_task_id_index_unique) DO NOTHING;
+  #     SQL
+  #
+  #   QuoteSql.new(<<-SQL).
+  #       INSERT INTO %table (%columns) VALUES %values
+  #         ON CONFLICT (responses_task_id_index_unique) DO NOTHING;
+  #     SQL
+  #     quote(
+  #       table: Response,
+  #       values: [
+  #         [nil, true, "A", [5, 5], { a: 1 }],
+  #         [1, false, "B", [], { a: 2 }],
+  #         [2, nil, "c", [1, 2, 3], { a: 3 }]
+  #       ]
+  #     )
+  # end
+
 end

data/lib/quote_sql/version.rb

@@ -0,0 +1,3 @@
+class QuoteSql
+  VERSION = "0.0.4"
+end

data/lib/quote_sql.rb

@@ -1,90 +1,8 @@
 Dir.glob(__FILE__.sub(/\.rb$/, "/*.rb")).each { require(_1) unless _1[/(deprecated|test)\.rb$/] }
 
 # Tool to build and run SQL queries easier
-#
-#   QuoteSql.new("SELECT %field").quote(field: "abc").to_sql
-#   => SELECT 'abc'
-#
-#   QuoteSql.new("SELECT %field__text").quote(field__text: 9).to_sql
-#   => SELECT 9::TEXT
-#
-#   QuoteSql.new("SELECT %columns FROM %table_name").quote(table: User).to_sql
-#   => SELECT "id",firstname","lastname",... FROM "users"
-#
-#   QuoteSql.new("SELECT a,b,%raw FROM table").quote(raw: "jsonb_build_object('a', 1)").to_sql
-#   => SELECT "a,b,jsonb_build_object('a', 1) FROM table
-#
-#   QuoteSql.new("SELECT %column_names FROM (%any_name) a").
-#     quote(any_name: User.select("%column_names").where(id: 3), column_names: [:firstname, :lastname]).to_sql
-#   => SELECT firstname, lastname FROM (SELECT firstname, lastname FROM users where id = 3)
-#
-#   QuoteSql.new("INSERT INTO %table (%columns) VALUES %values ON CONFLICT (%constraint) DO NOTHING").
-#     quote(table: User, values: [
-#       {firstname: "Albert", id: 1, lastname: "Müller"},
-#       {lastname: "Schultz", firstname: "herbert"}
-#     ], constraint: :id).to_sql
-#   => INSERT INTO "users" ("id", "firstname", "lastname", "created_at")
-#       VALUES (1, 'Albert', 'Müller', CURRENT_TIMESTAMP), (DEFAULT, 'herbert', 'Schultz', CURRENT_TIMESTAMP)
-#       ON CONFLICT ("id") DO NOTHING
-#
-#   QuoteSql.new("SELECT %columns").quote(columns: [:a, :"b.c", c: "jsonb_build_object('d', 1)"]).to_sql
-#   => SELECT "a","b"."c",jsonb_build_object('d', 1) AS c
-#
-# Substitution
-#   In the SQL matches of %foo or %{foo} or %foo_4_bar or %{foo_4_bar} the *"mixins"*
-#   are substituted with quoted values
-#   the values are looked up from the options given in the quotes method
-#   the mixins can be recursive, Caution! You need to take care, you can create infintive loops!
-#
-# Special mixins are
-# - %table | %table_name | %table_names
-# - %column | %columns | %column_names
-# - %ident | %constraint | %constraints quoting for database columns
-# - %raw | %sql inserting raw SQL
-# - %value | %values creates value section for e.g. insert
-#   - In the right order
-#     - Single value => (2)
-#     - +Array+ => (column, column, column) n.b. has to be the correct order
-#     - +Array+ of +Array+ => (...),(...),(...),...
-#   - if the columns option is given (or implicitely by setting table)
-#     - +Hash+ values are ordered according to the columns option, missing values are replaced by DEFAULT
-#     - +Array+ of +Hash+ multiple record insert
-# - %bind is replaced with the current bind sequence.
-#   Without appended number the first %bind => $1, the second => $2 etc.
-#   - %bind\\d+ => $+Integer+ e.g. %bind7 => $7
-#   - %bind__text => $1 and it is registered as text - this is used in prepared statements TODO
-#   - %key_bind__text => $1 and it is registered as text when using +Hash+ in the execute
-#     $1 will be mapped to the key's value in the +Hash+ TODO
-#
-# All can be preceded by additional letters and underscore e.g. %foo_bar_column
-#
-# A database typecast is added to fields ending with double underscore and a valid db data type
-# with optional array dimension
-#
-# - %field__jsonb => adds a ::JSONB typecast to the field
-# - %number_to__text => adds a ::TEXT typecast to the field
-# - %array__text1 => adds a ::TEXT[] TODO
-# - %array__text2 => adds a ::TEXT[][] TODO
-#
-# Quoting
-# - Any value of the standard mixins are quoted with these exceptions
-# - +Array+ are quoted as DB Arrays unless the type cast e.g. __jsonb is given
-# - +Hash+ are quoted as jsonb
-# - When the value responds to :to_sql or is a +Arel::Nodes::SqlLiteral+ its added as raw SQL
-# - +Proc+ are executed with the +QuoteSQL::Quoter+ object as parameter and added as raw SQL
-#
-# Special quoting columns
-# - +String+ or +Symbol+ without a dot  e.g. :firstname => "firstname"
-# - +String+ or +Symbol+ containing a dot e.g. "users.firstname" or => "users"."firstname"
-# - +Array+
-#   - +String+ and +Symbols+ see above
-#   - +Hash+ see below
-# - +Hash+ or within the +Array+
-#   - +Symbol+ value will become the column name e.g. {table: :column} => "table"."column"
-#   - +String+ value will become the expression, the key the AS {result: "SUM(*)"} => SUM(*) AS result
-#   - +Proc+ are executed with the +QuoteSQL::Quoter+ object as parameter and added as raw SQL
-#
 class QuoteSql
+
   DATA_TYPES_RE = %w(
 (?:small|big)(?:int|serial)
 bit bool(?:ean)? box bytea cidr circle date
@@ -119,50 +37,47 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
     @quotes = {}
     @resolved = {}
     @binds = []
+
+    @tables = {}
+    @columns = {}
+    @casts = {}
   end
 
-  attr_reader :sql, :quotes, :original, :binds
-  attr_writer :table_name, :column_names
+  attr_reader :sql, :quotes, :original, :binds, :tables, :columns
 
-  def table_name
-    return @table_name if @table_name
-    return unless table = @quote&.dig(:table)
-    @table_name = table.respond_to?(:table_name) ? table.table_name : table.to_s
+  def table(name = nil)
+    @tables[name&.to_sym].dup
   end
 
-  def column_names
-    return @column_names if @column_names
-    return unless columns = @quote&.dig(:columns)
-    @column_names = if columns[0].is_a? String
-      columns
-    else
-      columns.map(&:name)
-    end.map(&:to_s)
+  def columns(name = nil)
+    @columns[name&.to_sym].dup
   end
 
-  # Add quotes keys are symbolized
-  def quote(quotes1 = {}, **quotes2)
-    quotes = @quotes.merge(quotes1, quotes2).transform_keys(&:to_sym)
-    if table = quotes.delete(:table)
-      columns = quotes.delete(:columns) || table.columns
+  def casts(name = nil)
+    unless rv = @casts[name&.to_sym]
+      table = table(name) or return
+      return unless table.respond_to? :columns
+      rv = table.columns.to_h { [_1.name.to_sym, _1.sql_type] }
     end
-    @quotes = { table:, columns:, **quotes }
-    self
+    rv
   end
 
-  class Error < ::RuntimeError
-    def initialize(quote_sql)
-      @object = quote_sql
-    end
-
-    def message
-      super + %Q@<QuoteSql #{@object.original.inspect} #{@object.errors.inspect}>@
+  # Add quotes keys are symbolized
+  def quote(quotes = {})
+    re = /(?:^|(.*)_)(table|columns|casts)$/i
+    quotes.keys.grep(re).each do |quote|
+      _, name, type = quote.to_s.match(re)&.to_a
+      value = quotes.delete quote
+      value = Raw.sql(value) if value.class.to_s == "Arel::Nodes::SqlLiteral"
+      instance_variable_get(:"@#{type.sub(/s*$/,'s')}")[name&.to_sym] = value
     end
+    @quotes.update quotes.transform_keys(&:to_sym)
+    self
   end
 
   def to_sql
     mixin!
-    raise Error.new(self) if errors?
+    raise Error.new(self, errors) if errors?
     return Arel.sql @sql if defined? Arel
     @sql
   end
@@ -188,7 +103,6 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
     @prepare_name = name
   end
 
-
   # Executes a prepared statement
   # Processes in batches records
   # returns the array of the results depending on RETURNING is in the query
@@ -224,8 +138,8 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
   def errors
     @quotes.to_h do |k, v|
       r = @resolved[k]
-      next [nil, nil] unless r.nil? or r.is_a?(Exception)
-      [k, "#{@quotes[k].inspect} => #{v.inspect}"]
+      next [nil, nil] if r.nil? or not r.is_a?(Exception)
+      [k, { @quotes[k].inspect => v.inspect, exc: r, backtrace: r.backtrace }]
     end.compact
   end
 
@@ -238,7 +152,11 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
   def key_matches
     @sql.scan(MIXIN_RE).map do |full, *key|
       key = key.compact[0]
-      [full, key, @quotes.key?(key.to_sym)]
+      if m = key.match(/^(.+)#{CASTS}/i)
+        _, key, cast = m.to_a
+      end
+      has_quote = @quotes.key?(key.to_sym) || key.match?(/(table|columns)$/)
+      [full, key, cast, has_quote]
     end
   end
 
@@ -248,22 +166,20 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
     loop do
       s = StringScanner.new(@sql)
       sql = ""
-      key_matches.each do |key_match, key, has_quote|
+      key_matches.each do |key_match, key, cast, has_quote|
         s.scan_until(/(.*?)#{key_match}([a-z0-9_]*)/im)
         matched, pre, post = s.matched, s[1], s[2]
-        if m = key.match(/^bind(\d+)?(?:#{CASTS})?$/im)
-          if m[2].present?
-            cast = m[2].tr("_", " ")
-          end
+        if m = key.match(/^bind(\d+)?/im)
           if m[1].present?
             bind_num = m[1].to_i
             @binds[bind_num - 1] ||= cast
-            raise "cast #{bind_num} already set to #{@binds[bind_num - 1]}" unless @binds[bind_num - 1] == cast
+            raise "bind #{bind_num} already set to #{@binds[bind_num - 1]}" unless @binds[bind_num - 1] == cast
           else
             @binds << cast
             bind_num = @binds.length
           end
-          matched = "#{pre}$#{bind_num}#{post}"
+
+          matched = "#{pre}$#{bind_num}#{"::#{cast}" if cast.present?}#{post}"
         elsif has_quote
           quoted = quoter(key)
           unresolved.delete key
@@ -294,9 +210,25 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
 
   extend Quoting
 
-  def self.test
+  class Raw < String
+    def self.sql(v)
+      if v.class == self
+        v
+      elsif v.respond_to? :to_sql
+        new v.to_sql
+      else
+        new v
+      end
+    end
+  end
+
+  def self.test(which = :all)
     require __dir__ + "/quote_sql/test.rb"
-    Test
+    if which == :all
+      Test.new.all
+    else
+      Test.new.run(which)
+    end
   end
 end
 

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: quote-sql
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Martin Kufner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-23 00:00:00.000000000 Z
-dependencies: []
+date: 2024-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: niceql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 'QuoteSql helps you creating SQL queries and proper quoting especially
   with advanced queries.
 
@@ -23,12 +37,13 @@ files:
 - lib/quote_sql.rb
 - lib/quote_sql/connector.rb
 - lib/quote_sql/connector/active_record_base.rb
-- lib/quote_sql/deprecated.rb
+- lib/quote_sql/error.rb
 - lib/quote_sql/extension.rb
 - lib/quote_sql/formater.rb
 - lib/quote_sql/quoter.rb
 - lib/quote_sql/quoting.rb
 - lib/quote_sql/test.rb
+- lib/quote_sql/version.rb
 homepage: https://github.com/martin-kufner/quote-sql
 licenses:
 - MIT
@@ -48,7 +63,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: Tool to build and run SQL queries easier

data/lib/quote_sql/deprecated.rb

@@ -1,162 +0,0 @@
-class QuoteSql
-  module Deprecated
-    private def conn
-      ApplicationRecord.connection
-    end
-
-    private def quote_sql_values(sub, casts)
-      sub.map do |s|
-        casts.map do |k, column|
-          column.transform_keys(&:to_sym) => { sql_type:, default:, array: }
-          value = s.key?(k) ? s[k] : s[k.to_sym]
-          if value.nil?
-            value = default
-          else
-            value = value.to_json if sql_type[/^json/]
-          end
-          "#{conn.quote(value)}::#{sql_type}"
-        end.join(",")
-      end
-    end
-
-    def quote_sql(**options)
-      loop do
-        # keys = []
-        break unless gsub!(%r{(?<=^|\W)[:$](#{options.keys.join("|")})(?=\W|$)}) do |m|
-          key = m[1..].to_sym
-          # keys << key
-          next m unless options.key? key
-          sub = options[key]
-          case sub
-          when Arel::Nodes::SqlLiteral
-            next sub
-          when NilClass
-            next "NULL"
-          when TrueClass, FalseClass
-            next sub.to_s.upcase
-          when Time
-            sub = sub.strftime("%Y-%m-%d %H:%M:%S.%3N%z")
-          end
-          if sub.respond_to? :to_sql
-            next sub.to_sql
-          end
-          case m
-          when /^:(.+)_(FROM_CLAUSE)$/ # prefix (column,...) AS ( VALUES (data::CAST, ...), ...)
-            name = conn.quote_column_name($1)
-            casts = sub.shift.transform_keys(&:to_s)
-            rv = quote_sql_values(sub, casts)
-            column_names = casts.map { conn.quote_column_name(_2.key?(:as) ? _2[:as] : _1) }
-            next "(VALUES \n(#{rv.join("),\n(")})\n ) #{name} (#{column_names.join(",") })"
-
-          when /^:(.+)_(as_select)$/i # prefix (column,...) AS ( VALUES (data::CAST, ...), ...)
-            name = conn.quote_column_name($1)
-            casts = sub.shift.transform_keys(&:to_s)
-            rv = quote_sql_values(sub, casts)
-            next "SELECT * FROM (VALUES \n(#{rv.join("),\n(")})\n ) #{name} (#{casts.keys.map { conn.quote_column_name(_1) }.join(",") })"
-          when /^:(.+)_(as_values)$/i # prefix (column,...) AS ( VALUES (data::CAST, ...), ...)
-            name = conn.quote_column_name($1)
-            casts = sub.shift.transform_keys(&:to_s)
-            rv = quote_sql_values(sub, casts)
-            next "#{name} (#{casts.keys.map { conn.quote_column_name(_1) }.join(",") }) AS ( VALUES \n(#{rv.join("),\n(")})\n )"
-          when /^:(.+)_(values)$/i
-            casts = sub.shift.transform_keys(&:to_sym)
-            rv = quote_sql_values(sub, casts)
-            next "VALUES \n(#{rv.join("),\n(")})\n"
-          when /_(LIST)$/i
-            next sub.map { conn.quote _1 }.join(",")
-          when /_(args)$/i
-            next sub.join(',')
-          when /_(raw|sql)$/i
-            next sub
-          when /_(ident|column)$/i, /table_name$/, /_?columns?$/, /column_names$/
-            if sub.is_a? Array
-              next sub.map do
-                _1[/^"[^"]+"\."[^"]+"$/] ? _1 : conn.quote_column_name(_1)
-              end.join(',')
-            else
-              next conn.quote_column_name(sub)
-            end
-          when /(?<=_)jsonb?$/i
-            next conn.quote(sub.to_json) + "::#{$MATCH}"
-          when /(?<=_)(uuid|int|text)$/i
-            cast = "::#{$MATCH}"
-          end
-          case sub
-          when Regexp
-            sub.to_postgres
-          when Array
-            dims = 1 # todo more dimensional Arrays
-            dive = ->(ary) do
-              ary.map { |s| conn.quote s }.join(',')
-            end
-            sub = "[#{dive.call sub}]"
-            cast += "[]" * dims if cast.present?
-            "ARRAY#{sub}#{cast}"
-          else
-            "#{conn.quote(sub)}#{cast}"
-          end
-        end
-        # break if options.except!(*keys).blank?
-      end
-      Arel.sql self
-    end
-
-    def exec
-      result = conn.exec_query(self)
-      columns = result.columns.map(&:to_sym)
-      result.cast_values.map do |row|
-        row = [row] unless row.is_a? Array
-        [columns, row].transpose.to_h
-      end
-    end
-
-    def quote_exec(**)
-      quote_sql(**).exec
-    end
-
-    module Dsql
-
-      def dsql
-        IO.popen(PG_FORMAT_BIN, "r+", err: "/dev/null") do |f|
-          f.write self
-          f.close_write
-          puts f.read
-        end
-        self
-      rescue
-        self
-      end
-    end
-
-    include Dsql
-
-    module String
-      def self.included(other)
-        other.include Dsql
-      end
-
-      def quote_sql(**)
-        Arel.sql(self).quote_sql(**)
-      end
-    end
-
-    module Relation
-      def quote_sql(**)
-        Arel.sql(to_sql).quote_sql(**)
-      end
-
-      def dsql
-        to_sql.dsql
-        self
-      end
-
-      def result
-        result = ApplicationRecord.connection.exec_query(to_sql)
-        columns = result.columns.map(&:to_sym)
-        result.cast_values.map do |row|
-          [columns, Array(row)].transpose.to_h
-        end
-      end
-    end
-  end
-end