spiderfw 0.5

data/lib/spiderfw/model/request.rb

@@ -0,0 +1,80 @@
+require 'spiderfw/model/model_hash'
+
+module Spider; module Model
+    
+    # The request object specifies which data is to be loaded for a model. It is similar in purpose to
+    # the SELECT ... part of an SQL query.
+    
+    class Request < ModelHash
+        # (bool) if true, the total number of rows returned by the query is requested.
+        attr_accessor :total_rows
+        # (array) find also the given subclasses of the queried model.
+        attr_reader :polymorphs
+        
+        def initialize(val=nil, params={})
+            if (val.is_a?(Array))
+                super()
+                val.each{ |v| request(v) }
+            else
+                super(val)
+            end
+            @total_rows = params[:total_rows]
+            @polymorphs = {}
+        end
+        
+        # TODO: fix/remove?
+        def request(element) # :nodoc:
+            if (element.is_a?(Element))
+                self[element.name.to_s] = true
+            else
+                element.to_s.split(',').each do |el|
+                    self[el.strip] = true
+                end
+            end
+        end
+    
+        # Requests all base types
+        def load_all_simple
+            @load_all_simple = true
+        end
+        
+        def load_all_simple?
+            @load_all_simple
+        end
+        
+        # Adds a request for a subclass.
+        def with_polymorphs(type, request)
+            @polymorphs[type] = request
+        end
+        
+        def polymorphs?
+            @polymorphs.empty? ? false : true
+        end
+        
+        # Requests only subclasses, not the queried model.
+        def only_polymorphs
+            @only_polymorphs = true
+            return self
+        end
+        
+        def only_polymorphs?
+            @only_polymorphs
+        end
+        
+        def with_superclass
+            @with_superclass = true
+            return self
+        end
+        
+        def with_superclass=(val)
+            @with_superclass = val
+        end
+        
+        def with_superclass?
+            @with_superclass
+        end
+    
+    end
+
+
+end; end

data/lib/spiderfw/model/storage/base_storage.rb

@@ -0,0 +1,110 @@
+module Spider; module Model; module Storage
+    
+    class BaseStorage
+        include Spider::Logger
+        attr_reader :url
+        
+        def self.sequence_sync
+            @sequence_sync ||= Sync.new
+        end
+        
+        def self.base_types
+            Model.base_types
+        end
+        
+        def initialize(url)
+            @url = url
+            @configuration = {}
+            parse_url(url)
+        end
+        
+        def configure(conf)
+            @configuration.merge!(conf.to_hash)
+        end
+        
+        def parse_url(url)
+            raise StorageException, "Unimplemented"
+        end
+        
+        def get_mapper(model)
+            raise StorageException, "Unimplemented"
+        end
+        
+        def prepare_value(type, value)
+            return value
+        end
+        
+        def ==(storage)
+            return false unless self.class == storage.class
+            return false unless self.url == storage.url
+            return true
+        end
+        
+        # Utility methods
+        
+        def sequence_file_path(name)
+            path = 'var/sequences/'+name
+            return path
+        end
+        
+        def sequence_exists?(name)
+            File.exist?(sequence_file_path(name))
+        end
+        
+        def create_sequence(name, start=1, increment=1)
+            sequence_next(name, start-1, increment)
+        end
+            
+        
+        def update_sequence(name, val)
+            # not an alias because the set value behaviour of next_sequence isn't expected in subclasses
+            sequence_next(name, val)
+        end
+        
+        # Increments a named sequence and returns the new value
+        def sequence_next(name, newval=nil, increment=1)
+            path = sequence_file_path(name)
+            FileUtils.mkpath(File.dirname(path))
+            self.class.sequence_sync.lock(Sync::EX)
+            if newval
+                seq = newval
+            else
+                seq = 0
+                File.open(path, 'a+') do |f|
+                    f.rewind
+                    f.flock File::LOCK_EX
+                    cur = f.gets
+                    if (cur)
+                        seq, increment_str = cur.split('|')
+                    else
+                        seq, increment_str = 0, 1
+                    end
+                    seq = seq.to_i
+                    increment = increment_str.to_i if increment_str
+                    f.close
+                end
+                seq += increment
+            end
+            File.open(path, 'w+') do |f|
+                f.print(seq)
+                f.print("|#{increment}") if (increment != 1)
+                f.flock File::LOCK_UN
+                f.close
+            end
+            self.class.sequence_sync.lock(Sync::UN)
+            return seq
+        end
+            
+        
+    end
+    
+    ###############################
+    #   Exceptions                #
+    ###############################
+    
+    class StorageException < RuntimeError
+    end
+    
+    
+    
+end; end; end

