dbagile 0.0.1

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

@@ -0,0 +1,144 @@
+module DbAgile
+  class SequelAdapter
+    class SequelTracer
+      include DbAgile::Contract::Utils::Delegate
+    
+      ### INIT AND OPTIONS #########################################################
+    
+      # Default options of this adapter
+      DEFAULT_OPTIONS = {
+        :trace_sql    => false,
+        :trace_only   => false,
+        :trace_buffer => STDERR
+      }
+      
+      # Adapter delegate 
+      attr_reader :delegate
+      
+      # Creates a tracer instance
+      def initialize(delegate, options)
+        raise ArgumentError, "Connection options should be a Hash" unless options.kind_of?(Hash)
+        @delegate = delegate
+        @options = DEFAULT_OPTIONS.merge(options)
+      end
+      
+      # Tracing is on?
+      def trace?
+        @trace ||= (@options[:trace_sql] && !trace_buffer.nil?)
+      end
+      
+      # Only traces, forget about delegation?
+      def trace_only?
+        @trace_only ||= @options[:trace_only]
+      end
+      
+      # Returns the tracing buffer
+      def trace_buffer
+        @buffer ||= @options[:trace_buffer]
+      end
+      
+      ### UTILS ####################################################################
+      
+      # Returns SQL statement for a given alter table block
+      def alter_table_sql(table_name, &block)
+        generator = ::Sequel::Schema::AlterTableGenerator.new(self, &block)
+        sqls = delegate.db.send(:alter_table_sql_list, table_name, generator.operations).flatten
+        sqls.join("\n")
+      end
+      
+      ### SCHEMA UPDATES ###########################################################
+      
+      # Creates a table with some columns. 
+      def create_table(transaction, table_name, columns)
+        if trace?
+          gen = ::Sequel::Schema::Generator.new(self){
+            columns.each_pair{|name, type| column(name, type)}
+          }
+          sql = delegate.db.send(:create_table_sql, table_name, gen, {})
+          trace(sql)
+        end
+        return super unless trace_only?
+        nil
+      end
+      
+      # Adds some columns to a table
+      def add_columns(transaction, table_name, columns)
+        if trace?
+          trace(alter_table_sql(table_name){ 
+            columns.each_pair{|name, type| add_column(name, type)}
+          })
+        end
+        return super unless trace_only?
+        nil
+      end
+      
+      # Make columns be a candidate key for the table.
+      def key!(transaction, table_name, columns)
+        if trace?
+          trace(alter_table_sql(table_name){ 
+            add_index(columns, :unique => true)
+          })
+        end
+        return super unless trace_only?
+        nil
+      end
+      
+      ### DATA UPDATES #############################################################
+      
+      # Inserts a tuple inside a given table
+      def insert(transaction, table_name, record)
+        if trace?
+          trace(delegate.db[table_name].insert_sql(record)) 
+        end
+        return super unless trace_only?
+        record
+      end
+      
+      # Updates a project of a given table
+      def update(transaction, table_name, proj, update)
+        if trace?
+          trace(delegate.db[table_name].where(proj).update_sql(update)) 
+        end
+        return super unless trace_only?
+        true
+      end
+      
+      # Deletes a projection from a given table
+      def delete(transaction, table_name, proj = {})
+        if trace?
+          if proj.empty?
+            trace(delegate.db[table_name].delete_sql) 
+          else
+            trace(delegate.db[table_name].where(proj).delete_sql) 
+          end
+        end
+        return super unless trace_only?
+        true
+      end
+      
+      # Sends SQL directly to the database SQL server.
+      def direct_sql(transaction, sql)
+        if trace?
+          trace(sql)
+        end
+        return super unless trace_only?
+        nil
+      end
+    
+      ### ABOUT TRACING ############################################################
+    
+      # Traces a SQL statement. Returns true if trace_only, false
+      # otherwise
+      def trace(sql)
+        case out = trace_buffer
+          when Logger
+            out.info(sql)
+          else
+            out << "#{sql}\n"
+        end
+        sql
+      end
+    
+    end # class SequelTracer
+  end # class SequelAdapter
+end # module DbAgile

data/lib/dbagile/adapter/sequel.rb

