slick 0.16.3 → 0.17.0

data/lib/slick/database/abstract_row.rb

@@ -0,0 +1,13 @@
+
+require "slick/concern"
+
+module Slick::Database::AbstractRow
+
+    include Slick::Concern
+
+    def register(name)
+        method_missing(:register, name, :abstract => true)
+        Slick::Database::Union.register(name.pluralize)
+    end
+
+end

data/lib/slick/database/column.rb

@@ -0,0 +1,64 @@
+
+class Slick::Database::Column
+
+    TYPE_TO_MYSQL_COLUMN_TYPE_MAP = {
+        "primary_key" => "int(11) unsigned",
+        "foreign_key" => "int(11) unsigned",
+        "binary" => "longblob",
+        "boolean" => "enum('false','true')",
+        "date" => "date",
+        "datetime" => "datetime",
+        "decimal" => "decimal",
+        "float" => "float",
+        "integer" => "int(11)",
+        "string" => "varchar(255)",
+        "text" => "longtext",
+        "time" => "time",
+        "timestamp" => "datetime"
+    }
+
+    MYSQL_COLUMN_TYPE_TO_TYPE_MAP = TYPE_TO_MYSQL_COLUMN_TYPE_MAP.invert
+
+    def initialize(table, name, type = nil)
+        @table = table
+        @name = name
+        @type = type
+    end
+
+    def type
+        @type ||= @table.send(@name).instance_variable_get(:@type)
+    end
+
+    def exist?
+        !type.nil?
+    end
+
+    def create(type = 'string', options = {})
+        type = type.to_s
+        options = {:index => type == 'foreign_key'}.paramify.merge(options)
+        database = @table.instance_variable_get(:@database)
+
+        @table.create
+
+        database.run(
+            'alter table ?', @table.class.name.to_sym,
+            'add column ?', @name.to_sym, TYPE_TO_MYSQL_COLUMN_TYPE_MAP[type]
+        ) if !exist?
+
+        database.run(
+            'alter table ?', @table.class.name.to_sym,
+            'add index(?)', @name.to_sym
+        ) if options['index'] == 'true'
+    end
+
+    def drop
+        database = @table.instance_variable_get(:@database)
+
+        database.run(
+            'alter table ?', @table.class.name.to_sym,
+            'drop ?', @name.to_sym
+        )
+        @type = nil
+    end
+
+end

data/lib/slick/database/migration.rb

@@ -0,0 +1,36 @@
+
+require "slick/registry"
+require "slick/helpers"
+
+class Slick::Database::Migration
+
+    class << self
+
+        include Slick::Registry
+
+        def register(name, *args)
+            throw "Invalid migration name '#{name}' - it must begin with a unix timestamp" if !name.to_s.match(/\A\d+/)
+            super
+        end
+
+        def schema_version
+            if matches = name.to_s.match(/\A(\d+)/)
+                matches[0].to_i
+            else
+                0
+            end
+        end
+
+    end
+
+    include Slick::Helpers
+
+    def up
+
+    end
+
+    def down
+
+    end
+
+end

data/lib/slick/database/migrator.rb

