ruflet_record 0.0.1

data/lib/ruflet_record/relation.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+module RufletRecord
+  class WhereChain
+    def initialize(relation)
+      @relation = relation
+    end
+
+    def not(conditions, *binds)
+      fragment = SQL.predicate(@relation.table_name, conditions, binds)
+      @relation.add_where(SQL.negate(fragment))
+    end
+  end
+
+  class Relation
+    include Enumerable
+
+    attr_reader :model, :table_name
+
+    def initialize(model, values = nil)
+      @model = model
+      @table_name = model.table_name
+      @values = values || {
+        where: [], order: [], select: [], joins: [], limit: nil,
+        offset: nil, distinct: false
+      }
+      @loaded = false
+      @records = nil
+    end
+
+    def where(conditions = nil, *binds)
+      return WhereChain.new(self) if conditions.nil?
+      add_where(SQL.predicate(@table_name, conditions, binds))
+    end
+
+    def add_where(fragment)
+      spawn_with(:where, @values[:where] + [fragment])
+    end
+
+    def order(*values)
+      additions = values.flatten
+      SQL.order(@table_name, additions)
+      spawn_with(:order, @values[:order] + additions)
+    end
+
+    def reorder(*values)
+      replacements = values.flatten
+      SQL.order(@table_name, replacements)
+      spawn_with(:order, replacements)
+    end
+
+    def limit(value)
+      number = value.nil? ? nil : value.to_i
+      raise ArgumentError, "limit must not be negative" if number && number < 0
+      spawn_with(:limit, number)
+    end
+
+    def offset(value)
+      number = value.nil? ? nil : value.to_i
+      raise ArgumentError, "offset must not be negative" if number && number < 0
+      spawn_with(:offset, number)
+    end
+
+    def select(*columns)
+      spawn_with(:select, columns.flatten)
+    end
+
+    def distinct(value = true)
+      spawn_with(:distinct, !!value)
+    end
+
+    def joins(sql)
+      value = sql.is_a?(SQL::Literal) ? sql.sql : sql.to_s
+      raise ArgumentError, "joins requires an explicit JOIN expression" unless value =~ /\A\s*(INNER|LEFT|RIGHT|CROSS)?\s*JOIN\s+/i
+      spawn_with(:joins, @values[:joins] + [value])
+    end
+
+    def merge(other)
+      raise ArgumentError, "relations must have the same model" unless other.model == @model
+      merged = duplicate_values
+      other_values = other.send(:values)
+      merged[:where] += other_values[:where]
+      merged[:order] += other_values[:order]
+      merged[:joins] += other_values[:joins]
+      merged[:select] = other_values[:select] unless other_values[:select].empty?
+      merged[:limit] = other_values[:limit] unless other_values[:limit].nil?
+      merged[:offset] = other_values[:offset] unless other_values[:offset].nil?
+      merged[:distinct] ||= other_values[:distinct]
+      self.class.new(@model, merged)
+    end
+
+    def each(&block)
+      return to_enum(:each) unless block
+      to_a.each(&block)
+    end
+
+    def to_a
+      load unless @loaded
+      @records.dup
+    end
+
+    def load
+      sql, binds = to_sql_and_binds
+      @records = @model.connection.select_all(sql, binds).map { |row| @model.instantiate(row) }
+      @loaded = true
+      self
+    end
+
+    def loaded?
+      @loaded
+    end
+
+    def reload
+      @loaded = false
+      @records = nil
+      load
+    end
+
+    def first(count = nil)
+      return limit(count).to_a if count
+      limit(1).to_a.first
+    end
+
+    def last(count = nil)
+      primary = @model.primary_key
+      relation = reorder(primary => :desc)
+      records = count ? relation.limit(count).to_a.reverse : relation.limit(1).to_a.first
+      records
+    end
+
+    def find(id)
+      record = where(@model.primary_key => id).first
+      raise RecordNotFound, "Couldn't find #{@model.name} with '#{@model.primary_key}'=#{id}" unless record
+      record
+    end
+
+    def find_by(conditions)
+      where(conditions).first
+    end
+
+    def find_by!(conditions)
+      record = find_by(conditions)
+      raise RecordNotFound, "Couldn't find #{@model.name}" unless record
+      record
+    end
+
+    def count(column = nil)
+      aggregate("COUNT", column || SQL::Literal.new("*"), integer: true)
+    end
+
+    def sum(column)
+      aggregate("SUM", column) || 0
+    end
+
+    def average(column)
+      aggregate("AVG", column)
+    end
+
+    def minimum(column)
+      aggregate("MIN", column)
+    end
+
+    def maximum(column)
+      aggregate("MAX", column)
+    end
+
+    def exists?(conditions = nil)
+      relation = conditions.nil? ? self : where(conditions)
+      !relation.select(SQL::Literal.new("1")).limit(1).send(:pluck_value).nil?
+    end
+
+    def pluck(*columns)
+      names = columns.flatten
+      rows = select(*names).send(:raw_rows)
+      return rows.map { |row| row[names.first.to_s] } if names.length == 1
+      rows.map { |row| names.map { |name| row[name.to_s] } }
+    end
+
+    def pick(*columns)
+      values = limit(1).pluck(*columns)
+      values.first
+    end
+
+    def ids
+      pluck(@model.primary_key)
+    end
+
+    def create(attributes = {})
+      record = @model.new(scope_for_create.merge(attributes))
+      record.save
+      record
+    end
+
+    def create!(attributes = {})
+      record = @model.new(scope_for_create.merge(attributes))
+      record.save!
+      record
+    end
+
+    def update_all(attributes)
+      raise ArgumentError, "attributes must not be empty" if attributes.empty?
+      sql, binds = SQL.update(@table_name, stringify_keys(attributes), @values[:where])
+      @model.connection.update(sql, binds)
+    end
+
+    def delete_all
+      sql, binds = SQL.delete(@table_name, @values[:where])
+      @model.connection.delete(sql, binds)
+    end
+
+    def destroy_all
+      to_a.each(&:destroy)
+    end
+
+    def find_each(batch_size: 1000)
+      return to_enum(:find_each, batch_size: batch_size) unless block_given?
+      cursor = nil
+      loop do
+        relation = reorder(@model.primary_key => :asc).limit(batch_size)
+        relation = relation.where("#{SQL.column(@table_name, @model.primary_key)} > ?", cursor) if cursor
+        batch = relation.to_a
+        break if batch.empty?
+        batch.each { |record| yield record }
+        cursor = batch.last.public_send(@model.primary_key)
+      end
+    end
+
+    def to_sql
+      to_sql_and_binds.first
+    end
+
+    def bound_attributes
+      to_sql_and_binds.last
+    end
+
+    protected
+
+    attr_reader :values
+
+    def raw_rows
+      sql, binds = to_sql_and_binds
+      @model.connection.select_all(sql, binds)
+    end
+
+    def pluck_value
+      row = raw_rows.first
+      row && row.values.first
+    end
+
+    private
+
+    def aggregate(function, column, options = {})
+      expression = column.is_a?(SQL::Literal) ? column.sql : SQL.column(@table_name, column)
+      row = select(SQL::Literal.new("#{function}(#{expression}) AS value")).reorder.send(:raw_rows).first
+      value = row && row["value"]
+      options[:integer] && value ? value.to_i : value
+    end
+
+    def to_sql_and_binds
+      SQL.select(@table_name, @values)
+    end
+
+    def spawn_with(key, value)
+      values = duplicate_values
+      values[key] = value
+      self.class.new(@model, values)
+    end
+
+    def duplicate_values
+      {
+        where: @values[:where].dup, order: @values[:order].dup,
+        select: @values[:select].dup, joins: @values[:joins].dup,
+        limit: @values[:limit], offset: @values[:offset], distinct: @values[:distinct]
+      }
+    end
+
+    def stringify_keys(attributes)
+      result = {}
+      attributes.each { |key, value| result[key.to_s] = value }
+      result
+    end
+
+    def scope_for_create
+      attributes = {}
+      @values[:where].each do |fragment|
+        next unless fragment.sql =~ /\A\"[^\"]+\"\.\"([^\"]+)\" = \?\z/
+        attributes[Regexp.last_match(1)] = fragment.binds.first
+      end
+      attributes
+    end
+  end
+end

