quote-sql 0.0.3 → 0.0.5

data/lib/quote_sql/test.rb

@@ -1,35 +1,216 @@
-module QuoteSql::Test
-  def self.all
+class QuoteSql::Test
+  private
+  def test_columns
+    expected <<~SQL
+      SELECT x, "a", "b", "c", "d"
+    SQL
+    "SELECT x, %x_columns ".quote_sql(x_columns: %i[a b c d])
+  end
+
+  def test_columns_and_table_name_simple
+    expected <<~SQL
+      SELECT "my_table"."a", "b", "gaga"."c", "my_table"."e" AS "d", "gaga"."d" AS "f", 1 + 2 AS "g", whatever AS raw FROM "my_table"
+    SQL
+    QuoteSql.new("SELECT %columns FROM %table").quote(
+      columns: [:a, "b", "gaga.c", { d: :e, f: "gaga.d", g: Arel.sql("1 + 2") }, Arel.sql("whatever AS raw")],
+      table: "my_table"
+    )
+  end
+
+  def test_columns_and_table_name_complex
+    expected <<~SQL
+      SELECT "table1"."a","table1"."c" as "b" FROM "table1","table2"
+    SQL
+    QuoteSql.new("SELECT %columns FROM %table").quote(
+      columns: [:a, b: :c],
+      table: ["table1", "table2"]
+    )
+  end
+
+  def test_recursive_injects
+    expected %(SELECT TRUE FROM "table1")
+    QuoteSql.new("SELECT %raw FROM %table").quote(
+      raw: "%recurse1_raw",
+      recurse1_raw: "%recurse2",
+      recurse2: true,
+      table: "table1"
+    )
+  end
+
+  def test_values
+    expected <<~SQL
+      SELECT 'a text', 123, '{"abc":"don''t"}'::jsonb FROM "my_table"
+    SQL
+    QuoteSql.new("SELECT %text, %{number}, %hash FROM %table").quote(
+      text: "a text",
+      number: 123,
+      hash: { abc: "don't" },
+      table: "my_table"
+    )
+  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_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_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_from_json
+    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'}])
+  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)
+    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:)
+  end
+
+  def test_from_json_bind
+    expected <<~SQL
+        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"})
+  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)  
+    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
+  #   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
+
+
+  public
+
+  def all
     @success = []
     @fail = []
-    methods(false).grep(/^test_/).each do |name|
-      run(name, true)
-    end
+    private_methods(false).grep(/^test_/).each { run(_1, true) }
     @success.each { STDOUT.puts(*_1, nil) }
     @fail.each { STDOUT.puts(*_1, nil) }
     puts
   end
 
-  def self.run(name, all)
+  def run(name, all = false)
     name = name.to_s.sub(/^test_/, "")
+    rv = ["🧪 #{name}"]
     @expected = nil
     @test = send("test_#{name}")
-
     if sql.gsub(/\s+/, "")&.downcase&.strip == expected&.gsub(/\s+/, "")&.downcase&.strip
-      rv = [name, @test.original, @test.quotes.inspect, "✅ #{expected}"]
+      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}"]
       @success << rv if @success
     else
-      rv = [name, @test.inspect, sql, "❌ #{expected}"]
+      rv += [@test.inspect, "🎯 #{expected}", "❌ #{sql}"]
       @fail << rv if @fail
     end
-    STDOUT.puts rv unless @fail or @success
+  rescue => exc
+    rv += [@test.inspect, "🎯 #{expected}", "❌ #{sql}", exc.message]
+    @fail << rv if @fail
+  ensure
+    STDOUT.puts(*rv) unless @fail or @success
   end
 
-  def self.expected(v = nil)
+  def expected(v = nil)
     @expected ||= v
   end
 
-  def self.sql
+  def sql
     @test.to_sql
   end
 
@@ -47,134 +228,4 @@ module QuoteSql::Test
     end
   end
 
-  class << self
-    def test_columns_and_table_name_simple
-      expected %(SELECT "a","b"."c" FROM "my_table")
-      QuoteSql.new("SELECT %columns FROM %table_name").quote(
-        columns: [:a, b: :c],
-        table_name: "my_table"
-      )
-    end
-
-    def test_columns_and_table_name_complex
-      expected %(SELECT "a","b"."c" FROM "table1","table2")
-      QuoteSql.new("SELECT %columns FROM %table_names").quote(
-        columns: [:a, b: :c],
-        table_names: ["table1", "table2"]
-      )
-    end
-
-    def test_recursive_injects
-      expected %(SELECT TRUE FROM "table1")
-      QuoteSql.new("SELECT %raw FROM %table_names").quote(
-        raw: "%recurse1_raw",
-        recurse1_raw: "%recurse2",
-        recurse2: true,
-        table_names: "table1"
-      )
-    end
-
-    def test_values
-      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,
-        aliased_with_hash: {
-          abc: "text"
-        },
-        table_name: "my_table"
-      )
-    end
-
-    def test_binds
-      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_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/version.rb