data/lib/spiderfw/model/storage/db/adapters/mssql.rb

@@ -0,0 +1,129 @@
+require 'spiderfw/model/storage/db/db_storage'
+require 'spiderfw/model/storage/db/dialects/no_total_rows'
+
+module Spider; module Model; module Storage; module Db
+    
+    
+    class MSSQL < DbStorage
+        include Dialects::NoTotalRows
+        
+        def self.capabilities
+            {
+                :autoincrement => true,
+                :sequences => false,
+                :transactions => true
+            }
+        end
+        
+        def column_type(type, attributes)
+            case type.name
+            when 'String'
+                'nvarchar'
+            when 'Text'
+                'ntext'
+            when 'Fixnum'
+                'int'
+            when 'Float'
+                'real'
+            when 'BigDecimal', 'Spider::DataTypes::Decimal'
+                'decimal'
+            when 'Date', 'DateTime'
+                'datetime'
+            when 'Spider::DataTypes::Binary'
+                'varbinary'
+            when 'Spider::DataTypes::Bool'
+                'bit'
+            end
+        end
+        
+        def query(query)
+            return super unless query[:query_type] == :count
+            @last_query = query
+            query[:keys] = ['COUNT(*) AS N']
+            query[:order] = []
+            sql, bind_vars = sql_select(query)
+            return execute("#{sql} AS CountResult", *bind_vars)[0]['N'].to_i
+        end
+        
+        def sql_select(query)
+            bind_vars = query[:bind_vars] || []
+            if query[:limit] # Oracle is so braindead
+                replaced_fields = {}
+                replace_cnt = 0
+                # add first field to order if none is found; order is needed for limit
+                query[:order] << [query[:keys][0], 'desc'] if query[:order].length < 1
+                query[:order].each do |o|
+                    field, direction = o
+                    transformed = "O#{replace_cnt += 1}"
+                    replaced_fields[field] = transformed
+                    query[:keys] << "#{field} AS #{transformed}"
+                end
+            end
+            keys = sql_keys(query)
+            order = sql_order(query)
+            if (query[:limit])
+                keys += ", row_number() over (order by #{order}) mssql_row_num"
+            end
+            tables_sql, tables_values = sql_tables(query)
+            sql = "SELECT #{keys} FROM #{tables_sql} "
+            bind_vars += tables_values
+            where, vals = sql_condition(query)
+            bind_vars += vals
+            sql += "WHERE #{where} " if where && !where.empty?
+            order = sql_order(query)
+            if (query[:limit])
+                if (query[:offset])
+                    limit = "mssql_row_num between ? and ?"
+                    bind_vars << query[:offset] + 1
+                    bind_vars << query[:offset] + query[:limit]
+                else
+                    limit = "mssql_row_num < ?"
+                    bind_vars << query[:limit] + 1
+                end
+                replaced_fields.each do |f, repl|
+                    order = order.gsub(f, repl)
+                end
+                sql = "SELECT * FROM (#{sql}) as RowConstrainedResult WHERE #{limit} order by #{order}"
+            else
+                sql += "ORDER BY #{order} " if order && !order.empty?
+            end
+            return sql, bind_vars
+        end
+        
+        def parse_db_column(col)
+            type, attributes = col[:type].split(' ', 2)
+            attributes = attributes.split(' ') if attributes
+            col[:type] = type
+            return col
+        end
+        
+        def reflect_column(table, column_name, column_attributes)
+            column_type = column_attributes[:type]
+            el_type = nil
+            el_attributes = {}
+            case column_type
+            when 'varchar', 'nvarchar', 'char', 'nchar'
+                el_type = String
+            when 'text', 'ntext'
+                el_type = Spider::DataTypes::Text
+            when 'int', 'smallint'
+                el_type = Fixnum
+            when 'bit'
+                el_type = Spider::DataTypes::Bool
+            when 'real'
+                el_type = Float
+            when 'decimal'
+                el_type = BigDecimal
+            when 'datetime'
+                el_type = DateTime
+            when 'varbinary'
+                el_type = Spider::DataTypes::Binary
+            end
+            return el_type, el_attributes
+
+        end
+        
+    end
+    
+    
+end; end; end; end