dbagile 0.0.1

data/LICENCE.textile

@@ -0,0 +1,12 @@
+h1. The MIT License
+
+Copyright (c) 2009 Bernard Lambeau and the University of Louvain (Universite Catholique de Louvain, Louvain-la-Neuve, Belgium)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.textile

@@ -0,0 +1,89 @@
+h1. DbAgile - SQL Databases with Agility
+
+DbAgile aims at providing agile tools around databases, and relational/sql databases in particular.
+
+h2. Motivation
+
+Have you ever dreamed of having one central point for keeping your database access infos?
+
+<pre class="shell">
+  sh$ dba db:list
+  sh$ dba db:use my_contacts
+</pre> 
+
+Or displaying a SQL table (say, 'contacts') in one shell command?
+
+<pre class="shell">
+  sh$ dba sql:show contacts
+</pre> 
+
+Or to output the result of any SQL query to yaml, json, csv, ruby, ... or even xml?
+
+<pre class="shell">
+  sh$ dba bulk:export --yaml "SELECT name, mail FROM contacts" 
+</pre> 
+
+Or to have a Restful server on top of SQL databases?
+
+<pre class="shell">
+  dba web:tools
+</pre>
+
+Making similar things, ... in Ruby?
+
+<pre>
+  DbAgile::dba do |dba|
+    # Override environment default values (~/.dbagile, STDOUT)
+    dba.repository_path  = ...      # your application database repository
+    dba.output_buffer     = ...     # keep output in any IO object
+  
+    # Start using dbagile commands
+    dba.bulk_export %w{--yaml contacts}  # each line pushed in output_buffer
+  end
+</pre>
+
+The Rack middleware for the restful server (config.ru):
+
+<pre>
+  #!/usr/bin/env rackup --require dbagile/restful/middleware -p 8711
+  app = DbAgile::Restful::Middleware.new{|env|
+    #
+    # Set the environment!
+    #
+    # WARNING: Always use ::File instead of File because constants are
+    #          resolved in Rack scope, which contains a File class. Not
+    #          doing this may mead to bugs in certain ruby versions.
+    #
+    env.repository_path  = ::File.expand_path('../dbagile', __FILE__)
+  }
+</pre>
+
+h2. Pointers
+
+* DbAgile developper documentation on "rdoc.info":http://rdoc.info/projects/blambeau/dbagile
+
+h2. Installation
+
+<pre>
+  gem install dbagile (required dependencies are automatically installed)
+  dba --help
+</pre>
+
+Required dependencies:
+
+* sbyc >= 0.1.4
+* sequel >= 3.8.0
+* highline >= 1.5.2
+
+Optional dependencies (according to your needs):
+
+* mysql, pg, sqlite, ... (according to your sql database needs)
+* json                   (only if you use json import/export)
+* fastercsv              (only if you use csv import/export)
+* yaml                   (only if you use yaml import/export)
+* builder                (only if you use xml export)
+* rack >= 1.1.0          (only if you use the restful server)
+
+h2. Credits
+
+DbAgile (c) 2010 by Bernard Lambeau and the University of Louvain. DbAgile is distributed under the MIT licence. Please see the LICENCE.textile document for details.

data/bin/dba

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+#
+#  DbAgile - Agile interface on top of SQL databases
+#        (see lib/dbagile/dbagile.rb for more information)
+#
+#  Copyright (c) 2010 Bernard Lambeau & University of Louvain, 
+#  Released under a MIT or Ruby licence
+#
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'dbagile'
+
+begin
+  r = DbAgile::Command::Dba.new(DbAgile::default_environment).run '.', ARGV
+rescue Interrupt => e
+  $stderr.puts
+  $stderr.puts "Interrupted"
+  raise e
+rescue => e
+  $stderr.puts "DbAgile encountered a grave error, please report it to the developers"
+  $stderr.puts e.message
+  $stderr.puts e.backtrace.join("\n")
+end

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

@@ -0,0 +1,18 @@
+module DbAgile
+  class SequelAdapter < Adapter
+    module ClassMethods
+      
+      #
+      # Overrided to add a SequelTracer instance if trace is on  
+      #
+      def new(uri, options = {})
+        if options[:trace_sql]
+          SequelTracer.new(super(uri), options)
+        else
+          super(uri, options)
+        end
+      end  
+    
+    end # module ClassMethods
+  end # class SequelAdapter
+end # module DbAgile

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

