mini_sql 1.3.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49e28eb6f0b011fa819621155a5f4507140035c5c4386d8dbcd297ea81981ad8
-  data.tar.gz: 0dd3f883623ab47c530ebdce212f32cd02a2eb76dd9b51a27e165425b1dad974
+  metadata.gz: 491de0ce7925ad9ec428409af4a78e5ce3f91b6f886bfcca7c17544a4b44e23a
+  data.tar.gz: 2269da4aa96ec6d58c2141b82cae6d3764664e312ada254fe7f45476e6cb5b55
 SHA512:
-  metadata.gz: e52ffd9133bd63060e6f5f7373958196ba56e5e1ffa38b910fe1119154f06bb076634aa18b5cad3c13045fcbf5cc6990f7966db258aea455dda62a67f2d608ee
-  data.tar.gz: a3d8370bd15bf01f150c58521da264bddfd4e766d370fa776d052d22a0b484513e2b8fa8b1588c352b4c87c023876b65cfa117655fc0c5390b5da9ea64f5751f
+  metadata.gz: dddf4370cdff6041fc2a0ceb338aa387ddcca76b65e135838cd0c3a1bfcf0bd0fcae37ea7504052b89b505b8c5478fb6d11e260e2349e25131b01853d42eae2d
+  data.tar.gz: 8d2f7087f39d05a4e8ccf72e675a07a38d9f371bdcfef33d96589a085f13abef53feb6986668fb12c75886ff9db301c0b7753b36e72177ef33944f08ce347734

data/CHANGELOG

@@ -1,3 +1,13 @@
+2023-08-16 - 1.5.0
+
+- FEATURE: add to_sql for easy conversion of builder to sql
+- FEATURE: improve active record compat
+- FEATURE: change builder to use gsub vs sub, which allows repeat clauses
+
+2022-03-07 - 1.4.0
+
+- PERF: Optimize multiple use param in prepared postgres sql
+
 2022-02-02 - 1.3.0
 
 - FEATURE: Add ActiveRecordPostgres connection

data/README.md

@@ -77,23 +77,34 @@ builder.query.each do |t|
 end
 ```
 
+The same builder's statement may occur multiple times.
+
+```ruby
+builder = conn.build('(/*select*/ from books) union (/*select*/ from movies)').select('title').query
+
+# => (SELECT title from books) union (SELECT title from movies)
+```
+
 The builder predefined next _SQL Literals_
 
-| Method | SQL Literal |
-| ------ | ----------- |
-|`select`    |`/*select*/`|
-|`where`     |`/*where*/`|
-|`where2`    |`/*where2*/`|
-|`join`      |`/*join*/`|
-|`left_join` |`/*left_join*/`|
-|`group_by`  |`/*group_by*/`|
-|`order_by`  |`/*order_by*/`|
-|`limit`     |`/*limit*/`|
-|`offset`    |`/*offset*/`|
-|`set`       |`/*set*/`|
+| Method      | SQL Literal  |
+|-------------|--------------|
+| `select`    | `/*select*/` |
+| `count`     | `/*select*/` |
+| `where`     | `/*where*/`  |
+| `where_or`  | `/*where*/`  |
+| `where2`    | `/*where2*/` |
+| `where2_or` | `/*where2*/` |
+| `join`      | `/*join*/`   |
+| `left_join` | `/*left_join*/` |
+| `group_by`  | `/*group_by*/` |
+| `order_by`  | `/*order_by*/` |
+| `limit`     | `/*limit*/`  |
+| `offset`    | `/*offset*/` |
+| `set`       | `/*set*/`    |
 
 ### Custom SQL Literals
-Use `sql_literal` for injecting custom sql into Builder
+Use `sql_literal` to inject SQL into Builder from `String`, `Builder`, `ActiveRecord::Relation`, or any object that implements `to_sql` method.
 
 ```ruby
 user_builder = conn
@@ -101,9 +112,9 @@ user_builder = conn
   .where('type = ?', input_type)
   .group_by("date_trunc('day', created_at)")
 
-guest_builder = conn
-  .build("select date_trunc('day', created_at) day, count(*) from guest_topics /*where*/")
-  .where('state = ?', input_state)
+guest_relation = GuestTopic
+  .select("date_trunc('day', created_at) day, count(*)")
+  .where(state: input_state)
   .group_by("date_trunc('day', created_at)")
 
 conn
@@ -113,8 +124,8 @@ conn
      from u
      /*custom_join*/
   SQL
