dbagile 0.0.1

data/lib/dbagile/command/sql/send.rb

@@ -0,0 +1,67 @@
+module DbAgile
+  class Command
+    module SQL
+      #
+      # Send SQL commands directly to the DBMS
+      #
+      # Usage: dba #{command_name} [--file=SCRIPT] [QUERY]
+      #
+      class Send < Command
+        Command::build_me(self, __FILE__)
+      
+        # Query to send
+        attr_accessor :query
+      
+        # The file to execute
+        attr_accessor :file
+      
+        # Contribute to options
+        def add_options(opt)
+          opt.separator nil
+          opt.separator "Options:"
+          opt.on("--file=SCRIPT", '-f',
+                 "Executes a whole SQL script file") do |value|
+            self.file = valid_read_file!(value)
+          end
+        end
+      
+        # Normalizes the pending arguments
+        def normalize_pending_arguments(arguments)
+          case arguments.size
+            when 0
+            when 1
+              self.query = valid_argument_list!(arguments, String)
+            else
+              bad_argument_list!(arguments)
+          end
+          ambigous_argument_list! if self.query and self.file
+        end
+      
+        # Executes the command.
+        def execute_command
+          result = nil
+          with_current_connection do |connection|
+            connection.transaction do |t|
+              if self.file
+                result = t.direct_sql(File.read(self.file))
+              elsif self.query
+                result = t.direct_sql(self.query)
+              else
+                script = environment.input_buffer.readlines.join("\n")
+                result = t.direct_sql(script)
+              end
+            end
+          end
+          case result
+            when DbAgile::Contract::Data::Dataset
+              result.to_text(environment.output_buffer)
+            else
+              flush(result)
+          end
+          result
+        end
+      
+      end # class Send
+    end # module SQL
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/sql/show.rb

@@ -0,0 +1,42 @@
+module DbAgile
+  class Command
+    module SQL
+      #
+      # Display content of a table/view/query (shortcut for 'export --text ...')
+      #
+      # Usage: dba #{command_name} [OPTIONS] DATASET
+      #
+      class Show < Command
+        Command::build_me(self, __FILE__)
+      
+        # Contribute to options
+        def add_options(opt)
+          opt.separator nil
+          opt.separator "Options:"
+          opt.on("--[no-]pretty",
+                 "Make/Avoid pretty output (truncate string at terminal size and so on.)") do |value|
+            self.pretty = value
+          end
+        end
+      
+        # Infer options
+        def infer_options(argv)
+          argv = ["--text"] + argv
+          if argv.include?("--no-pretty")
+            argv.delete("--no-pretty")
+          else
+            argv += ["--truncate-at", environment.console_width.to_s]
+          end
+          argv
+        end
+      
+        # Override to avoid pending options to be rejected
+        def unsecure_run(requester_file, argv)
+          DbAgile::dba(environment){|dba| dba.bulk_export(infer_options(argv))}
+          environment.output_buffer
+        end
+      
+      end # class Show
+    end # module SQL
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/sql.rb

@@ -0,0 +1,4 @@
+require 'dbagile/command/sql/show'
+require 'dbagile/command/sql/send'
+require 'dbagile/command/sql/heading'
+require 'dbagile/command/sql/drop'

data/lib/dbagile/command/web/tools.rb

@@ -0,0 +1,23 @@
+module DbAgile
+  class Command
+    module Web
+      #
+      # Start the web tools
+      #
+      # Usage: dba #{command_name} [OPTIONS]
+      #
+      class Tools < Command
+        Command::build_me(self, __FILE__)
+      
+        # Executes the command.
+        def execute_command
+          require 'dbagile/restful/server'
+          DbAgile::Restful::Server.new(environment).start.join
+        rescue Interrupt => ex
+          environment.say("Ciao!")
+        end
+      
+      end # class Tools
+    end # module Web
+  end # class Command
+end # module DbAgile

data/lib/dbagile/command/web.rb

@@ -0,0 +1 @@
+require 'dbagile/command/web/tools'

data/lib/dbagile/command.rb

