quote-sql 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e32e2e164efd0cfb007de82abb8870b13d5b432856d21af6f75faed9d2d1107
-  data.tar.gz: 141ef285fbb563e649d5c4b71faa8b1d9d67066d1c600dd9d85c7dd5ee017edc
+  metadata.gz: 17336c46db1b966512f67b1c4dae714d612460ae61c1f24d75d0fa79153422df
+  data.tar.gz: 8b510daed8f21c7733e0b841f0c11f60c8634abde062e3a81dc844b8ed4cb682
 SHA512:
-  metadata.gz: 8e13010de0021284de07a99e33822e54b530d3d5dfbc5986028327c903b5c3ab55ceadcf0042eb7207eea8245f31f57db5811a0f902fe8f68eb9a435c02ff255
-  data.tar.gz: f178c03540bdea0b38c8278ace489954d9efff1786fa76b804950c11bf60f2ac3162f6ca3ac9f142f08dc62d830e10cd8835786618175a922b7eb183e71c89bc
+  metadata.gz: 1cc8dd6b2e36c5f5e976027d1f25442cf3cbee76b8bf5bf05b827ba2693d2aed952273491b1abd6404f53482b6da1c0e88e5de5cc9d25ac3af56b65f649f0aa7
+  data.tar.gz: 3e4a135613d5c22963030754e1bc21d8ac3d3aaf210abecdd2d8eeb47893f96c3243702c29d138321a122c28ed571670e32c0f703462cf1a1ca41e6b925f6da5

data/lib/quote_sql/quoter.rb

@@ -5,8 +5,16 @@ class QuoteSql
       @key, @quotable = key, quotable
     end
 
+    def quotes
+      @qsql.quotes
+    end
+
     attr_reader :key, :quotable
 
+    def name
+      @key.sub(/_[^_]+$/, '')
+    end
+
     def to_sql
       return @quotable.call(self) if @quotable.is_a? Proc
       case key.to_s
@@ -24,8 +32,10 @@ class QuoteSql
         quotable.to_s
       when /(?:^|(.*)_)(raw|sql)$/i
         quotable.to_s
-      when /(?:^|(.*)_)(values?)$/i
-        values
+      when /^(.+)_values$/i
+        data_values
+      when /values$/i
+        insert_values
       else
         quote
       end
@@ -56,24 +66,75 @@ class QuoteSql
 
     end
 
-    def values(item = @quotable)
+    def data_values(item = @quotable)
+      item = Array(item).compact
+      column_names = @qsql.quotes[:"#{name}_columns"].dup
+      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] || ""}
+      "(VALUES #{values.join(",")}) AS #{ident_name name} (#{ident_name column_names})"
+    end
+
+
+    def insert_values(item = @quotable)
       case item
       when Arel::Nodes::SqlLiteral
         item = Arel.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
+
+        if item.all? { _1.is_a?(Hash) }
+          column_names ||= item.flat_map { _1.keys.sort }.uniq
+          item.map! { _1.fetch_values(*column_names) {} }
+        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?(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
+          raise ArgumentError, "Either all type Hash or Array"
+        end
+        if column_names.present?
+          "(#{ident_name column_names}) VALUES #{values.join(",")}"
         else
-          value([item])
+          "VALUES #{values.join(",")}"
         end
       when Hash
         value([item])
-      else
-        return item.to_sql if item.respond_to? :to_sql
-        "(" + _quote(item) + ")"
       end
     end
 
@@ -127,7 +188,7 @@ class QuoteSql
       elsif item.class.respond_to?(:column_names)
         item = item.class.column_names
       elsif item.is_a?(Array)
-        if item[0].respond_to?(:name)
+        if item.all?{ _1.respond_to?(:name) }
           item = item.map(&:name)
         end
       end

data/lib/quote_sql/test.rb

@@ -1,21 +1,28 @@
 module QuoteSql::Test
   def self.all
+    @success = []
+    @fail = []
     methods(false).grep(/^test_/).each do |name|
-      run(name)
-      puts
+      run(name, true)
     end
-
+    @success.each { STDOUT.puts(*_1, nil) }
+    @fail.each { STDOUT.puts(*_1, nil) }
+    puts
   end
 
-  def self.run(name)
+  def self.run(name, all)
     name = name.to_s.sub(/^test_/, "")
     @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
+      rv = [name, @test.original, @test.quotes.inspect, "✅ #{expected}"]
+      @success << rv if @success
     else
-      STDOUT.puts name, @test.inspect, sql, "❌ #{expected}"
+      rv = [name, @test.inspect, sql, "❌ #{expected}"]
+      @fail << rv if @fail
     end
+    STDOUT.puts rv unless @fail or @success
   end
 
   def self.expected(v = nil)
@@ -39,9 +46,10 @@ 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"))
+      expected %(SELECT "a","b"."c" FROM "my_table")
       QuoteSql.new("SELECT %columns FROM %table_name").quote(
         columns: [:a, b: :c],
         table_name: "my_table"
@@ -49,7 +57,7 @@ module QuoteSql::Test
     end
 
     def test_columns_and_table_name_complex
-      expected Arel.sql(%(SELECT "a","b"."c" FROM "table1","table2"))
+      expected %(SELECT "a","b"."c" FROM "table1","table2")
       QuoteSql.new("SELECT %columns FROM %table_names").quote(
         columns: [:a, b: :c],
         table_names: ["table1", "table2"]
@@ -57,7 +65,7 @@ module QuoteSql::Test
     end
 
     def test_recursive_injects
-      expected Arel.sql(%(SELECT TRUE FROM "table1"))
+      expected %(SELECT TRUE FROM "table1")
       QuoteSql.new("SELECT %raw FROM %table_names").quote(
         raw: "%recurse1_raw",
         recurse1_raw: "%recurse2",
@@ -67,7 +75,9 @@ module QuoteSql::Test
     end
 
     def test_values
-      expected Arel.sql(%(SELECT 'a text', 123, 'text' AS abc FROM "my_table"))
+      expected <<~SQL
+        SELECT 'a text', 123, 'text' AS abc FROM "my_table"
+      SQL
       QuoteSql.new("SELECT %text, %{number}, %aliased_with_hash FROM %table_name").quote(
         text: "a text",
         number: 123,
@@ -79,33 +89,92 @@ module QuoteSql::Test
     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"
-      )
+      expected <<~SQL
+                SELECT $1, $2, $1 AS get_bind_1_again FROM "my_table"
+         SQL
+          QuoteSql.new("SELECT %bind, %bind__uuid, %bind1 AS get_bind_1_again FROM %table_name").quote(
+            table_name: "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_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 }]
-          ]
-        )
+    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_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
 end

data/lib/quote_sql.rb

@@ -151,18 +151,29 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
   end
 
   class Error < ::RuntimeError
-    def initialize(quote_sql)
+    def initialize(quote_sql, errors)
       @object = quote_sql
+      @errors = errors
     end
 
+    attr_reader :object, :errors
+
+    def sql
+      @object.original.inspect
+    end
+
+    # def inspect
+    #   super + errors.flat_map { [_1.inspect, _1.backtrace] }
+    # end
+
     def message
-      super + %Q@<QuoteSql #{@object.original.inspect} #{@object.errors.inspect}>@
+      super + %Q@<QuoteSql #{sql} #{@object.errors.inspect}>@
     end
   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
@@ -224,8 +235,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
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quote-sql
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Martin Kufner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-23 00:00:00.000000000 Z
+date: 2024-02-24 00:00:00.000000000 Z
 dependencies: []
 description: 'QuoteSql helps you creating SQL queries and proper quoting especially
   with advanced queries.