querykit 0.1.0

data/lib/querykit/connection.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module QueryKit
+  # Connection class to manage database interactions.
+  #
+  # Provides methods for executing queries, managing transactions,
+  # and optionally mapping results to model objects.
+  #
+  # @example Basic usage
+  #   db = Quby.connect(:sqlite, database: 'app.db')
+  #   query = db.query('users').where('age', '>', 18)
+  #   users = db.get(query)
+  #
+  # @example With model mapping
+  #   users = db.get(query, User)  # Returns array of User objects
+  #
+  # @example Transaction
+  #   db.transaction do
+  #     db.execute_insert(db.insert('users').values(name: 'John'))
+  #     db.execute_update(db.update('posts').set(status: 'published'))
+  #   end
+  class Connection
+    # @return [Adapter] the database adapter instance
+    attr_reader :adapter
+
+    # Initialize a new Connection with the given adapter.
+    #
+    # @param adapter [Adapter] a database adapter instance (SQLite, PostgreSQL, or MySQL)
+    #
+    # @example
+    #   adapter = Quby::Adapters::SQLiteAdapter.new(database: 'app.db')
+    #   connection = Quby::Connection.new(adapter)
+    def initialize(adapter)
+      @adapter = adapter
+    end
+
+    # Create a new query builder for the specified table.
+    #
+    # @param table [String, nil] the table name (can be set later with from())
+    # @return [Query] a new query builder instance
+    #
+    # @example
+    #   query = db.query('users').where('age', '>', 18)
+    def query(table = nil)
+      Query.new(table)
+    end
+
+    # Create a new query builder for the specified table (alias for query).
+    #
+    # @param table [String] the table name
+    # @return [Query] a new query builder instance
+    #
+    # @example
+    #   query = db.from('users').where('status', 'active')
+    def from(table)
+      Query.new(table)
+    end
+
+    # Create a new query builder for the specified table (alias for query).
+    #
+    # @param table [String] the table name
+    # @return [Query] a new query builder instance
+    #
+    # @example
+    #   query = db.table('users').select('*')
+    def table(table)
+      Query.new(table)
+    end
+
+    # Create a new INSERT query builder.
+    #
+    # @param table [String, nil] the table name
+    # @return [InsertQuery] a new insert query builder instance
+    #
+    # @example
+    #   insert = db.insert('users').values(name: 'John', email: 'john@example.com')
+    def insert(table = nil)
+      InsertQuery.new(table)
+    end
+
+    # Create a new UPDATE query builder.
+    #
+    # @param table [String, nil] the table name
+    # @return [UpdateQuery] a new update query builder instance
+    #
+    # @example
+    #   update = db.update('users').set(status: 'inactive').where('last_login', '<', '2020-01-01')
+    def update(table = nil)
+      UpdateQuery.new(table)
+    end
+
+    # Create a new DELETE query builder.
+    #
+    # @param table [String, nil] the table name
+    # @return [DeleteQuery] a new delete query builder instance
+    #
+    # @example
+    #   delete = db.delete('users').where('status', 'deleted')
+    def delete(table = nil)
+      DeleteQuery.new(table)
+    end
+
+    # Execute a SELECT query and return all results.
+    #
+    # @param query [Query] the query to execute
+    # @param model_class [Class, nil] optional model class to map results to
+    #
+    # @return [Array<Hash>, Array<Object>] array of result hashes or model instances
+    #
+    # @example Get raw hashes
+    #   users = db.get(db.query('users').where('age', '>', 18))
+    #
+    # @example Map to model objects
+    #   users = db.get(db.query('users').where('age', '>', 18), User)
+    def get(query, model_class = nil)
+      sql = query.to_sql
+      results = @adapter.execute(sql, query.bindings)
+      return results unless model_class
+      
+      results.map { |row| map_to_model(row, model_class) }
+    end
+
+    # Execute a SELECT query and return the first result.
+    #
+    # @param query [Query] the query to execute
+    # @param model_class [Class, nil] optional model class to map result to
+    #
+    # @return [Hash, Object, nil] result hash, model instance, or nil if no results
+    #
+    # @example
+    #   user = db.first(db.query('users').where('email', 'john@example.com'))
+    def first(query, model_class = nil)
+      query.limit(1)
+      results = @adapter.execute(query.to_sql, query.bindings)
+      return nil if results.empty?
+      
+      row = results.first
+      model_class ? map_to_model(row, model_class) : row
+    end
+
+    # Execute an insert query and return the last insert ID
+    def execute_insert(query)
+      sql = query.to_sql
+      @adapter.execute(sql, query.bindings)
+      @adapter.last_insert_id
+    end
+
+    # Execute an update query and return the number of affected rows
+    def execute_update(query)
+      sql = query.to_sql
+      @adapter.execute(sql, query.bindings)
+      @adapter.affected_rows
+    end
+
+    # Execute a delete query and return the number of affected rows
+    def execute_delete(query)
+      sql = query.to_sql
+      @adapter.execute(sql, query.bindings)
+      @adapter.affected_rows
+    end
+
+    # Execute a query and return a scalar value (first column of first row)
+    # Useful for aggregate queries like COUNT, SUM, AVG, etc.
+    def execute_scalar(query)
+      result = first(query)
+      return nil if result.nil?
+      result.is_a?(Hash) ? result.values.first : result
+    end
+
+    # Raw SQL with optional model mapping
+    def raw(sql, *bindings, model_class: nil)
+      results = @adapter.execute(sql, bindings.flatten)
+      return results unless model_class
+      
+      results.map { |row| map_to_model(row, model_class) }
+    end
+
+    # Transaction support
+    def transaction
+      @adapter.begin_transaction
+      result = yield
+      @adapter.commit
+      result
+    rescue => e
+      @adapter.rollback
+      raise e
+    end
+
+    private
+
+    # Map a hash to a model instance
+    def map_to_model(hash, model_class)
+      # Convert string keys to symbols for better Ruby convention
+      symbolized = hash.transform_keys(&:to_sym)
+      
+      # Try different initialization strategies
+      if model_class.instance_method(:initialize).arity == 0
+        # No-arg constructor - set attributes after creation
+        instance = model_class.new
+        symbolized.each do |key, value|
+          setter = "#{key}="
+          instance.send(setter, value) if instance.respond_to?(setter)
+        end
+        instance
+      else
+        # Constructor accepts hash
+        model_class.new(symbolized)
+      end
+    end
+  end
+end

