dbagile 0.0.1

data/lib/dbagile/core/schema/errors.rb

@@ -0,0 +1,173 @@
+module DbAgile
+
+  class Error < StandardError; end
+
+  # Raised when something goes wrong with a schema
+  class SchemaError < DbAgile::Error; end
+
+  # 
+  # Raised when something goes really wrong with a schema. This certainly
+  # indicates a bug inside DbAgile, please report!
+  #
+  # Something wrong happened in DbAgile when using your schema. Please report 
+  # the error to developers:
+  # #{cause.message}
+  # #{cause.backtrace}
+  #
+  class SchemaInternalError < DbAgile::SchemaError; end
+  
+  # 
+  # Raised when an operation on schemas fails because of conflicts (typically
+  # a merge operation without resolver block)
+  #
+  # Database schema conflict between #{left} and #{right}
+  #
+  class SchemaConflictError < DbAgile::SchemaError 
+    
+    # Left schema object
+    attr_reader :left
+    
+    # Right schema object
+    attr_reader :right
+    
+    # Part name
+    attr_reader :part_name
+    
+    # Creates an error instance
+    def initialize(left, right, part_name = nil)
+      @left, @right = left, right
+      @part_name = part_name
+      super(left.parent)
+    end
+    
+    def message
+      "Schema conflict occured on #{left} : #{part_name}"
+    end
+    
+  end # class SchemaConflictError
+  
+  #
+  # Raised when something goes wrong with a schema during a builder 
+  # execution.
+  #
+  # As schema parsing is often made on YAML files, any error at builder
+  # stage is considered a syntax error. However, it includes schema
+  # type checking, which is not that syntactic!
+  #
+  # Syntax error when parsing #{schema_file}: #{cause.message}
+  #
+  class SchemaSyntaxError < DbAgile::SchemaError; end
+  
+  # 
+  # Raised when a schema is semantically not correct.
+  #
+  class SchemaSemanticsError < DbAgile::SchemaError
+    
+    # Object-specific error tree
+    InvalidLogicalSchema          =                           0x1000000          # 
+      InvalidRelvar               = InvalidLogicalSchema  |     0x0100000        #
+        InvalidHeading            = InvalidRelvar         |       0x0010000      #
+          UnsupportedEmptyHeading = InvalidHeading        |         0x0001000    # schema_object=Heading
+          InvalidAttribute        = InvalidHeading        |         0x0002000    #
+            InvalidDefaultValue   = InvalidAttribute      |           0x0000100  # schema_object=Attribute
+        InvalidConstraints        = InvalidRelvar         |       0x0020000      # 
+          MissingPrimaryKey       = InvalidConstraints    |         0x0001000    # schema_object=Relvar
+          InvalidConstraint       = InvalidConstraints    |         0x0002000    # schema_object=Constraint
+            InvalidCandidateKey   = InvalidConstraint     |           0x0000100  # schema_object=CandidateKey
+            InvalidForeignKey     = InvalidConstraint     |           0x0000200  # schema_object=ForeignKey
+    InvalidPhysicalSchema         =                           0x2000000
+      InvalidIndexes              = InvalidPhysicalSchema |     0x0100000        #
+        InvalidIndex              = InvalidIndexes        |       0x0010000      #
+      
+    # General flags  
+    NoSuchRelvar                   = 0x0000001  # :relvar_name
+    NoSuchRelvarAttributes         = 0x0000002  # :relvar_name, :attributes
+    NoSuchCandidateKey             = 0x0000004  # :constraint_name
+    AttributeMismatch              = 0x0000008  # 
+    TargetKeyMismatch              = 0x0000010  # 
+    
+    # User-defined messages
+    MESSAGE_KEYS = [ 
+      InvalidDefaultValue, 
+      UnsupportedEmptyHeading, 
+      MissingPrimaryKey,
+      InvalidConstraint,
+      
+      InvalidIndex,
+      
+      NoSuchRelvar,
+      NoSuchRelvarAttributes,
+      NoSuchCandidateKey,
+      AttributeMismatch,
+      TargetKeyMismatch
+    ]
+    MESSAGE_VALUES = [
+      'invalid default value on attribute #{schema_object.name}',
+      'relvar #{schema_object.relation_variable.name} has an empty heading (unsupported so far)',
+      'relvar #{schema_object.name} has no primary key',
+      'invalid constraint #{schema_object.name} on #{schema_object.relation_variable.name}',
+      
+      'invalid index #{schema_object.name}',
+      
+      'no such relvar #{args[:relvar_name]}',
+      'no such attributes #{args[:attributes].join(\',\')}',
+      'no such candidate key #{args[:constraint_name]}',
+      'attribute mismatch',
+      'target key mismatch'
+    ]
+      
+    # Involved schema object
+    attr_reader :schema
+    
+    # Collected semantical errors
+    attr_reader :errors
+    
+    # Creates an error instance
+    def initialize(schema)
+      @schema = schema
+      @errors = []
+    end
+    
+    # Converts an error to a message
+    def error_to_message(schema_object, error_code, args = {})
+      buffer = []
+      MESSAGE_KEYS.each_with_index{|msg_key, index|
+        next unless msg_key & error_code == msg_key
+        buffer << Kernel.eval('"' + MESSAGE_VALUES[index] + '"', binding)
+      }
+      buffer.join(', ')
+    end
+    
+    # Returns a friendly message
+    def message(long = false)
+      buffer = "Schema #{schema.schema_identifier} contains errors"
+      if long
+        buffer << ":\n"
+        error_messages.each{|m| buffer << "  * " << m << "\n"}
+      end
+      buffer
+    end
+    
+    # Returns an arry of error messages
+    def error_messages
+      errors.collect{|e|error_to_message(*e)}
+    end
+    
+    # Returns number of sub errors
+    def size
+      errors.size
+    end
+    
+    # Is this error empty (no semantics error, then)
+    def empty?
+      @errors.empty?
+    end
+    
+    # Adds a semantics error
+    def add_error(object, error_code, args = {})
+      @errors << [object, error_code, args]
+    end
+    
+  end # class SchemaSemanticsError
+  
+end # module DbAgile