@@ -0,0 +1,67 @@
+
+class Slick::Database::Migrator
+
+    def initialize(database)
+        @database = database
+
+        if !database.slick_applied_migrations.exist?
+            database.slick_applied_migrations.add_column(:schema_version, :integer) 
+        end
+    end
+
+    def current_schema_version
+        slick_applied_migration = @database.slick_applied_migrations.order_by(:schema_version, :desc).first(:cache => "schema")
+        if slick_applied_migration
+            slick_applied_migration.schema_version
+        else
+            -1
+        end
+    end
+
+    def latest_schema_version
+        migrations.length > 0 ? migrations.last.schema_version : -1
+    end
+
+    def migrate(to_schema_version = latest_schema_version)
+        if to_schema_version > current_schema_version
+            migrate_up(to_schema_version)
+        elsif to_schema_version < current_schema_version
+            migrate_down(to_schema_version)
+        else
+            puts "Migrations up-to-date"
+        end
+    end
+
+    private
+
+    def migrate_up(to_schema_version)
+        migrations.each do |migration|
+            if migration.schema_version <= to_schema_version && !migration_applied?(migration)
+                puts "Up: #{migration.name}"
+                migration.new.up
+                @database.slick_applied_migrations.insert(:schema_version => migration.schema_version)
+            end
+        end
+    end
+
+    def migrate_down(to_schema_version)
+        migrations.reverse.each do |migration|
+            if migration.schema_version > to_schema_version && migration_applied?(migration)
+                puts "Down: #{migration.name}"
+                migration.new.down
+                @database.slick_applied_migrations.schema_version_eq(migration.schema_version).delete
+            end
+        end
+    end
+
+    def migrations
+        @migrations ||= Slick::Database::Migration.registered_classes.values.sort do |a, b|
+            a.schema_version <=> b.schema_version
+        end
+    end
+
+    def migration_applied?(migration)
+        @database.slick_applied_migrations.schema_version_eq(migration.schema_version).count > 0
+    end
+
+end

data/lib/slick/database/row.rb

@@ -0,0 +1,127 @@
+
+class Slick::Database::Row
+
+    class << self
+
+        include Slick::Registry
+
+        attr_accessor :table_class
+
+        def register(name, options = {})
+            if options[:abstract]
+                union_class = Slick::Database::Union.for(name.pluralize, :register_if_not_exists => true)
+                union_class.table_classes << table_class if !union_class.table_classes.include?(table_class)
+            else
+                super(name)
+                @table_class = Slick::Database::Table.for(name.pluralize, :register_if_not_exists => true)
+            end
+        end
+
+        def has_many(name, *args, &block)
+           table_class.has_many(name, *args, &block)
+           class_eval("def #{name}; self.class.table_class.new(@database).id_eq(id).#{name}; end")
+        end
+
+        def has_one(name, *args, &block)
+            table_class.has_one(name, *args, &block)
+            class_eval("def #{name}; self.class.table_class.new(@database).id_eq(id).#{name}.first; end")
+        end
+
+        def belongs_to(name, *args, &block)
+            table_class.belongs_to(name, *args, &block)
+            class_eval("def #{name}; self.class.table_class.new(@database).id_eq(id).#{name}.first; end")
+        end
+
+    end
+
+    def initialize(database, fields = {})
+        @database = database
+        @fields = fields
+        @altered_fields = {}
+        @update_level = 0
+    end
+
+    def inspect
+        @fields
+    end
+
+    def id=(value)
+        raise "Id fields can't be set directly on a row"
+    end
+
+    def update(fields = {}, &block)
+        @update_level += 1
+        fields.each{ |name, value| send("#{name}=", value) }
+
+        if block
+            if block.arity > 0
+                block.call(self)
+            else
+               instance_eval(&block) 
+            end
+        end
+        @update_level -=1
+
+        if @update_level == 0 && @altered_fields.count > 0
+            if @fields['id'].nil?
+                @database.run(_generate_insert_sql())
+            else
+                @database.run(_generate_update_sql())
+            end
+        end
+        self
+    end
+
+    def delete
+        @database.run('delete from ? where id = ?', self.class.name.pluralize.to_sym, id)
+    end
+
+    def method_missing(name, *args, &block)
+        if args.length == 1 && matches = name.match(/\A(.+)=\z/)
+            if _column_names.include?(matches[1])
+                @altered_fields[matches[1]] = args.first if @fields[matches[1]] != args.first
+                update if @update_level == 0
+            else
+                raise "No such column '#{matches[1]} exists for table '#{self.class.name.pluralize}'"
+            end
+        elsif args.length == 0
+            name = name.to_s
+            if _column_names.include?(name)
+                if @altered_fields.key?(name)
+                    @altered_fields[name]
+                else
+                    @fields[name]
+                end
+            else
+                raise "No such column '#{name}' exists for table '#{self.class.name.pluralize}'"
+            end
+        else
+            super
+        end
+    end
+
+    def _generate_insert_sql
+        out = []
+        out << ['insert into ?', self.class.name.pluralize.to_sym]
+        out << ["(#{@altered_fields.keys.map{'?'}.join(', ')})", @altered_fields.keys.map{|name| name.to_sym}]
+        out << ["values(#{@altered_fields.keys.map{'?'}.join(', ')})", @altered_fields.values]
+        out
+    end
+
+    def _generate_update_sql
+        out = []
+        out << ['update ? ', self.class.name.pluralize.to_sym]
+        out << ['set']
+        out << @altered_fields.keys.map{'? = ?'}.join(', ')
+        @altered_fields.each do |name, value|
+            out << [name.to_sym, value]
+        end
+        out << ['where id = ?', @fields['id']]
+        out
+    end
+
+    def _column_names
+        @_column_names ||= Slick::Database::Table.create(self.class.name.pluralize, @database).columns.keys
+    end
+
+end