@@ -0,0 +1,46 @@
+require 'dbagile/adapter/sequel/class_methods'
+require 'dbagile/adapter/sequel/connection'
+
+require 'dbagile/adapter/sequel/data/table_driven'
+require 'dbagile/adapter/sequel/data/transaction_driven'
+
+require 'dbagile/adapter/sequel/schema/physical_dump'
+require 'dbagile/adapter/sequel/schema/schema2sequel_args'
+require 'dbagile/adapter/sequel/schema/concrete_script'
+require 'dbagile/adapter/sequel/schema/table_driven'
+require 'dbagile/adapter/sequel/schema/transaction_driven'
+module DbAgile
+  #
+  # Implements the Adapter contract using Sequel.
+  #
+  class SequelAdapter < Adapter
+    extend SequelAdapter::ClassMethods
+    include SequelAdapter::Connection
+    include SequelAdapter::Data::TableDriven
+    include SequelAdapter::Data::TransactionDriven
+    include SequelAdapter::Schema::TableDriven
+    include SequelAdapter::Schema::TransactionDriven
+    
+    # Underlying database URI
+    attr_reader :uri
+    
+    # Connection options
+    attr_reader :options
+    
+    # Creates an adapter with a given uri
+    def initialize(uri, options = {})
+      @uri, @options = uri, options
+    end
+    
+    # Returns the underlying Sequel::Database instance
+    def db
+      unless @db
+        @db = ::Sequel.connect(uri)
+        @db.logger = @options[:sequel_logger]
+      end
+      @db
+    end
+    
+  end # class SequelAdapter
+end # module DbAgile
+require 'dbagile/adapter/sequel/sequel_tracer'

data/lib/dbagile/adapter.rb

@@ -0,0 +1,15 @@
+module DbAgile
+  class Adapter
+    include DbAgile::Contract::Robust::Helpers
+    include DbAgile::Contract::Utils::Full
+    
+    # Builds an adapter instance from an URI
+    def self.factor(uri, options = {})
+      return uri if uri.kind_of?(Adapter)
+      DbAgile::SequelAdapter.new(uri, options)
+    end
+    def self.[](*args) factor(*args) end
+    
+  end # class Adapter
+end # module DbAgile
+require 'dbagile/adapter/sequel'

data/lib/dbagile/command/api.rb