@@ -0,0 +1,158 @@
+require 'optparse'
+require 'fileutils'
+require 'dbagile/command/robust'
+require 'dbagile/command/class_methods'
+module DbAgile
+  class Command
+    include ::DbAgile::Command::Robust
+    include ::DbAgile::Environment::Delegator
+    extend ::DbAgile::Command::ClassMethods
+    
+    # Command categories
+    CATEGORIES = [:dba, :repo, :db, :sql, :schema, :bulk, :web]
+    
+    # Names of the categories
+    CATEGORY_NAMES = {
+      :dba           => "Main commands:",
+      :repo          => "Repository management:",
+      :db            => "Database management:",
+      :bulk          => "Import/Export management:",
+      :sql           => "SQL:",
+      :schema        => "Database schema:",
+      :web           => "Database and the web:"
+    }
+
+    ##############################################################################
+    ### Instance variables and construction
+    ##############################################################################
+    
+    # Command execution environment
+    attr_reader :environment
+     
+    # Creates an empty command instance
+    def initialize(env)
+      @environment = env
+      set_default_options
+    end
+    
+    # Returns commands category
+    def category
+      self.class.category
+    end
+      
+    # Returns command name
+    def command_name
+      self.class.command_name
+    end
+    
+    # Returns command summary
+    def summary
+      self.class.summary || ""
+    end
+    
+    # Returns command summary
+    def usage
+      self.class.usage || ""
+    end
+    alias :banner :usage
+    
+    def description
+      self.class.description || ""
+    end
+    
+    ##############################################################################
+    ### About options
+    ##############################################################################
+    
+    # Parses commandline options provided as an array of Strings.
+    def options
+      @options ||= OptionParser.new do |opt|
+        opt.program_name = File.basename $0
+        opt.version = DbAgile::VERSION
+        opt.release = nil
+        opt.summary_indent = ' ' * 2
+        opt.banner = self.banner
+        add_options(opt)
+      end
+    end
+    
+    # Sets the default options
+    def set_default_options
+    end
+    
+    # Contribute to options
+    def add_options(opt)
+    end
+    
+    ##############################################################################
+    ### Command info/help and so on.
+    ##############################################################################
+      
+    # Shows the help
+    def show_help
+      display banner
+      display ""
+      display short_help
+      display ""
+    end
+
+    ##############################################################################
+    ### Run logic
+    ##############################################################################
+    
+    # Runs the command
+    def run(requester_file, argv)
+      unsecure_run(requester_file, argv)
+    rescue Exception => ex
+      environment.on_error(self, ex)
+      environment
+    end
+    
+    # Runs the command without catching any error
+    def unsecure_run(requester_file, argv)
+      rest = options.parse!(argv)
+      normalize_pending_arguments(rest)
+      check_command
+      execute_command
+    end
+    
+    # Normalizes the pending arguments
+    def normalize_pending_arguments(arguments)
+      bad_argument_list!(arguments) unless arguments.empty?
+    end
+    
+    # Checks the command
+    def check_command
+    end
+    
+    # Executes the command
+    def execute_command
+    end
+    
+  end # class Command
+end # module DbAgile
+
+# :dba category
+require 'dbagile/command/dba'
+require 'dbagile/command/help'
+
+# :repo category
+require 'dbagile/command/repo'
+
+# :db category
+require 'dbagile/command/db'
+
+# :bulk category
+require 'dbagile/command/bulk'
+
+# :sql category
+require 'dbagile/command/sql'
+
+# :schema category
+require 'dbagile/command/schema'
+
+# :web category
+require 'dbagile/command/web'
+
+# Build Command API now
+require 'dbagile/command/api'

data/lib/dbagile/contract/connection.rb

@@ -0,0 +1,66 @@
+module DbAgile
+  module Contract
+    # Connection driven methods of the contract
+    module Connection
+      
+      # 
+      # Ping the SQL server, returns true if everything is fine. Raises an
+      # error otherwise
+      #
+      # @return true
+      #
+      def ping
+        Kernel.raise NotImplementedError
+      end
+      
+      # 
+      # Ping the SQL server, returns true if everything is fine, false 
+      # otherwise.
+      #
+      def ping?
+        ping
+        true
+      rescue StandardError
+        false
+      end
+      
+      #
+      # Returns the database schema as a DbAgile::Core::Schema instance
+      #
+      def physical_schema
+        Kernel.raise NotImplementedError
+      end
+      
+      # 
+      # Converts a schema abstract script to a SQL script
+      #
+      # @param [DbAgile::Core::Migrate::AbstractScript] a script to run
+      #
+      def script2sql(script, buffer = "")
+        Kernel.raise NotImplementedError
+      end
+        
+      # 
+      # Disconnect the adapter and frees all resources.
+      #
+      # @return true
+      #
+      def disconnect
+        Kernel.raise NotImplementedError
+      end
+    
+      #
+      # Yields the block inside a transaction. 
+      #
+      # Adapters are expected to catch the DbAgile::Errors::AbordTransactionError
+      # and to rollback the transaction without re-raising the error.
+      #
+      # @return [...] block's result
+      #
+      def transaction(&block)
+        Kernel.raise NotImplementedError
+      end
+      
+    end # module Connection
+  end # module Contract
+end # module DbAgile

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

