simple_query 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b6095e96524f3fda796bd8965a24595814091f2e84e74c3ca1789ca644269a22
+  data.tar.gz: b665f9077a68854e225c14188ce83948390d665ef7a6d30c4a04a3f2349d5150
+SHA512:
+  metadata.gz: ff9b7c518565311e9a1bbd23b03a5d6ce988ac9ed3bac2ef8f1e16088d846629190818d36163c2a9cfd95b943c734c1b6a3b3ab843413b6acfaf504528388d32
+  data.tar.gz: ce323624e8df7f73cedfea917acedc8cc07c295a10e86b9ecb896c34fa3ca151becfff1357d80d68b388cbe3998522ffe21cb2557d9cdab590d68a8bf435e43d

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Alex Kholodniak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,96 @@
+# SimpleQuery
+
+SimpleQuery is a lightweight and efficient query builder for ActiveRecord, designed to provide a flexible and performant way to construct complex database queries in Ruby on Rails applications.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'simple_query'
+```
+
+And then execute:
+```bash
+bundle install
+```
+
+Or install it yourself as:
+```bash
+gem install simple_query
+```
+
+## Usage
+
+SimpleQuery offers an intuitive interface for building queries with joins, conditions, and aggregations. Here are some examples:
+
+Basic query
+```ruby
+User.simple_query.select(:name, :email).where(active: true).execute
+```
+
+Query with join
+```ruby
+User.simple_query
+    .select(:name, :email)
+    .join(:users, :companies, foreign_key: :user_id, primary_key: :id)
+    .where(Company.arel_table[:name].eq("TechCorp"))
+    .execute
+```
+
+Complex query with multiple joins and conditions
+```ruby
+User.simple_query
+    .select(:name)
+    .join(:users, :companies, foreign_key: :user_id, primary_key: :id)
+    .join(:companies, :projects, foreign_key: :company_id, primary_key: :id)
+    .where(Company.arel_table[:industry].eq("Technology"))
+    .where(Project.arel_table[:status].eq("active"))
+    .where(User.arel_table[:admin].eq(true))
+    .execute
+```
+
+Lazy execution
+```ruby
+User.simple_query
+    .select(:name)
+    .where(active: true)
+    .lazy_execute
+```
+
+## Features
+
+- Efficient query building
+- Support for complex joins
+- Lazy execution
+- DISTINCT queries
+- Aggregations
+- LIMIT and OFFSET
+- ORDER BY clause
+- Subqueries
+
+## 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.
+
+```
+🚀 Performance Results (100,000 records):
+ActiveRecord Query:        0.43343 seconds
+SimpleQuery Execution:      0.06186 seconds
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kholdrex/simple_query. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/kholdrex/simple_query/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the SimpleQuery project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/kholdrex/simple_query/blob/master/CODE_OF_CONDUCT.md).