@@ -0,0 +1,38 @@
+module DbAgile
+  class SequelAdapter < Adapter
+    module Connection
+      
+      # @see DbAgile::Contract::Connection#ping
+      def ping
+        db.test_connection
+      end
+      
+      # @see DbAgile::Contract::Connection#disconnect
+      def disconnect
+        @db.disconnect if @db
+        true
+      end
+      
+      # @see DbAgile::Contract::Connection#physical_schema
+      def physical_schema
+        SequelAdapter::Schema::PhysicalDump.new.run(db, uri)
+      end
+    
+      # @see DbAgile::Contract::Connection#script2sql
+      def script2sql(script, buffer = "")
+        SequelAdapter::Schema::ConcreteScript::script2sql(db, script, buffer)
+      end
+      
+      # @see DbAgile::Contract::Connection#transaction
+      def transaction(&block)
+        raise ArgumentError, "Missing transaction block" unless block
+        begin
+          db.transaction{ block.call(self) }
+        rescue DbAgile::AbordTransactionError
+          nil
+        end
+      end
+      
+    end # module Connection
+  end # class SequelAdapter
+end # module DbAgile

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

@@ -0,0 +1,30 @@
+module DbAgile
+  class SequelAdapter < Adapter
+    module Data
+      module TableDriven
+
+        # @see DbAgile::Contract::Data::TableDriven#dataset
+        def dataset(table, proj = nil)
+          result = case table
+            when Symbol
+              (proj.nil? or proj.empty?) ? db[table] : db[table].where(proj)
+            else
+              (proj.nil? or proj.empty?) ? db[table] : db[table].where(proj)
+          end
+          result.extend(::DbAgile::Contract::Data::Dataset)
+          result
+        end
+      
+        # @see DbAgile::Contract::Data::TableDriven#exists?
+        def exists?(table_or_query, subtuple = {})
+          if subtuple.nil? or subtuple.empty?
+            !dataset(table_or_query).empty?
+          else
+            !dataset(table_or_query).where(subtuple).empty?
+          end
+        end
+    
+      end # module TableDriven
+    end # module Data
+  end # class SequelAdapter
+end # module DbAgile

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

@@ -0,0 +1,43 @@
+module DbAgile
+  class SequelAdapter < Adapter
+    module Data
+      module TransactionDriven
+
+        # @see DbAgile::Contract::Data::TransactionDriven#insert
+        def insert(transaction, table, tuple)
+          db[table].insert(tuple)
+          tuple
+        end
+    
+        # @see DbAgile::Contract::Data::TransactionDriven#update
+        def update(transaction, table_name, update, proj = {})
+          if proj.nil? or proj.empty?
+            db[table_name].update(update)
+          else
+            db[table_name].where(proj).update(update)
+          end 
+        end
+    
+        # @see DbAgile::Contract::Data::TransactionDriven#delete
+        def delete(transaction, table_name, proj = {})
+          if proj.empty?
+            db[table_name].delete
+          else
+            db[table_name].where(proj).delete
+          end
+          true
+        end
+      
+        # @see DbAgile::Contract::Data::TransactionDriven#direct_sql
+        def direct_sql(transaction, sql)
+          if /^\s*(select|SELECT)/ =~ sql
+            dataset(sql)
+          else
+            db << sql
+          end
+        end
+
+      end # module TransactionDriven
+    end # module Data
+  end # class SequelAdapter
+end # module DbAgile

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

