simple_query 0.3.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6aeb71d493d14743e43b8c9a37eed697f131db105ffc4dc0fa35dd0dd189255b
-  data.tar.gz: 82b1815e569f24a4c4da9e4cd727d95ad6c938403bd2b781eccfc39398cb264b
+  metadata.gz: 856dc1549df83e6c82a7105b3dfa97b9c6f4e69b86f6c2f9ad653ae1f322d1e8
+  data.tar.gz: c10490e13ffbc3da9c629081cde483188efbc0ec3fbdcf27070d565947cc723a
 SHA512:
-  metadata.gz: d422a6a3484d4242b6666bb6536f4828b666c0f16dd6a0c42104b12e3f077bd30e580dc9cf5eb4292ecbb1cd0eda218aabe29af6e221a86c3291fc116b62b856
-  data.tar.gz: cf6e7c8a7e198d1b5376053237d7bdfac59819e07571adb5656e859de9a3bb840dace69e2e600703b14a5ff01bfedbf448d1aadb471a3875874c7d390599878a
+  metadata.gz: 627f5f7fe8a02a9bdf949f8b4d681fc811a6081b0dc2666f60baacff55d6136a3e28512d8c44a1d5cca1699a6529716b36daa4aca455a1ed070efdca935b078a
+  data.tar.gz: 056dbe8add051110bc32cb79264128e87804d4839b0e1f74172353d6f205a59080a54ed463f04ae82efb239237f4d3d0e4ad8f03bc96bdbc607f1c1a0ec68ff9

data/README.md

