spiderfw 0.5

data/lib/spiderfw/model/storage/db/connectors/odbc.rb

@@ -0,0 +1,213 @@
+require 'odbc'
+
+module Spider; module Model; module Storage; module Db; module Connectors
+    
+    module ODBC
+        
+        def self.included(klass)
+            klass.extend(ClassMethods)
+        end
+        
+        module ClassMethods
+        
+            def new_connection(dsn=nil, user=nil, passwd=nil)
+                conn = ::ODBC.connect(dsn, user, passwd)
+                conn.autocommit = true
+                return conn
+            end
+        
+            def connection_alive?(conn)
+                begin
+                    return conn.connected?
+                rescue
+                    return false
+                end 
+            end
+            
+        end
+        
+        def release
+            begin
+                @conn.autocommit = true if @conn
+                super
+            rescue
+                self.class.remove_connection(@conn, @connection_params)
+                @conn = nil
+            end
+        end
+        
+        def parse_url(url)
+            # adapter//<username:password>@<dsn>
+            if (url =~ /(.+):\/\/(?:(.+):(.+)@)?(.+)/)
+                @adapter = $1
+                @user = $2
+                @pass = $3
+                @dsn = $4
+            else
+                raise ArgumentError, "ODBC url '#{url}' is invalid"
+            end
+            @connection_params = [@dsn, @user, @pass]
+        end
+        
+        def start_transaction
+            connection.autocommit = false
+            @in_transaction = true
+        end
+        
+        def in_transaction?
+            return @in_transaction ? true : false
+        end
+        
+        def commit
+            @conn.commit if @conn
+            release
+        end
+        
+        def rollback
+            @conn.rollback
+            release
+        end
+        
+        def execute(sql, *bind_vars)
+            begin
+                if (bind_vars && bind_vars.length > 0)
+                    debug_vars = bind_vars.map{|var| var = var.to_s; var && var.length > 50 ? var[0..50]+"...(#{var.length-50} chars more)" : var}
+                end
+                @last_executed = [sql, bind_vars]
+                if (Spider.conf.get('storage.db.replace_debug_vars'))
+                    cnt = -1
+                    debug("odbc executing: "+sql.gsub('?'){ debug_vars[cnt+=1] })
+                else
+                    debug_vars_str = debug_vars ? debug_vars.join(', ') : ''
+                    debug("odbc executing:\n#{sql}\n[#{debug_vars_str}]")
+                end
+                @stmt = connection.prepare(sql)
+                res = @stmt.execute(*bind_vars)
+                have_result = (@stmt.ncols != 0)
+                if (have_result)
+                    result = []
+                    while (h = res.fetch_hash)
+                        if block_given?
+                            yield h
+                        else
+                            result << h
+                        end
+                    end
+                end
+                @stmt.drop
+                if (@last_query_type == :insert)
+                    res = conn.run("SELECT @@IDENTITY AS NewID")
+                    @last_insert_id = res.fetch[0]
+                end
+                @last_query_type = nil
+                if (have_result)
+                    unless block_given?
+                        result.extend(StorageResult)
+                        return result
+                    end
+                else
+                    return res
+                end
+            rescue => exc
+                release
+                raise exc
+            ensure
+                @stmt.drop if @stmt
+                release if @conn && !in_transaction?
+            end
+         end
+         
+         def prepare(sql)
+             return @stmt = connection.prepare(sql)
+         end
+         
+         def execute_statement(stmt, *bind_vars)
+              stmt.execute(*bind_vars)
+         end
+         
+         
+         ##############################################################
+         #   Methods to get information from the db                   #
+         ##############################################################
+
+         def list_tables
+             connection do |c|
+                 res = c.tables
+                 tables = []
+                 res.each do |a|
+                     tables << a[2]
+                 end
+                 res.drop
+                 return tables
+             end
+         end
+
+         def describe_table(table)
+             columns = {}
+             connection do |c|
+                 fields = c.columns(table)
+                 fields.each_hash do |f|
+                     name = f['COLUMN_NAME']
+                     type =  f['TYPE_NAME']
+                     length = f['LENGTH'];
+                     scale = nil
+                     precision = f['PRECISION']
+                     col = {
+                         :type => type,
+                         :length => length,
+                         :precision => precision,
+                         :scale => scale
+                     }
+                     col = parse_db_column(col)
+                     columns[name] = col
+                 end
+                 fields.drop
+                 pks = c.primary_keys(table)
+                 pks.each_hash do |pk|
+                     columns[pk['COLUMN_NAME']][:primary_key] = true
+                 end
+                 pks.drop
+                 indexes = {}
+                 inds = c.indexes(table)
+                 inds.each_hash do |ind|
+                     name = ind['INDEX_QUALIFIER']
+                     next unless name
+                     indexes[name] = ind['COLUMN_NAME']
+                 end
+                 inds.drop
+             end
+             
+             return {:columns => columns}
+         end
+         
+         def value_to_mapper(type, value)
+             return unless value
+             case type.name
+             when 'DateTime'
+                 begin
+                     return ::ODBC.to_time(value).to_datetime
+                 rescue ArgumentError => exc
+                     @@time_offset ||= DateTime.now.offset
+                     return DateTime.civil(value.year, value.month, value.day, value.hour, value.minute, value.second, @@time_offset)
+                 end
+             when 'Date'
+                 return ::ODBC.to_date(value)
+             end
+             return super(type, value)
+         end
+
+         def table_exists?(table)
+             connection do |c|
+                 cols = c.columns(table)
+                 res = cols.fetch ? true : false
+                 cols.drop
+             end
+             Spider.logger.debug("TABLE EXISTS #{table}") if res
+             return res
+         end
+        
+    end
+    
+    
+    
+end; end; end; end; end

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