data/lib/ruflet_record/schema.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module RufletRecord
+  class TableDefinition
+    attr_reader :name, :columns, :indexes, :foreign_keys
+
+    def initialize(name, id)
+      @name = name.to_s
+      @columns = []
+      @indexes = []
+      @foreign_keys = []
+      integer(:id, primary_key: true, auto_increment: true, null: false) unless id == false
+    end
+
+    def column(name, type, options = {})
+      @columns << [name.to_s, type.to_sym, options]
+      self
+    end
+
+    def string(name, options = {}); column(name, :string, options); end
+    def text(name, options = {}); column(name, :text, options); end
+    def integer(name, options = {}); column(name, :integer, options); end
+    def float(name, options = {}); column(name, :float, options); end
+    def decimal(name, options = {}); column(name, :decimal, options); end
+    def boolean(name, options = {}); column(name, :boolean, options); end
+    def datetime(name, options = {}); column(name, :datetime, options); end
+    def date(name, options = {}); column(name, :date, options); end
+    def binary(name, options = {}); column(name, :binary, options); end
+    def json(name, options = {}); column(name, :json, options); end
+
+    def references(name, options = {})
+      column_options = options.dup
+      foreign_key = column_options.delete(:foreign_key)
+      index_option = column_options.delete(:index)
+      column_name = "#{name}_id"
+      column(column_name, :integer, column_options)
+      index(column_name, index_option.is_a?(Hash) ? index_option : {}) unless index_option == false
+      add_foreign_key(column_name, name, foreign_key) if foreign_key
+    end
+    alias belongs_to references
+
+    def timestamps(options = {})
+      datetime(:created_at, options)
+      datetime(:updated_at, options)
+    end
+
+    def index(columns, options = {})
+      @indexes << [Array(columns).map(&:to_s), options]
+      self
+    end
+
+    def add_foreign_key(column_name, reference_name, options)
+      settings = options.is_a?(Hash) ? options : {}
+      target_table = settings[:to_table] || Inflector.pluralize(reference_name.to_s)
+      target_column = settings[:primary_key] || "id"
+      @foreign_keys << [
+        column_name.to_s,
+        target_table.to_s,
+        target_column.to_s,
+        settings[:on_delete],
+        settings[:on_update]
+      ]
+      self
+    end
+  end
+
+  class Schema
+    TYPE_SQL = {
+      string: "VARCHAR", text: "TEXT", integer: "INTEGER", float: "REAL",
+      decimal: "DECIMAL", boolean: "BOOLEAN", datetime: "DATETIME",
+      date: "DATE", binary: "BLOB", json: "TEXT"
+    }.freeze
+
+    class << self
+      attr_writer :connection
+
+      def connection
+        @connection || RufletRecord.connection
+      end
+
+      def define(&block)
+        schema = new(connection)
+        schema.instance_eval(&block)
+        schema
+      end
+    end
+
+    def initialize(connection = nil)
+      @connection = connection || RufletRecord.connection
+    end
+
+    def create_table(name, options = {}, &block)
+      definition = TableDefinition.new(name, options.fetch(:id, true))
+      block.call(definition) if block
+      if options[:force]
+        drop_table(name, if_exists: true)
+      elsif options[:if_not_exists] && @connection.table_exists?(name)
+        return
+      end
+      columns = definition.columns.map { |column| column_sql(*column) }
+      definition.foreign_keys.each { |foreign_key| columns << foreign_key_sql(*foreign_key) }
+      @connection.execute("CREATE TABLE #{SQL.quote_identifier(name)} (#{columns.join(', ')})")
+      definition.indexes.each { |columns_value, index_options| add_index(name, columns_value, index_options) }
+      reset_models
+    end
+
+    def drop_table(name, options = {})
+      clause = options[:if_exists] ? " IF EXISTS" : ""
+      @connection.execute("DROP TABLE#{clause} #{SQL.quote_identifier(name)}")
+      reset_models
+    end
+
+    def add_column(table, name, type, options = {})
+      @connection.execute("ALTER TABLE #{SQL.quote_identifier(table)} ADD COLUMN #{column_sql(name, type, options)}")
+      reset_models
+    end
+
+    def add_index(table, columns, options = {})
+      names = Array(columns).map(&:to_s)
+      index_name = options[:name] || "index_#{table}_on_#{names.join('_and_')}"
+      unique = options[:unique] ? "UNIQUE " : ""
+      quoted_columns = names.map { |name| SQL.quote_identifier(name) }.join(", ")
+      @connection.execute("CREATE #{unique}INDEX #{SQL.quote_identifier(index_name)} ON #{SQL.quote_identifier(table)} (#{quoted_columns})")
+    end
+
+    def remove_index(table, columns = nil, options = {})
+      names = Array(columns).map(&:to_s)
+      index_name = options[:name] || "index_#{table}_on_#{names.join('_and_')}"
+      @connection.execute("DROP INDEX #{SQL.quote_identifier(index_name)}")
+    end
+
+    def rename_table(old_name, new_name)
+      @connection.execute("ALTER TABLE #{SQL.quote_identifier(old_name)} RENAME TO #{SQL.quote_identifier(new_name)}")
+      reset_models
+    end
+
+    private
+
+    def column_sql(name, type, options)
+      sql_type = TYPE_SQL[type.to_sym]
+      raise ArgumentError, "unknown column type: #{type}" unless sql_type
+      sql = "#{SQL.quote_identifier(name)} #{sql_type}"
+      if options[:primary_key]
+        sql << " PRIMARY KEY"
+        sql << " AUTOINCREMENT" if options[:auto_increment]
+      end
+      sql << " NOT NULL" if options[:null] == false
+      sql << " UNIQUE" if options[:unique]
+      sql << " DEFAULT #{quote_default(options[:default])}" if options.key?(:default)
+      sql
+    end
+
+    def quote_default(value)
+      return "NULL" if value.nil?
+      return value.to_s if value.is_a?(Numeric)
+      return value ? "1" : "0" if value == true || value == false
+      return value.sql if value.is_a?(SQL::Literal)
+
+      "'#{value.to_s.gsub("'", "''")}'"
+    end
+
+    def foreign_key_sql(column, target_table, target_column, on_delete, on_update)
+      sql = "FOREIGN KEY (#{SQL.quote_identifier(column)}) REFERENCES #{SQL.quote_identifier(target_table)} (#{SQL.quote_identifier(target_column)})"
+      sql << " ON DELETE #{foreign_key_action(on_delete)}" if on_delete
+      sql << " ON UPDATE #{foreign_key_action(on_update)}" if on_update
+      sql
+    end
+
+    def foreign_key_action(value)
+      action = value.to_s.upcase.tr("_", " ")
+      allowed = ["CASCADE", "RESTRICT", "SET NULL", "SET DEFAULT", "NO ACTION"]
+      raise ArgumentError, "invalid foreign key action: #{value}" unless allowed.include?(action)
+      action
+    end
+
+    def reset_models
+      Base.descendants.each(&:reset_column_information) if RufletRecord.const_defined?(:Base)
+    end
+  end
+
+  class Migration
+    class << self
+      attr_accessor :connection
+
+      def migrate(direction = :up)
+        migration = new
+        if migration.respond_to?(direction)
+          migration.public_send(direction)
+        elsif direction.to_sym == :up && migration.respond_to?(:change)
+          migration.change
+        else
+          raise Error, "migration does not implement #{direction}"
+        end
+      end
+    end
+
+    def connection
+      self.class.connection || RufletRecord.connection
+    end
+
+    def method_missing(name, *args, &block)
+      schema = Schema.new(connection)
+      return schema.public_send(name, *args, &block) if schema.respond_to?(name)
+      super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      Schema.new(connection).respond_to?(name, include_private) || super
+    end
+  end
+end