data/lib/dbagile/core/schema/logical/attribute.rb

@@ -0,0 +1,68 @@
+module DbAgile
+  module Core
+    module Schema
+      class Logical
+        class Attribute < Schema::Part
+        
+          ############################################################################
+          ### Attribute
+          ############################################################################
+          
+          # Returns attribute domain
+          def domain
+            definition[:domain]
+          end
+          
+          # Returns default value
+          def default_value
+            definition[:default]
+          end
+        
+          # Returns default value
+          def mandatory?
+            !(definition[:mandatory] == false)
+          end
+        
+          ############################################################################
+          ### Dependency control
+          ############################################################################
+          
+          # @see DbAgile::Core::Schema::SchemaObject
+          def dependencies(include_parent = false)
+            include_parent ? [ parent ] : []
+          end
+          
+          ############################################################################
+          ### Check interface
+          ############################################################################
+          
+          # @see DbAgile::Core::Schema::SchemaObject
+          def _semantics_check(clazz, buffer)
+            unless default_value.nil? or default_value.kind_of?(domain)
+              buffer.add_error(self, clazz::InvalidDefaultValue)
+            end
+          end
+      
+          ############################################################################
+          ### About IO
+          ############################################################################
+        
+          # Delegation pattern on YAML flushing
+          def to_yaml(opts = {})
+            YAML::quick_emit(self, opts){|out|
+              defn = definition
+              out.map("tag:yaml.org,2002:map", :inline ) do |map|
+                map.add('domain', defn[:domain].to_s)
+                map.add('mandatory', false) unless defn[:mandatory]
+                if defn[:default]
+                  map.add('default', defn[:default])
+                end
+              end
+            }
+          end
+          
+        end # class Attribute
+      end # module Logical
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/logical/constraint/candidate_key.rb