@@ -0,0 +1,13 @@
+module Spider; module Model; module Storage
+    
+    module Db
+        
+    end
+    
+    Db.autoload(:DbSchema, 'spiderfw/model/storage/db/db_schema')
+    Db.autoload(:SQLite, 'spiderfw/model/storage/db/adapters/sqlite')
+    Db.autoload(:OCI8, 'spiderfw/model/storage/db/adapters/oci8')
+    Db.autoload(:Mysql, 'spiderfw/model/storage/db/adapters/mysql')
+    Db.autoload(:MSSQL, 'spiderfw/model/storage/db/adapters/mssql')
+    
+end; end; end

data/lib/spiderfw/model/storage/db/db_connection_pool.rb

@@ -0,0 +1,126 @@
+require 'monitor'
+
+module Spider; module Model; module Storage; module Db
+
+    class DbConnectionPool
+        attr_reader :max_size
+        attr_accessor :timeout, :retry
+
+        def initialize(connection_params, provider)
+            @connection_params = connection_params
+            @provider = provider
+            @connection_mutex = Monitor.new
+            @queue = @connection_mutex.new_cond
+            @max_size = Spider.conf.get('storage.db.pool.size')
+            @max_size = provider.max_connections if provider.max_connections && provider.max_connections < @max_size
+            @timeout = Spider.conf.get('storage.db.pool.timeout')
+            @retry = Spider.conf.get('storage.db.pool.retry')
+            @connections = []
+            @free_connections = []
+            # if Spider.runmode == 'devel'
+            #     Thread.new do
+            #         loop do
+            #             Spider.logger.debug("DB Pool: #{@connections.length} connections, #{@free_connections.length} free")
+            #             sleep(10)
+            #         end
+            #     end
+            # end
+        end
+        
+        def size
+            @connections.length
+        end
+        
+        def free_size
+            @free_connections.length
+        end
+
+        def get_connection
+            Thread.current[:db_connections] ||= {}
+            @connection_mutex.synchronize do
+                if conn = Thread.current[:db_connections][@connection_params]
+                    # Spider.logger.debug("DB Pool (#{Thread.current}): returning thread connection #{conn}")
+                    @free_connections.delete(conn)
+                    conn
+                else
+                    Thread.current[:db_connections][@connection_params] = _checkout
+                end
+            end
+        end
+        
+        def checkout
+            @connection_mutex.synchronize do
+                _checkout
+            end
+        end
+        
+        def release(conn)
+            @connection_mutex.synchronize do
+                # Spider.logger.debug("DB Pool (#{Thread.current}): releasing #{conn}")
+                @free_connections << conn
+                @queue.signal
+                Thread.current[:db_connections].delete(@connection_params)
+            end
+        end
+        
+        def remove(conn)
+            @connection_mutex.synchronize do
+                remove_connection(conn)
+            end
+        end
+        
+        def clear
+            @connections.each do |c|
+                @provider.disconnect(c)
+            end
+            @connections = []
+            @free_connections = []
+        end
+        
+        private
+        
+        def _checkout
+            # Spider.logger.debug("DB Pool (#{Thread.current}): checkout (max: #{@max_size})")
+            1.upto(@retry) do
+                if @free_connections.empty?
+                    # Spider.logger.debug("DB Pool (#{Thread.current}): no free connection")
+                    if @connections.length < @max_size
+                        create_new_connection
+                    else
+                        Spider.logger.debug "#{Thread.current} WAITING FOR CONNECTION, #{@queue.count_waiters} IN QUEUE"
+                        unless @queue.wait(@timeout)
+                            raise StorageException, "Unable to get a db connection in #{@timeout} seconds" if @timeout
+                        end
+                    end
+                else
+                    # Spider.logger.debug("DB Pool (#{Thread.current}): had free connection")
+                end
+                conn = @free_connections.pop
+                if @provider.connection_alive?(conn)
+                    # Spider.logger.debug("DB Pool (#{Thread.current}): returning #{conn} (#{@free_connections.length} free)")
+                    return conn
+                else
+                    remove(conn)
+                end
+            end
+        end
+        
+        def remove_connection(conn)
+            @free_connections.delete(conn)
+            @connections.delete(conn)
+        end
+        
+        
+        def create_new_connection
+            conn = @provider.new_connection(*@connection_params)
+            Spider.logger.debug("DB Pool (#{Thread.current}): creating new connection #{conn} (#{@connections.length} already in pool)")
+            @connections << conn
+            @free_connections << conn
+        end
+
+
+
+    end
+
+
+end; end; end; end