@@ -0,0 +1,69 @@
+module DbAgile
+  module Contract
+    module Data
+      module Dataset
+      
+        # Makes an allbut selection
+        def allbut(*cs)
+          arr = self.columns - cs.flatten
+          select(*arr)
+        end
+      
+        #
+        # Outputs this dataset as a CSV string.
+        #
+        # @return [...] the buffer itself
+        #
+        def to_csv(buffer = "", options = {})
+          DbAgile::IO::CSV::to_csv(self, self.columns, buffer, options)
+        end
+      
+        # 
+        # Outputs this dataset as a JSON string
+        #
+        # @return [...] the buffer itself
+        #
+        def to_json(buffer = "", options = {})
+          DbAgile::IO::JSON::to_json(self.to_a, self.columns, buffer, options)
+        end
+      
+        # 
+        # Outputs this dataset as a YAML string
+        #
+        # @return [...] the buffer itself
+        #
+        def to_yaml(buffer = "", options = {})
+          DbAgile::IO::YAML::to_yaml(self.to_a, self.columns, buffer, options)
+        end
+      
+        # 
+        # Outputs this dataset as a XML string
+        #
+        # @return [...] the buffer itself
+        #
+        def to_xml(buffer = "", options = {})
+          DbAgile::IO::XML::to_xml(self, self.columns, buffer, options)
+        end
+      
+        # 
+        # Outputs this dataset as a Ruby Array of hashes string
+        #
+        # @return [...] the buffer itself
+        #
+        def to_ruby(buffer = "", options = {})
+          DbAgile::IO::Ruby::to_ruby(self, self.columns, buffer, options)
+        end
+      
+        # 
+        # Outputs this dataset as plain text
+        #
+        # @return [...] the buffer itself
+        #
+        def to_text(buffer = "", options = {})
+          DbAgile::IO::Text::to_text(self, self.columns, buffer, options)
+        end
+      
+      end # module Dataset
+    end # module Data
+  end # module Contract
+end # module DbAgile

data/lib/dbagile/contract/data/table_driven.rb

@@ -0,0 +1,49 @@
+module DbAgile
+  module Contract
+    module Data
+      #
+      # Table driven methods of the contract
+      #
+      module TableDriven
+      
+        #
+        # Returns a dataset object for a given table (if a Symbol is given) or query 
+        # (if a String is given). 
+        #
+        # As DbAgile aims at helping to manage SQL database access with respect to their
+        # schema, it does not specifies a detailed contract about the object returned here,
+        # which is related to queries, not schema modification. The kind of returned object
+        # is therefore left open to adapter specfic implementations.
+        #
+        # We expect (mainly for tests) the following about datasets:
+        # - count: returns the number of records inside the dataset
+        # - to_a: returns an array of hashes representing records
+        #
+        # @param [Symbol | String] table_or_query name of a table or query string
+        # @param [Hash | nil] a tuple projection for query restriction
+        # @return [...] a dataset object with query (execution result)
+        #
+        # @pre [table_or_query] all referenced tables must exist
+        #
+        def dataset(table_or_query, proj = nil)
+          Kernel.raise NotImplementedError
+        end
+      
+        # 
+        # Checks if a (sub)-tuple exists inside a table.
+        #
+        # @param [Symbol | String] table_or_query name of a table or query string
+        # @param [Hash] subtuple a tuple or tuple projection for the result
+        # @return true if the projection of the query result on subtuple's heading contains
+        #         the subtuple itself, false otherwise.
+        #
+        # @pre [table_or_query] all referenced tables must exist
+        #
+        def exists?(table_or_query, subtuple = {})
+          Kernel.raise NotImplementedError
+        end
+      
+      end # module TableDriven
+    end # module Data
+  end # module Contract
+end # module DbAgile

data/lib/dbagile/contract/data/transaction_driven.rb