data/lib/slick/database/table.rb

@@ -0,0 +1,381 @@
+
+require "slick/registry"
+require "slick/helper"
+
+class Slick::Database::Table
+
+    class << self
+
+        include Slick::Registry
+
+        def register(name, *args)
+            super
+            Class.new(Slick::Helper){ register name }.define_method "call" do |*args, &block|
+                database.send(self.class.name, *args, &block)
+            end
+        end
+
+        def relationships
+            @relationships ||= {}.paramify
+        end
+
+        def has_many(name, options = {})
+            relationships[name] = {
+                "name" => name.to_s,
+                "collection_name" => name.to_s,
+                "from_key" => "id",
+                "to_key" => "#{self.name.singularize}_id",
+                "cascade_delete" => "true"
+            }
+            relationships[name].merge!(options)
+            class_eval("def #{name}; _join('#{name}'); end")
+        end
+
+        def has_one(name, options = {})
+            relationships[name] = {
+                "name" => name.to_s,
+                "collection_name" => name.pluralize,
+                "from_key" => "id",
+                "to_key" => "#{self.name.singularize}_id",
+                "cascade_delete" => "true"
+            }
+            relationships[name].merge!(options)
+            class_eval("def #{name}; _join('#{name}'); end")
+        end
+
+        def belongs_to(name, options = {})
+            relationships[name] = {
+                "name" => name.to_s,
+                "collection_name" => name.pluralize,
+                "from_key" => "#{name}_id",
+                "to_key" => "id",
+                "cascade_delete" => "false"
+            }
+            relationships[name].merge!(options)
+            class_eval("def #{name}; _join('#{name}'); end")
+        end
+
+        def scope(name, &block)
+            #call block with join parents as arguments
+        end
+
+    end
+
+    def initialize(database, join_parent = nil)
+        @database = database
+        @join_parent = join_parent
+        @alias_counters = {} if !@join_parent
+        @alias = _generate_alias(self.class.name)
+
+        if !@join_parent
+            @from_sql = ['? as ?', self.class.name.to_sym, @alias.to_sym]
+            @where_sql = []
+            @order_by_sql = []
+            @limit_sql = []
+        end
+    end
+
+    def +(collection)
+        Slick::Database::Union.new(@database, [clone, collection])
+    end
+
+    def clone
+        out = super
+        out.instance_eval do
+            instance_variables.each do |name|
+                if name.match(/\A@_/)
+                    remove_instance_variable(name)
+                elsif name != :@database
+                    instance_variable_set(name, instance_variable_get(name).clone)
+                end
+            end
+        end
+        out
+    end
+
+    def back(count = 1)
+        out = self
+        count.times{ out = out.instance_variable_get(:@join_parent) }
+        out
+    end
+
+    def where(*predicate, &block)
+        if block
+            join_path = []
+            current = self
+            block.arity.times do
+                join_path << current
+                current = current.instance_eval{ @join_parent } if current
+            end
+            predicate << block.call(*join_path)
+        end
+        out = clone
+        where_sql = out.send(:_join_root).instance_variable_get(:@where_sql)
+        if where_sql.count > 0
+            where_sql << ['and', predicate]
+        else
+            where_sql << predicate
+        end
+        out
+    end
+
+    def order_by(column, direction = 'asc')
+        out = clone
+        column = out.send(column.to_s) if !column.kind_of?(Slick::Database::Column)
+        order_by_sql = out.send(:_join_root).instance_variable_get(:@order_by_sql)
+        if order_by_sql.count > 0
+            order_by_sql << [", ? #{direction.to_s == 'desc' ? 'desc' : 'asc'}", column]
+        else
+            order_by_sql << ["? #{direction.to_s == 'desc' ? 'desc' : 'asc'}", column]
+        end
+        out
+    end
+
+    def clear_order_by
+        out = clone
+        out.send(:_join_root).instance_variable_set(:@order_by_sql, [])
+        out
+    end
+
+    def paginate(page = 1, page_size = 10)
+        out = clone
+        out.send(:_join_root).instance_variable_set(:@limit_sql, ['?, ?', (page - 1) * page_size, page_size])
+        out
+    end
+
+    def clear_pagination
+        out = clone
+        out.send(:_join_root).instance_variable_set(:@limit_sql, [])
+        out
+    end
+
+    def all(options = {})
+        @database.run(_generate_select_sql(options), options)
+    end
+
+    def each(options = {}, &block)
+        @database.run(_generate_select_sql(options), options).each(&block)
+    end
+
+    def first(options = {})
+        paginate(1, 1).all(options).pop
+    end
+
+    def [](id)
+        id_eq(id).first
+    end
+
+    def count(options = {})
+        first(options.paramify.merge('select' => 'count(*)')).values.pop
+    end
+
+    def explain(options = {})
+        @database.send(:_prepare, _generate_select_sql(options))
+    end
+
+    def inspect
+        all
+    end
+
+    def insert(fields = {}, &block)
+        Slick::Database::Row.create(self.class.name.singularize, @database).update(fields, &block)
+    end
+
+    def update(fields = {}, &block)
+        each{|row| row.update(fields, &block)}
+        self
+    end
+
+    def delete
+        each{|row| row.delete}
+        self
+    end
+
+    def columns
+        if exist?
+            out = {}
+            @database.run('describe ?', self, :cache => 'schema').each do |row|
+                name = row['Field']
+                if name == 'id'
+                    type = 'primary_key'
+                else
+                    type = Slick::Database::Column::MYSQL_COLUMN_TYPE_TO_TYPE_MAP[
+                        row['Type']
+                    ] || "string"
+                end
+                out[name] = Slick::Database::Column.new(self, name, type)
+            end
+            out
+        else
+            {}
+        end
+    end
+    
+    def exist?
+        @database.tables.keys.include?(self.class.name)
+    end
+
+    def create
+        @database.create()
+        @database.run(
+            "create table ?", self.class.name.to_sym, "(",
+                "id int(11) unsigned auto_increment primary key",
+            ")"
+        ) if !exist?
+    end
+
+    def drop
+        @database.run("drop table ?", self.class.name.to_sym) if exist?
+    end
+    
+    def add_column(name, *args)
+        send(name).create(*args)
+    end
+
+    def remove_column(name)
+        send(name).drop
+    end
+
+    COMPARISON_OPERATORS = {
+        'eq' => '? = ?',
+        'ne' => '? != ?',
+        'lt' => '? < ?',
+        'gt' => '',
+        'le' => '? <= ?',
+        'ge' => '? >= ?',
+        'begins_with' => '? like concat(?, '%')',
+        'ends_with' => '? like concat('%', ?)',
+        'contains' => '? like concat('%', ?, '%')'
+    }
+
+    COMPARISON_OPERATOR_METHOD_PATTERN = Regexp.new("\\A(.+)_(#{COMPARISON_OPERATORS.keys.join('|')})\\z")
+
+    def method_missing(name, *args, &block)
+        if args.length == 0 && block.nil?
+            columns[name.to_s] || Slick::Database::Column.new(self, name)
+        elsif args.length == 1 && block.nil? && matches = name.to_s.match(COMPARISON_OPERATOR_METHOD_PATTERN)
+            if send(matches[1]).exist?
+                where(COMPARISON_OPERATORS[matches[2]], send(matches[1]), *args)
+            else
+                where('1 = 2')
+            end
+        else
+            super
+        end
+    end
+
+    private
+
+    def _join(relationship_name)
+        relationship = self.class.relationships[relationship_name]
+        if Slick::Database::Union.registered_classes[relationship.collection_name]
+            _join_to_union(relationship)
+        else
+            _join_to_table(relationship)
+        end
+    end
+
+    def _join_to_union(relationship)
+        union_class = Slick::Database::Union.registered_classes[relationship.collection_name]
+        tables = union_class.table_classes.map do |table_class|
+            join_parent = clone
+            out = table_class.new(@database, join_parent)
+            out.send(:_join_root).instance_eval do
+                @from_sql << [', ? as ?', out.class.name.to_sym, out.instance_variable_get(:@alias).to_sym]
+                @where_sql << ["#{@where_sql.count > 0 ? 'and ' : ''}? = ?", join_parent.send(relationship.from_key), out.send(relationship.to_key)]
+                if matches = relationship.from_key.match(/\A(.+)_id\z/)
+                    @where_sql << ['and ? = ?', join_parent.send("#{matches[1]}_type"), out.class.name.singularize]
+                elsif matches = relationship.to_key.match(/\A(.+)_id\z/)
+                    @where_sql << ['and ? = ?', out.send("#{matches[1]}_type"), join_parent.class.name.singularize]
+                end
+            end
+            out
+        end
+        union_class.new(@database, tables)
+    end
+
+    def _join_to_table(relationship)
+        join_parent = clone
+        out = Slick::Database::Table.create(relationship.collection_name, @database, join_parent)
+        out.send(:_join_root).instance_eval do
+            @from_sql << [', ? as ?', out.class.name.to_sym, out.instance_variable_get(:@alias).to_sym]
+            @where_sql << ["#{@where_sql.count > 0 ? 'and ' : ''}? = ?", join_parent.send(relationship.from_key), out.send(relationship.to_key)]
+        end
+        out
+    end
+
+    def _generate_select_sql(options = {})
+        options = {"column_names" => columns.keys}.paramify.merge(options)
+
+        out = ['select']
+
+        if options.key?('select')
+            out << options['select']
+        else
+            options.column_names.values.each do |column_name|
+                column = send(column_name)
+                if column.exist?
+                    out << ['? as ?, ', column, column_name.to_sym]
+                else
+                    out << ['null as ?, ', column_name.to_sym]
+                end
+            end
+            out << ['? as ?', self.class.name.singularize, :_type]
+        end
+        
+        if options.key?('from')
+            from_sql = options.from || []
+        else
+            from_sql = _join_root.instance_variable_get(:@from_sql)
+        end
+        out << ["from", from_sql] if from_sql.count > 0
+
+        if options.key?('where')
+            where_sql = options.where || []
+        else
+            where_sql = _join_root.instance_variable_get(:@where_sql)
+        end
+        out << ['where', where_sql] if where_sql.count > 0
+
+        if options.key?('order_by')
+            order_by_sql = options.order_by || []
+        else
+            order_by_sql = _join_root.instance_variable_get(:@order_by_sql)
+        end
+        out << ['order by', order_by_sql] if order_by_sql.count > 0
+
+        if options.key?('limit')
+            limit_sql = options.limit || []
+        else
+            limit_sql = _join_root.instance_variable_get(:@limit_sql)
+        end
+        out << ['limit', limit_sql] if limit_sql.count > 0
+
+        out
+    end
+
+    def _generate_alias(name)
+        alias_counters = _join_root.instance_variable_get(:@alias_counters)
+
+        name = name.to_s
+        alias_counters[name] = 0 if alias_counters[name].nil?
+        alias_counters[name] += 1
+
+        if alias_counters[name] == 1
+            name
+        else
+            "#{name}#{alias_counters[name]}"
+        end
+    end
+
+    def _join_root
+        @_join_root ||= begin
+            out = self
+            while join_parent = out.instance_variable_get(:@join_parent)
+                out = join_parent
+            end
+            out
+        end
+    end
+
+end