data/lib/spiderfw/model/storage/db/db_connector.rb

@@ -0,0 +1,9 @@
+module Spider; module Model; module Storage; module Db
+    
+    module DbConnector
+        
+        
+    end
+    
+    
+end; end; end; end

data/lib/spiderfw/model/storage/db/db_schema.rb

@@ -0,0 +1,233 @@
+require 'spiderfw/model/storage/schema'
+
+module Spider; module Model; module Storage; module Db
+    
+    # The class describind the DB table(s) associated to a model.
+    
+    class DbSchema < Spider::Model::Storage::Schema
+        # An Hash of db names for each named sequence.
+        attr_reader :sequences
+        # An Hash of column definitions for each element:
+        # {:element_name => {:name => 'COLUMN_NAME', :attributes => {...}}}
+        attr_reader :columns
+        # An Hash of column definitions for foreign keys:
+        # {:element_name => {:primary_key_name => {:name => 'FOREIGN_COLUMN', :attributes => {...}}}}
+        attr_reader :foreign_keys
+        # An Hash of elements without primary columns.
+        attr_reader :pass
+        
+        def initialize()
+            super
+            @columns = {}
+            @foreign_keys = {}
+            @junction_tables = {}
+            @sequences = {}
+            @pass = {}
+            @foreign_key_constraints = []
+        end
+        
+        # Returns the main table name.
+        def table
+            return @table
+        end
+        
+        # Sets the main table name.
+        def table=(table)
+            table = Table.new(table) unless table.is_a?(Table)
+            @table = table
+        end
+        alias :set_table :table=
+        
+        # Returns the db column defined for the element.
+        def field(element_name)
+            if (@columns[element_name])
+                return @columns[element_name]
+            elsif (@foreign_keys[element_name])
+                unless @foreign_keys[element_name].length == 1 # FIXME!!
+                    raise SchemaException, "No single field for element #{element_name}" 
+                end
+                @foreign_keys[element_name].each do |key, val|
+                    return val
+                end
+            end
+            return nil
+        end
+        
+        # Returns column attributes for given element name.
+        def attributes(element_name)
+            return nil if (!@columns[element_name])
+            return @columns[element_name].attributes
+        end
+
+        # Returns the column for element_name, prefixed with the table name.
+        def qualified_field(element_name, qualifier=nil)
+            raise SchemaException, "No DB field defined in table #{@table} for element #{element_name}" unless f = field(element_name)
+            qualifier ||= @table.name
+            return qualifier + '.' + f.name
+        end
+
+        # Returns the defined foreign key column for given element and primary key
+        def foreign_key_field(element_name, key_name)
+            return nil unless @foreign_keys[element_name]
+            return @foreign_keys[element_name][key_name]
+        end
+        
+        # Returns table_name + '.' + #foreign_key_field
+        def qualified_foreign_key_field(element_name, key_name)
+            return @table.name + '.' + foreign_key_field(element_name, key_name).name
+        end
+        
+        # True if element_name has a defined column or foreign key.
+        def has_fields?(element_name)
+            return (@columns[element_name] || @foreign_keys[element_name]) ? true : false
+        end
+
+        def has_foreign_fields?(element_name)
+            return @foreign_keys[element_name] ? true : false
+        end
+        
+        # Returns the column name for an element.
+        def column(element_name)
+            return @columns[element_name]
+        end 
+        
+        # Sets the column name for an element.
+        def set_column(element_name, field)
+            field = Field.new(@table, field[:name], field[:type], field[:attributes] || {}) if field.is_a?(Hash)
+            @columns[element_name] = field
+        end
+        
+        # Sets a foreign key to the primary key of an element.
+        def set_foreign_key(element_name, element_key, field)
+            field = Field.new(@table, field[:name], field[:type], field[:attributes] || {}) if field.is_a?(Hash)
+            @foreign_keys[element_name] ||= {}
+            @foreign_keys[element_name][element_key] = field
+        end
+        
+        def set_foreign_key_constraint(name, table, keys, options={})
+            @foreign_key_constraints << ForeignKeyConstraint.new(name, table, keys, options)
+        end
+        
+        
+        # Sets the db name for a named sequence.
+        def set_sequence(name, db_name)
+            @sequences[name] = db_name
+        end
+        
+        # Sets that given element has no associated db field.
+        def set_nil(name)
+            @pass[name] = true
+        end
+        
+        # Returns the db name of a named sequence.
+        def sequence(name)
+            @sequences[name]
+        end
+        
+        # Returns a description of all the tables used by the model.
+        # Returns a struct in the form
+        #   {table_name => :columns => {
+        #     'column_name' => {:type => 'column_type', :attributes => {:attr => true, :attr2 => 'some_val, ...}}
+        #   }, :attributes => {
+        #     :primary_key => 'primary_key_column', ...
+        #   }}
+        def get_schemas
+            schemas = {}
+            schemas[@table.name] = {:columns => {}, :attributes => {}}
+            @columns.each do |element, column|
+                schemas[@table.name][:columns][column.name] = {:type => column.type, :attributes => column.attributes}
+            end
+            @foreign_keys.each_key do |element|
+                @foreign_keys[element].each do |key, column|
+                    schemas[@table.name][:columns][column.name] = {:type => column.type, :attributes => column.attributes}
+                end
+            end
+            schemas[@table.name][:attributes][:primary_keys] = primary_keys.map{ |k| k.name }
+            schemas[@table.name][:attributes][:foreign_key_constraints] = @foreign_key_constraints
+            return schemas
+        end
+        
+        # Primary key column(s)
+        def primary_keys
+            @table.fields.select{ |f| f.primary_key? }
+        end
+        
+        
+    end
+    
+    class Table
+        attr_reader :name, :fields, :attributes
+        
+        def initialize(name, attributes={})
+            @name = name
+            @attributes = attributes
+            @fields = []
+        end
+        
+        def add_field(field)
+            @fields << field
+        end
+        
+        def to_s
+            @name
+        end
+        
+    end
+    
+    class Field
+        attr_reader :name, :table
+        attr_accessor :type
+        attr_accessor :attributes
+        
+        def initialize(table, name, type, attributes={})
+            @table = table
+            @name = name.to_s
+            @type = type
+            @attributes = attributes
+            @table.add_field(self)
+        end
+        
+        
+        def primary_key
+            @attributes[:primary_key]
+        end
+        alias :primary_key? :primary_key
+        
+        def primary_key=(val)
+            @attributes[:primary_key] = true
+        end
+        
+        
+        def to_s
+            "#{@table.name}.#{@name}"
+        end
+        
+        def inspect
+            "#<#{self.class.name}:#{self.object_id} @name=\"#{@name}\", @table=#<Spider::Model::Storage::Db::Table:0x6d3ff94 #{@table.name}> >"
+        end
+        
+    end
+    
+    class ForeignKeyConstraint
+        attr_reader :name, :table, :fields, :options
+        
+        def initialize(name, table, fields, options={})
+            @name = name.to_s
+            @table = table
+            @fields = fields
+            @options = options
+        end
+        
+        def ==(other)
+            other.table == @table && other.fields == @fields && other.options == @options
+        end
+        
+        def eq?(other)
+            self ==  other
+        end
+        
+    end
+    
+
+    
+end; end; end; end