@@ -0,0 +1,3 @@
+class QuoteSql
+  VERSION = "0.0.5"
+end

data/lib/quote_sql.rb

@@ -1,90 +1,8 @@
 Dir.glob(__FILE__.sub(/\.rb$/, "/*.rb")).each { require(_1) unless _1[/(deprecated|test)\.rb$/] }
 
 # Tool to build and run SQL queries easier
-#
-#   QuoteSql.new("SELECT %field").quote(field: "abc").to_sql
-#   => SELECT 'abc'
-#
-#   QuoteSql.new("SELECT %field__text").quote(field__text: 9).to_sql
-#   => SELECT 9::TEXT
-#
-#   QuoteSql.new("SELECT %columns FROM %table_name").quote(table: User).to_sql
-#   => SELECT "id",firstname","lastname",... FROM "users"
-#
-#   QuoteSql.new("SELECT a,b,%raw FROM table").quote(raw: "jsonb_build_object('a', 1)").to_sql
-#   => SELECT "a,b,jsonb_build_object('a', 1) FROM table
-#
-#   QuoteSql.new("SELECT %column_names FROM (%any_name) a").
-#     quote(any_name: User.select("%column_names").where(id: 3), column_names: [:firstname, :lastname]).to_sql
-#   => SELECT firstname, lastname FROM (SELECT firstname, lastname FROM users where id = 3)
-#
-#   QuoteSql.new("INSERT INTO %table (%columns) VALUES %values ON CONFLICT (%constraint) DO NOTHING").
-#     quote(table: User, values: [
-#       {firstname: "Albert", id: 1, lastname: "Müller"},
-#       {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)
-#       ON CONFLICT ("id") DO NOTHING
-#
-#   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
-#
-# Substitution
-#   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
-#   the mixins can be recursive, Caution! You need to take care, you can create infintive loops!
-#
-# Special mixins are
-# - %table | %table_name | %table_names
-# - %column | %columns | %column_names
-# - %ident | %constraint | %constraints quoting for database columns
-# - %raw | %sql inserting raw SQL
-# - %value | %values creates value section for e.g. insert
-#   - In the right order
-#     - Single value => (2)
-#     - +Array+ => (column, column, column) n.b. has to be the correct order
-#     - +Array+ of +Array+ => (...),(...),(...),...
-#   - if the columns option is given (or implicitely by setting table)
-#     - +Hash+ values are ordered according to the columns option, missing values are replaced by DEFAULT
-#     - +Array+ of +Hash+ multiple record insert
-# - %bind is replaced with the current bind sequence.
-#   Without appended number the first %bind => $1, the second => $2 etc.
-#   - %bind\\d+ => $+Integer+ e.g. %bind7 => $7
-#   - %bind__text => $1 and it is registered as text - this is used in prepared statements TODO
-#   - %key_bind__text => $1 and it is registered as text when using +Hash+ in the execute
-#     $1 will be mapped to the key's value in the +Hash+ TODO
-#
-# 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[] TODO
-# - %array__text2 => adds a ::TEXT[][] TODO
-#
-# Quoting
-# - Any value of the standard mixins are quoted with these exceptions
-# - +Array+ are quoted as DB Arrays unless the type cast e.g. __jsonb is given
-# - +Hash+ are quoted as jsonb
-# - When the value responds to :to_sql or is a +Arel::Nodes::SqlLiteral+ its added as raw SQL
-# - +Proc+ are executed with the +QuoteSQL::Quoter+ object as parameter and added as raw SQL
-#
-# Special quoting columns
-# - +String+ or +Symbol+ without a dot  e.g. :firstname => "firstname"
-# - +String+ or +Symbol+ containing a dot e.g. "users.firstname" or => "users"."firstname"
-# - +Array+
-#   - +String+ and +Symbols+ see above
-#   - +Hash+ see below
-# - +Hash+ or within the +Array+
-#   - +Symbol+ value will become the column name e.g. {table: :column} => "table"."column"
-#   - +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
-#
 class QuoteSql