@@ -0,0 +1,135 @@
+module DbAgile
+  class SequelAdapter < Adapter
+    module Schema
+      module ConcreteScript
+        include Schema::Schema2SequelArgs
+        
+        # Converts an abstract script to a concrete one
+        def script2sql(conn, script, buffer)
+          script.each{|op| self.send(op.kind, conn, op, buffer)}
+          buffer
+        end
+        
+        def create_table(conn, op, buffer)
+          gen = Sequel::Schema::Generator.new(conn)
+          build_sequel_expand_generator(conn, op, gen, "")
+          buffer << to_sql(conn, op, gen)
+          staged!(op)
+        rescue Sequel::Error => ex
+          buffer << "-- UNSUPPORTED: #{op.to_sql92}" << "\n"
+          unsupported!(op)
+        end
+
+        def expand_table(conn, op, buffer)
+          gen = Sequel::Schema::AlterTableGenerator.new(conn)
+          build_sequel_expand_generator(conn, op, gen, "add_")
+          buffer << to_sql(conn, op, gen)
+          staged!(op)
+        rescue Sequel::Error => ex
+          buffer << "-- UNSUPPORTED: #{op.to_sql92}" << "\n"
+          unsupported!(op)
+        end
+
+        def collapse_table(conn, op, buffer)
+          gen = Sequel::Schema::AlterTableGenerator.new(conn)
+          build_sequel_collapse_generator(conn, op, gen, "drop_")
+          buffer << to_sql(conn, op, gen)
+          staged!(op)
+        rescue Sequel::Error => ex
+          buffer << "-- UNSUPPORTED: #{op.to_sql92}" << "\n"
+          unsupported!(op)
+        end
+
+        # Drops table
+        def drop_table(conn, op, buffer)
+          buffer << conn.send(:drop_table_sql, op.table_name) << ";\n"
+          op.relvar.visit{|obj,parent| op.staged!(obj)}
+        rescue Sequel::Error => ex
+          buffer << "-- UNSUPPORTED: #{op.to_sql92}" << "\n"
+          unsupported!(op)
+        end
+        
+        # Mark objects as staged for an operation
+        def staged!(op)
+          if op.supports_sub_operation?(nil)
+            op.each_sub_operation{|kind, operand| op.staged!(operand)}
+          end
+          op.staged!(op.relvar)
+        end
+        
+        # Mark objects as not staged for an operation
+        def unsupported!(op)
+          if op.supports_sub_operation?(nil)
+            op.each_sub_operation{|kind, operand| op.not_staged!(operand)}
+          end
+          op.not_staged!(op.relvar)
+        end
+        
+        # Builds a sequel expand generator
+        def build_sequel_expand_generator(conn, op, generator, prefix)
+          op.each_sub_operation{|kind, operand|
+            case kind
+              when :attribute
+                args = attribute2column_args(operand)
+                generator.send(:"#{prefix}column", *args)
+              when :candidate_key
+                if operand.primary?
+                  args = candidate_key2primary_key_args(operand)
+                  generator.send(:"#{prefix}primary_key", *args) 
+                else
+                  args = candidate_key2unique_args(operand)
+                  generator.send(:"#{prefix}unique", *args)
+                end
+              when :foreign_key
+                args = foreign_key2foreign_key_args(operand)
+                generator.send(:"#{prefix}foreign_key", *args)
+              when :index
+                args = index2index_args(operand)
+                generator.send(:"#{prefix}index", *args)
+              else
+                raise DbAgile::AssumptionFailedError, "Unknown script operation kind #{kind}"
+            end
+          }
+        end
+        
+        # Builds a sequel collapse generator
+        def build_sequel_collapse_generator(conn, op, generator, prefix)
+          op.each_sub_operation{|kind, operand|
+            case kind
+              when :attribute
+                args = [ operand.name ]
+                generator.send(:"#{prefix}column", *args)
+              when :candidate_key, :foreign_key
+                args = [ operand.name ]
+                generator.send(:"#{prefix}constraint", *args) 
+              when :index
+                column_names = operand.indexed_attributes.collect{|a| a.name}
+                args = [ column_names, {:name => operand.name}]
+                generator.send(:"#{prefix}index", *args)
+              else
+                raise DbAgile::AssumptionFailedError, "Unknown script operation kind #{kind}"
+            end
+          }
+        end
+        
+        # Converts a sequel generator to SQL for a given operation
+        def to_sql(conn, op, generator)
+          case generator
+            when Sequel::Schema::Generator
+              sql = conn.send(:create_table_sql, op.table_name, generator, {})
+              sql = sql + ";\n"
+              sql
+            when Sequel::Schema::AlterTableGenerator
+              sql = conn.send(:alter_table_sql_list, op.table_name, generator.operations)
+              sql = sql.flatten.join(";\n")
+              sql + ";\n"
+            else
+              raise DbAgile::AssumptionFailedError, "Unknown generator #{gen.class}"
+          end
+        end
+        
+        extend(ConcreteScript)
+      end # module ConcreteScript
+    end # module Schema
+  end # class SequelAdapter
+end # module DbAgile

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

