quote-sql 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e308b3aef586983a61155c9ba3be6c39c2397fa5fbae069ab45522e51681caa
-  data.tar.gz: 6a3945e1a4cfc16fed91c46216d1a10c5a69e85a6b3a0df10db45a9f162c07eb
+  metadata.gz: b1ae8afe082e0867130f3933c76e867ac3f16f53b816db61cd9a9cabdfeb3298
+  data.tar.gz: d5c1638521b04e8e62ff2dab8a27a27165f27f972ea4bc6e5f6e55e4680a8cb6
 SHA512:
-  metadata.gz: 3ce751f52d51a6b7b989062673f9c849b5a8b44e5e4227f0f453290d41b20856b45f0d0bbddd6cea6f5256405b313d82367a27fdd2381dd2b37f27c3ac3442e6
-  data.tar.gz: 2656c2cbacc7375fd22f2148d4a929fbba1822c97b61467bdf5794c7bcf78b75d5ba4a9bfb90a6f01b282479bad95c77d354ca2211a6f3561a6eaa60e9d90db4
+  metadata.gz: 886abf29ad27600528bd42dd88e4c13da41a1c7076b7bc9a69592d07f8d1653962eb9daaab68eb897238f5b4069658496919a254d01a53b5656cbff9c02bc958
+  data.tar.gz: '085c3fd76781bf95c658151398970fdc6de805767d495d4c23cc9e8cbd444cd61335b73162b99cc16d71eb1f8d268d8c7824244c5e2d6eafe47fe1bd20aaed0e'

data/README.md

@@ -26,7 +26,7 @@ Best Martin
 `QuoteSql.new("SELECT %field").quote(field: "abc").to_sql`
   => SELECT 'abc'
 
-`QuoteSql.new("SELECT %field__text").quote(field__text: 9).to_sql`
+`QuoteSql.new("SELECT %field::TEXT").quote(field: 9).to_sql`
 => SELECT 9::TEXT
 
 ### Rails models
@@ -54,15 +54,14 @@ Values are be ordered in sequence of columns. Missing value entries are substitu
       {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)
+      VALUES
+        (1, 'Albert', 'Müller', DEFAULT), 
+        (DEFAULT, 'herbert', 'Schultz', DEFAULT)
       ON CONFLICT ("id") DO NOTHING
       
 ### Columns from a list
-`QuoteSql.new("SELECT %columns").quote(columns: [:a, "b.c", d: {e: field}]).to_sql`
-  => SELECT "a","b"."c",jsonb_build_object('e', field) AS d 
-
-`QuoteSql.new("SELECT %columns").quote(columns: [:a, "b.c", d: {e: field, nil: false}]).to_sql`
-  => SELECT "a","b"."c",jsonb_strip_nulls(jsonb_build_object('e', 1)) AS d
+`QuoteSql.new("SELECT %columns FROM %table").quote(table: "foo", columns: [:a, "b", "foo.c", {d: :e}]).to_sql`
+  => SELECT "foo"."a","b"."foo"."c", "foo"."e" AS d
 
 ## Executing
 ### Getting the results
@@ -72,6 +71,7 @@ Values are be ordered in sequence of columns. Missing value entries are substitu
 ### Binds
 You can use binds ($1, $2, ...) in the SQL and add arguments to the result call
   `QuoteSql.new('SELECT $1 AS a').result(1)`  
+    => [{:a=>1}]
 
 #### using JSON
 
@@ -83,7 +83,7 @@ You can use binds ($1, $2, ...) in the SQL and add arguments to the result call
 Insert fom json
   
     v = {a: 1, b: "foo", c: true}
-    QuoteSql.new("INSERT INTO table (%x_columns) SELECT * FROM %x_json").quote({:x_json=>1}).result(v.to_json)
+    QuoteSql.new("INSERT INTO table (%columns) SELECT * FROM %json").quote({:json=>1}).result(v.to_json)
 
 
 
@@ -111,10 +111,8 @@ 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[]` (TO BE IMPLEMENTED)
-- `%array__text2` => adds a `::TEXT[][]` (TO BE IMPLEMENTED)
+- `%field::jsonb` => treats the field as jsonb when casted
+- `%array::text[]` => treats an array like a text array, default is JSONB
 
 ### Quoting
 - Any value of the standard mixins are quoted with these exceptions

data/lib/quote_sql/connector/active_record_base.rb

@@ -19,12 +19,11 @@ class QuoteSql
         self.class.conn
       end
 
-      def _exec_query(sql, binds = [], prepare: false, async: false)
-        conn.exec_query(sql, "SQL", binds, prepare:, async:)
+      def _exec_query(sql, binds = [], **options)
+        conn.exec_query(sql, "SQL", binds, **options)
       end
 
-      def _exec(sql, binds = [], prepare: false, async: false)
-        options = { prepare:, async: }
+      def _exec(sql, binds = [], **options)
         result = _exec_query(sql, binds, **options)
         columns = result.columns.map(&:to_sym)
         result.cast_values.map do |row|

data/lib/quote_sql/formater.rb

@@ -1,3 +1,4 @@
+require 'niceql'
 class QuoteSql
   module Formater
     PG_FORMAT_BIN = `which pg_format`.chomp.presence
@@ -9,15 +10,14 @@ class QuoteSql
 
     def to_formatted_sql
       sql = respond_to?(:to_sql) ? to_sql : to_s
-      Niceql::Prettifier.prettify_sql(sql)
+      Niceql::Prettifier.prettify_sql(sql.gsub(/(?<=[^%])%(?=\S)/, "%%"))
 
       # IO.popen(PG_FORMAT_BIN, "r+", err: "/dev/null") do |f|
       #   f.write(sql)
       #   f.close_write
       #   f.read
       # end
-    rescue
-      sql
+
     end
 
     alias to_sqf to_formatted_sql

data/lib/quote_sql/quoter.rb

@@ -1,12 +1,12 @@
 class QuoteSql
   class Quoter
-    def initialize(qsql, key, quotable)
+    def initialize(qsql, key, cast, quotable)
       @qsql = qsql
-      @key, @quotable = key, quotable
+      @key, @cast, @quotable = key, cast, quotable
       @name = key.sub(/_[^_]+$/, '') if key["_"]
     end
 
-    attr_reader :key, :quotable, :name
+    attr_reader :key, :quotable, :name, :cast
 
     def quotes
       @qsql.quotes
@@ -34,19 +34,19 @@ class QuoteSql
       @qsql.casts(name || self.name)
     end
 
-    def ident_columns(name = nil)
-      item = columns(name || self.name)
+    def ident_columns(name = self.name)
+      item = columns(name)
       unless item
-        unless item = casts(name || self.name)&.keys
-          if (table = self.table(name || self.name))&.respond_to? :column_names
+        unless item = casts(name)&.keys&.map(&:to_s)
+          if (table = self.table(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
+            raise ArgumentError, "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) }
+        if item.all? { not _1.is_a?(Symbol) and not _1.is_a?(String) and _1.respond_to?(:name) }
           item = item.map(&:name)
         end
       end
@@ -90,13 +90,13 @@ class QuoteSql
       when /(?:^|(.*)_)(ident)$/i
         _ident
       when /(?:^|(.*)_)constraints?$/i
-        quotable
+        quotable.to_s
       when /(?:^|(.*)_)(raw|sql)$/i
-        quotable
-      when /^(.+)_json$/i
-        data_json
+        quotable.to_s
+      when /(?:^|(.*)_)json$/i
+        json_recordset
       when /^(.+)_values$/i
-        data_values
+        values
       when /values$/i
         insert_values
       else
@@ -106,31 +106,7 @@ class QuoteSql
 
     ###############
 
-    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
-
+    private def _value(values)
       rv ||= values.map do |i|
         case i
         when :default, :current_timestamp
@@ -143,128 +119,155 @@ class QuoteSql
       Raw.sql "(#{rv.join(",")})"
     end
 
-    def data_json(item = @quotable)
+    # 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 json_recordset(rows = @quotable)
+      case rows
+      when Array, Integer
+      when Hash
+        rows = [rows]
+      else
+        raise ArgumentError, "just Array<Hash> or Hash (for a single value)"
+      end
       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}"
+      columns = (self.columns(name) || casts&.keys)&.map(&:to_sym)
+      if rows.is_a? Integer
+        rv = "$#{rows}"
       else
-        item = [item].flatten.compact.as_json.map { _1.slice(*columns.map(&:to_s)) }
-        rv = "'#{item.to_json.gsub(/'/, "''")}'"
+        rows = rows.compact.map { _1.transform_keys(&:to_sym) }
+        raise ArgumentError, "all values need to be type Hash" if rows.any? { not _1.is_a?(Hash) }
+        columns ||= rows.flat_map { _1.keys.sort }.uniq.map(&:to_sym)
+        rv = "'#{rows.map{ _1.slice(*columns)}.to_json.gsub(/'/, "''")}'"
+      end
+      raise ArgumentError, "table or columns has to be present" if columns.blank?
+      column_cast = columns.map do |column|
+        "#{QuoteSql.quote_column_name column} #{casts&.dig(column, :sql_type) || "TEXT"}"
       end
-      Raw.sql "json_to_recordset(#{rv}) AS #{QuoteSql.quote_column_name name}(#{column_cast.join(',')})"
+      Raw.sql "json_to_recordset(#{rv}) AS #{QuoteSql.quote_column_name(name || "json")}(#{column_cast.join(',')})"
     end
 
-    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
+    def values(rows = @quotable)
+      if rows.class.to_s[/^(Arel::Nodes::SqlLiteral|QuoteSql::Raw)$/]
+        return Raw.sql((item[/^\s*\(/] and item[/\)\s*$/]) ? rows : "(#{rows})")
       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) }
+      case rows
+      when Array
+      when Hash
+        rows = [rows]
       else
-        raise ArgumentError, "Either all type Hash or Array"
+        raise ArgumentError, "just raw or Array<Hash, Integer> or Hash (for a single value)"
       end
-      if types.present?
-        value = values[0][1..-2].split(/\s*,\s*/)
-        types.each_with_index { value[_2] << _1 || "" }
-        values[0] = "(" + value.join(",") + ")"
+      casts = self.casts(name)
+      columns = (self.columns(name) || casts&.keys)&.map(&:to_sym)
+      raise ArgumentError, "all values need to be type Hash" if rows.any? { not _1.is_a?(Hash) }
+      columns ||= rows.flat_map { _1.keys.sort }.uniq.map(&:to_sym)
+      values = rows.each_with_index.map do |row, i|
+        row.transform_keys(&:to_sym)
+        if i == 0 and casts.present?
+          columns.map{ "#{_quote(row[_1])}::#{casts&.dig(_1, :sql_type) || "TEXT"}" }
+        else
+          columns.map{ _quote(row[_1]) }
+        end.then { "(#{_1.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 = 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
+      Raw.sql "(VALUES #{values.join(",")}) AS #{QuoteSql.quote_column_name(name || "values")} (#{columns.map{QuoteSql.quote_column_name(_1)}.join(",")})"
+    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
-          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?
-          Raw.sql "(#{_ident column_names}) VALUES #{values.join(",")}"
-        else
-          Raw.sql "VALUES #{values.join(",")}"
-        end
+    def insert_values(rows = @quotable)
+      if rows.class.to_s[/^(Arel::Nodes::SqlLiteral|QuoteSql::Raw)$/]
+        return Raw.sql((item[/^\s*\(/] and item[/\)\s*$/]) ? rows : "(#{rows})")
+      end
+      case rows
+      when Array
       when Hash
-        value([item])
+        rows = [rows]
+      else
+        raise ArgumentError, "just raw or Array<Hash> or Hash (for a single value)"
       end
-    end
 
-    def cast
-      if m = key.to_s[CASTS]
-        m[2..].sub(CASTS) { _1.tr("_", " ") }
-      end
+      rows = rows.compact.map { _1.transform_keys(&:to_sym) }
+      raise ArgumentError, "all values need to be type Hash" if rows.any? { not _1.is_a?(Hash) }
+      casts = self.casts(name)
+      columns = (self.columns(name) || casts&.keys || rows.flat_map { _1.keys.sort }.uniq).map(&:to_sym)
+      raise ArgumentError, "table or columns has to be present" if columns.blank?
+      columns -= (casts&.select { _2[:virtual] }&.keys || [])
+      values = rows.map { _value(_1.fetch_values(*columns) { :default }) }
+      Raw.sql("(#{columns.map { QuoteSql.quote_column_name _1 }.join(",")}) VALUES #{values.join(",")}")
     end
 
-    def json?
-      !!key[/(^|_)(jsonb?)$/]
+    def json?(cast = self.cast)
+      cast.to_s[/jsonb?$/i]
     end
 
-    private def _quote(item = @quotable, cast = self.cast)
-      rv = QuoteSql.quote(item)
-      if cast
-        rv << "::#{cast.upcase}"
-        rv << "[]" * rv.depth if rv[/^ARRAY/]
-      end
-      Raw.sql rv
+    private def _quote(item = @quotable)
+      Raw.sql QuoteSql.quote(item)
     end
 
     private def _quote_column_name(name)
       Raw.sql name.scan(/(?:^|")?([^."]+)/).map { QuoteSql.quote_column_name _1 }.join(".")
     end
 
-    def quote(item = @quotable)
-      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"
-        _quote(item.to_json, :jsonb)
-      else
-        return Raw.sql item.to_sql if item.respond_to? :to_sql
-        _quote(item)
+    private def _quote_array(items)
+      rv = items.map do |i|
+        if i.is_a?(Array)
+          _quote_array(i)
+        elsif self.cast[/jsonb?/i]
+          _quote(i.to_json)
+        else
+          quote(i)
+        end
+      end
+      "[#{rv.join(",")}]"
+    end
+
+    def quote_hash(item)
+      item.compact! if item.delete(nil) == false
+      case self.cast
+      when /hstore/i
+        _quote(item.map { "#{_1}=>#{_2.nil? ? 'NULL' : _2}" }.join(","))
+      when NilClass, ""
+        "#{_quote(item.to_json)}::JSONB"
+      when /jsonb?/i
+        _quote(item.to_json)
       end
     end
 
+    def quote(item = @quotable, cast = nil)
+      Raw.sql case item.class.to_s
+              when "Arel::Nodes::SqlLiteral", "QuoteSql::Raw"
+                item
+              when "Array"
+                if json? or self.cast.blank?
+                  rv = _quote(item.to_json)
+                  self.cast.present? ? rv : "#{rv}::JSONB"
+                else
+                  "ARRAY#{_quote_array(item)}"
+                end
+              when "Hash"
+                quote_hash(item)
+              else
+                if item.respond_to? :to_sql
+                  item.to_sql
+                elsif json?
+                  _quote(item.to_json)
+                else
+                  _quote(item)
+                end
+              end
+    end
+
     def column_names(item = @quotable)
       if item.respond_to?(:column_names)
         item = item.column_names

data/lib/quote_sql/test.rb

@@ -1,5 +1,6 @@
 class QuoteSql::Test
   private
+
   def test_columns
     expected <<~SQL
       SELECT x, "a", "b", "c", "d"
@@ -49,22 +50,46 @@ class QuoteSql::Test
     )
   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_values_hash_active_record
+    table = create_active_record_class("tasks") do |t|
+      t.text :name
+      t.integer :n1, default: 1, null: false
+      t.virtual :v1, type: :boolean, stored: true, as: "FALSE"
+      t.timestamps
+    end
+    updated_at = Date.new(2024,1,1)
+    expected <<~SQL
+        INSERT INTO "tasks" ("id", "name", "n1", "created_at", "updated_at") VALUES (DEFAULT, 'Task1', 1, DEFAULT, DEFAULT), (DEFAULT, 'Task2', DEFAULT, DEFAULT, '2024-01-01')
+    SQL
+    values = [
+                {n1: 1, name: "Task1"},
+                {name: "Task2", updated_at: }
+    ]
+    QuoteSql.new(<<~SQL).quote(table:, values:)
+        INSERT INTO %table %values
+    SQL
+  end
 
-  def test_from_values_array
+  def test_values_hash_active_record_select_columns
+    table = create_active_record_class("tasks") do |t|
+      t.text :name
+      t.integer :n1, default: 1, null: false
+      t.virtual :v1, type: :boolean, stored: true, as: "FALSE"
+      t.timestamps
+    end
     expected <<~SQL
-      SELECT * FROM (VALUES ('a',1,TRUE,NULL)) AS "x" ("column1","column2","column3","column4")
+        INSERT INTO "tasks" ("name") VALUES ('Task1'), ('Task2')
+    SQL
+    values = [
+      {n1: 1, name: "Task1"},
+      {name: "Task2", id: "12345" }
+    ]
+    QuoteSql.new(<<~SQL).quote(table:, values:, columns: %i[name])
+        INSERT INTO %table %values
     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")
@@ -93,7 +118,7 @@ class QuoteSql::Test
                   ) AS "x" ("a", "b", "c", "d")
     SQL
     "SELECT * FROM %x_values".quote_sql(
-      x_columns: {
+      x_casts: {
         a: "text",
         b: "integer",
         c: "boolean",
@@ -106,12 +131,6 @@ class QuoteSql::Test
       ])
   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
@@ -124,29 +143,91 @@ class QuoteSql::Test
     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'}])
+    "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)
+      INSERT INTO users ("name", "color") SELECT * from json_to_recordset('[{"name":"auge","color":"#611333"}]') AS "json"("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:)
+    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 (%columns) SELECT * from %json".quote_sql(columns: %i[name color], json:)
   end
 
   def test_from_json_bind
     expected <<~SQL
-        Select * From json_to_recordset($1) AS "x"("a" int,"b" text,"c" boolean)
+      Select * From json_to_recordset($1) AS "x"("a" int,"b" text,"c" boolean)
     SQL
-    QuoteSQL("Select * From %x_json", x_json: 1, x_casts: {a: "int", b: "text", c: "boolean"})
+    QuoteSQL("Select * From %x_json", x_json: 1, x_casts: { a: "int", b: "text", c: "boolean" })
   end
 
   def test_insert_json_bind
     expected <<~SQL
-         INSERT INTO table ("a","b","c") Select * From json_to_recordset($1) AS "x"("a" int,"b" text,"c" boolean)  
+      INSERT INTO table ("a","b","c") Select * From json_to_recordset($1) AS "x"("a" int,"b" text,"c" boolean)  
+    SQL
+    QuoteSQL("INSERT INTO table (%x_columns) Select * From %x_json", x_json: 1, x_casts: { a: "int", b: "text", c: "boolean" })
+  end
+
+  def test_cast_values
+    expected <<~SQL
+      SELECT 
+         'abc'::TEXT, 
+         '"abc"'::JSON, 
+         '["cde",null,"fgh"]'::JSONB,
+         ARRAY['cde', NULL, 'fgh']::TEXT[],  
+         ARRAY['"cde"', 'null', '"fgh"']::JSON[],
+         '{"foo":"bar","go":1,"strip_null":null}'::JSONB not_compact,
+         '{"foo":"bar","go":1}'::JSON compact,
+         'foo=>bar,go=>1,strip_null=>NULL'::HSTORE,
+        ARRAY[[1,2,3],[1,2,3]]::INT[][]
+    SQL
+    array1 = array2 = array3 = ["cde", nil, "fgh"]
+    array4 = [[1, 2, 3], [1, 2, 3]]
+    hash = { foo: "bar", "go": 1, strip_null: nil }
+    QuoteSQL(<<~SQL, field1: 'abc', array1:, array2:, array3:, array4:, hash:, not_compact: hash, compact: hash.merge(nil => false))
+      SELECT 
+        %field1::TEXT, 
+        %field1::JSON,
+        %array1,
+        %array2::TEXT[],
+        %array3::JSON[], 
+        %not_compact not_compact,
+        %compact::JSON compact,
+        %hash::HSTORE,
+        %array4::INT[][]
+    SQL
+  end
+
+  def test_columns_with_tables
+    expected <<~SQL
+      SELECT "profiles"."a", "profiles"."b",
+          "relationships"."a", "relationships"."b",
+          relationship_timestamp("relationships".*)
+    SQL
+
+    profile_table = "profiles"
+    relationship_table = "relationships"
+    relationship_columns = profile_columns = %i[a b]
+
+    <<~SQL.quote_sql(profile_columns:, profile_table:, relationship_columns:, relationship_table:)
+      SELECT %profile_columns, %relationship_columns, 
+        relationship_timestamp(%relationship_table.*)
+    SQL
+  end
+
+  def test_active_record
+    table = create_active_record_class("users") do |t|
+      t.text :first_name
+      t.integer :n1, default: 1, null: false
+      t.virtual :v1, type: :boolean, stored: true, as: "FALSE"
+      t.timestamps default: "CURRENT_TIMESTAMP", null: false
+    end
+    expected <<~SQL
+      SELECT "id", "first_name", "n1", "v1", "created_at", "updated_at" FROM "users"
+    SQL
+    <<~SQL.quote_sql(table:)
+        SELECT %columns FROM %table
     SQL
-    QuoteSQL("INSERT INTO table (%x_columns) Select * From %x_json", x_json: 1, x_casts: {a: "int", b: "text", c: "boolean"})
   end
 
   # def test_q3
@@ -172,7 +253,6 @@ class QuoteSql::Test
   #     )
   # end
 
-
   public
 
   def all
@@ -187,16 +267,20 @@ class QuoteSql::Test
   def run(name, all = false)
     name = name.to_s.sub(/^test_/, "")
     rv = ["🧪 #{name}"]
+    puts(*rv)
     @expected = nil
     @test = send("test_#{name}")
     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 += [
-        "QuoteSql.new(\"#{@test.original}\").quote(#{{**tables, **columns, **@test.quotes }.inspect}).to_sql", "🎯 #{expected}", "✅ #{sql}"]
+      # tables = @test.tables.to_h { [[_1, "table"].compact.join("_"), _2] }
+      # columns = @test.instance_variable_get(:@columns).to_h { [[_1, "columns"].compact.join("_"), _2] }
+      #"QuoteSql.new(\"#{@test.original}\").quote(#{{ **tables, **columns, **@test.quotes }.inspect}).to_sql",
+        rv += ["🎯 #{expected}", "✅ #{sql}"]
+
       @success << rv if @success
     else
       rv += [@test.inspect, "🎯 #{expected}", "❌ #{sql}"]
+      rv << "🎯 " + expected&.gsub(/\s+/, "")&.downcase&.strip
+      rv << "❌ " + sql.gsub(/\s+/, "")&.downcase&.strip
       @fail << rv if @fail
     end
   rescue => exc
@@ -214,18 +298,170 @@ class QuoteSql::Test
     @test.to_sql
   end
 
-  class PseudoActiveRecord
-    def self.table_name
-      "pseudo_active_records"
+  class PseudoActiveRecordKlass
+    class Column
+      def initialize(name, type, **options)
+        @name = name.to_s
+        @type = type
+        @null = options[:null]
+        type = options[:type] if @type == :virtual
+        @sql_type = DATATYPES[/^#{type}$/]
+        unless @type == :virtual or options[:default].nil?
+         @default = options[:default]
+        end
+      end
+
+      attr_reader :name, :type, :sql_type, :null, :default, :default_function
+
+      def default?
+        ! (@default || @default_function).nil?
+      end
     end
+    class Columns
+      def initialize(&block)
+        @rv = []
+        block.call(self)
+      end
 
-    def self.column_names
-      %w(id column1 column2)
+      def to_a
+        @rv
+      end
+
+      def timestamps(**options)
+        @rv << Column.new( :created_at, :timestamp, null: false, **options)
+        @rv << Column.new( :updated_at, :timestamp, null: false, **options)
+      end
+
+      def method_missing(type, name, *args, **options)
+        @rv << Column.new(name, type, *args, **options)
+      end
     end
 
-    def to_qsl
-      "SELECT * FROM #{self.class.table_name}"
+    def initialize(table_name, id: :uuid, &block)
+      @table_name = table_name
+      @columns = Columns.new(&block).to_a
+      unless id.nil? or id == false
+        @columns.unshift(Column.new("id", *[id], null: false, default: "gen_random_uuid()"))
+      end
     end
+
+    attr_reader :table_name, :columns
+
+    def column_names
+      @columns.map { _1.name }
+    end
+  end
+
+  def create_active_record_class(table_name, **options, &block)
+     PseudoActiveRecordKlass.new(table_name, **options, &block)
+  end
+
+
+  def datatype
+    errors = {}
+    success = []
+    spaces = ->(*) { " " * (rand(4) + 1) }
+
+    DATATYPES.each_line(chomp: true) do |line|
+
+      l = line.gsub(/\s+/, &spaces).gsub(/(?<=\()\d+|\d+(?=\))/) { "#{spaces.call}#{rand(10) + 1}#{spaces.call}" }.gsub(/\(/) { "#{spaces.call}(" }
+
+      m = "jgj hsgjhsgfjh ag %field::#{l} asldfalskjdfl".match(QuoteSql::CASTS)
+      if m.present? and l == m[1]
+        success << line
+      else
+        errors[line] = m&.to_a
+      end
+      line = line + "[]" * (rand(3) + 1)
+      m = "jgj hsgjhsgfjh ag %field::#{line} asldfalskjdfl".match(QuoteSql::CASTS)
+      if m.present? and line == m[1] + m[2]
+        success << line
+      else
+        errors[line] = m&.to_a
+      end
+    end
+    puts success.sort.inspect
+    ap errors
   end
 
-end
+  DATATYPES = <<-DATATYPES
+bigint
+int8
+bigserial
+serial8
+bit
+bit (1)
+bit varying
+varbit
+bit varying (2)
+varbit (2)
+boolean
+bool
+box
+bytea
+character
+char
+character (1)
+char (1)
+character varying
+varchar
+character varying (1)
+varchar (1)
+cidr
+circle
+date
+double precision
+float8
+inet
+integer
+int
+int4
+interval
+interval (1)
+json
+jsonb
+line
+lseg
+macaddr
+macaddr8
+money
+numeric
+numeric(10,3)
+decimal
+decimal(10,3)
+path
+pg_lsn
+pg_snapshot
+point
+polygon
+real
+float4
+smallint
+int2
+smallserial
+serial
+serial2
+serial4
+text
+time
+time(1)
+time without time zone
+time(1) without time zone
+time with time zone
+time(2) with time zone
+timetz
+timestamp
+timestamp(1)
+timestamp without time zone
+timestamp(1) without time zone
+timestamp with time zone
+timestamp(1) with time zone
+timestamptz
+tsquery
+tsvector
+txid_snapshot
+uuid
+xml
+  DATATYPES
+
+end

data/lib/quote_sql/version.rb

@@ -1,3 +1,3 @@
 class QuoteSql
-  VERSION = "0.0.6"
+  VERSION = "0.0.8"
 end

data/lib/quote_sql.rb

@@ -4,24 +4,28 @@ Dir.glob(__FILE__.sub(/\.rb$/, "/*.rb")).each { require(_1) unless _1[/(deprecat
 class QuoteSql
 
   DATA_TYPES_RE = %w(
-(?:small|big)(?:int|serial)
-bit bool(?:ean)? box bytea cidr circle date
+(?>character\\s+varying|bit\\s+varying|character|varbit|varchar|char|bit|interval)(?>\\s*\\(\\s*\\d+\\s*\\))?
+(?>numeric|decimal)(?>\\s*\\(\\s*\\d+\\s*,\\s*\\d+\\s*\\))?
+timestamptz timetz
+time(?>stamp)?(?>\\s*\\(\\s*\\d+\\s*\\))?(?>\\s+with(?>out)?\\s+time\\s+zone)?
+integer
+(?>small|big)(?>int|serial)
+bool(?>ean)? box bytea cidr circle date
 (?:date|int[48]|num|ts(?:tz)?)(?:multi)?range
 macaddr8?
-jsonb?
-ts(?:query|vector)
-float[48] (?:int|serial)[248]?
-double_precision  inet
-integer  line lseg   money   path pg_lsn
-pg_snapshot point polygon real  text timestamptz timetz
-txid_snapshot uuid xml
-(bit_varying|varbit|character|char|character varying|varchar)(_\\(\\d+\\))?
-(numeric|decimal)(_\\(\d+_\d+\\))?
-interval(_(YEAR|MONTH|DAY|HOUR|MINUTE|SECOND|YEAR_TO_MONTH|DAY_TO_HOUR|DAY_TO_MINUTE|DAY_TO_SECOND|HOUR_TO_MINUTE|HOUR_TO_SECOND|MINUTE_TO_SECOND))?(_\\(\d+\\))?
-time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
+ts(?>query|vector)
+float[48]
+(?:int|serial)[248]?
+double\\s+precision
+jsonb json
+ inet
+line lseg   money   path
+pg_lsn pg_snapshot txid_snapshot
+point polygon real text
+uuid xml hstore
     ).join("|")
 
-  CASTS = Regexp.new("__(#{DATA_TYPES_RE})$", "i")
+  CASTS = Regexp.new("::(#{DATA_TYPES_RE})((?:\\s*\\[\\s*\\d?\\s*\\])*)", "i")
 
   def self.conn
     raise ArgumentError, "You need to define a database connection function"
@@ -46,20 +50,49 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
   attr_reader :sql, :quotes, :original, :binds, :tables, :columns
 
   def table(name = nil)
-    @tables[name&.to_sym].dup
+    table = @tables[name&.to_sym]
+    table.is_a?(Class) ? table : table.dup
   end
 
+  def table=(value)
+    name, table = value
+    name = name&.to_sym
+    @tables[name] = table
+    if table.respond_to?(:columns)
+      @casts[name] = table.columns.to_h do |c|
+        [c.name.to_sym, { sql_type: c.sql_type, default: (c.default || c.default_function rescue nil).present?, virtual: c.type == :virtual }]
+      end if @casts[name].blank?
+    elsif table.respond_to?(:column_names)
+      @casts[name] = table.column_names.to_h { [_1.to_sym, nil] } if @casts[name].blank?
+    end
+  end
+
+  alias tables= table=
+
+  def column=(value)
+    name, column = value
+    name = name&.to_sym
+    @columns[name] = column
+  end
+
+  alias columns= column=
+
+  def cast=(value)
+    name, cast = value
+    name = name&.to_sym
+    raise ArgumentError unless cast.is_a?(Hash)
+    (@casts[name] ||= {}).update(cast.transform_values { _1.is_a?(Hash) ? _1 : { sql_type: _1 } })
+  end
+
+  alias casts= cast=
+
   def columns(name = nil)
-    @columns[name&.to_sym].dup
+    name = name&.to_sym
+    @columns[name] || @casts[name]&.keys&.map(&:to_s)
   end
 
   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
-    rv
+    @casts[name&.to_sym]
   end
 
   # Add quotes keys are symbolized
@@ -69,7 +102,8 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
       _, 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
+      send(:"#{type}=", [name, value])
+      # instance_variable_get(:"@#{type.sub(/s*$/,'s')}")[name&.to_sym] = value
     end
     @quotes.update quotes.transform_keys(&:to_sym)
     self
@@ -87,7 +121,7 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
     if binds.present? and sql.scan(/(?<=\$)\d+/).map(&:to_i).max != binds.length
       raise ArgumentError, "Wrong number of binds"
     end
-    _exec(sql, binds, prepare: false, async: false)
+    _exec(sql, binds, prepare: false)
   rescue => exc
     STDERR.puts exc.inspect, self.inspect
     raise exc
@@ -127,7 +161,7 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
       if @binds.length != record.length
         next RuntimeError.new("binds are not equal arguments, #{record.inspect}")
       end
-      _exec(sql, record, prepare: false, async: false)
+      _exec(sql, record, prepare: false)
     end
   end
 
@@ -152,11 +186,8 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
   def key_matches
     @sql.scan(MIXIN_RE).map do |full, *key|
       key = key.compact[0]
-      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]
+      [full, key, has_quote]
     end
   end
 
@@ -166,27 +197,28 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
     loop do
       s = StringScanner.new(@sql)
       sql = ""
-      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+)?/im)
-          if m[1].present?
-            bind_num = m[1].to_i
-            @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}#{"::#{cast}" if cast.present?}#{post}"
-        elsif has_quote
-          quoted = quoter(key)
+      key_matches.each do |key_match, key, has_quote|
+        s.scan_until(/(.*?)#{key_match}(#{CASTS}?)/im)
+        matched, pre, cast = s.matched, s[1], s[2]
+        # if m = key.match(/^bind(\d+)?/im)
+        #   if m[1].present?
+        #     bind_num = m[1].to_i
+        #     @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}#{"::#{cast}" if cast.present?}#{post}"
+        # els
+        if has_quote
+          quoted = quoter(key, cast)
           unresolved.delete key
           if (i = quoted.scan MIXIN_RE).present?
             unresolved += i.map(&:last)
           end
-          matched = "#{pre}#{quoted}#{post}"
+          matched = "#{pre}#{quoted}#{cast}"
         end
       rescue TypeError
       ensure
@@ -200,8 +232,8 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
     self
   end
 
-  def quoter(key)
-    quoter = @resolved[key.to_sym] = Quoter.new(self, key, @quotes[key.to_sym])
+  def quoter(key, cast)
+    quoter = @resolved[key.to_sym] = Quoter.new(self, key, cast, @quotes[key.to_sym])
     quoter.to_sql
   rescue TypeError => exc
     @resolved[key.to_sym] = exc
@@ -224,8 +256,11 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
 
   def self.test(which = :all)
     require __dir__ + "/quote_sql/test.rb"
-    if which == :all
+    case which
+    when :all
       Test.new.all
+    when :datatype
+      Test.new.datatype
     else
       Test.new.run(which)
     end
@@ -239,9 +274,3 @@ end
 
 QuoteSql.include QuoteSql::Formater
 
-class Array
-  def depth
-    select { _1.is_a?(Array) }.map { _1.depth.to_i + 1 }.max || 1
-  end
-end
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quote-sql
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - Martin Kufner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-27 00:00:00.000000000 Z
+date: 2024-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: niceql