-  .sql_literal(user: user_builder, guest: guest_builder) # builder
-  .sql_literal(custom_join: "#{input_cond ? 'FULL' : 'LEFT'} JOIN g on g.day = u.day") # or string
+  .sql_literal(user: user_builder, guest: guest_relation) # Builder and ActiveRecord::Relation
+  .sql_literal(custom_join: "#{input_cond ? 'FULL' : 'LEFT'} JOIN g on g.day = u.day") # or String
   .query
 ```
 

data/lib/mini_sql/builder.rb

@@ -11,8 +11,13 @@ class MiniSql::Builder
     @is_prepared = false
   end
 
+  def initialize_copy(_original_builder)
+    @args = @args.transform_values { |v| v.dup }
+    @sections = @sections.transform_values { |v| v.dup }
+  end
+
   literals1 =
-    [:set, :where2, :where, :order_by, :left_join, :join, :select, :group_by].each do |k|
+    [:set, :where2, :where2_or, :where, :where_or, :order_by, :left_join, :join, :select, :group_by].each do |k|
       define_method k do |sql_part, *args|
         if Hash === args[0]
           @args.merge!(args[0])
@@ -48,7 +53,7 @@ class MiniSql::Builder
       if PREDEFINED_SQL_LITERALS.include?(name)
         raise "/*#{name}*/ is predefined, use method `.#{name}` instead `sql_literal`"
       end
-      @sections[name] = part_sql.is_a?(::MiniSql::Builder) ? part_sql.to_sql : part_sql
+      @sections[name] = part_sql.respond_to?(:to_sql) ? part_sql.to_sql : part_sql
     end
     self
   end
@@ -75,6 +80,10 @@ class MiniSql::Builder
     @connection.param_encoder.encode(parametrized_sql, union_parameters(hash_args))
   end
 
+  def count(field = '*')
+    dup.select("count(#{field})").query_single.first
+  end
+
   private def connection_switcher
     if @is_prepared
       @connection.prepared
@@ -83,35 +92,43 @@ class MiniSql::Builder
     end
   end
 
+  WHERE_SECTIONS = [%i[where where_or], %i[where2 where2_or]]
   private def parametrized_sql
     sql = @sql.dup
 
-    @sections.each do |k, v|
-      joined = nil
-      case k
-      when :select
-        joined = (+"SELECT ") << v.join(" , ")
-      when :where, :where2
-        joined = (+"WHERE ") << v.map { |c| (+"(") << c << ")" }.join(" AND ")
-      when :join
-        joined = v.map { |item| (+"JOIN ") << item }.join("\n")
-      when :left_join
-        joined = v.map { |item| (+"LEFT JOIN ") << item }.join("\n")
-      when :limit
-        joined = (+"LIMIT :mq_auto_limit")
-      when :offset
-        joined = (+"OFFSET :mq_auto_offset")
-      when :order_by
-        joined = (+"ORDER BY ") << v.join(" , ")
-      when :group_by
-        joined = (+"GROUP BY ") << v.join(" , ")
-      when :set
-        joined = (+"SET ") << v.join(" , ")
-      else # for sql_literal
-        joined = v
+    WHERE_SECTIONS.each do |section_and, section_or|
+      if (or_values = @sections.delete(section_or))
+        @sections[section_and] ||= []
+        @sections[section_and] << or_values.map { |c| "(#{c})" }.join(" OR ")
       end