@@ -104,6 +104,94 @@ User.simple_query
     .execute
 ```
 
+## Enhanced Aggregation Support
+
+SimpleQuery provides a comprehensive set of aggregation methods that are more convenient and readable than writing raw SQL:
+
+### Basic Aggregations
+
+```ruby
+# Count records
+User.simple_query.count.execute
+# => #<struct count=1000>
+
+# Count specific column (non-null values)
+User.simple_query.count(:email).execute
+# => #<struct count_email=995>
+
+# Sum values
+Company.simple_query.sum(:annual_revenue).execute
+# => #<struct sum_annual_revenue=50000000>
+
+# Average values
+Company.simple_query.avg(:annual_revenue).execute
+# => #<struct avg_annual_revenue=1000000.5>
+
+# Find minimum and maximum
+Company.simple_query.min(:annual_revenue).max(:annual_revenue).execute
+# => #<struct min_annual_revenue=100000, max_annual_revenue=5000000>
+```
+
+### Statistical Functions
+
+```ruby
+# Variance and standard deviation
+User.simple_query.variance(:score).stddev(:score).execute
+# => #<struct variance_score=125.67, stddev_score=11.21>
+
+# Database-specific group concatenation
+User.simple_query
+    .select(:department)
+    .group_concat(:name, separator: ", ")
+    .group(:department)
+    .execute
+# => #<struct department="Engineering", group_concat_name="Alice, Bob, Charlie">
+```
+
+### Advanced Aggregation Features
+
+```ruby
+# Get comprehensive statistics for a column
+Company.simple_query.stats(:annual_revenue).execute
+# => #<struct 
+#      annual_revenue_count=100,
+#      annual_revenue_sum=50000000,
+#      annual_revenue_avg=500000,
+#      annual_revenue_min=100000,
+#      annual_revenue_max=2000000
+#    >
+
+# Custom aggregations
+Company.simple_query
+        .custom_aggregation("COUNT(DISTINCT industry)", "unique_industries")
+        .execute
+# => #<struct unique_industries=5>
+
+# Combining with other features
+Company.simple_query
+        .select(:industry)
+        .count
+        .sum(:annual_revenue)
+        .group(:industry)
+        .execute
+# => [
+#      #<struct industry="Technology", count=50, sum_annual_revenue=25000000>,
+#      #<struct industry="Finance", count=30, sum_annual_revenue=20000000>
+#    ]
+```
+
+### Custom Aliases
+
+All aggregation methods support custom aliases:
+
+```ruby
+User.simple_query
+    .count(:id, alias_name: "total_users")
+    .sum(:score, alias_name: "total_score")
+    .execute
+# => #<struct total_users=1000, total_score=85000>
+```
+
 ## Custom Read Models
 By default, SimpleQuery returns results as `Struct` objects for maximum speed. However, you can also define a lightweight model class for more explicit attribute handling or custom logic.
 
@@ -176,32 +264,70 @@ Each scope block (e.g. by_name) is evaluated in the context of the SimpleQuery b
 Parameterized scopes accept arguments — passed directly to the block (e.g. |name| above).
 Scopes return self, so you can chain multiple scopes or mix them with standard query methods.
 
-## Features
+## Streaming Large Datasets
+
+For massive queries (millions of rows), **SimpleQuery** offers a `.stream_each` method to avoid loading the entire result set into memory. It **automatically** picks a streaming approach depending on your database adapter:
 
-- Efficient query building
-- Support for complex joins
-- Lazy execution
-- DISTINCT queries
-- Aggregations
-- LIMIT and OFFSET
-- ORDER BY clause
-- Having and Grouping
-- Subqueries
-- Custom Read models
-- Named Scopes
+- **PostgreSQL**: Uses a **server-side cursor** via `DECLARE ... FETCH`.
+- **MySQL**: Uses `mysql2` gem’s **streaming** (`stream: true, cache_rows: false, as: :hash`).
+
+```ruby
+# Example usage:
+User.simple_query
+    .where(active: true)
+    .stream_each(batch_size: 10_000) do |row|
+  # row is a struct or read-model instance
+  puts row.name
+end
+```
 
 ## Performance
 
-SimpleQuery is designed to potentially outperform standard ActiveRecord queries on large datasets. In our benchmarks with 100,000 records, SimpleQuery showed improved performance compared to equivalent ActiveRecord queries.
+SimpleQuery aims to outperform standard ActiveRecord queries at scale. We’ve benchmarked **1,000,000** records on **both PostgreSQL** and **MySQL**, with the following results:
+
+### PostgreSQL (1,000,000 records)
+```
+🚀 Performance Results (1000,000 records):
+ActiveRecord Query:                  10.36932 seconds
+SimpleQuery Execution (Struct):      3.46136 seconds
+SimpleQuery Execution (Read model):  2.20905 seconds
+
+----------------------------------------------------
+ActiveRecord find_each:              6.10077 seconds
+SimpleQuery stream_each:             2.75639 seconds
+
+--- AR find_each Memory Report ---
+Total allocated: 1.98 GB (16,001,659 objects)
+Retained:        ~2 KB
+
+--- SimpleQuery stream_each Memory Report ---
+Total allocated: 1.38 GB (8,000,211 objects)
+Retained:        ~3 KB
+```
+- **Struct-based** approach remains the fastest, skipping model overhead.
+- **Read model** approach is still significantly faster than standard ActiveRecord while allowing domain-specific logic.
 
+### MySQL (1,000,000 records)
 ```