@@ -0,0 +1,70 @@
+module DbAgile
+  module Core
+    module Schema
+      class Logical
+        class CandidateKey < Constraint
+        
+          ############################################################################
+          ### Candidate key
+          ############################################################################
+          
+          # Is it a primary key?
+          def primary?
+            definition[:type] == :primary_key
+          end
+          
+          # Returns attribute names
+          def attribute_names
+            definition[:attributes]
+          end
+          
+          # Returns key attributes
+          def key_attributes
+            rv = relation_variable
+            definition[:attributes].collect{|k| rv.heading[k]}
+          end
+          
+          ############################################################################
+          ### Dependency control
+          ############################################################################
+          
+          # @see DbAgile::Core::Schema::SchemaObject
+          def dependencies(include_parent = false)
+            include_parent ? [ parent ] + key_attributes : key_attributes
+          end
+          
+          ############################################################################
+          ### Check interface
+          ############################################################################
+          
+          # @see DbAgile::Core::Schema::SchemaObject
+          def _semantics_check(clazz, buffer)
+            rv = relation_variable
+            unless rv.heading.has_attributes?(definition[:attributes])
+              error_code = clazz::InvalidCandidateKey | clazz::NoSuchRelvarAttributes
+              buffer.add_error(self, error_code, :relvar_name => rv.name, 
+                                                 :attributes  => definition[:attributes])
+            end
+          end
+      
+          ############################################################################
+          ### About IO
+          ############################################################################
+        
+          # Delegation pattern on YAML flushing
+          def to_yaml(opts = {})
+            YAML::quick_emit(self, opts){|out|
+              defn = definition
+              attrs = Schema::Builder::Coercion::unsymbolize_array(definition[:attributes])
+              out.map("tag:yaml.org,2002:map", :inline ) do |map|
+                map.add('type', definition[:type])
+                map.add('attributes', attrs)
+              end
+            }
+          end
+          
+        end # class CandidateKey
+      end # module Logical
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/logical/constraint/foreign_key.rb

@@ -0,0 +1,121 @@
+module DbAgile
+  module Core
+    module Schema
+      class Logical
+        class ForeignKey < Constraint
+        
+          ############################################################################
+          ### Foreign key
+          ############################################################################
+          
+          # Returns relation variable on which this foreign key is installed.
+          def source_relvar
+            relation_variable
+          end
+          alias :referencing_relvar :source_relvar
+          
+          # Collects referencing attributes on the source relvar
+          def source_attributes
+            rv = source_relvar
+            definition[:attributes].collect{|attr_name| rv.heading[attr_name]}
+          end
+          
+          # Returns target relation variable (aka) referenced_relvar
+          def target_relvar
+            schema.logical.relation_variable(definition[:references])
+          end
+          alias :referenced_relvar :target_relvar
+          
+          # Collects referencing attributes on the source relvar
+          def target_key
+            rv = target_relvar
+            if definition.key?(:key)
+              rv.constraints.constraint_by_name(definition[:key])
+            else
+              rv.constraints.primary_key
+            end
+          end
+          
+          ############################################################################
+          ### Dependency control
+          ############################################################################
+          
+          # @see DbAgile::Core::Schema::SchemaObject
+          def dependencies(include_parent = false)
+            deps = source_attributes + [ target_key ]
+            deps << parent if include_parent
+            deps
+          end
+          
+          ############################################################################
+          ### Public check interface
+          ############################################################################
+          
+          # @see DbAgile::Core::Schema::SchemaObject
+          def _semantics_check(clazz, errors)
+            failed = false
+            
+            # 1) check source and target relvars
+            if (srv = source_relvar).nil?
+              raise DbAgile::SchemaInternalError, "Foreign key without source relvar"
+            end
+            if (trv = target_relvar).nil?
+              code = clazz::InvalidForeignKey | clazz::NoSuchRelvar
+              errors.add_error(self, code, :relvar_name => definition[:references])
+              failed = true
+            end
+            return if failed
+            
+            # 2) Both exist, check source attributes
+            if !srv.heading.has_attributes?(definition[:attributes])
+              code = clazz::InvalidForeignKey | clazz::NoSuchRelvarAttributes
+              errors.add_error(self, code, :relvar_name => srv.name,
+                                           :attributes  => definition[:attributes])
+              failed = true
+            end
+            return if failed
+            
+            # 3) Check target key existence and kind now
+            trg_key = self.target_key
+            if trg_key.nil? or not(trg_key.candidate_key?)
+              code = clazz::InvalidForeignKey | clazz::NoSuchCandidateKey
+              errors.add_error(self, code, :constraint_name => definition[:key])
+              failed = true
+            end
+            return if failed
+            
+            source_attrs, target_attrs = source_attributes, trg_key.key_attributes
+            if source_attrs.size != target_attrs.size
+              code = clazz::InvalidForeignKey | clazz::TargetKeyMismatch
+              errors.add_error(self, code, :constraint_name => definition[:key])
+            elsif source_attrs.collect{|a| a.domain} != target_attrs.collect{|a| a.domain}
+              code = clazz::InvalidForeignKey | clazz::TargetKeyMismatch
+              errors.add_error(self, code, :constraint_name => definition[:key])
+            end
+          end
+      
+          ############################################################################
+          ### About IO
+          ############################################################################
+        
+          # Delegation pattern on YAML flushing
+          def to_yaml(opts = {})
+            YAML::quick_emit(self, opts){|out|
+              defn = definition
+              attributes = Schema::Builder::Coercion::unsymbolize_array(definition[:attributes])
+              references = definition[:references].to_s
+              key        = definition.key?(:key) ? definition[:key].to_s : nil
+              out.map("tag:yaml.org,2002:map", :inline ) do |map|
+                map.add('type', definition[:type])
+                map.add('attributes', attributes)
+                map.add('references', definition[:references].to_s)
+                map.add('key', key) unless key.nil?
+              end
+            }
+          end
+
+        end # class ForeignKey
+      end # module Logical
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/logical/constraint.rb

