quote-sql 0.0.4 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70f787b04560e3b297b4a392eb72c0e85be57e349a0533366056fe485f339401
-  data.tar.gz: ad8a2e347c97e12b78a264e67d0e12649e838127a0079d8ff96bf5ac51764b40
+  metadata.gz: 7e308b3aef586983a61155c9ba3be6c39c2397fa5fbae069ab45522e51681caa
+  data.tar.gz: 6a3945e1a4cfc16fed91c46216d1a10c5a69e85a6b3a0df10db45a9f162c07eb
 SHA512:
-  metadata.gz: 7d2a6819ad0d7fc752a70a04efb48c7583759a1b6cd07eb93c0bacd5deec9845b4abf578ae902c94aaf68ba4cf41720b1f05aea8dc6950b468c8cc8f42c34c42
-  data.tar.gz: e84a311154ef05f71b8af81c17cac1b4923f067fb48556f501aa075ab8fca1c112d494c8b0b58f1c8350d7d7467c10ba99f74591755beb206415dbe78756c7ff
+  metadata.gz: 3ce751f52d51a6b7b989062673f9c849b5a8b44e5e4227f0f453290d41b20856b45f0d0bbddd6cea6f5256405b313d82367a27fdd2381dd2b37f27c3ac3442e6
+  data.tar.gz: 2656c2cbacc7375fd22f2148d4a929fbba1822c97b61467bdf5794c7bcf78b75d5ba4a9bfb90a6f01b282479bad95c77d354ca2211a6f3561a6eaa60e9d90db4

data/README.md

@@ -1,21 +1,26 @@
 # 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`
 
-My strategy is to segment SQL Queries in readable junks, which can be individually tested and then combine their sql to the final query.
+Please have a look at the *unfinished* documentation below or run `QuoteSql.test` in a Ruby console
 
-QuoteSql is used in production, but is still bleeding edge - and there is not a fully sync between doc and code.
+If you think QuoteSql is interesting 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*.
+- 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`
@@ -29,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").
@@ -52,15 +58,34 @@ 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").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").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)`  
+
+#### 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 
@@ -71,24 +96,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`
 
@@ -108,16 +123,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
+    
+
 
 ## Shortcuts and functions
 - `QuoteSQL("select %abc", abc: 1)` == `QuoteSql.new("select %abc").quote(abc: 1)`
@@ -129,8 +155,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
@@ -143,8 +169,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/quoter.rb

@@ -37,9 +37,13 @@ class QuoteSql
     def ident_columns(name = nil)
       item = columns(name || self.name)
       unless item
-        table = self.table(name || self.name)
-        raise ArgumntError, "No columns or table given" unless table&.respond_to? :column_names
-        item = table.column_names
+        unless item = casts(name || self.name)&.keys
+          if (table = self.table(name || self.name))&.respond_to? :column_names
+            item = table.column_names
+          else
+            raise ArgumntError, "No columns, casts or table given for #{name}" unless table&.respond_to? :column_names
+          end
+        end
       end
       if item.is_a?(Array)
         if item.all? { _1.respond_to?(:name) }
@@ -143,11 +147,15 @@ class QuoteSql
       casts = self.casts(name)
       columns = self.columns(name) || casts&.keys
       column_cast = columns&.map { "#{QuoteSql.quote_column_name(_1)} #{casts&.dig(_1) || "TEXT"}" }
-      item = [item].flatten.compact.as_json.map{_1.slice(*columns.map(&:to_s))}
-      Raw.sql "json_to_recordset('#{item.to_json.gsub(/'/,"''")}') AS #{QuoteSql.quote_column_name name}(#{column_cast.join(',')})"
+      if item.is_a? Integer
+        rv = "$#{item}"
+      else
+        item = [item].flatten.compact.as_json.map { _1.slice(*columns.map(&:to_s)) }
+        rv = "'#{item.to_json.gsub(/'/, "''")}'"
+      end
+      Raw.sql "json_to_recordset(#{rv}) AS #{QuoteSql.quote_column_name name}(#{column_cast.join(',')})"
     end
 
-
     def data_values(item = @quotable)
       item = Array(item).compact
       column_names = columns(name)

data/lib/quote_sql/test.rb

@@ -1,59 +1,5 @@
 class QuoteSql::Test
-
-  def all
-    @success = []
-    @fail = []
-    private_methods(false).grep(/^test_/).each { run(_1, true) }
-    @success.each { STDOUT.puts(*_1, nil) }
-    @fail.each { STDOUT.puts(*_1, nil) }
-    puts
-  end
-
-  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
-      tables = @test.tables.to_h { [[_1, "table"].compact.join("_"), _2] }
-      columns = @test.instance_variable_get(:@columns).to_h { [[_1, "columns"].compact.join("_"), _2] }
-      rv += [@test.original, { **tables, **columns, **@test.quotes }.inspect, "🎯 #{expected}", "✅ #{sql}"]
-      @success << rv if @success
-    else
-      rv += [@test.inspect, "🎯 #{expected}", "❌ #{sql}"]
-      @fail << rv if @fail
-    end
-  rescue => exc
-    rv += [@test.inspect, "🎯 #{expected}", "❌ #{sql}", exc.message]
-    @fail << rv if @fail
-  ensure
-    STDOUT.puts(*rv) unless @fail or @success
-  end
-
-  def expected(v = nil)
-    @expected ||= v
-  end
-
-  def sql
-    @test.to_sql
-  end
-
-  class PseudoActiveRecord
-    def self.table_name
-      "pseudo_active_records"
-    end
-
-    def self.column_names
-      %w(id column1 column2)
-    end
-
-    def to_qsl
-      "SELECT * FROM #{self.class.table_name}"
-    end
-  end
-
   private
-
   def test_columns
     expected <<~SQL
       SELECT x, "a", "b", "c", "d"
@@ -103,14 +49,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
@@ -189,6 +135,20 @@ class QuoteSql::Test
     "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")
@@ -212,4 +172,60 @@ class QuoteSql::Test
   #     )
   # end
 
+
+  public
+
+  def all
+    @success = []
+    @fail = []
+    private_methods(false).grep(/^test_/).each { run(_1, true) }
+    @success.each { STDOUT.puts(*_1, nil) }
+    @fail.each { STDOUT.puts(*_1, nil) }
+    puts
+  end
+
+  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
+      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 += [@test.inspect, "🎯 #{expected}", "❌ #{sql}"]
+      @fail << rv if @fail
+    end
+  rescue => exc
+    rv += [@test.inspect, "🎯 #{expected}", "❌ #{sql}", exc.message]
+    @fail << rv if @fail
+  ensure
+    STDOUT.puts(*rv) unless @fail or @success
+  end
+
+  def expected(v = nil)
+    @expected ||= v
+  end
+
+  def sql
+    @test.to_sql
+  end
+
+  class PseudoActiveRecord
+    def self.table_name
+      "pseudo_active_records"
+    end
+
+    def self.column_names
+      %w(id column1 column2)
+    end
+
+    def to_qsl
+      "SELECT * FROM #{self.class.table_name}"
+    end
+  end
+
 end

data/lib/quote_sql/version.rb

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

data/lib/quote_sql.rb

@@ -82,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
 

metadata

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