dbagile 0.0.1

data/lib/dbagile/core/schema/migrate/abstract_script.rb

@@ -0,0 +1,35 @@
+module DbAgile
+  module Core
+    module Schema
+      module Migrate
+        class AbstractScript
+          include Enumerable
+        
+          # Operations in this abstract script
+          attr_reader :operations
+        
+          # Creates an abstract script instance
+          def initialize
+            @operations = []
+          end
+        
+          # Yields the block with each operation in turn
+          def each(&block)
+            operations.each(&block)
+          end
+        
+          # Pushes operations in this abstract script
+          def <<(*ops)
+            self.operations.push(*ops)
+          end
+        
+        end # class AbstractScript
+      end # module Migrate
+    end # module Schema
+  end # module Core
+end # module DbAgile
+require 'dbagile/core/schema/migrate/operation'
+require 'dbagile/core/schema/migrate/create_table'
+require 'dbagile/core/schema/migrate/drop_table'
+require 'dbagile/core/schema/migrate/expand_table'
+require 'dbagile/core/schema/migrate/collapse_table'

data/lib/dbagile/core/schema/migrate/collapse_table.rb

@@ -0,0 +1,15 @@
+module DbAgile
+  module Core
+    module Schema
+      module Migrate
+        class CollapseTable < Migrate::Operation
+
+          def to_sql92
+            "ALTER TABLE DROP #{ops_to_sql92(operations)}"
+          end
+          
+        end # class CollapseTable
+      end # module Migrate
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/migrate/create_table.rb

@@ -0,0 +1,15 @@
+module DbAgile
+  module Core
+    module Schema
+      module Migrate
+        class CreateTable < Migrate::Operation
+
+          def to_sql92
+            "CREATE TABLE (#{ops_to_sql92(operations)})"
+          end
+          
+        end # class CreateTable
+      end # module Migrate
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/migrate/drop_table.rb

@@ -0,0 +1,15 @@
+module DbAgile
+  module Core
+    module Schema
+      module Migrate
+        class DropTable < Migrate::Operation
+
+          def to_sql92
+            "DROP TABLE #{table_name}"
+          end
+          
+        end # class DropTable
+      end # module Migrate
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/migrate/expand_table.rb

@@ -0,0 +1,15 @@
+module DbAgile
+  module Core
+    module Schema
+      module Migrate
+        class ExpandTable < Migrate::Operation
+          
+          def to_sql92
+            "ALTER TABLE ADD #{ops_to_sql92(operations)}"
+          end
+          
+        end # class ExpandTable
+      end # module Migrate
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/migrate/operation.rb

@@ -0,0 +1,141 @@
+module DbAgile
+  module Core
+    module Schema
+      module Migrate
+        class Operation
+          
+          # The sub operations
+          attr_reader :operations
+        
+          # Targetted relation variable
+          attr_reader :relvar
+          
+          # Returns table name
+          def table_name
+            relvar.name
+          end
+          
+          def initialize(relvar)
+            unless relvar.kind_of?(DbAgile::Core::Schema::Logical::Relvar)
+              raise ArgumentError, "Relvar expected for relvar, got #{relvar.class}"
+            end
+            @relvar = relvar
+            @operations = []
+          end
+          
+          # Returns kind of this operation
+          def kind
+            unqualified = DbAgile::RubyTools::class_unqualified_name(self.class).to_s
+            unqualified.gsub(/[A-Z]/){|x| "_#{x.downcase}"}[1..-1].to_sym
+          end
+          
+          ##########################################################################
+          ### Execution feedback
+          ##########################################################################
+          
+          # Mark an object as upgraded
+          def staged!(obj = relvar)
+            obj.status = case obj.status
+              when Schema::TO_CREATE, Schema::CREATED
+                Schema::CREATED
+              when Schema::TO_ALTER, Schema::ALTERED
+                Schema::ALTERED
+              when Schema::TO_DROP, Schema::DROPPED
+                Schema::DROPPED
+              when Schema::NO_CHANGE
+                Schema::NO_CHANGE
+              else
+                status_str = obj.status.to_s.upcase
+                raise DbAgile::AssumptionFailedError, "Unexpected staged! source status #{status_str} on #{obj}"
+            end
+          end
+          
+          # Mark an object as not being staged
+          def not_staged!(obj = relvar)
+            obj.status = case obj.status
+              when Schema::TO_CREATE
+                Schema::DEFERED
+              when Schema::TO_ALTER
+                Schema::DEFERED
+              when Schema::TO_DROP
+                Schema::DEFERED
+              when Schema::DEFERED
+                Schema::DEFERED
+              when Schema::NO_CHANGE
+                Schema::NO_CHANGE
+              else
+                status_str = obj.status.to_s.upcase
+                raise DbAgile::AssumptionFailedError, "Unexpected staged! source status #{status_str} on #{obj}"
+            end
+          end
+          
+          ##########################################################################
+          ### About sub operations
+          ##########################################################################
+          
+          # Asserts that this operation supports sub operations
+          def supports_sub_operation?(name = nil)
+            !self.kind_of?(Migrate::DropTable)
+          end
+          
+          # Asserts that this operation supports sub operations
+          def supports_sub_operation!(name)
+            unless supports_sub_operation?(name)
+              raise DbAgile::AssumptionFailedError, "#{self.class} does not support sub operation #{name}"
+            end
+          end
+          
+          # Yields the block with each (subop_kind, operand) pair
+          def each_sub_operation(&block)
+            supports_sub_operation!(nil)
+            operations.each{|op| block.call(op[0], op[1])}
+          end
+          
+          # Create/alter an attribute
+          def attribute(attribute)
+            supports_sub_operation!(:attribute)
+            operations << [:attribute, attribute]
+          end
+
+          # Create/alter a candidate key
+          def candidate_key(ckey)
+            supports_sub_operation!(:candidate_key)
+            operations << [:candidate_key, ckey]
+          end
+
+          # Create/alter a foreign key
+          def foreign_key(fkey)
+            supports_sub_operation!(:foreign_key)
+            operations << [:foreign_key, fkey]
+          end
+
+          # Create/alter an index
+          def index(index)
+            supports_sub_operation!(:index)
+            operations << [:index, index]
+          end
+          
+          # Converts operations to simili SQL
+          def ops_to_sql92(ops)
+            ops.collect{|op|
+              kind, operand = op
+              case kind
+                when :attribute
+                  "COLUMN #{operand.name} #{operand.domain}"
+                when :candidate_key
+                  "CANDIDATE KEY #{operand.name})"
+                when :foreign_key
+                  "FOREIGN KEY #{operand.name}"
+                when :index
+                  "INDEX #{operand.name}"
+                else
+                  raise DbAgile::AssumptionFailedError, "Unexpected operation kin #{kind}"
+              end
+            }.join(';')
+          end
+          
+        end # class Operation
+      end # module Migrate
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/migrate/stager.rb

@@ -0,0 +1,282 @@
+module DbAgile
+  module Core
+    module Schema
+      module Migrate
+        class Stager
+      
+          # List of status
+          Status = ::DbAgile::Core::Schema
+          
+          # Default stager options
+          DEFAULT_OPTIONS = {:expand => true, :collapse => true}
+      
+          # The abstract script we build
+          attr_reader :script
+
+          # Helper for each relation variable
+          attr_reader :helpers
+
+          # Status of each object
+          attr_reader :status
+
+          ############################################################################
+          ### Schema info helpers need
+          ############################################################################
+      
+          # Checks if table already exists
+          def relvar_exists?(rv)
+            (rv.status == Status::NO_CHANGE) or
+            (rv.status == Status::TO_ALTER) or 
+            (status[rv] == Status::CREATED)
+          end
+
+          # Asserts that a table exists
+          def relvar_exists!(rv)
+            status[rv] = Status::CREATED
+          end
+
+          ############################################################################
+          ### Public interface
+          ############################################################################
+      
+          #
+          # Runs the staging algorithm on an annotated schema (result of a merge)
+          # and options.
+          #
+          def run(schema, options)
+            @helpers = {}
+            @status = {}
+            @script = Migrate::AbstractScript.new
+        
+            # Take all objects and mark them as :to_ensure
+            all_objects = schema.collect{|o, parent| o}
+            all_objects.each{|o| @status[o] = o.status}
+        
+            # Collapse first
+            if options[:collapse]
+              collapse_objects(all_objects.select{|obj| @status[obj] == Status::TO_DROP})
+            end
+        
+            # Expand then
+            if options[:expand]
+              expand_objects(all_objects.select{|obj| @status[obj] == Status::TO_CREATE})
+            end
+        
+            # clean
+            raise AssumptionFailedError, "Helpers should be empty" unless @helpers.empty?
+            to_return = @script
+            @script = nil
+            @helpers = nil
+            @status = nil
+            to_return
+          end
+      
+          ############################################################################
+          ### Collapse algorithms (for drop)
+          ############################################################################
+
+          # Yields the block with an helper to collapse a relation
+          # variable, creating it if required.
+          def with_collapse_helper(rv)
+            if h = helpers[rv]
+              yield(h)
+            else
+              h = helpers[rv] = Migrate::CollapseTable.new(rv)
+              yield(h)
+              script << h
+              helpers.delete(rv)
+            end
+          end
+
+          # Ensures inexistence of a list of schema objects
+          def collapse_objects(schema_objects)
+            schema_objects.each do |object|
+              case s = status[object]
+                when Status::TO_DROP, Status::TO_ALTER
+                  collapse_object(object)
+                when Status::NO_CHANGE, Status::DROPPED
+                  # nothing to do
+                else
+                  msg = "Unexpected status #{s} for #{object} for schema collapsing"
+                  raise AssumptionFailedError, msg
+              end
+            end
+          end
+      
+          # Ensures inexistence of a single schema object
+          def collapse_object(object)
+            parent = object.parent
+        
+            case status[parent]
+              when Status::DROPPED
+                # nothing do do, parent has certainly removed me
+                status[object] = Status::DROPPED
+              when Status::TO_DROP
+                #
+                # Delegate to parent if it needs to be collapsed itself
+                #
+                # Making this helps issuing a single DROP TABLE and avoiding 
+                # many ALTER TABLE that will eventually fail (the last column)
+                #
+                collapse_object(parent)
+                status[object] = Status::DROPPED
+              else
+                status[object] = Status::PENDING
+            
+                object.outside_dependents.each{|dep|
+                  collapse_objects([ dep ])
+                }
+
+                collapse_call = :"collapse_#{object.builder_handler}"
+                self.send(collapse_call, object)
+            
+                status[object] = Status::DROPPED
+            end
+          end
+
+          # Collapses a relation variable
+          def collapse_relvar(relvar)
+            script << Migrate::DropTable.new(relvar)
+          end
+
+          # Collapses a candidate key
+          def collapse_candidate_key(ckey)
+            with_collapse_helper(ckey.relation_variable){|h| h.candidate_key(ckey)}
+          end
+
+          # Collapses a foreign key
+          def collapse_foreign_key(fkey)
+            with_collapse_helper(fkey.relation_variable){|h| h.foreign_key(fkey)}
+          end
+
+          # Collapses an attribute
+          def collapse_attribute(attribute)
+            with_collapse_helper(attribute.relation_variable){|h| h.attribute(attribute)}
+          end
+
+          # Collapses an index
+          def collapse_index(index)
+            with_collapse_helper(index.indexed_relvar){|h| h.index(index)}
+          end
+
+          ############################################################################
+          ### Expand algorithms (for alter/create)
+          ############################################################################
+
+          # Yields the block with an helper to expand a relation
+          # variable, creating it if required
+          def with_expand_helper(rv)
+            if h = helpers[rv]
+              yield(h)
+            else
+              # create the operation
+              exists = relvar_exists?(rv)
+              h = exists ? Migrate::ExpandTable.new(rv) : Migrate::CreateTable.new(rv)
+              
+              # execute sub operations and save
+              yield(helpers[rv] = h)
+              script << h
+              
+              # assert that the table now exists
+              unless exists
+                relvar_exists!(rv)
+              end
+              
+              # remove helper now
+              helpers.delete(rv)
+            end
+          end
+
+          # Ensures existence of a list of schema objects.
+          def expand_objects(schema_objects)
+            schema_objects.each do |object| 
+              case s = status[object]
+                when Status::TO_CREATE, Status::TO_ALTER
+                  expand_object(object)
+                when Status::NO_CHANGE, Status::CREATED
+                  # nothing do to
+                else
+                  msg = "Unexpected status #{s} for #{object} for schema expansion"
+                  raise AssumptionFailedError, msg
+              end
+            end
+          end
+      
+          # Ensures existence of a single schema object
+          def expand_object(object)
+            parent = object.parent
+
+            if status[parent] == Status::TO_CREATE
+              #
+              # Delegate to parent if it needs to be ensured itself
+              #
+              # Making this helps issuing a single CREATE TABLE instead of 
+              # many ALTER TABLE statements, which are not always supported
+              # by adapters.
+              #
+              expand_object(parent)
+            else
+              # Mark the object as being currently created
+              status[object] = Status::PENDING
+    
+              # ensure dependencies
+              expand_objects(object.outside_dependencies)
+    
+              # ensure itself and recurse on children
+              expand_call = :"expand_#{object.builder_handler}"
+              if object.composite?
+                # ensure composite objects
+                if self.respond_to?(expand_call)
+                  self.send(expand_call, object){ expand_objects(object.parts) }
+                else
+                  expand_objects(object.parts)
+                end
+              else
+                # ensure part objects
+                self.send(expand_call, object)
+              end
+
+              # mark object as ensured!
+              status[object] = Status::CREATED
+            end
+          end
+
+          ### Composites
+
+          def expand_relvar_xxx(xxx)
+            with_expand_helper(rv = xxx.relation_variable){|helper| yield}
+          end
+          alias :expand_relvar :expand_relvar_xxx
+          alias :expand_heading :expand_relvar_xxx
+
+          ### Parts
+
+          def expand_attribute(attribute)
+            with_expand_helper(rv = attribute.relation_variable){|helper|
+              helper.attribute(attribute)
+            }
+          end
+
+          def expand_candidate_key(ckey)
+            with_expand_helper(rv = ckey.relation_variable){|helper|
+              helper.candidate_key(ckey)
+            }
+          end
+
+          def expand_foreign_key(fkey)
+            with_expand_helper(rv = fkey.relation_variable){|helper|
+              helper.foreign_key(fkey)
+            }
+          end
+
+          def expand_index(index)
+            with_expand_helper(rv = index.indexed_relvar){|helper|
+              helper.index(index)
+            }
+          end
+
+        end # class Stager
+      end # module Migrate
+    end # module Schema
+  end # module Core
+end # module DbAgile

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

@@ -0,0 +1,2 @@
+require 'dbagile/core/schema/migrate/abstract_script'
+require 'dbagile/core/schema/migrate/stager'

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

@@ -0,0 +1,114 @@
+module DbAgile
+  module Core
+    module Schema
+      class Part < SchemaObject
+        
+        # Object name
+        attr_reader :name
+        
+        # Object definition
+        attr_reader :definition
+      
+        # Creates a part instance
+        def initialize(name, definition)
+          @name = name
+          @definition = definition
+        end
+        
+        # Makes a sanity check on the part
+        def _sanity_check(schema)
+          raise SchemaInternalError, "No name provided on #{self}" if name.nil?
+          raise SchemaInternalError, "No definition provided on #{self}" if definition.nil?
+        end
+        
+        # Checks this composite's semantics and collect errors
+        def _semantics_check(clazz, buffer)
+        end
+        
+        ############################################################################
+        ### Schema typing
+        ############################################################################
+        
+        # Returns true if this object is a logical object, false otherwise
+        def logical?
+          relvar? or attribute? or constraint?
+        end
+        
+          # Returns true if this object is a relation variable, false otherwise
+          def relvar?
+            self.kind_of?(Schema::Logical::Relvar)
+          end
+        
+          # Returns true if this object is an attribute, false otherwise
+          def attribute?
+            self.kind_of?(Schema::Logical::Attribute)
+          end
+        
+          # Returns true if this object is a constraint, false otherwise
+          def constraint?
+            self.kind_of?(Schema::Logical::Constraint)
+          end
+      
+            # Returns true if this object is a candidate key, false otherwise
+            def candidate_key?
+              self.kind_of?(Schema::Logical::Constraint::CandidateKey)
+            end
+      
+            # Returns true if this object is a primary key, false otherwise
+            def primary_key?
+              self.candidate_key? and self.primary?
+            end
+      
+            # Returns true if this object is a foreign key, false otherwise
+            def foreign_key?
+              self.kind_of?(Schema::Logical::Constraint::ForeignKey)
+            end
+      
+        # Returns true if this object is a physical object, false otherwise
+        def physical?
+          index?
+        end
+        
+          # Returns true if this object is an index, false otherwise
+          def index?
+            self.kind_of?(Schema::Physical::Index)
+          end
+        
+        ############################################################################
+        ### Schema::SchemaObject
+        ############################################################################
+        
+        # Returns an array with part dependencies
+        def dependencies(include_parent = false)
+          include_parent ? [ parent ] : []
+        end
+        
+        # @see DbAgile::Core::Schema
+        def visit(&block)
+          block.call(self, parent)
+        end
+        
+        ############################################################################
+        ### Equality and hash code
+        ############################################################################
+      
+        # Compares with another part
+        def look_same_as?(other)
+          return nil unless other.kind_of?(self.class)
+          (name == other.name) and (definition == other.definition)
+        end
+        
+        # Duplicates this part
+        def dup
+          self.class.new(name, definition.dup)
+        end
+        
+        # Returns a string representation
+        def to_s
+          "#{DbAgile::RubyTools::unqualified_class_name(self.class)}: #{name} #{definition.inspect}"
+        end
+
+      end # class Part
+    end # module Schema
+  end # module Core
+end # module DbAgile