@@ -0,0 +1,106 @@
+module DbAgile
+  class SequelAdapter < Adapter
+    module Schema
+      # 
+      # Loads a schema from an existing database through Sequel
+      #
+      class PhysicalDump
+      
+        # Returns the ruby type associated to a given column info
+        def dbtype_to_ruby_type(info)
+          type = info[:type]
+          capitalized = type.to_s.capitalize
+          begin
+            Kernel.eval(capitalized)
+          rescue NameError
+            case type
+              when :datetime
+                Time
+              when :boolean
+                SByC::TypeSystem::Ruby::Boolean
+              else
+                Object
+            end
+          end
+        end
+
+        # Runs the loading process and returns the schema instance
+        def run(conn, identifier)
+          builder = DbAgile::Core::Schema::builder
+          builder.schema(identifier){
+            builder.logical{ load_logical_schema(conn, builder) }
+            builder.physical{ load_physical_schema(conn, builder) }
+          }
+          builder._dump
+        end
+      
+        def load_logical_schema(conn, builder)
+          conn.tables.each{|table|
+            load_table_schema(conn, builder, table)
+          }
+        end
+      
+        # Loads a table schema
+        def load_table_schema(conn, builder, table)
+          builder.relvar(table){
+            primary_key_columns = load_table_heading(conn, builder, table)
+            load_table_constraints(conn, builder, table, primary_key_columns)
+          }
+        end
+        
+        # Loads a table heading. Returns primary key columns
+        def load_table_heading(conn, builder, table)
+          primary_key_columns = []
+          builder.heading{
+            columns = conn.schema(table, {:reload => true})
+            columns.each do |name, info|
+              #puts info.inspect
+              
+              # find attribute definition
+              defn = {:domain    => dbtype_to_ruby_type(info),
+                      :mandatory => !info[:allow_null] }
+              unless info[:ruby_default].nil?
+                defn[:default] = info[:ruby_default]
+              end
+              
+              # mark primary key columns
+              if primary_key_columns and info[:primary_key]
+                primary_key_columns << name 
+              end
+              
+              # build the attribute
+              builder.attribute(name, defn)
+            end
+          }
+          primary_key_columns
+        end
+        
+        # Loads table constraint
+        def load_table_constraints(conn, builder, table, primary_key_columns = nil)
+          builder.constraints{
+            unless primary_key_columns.nil? or primary_key_columns.empty?
+              builder.constraint(:pk, {:type => :primary_key, :attributes => primary_key_columns})
+            end
+            conn.indexes(table).each_pair{|name, defn|
+              next unless defn[:unique]
+              builder.constraint(name, {:type => :candidate_key, :attributes => defn[:columns]})
+            }
+          }
+        end
+      
+        # Loads the physical schema
+        def load_physical_schema(conn, builder)
+          builder.indexes{
+            conn.tables.each{|table|
+              conn.indexes(table).each_pair{|name, defn|
+                next if defn[:unique]
+                builder.index(name, {:relvar => table, :attributes => defn[:columns]})
+              }
+            }
+          }
+        end
+      
+      end # class PhysicalDump
+    end # module Schema
+  end # module Core
+end # module DbAgile

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