@@ -0,0 +1,58 @@
+module DbAgile
+  module Core
+    module Schema
+      class Logical
+        class Constraint < Schema::Part
+          
+          ############################################################################
+          ### Constraint factory
+          ############################################################################
+        
+          # Builds a constraint
+          def self.factor(name, definition)
+            case kind = definition[:type]
+              when :primary_key, :candidate_key, :key
+                Schema::Logical::CandidateKey.new(name, definition)
+              when :foreign_key
+                Schema::Logical::ForeignKey.new(name, definition)
+              else 
+                raise ArgumentError, "Unexpected constraint kind #{kind}"
+            end
+          end
+
+          ############################################################################
+          ### Query interface
+          ############################################################################
+          
+          # Returns true if this constraint is a candidate key (including a primary 
+          # key)
+          def candidate_key?
+            self.kind_of?(Logical::CandidateKey)
+          end
+          
+          # Returns true if this constraint is a primary key, false otherwise
+          def primary_key?
+            candidate_key? and primary?
+          end
+        
+          # Returns true if this constraint is a foreign key
+          def foreign_key?
+            self.kind_of?(Logical::ForeignKey)
+          end
+          
+          ############################################################################
+          ### Dependency control
+          ############################################################################
+          
+          # @see DbAgile::Core::Schema::SchemaObject
+          def dependencies(include_parent = false)
+            include_parent ? [ parent ] : false
+          end
+          
+        end # class Constraint
+      end # module Logical
+    end # module Schema
+  end # module Core
+end # module DbAgile
+require 'dbagile/core/schema/logical/constraint/candidate_key'
+require 'dbagile/core/schema/logical/constraint/foreign_key'

data/lib/dbagile/core/schema/logical/constraints.rb

@@ -0,0 +1,28 @@
+module DbAgile
+  module Core
+    module Schema
+      class Logical
+        class Constraints < Schema::Composite
+          
+          # Returns the primary key
+          def primary_key
+            each_part{|c|
+              return c if c.kind_of?(Logical::CandidateKey) and c.primary?
+            }
+            nil
+          end
+          
+          # Returns a constraint by name
+          def constraint_by_name(name)
+            self[name]
+          end
+          
+          def to_s
+            "Constraints of #{relation_variable.name}"
+          end
+          
+        end # class Constraints
+      end # class Logical
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/logical/heading.rb