+    end
+
+    @sections.each do |k, v|
+      joined =
+        case k
+        when :select
+          "SELECT #{v.join(" , ")}"
+        when :where, :where2
+          "WHERE #{v.map { |c| "(#{c})" }.join(" AND ")}"
+        when :join
+          v.map { |item| "JOIN #{item}" }.join("\n")
+        when :left_join
+          v.map { |item| "LEFT JOIN #{item}" }.join("\n")
+        when :limit
+          "LIMIT :mq_auto_limit"
+        when :offset
+          "OFFSET :mq_auto_offset"
+        when :order_by
+          "ORDER BY #{v.join(" , ")}"
+        when :group_by
+          "GROUP BY #{v.join(" , ")}"
+        when :set
+          "SET #{v.join(" , ")}"
+        else # for sql_literal
+          v
+        end
 
-      unless sql.sub!("/*#{k}*/", joined)
+      unless sql.gsub!("/*#{k}*/", joined)
         raise "The section for the /*#{k}*/ clause was not found!"
       end
     end

data/lib/mini_sql/connection.rb

@@ -57,6 +57,14 @@ module MiniSql
       Builder.new(self, sql)
     end
 
+    def to_sql(sql, *params)
+      if params.empty?
+        sql
+      else
+        param_encoder.encode(sql, *params)
+      end
+    end
+
     def escape_string(str)
       raise NotImplementedError, "must be implemented by child connection"
     end

data/lib/mini_sql/mysql/connection.rb

@@ -51,18 +51,11 @@ module MiniSql
         raw_connection.escape(str)
       end
 
-      def build(sql)
-        Builder.new(self, sql)
-      end
-
       private
 
       def run(sql, as, params)
-        if params && params.length > 0
-          sql = param_encoder.encode(sql, *params)
-        end
         raw_connection.query(
-          sql,
+          to_sql(sql, *params),
           as: as,
           database_timezone: :utc,
           application_timezone: :utc,

data/lib/mini_sql/postgres/connection.rb

@@ -192,10 +192,6 @@ module MiniSql
         result.clear if result
       end
 
-      def build(sql)
-        Builder.new(self, sql)
-      end
-
       def escape_string(str)
         raw_connection.escape_string(str)
       end
@@ -203,10 +199,7 @@ module MiniSql
       private
 
       def run(sql, params)
-        if params && params.length > 0
-          sql = param_encoder.encode(sql, *params)
-        end
-        raw_connection.async_exec(sql)
+        raw_connection.async_exec(to_sql(sql, *params))
       end
 
     end

data/lib/mini_sql/postgres/prepared_binds.rb

@@ -6,6 +6,33 @@ module MiniSql
   module Postgres
     class PreparedBinds < ::MiniSql::Abstract::PreparedBinds
 
+      def bind_hash(sql, hash)
+        sql = sql.dup
+        binds = []
+        bind_names = []
+        i = 0
+
+        hash.each do |k, v|
+          bind_outputs =
+            array_wrap(v).map { |vv|
+              binds << vv
+              bind_names << [BindName.new(k)]
+              bind_output(i += 1)
+            }.join(', ')
+
+          sql.gsub!(":#{k}") do
+            # ignore ::int and stuff like that
+            # $` is previous to match
+            if $` && $`[-1] != ":"
+              bind_outputs
+            else
+              ":#{k}"
+            end
+          end
+        end
+        [sql, binds, bind_names]
+      end
+
       def bind_output(i)
         "$#{i}"
       end

data/lib/mini_sql/postgres_jdbc/connection.rb

@@ -78,10 +78,6 @@ module MiniSql
         run(sql, params).to_a
       end
 
-      def build(sql)
-        Builder.new(self, sql)
-      end
-
       def escape_string(str)
         raw_connection.escape_string(str)
       end
@@ -89,12 +85,9 @@ module MiniSql
       private
 
       def run(sql, params)
-        if params && params.length > 0
-          sql = param_encoder.encode(sql, *params)
-        end
         conn = raw_connection
         conn.typemap = self.class.typemap
-        conn.execute(sql)
+        conn.execute(to_sql(sql, *params))
       ensure
         # Force unsetting of typemap since we don't want mixed AR usage to continue to use these extra converters.
         conn.typemap = nil

data/lib/mini_sql/sqlite/connection.rb

@@ -21,12 +21,12 @@ module MiniSql
 
       def query_single(sql, *params)
         # a bit lazy can be optimized
-        run(sql, *params).flatten!
+        run(sql, params).flatten!
       end
 
       def query_hash(sql, *params)
         r = []
-        run(sql, *params) do |set|
+        run(sql, params) do |set|
           set.each_hash do |h|
             r << h
           end
@@ -35,14 +35,14 @@ module MiniSql
       end
 
       def query_array(sql, *params)
-        run(sql, *params)
+        run(sql, params)
       end
 
       def exec(sql, *params)
 
         start = raw_connection.total_changes
 
-        r = run(sql, *params)
+        r = run(sql, params)
         # this is not safe for multithreading, also for DELETE from TABLE will return
         # incorrect data
         if r.length > 0
@@ -53,13 +53,13 @@ module MiniSql
       end
 
       def query(sql, *params)
-        run(sql, *params) do |set|
+        run(sql, params) do |set|
           deserializer_cache.materialize(set)
         end
       end
 
       def query_decorator(decorator, sql, *params)
-        run(sql, *params) do |set|
+        run(sql, params) do |set|
           deserializer_cache.materialize(set, decorator)
         end
       end
@@ -70,10 +70,8 @@ module MiniSql
 
       private
 
-      def run(sql, *params)
-        if params && params.length > 0
-          sql = param_encoder.encode(sql, *params)
-        end
+      def run(sql, params)
+        sql = to_sql(sql, *params)
         if block_given?
           stmt = SQLite3::Statement.new(raw_connection, sql)
           result = yield stmt.execute

data/lib/mini_sql/sqlite/prepared_connection.rb

@@ -28,7 +28,7 @@ module MiniSql
       end
 
       private def run(sql, params)
-        prepared_sql, binds, _bind_names = @param_binder.bind(sql, params)
+        prepared_sql, binds, _bind_names = @param_binder.bind(sql, *params)
         statement = @prepared_cache.prepare_statement(prepared_sql)
         statement.bind_params(binds)
         if block_given?

data/lib/mini_sql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module MiniSql
-  VERSION = "1.3.0"
+  VERSION = "1.5.0"
 end

data/mini_sql.gemspec

@@ -47,7 +47,7 @@ Gem::Specification.new do |spec|
   else
     spec.add_development_dependency "pg", "> 1"
     spec.add_development_dependency "mysql2"
-    spec.add_development_dependency "sqlite3", "~> 1.3"
+    spec.add_development_dependency "sqlite3", "~> 1.4.4"
     spec.add_development_dependency "activerecord", "~> 7.0.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_sql
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-02 00:00:00.000000000 Z
+date: 2023-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -170,14 +170,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: 1.4.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: 1.4.4
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement