dbagile 0.0.1 → 0.0.2

data/lib/dbagile.rb

@@ -2,7 +2,7 @@ require 'dbagile/loader'
 module DbAgile
   
   # Version of the DbAgile interface
-  VERSION = "0.0.1".freeze
+  VERSION = "0.0.2".freeze
   
   # Domains recognized as valid domains inside a SQL database
   RECOGNIZED_DOMAINS = [
@@ -52,7 +52,7 @@ module DbAgile
     DbAgile::Environment.default
   end
   module_function :default_environment
-
+  
 end # module DbAgile
 require 'dbagile/robustness'
 require 'dbagile/errors'

data/lib/dbagile/adapter/sequel/data/transaction_driven.rb

@@ -16,6 +16,7 @@ module DbAgile
           else
             db[table_name].where(proj).update(update)
           end 
+          update
         end
     
         # @see DbAgile::Contract::Data::TransactionDriven#delete

data/lib/dbagile/adapter/sequel/schema/concrete_script.rb

@@ -10,6 +10,24 @@ module DbAgile
           buffer
         end
         
+        def create_view(conn, op, buffer)
+          tname = conn.send(:quote_schema_table, op.table_name)
+          buffer <<  "CREATE VIEW #{tname} AS #{op.relview.definition};" << "\n"
+          staged!(op)
+        rescue Sequel::Error => ex
+          buffer << "-- UNSUPPORTED: #{op.to_sql92}" << "\n"
+          unsupported!(op)
+        end
+        
+        def drop_view(conn, op, buffer)
+          tname = conn.send(:quote_schema_table, op.table_name)
+          buffer <<  "DROP VIEW #{tname};" << "\n"
+          staged!(op)
+        rescue Sequel::Error => ex
+          buffer << "-- UNSUPPORTED: #{op.to_sql92}" << "\n"
+          unsupported!(op)
+        end
+        
         def create_table(conn, op, buffer)
           gen = Sequel::Schema::Generator.new(conn)
           build_sequel_expand_generator(conn, op, gen, "")

data/lib/dbagile/adapter/sequel/schema/table_driven.rb

@@ -43,7 +43,16 @@ module DbAgile
     
         # @see DbAgile::Contract::Schema::TableDriven#keys
         def keys(table_name)
-          db.indexes(table_name).values.select{|i| i[:unique] == true}.collect{|i| i[:columns]}.sort{|a1, a2| a1.size <=> a2.size}
+          # take the indexes
+          indexes = db.indexes(table_name).values
+          indexes = indexes.select{|i| i[:unique] == true}.collect{|i| i[:columns]}.sort{|a1, a2| a1.size <=> a2.size}
+
+          # take single keys as well
+          key = db.schema(table_name).select{|pair|
+            pair[1][:primary_key]
+          }.collect{|pair| pair[0]}
+
+          key.empty? ? indexes : (indexes + [ key ])
         end
     
       end # module TableDriven

data/lib/dbagile/adapter/sequel/sequel_tracer.rb

@@ -1,3 +1,4 @@
+require 'logger'
 module DbAgile
   class SequelAdapter
     class SequelTracer

data/lib/dbagile/command/bulk/commons.rb

@@ -59,8 +59,8 @@ module DbAgile
 
         # Adds the format options for output
         def add_output_format_options(opt)
-          opt.on('--format=X', [:csv, :text, :json, :yaml, :ruby, :xml],
-                 "Export dataset in (csv, text, json, yaml, ruby, xml)") do |value|
+          opt.on('--format=X', [:csv, :text, :json, :yaml, :ruby, :xml, :html],
+                 "Export dataset in (csv, text, json, yaml, ruby, xml, html)") do |value|
             self.format = value
           end
           opt.on("--csv",  "Export dataset in csv (default)"){ self.format = :csv }
@@ -68,6 +68,7 @@ module DbAgile
           opt.on("--json", "Export dataset in json"){ self.format = :json }
           opt.on("--yaml", "Export dataset in yaml"){ self.format = :yaml }
           opt.on("--xml",  "Export dataset in xml"){ self.format = :xml }
+          opt.on("--html",  "Export dataset in html"){ self.format = :html }
           opt.on("--ruby", "Export dataset as ruby code"){ self.format = :ruby }
         end
       
@@ -123,6 +124,10 @@ module DbAgile
             io_options[:text][:append_with] = '...'
           end
         end
+
+        # Adds output HTML options 
+        def add_html_output_options(opt)
+        end
        
       end # module Commons
     end # module Bulk

data/lib/dbagile/command/bulk/export.rb

@@ -39,6 +39,10 @@ module DbAgile
           opt.separator "\nTEXT options:"
           add_text_output_options(opt)
 
+          # HTML output options
+          opt.separator "\nHTML options:"
+          add_html_output_options(opt)
+
           # JSON output options
           opt.separator "\nJSON options:"
           add_json_output_options(opt)
@@ -85,7 +89,6 @@ module DbAgile
             # Export it
             with_io{|io| 
               method = "to_#{self.format}".to_sym
-              io = environment.output_buffer
               options =  io_options[self.format]
               options[:type_system] = self.type_system if self.type_system
               ds.send(method, io, options)

data/lib/dbagile/command/bulk/import.rb

@@ -23,6 +23,9 @@ module DbAgile
         # Truncate table?
         attr_accessor :truncate_table
             
+        # Update tuple when key already exists?
+        attr_accessor :update_on_existing
+            
         # Contribute to options
         def add_options(opt)
           # Main output options
@@ -48,9 +51,13 @@ module DbAgile
           opt.on('--trace-sql', "Trace SQL statements on STDOUT (but executes them)") do |value|
             self.conn_options[:trace_sql] = true
           end
+          opt.on("--update", "-u", "Update tuple instead of insert when key already exists") do |value|
+            self.update_on_existing = true
+          end
           opt.on('--dry-run', "Trace SQL statements on STDOUT only, do nothing on the database") do |value|
             self.conn_options[:trace_sql] = true
             self.conn_options[:trace_only] = true
+            self.conn_options[:trace_buffer] = environment.output_buffer
           end
 
           opt.separator "\nRecognized format options:"
@@ -106,7 +113,7 @@ module DbAgile
         # Executes the command
         def execute_command
           with_current_connection(conn_options) do |connection|
-        
+                  
             # Make the job now
             connection.transaction do |t|
               first = true
@@ -119,10 +126,33 @@ module DbAgile
           end
         end
       
+        def find_key(t, tuple)
+          t.keys(self.dataset).find{|key|
+            key.all?{|k| tuple.has_key?(k)}
+          }
+        end
+      
         # Makes the insert job
         def make_the_job(t, tuple, first = true)
           handle_schema_modification(t, tuple) if first
-          t.insert(self.dataset, tuple)
+          if self.update_on_existing 
+            
+            # find a candidate key
+            key = find_key(t, tuple)
+            if key.nil?
+              raise DbAgile::CandidateKeyNotFoundError, "Unable to find a candidate key for UPDATE"
+            end
+
+            # Make insert or update according to key
+            key_value = tuple_project(tuple, key)
+            if t.exists?(self.dataset, key_value)
+              t.update(self.dataset, tuple, key_value)
+            else
+              t.insert(self.dataset, tuple)
+            end
+          else
+            t.insert(self.dataset, tuple)
+          end
         end
       
         # Handles the schema modifications

data/lib/dbagile/command/schema/check.rb

@@ -4,7 +4,7 @@ module DbAgile
       #
       # Check a database schema
       #
-      # Usage: dba #{command_name} [SCHEMA.yaml|announced|effective|physical]
+      # Usage: dba #{command_name} [options] [SCHEMA.yaml|announced|effective|physical]
       #
       # This command informs you about bad smells and good practices with relational
       # schemas (i.e. forgetting to create keys, not providing unique constraint 
@@ -33,6 +33,7 @@ module DbAgile
         # Contribute to options
         def add_options(opt)
           self.check_schemas = false
+          add_stdin_options(opt)
         end
         
         # Executes the command

data/lib/dbagile/command/schema/commons.rb

@@ -6,6 +6,9 @@ module DbAgile
         # Checks schema(s) first?
         attr_accessor :check_schemas
       
+        # Take schema on standard input?
+        attr_accessor :on_stdin
+      
         # Schema arguments
         attr_accessor :schema_arguments
       
@@ -17,6 +20,13 @@ module DbAgile
           end
         end
         
+        # Adds --stdin option
+        def add_stdin_options(opt)
+          opt.on('--stdin', "Take schema on the standard command input") do
+            self.on_stdin = true
+          end
+        end
+        
         # Normalizes a schema argument
         def normalize_schema_argument(argument)
           if File.exists?(argument) and File.file?(argument)
@@ -31,7 +41,7 @@ module DbAgile
           @schema_arguments = case kind_of_schema_arguments
             when :single
               if arguments.empty?
-                [ :announced ]
+                on_stdin ? [ :stdin ] : [ :announced ]
               elsif arguments.size == 1
                 arguments.collect{|arg| normalize_schema_argument(arg) }
               else
@@ -64,6 +74,11 @@ module DbAgile
         # Loads a given schema from a schema argument
         def load_schema(schema_argument, check = self.check_schemas)
           schema = case schema_argument
+            when :stdin
+              r = environment.input_buffer.read
+              s = DbAgile::Core::Schema::yaml_load(r)
+              s.schema_identifier = "--stdin"
+              s
             when Symbol
               with_current_database do |database|
                 case schema_argument

data/lib/dbagile/command/schema/dump.rb

@@ -4,13 +4,32 @@ module DbAgile
       #
       # Dump a schema of the current database
       #
-      # Usage: dba #{command_name} [announced|effective|physical]
+      # Usage: dba #{command_name} [options] [announced|effective|physical]
       #
       # This command dumps the schema of the current database on the output console. 
       # Without argument, the announced schema is implicit. This command uses the 
       # fallback chain (announced -> effective -> physical) and has no side-effect 
       # on the database itself (read-only).
       #
+      # Schema filtering is possible via the --include and --exclude options, which
+      # allow including/excluding specific schema object kinds. When used conjointly, 
+      # the semantics is '--include AND NOT(--exclude)'. The different object kinds
+      # are:
+      #   * logical            (all logical objects, see indented list below)
+      #     * table            (base tables)
+      #     * view             (derived tables, aka views)
+      #     * constraint       (all constraints, see indented list below)
+      #       * candidate_key  (all candidate keys, primary or not)
+      #       * primary_key    (all primary keys)
+      #       * foreign_key    (all foreign keys)
+      #   * physical           (all physical objects, see indented list below)
+      #     * index            (all physical indexes)
+      #
+      # A typical usage of schema filtering is to generate a script that drops all 
+      # constraints at once by chaining this command with sql-script:
+      #
+      #   dba schema:dump --include=constraint | dba schema:sql-script --stdin drop
+      #
       # NOTE: Schema-checking is on by default, which may lead to checking errors, 
       #       typically when reverse engineering poorly designed databases. Doing so 
       #       immediately informs you about a potential problem.
@@ -21,22 +40,84 @@ module DbAgile
         include Schema::Commons
         Command::build_me(self, __FILE__)
         
+        QUERIES = {
+          :logical       => [:logical?],
+          :table         => [:attribute?, :constraint?],
+          :view          => [:relview?],
+          :constraint    => [:constraint?],
+          :candidate_key => [:candidate_key], 
+          :primary_key   => [:primary_key],
+          :foreign_key   => [:foreign_key],
+          :physical      => [:physical?],
+          :index         => [:index?]
+        }
+        
+        # Returns :single
+        def kind_of_schema_arguments
+          :single
+        end
+        
+        # Include and exclude options
+        attr_accessor :include_kind, :exclude_kind
+        
+        # Marks a kind a begin included
+        def include_kind!(kind)
+          if queries = QUERIES[kind]
+            self.include_kind ||= []
+            self.include_kind += queries
+          else
+            raise DbAgile::Error, "Unrecognized object kind #{kind}"
+          end
+        end
+        
+        # Marks a kind a begin excluded
+        def exclude_kind!(kind)
+          if queries = QUERIES[kind]
+            self.exclude_kind ||= []
+            self.exclude_kind += queries
+          else
+            raise DbAgile::Error, "Unrecognized object kind #{kind}"
+          end
+        end
+        
         # Contribute to options
         def add_options(opt)
           opt.separator nil
           opt.separator "Options:"
           add_check_options(opt)
+          add_stdin_options(opt)
+          opt.on('--include=x,y,z', Array, 
+                 "Include object kinds (logical, physical, candidate_key, ...)") do |values|
+            values.each{|value| include_kind!(value.to_sym)}
+          end
+          opt.on('--exclude=x,y,z', Array, 
+                 "Exclude object kinds (logical, physical, candidate_key, ...)") do |values|
+            values.each{|value| exclude_kind!(value.to_sym)}
+          end
         end
         
-        # Returns :single
-        def kind_of_schema_arguments
-          :single
+        # Returns the kind of an object
+        def include?(obj)
+          if include_kind && !include_kind.any?{|kind| obj.send(kind)}
+            return false
+          end
+          if exclude_kind && exclude_kind.any?{|kind| obj.send(kind)}
+            return false
+          end
+          true
+        end
+        
+        # Filters the schema according to --select and --reject 
+        # options.
+        def filter_shema(schema)
+          schema.filter{|obj| include?(obj)}
         end
       
         # Executes the command
         def execute_command
           with_schema do |schema|
             say("# Schema of #{schema.schema_identifier.inspect}", :magenta)
+            schema = filter_shema(schema)
             flush(schema.to_yaml)
             schema
           end

data/lib/dbagile/command/schema/sql_script.rb

@@ -49,6 +49,7 @@ module DbAgile
           opt.separator nil
           opt.separator "Options:"
           add_check_options(opt)
+          add_stdin_options(opt)
         end
         
         # Returns :single

data/lib/dbagile/contract/data/dataset.rb

@@ -45,6 +45,15 @@ module DbAgile
           DbAgile::IO::XML::to_xml(self, self.columns, buffer, options)
         end
       
+        # 
+        # Outputs this dataset as a HTML string
+        #
+        # @return [...] the buffer itself
+        #
+        def to_html(buffer = "", options = {})
+          DbAgile::IO::HTML::to_html(self, self.columns, buffer, options)
+        end
+      
         # 
         # Outputs this dataset as a Ruby Array of hashes string
         #

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

@@ -117,10 +117,14 @@ module DbAgile
         
         # Starts a relvar section
         def relvar(name, hash = nil, &block)
-          block = lambda{ _natural(hash) } unless block
-          name = coerce_relvar_name(name)
-          relvar = (_peek(:logical)[name] ||= build_relvar(name))
-          _push(:relvar, relvar, &block)
+          if String === hash
+            (_peek(:logical)[name] ||= build_relview(name, hash))
+          else
+            block = lambda{ _natural(hash) } unless block
+            name = coerce_relvar_name(name)
+            relvar = (_peek(:logical)[name] ||= build_relvar(name))
+            _push(:relvar, relvar, &block)
+          end
         rescue SByC::TypeSystem::CoercionError => ex
           invalid!("Invalid relvar definition (#{name}): #{ex.message}")
         end

data/lib/dbagile/core/schema/builder/concept_factory.rb

@@ -18,6 +18,11 @@ module DbAgile
           def build_relvar(name)
             Schema::Logical::Relvar.new(name)
           end
+          
+          # Builds a relvar
+          def build_relview(name, defn)
+            Schema::Logical::Relview.new(name, defn)
+          end
         
           # Builds a heading
           def build_heading

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

@@ -140,7 +140,7 @@ module DbAgile
         end
       
         # @see DbAgile::Core::SchemaObject
-        def part_keys(sort = false)
+        def part_keys(sort = (RUBY_VERSION < "1.9"))
           if sort
             @composite_parts.keys.sort{|k1,k2| k1.to_s <=> k2.to_s}
           else

data/lib/dbagile/core/schema/computations/merge.rb

@@ -14,7 +14,7 @@ module DbAgile
             end
             
             # Computes key differences
-            left_keys, right_keys = left.part_keys(true), right.part_keys(true)
+            left_keys, right_keys = left.part_keys, right.part_keys
             left_only  = left_keys - right_keys
             right_only = right_keys - left_keys
             commons    = left_keys & right_keys