@@ -0,0 +1,71 @@
+module DbAgile
+  class SequelAdapter < Adapter
+    module Schema
+      module Schema2SequelArgs
+      
+        # Converts a Ruby type to a Sequel type
+        def ruby_type2sequel_type(type)
+          if type == SByC::TypeSystem::Ruby::Boolean
+            TrueClass
+          else
+            type
+          end
+        end
+      
+        #
+        # Returns Sequel's column argument from an Attribute instance
+        #
+        def attribute2column_args(attribute)
+          options = {:null => !attribute.mandatory?}
+          unless (defa = attribute.default_value).nil?
+            options[:default] = defa
+          end
+          domain = ruby_type2sequel_type(attribute.domain)
+          [attribute.name, domain, options]
+        end
+      
+        #
+        # Returns Sequel's primary_key arguments from a CandidateKey 
+        # instance
+        #
+        def candidate_key2primary_key_args(ckey)
+          columns = ckey.key_attributes.collect{|c| c.name} 
+          options = {:name => ckey.name}
+          [ columns, options ]
+        end
+      
+        #
+        # Returns Sequel's unique arguments from a CandidateKey 
+        # instance
+        #
+        def candidate_key2unique_args(ckey)
+          columns = ckey.key_attributes.collect{|c| c.name} 
+          options = {:name => ckey.name}
+          [ columns, options ]
+        end
+      
+        # 
+        # Returns Sequel's foreign_key arguments from a ForeignKey 
+        # instance.
+        #
+        def foreign_key2foreign_key_args(fkey)
+          target_relvar = fkey.target_relvar.name
+          source_names = fkey.source_attributes.collect{|a| a.name}
+          target_names  = fkey.target_key.key_attributes.collect{|a| a.name}
+          [source_names, target_relvar, { :key => target_names, :name => fkey.name }]
+        end
+      
+        #
+        # Returns Sequel's index arguments from an Index instance.
+        # 
+        def index2index_args(index)
+          attr_names = index.indexed_attributes.collect{|a| a.name}
+          options = {:name => index.name}
+          [ attr_names, options ]
+        end
+      
+      end # module Schema2SequelArgs
+    end # module Schema
+  end # class SequelAdapter
+end # module DbAgile
+    

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

@@ -0,0 +1,52 @@
+module DbAgile
+  class SequelAdapter < Adapter
+    module Schema
+      module TableDriven
+
+        # Returns the ruby type associated to a given column info
+        def dbtype_to_ruby_type(info)
+          type = info[:type]
+          capitalized = type.to_s.capitalize
+          begin
+            Kernel.eval(capitalized)
+          rescue NameError
+            case type
+              when :datetime
+                Time
+              when :boolean
+                SByC::TypeSystem::Ruby::Boolean
+              else
+                Object
+            end
+          end
+        end
+
+        # @see DbAgile::Contract::Schema::TableDriven#has_table?
+        def has_table?(name)
+          db.table_exists?(name)
+        end
+    
+        # @see DbAgile::Contract::Schema::TableDriven#heading
+        def heading(table_name)
+          heading = {}
+          db.schema(table_name).each do |pair|
+            column_name, info = pair
+            heading[column_name] = dbtype_to_ruby_type(info)
+          end
+          heading
+        end
+    
+        # @see DbAgile::Contract::Schema::TableDriven#columns_names
+        def column_names(table, sort_it_by_name = false)
+          sort_it_by_name ? db[table].columns.sort{|k1,k2| k1.to_s <=> k2.to_s} : db[table].columns
+        end
+    
+        # @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}
+        end
+    
+      end # module TableDriven
+    end # module Schema
+  end # class SequelAdapter
+end # module DbAgile

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

@@ -0,0 +1,46 @@
+module DbAgile
+  class SequelAdapter < Adapter
+    module Schema
+      module TransactionDriven
+
+        # @see DbAgile::Contract::Schema::TransactionDriven#run_schema_script
+        def run_schema_script(transaction, script, options)
+          buffer = ""
+          SequelAdapter::Schema::Stager.new(db).run(schema, buffer, options)
+          unless options[:dry_run]
+            db.execute_ddl(buffer)
+          end
+          buffer
+        end
+
+        # @see DbAgile::Contract::Schema::TransactionDriven#create_table
+        def create_table(transaction, name, columns)
+          db.create_table(name){ 
+            columns.each_pair{|name, type| column(name, type)} 
+          }
+          columns
+        end
+    
+        # @see DbAgile::Contract::Schema::TransactionDriven#drop_table
+        def drop_table(transaction, table_name)
+          db.drop_table(table_name)
+          true
+        end
+        
+        # @see DbAgile::Contract::Schema::TransactionDriven#add_columns
+        def add_columns(transaction, table, columns)
+          db.alter_table(table) do
+            columns.each_pair{|name, type| add_column name, type}
+          end
+          true
+        end
+
+        # @see DbAgile::Contract::Schema::TransactionDriven#key!
+        def key!(transaction, table_name, columns)
+          db.add_index(table_name, columns, {:unique => true})
+        end
+      
+      end # module TransactionDriven
+    end # module Schema
+  end # class SequelAdapter
+end # module DbAgile