quote-sql 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb47e85b4c7c4e1f945748295390c9e1bd49b7e0ba5291e0f7310058f6f91ddc
-  data.tar.gz: 0f5bde1afc31eb573bb3e24727b530bf5909048284114d45c56c1b24a63e97aa
+  metadata.gz: cfe070af9a81f751ed10ef8ace30bf5e44a3efb54cff04f2eb5cc137b7fbc0f1
+  data.tar.gz: 8c8ec59ca80a8c72ceee6567da4beb5f79c96a63e16d945694fed26ea695feca
 SHA512:
-  metadata.gz: 6596b9bb50ee373030e401dcb9d0067ae31857b6467fdd7b0341e21b3dcbe8fb0e78714ec24f56615618bbf965849307474a4030978e6c98d2d728166e235151
-  data.tar.gz: f38366de3e2227835fd11f512a9c9d2a99d130d896a17f6b0a58788dd8ed7ebd13f46682992b762e2d50f09716c3bd5654d525dc4b03f350d3a52cc6b19b322e
+  metadata.gz: 03d69b9b3256cd22762844dc98c31ce2223c673079488d7175078dd82406d8031673368871a2a920ecda17ea68beb79c87f3208d56b1e770c4ba15583fafc648
+  data.tar.gz: b6d9f335cdcaf0e597f3118090451059220ebd9e540eda483f546301ad148bfebc35150a73a72c6dc54a39f537e8aa9b854970a975218226a26af3ed6add75c0

data/README.md

@@ -1,29 +1,32 @@
 # QuoteSql - Tool to build and run SQL queries easier
-I've built this library as an addition to ActiveRecord and Arel, however you can use it with any sql database and plain Ruby.
-However currently it is just used with PostgreSQL.
-
 Creating SQL queries and proper quoting becomes complicated especially when you need advanced queries.
 
-I created this library while coding for different projects, and had lots of Heredoc SQL queries, which pretty quickly becomes the kind of: 
-> When I wrote these lines of code, just me and God knew what they mean. Now its just God.
+I created this library while coding for different projects, and had lots of Heredoc SQL queries, which pretty quickly became unreadable.
+
+With QuoteSql you segment SQL Queries in readable junks, which can be individually tested and then combine them to the final query.
+When us use RoR, you can combine queries or get the output with fields other than `pick` or `pluck`
+
+Please have a look at the *unfinished* documentation below or run `QuoteSql.test` in a Ruby console
 
-My strategy is to segment SQL Queries in readable junks, which can be individually tested and then combine their sql to the final query.
+If you think QuoteSql is interesting but needs extension, let's chat!
 
-If you think QuoteSql is interesting, let's chat!
-Also if you have problems using it, just drop me a note.
+If you run into problems, drop me a note.
 
 Best Martin
 
 ## Caveats & Notes
+- Currently its just built for Ruby 3, if you need Ruby 2, let me know.
 - 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*. 
+- 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*.
+- I've built this library as an addition to ActiveRecord and Arel, however you can use it with any sql database and plain Ruby.
+- It is currently built for PostgreSQL only. If you want to use other DBs, please contribute your code!
 
 ## Examples
 ### Simple quoting
 `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
@@ -31,11 +34,12 @@ Best Martin
 => SELECT first_name, last_name FROM users LIMIT 10
 
 ### Quoting of columns and table from a model - or an object responding to table_name and column_names or columns
-`QuoteSql.new("SELECT %columns FROM %table_name").quote(table: User).to_sql`
+`QuoteSql.new("SELECT %columns FROM %table").quote(table: User).to_sql`
   => SELECT "id",firstname","lastname",... FROM "users"
+  
 ### Injecting raw sql in a query
-`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 a,b,%raw FROM my_table").quote(raw: "jsonb_build_object('a', 1)").to_sql`
+  => SELECT "a,b,jsonb_build_object('a', 1) FROM my_table
 
 ### Injecting ActiveRecord, Arel.sql or QuoteSql
 `QuoteSql.new("SELECT %column_names FROM (%any_name) a").
@@ -54,15 +58,32 @@ Values are be ordered in sequence of columns. Missing value entries are substitu
       ON CONFLICT ("id") DO NOTHING
       
 ### Columns from a list
-`QuoteSql.new("SELECT %columns").quote(columns: [:a, :"b.c", c: {d: field}]).to_sql`
-  => SELECT "a","b"."c",jsonb_build_object('d', field) AS c 
+`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
 
-`QuoteSql.new("SELECT %columns").quote(columns: [:a, :"b.c", c: {d: field, nil: false}]).to_sql`
-  => SELECT "a","b"."c",jsonb_strip_nulls(jsonb_build_object('d', 1)) AS c 
+## Executing
+### Getting the results
+  `QuoteSql.new('SELECT %x AS a').quote(x: 1).result`
+    => [{:a=>1}]
+
+### 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
+
+    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}]
+
+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)
 
 
-### Execution of a query
-`QuoteSql.new("Select 1 as abc").result` => [{:abc=>1}]
 
 
 ## Substitution of mixins with quoted values 