@@ -0,0 +1,49 @@
+module DbAgile
+  class Command
+    class API
+      include DbAgile::Environment::Delegator
+      
+      # Underlying environment
+      attr_reader :environment
+      
+      # Creates an API instance for a given environment
+      def initialize(environment)
+        @environment = environment
+      end
+      
+      ##############################################################################
+      # Ruby commands
+      ##############################################################################
+      
+      # Returns a dataset instance
+      def dataset(name)
+        environment.with_current_connection{|c|
+          c.dataset(name)
+        }
+      end
+      
+      ##############################################################################
+      # Console subcommands mimics
+      ##############################################################################
+      
+      # Add API methods to Command class
+      DbAgile::Command::each_subclass do |subclass|
+        method_name = DbAgile::Command::ruby_method_for(subclass)
+        module_eval <<-EOF
+          def #{method_name}(*options)
+            options = options.flatten
+            command = DbAgile::Command::command_for(#{subclass.name}, environment)
+            options = DbAgile::Command::build_command_options(options)
+            command.unsecure_run(__FILE__, options)
+          end
+        EOF
+      end
+      
+      # Delegates this api on a environment duplication
+      def dup
+        API.new(environment.dup)
+      end
+      
+    end # class API
+  end # class Command
+end # module DbAgile

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

@@ -0,0 +1,130 @@
+module DbAgile
+  class Command
+    module Bulk
+      module Commons
+      
+        # Output/input format [ruby, csv, json]
+        attr_accessor :format
+      
+        # Connection options
+        attr_accessor :conn_options
+      
+        # Input/output options
+        attr_accessor :io_options
+      
+        # Type system to use
+        attr_accessor :type_system
+      
+        # Dataset whose contents must be shown
+        attr_accessor :dataset
+      
+        # Columns to select
+        attr_accessor :select
+      
+        # Columns to allbut
+        attr_accessor :allbut
+      
+        # Builds default io options
+        def set_default_options
+          self.format = :csv
+          self.type_system = nil
+          self.conn_options = {}
+          self.io_options = Hash.new{|h,k| h[k] = {}}
+        end
+      
+        # Adds the select/allbut options
+        def add_select_options(opt)
+          opt.on('--select x,y,z', Array,
+                 "Select x, y, z columns only") do |value|
+            self.select = value.collect{|c| c.to_sym}
+          end
+          opt.on('--allbut x,y,z', Array,
+                 "Select all but x, y, z columns") do |value|
+            self.allbut = value.collect{|c| c.to_sym}
+          end
+        end
+      
+        def add_typesafe_options(opt)
+          opt.on("--type-safe=[X]", [:ruby], 
+                 "Read/Write type-safe values for (ruby)") do |value|
+            case value
+              when :ruby, NilClass
+                require 'sbyc/type_system/ruby'
+                self.type_system = SByC::TypeSystem::Ruby
+              else
+                raise ArgumentError, "Unknown type system #{value}"
+            end
+          end
+        end
+
+        # 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|
+            self.format = value
+          end
+          opt.on("--csv",  "Export dataset in csv (default)"){ self.format = :csv }
+          opt.on("--text", "Export dataset as a plain text table"){ self.format = :text }
+          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("--ruby", "Export dataset as ruby code"){ self.format = :ruby }
+        end
+      
+        # Adds the format options for input
+        def add_input_format_options(opt)
+          opt.on('--format=X', [:csv, :json, :yaml, :ruby],
+                 "Import dataset from (csv, json, yaml, ruby)") do |value|
+            self.format = value
+          end
+          opt.on("--csv",  "Import dataset from csv (default)"){ self.format = :csv }
+          opt.on("--json", "Import dataset from json"){ self.format = :json }
+          opt.on("--ruby", "Import dataset from ruby code"){ self.format = :ruby }
+          opt.on("--yaml", "Import dataset from yaml"){ self.format = :yaml }
+        end
+      
+        # Adds the CSV options
+        def add_csv_options(opt)
+          opt.on("--headers", "-h", "Read/Write column names on first line") do
+            io_options[:csv][:headers] = true
+          end
+          opt.on("--separator=C", "Use C as column separator character") do |value|
+            io_options[:csv][:col_sep] = value
+          end
+          opt.on("--quote=C", "Use C as quoting character") do |value|
+            io_options[:csv][:quote_char] = value
+          end
+          opt.on("--force-quotes", "Force quoting?") do 
+            io_options[:csv][:force_quotes] = true
+          end 
+          opt.on("--skip-blanks", "Skip blank lines?") do 
+            io_options[:csv][:skip_blanks] = true
+          end 
+        end
+        alias :add_csv_input_options  :add_csv_options
+        alias :add_csv_output_options :add_csv_options
+      
+        # Adds output JSON options 
+        def add_json_output_options(opt)
+          opt.on("--[no-]pretty", "Generate a pretty JSON document") do |value|
+            io_options[:json][:pretty] = value
+          end 
+        end
+       
+        # Adds output TEXT options 
+        def add_text_output_options(opt)
+          opt.on("--wrap-at=X", Integer,
+                 "Wraps table after X's character (no wrap by default)") do |x|
+            io_options[:text][:wrap_at] = x
+          end
+          opt.on("--truncate-at=X", Integer,
+                 "Truncate row lines at X character") do |x|
+            io_options[:text][:truncate_at] = x
+            io_options[:text][:append_with] = '...'
+          end
+        end
+       
+      end # module Commons
+    end # module Bulk
+  end # class Command
+end # module DbAgile

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

@@ -0,0 +1,99 @@
+module DbAgile
+  class Command
+    module Bulk
+      #
+      # Export a table/view/query to (csv, json, yaml, ruby, xml)
+      #
+      # Usage: dba #{command_name} [OPTIONS] DATASET [FILE]
+      #
+      # This command helps exporting data in a SQL database to common transfer 
+      # formats.
+      #
+      class Export < Command
+        include Bulk::Commons
+        Command::build_me(self, __FILE__)
+      
+        # Output file to use
+        attr_accessor :output_file
+      
+        # Contribute to options
+        def add_options(opt)
+          # Main output options
+          opt.separator "\nOutput options:"
+          opt.on("--output=FILE", "-o", "Flush output in FILE (stdout by default)") do |value|
+            self.output_file = value
+          end
+
+          opt.separator "\nRelational options:"
+          add_select_options(opt)
+
+          opt.separator "\nRecognized format options:"
+          add_output_format_options(opt)
+          add_typesafe_options(opt)
+
+          # CSV output options
+          opt.separator "\nCSV options:"
+          add_csv_output_options(opt)
+
+          # CSV output options
+          opt.separator "\nTEXT options:"
+          add_text_output_options(opt)
+
+          # JSON output options
+          opt.separator "\nJSON options:"
+          add_json_output_options(opt)
+        end
+      
+        # Normalizes the pending arguments
+        def normalize_pending_arguments(arguments)
+          case arguments.size
+            when 1
+              self.dataset = valid_argument_list!(arguments, String)
+            when 2
+              raise OptionParser::AmbiguousArgument, '--output-file=#{self.output_file}' if self.output_file
+              self.dataset, self.output_file = valid_argument_list!(arguments, String, String)
+            else
+              bad_argument_list!(arguments)
+          end
+          unless /select|SELECT/ =~ self.dataset
+            self.dataset = self.dataset.to_sym
+          end
+        end
+      
+        # Yields the block with the IO object to use for output
+        def with_io(&block)
+          if self.output_file
+            require 'fileutils'
+            FileUtils.mkdir_p(File.dirname(self.output_file))
+            File.open(self.output_file, "w", &block)
+          else
+            block.call(environment.output_buffer)
+          end
+        end
+      
+        # Executes the command
+        def execute_command
+          with_current_connection do |connection|
+            # Prepare the dataset
+            ds = connection.dataset(self.dataset)
+            if self.select
+              ds = ds.select(*self.select)
+            elsif self.allbut
+              ds = ds.allbut(*self.allbut)
+            end
+        
+            # 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)
+            }
+          end
+        end
+      
+      end # class Export
+    end # module Bulk
+  end # class Command
+end # module DbAgile

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

