simple_query 0.4.0 → 0.6.0

data/lib/simple_query/stream/postgres_stream.rb

@@ -3,17 +3,27 @@
 module SimpleQuery
   module Stream
     module PostgresStream
+      PQTRANS_IDLE = 0 # PG::PQTRANS_IDLE
+
       # rubocop:disable Metrics/MethodLength
       def stream_each_postgres(batch_size, &block)
+        validate_postgres_stream_batch_size!(batch_size)
+
         select_sql = cached_sql
 
-        conn = ActiveRecord::Base.connection.raw_connection
+        conn = connection.raw_connection
         cursor_name = "simple_query_cursor_#{object_id}"
 
+        # Cursors need a transaction. Reuse the caller's one instead of committing it.
+        own_transaction = conn.transaction_status == PQTRANS_IDLE
+        cursor_declared = false
+        cursor_close_started = false
+        completed = false
+
         begin
-          conn.exec("BEGIN")
-          declare_sql = "DECLARE #{cursor_name} NO SCROLL CURSOR FOR #{select_sql}"
-          conn.exec(declare_sql)
+          conn.exec("BEGIN") if own_transaction
+          conn.exec("DECLARE #{cursor_name} NO SCROLL CURSOR FOR #{select_sql}")
+          cursor_declared = true
 
           loop do
             res = conn.exec("FETCH #{batch_size} FROM #{cursor_name}")
@@ -25,21 +35,45 @@ module SimpleQuery
             end
           end
 
+          cursor_close_started = true
           conn.exec("CLOSE #{cursor_name}")
-          conn.exec("COMMIT")
-        rescue StandardError => e
-          begin
-            conn.exec("ROLLBACK")
-          rescue StandardError
-            nil
+          conn.exec("COMMIT") if own_transaction
+          completed = true
+        ensure
+          # Also runs when the caller leaves the block early with break/return.
+          unless completed
+            abort_postgres_stream(conn, cursor_name, close_cursor: cursor_declared && !cursor_close_started,
+                                                     rollback: own_transaction)
           end
-          raise e
         end
       end
       # rubocop:enable Metrics/MethodLength
 
       private
 
+      def validate_postgres_stream_batch_size!(batch_size)
+        return if batch_size.is_a?(Integer) && batch_size.positive?
+
+        raise ArgumentError, "stream_each batch_size must be a positive Integer"
+      end
+
+      def abort_postgres_stream(conn, cursor_name, close_cursor:, rollback:)
+        close_postgres_stream_cursor(conn, cursor_name) if close_cursor
+        rollback_postgres_stream_transaction(conn) if rollback
+      end
+
+      def close_postgres_stream_cursor(conn, cursor_name)
+        conn.exec("CLOSE #{cursor_name}")
+      rescue StandardError
+        nil
+      end
+
+      def rollback_postgres_stream_transaction(conn)
+        conn.exec("ROLLBACK")
+      rescue StandardError
+        nil
+      end
+
       def build_row_object(pg_row)
         if @read_model_class
           obj = @read_model_class.allocate

data/lib/simple_query/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleQuery
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

data/lib/simple_query.rb

@@ -14,10 +14,13 @@ require_relative "simple_query/clauses/distinct_clause"
 require_relative "simple_query/clauses/limit_offset_clause"
 require_relative "simple_query/clauses/group_having_clause"
 require_relative "simple_query/clauses/set_clause"
+require_relative "simple_query/clauses/aggregation_clause"
 
 module SimpleQuery
   extend ActiveSupport::Concern
 
+  class UnsupportedAdapterError < StandardError; end
+
   class Configuration
     attr_accessor :auto_include_ar
 
@@ -45,12 +48,16 @@ module SimpleQuery
     end
 
     def simple_scope(name, body = nil, &block)
-      raise ArgumentError, "Pass either a proc/lambda or a block, not both" if body && block_given?
+      raise ArgumentError, "Pass either a proc/lambda or a block, not both" if !body.nil? && block_given?
+
+      scope_body = body.nil? ? block : body
+      raise ArgumentError, "You must provide a block or a proc" if scope_body.nil?
+      raise ArgumentError, "simple_scope body must respond to #to_proc" unless scope_body.respond_to?(:to_proc)
 
-      scope_body = body || block
-      raise ArgumentError, "You must provide a block or a proc" unless scope_body
+      scope_proc = scope_body.to_proc
+      raise ArgumentError, "simple_scope body #to_proc must return a Proc" unless scope_proc.is_a?(Proc)
 
-      _simple_scopes[name.to_sym] = scope_body
+      _simple_scopes[name.to_sym] = scope_proc
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_query
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Alex Kholodniak
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-15 00:00:00.000000000 Z
+date: 2026-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -17,9 +17,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.0'
-    - - "<="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '8.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,9 +27,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.0'
-    - - "<="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '8.2'
 description: SimpleQuery provides a flexible and performant way to construct complex
   database queries in Ruby on Rails applications. It offers an intuitive interface
   for building queries with joins, conditions, and aggregations, while potentially
@@ -44,6 +44,7 @@ files:
 - README.md
 - lib/simple_query.rb
 - lib/simple_query/builder.rb
+- lib/simple_query/clauses/aggregation_clause.rb
 - lib/simple_query/clauses/distinct_clause.rb
 - lib/simple_query/clauses/group_having_clause.rb
 - lib/simple_query/clauses/join_clause.rb