quote-sql 0.0.7 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfe070af9a81f751ed10ef8ace30bf5e44a3efb54cff04f2eb5cc137b7fbc0f1
-  data.tar.gz: 8c8ec59ca80a8c72ceee6567da4beb5f79c96a63e16d945694fed26ea695feca
+  metadata.gz: 37390ee5356d22cf9fe8b2ba9d737e35c5ac6d39a69e8db62bb4b554c15328dc
+  data.tar.gz: cefa08d46fe1b51de03327f0840daa0059fc9da503225b4379c2cd8213fe455e
 SHA512:
-  metadata.gz: 03d69b9b3256cd22762844dc98c31ce2223c673079488d7175078dd82406d8031673368871a2a920ecda17ea68beb79c87f3208d56b1e770c4ba15583fafc648
-  data.tar.gz: b6d9f335cdcaf0e597f3118090451059220ebd9e540eda483f546301ad148bfebc35150a73a72c6dc54a39f537e8aa9b854970a975218226a26af3ed6add75c0
+  metadata.gz: 51fb6f48e65548dd29402fac1b4d4de5d0ebdf3dcec0e591ea10d4144be82e10e24100f535ae62627b88863ab5517b770f53fe13a24febdb2676669dbc37f674
+  data.tar.gz: cd07e668bcbe753cfd180560191d66eedfe1de87f37f33f461f4f05f981c2818e0bae83892182b17b012290fbffe13ca55fb2bac9544387d314b639d91b65a89

data/README.md

@@ -54,7 +54,9 @@ 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
@@ -81,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)
 
 
 

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/quoter.rb

@@ -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
@@ -83,20 +83,22 @@ class QuoteSql
     def to_sql
       return @quotable.call(self) if @quotable.is_a? Proc
       case key.to_s
-      when /(?:^|(.*)_)table$/i
+      when /(?:^|(.+)_)table_name$/i
         ident_table
-      when /(?:^|(.*)_)columns$/i
+      when /(?:^|(.+)_)table$/i
+        ident_table
+      when /(?:^|(.+)_)columns$/i
         ident_columns
-      when /(?:^|(.*)_)(ident)$/i
+      when /(?:^|(.+)_)(ident|column)$/i
         _ident
-      when /(?:^|(.*)_)constraints?$/i
-        quotable
-      when /(?:^|(.*)_)(raw|sql)$/i
-        quotable
-      when /^(.+)_json$/i
-        data_json
+      when /(?:^|(.+)_)constraints?$/i
+        quotable.to_s
+      when /(?:^|(.+)_)(raw|sql)$/i
+        quotable.to_s
+      when /(?:^|(.+)_)json$/i
+        json_recordset
       when /^(.+)_values$/i
-        data_values
+        values
       when /values$/i
         insert_values
       else
@@ -106,31 +108,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,88 +121,92 @@ 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
+
+      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?(cast = self.cast)
@@ -256,8 +238,8 @@ class QuoteSql
       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.map { "#{_1}=>#{_2.nil? ? 'NULL' : _2}" }.join(","))
+      when NilClass, ""
         "#{_quote(item.to_json)}::JSONB"
       when /jsonb?/i
         _quote(item.to_json)

data/lib/quote_sql/test.rb

@@ -50,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")
@@ -94,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",
@@ -107,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
@@ -130,10 +148,10 @@ class QuoteSql::Test
 
   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
@@ -164,9 +182,9 @@ class QuoteSql::Test
         ARRAY[[1,2,3],[1,2,3]]::INT[][]
     SQL
     array1 = array2 = array3 = ["cde", nil, "fgh"]
-    array4 = [[1,2,3], [1,2,3]]
+    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))
+    QuoteSQL(<<~SQL, field1: 'abc', array1:, array2:, array3:, array4:, hash:, not_compact: hash, compact: hash.merge(nil => false))
       SELECT 
         %field1::TEXT, 
         %field1::JSON,
@@ -180,6 +198,38 @@ class QuoteSql::Test
     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
+  end
+
   # def test_q3
   #   expected Arel.sql(<<-SQL)
   #         INSERT INTO "responses" ("id","type","task_id","index","data","parts","value","created_at","updated_at")
@@ -217,18 +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 << sql.gsub(/\s+/, "")&.downcase&.strip
-      rv << expected&.gsub(/\s+/, "")&.downcase&.strip
+      rv << "🎯 " + expected&.gsub(/\s+/, "")&.downcase&.strip
+      rv << "❌ " + sql.gsub(/\s+/, "")&.downcase&.strip
       @fail << rv if @fail
     end
   rescue => exc
@@ -246,20 +298,65 @@ 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 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 self.column_names
-      %w(id column1 column2)
+      def method_missing(type, name, *args, **options)
+        @rv << Column.new(name, type, *args, **options)
+      end
+    end
+
+    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
 
-    def to_qsl
-      "SELECT * FROM #{self.class.table_name}"
+    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 = []
@@ -271,11 +368,11 @@ class QuoteSql::Test
 
       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
+        success << line
+      else
+        errors[line] = m&.to_a
       end
-      line = line + "[]"*(rand(3) + 1)
+      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

data/lib/quote_sql/version.rb

@@ -1,3 +1,3 @@
 class QuoteSql
-  VERSION = "0.0.7"
+  VERSION = "0.0.9"
 end

data/lib/quote_sql.rb

@@ -3,7 +3,6 @@ Dir.glob(__FILE__.sub(/\.rb$/, "/*.rb")).each { require(_1) unless _1[/(deprecat
 # Tool to build and run SQL queries easier
 class QuoteSql
 
-
   DATA_TYPES_RE = %w(
 (?>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*\\))?
@@ -51,32 +50,64 @@ uuid xml hstore
   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
   def quote(quotes = {})
+    quotes = quotes.transform_keys(&:to_sym)
     re = /(?:^|(.*)_)(table|columns|casts)$/i
+    (table_name = quotes[:table_name].presence) and (@tables[:table] ||= table_name)
     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
+      send(:"#{type}=", [name, value])
+      # instance_variable_get(:"@#{type.sub(/s*$/,'s')}")[name&.to_sym] = value
     end
-    @quotes.update quotes.transform_keys(&:to_sym)
+    @quotes.update quotes
     self
   end
 
@@ -92,7 +123,7 @@ uuid xml hstore
     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
@@ -132,7 +163,7 @@ uuid xml hstore
       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
 
@@ -183,7 +214,7 @@ uuid xml hstore
         #
         #   matched = "#{pre}$#{bind_num}#{"::#{cast}" if cast.present?}#{post}"
         # els
-         if has_quote
+        if has_quote
           quoted = quoter(key, cast)
           unresolved.delete key
           if (i = quoted.scan MIXIN_RE).present?
@@ -245,9 +276,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.7
+  version: 0.0.9
 platform: ruby
 authors:
 - Martin Kufner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-29 00:00:00.000000000 Z
+date: 2024-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: niceql