@@ -0,0 +1,47 @@
+module DbAgile
+  module Core
+    module Schema
+      class Logical
+        class Heading < Schema::Composite
+         
+          alias :attributes :parts
+          
+          # Yields the block with each attribute
+          def each_attribute(&block)
+            attributes.each(&block)
+          end
+          
+          # Checks if this heading has some attributes (through 
+          # names)
+          def has_attributes?(names)
+            parts = composite_parts
+            names.all?{|k| parts.key?(k)}
+          end
+          
+          # Returns the domain of a specific attribute
+          def domain_of(attr_name)
+            attribute = self[attr_name]
+            attribute ? attribute.domain : nil
+          end
+        
+          ############################################################################
+          ### Private interface
+          ############################################################################
+          
+          # @see DbAgile::Core::Schema
+          def _semantics_check(clazz, buffer)
+            if empty?
+              buffer.add_error(self, clazz::UnsupportedEmptyHeading)
+            end
+            super(clazz, buffer)
+          end
+          
+          def to_s
+            "Heading of #{relation_variable.name}"
+          end
+          
+        end # class Heading
+      end # class Logical
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/logical/relvar.rb

@@ -0,0 +1,81 @@
+module DbAgile
+  module Core
+    module Schema
+      class Logical
+        class Relvar < Schema::Composite
+          
+          # Relvar name
+          attr_reader :name
+        
+          # Creates a relation variable instance
+          def initialize(name, parts = _default_parts)
+            @name = name.to_s.to_sym
+            super(parts)
+            @insert_order = [ :heading, :constraints ] & parts.keys
+          end
+          
+          ############################################################################
+          ### Private interface
+          ############################################################################
+          
+          # @see DbAgile::Core::Schema::Composite#_install_eigenclass_methods?
+          def _install_eigenclass_methods?
+            true
+          end
+        
+          # Creates default parts
+          def _default_parts
+            {:heading     => Schema::Logical::Heading.new,
+             :constraints => Schema::Logical::Constraints.new}
+          end
+          
+          # Makes a sanity check on the part
+          def _sanity_check(schema)
+            raise SchemaInternalError, "No name provided on #{self}" if name.nil?
+            super(schema)
+          end
+        
+          # Checks this composite's semantics and collects errors inside buffer
+          def _semantics_check(clazz, buffer)
+            if constraints.primary_key.nil?
+              buffer.add_error(self, clazz::MissingPrimaryKey)
+            end
+            super(clazz, buffer)
+          end
+      
+          ############################################################################
+          ### Pseudo-private SchemaObject interface
+          ############################################################################
+          
+          # Returns the arguments to pass to builder handler
+          def builder_args
+            [ name ]
+          end
+
+          ############################################################################
+          ### Equality and hash code
+          ############################################################################
+        
+          # Compares with another attribute
+          def look_same_as?(other)
+            return nil unless other.kind_of?(Relvar)
+            return false unless name == other.name
+            super(other)
+          end
+        
+          # Duplicates this attribute
+          def dup
+            Logical::Relvar.new(name, :heading => heading.dup, :constraints => constraints.dup)
+          end
+          
+          # Returns a string representation
+          def to_s
+            "#{DbAgile::RubyTools::unqualified_class_name(self.class)}: #{name}"
+          end
+          
+          private :_default_parts
+        end # class Relvar
+      end # module Logical
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/logical.rb

@@ -0,0 +1,24 @@
+module DbAgile
+  module Core
+    module Schema
+      class Logical < Schema::Composite
+        
+        # Returns a relation variable by its name
+        def relation_variable(name)
+          self[name]
+        end
+        
+        # Returns an array with part dependencies
+        def dependencies(include_parent = false)
+          []
+        end
+        
+      end # class Logical
+    end # module Schema
+  end # module Core
+end # module DbAgile
+require 'dbagile/core/schema/logical/relvar'
+require 'dbagile/core/schema/logical/heading'
+require 'dbagile/core/schema/logical/attribute'
+require 'dbagile/core/schema/logical/constraints'
+require 'dbagile/core/schema/logical/constraint'