data/lib/simple_query/builder.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module SimpleQuery
+  class Builder
+    attr_reader :model, :arel_table, :selects, :wheres, :joins, :orders, :limits, :offsets
+
+    def initialize(source)
+      @model = source
+      @arel_table = @model.arel_table
+      @selects = []
+      @wheres = []
+      @joins = []
+      @orders = []
+      @limits = nil
+      @offsets = nil
+      @distinct_flag = false
+      @query_cache = {}
+      @result_struct = nil
+      @query_built = false
+    end
+
+    def select(*fields)
+      @selects.concat(fields.map { |field| parse_select_field(field) })
+      reset_query
+      self
+    end
+
+    def where(condition)
+      @wheres.concat(parse_where_condition(condition))
+      reset_query
+      self
+    end
+
+    def join(table1, table2, foreign_key:, primary_key:)
+      @joins << {
+        table1: arel_table(table1),
+        table2: arel_table(table2),
+        foreign_key: foreign_key,
+        primary_key: primary_key
+      }
+      reset_query
+      self
+    end
+
+    def order(order_conditions)
+      @orders.concat(parse_order_conditions(order_conditions))
+      reset_query
+      self
+    end
+
+    def limit(number)
+      validate_positive_integer(number, "LIMIT")
+      @limits = number
+      reset_query
+      self
+    end
+
+    def offset(number)
+      validate_non_negative_integer(number, "OFFSET")
+      @offsets = number
+      reset_query
+      self
+    end
+
+    def distinct
+      @distinct_flag = true
+      reset_query
+      self
+    end
+
+    def execute
+      records = ActiveRecord::Base.connection.select_all(cached_sql)
+      build_result_objects(records)
+    end
+
+    def lazy_execute
+      Enumerator.new do |yielder|
+        records = ActiveRecord::Base.connection.select_all(cached_sql)
+        struct = result_struct(records.columns)
+        records.rows.each { |row| yielder << struct.new(*row) }
+      end
+    end
+
+    def build_query
+      return @query if @query_built
+
+      @query = Arel::SelectManager.new(Arel::Table.engine)
+      @query.from(@arel_table)
+      @query.project(*(@selects.empty? ? [@arel_table[Arel.star]] : @selects))
+      @query.distinct if @distinct_flag
+
+      apply_where_conditions
+      apply_joins
+      apply_order_conditions
+      apply_limit_and_offset
+
+      @query_built = true
+      @query
+    end
+
+    private
+
+    def reset_query
+      @query_built = false
+      @query_cache.clear
+    end
+
+    def cached_sql
+      @query_cache[@wheres] ||= build_query.to_sql
+    end
+
+    def result_struct(columns)
+      @result_struct ||= Struct.new(*columns.map(&:to_sym))
+    end
+
+    def parse_select_field(field)
+      case field
+      when Symbol then @arel_table[field]
+      when String then Arel.sql(field)
+      when Arel::Nodes::Node then field
+      else
+        raise ArgumentError, "Unsupported select field type: #{field.class}"
+      end
+    end
+
+    def parse_where_condition(condition)
+      case condition
+      when Hash then condition.map { |field, value| @arel_table[field].eq(value) }
+      when Arel::Nodes::Node then [condition]
+      else [Arel.sql(condition.to_s)]
+      end
+    end
+
+    def arel_table(table)
+      table.is_a?(Arel::Table) ? table : Arel::Table.new(table)
+    end
+
+    def parse_order_conditions(order_conditions)
+      order_conditions.map do |field, direction|
+        validate_order_direction(direction)
+        @arel_table[field].send(direction)
+      end
+    end
+
+    def validate_order_direction(direction)
+      return if [:asc, :desc].include?(direction)
+
+      raise ArgumentError, "Invalid order direction: #{direction}. Use :asc or :desc."
+    end
+
+    def validate_positive_integer(number, label)
+      raise ArgumentError, "#{label} must be a positive integer" unless number.is_a?(Integer) && number.positive?
+    end
+
+    def validate_non_negative_integer(number, label)
+      raise ArgumentError, "#{label} must be a non-negative integer" unless number.is_a?(Integer) && number >= 0
+    end
+
+    def build_result_objects(records)
+      struct = result_struct(records.columns)
+      records.rows.map { |row| struct.new(*row) }
+    end
+
+    def apply_where_conditions
+      @query.where(@wheres.inject(&:and)) if @wheres.any?
+    end
+
+    def apply_joins
+      @joins.each do |join|
+        @query.join(join[:table2]).on(join[:table2][join[:foreign_key]].eq(join[:table1][join[:primary_key]]))
+      end
+    end
+
+    def apply_order_conditions
+      @orders.each { |order| @query.order(order) }
+    end
+
+    def apply_limit_and_offset
+      @query.take(@limits) if @limits
+      @query.skip(@offsets) if @offsets
+    end
+  end
+end

data/lib/simple_query/version.rb

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

data/lib/simple_query.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "simple_query/builder"
+
+module SimpleQuery
+  extend ActiveSupport::Concern
+
+  included do
+    def self.simple_query
+      SimpleQuery::Builder.new(self)
+    end
+  end
+end
+
+ActiveRecord::Base.include SimpleQuery

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: simple_query
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alex Kholodniak
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-02-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !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
+  outperforming standard ActiveRecord queries on large datasets.
+email:
+- alexandrkholodniak@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/simple_query.rb
+- lib/simple_query/builder.rb
+- lib/simple_query/version.rb
+homepage: https://oneruby.dev
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://oneruby.dev
+  source_code_uri: https://github.com/kholdrex/simple_query
+  changelog_uri: https://github.com/kholdrex/simple_query/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
+summary: A lightweight and efficient query builder for ActiveRecord.
+test_files: []