@@ -0,0 +1,74 @@
+module DbAgile
+  module Contract
+    module Data
+      #
+      # Transaction driven methods of the contract
+      #
+      module TransactionDriven
+      
+        #
+        # Inserts a tuple inside a given table
+        #
+        # @param [Transaction] transaction the current transaction
+        # @param [Symbol] table_name the name of a table
+        # @param [Hash] record a record as a hash (column_name -> value)
+        # @return [Hash] inserted record as a hash
+        #
+        # @pre [table_name] the table must exist
+        # @pre [record] the record is valid for the table
+        # @post the record has been inserted.
+        #
+        def insert(transaction, table_name, record)
+          Kernel.raise NotImplementedError
+        end
+      
+        #
+        # Updates all tuples whose projection equal _proj_ with values given by _update_ 
+        # inside a given table
+        #
+        # @param [Transaction] transaction the current transaction
+        # @param [Symbol] table_name the name of a table
+        # @param [Hash] proj a projection tuple
+        # @return [Hash] update the new values for tuples
+        #
+        # @pre [table_name] the table must exist
+        # @pre [update] the record is valid for the table
+        # @pre [proj] the projection tuple is valid for the table
+        # @post all records have been updated.
+        #
+        def update(transaction, table_name, update, proj = {})
+          Kernel.raise NotImplementedError
+        end
+      
+        #
+        # Delete all tuples whose projection equal _proj_ inside a given table
+        #
+        # @param [Transaction] transaction the current transaction
+        # @param [Symbol] table_name the name of a table
+        # @param [Hash] proj a projection tuple
+        #
+        # @pre [table_name] the table must exist
+        # @pre [proj] the projection tuple is valid for the table
+        # @post all records have been updated.
+        #
+        def delete(transaction, table_name, proj = {})
+          Kernel.raise NotImplementedError
+        end
+      
+        #
+        # Send SQL directly to the database SQL server.
+        #
+        # Returned result is left opened to adapters.
+        #
+        # @param [Transaction] transaction the current transaction
+        # @param [String] sql a SQL query
+        # @return [...] adapter defined
+        #
+        def direct_sql(transaction, sql)
+          Kernel.raise NotImplementedError
+        end
+
+      end # module TransactionDriven
+    end # module Data
+  end # module Contract
+end # module DbAgile

data/lib/dbagile/contract/data.rb

@@ -0,0 +1,3 @@
+require 'dbagile/contract/data/dataset'
+require 'dbagile/contract/data/table_driven'
+require 'dbagile/contract/data/transaction_driven'

data/lib/dbagile/contract/robust/helpers.rb

@@ -0,0 +1,19 @@
+module DbAgile
+  module Contract
+    module Robust
+      module Helpers
+    
+        # Asserts that a table exists or raises a NoSuchTableError
+        def has_table!(name, ex = nil)
+          raise NoSuchTableError, "No such table #{name}" unless has_table?(name)
+        end
+    
+        # Asserts that a table does not exist or raises a TableAlreadyExistsError
+        def not_has_table!(name, ex = nil)
+          raise TableAlreadyExistsError, "No such table #{name}" if has_table?(name)
+        end
+  
+      end # module Helpers
+    end # module Robust
+  end # module Contract
+end # module DbAgile

data/lib/dbagile/contract/robust/optimistic/data/table_driven.rb

@@ -0,0 +1,31 @@
+module DbAgile
+  module Contract
+    module Robust
+      class Optimistic
+        module Data
+          module TableDriven
+            
+            # @see DbAgile::Contract::Data::TableDriven#dataset
+            def dataset(*args, &block)
+              ds = delegate.dataset(*args, &block)
+              ds.empty?
+              ds
+            rescue StandardError => ex
+              has_table!(args[0], ex)
+              raise
+            end
+      
+            # @see DbAgile::Contract::Data::TableDriven#exists?
+            def exists?(*args, &block)
+              delegate.exists?(*args, &block)
+            rescue StandardError => ex
+              has_table!(args[0], ex)
+              raise
+            end
+            
+          end # module TableDriven
+        end # module Data
+      end # class Optimistic
+    end # module Robust
+  end # module Contract
+end # module DbAgile

data/lib/dbagile/contract/robust/optimistic/data/transaction_driven.rb

@@ -0,0 +1,45 @@
+module DbAgile
+  module Contract
+    module Robust
+      class Optimistic
+        module Data
+          module TransactionDriven
+            
+            # @see ::DbAgile::Contract::Data::TransactionDriven#insert
+            def insert(*args, &block)
+              delegate.insert(*args, &block)
+            rescue
+              has_table!(args[1])
+              raise
+            end
+      
+            # @see ::DbAgile::Contract::Data::TransactionDriven#update
+            def update(*args, &block)
+              delegate.update(*args, &block)
+            rescue
+              has_table!(args[1])
+              raise
+            end
+      
+            # @see ::DbAgile::Contract::Data::TransactionDriven#delete
+            def delete(*args, &block)
+              delegate.delete(*args, &block)
+            rescue
+              has_table!(args[1])
+              raise
+            end
+      
+            # @see ::DbAgile::Contract::Data::TransactionDriven#direct_sql
+            def direct_sql(*args, &block)
+              delegate.direct_sql(*args, &block)
+            rescue
+              has_table!(args[1]) if args[1].kind_of?(::Symbol)
+              raise
+            end
+            
+          end # module TransactionDriven
+        end # module Data
+      end # class Optimistic
+    end # module Robust
+  end # module Contract
+end # module DbAgile