quote-sql 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13f64b3b81c62230c2814c487d3a5b2e56109b651297a599449a2b8edd91b3d8
-  data.tar.gz: 8fc4b373eb65ab1d6ba2e86a32db5d60caf3bef38096e9a098127d9f892a4abe
+  metadata.gz: 17336c46db1b966512f67b1c4dae714d612460ae61c1f24d75d0fa79153422df
+  data.tar.gz: 8b510daed8f21c7733e0b841f0c11f60c8634abde062e3a81dc844b8ed4cb682
 SHA512:
-  metadata.gz: d58cc18c35110eef2ddb9c08f1e23f9b353ab7fc73939063fa3a576156c0fd96b05099e8fe8742fcb4c46261735fc47d547d24f6218ce9f6776c8e91be873211
-  data.tar.gz: 7facea8c215baf9c9196512b636b3ae866343eea0ca8137589b25f3cd6684a4fa815661c05059be58c11ace2c0fc6ac3962d96d02c3c9be1fdef628a00c6349d
+  metadata.gz: 1cc8dd6b2e36c5f5e976027d1f25442cf3cbee76b8bf5bf05b827ba2693d2aed952273491b1abd6404f53482b6da1c0e88e5de5cc9d25ac3af56b65f649f0aa7
+  data.tar.gz: 3e4a135613d5c22963030754e1bc21d8ac3d3aaf210abecdd2d8eeb47893f96c3243702c29d138321a122c28ed571670e32c0f703462cf1a1ca41e6b925f6da5

data/README.md

@@ -1,5 +1,6 @@
 # QuoteSql - Tool to build and run SQL queries easier
 I've built this library as an addition to ActiveRecord and Arel, however you can use it with any sql database and plain Ruby.
+However currently it is just used with PostgreSQL.
 
 Creating SQL queries and proper quoting becomes complicated especially when you need advanced queries.
 
@@ -8,7 +9,7 @@ I created this library while coding for different projects, and had lots of Here
 
 My strategy is to segment SQL Queries in readable junks, which can be individually tested and then combine their sql to the final query.
 
-QuoteSql is used in production, but is still evolving.
+QuoteSql is used in production, but is still bleeding edge - and there is not a fully sync between doc and code.
 
 If you think QuoteSql is interesting, let's chat!
 Also if you have problems using it, just drop me a note.
@@ -23,6 +24,10 @@ Best Martin
 `QuoteSql.new("SELECT %field__text").quote(field__text: 9).to_sql`
 => SELECT 9::TEXT
 
+### Rails models
+`QuoteSql.new(Users.limit(10).select("%columns")).quote(columns: ['first_name', 'last_name').to_sql` 
+=> SELECT first_name, last_name FROM users LIMIT 10
+
 ### Quoting of columns and table from a model - or an object responding to table_name and column_names or columns
 `QuoteSql.new("SELECT %columns FROM %table_name").quote(table: User).to_sql`
   => SELECT "id",firstname","lastname",... FROM "users"
@@ -47,10 +52,18 @@ Values are be ordered in sequence of columns. Missing value entries are substitu
       ON CONFLICT ("id") DO NOTHING
       
 ### Columns from a list
-`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
+`QuoteSql.new("SELECT %columns").quote(columns: [:a, :"b.c", c: {d: field}]).to_sql`
+  => SELECT "a","b"."c",jsonb_build_object('d', field) AS c 
+
+`QuoteSql.new("SELECT %columns").quote(columns: [:a, :"b.c", c: {d: field, nil: false}]).to_sql`
+  => SELECT "a","b"."c",jsonb_strip_nulls(jsonb_build_object('d', 1)) AS c 
+
+
+### Execution of a query
+`QuoteSql.new("Select 1 as abc").result` => [{:abc=>1}]
 
-## Substitution of 
+
+## Substitution of mixins with quoted values 
   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
@@ -106,6 +119,16 @@ with optional array dimension
   - +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
 
+## Shortcuts and functions
+- `QuoteSQL("select %abc", abc: 1)` == `QuoteSql.new("select %abc").quote(abc: 1)`
+- when you have in your initializer `String.include QuoteSql::Extension` you can do e.g. `"select %abc".quote_sql(abc: 1)`
+- when you have in your initializer `ActiveRecord::Relation.include QuoteSql::Extension` you can do e.g.  `Profile.limit(10).select('%abc').quote_sql(abc: 1)`
+
+## Debug and dump
+If you have pg_format installed you can get the resulting query inspected: 
+  `QuoteSql.new("select %abc").quote(abc: 1).dsql`
+  
+
 ## Installing
 `gem install quote-sql`
 or in Gemfile
@@ -121,3 +144,10 @@ Add this to config/initializers/quote_sql.rb
       ActiveRecord::Relation.include QuoteSql::Extension
     end  
 
+## Todos
+- Functionalities not yet used in my production might not work
+- More documentation
+- Tests missing
+- Missing functionalities
+  - Prepare
+  - which other - let me know!

data/lib/quote_sql/quoter.rb

@@ -5,15 +5,23 @@ 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
       when /(?:^|(.*)_)table$/i
         table
       when /(?:^|(.*)_)columns?$/i
-        column_names
+        columns
       when /(?:^|(.*)_)(table_name?s?)$/i
         table_name
       when /(?:^|(.*)_)(column_name?s?)$/i
@@ -22,10 +30,12 @@ class QuoteSql
         ident_name
       when /(?:^|(.*)_)constraints?$/i
         quotable.to_s
-      when /(?:^|(.*)_)(raw|sql)$/
+      when /(?:^|(.*)_)(raw|sql)$/i
         quotable.to_s
-      when /(?:^|(.*)_)(values?)$/
-        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
 
@@ -121,6 +182,20 @@ class QuoteSql
       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.all?{ _1.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
@@ -133,6 +208,13 @@ class QuoteSql
       ident_name(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})"
+    end
+
     def ident_name(item = @quotable)
       case item
       when Array
@@ -147,14 +229,18 @@ class QuoteSql
           end
         end.join(",")
       when Hash
-        item.map do
-          case _2
+        item.map do |k,v|
+          case v
           when Symbol
-            _quote_column_name(_1, _2)
+            _quote_column_name(k, v)
           when String
-            "#{_2} AS #{_1}"
+            "#{v} AS #{k}"
           when Proc
             item.call(self)
+          when Hash
+            "#{json_build_object(v)} AS #{k}"
+          else
+            raise ArgumentError
           end
         end.join(",")
       else

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)
@@ -42,7 +49,7 @@ module QuoteSql::Test
 
   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"
@@ -50,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"]
@@ -58,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",
@@ -68,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,
@@ -80,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

@@ -1,4 +1,4 @@
-Dir.glob(__FILE__.sub(/\.rb$/, "/*.rb")).each { require(_1) unless _1[/test\.rb$/] }
+Dir.glob(__FILE__.sub(/\.rb$/, "/*.rb")).each { require(_1) unless _1[/(deprecated|test)\.rb$/] }
 
 # Tool to build and run SQL queries easier
 #
@@ -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
 
@@ -294,6 +305,15 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
 
   extend Quoting
 
+  def self.test
+    require __dir__ + "/quote_sql/test.rb"
+    Test
+  end
+end
+
+def QuoteSQL(sql, **options)
+  rv = QuoteSql.new(sql)
+  options.any? ? rv.quote(**options) : rv
 end
 
 QuoteSql.include QuoteSql::Formater

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quote-sql
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  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.
@@ -39,9 +39,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="