-🚀 Performance Results (100,000 records):
-ActiveRecord Query:                  0.47441 seconds
-SimpleQuery Execution (Struct):      0.05346 seconds
-SimpleQuery Execution (Read model):  0.14408 seconds
+🚀 Performance Results (1000,000 records):
+ActiveRecord Query:                  10.45833 seconds
+SimpleQuery Execution (Struct):      3.04655 seconds
+SimpleQuery Execution (Read model):  3.69052 seconds
+
+----------------------------------------------------
+ActiveRecord find_each:              5.04671 seconds
+SimpleQuery stream_each:             2.96602 seconds
+
+--- AR find_each Memory Report ---
+Total allocated: 1.32 GB (11,001,445 objects)
+Retained:        ~2.7 KB
+
+--- SimpleQuery stream_each Memory Report ---
+Total allocated: 1.22 GB (8,000,068 objects)
+Retained:        ~3.9 KB
 ```
-- The **Struct-based** approach is the fastest. 
-- The **Read model** approach is still significantly faster than ActiveRecord, while letting you define custom logic or domain-specific attributes.
+- Even in MySQL, **Struct** was roughly **three times faster** than ActiveRecord’s overhead.
+- Read models still outperform AR, though by a narrower margin in this scenario.
 
 ## Development
 

data/lib/simple_query/builder.rb

@@ -2,6 +2,9 @@
 
 module SimpleQuery
   class Builder
+    include SimpleQuery::Stream::PostgresStream
+    include SimpleQuery::Stream::MysqlStream
+
     attr_reader :model, :arel_table
 
     def initialize(source)
@@ -15,6 +18,7 @@ module SimpleQuery
       @orders = OrderClause.new(@arel_table)
       @limits = LimitOffsetClause.new
       @distinct_flag = DistinctClause.new
+      @aggregations = AggregationClause.new(@arel_table)
 
       @query_cache = {}
       @query_built = false
@@ -88,12 +92,128 @@ module SimpleQuery
       self
     end
 
+    # Aggregation methods
+    def count(column = nil, alias_name: nil)
+      @aggregations.count(column, alias_name: alias_name)
+      reset_query
+      self
+    end
+
+    def sum(column, alias_name: nil)
+      @aggregations.sum(column, alias_name: alias_name)
+      reset_query
+      self
+    end
+
+    def avg(column, alias_name: nil)
+      @aggregations.avg(column, alias_name: alias_name)
+      reset_query
+      self
+    end
+
+    def min(column, alias_name: nil)
+      @aggregations.min(column, alias_name: alias_name)
+      reset_query
+      self
+    end
+
+    def max(column, alias_name: nil)
+      @aggregations.max(column, alias_name: alias_name)
+      reset_query
+      self
+    end
+
+    def variance(column, alias_name: nil)
+      @aggregations.variance(column, alias_name: alias_name)
+      reset_query
+      self
+    end
+
+    def stddev(column, alias_name: nil)
+      @aggregations.stddev(column, alias_name: alias_name)
+      reset_query
+      self
+    end
+
+    def group_concat(column, separator: ",", alias_name: nil)
+      @aggregations.group_concat(column, separator: separator, alias_name: alias_name)
+      reset_query
+      self
+    end
+
+    def custom_aggregation(expression, alias_name)
+      @aggregations.custom(expression, alias_name)
+      reset_query
+      self
+    end
+
+    # Convenience methods for common aggregation patterns
+    def total_count(alias_name: "total")
+      count(alias_name: alias_name)
+    end
+
+    def stats(column, alias_prefix: nil)
+      prefix = alias_prefix || column.to_s
+      count(alias_name: "#{prefix}_count")
+      sum(column, alias_name: "#{prefix}_sum")
+      avg(column, alias_name: "#{prefix}_avg")
+      min(column, alias_name: "#{prefix}_min")
+      max(column, alias_name: "#{prefix}_max")
+      self
+    end
+
+    # Method to get first/top record by column
+    def first_by(column, alias_name: nil)
+      alias_name ||= "first_#{column}"
+      custom_aggregation("FIRST_VALUE(#{resolve_column_name(column)}) OVER (ORDER BY #{resolve_column_name(column)})",
+                         alias_name)
+    end
+
+    # Method to get last/bottom record by column
+    def last_by(column, alias_name: nil)
+      alias_name ||= "last_#{column}"
+      custom_aggregation("LAST_VALUE(#{resolve_column_name(column)}) OVER (ORDER BY #{resolve_column_name(column)})",
+                         alias_name)
+    end
+
+    # Percentage calculations
+    def percentage_of_total(column, alias_name: nil)
+      alias_name ||= "#{column}_percentage"
+      column_expr = resolve_column_name(column)
+      expression = "ROUND((#{column_expr} * 100.0 / SUM(#{column_expr}) OVER ()), 2)"
+      custom_aggregation(expression, alias_name)
+    end
+
     def map_to(klass)
       @read_model_class = klass
       reset_query
       self
     end
 
+    def bulk_update(set:)
+      table_name = @arel_table.name
+      set_sql = SetClause.new(set).to_sql
+
+      raise ArgumentError, "No columns to update" if set_sql.empty?
+
+      where_sql = build_where_sql
+      sql = "UPDATE #{table_name} SET #{set_sql}"
+      sql += " WHERE #{where_sql}" unless where_sql.nil? || where_sql.empty?
+
+      ActiveRecord::Base.connection.execute(sql)
+    end
+
+    def stream_each(batch_size: 1000, &block)
+      adapter = ActiveRecord::Base.connection.adapter_name.downcase
+      if adapter.include?("postgres")
+        stream_each_postgres(batch_size, &block)
+      elsif adapter.include?("mysql")
+        stream_each_mysql(&block)
+      else
+        raise "stream_each is only implemented for Postgres and MySQL."
+      end
+    end
+
     def execute
       records = ActiveRecord::Base.connection.select_all(cached_sql)
       build_result_objects_from_rows(records)
@@ -118,7 +238,10 @@ module SimpleQuery
 
       @query = Arel::SelectManager.new(Arel::Table.engine)
       @query.from(@arel_table)
-      @query.project(*(@selects.empty? ? [@arel_table[Arel.star]] : @selects))
+
+      # Combine regular selects with aggregations
+      all_selects = build_select_expressions
+      @query.project(*all_selects)
 
       apply_distinct
       apply_where_conditions
@@ -133,6 +256,30 @@ module SimpleQuery
 
     private
 
+    def build_select_expressions
+      expressions = []
+
+      # Add regular selects
+      if @selects.any?
+        expressions.concat(@selects)
+      elsif @aggregations.empty?
+        # Only use * if no aggregations and no explicit selects
+        expressions << @arel_table[Arel.star]
+      end
+
+      # Add aggregation expressions
+      expressions.concat(@aggregations.to_arel_expressions)
+
+      expressions
+    end
+
+    def build_where_sql
+      condition = @wheres.to_arel
+      return "" unless condition
+
+      condition.to_sql
+    end
+
     def reset_query
       @query_built = false
       @query_cache.clear
@@ -148,7 +295,8 @@ module SimpleQuery
         @orders.orders,
         @limits.limit_value,
         @limits.offset_value,
-        @distinct_flag.use_distinct?
+        @distinct_flag.use_distinct?,
+        @aggregations.aggregations
       ]
 
       @query_cache[key] ||= build_query.to_sql
@@ -233,6 +381,17 @@ module SimpleQuery
       end
     end
 
+    def resolve_column_name(column)
+      case column
+      when Symbol
+        "#{@arel_table.name}.#{column}"
+      when String
+        column.include?(".") ? column : "#{@arel_table.name}.#{column}"
+      else
+        column.to_s
+      end
+    end
+
     def method_missing(method_name, *args, &block)
       if (scope_block = find_scope(method_name))
         instance_exec(*args, &scope_block)

data/lib/simple_query/clauses/aggregation_clause.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module SimpleQuery
+  class AggregationClause
+    attr_reader :aggregations
+
+    def initialize(table)
+      @table = table
+      @aggregations = []
+    end
+
+    def count(column = nil, alias_name: nil)
+      column_expr = column ? resolve_column(column) : "*"
+      alias_name ||= column ? "count_#{sanitize_alias(column)}" : "count"
+
+      add_aggregation("COUNT", column_expr, alias_name)
+    end
+
+    def sum(column, alias_name: nil)
+      raise ArgumentError, "Column is required for SUM aggregation" if column.nil?
+
+      column_expr = resolve_column(column)
+      alias_name ||= "sum_#{sanitize_alias(column)}"
+
+      add_aggregation("SUM", column_expr, alias_name)
+    end
+
+    def avg(column, alias_name: nil)
+      raise ArgumentError, "Column is required for AVG aggregation" if column.nil?
+
+      column_expr = resolve_column(column)
+      alias_name ||= "avg_#{sanitize_alias(column)}"
+
+      add_aggregation("AVG", column_expr, alias_name)
+    end
+
+    def min(column, alias_name: nil)
+      raise ArgumentError, "Column is required for MIN aggregation" if column.nil?
+
+      column_expr = resolve_column(column)
+      alias_name ||= "min_#{sanitize_alias(column)}"
+
+      add_aggregation("MIN", column_expr, alias_name)
+    end
+
+    def max(column, alias_name: nil)
+      raise ArgumentError, "Column is required for MAX aggregation" if column.nil?
+
+      column_expr = resolve_column(column)
+      alias_name ||= "max_#{sanitize_alias(column)}"
+
+      add_aggregation("MAX", column_expr, alias_name)
+    end
+
+    def custom(expression, alias_name)
+      if expression.nil? || alias_name.nil?
+        raise ArgumentError,
+              "Expression and alias are required for custom aggregation"
+      end
+
+      @aggregations << {
+        expression: expression,
+        alias: alias_name
+      }
+    end
+
+    # Statistical functions
+    def variance(column, alias_name: nil)
+      raise ArgumentError, "Column is required for VARIANCE aggregation" if column.nil?
+
+      column_expr = resolve_column(column)
+      alias_name ||= "variance_#{sanitize_alias(column)}"
+
+      add_aggregation("VARIANCE", column_expr, alias_name)
+    end
+
+    def stddev(column, alias_name: nil)
+      raise ArgumentError, "Column is required for STDDEV aggregation" if column.nil?
+
+      column_expr = resolve_column(column)
+      alias_name ||= "stddev_#{sanitize_alias(column)}"
+
+      add_aggregation("STDDEV", column_expr, alias_name)
+    end
+
+    # Group concatenation (database-specific)
+    def group_concat(column, separator: ",", alias_name: nil)
+      raise ArgumentError, "Column is required for GROUP_CONCAT aggregation" if column.nil?
+
+      column_expr = resolve_column(column)
+      alias_name ||= "group_concat_#{sanitize_alias(column)}"
+
+      # Use database-specific group concatenation
+      adapter = ActiveRecord::Base.connection.adapter_name.downcase
+
+      expression = case adapter
+                   when /mysql/
+                     "GROUP_CONCAT(#{column_expr} SEPARATOR '#{separator}')"
+                   when /postgres/
+                     "STRING_AGG(#{column_expr}::text, '#{separator}')"
+                   when /sqlite/
+                     "GROUP_CONCAT(#{column_expr}, '#{separator}')"
+                   else
+                     # Fallback for other databases
+                     "GROUP_CONCAT(#{column_expr})"
+                   end
+
+      @aggregations << {
+        expression: expression,
+        alias: alias_name
+      }
+    end
+
+    def to_arel_expressions
+      @aggregations.map do |agg|
+        Arel.sql("#{agg[:expression]} AS #{agg[:alias]}")
+      end
+    end
+
+    def empty?
+      @aggregations.empty?
+    end
+
+    def clear
+      @aggregations.clear
+    end
+
+    private
+
+    def add_aggregation(function, column_expr, alias_name)
+      @aggregations << {
+        expression: "#{function}(#{column_expr})",
+        alias: alias_name
+      }
+    end
+
+    def resolve_column(column)
+      case column
+      when Symbol
+        "#{@table.name}.#{column}"
+      when String
+        # Allow table.column format or just column name
+        column.include?(".") ? column : "#{@table.name}.#{column}"
+      when Arel::Attributes::Attribute
+        column.to_sql
+      else
+        column.to_s
+      end
+    end
+
+    def sanitize_alias(column)
+      column.to_s.gsub(".", "_")
+    end
+  end
+end

data/lib/simple_query/clauses/set_clause.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SimpleQuery
+  class SetClause
+    def initialize(set_hash)
+      @set_hash = set_hash
+    end
+
+    def to_sql
+      @set_hash.map do |col, val|
+        "#{quote_column(col)} = #{quote_value(val)}"
+      end.join(", ")
+    end
+
+    private
+
+    def quote_column(col)
+      ActiveRecord::Base.connection.quote_column_name(col)
+    end
+
+    def quote_value(val)
+      ActiveRecord::Base.connection.quote(val)
+    end
+  end
+end

data/lib/simple_query/stream/mysql_stream.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SimpleQuery
+  module Stream
+    module MysqlStream
+      def stream_each_mysql(&block)
+        select_sql = cached_sql
+
+        raw_conn = ActiveRecord::Base.connection.raw_connection
+
+        result = raw_conn.query(select_sql, stream: true, cache_rows: false, as: :hash)
+        result.each do |mysql_row|
+          record = build_row_object_mysql(mysql_row)
+          block.call(record)
+        end
+      end
+
+      private
+
+      def build_row_object_mysql(mysql_row)
+        if @read_model_class
+          obj = @read_model_class.allocate
+          @read_model_class.attributes.each do |attr_name, col_name|
+            obj.instance_variable_set(:"@#{attr_name}", mysql_row[col_name])
+          end
+          obj
+        else
+          columns = mysql_row.keys
+          values = columns.map { |k| mysql_row[k] }
+          struct = result_struct(columns)
+          struct.new(*values)
+        end
+      end
+    end
+  end
+end

data/lib/simple_query/stream/postgres_stream.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module SimpleQuery
+  module Stream
+    module PostgresStream
+      # rubocop:disable Metrics/MethodLength
+      def stream_each_postgres(batch_size, &block)
+        select_sql = cached_sql
+
+        conn = ActiveRecord::Base.connection.raw_connection
+        cursor_name = "simple_query_cursor_#{object_id}"
+
+        begin
+          conn.exec("BEGIN")
+          declare_sql = "DECLARE #{cursor_name} NO SCROLL CURSOR FOR #{select_sql}"
+          conn.exec(declare_sql)
+
+          loop do
+            res = conn.exec("FETCH #{batch_size} FROM #{cursor_name}")
+            break if res.ntuples.zero?
+
+            res.each do |pg_row|
+              record = build_row_object(pg_row)
+              block.call(record)
+            end
+          end
+
+          conn.exec("CLOSE #{cursor_name}")
+          conn.exec("COMMIT")
+        rescue StandardError => e
+          begin
+            conn.exec("ROLLBACK")
+          rescue StandardError
+            nil
+          end
+          raise e
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def build_row_object(pg_row)
+        if @read_model_class
+          obj = @read_model_class.allocate
+          @read_model_class.attributes.each do |attr_name, col_name|
+            obj.instance_variable_set(:"@#{attr_name}", pg_row[col_name])
+          end
+          obj
+        else
+          columns = pg_row.keys
+          values = columns.map { |k| pg_row[k] }
+          struct = result_struct(columns)
+          struct.new(*values)
+        end
+      end
+    end
+  end
+end

data/lib/simple_query/version.rb

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

data/lib/simple_query.rb

@@ -3,6 +3,8 @@
 require "active_support/concern"
 require "active_record"
 
+require_relative "simple_query/stream/mysql_stream"
+require_relative "simple_query/stream/postgres_stream"
 require_relative "simple_query/builder"
 require_relative "simple_query/read_model"
 require_relative "simple_query/clauses/where_clause"
@@ -11,6 +13,8 @@ require_relative "simple_query/clauses/order_clause"
 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_query
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Alex Kholodniak
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-01 00:00:00.000000000 Z
+date: 2025-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -30,62 +30,6 @@ dependencies:
     - - "<="
       - !ruby/object:Gem::Version
         version: '8.0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.21'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.21'
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.5.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.5.0
 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
@@ -100,13 +44,17 @@ 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
 - lib/simple_query/clauses/limit_offset_clause.rb
 - lib/simple_query/clauses/order_clause.rb
+- lib/simple_query/clauses/set_clause.rb
 - lib/simple_query/clauses/where_clause.rb
 - lib/simple_query/read_model.rb
+- lib/simple_query/stream/mysql_stream.rb
+- lib/simple_query/stream/postgres_stream.rb
 - lib/simple_query/version.rb
 homepage: https://github.com/kholdrex/simple_query
 licenses:
@@ -133,5 +81,6 @@ requirements: []
 rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
-summary: A lightweight and efficient query builder for ActiveRecord.
+summary: A lightweight, multi-DB-friendly, and high-performance query builder for
+  ActiveRecord, featuring streaming, bulk updates, and read-model support.
 test_files: []