data/lib/querykit/delete_query.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module QueryKit
+  # DeleteQuery class for building SQL DELETE statements.
+  class DeleteQuery
+    attr_reader :table, :wheres, :bindings
+
+    # Initialize a new DeleteQuery instance.
+    def initialize(table = nil)
+      @table = table
+      @wheres = []
+      @bindings = []
+    end
+
+    # Set the table to delete from.
+    def from(table)
+      @table = table
+      self
+    end
+
+    # Add a WHERE condition to the delete query.
+    def where(column, operator = nil, value = nil)
+      if value.nil? && !operator.nil?
+        value = operator
+        operator = '='
+      end
+
+      @wheres << { type: 'basic', column: column, operator: operator, value: value, boolean: 'AND' }
+      @bindings << value
+      self
+    end
+
+    # Generate the SQL DELETE statement.
+    def to_sql
+      raise "No table specified" unless @table
+
+      sql = []
+      sql << "DELETE FROM #{@table}"
+
+      unless @wheres.empty?
+        sql << "WHERE"
+        where_clauses = @wheres.map { |w| "#{w[:column]} #{w[:operator]} ?" }
+        sql << where_clauses.join(' AND ')
+      end
+
+      sql.join(' ')
+    end
+
+    # Return the SQL DELETE statement as a string.
+    def to_s
+      to_sql
+    end
+  end
+end

data/lib/querykit/extensions/case_when.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../case_builder'
+
+module QueryKit
+  # Extension module that adds CASE WHEN support to Query
+  # Include this in Query to enable select_case functionality
+  module CaseWhenExtension
+    # Start a CASE expression and return the builder
+    # The builder can be passed to select() like any other expression
+    # @param column [String, nil] Optional column for simple CASE
+    # @return [CaseBuilder] Builder for constructing CASE expression
+    def select_case(column = nil)
+      CaseBuilder.new(column)
+    end
+    
+    # Override select to handle CaseBuilder objects
+    def select(*columns)
+      columns.flatten.each do |col|
+        if col.is_a?(CaseBuilder)
+          @selects << col.to_sql
+          @bindings.concat(col.bindings)
+        else
+          @selects << col
+        end
+      end
+      self
+    end
+  end
+end

data/lib/querykit/insert_query.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module QueryKit
+  # InsertQuery class for building INSERT SQL queries
+  class InsertQuery
+    attr_reader :table, :values, :bindings
+
+    # Initialize a new InsertQuery instance.
+    def initialize(table = nil)
+      @table = table
+      @values = []
+      @bindings = []
+    end
+
+    # Set the table to insert into.
+    def into(table)
+      @table = table
+      self
+    end
+
+    # Set the table to insert into.
+    def values(data)
+      if data.is_a?(Hash)
+        @values << data
+      elsif data.is_a?(Array)
+        @values.concat(data)
+      end
+      self
+    end
+
+    # Generate the SQL INSERT statement.
+    def to_sql
+      raise "No table specified" unless @table
+      raise "No values specified" if @values.empty?
+
+      first_row = @values.first
+      columns = first_row.keys
+      @bindings = @values.flat_map { |row| columns.map { |col| row[col] } }
+
+      sql = []
+      sql << "INSERT INTO #{@table}"
+      sql << "(#{columns.join(', ')})"
+      sql << "VALUES"
+
+      value_sets = @values.map do |row|
+        placeholders = (['?'] * columns.size).join(', ')
+        "(#{placeholders})"
+      end
+
+      sql << value_sets.join(', ')
+      sql.join(' ')
+    end
+
+    def to_s
+      to_sql
+    end
+  end
+end