+
   DATA_TYPES_RE = %w(
 (?:small|big)(?:int|serial)
 bit bool(?:ean)? box bytea cidr circle date
@@ -119,56 +37,42 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
     @quotes = {}
     @resolved = {}
     @binds = []
+
+    @tables = {}
+    @columns = {}
+    @casts = {}
   end
 
-  attr_reader :sql, :quotes, :original, :binds
-  attr_writer :table_name, :column_names
+  attr_reader :sql, :quotes, :original, :binds, :tables, :columns
 
-  def table_name
-    return @table_name if @table_name
-    return unless table = @quote&.dig(:table)
-    @table_name = table.respond_to?(:table_name) ? table.table_name : table.to_s
+  def table(name = nil)
+    @tables[name&.to_sym].dup
   end
 
-  def column_names
-    return @column_names if @column_names
-    return unless columns = @quote&.dig(:columns)
-    @column_names = if columns[0].is_a? String
-      columns
-    else
-      columns.map(&:name)
-    end.map(&:to_s)
+  def columns(name = nil)
+    @columns[name&.to_sym].dup
   end
 
-  # Add quotes keys are symbolized
-  def quote(quotes1 = {}, **quotes2)
-    quotes = @quotes.merge(quotes1, quotes2).transform_keys(&:to_sym)
-    if table = quotes.delete(:table)
-      columns = quotes.delete(:columns) || table.columns
+  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
-    @quotes = { table:, columns:, **quotes }
-    self
+    rv
   end
 
-  class Error < ::RuntimeError
-    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 #{sql} #{@object.errors.inspect}>@
+  # Add quotes keys are symbolized
+  def quote(quotes = {})
+    re = /(?:^|(.*)_)(table|columns|casts)$/i
+    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
     end
+    @quotes.update quotes.transform_keys(&:to_sym)
+    self
   end
 
   def to_sql
@@ -178,14 +82,14 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
     @sql
   end
 
-  def result(binds = [], prepare: false, async: false)
+  def result(*binds, prepare: false, async: false)
     sql = to_sql
-    if binds.present? and sql.scan(/(?<=\$)\d+/).map(&:to_i).max + 1 != binds.length
+    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)
   rescue => exc
-    STDERR.puts exc.sql
+    STDERR.puts exc.inspect, self.inspect
     raise exc
   end
 
@@ -199,7 +103,6 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
     @prepare_name = name
   end
 
-
   # Executes a prepared statement
   # Processes in batches records
   # returns the array of the results depending on RETURNING is in the query
@@ -236,7 +139,7 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
     @quotes.to_h do |k, v|
       r = @resolved[k]
       next [nil, nil] if r.nil? or not r.is_a?(Exception)
-      [k, {@quotes[k].inspect => v.inspect, exc: r, backtrace: r.backtrace}]
+      [k, { @quotes[k].inspect => v.inspect, exc: r, backtrace: r.backtrace }]
     end.compact
   end
 
@@ -249,7 +152,11 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
   def key_matches
     @sql.scan(MIXIN_RE).map do |full, *key|
       key = key.compact[0]
-      [full, key, @quotes.key?(key.to_sym)]
+      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]
     end
   end
 
@@ -259,22 +166,20 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
     loop do
       s = StringScanner.new(@sql)
       sql = ""
-      key_matches.each do |key_match, key, has_quote|
+      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+)?(?:#{CASTS})?$/im)
-          if m[2].present?
-            cast = m[2].tr("_", " ")
-          end
+        if m = key.match(/^bind(\d+)?/im)
           if m[1].present?
             bind_num = m[1].to_i
             @binds[bind_num - 1] ||= cast
-            raise "cast #{bind_num} already set to #{@binds[bind_num - 1]}" unless @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}#{post}"
+
+          matched = "#{pre}$#{bind_num}#{"::#{cast}" if cast.present?}#{post}"
         elsif has_quote
           quoted = quoter(key)
           unresolved.delete key
@@ -305,9 +210,25 @@ time(stamp)?(_\\(\d+\\))?(_with(out)?_time_zone)?
 
   extend Quoting
 
-  def self.test
+  class Raw < String
+    def self.sql(v)
+      if v.class == self
+        v
+      elsif v.respond_to? :to_sql
+        new v.to_sql
+      else
+        new v
+      end
+    end
+  end
+
+  def self.test(which = :all)
     require __dir__ + "/quote_sql/test.rb"
-    Test
+    if which == :all
+      Test.new.all
+    else
+      Test.new.run(which)
+    end
   end
 end