@@ -0,0 +1,147 @@
+module DbAgile
+  class Command
+    module Bulk
+      #
+      # Import a table from (csv, json, yaml, ruby)
+      #
+      # Usage: dba #{command_name} [OPTIONS] TABLE [FILE]
+      #
+      class Import < Command
+        include Bulk::Commons
+        include ::DbAgile::Tools::Tuple
+        Command::build_me(self, __FILE__)
+      
+        # Input file to use
+        attr_accessor :input_file
+      
+        # Drop table?
+        attr_accessor :drop_table
+      
+        # Create table?
+        attr_accessor :create_table
+      
+        # Truncate table?
+        attr_accessor :truncate_table
+            
+        # Contribute to options
+        def add_options(opt)
+          # Main output options
+          opt.separator "\nInput options:"
+          opt.on("--input=FILE", "-i", "Read input from FILE (stdin by default)") do |value|
+            self.input_file = value
+          end
+
+          opt.separator "\nSQL options:"
+          opt.on("--create-table", "-c", "Create table before inserting values") do |value|
+            self.drop_table = true
+            self.create_table = true
+            self.truncate_table = false
+          end
+          opt.on("--drop-table", "-d", "Drop table before inserting values") do |value|
+            self.drop_table = true
+            self.create_table = true
+            self.truncate_table = false
+          end
+          opt.on("--truncate", "-t", "Truncate table before inserting values") do |value|
+            self.truncate_table = true
+          end
+          opt.on('--trace-sql', "Trace SQL statements on STDOUT (but executes them)") do |value|
+            self.conn_options[:trace_sql] = 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
+          end
+
+          opt.separator "\nRecognized format options:"
+          add_input_format_options(opt)
+          add_typesafe_options(opt)
+        
+          # CSV output options
+          opt.separator "\nCSV options:"
+          add_csv_input_options(opt)
+        end
+      
+        # Normalizes the pending arguments
+        def normalize_pending_arguments(arguments)
+          case arguments.size
+            when 1
+              self.dataset = valid_argument_list!(arguments, Symbol)
+            when 2
+              raise OptionParser::AmbiguousArgument, '--input-file=#{self.input_file}' if self.input_file
+              self.dataset, self.input_file = valid_argument_list!(arguments, Symbol, String)
+            else
+              bad_argument_list!(arguments)
+          end
+        end
+      
+        # Yields the block with the IO object to use for input
+        def with_io(&block)
+          if self.input_file
+            File.open(self.input_file, "r", &block)
+          else
+            block.call(environment.input_buffer)
+          end
+        end
+      
+        # Yields the block with each emitted tuple 
+        def with_emitter(&block)
+          with_io{|io|
+            options = io_options[self.format]
+            options[:type_system] = self.type_system if self.type_system
+            options[:input_file] = self.input_file
+            case self.format
+              when :csv
+                DbAgile::IO::CSV::from_csv(io, options, &block)
+              when :json
+                DbAgile::IO::JSON::from_json(io, options, &block)
+              when :yaml
+                DbAgile::IO::YAML::from_yaml(io, options, &block)
+              when :ruby
+                DbAgile::IO::Ruby::from_ruby(io, options, &block)
+            end
+          }
+        end
+      
+        # Executes the command
+        def execute_command
+          with_current_connection(conn_options) do |connection|
+        
+            # Make the job now
+            connection.transaction do |t|
+              first = true
+              with_emitter do |tuple|
+                make_the_job(t, tuple, first)
+                first = false
+              end
+            end
+          
+          end
+        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)
+        end
+      
+        # Handles the schema modifications
+        def handle_schema_modification(t, tuple)
+          # Handle table creation/deletion/truncation
+          if drop_table
+            t.drop_table(self.dataset) if t.has_table?(self.dataset)
+          end
+          if create_table
+            heading = tuple_heading(tuple)
+            heading = check_tuple_heading(heading, environment)
+            t.create_table(self.dataset, heading)
+          end
+          if truncate_table
+            t.delete(self.dataset, {})
+          end
+        end
+      
+      end # class Import
+    end # module Bulk
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/bulk.rb

@@ -0,0 +1,3 @@
+require 'dbagile/command/bulk/commons'
+require 'dbagile/command/bulk/import'
+require 'dbagile/command/bulk/export'