@@ -73,24 +94,14 @@ Values are be ordered in sequence of columns. Missing value entries are substitu
   **Caution! You need to take care, no protection against infinite recursion **
   
 ### Special mixins
-- `%table` | `%table_name` | `%table_names`
-- `%column` | `%columns` | `%column_names`
+- `%table` +String+, +ActiveRecord::Base+, Object responding to #to_sql, and +Array+ of these
+- `%columns` +Array+ of +String+, +Hash+ keys: AS +Symbol+, +String+. fallback: 1) %casts keys, 2) %table.columns 
+- `%casts` +Hash+ keys: column name, values: Cast e.g. "text", "integer"
 - `%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 (TO BE IMPLEMENTED)
-  - `%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
+- `%values` creates the value section for INSERT `INSERT INTO foo (a,b) %values`
+- `%x_values` creates the value secion for FROM `SELECT column1, column2, column3 FROM %x_values`
+- `%x_json` creates `json_for_recordset(JSON) x (CASTS)`. "x" can be any other identifier, you need to define the casts e.g. `quotes(x_json: {a: "a", b: 1}, x_casts: {a: :text, b: :integer)`
 
 All can be preceded by additional letters and underscore e.g. `%foo_bar_column`
 
@@ -98,10 +109,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
@@ -110,22 +119,27 @@ with optional array dimension
 - 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"
+### Special quoting for %columns
+
+    `QuoteSql.new("SELECT %columns FROM %table, other_table").quote(columns: ["a", "other_table.a", :a ], table: "my_table")`
+    => SELECT "a", "other_table"."a", "my_table"."a" from "my_table", "other_table"
+
+- +String+ without a dot  e.g. "firstname" => "firstname"
+- +String+ containing a dot e.g. "users.firstname" or => "users"."firstname"
+- +Symbol+ prepended with table from table: quote if present.
+- +Proc+ is called in the current context
+- +QuoteSql::Raw+ or +Arel::Nodes::SqlLiteral+ are injected as is
+- Object responding to #to_sql is called and injected 
 - +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
+  - other see above
+- +Hash+
+  - keys become the "AS"
+  - values
+    - +Hash+, +Array+ casted as JSONB
+    - others see above
+    
 
-## 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)`
@@ -137,8 +151,8 @@ 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`
+Currently there are just minimal tests
+run `QuoteSql.test`
 You can find them in /lib/quote_sql/test.rb
 
 ## Installing
@@ -151,8 +165,15 @@ Add this to config/initializers/quote_sql.rb
 
     ActiveSupport.on_load(:active_record) do
       require 'quote_sql'
-      QuoteSql.db_connector = ActiveRecord::Base
+      
+      # if you want to execute from Strings 
+      #   e.g. "select %a".quote_sql(a: 1).result
       String.include QuoteSql::Extension
+
+      # if you use Active Record 
+      QuoteSql.db_connector = ActiveRecord::Base
+      # if you want to execute from a Model 
+      #   e.g. User.select("name, %a").quote_sql(a: 1).result
       ActiveRecord::Relation.include QuoteSql::Extension
     end  
 

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
@@ -227,42 +227,65 @@ class QuoteSql
       end
     end
 
-    def cast
-      if m = key.to_s[CASTS]
-        m[2..].sub(CASTS) { _1.tr("_", " ") }
-      end
-    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)

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,14 +50,14 @@ 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_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
@@ -124,29 +125,59 @@ 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 "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:)
+    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)
+      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
-    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 +203,6 @@ class QuoteSql::Test
   #     )
   # end
 
-
   public
 
   def all
@@ -193,10 +223,12 @@ class QuoteSql::Test
       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}"]
+        "QuoteSql.new(\"#{@test.original}\").quote(#{{ **tables, **columns, **@test.quotes }.inspect}).to_sql", "🎯 #{expected}", "✅ #{sql}"]
       @success << rv if @success
     else
       rv += [@test.inspect, "🎯 #{expected}", "❌ #{sql}"]
+      rv << sql.gsub(/\s+/, "")&.downcase&.strip
+      rv << expected&.gsub(/\s+/, "")&.downcase&.strip
       @fail << rv if @fail
     end
   rescue => exc
@@ -228,4 +260,111 @@ class QuoteSql::Test
     end
   end
 
-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
+
+  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.5"
+  VERSION = "0.0.7"
 end

data/lib/quote_sql.rb

@@ -3,25 +3,30 @@ 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(
-(?: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"
@@ -152,11 +157,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 +168,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 +203,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 +227,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

metadata

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