data/lib/ruflet_record/sql.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module RufletRecord
+  module SQL
+    class Literal
+      attr_reader :sql
+
+      def initialize(sql)
+        @sql = sql.to_s.freeze
+      end
+
+      def to_s
+        @sql
+      end
+    end
+
+    class Fragment
+      attr_reader :sql, :binds
+
+      def initialize(sql, binds)
+        @sql = sql.to_s.freeze
+        @binds = binds.freeze
+      end
+    end
+
+    class << self
+
+    def quote_identifier(name)
+      parts = name.to_s.split(".")
+      parts.map { |part| "\"#{part.gsub('"', '""')}\"" }.join(".")
+    end
+
+    def column(table, name)
+      return name.sql if name.is_a?(Literal)
+
+      value = name.to_s
+      value.include?(".") ? quote_identifier(value) : "#{quote_identifier(table)}.#{quote_identifier(value)}"
+    end
+
+    def columns(table, values)
+      selected = values.nil? || values.empty? ? [Literal.new("#{quote_identifier(table)}.*")] : values
+      selected.map { |value| column(table, value) }.join(", ")
+    end
+
+    def predicate(table, conditions, binds)
+      if conditions.is_a?(Fragment)
+        return conditions
+      elsif conditions.is_a?(Hash)
+        parts = []
+        values = []
+        conditions.each do |name, value|
+          identifier = column(table, name)
+          if value.nil?
+            parts << "#{identifier} IS NULL"
+          elsif value.is_a?(Array)
+            if value.empty?
+              parts << "1 = 0"
+            else
+              parts << "#{identifier} IN (#{(["?"] * value.length).join(', ')})"
+              values.concat(value)
+            end
+          elsif value.is_a?(Range)
+            if value.exclude_end?
+              parts << "(#{identifier} >= ? AND #{identifier} < ?)"
+            else
+              parts << "#{identifier} BETWEEN ? AND ?"
+            end
+            values << value.begin << value.end
+          else
+            parts << "#{identifier} = ?"
+            values << value
+          end
+        end
+        return Fragment.new(parts.empty? ? "1 = 1" : parts.join(" AND "), values)
+      elsif conditions.is_a?(String)
+        expected = conditions.count("?")
+        if expected != binds.length
+          raise ArgumentError, "wrong number of bind values (#{binds.length} for #{expected})"
+        end
+        return Fragment.new(conditions, binds)
+      end
+
+      raise ArgumentError, "where conditions must be a Hash, String, or SQL fragment"
+    end
+
+    def negate(fragment)
+      Fragment.new("NOT (#{fragment.sql})", fragment.binds)
+    end
+
+    def order(table, values)
+      values.map do |value|
+        if value.is_a?(Hash)
+          value.map do |name, direction|
+            normalized = direction.to_s.upcase
+            raise ArgumentError, "invalid order direction: #{direction}" unless %w[ASC DESC].include?(normalized)
+            "#{column(table, name)} #{normalized}"
+          end.join(", ")
+        elsif value.is_a?(Symbol)
+          "#{column(table, value)} ASC"
+        elsif value.is_a?(Literal)
+          value.sql
+        else
+          parse_order_string(table, value.to_s)
+        end
+      end.join(", ")
+    end
+
+    def parse_order_string(table, value)
+      value.split(",").map do |piece|
+        match = /\A\s*([A-Za-z_][A-Za-z0-9_.]*)(?:\s+(ASC|DESC))?\s*\z/i.match(piece)
+        raise ArgumentError, "unsafe order expression: #{value.inspect}" unless match
+        direction = match[2] ? " #{match[2].upcase}" : " ASC"
+        "#{column(table, match[1])}#{direction}"
+      end.join(", ")
+    end
+
+    def select(table, values)
+      sql = +"SELECT "
+      sql << "DISTINCT " if values[:distinct]
+      sql << columns(table, values[:select])
+      sql << " FROM #{quote_identifier(table)}"
+      sql << " #{values[:joins].join(' ')}" unless values[:joins].empty?
+      binds = []
+      append_wheres(sql, binds, values[:where])
+      unless values[:order].empty?
+        sql << " ORDER BY #{order(table, values[:order])}"
+      end
+      if values[:limit]
+        sql << " LIMIT ?"
+        binds << values[:limit]
+      elsif values[:offset]
+        sql << " LIMIT -1"
+      end
+      if values[:offset]
+        sql << " OFFSET ?"
+        binds << values[:offset]
+      end
+      [sql, binds]
+    end
+
+    def insert(table, attributes)
+      names = attributes.keys
+      sql = "INSERT INTO #{quote_identifier(table)}"
+      if names.empty?
+        return ["#{sql} DEFAULT VALUES", []]
+      end
+      quoted = names.map { |name| quote_identifier(name) }.join(", ")
+      placeholders = (["?"] * names.length).join(", ")
+      ["#{sql} (#{quoted}) VALUES (#{placeholders})", names.map { |name| attributes[name] }]
+    end
+
+    def update(table, attributes, wheres)
+      assignments = attributes.keys.map { |name| "#{quote_identifier(name)} = ?" }.join(", ")
+      binds = attributes.keys.map { |name| attributes[name] }
+      sql = "UPDATE #{quote_identifier(table)} SET #{assignments}"
+      append_wheres(sql, binds, wheres)
+      [sql, binds]
+    end
+
+    def delete(table, wheres)
+      sql = "DELETE FROM #{quote_identifier(table)}"
+      binds = []
+      append_wheres(sql, binds, wheres)
+      [sql, binds]
+    end
+
+    def append_wheres(sql, binds, wheres)
+      return if wheres.empty?
+
+      sql << " WHERE #{wheres.map { |fragment| "(#{fragment.sql})" }.join(' AND ')}"
+      wheres.each { |fragment| binds.concat(fragment.binds) }
+    end
+    end
+  end
+end

data/lib/ruflet_record/version.rb

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