quote-sql 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17336c46db1b966512f67b1c4dae714d612460ae61c1f24d75d0fa79153422df
-  data.tar.gz: 8b510daed8f21c7733e0b841f0c11f60c8634abde062e3a81dc844b8ed4cb682
+  metadata.gz: cb47e85b4c7c4e1f945748295390c9e1bd49b7e0ba5291e0f7310058f6f91ddc
+  data.tar.gz: 0f5bde1afc31eb573bb3e24727b530bf5909048284114d45c56c1b24a63e97aa
 SHA512:
-  metadata.gz: 1cc8dd6b2e36c5f5e976027d1f25442cf3cbee76b8bf5bf05b827ba2693d2aed952273491b1abd6404f53482b6da1c0e88e5de5cc9d25ac3af56b65f649f0aa7
-  data.tar.gz: 3e4a135613d5c22963030754e1bc21d8ac3d3aaf210abecdd2d8eeb47893f96c3243702c29d138321a122c28ed571670e32c0f703462cf1a1ca41e6b925f6da5
+  metadata.gz: 6596b9bb50ee373030e401dcb9d0067ae31857b6467fdd7b0341e21b3dcbe8fb0e78714ec24f56615618bbf965849307474a4030978e6c98d2d728166e235151
+  data.tar.gz: f38366de3e2227835fd11f512a9c9d2a99d130d896a17f6b0a58788dd8ed7ebd13f46682992b762e2d50f09716c3bd5654d525dc4b03f350d3a52cc6b19b322e

data/README.md

@@ -9,13 +9,15 @@ 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 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.
 
 Best Martin
 
+## Caveats & Notes
+- QuoteSql is used in production, but is still bleeding edge - and there is not a fully sync between doc and code.
+- Just for my examples and in the docs, I'm using for Yajl for JSON parsing, and changed in my environments the standard parse output to *symbolized keys*. 
+
 ## Examples
 ### Simple quoting
 `QuoteSql.new("SELECT %field").quote(field: "abc").to_sql`
@@ -119,6 +121,12 @@ 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
 
+## Executing
+### Getting the results
+### Binds
+  `v = {a: 1, b: "foo", c: true};QuoteSQL(%q{Select * From %x_json}, x_json: 1, x_casts: {a: "int", b: "text", c: "boolean"}).result(v.to_json)`
+  => Select * From json_to_recordset($1) AS "x"("a" int,"b" text,"c" boolean) => [{a: 1, b: "foo", c: true}]
+
 ## 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)`
@@ -127,7 +135,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,35 +3,98 @@ class QuoteSql
     def initialize(qsql, key, quotable)
       @qsql = qsql
       @key, @quotable = key, quotable
+      @name = key.sub(/_[^_]+$/, '') if key["_"]
     end
 
+    attr_reader :key, :quotable, :name
+
     def quotes
       @qsql.quotes
     end
 
-    attr_reader :key, :quotable
+    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
+        unless item = casts(name || self.name)&.keys
+          if (table = self.table(name || self.name))&.respond_to? :column_names
+            item = table.column_names
+          else
+            raise ArgumntError, "No columns, casts or table given for #{name}" unless table&.respond_to? :column_names
+          end
+        end
+      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 name
-      @key.sub(/_[^_]+$/, '')
+    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
+        quotable
+      when /^(.+)_json$/i
+        data_json
       when /^(.+)_values$/i
         data_values
       when /values$/i
@@ -41,20 +104,34 @@ class QuoteSql
       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
@@ -62,13 +139,26 @@ 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"}" }
+      if item.is_a? Integer
+        rv = "$#{item}"
+      else
+        item = [item].flatten.compact.as_json.map { _1.slice(*columns.map(&:to_s)) }
+        rv = "'#{item.to_json.gsub(/'/, "''")}'"
+      end
+      Raw.sql "json_to_recordset(#{rv}) AS #{QuoteSql.quote_column_name name}(#{column_cast.join(',')})"
     end
 
     def data_values(item = @quotable)
       item = Array(item).compact
-      column_names = @qsql.quotes[:"#{name}_columns"].dup
+      column_names = columns(name)
       if column_names.is_a? Hash
         types = column_names.values.map { "::#{_1.upcase}" if _1 }
         column_names = column_names.keys
@@ -80,7 +170,7 @@ class QuoteSql
       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}"}
+        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
@@ -88,18 +178,17 @@ class QuoteSql
       end
       if types.present?
         value = values[0][1..-2].split(/\s*,\s*/)
-        types.each_with_index { value[_2] << _1 || ""}
+        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})"
+      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!
@@ -129,9 +218,9 @@ class QuoteSql
           raise ArgumentError, "Either all type Hash or Array"
         end
         if column_names.present?
-          "(#{ident_name column_names}) VALUES #{values.join(",")}"
+          Raw.sql "(#{_ident column_names}) VALUES #{values.join(",")}"
         else
-          "VALUES #{values.join(",")}"
+          Raw.sql "VALUES #{values.join(",")}"
         end
       when Hash
         value([item])
@@ -151,51 +240,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.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
@@ -205,70 +274,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