sqldump 0.0.1

data/.gitignore

@@ -0,0 +1,9 @@
+foo.sqlite
+tmp
+.idea
+doc
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*~

data/.rspec

@@ -0,0 +1 @@
+--color

data/CHANGELOG

@@ -0,0 +1,8 @@
+Version 0.0.1
+-------------
+
+Initial version.
+- Very simple INSERT support.
+- CSV support.
+- SQLite3
+- PostgreSQL

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in sqldump.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,6 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})         { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^lib/(.+)/(.+)\.rb$})    { |m| "spec/#{m[1]}/#{m[2]}_spec.rb" }
+  watch('spec/spec_helper.rb')      { "spec" }
+end

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012 Mats Sigge
+
+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.md

@@ -0,0 +1,105 @@
+# SQLDump
+
+A command line tool to dump the data in a database table as INSERT or UPDATE statements, or in CSV format.
+
+## Installation
+
+Just install the gem with
+
+```bash
+$ gem install sqldump
+```
+
+This will make the executable `sqldump` available from your command line.
+
+**Requires Ruby 1.9.2 or later.**
+
+## Usage
+
+###Simplest case (SQLite3 is default). Dumps in csv format.
+
+```bash
+$ sqldump -d mydatabase.sqlite3 mytable
+```
+
+###Dump as INSERT statements
+
+```bash
+$ sqldump -d mydatabase.sqlite3 -i mytable
+```
+
+###Postgres database with username and password
+
+```bash
+$ sqldump -T pg -d mypostgresdb -U username -P password -i mytable
+```
+
+###Show all options
+
+```bash
+$ sqldump -h
+```
+
+## Development
+
+Questions or problems? Please post them on the [issue tracker](https://github.com/matssigge/sqldump/issues). You can contribute changes by forking the project and submitting a pull request. You can ensure the tests passing by running `bundle` and `rake`.
+
+This gem is created by Mats Sigge and is under the MIT License.
+
+## Roadmap
+
+###Immediate goals
+* More databases. At least MySQL and SQL Server.
+* Selecting only some columns
+* Support for UPDATEs
+* Pretty-printing SQL on multiple lines
+* Suppressing NULL columns in output
+* Handling auto-incrementing columns, e.g. nextval('sequence_name') in PostgreSQL
+
+###Longer-term goals / pipe dreams
+* Configuration system, e.g. .sqldump file
+** Default user, password, host, database
+* "Column handlers", e.g. some way of saying that the column CREATED_AT should get the value now() or getDate() instead of whatever value is actually in the database.
+* Other hooks, e.g. being able to append `SELECT @id = @@IDENTITY` after a select on SQL Server.
+
+###Done
+* Initial support for dumping INSERTs
+* Support for SQLite3
+* Support for PostgreSQL
+
+## History
+
+Once, at a company where I worked, there was a whole lot of DB scripting. So much that I got tired of writing all that SQL by hand. At first, there were some SQL scripts that generated SQL as output, i.e. something like 
+
+```SQL
+SELECT 'INSERT INTO ' + ... 
+```
+
+but that gets tired *really quickly*. So after a while, I started hacking on a perl tool called SQLDump. It would query the database and output the results as INSERT (or UPDATE) statements directly. More and more options were added on, and it got to be quite powerful. It could take a command line like
+
+```bash
+$ sqldump -S testserver -d test_db_14 -irtl -f SPROCKET_ID RATCHET WHERE RATCHET_DATE = '2012-01-02'
+```
+
+and output
+
+```SQL
+INSERT INTO RATCHET (
+	SPROCKET_ID,
+	RATCHET_NAME,
+	RATCHET_DATE
+	CREATED_AT
+)
+VALUES (
+	@SPROCKET_ID,
+	'My ratchet rocks!',
+	'2012-01-02',
+	getDate()
+)
+```
+
+which was pretty useful at the time. I could chain together sequences of calls and dump whole hierarchies of data. I used it a lot.
+
+It also ended up a big smelly mess. And while it's possible to make a mess in any language, it's one of the things that Perl does best. (Don't get me wrong, I love Perl, and can't imagíne life without it, but I've also written some of my worst code in it.) So I decided that I wanted to rewrite it in Ruby, and at least attempting to keep the code clean. Also, the initial tool was specific to both SQL Server and the idiosynchracies of the system I worked on (i.e. special handling of some column names and other stuff). My vision of this rewrite is to be able to support the same kind of special handling, but through some form of hooks instead of hard coding that logic into the guts of the tool. 
+
+Mats Sigge

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/sqldump

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+require 'sqldump'
+
+options = Sqldump::Options.new(ARGV)
+connector = Sqldump::Connector.new(options)
+connector.connect do |dbh|
+  dumper = Sqldump::Dumper.new(dbh, options)
+  dumper.dump do |sth|
+    formatter = Sqldump::Formatter.formatter(sth, STDOUT, options)
+    formatter.output
+  end
+end

data/features/database_types.feature

@@ -0,0 +1,28 @@
+Feature: dump data from different database types (e.g. MySQL, PostgreSQL, SQLite, etc.)
+
+  sqldump supports dumping data from any database type supported by Ruby DBI/DBD.
+  The default database type is (for now) SQLite3 for the simple reason that it's extremely easy to test with.
+
+  In a distant future, there may be JRuby support for JDBC to (possibly) extend the range of supported databases
+  even further.
+
+  Scenario: SQLite3
+
+  Scenario: MySQL
+
+  Scenario: SQL Server
+
+  Scenario: PostgreSQL
+    Given a PostgreSQL database named "numbers" on "localhost"
+    And a table "numbers" with the following data
+      | number[int] |
+      | 17          |
+      | 42          |
+      | 4711        |
+    When I run `sqldump -T postgresql -d numbers -S localhost -U mats numbers`
+    Then it should pass with:
+    """
+    17
+    42
+    4711
+    """

data/features/dump_as_csv.feature

@@ -0,0 +1,57 @@
+Feature: dump as csv
+
+  The default mode of operation of sqldump is to output data in CSV
+√
+  Scenario: one-column, one-row table
+    Given a database "foo.sqlite" with a table "number" with the following data
+      | number[int] |
+      | 42          |
+    When I run `sqldump -d foo.sqlite number`
+    Then it should pass with:
+    """
+    42
+    """
+
+  Scenario: multi-row table
+    Given a database "foo.sqlite" with a table "numbers" with the following data
+      | number[int] |
+      | 17          |
+      | 42          |
+      | 4711        |
+    When I run `sqldump -d foo.sqlite numbers`
+    Then it should pass with:
+    """
+    17
+    42
+    4711
+    """
+
+  Scenario: multi-column table
+    Given a database "foo.sqlite" with a table "numbers_and_strings" with the following data
+      | number[int] | string |
+      | 17          | foo    |
+      | 42          | bar    |
+      | 4711        | baz    |
+    When I run `sqldump -d foo.sqlite numbers_and_strings`
+    Then it should pass with:
+    """
+    17,foo
+    42,bar
+    4711,baz
+    """
+
+  Scenario: with header line
+    Given a database "foo.sqlite" with a table "numbers_strings_and_things" with the following data
+      | number[int] | string | thing       |
+      | 17          | foo    | rubber duck |
+    When I run `sqldump -d foo.sqlite -H numbers_strings_and_things`
+    Then it should pass with:
+    """
+    number,string,thing
+    17,foo,rubber duck
+    """
+
+  Scenario: custom separator
+
+
+  Scenario: quoting of separator

data/features/dump_as_insert.feature

@@ -0,0 +1,23 @@
+Feature: dump data as INSERT statements
+
+  sqldump can dump data as INSERT statements so that the corresponding data can be inserted in a new database
+
+  Scenario: simple table
+    Given a database "foo.sqlite" with a table "number" with the following data
+      | number[int] |
+      | 42          |
+    When I run `sqldump -d foo.sqlite -i number`
+    Then it should pass with:
+    """
+    INSERT INTO number (number) VALUES (42);
+    """
+
+  Scenario: null value
+    Given a database "foo.sqlite" with a table "number" with the following data
+      | number[int] |
+      | <null>      |
+    When I run `sqldump -d foo.sqlite -i number`
+    Then it should pass with:
+    """
+    INSERT INTO number (number) VALUES (NULL);
+    """

data/features/step_definitions/sqldump_steps.rb

@@ -0,0 +1,15 @@
+require 'dbi'
+
+Given /^a database "([^"]*)" with a table "([^"]*)" with the following data$/ do |database, table_name, table|
+  create_dummy_database_with_data(:sqlite3, nil, database, table_name, table)
+end
+
+Given /^a PostgreSQL database named "([^"]*)" on "([^"]*)"$/ do |database, host|
+  @database = database
+  @host = host
+  @driver = :postgresql
+end
+
+When /^a table "([^"]*)" with the following data$/ do |table_name, table|
+  create_dummy_database_with_data(@driver, @host, @database, table_name, table)
+end

data/features/support/cuke_table_data_converter.rb

@@ -0,0 +1,62 @@
+class CukeTableDataConverter
+
+  def initialize(table_name, table)
+    @table_name = table_name
+    @table = table
+
+    @column_names = extract_column_names(table)
+    @datatypes = extract_column_datatypes(table)
+  end
+
+  def extract_column_names(table)
+    table.column_names.collect { |column| column_name(column) }
+  end
+
+  def extract_column_datatypes(table)
+    datatypes = Hash.new
+    table.column_names.each do |column|
+      datatype = column_datatype(column)
+      datatypes[column_name(column)] = datatype
+    end
+    datatypes
+  end
+
+  def get_create_table_sql
+    query = "CREATE TABLE #{@table_name} ("
+    query += @column_names.collect { |column| "#{column} #{@datatypes[column]}" }.join ", "
+    query += ");"
+    query
+  end
+
+  def get_insert_sql
+    sql = []
+    @table.hashes.each do |hash|
+      query = "INSERT INTO #{@table_name} ("
+      query += @column_names.join ", "
+      query += ") VALUES ("
+      query += @table.column_names.collect { |column| as_sql_literal(hash[column]) }.join ", "
+      query += ");"
+      sql << query
+    end
+    sql
+  end
+
+  def as_sql_literal(value)
+    if value == '<null>'
+      'NULL'
+    elsif (value =~ /[^0-9]/ || value =~ /^0./)
+      "'#{value}'"
+    else
+      value
+    end
+  end
+
+  def column_name(column_heading)
+    /^(\w+)/.match(column_heading)[1]
+  end
+
+  def column_datatype(column_heading)
+    column_heading =~ /\[([^\]]+)\]/ ? $1 : 'varchar(100)'
+  end
+
+end

data/features/support/env.rb

@@ -0,0 +1,66 @@
+$LOAD_PATH << File.expand_path('../../../lib', __FILE__)
+require 'aruba/cucumber'
+# Ensure aruba can find the bin folder
+ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
+
+def drop_database_if_exists(driver, host, database, username, password)
+  case driver
+    when :sqlite3
+      File.delete(database) if File.exists?(database)
+    when :postgresql
+      DBI.connect("DBI:Pg:postgres:#{host}", username, password) do |dbh|
+        dbh.do("DROP DATABASE IF EXISTS #{database}")
+      end
+  end
+end
+
+def get_driver_string(driver)
+  driver_string = case driver
+                    when :sqlite3
+                      "SQLite3"
+                    when :postgresql
+                      "Pg"
+                  end
+  driver_string
+end
+
+def create_and_connect_to_database(driver, host, database, username, password, &block)
+  create_database(driver, host, database, username, password)
+
+  url = "DBI:#{get_driver_string(driver)}:#{database}"
+  url += ":#{host}" if host
+
+  if block
+    DBI.connect(url, username, password, nil, &block)
+  end
+  DBI.connect(url, username, password)
+end
+
+def create_database(driver, host, database, username, password)
+  case driver
+    when :sqlite3
+      # Do nothing - just connecting to the correct filename creates the database
+    when :postgresql
+      DBI.connect("DBI:Pg:postgres:#{host}", username, password) do |dbh|
+        dbh.do("CREATE DATABASE #{database}")
+      end
+  end
+end
+
+def create_dummy_database_with_data(driver, host, database, table_name, table_data)
+  username = 'mats'
+  password = nil
+
+  in_current_dir do
+    drop_database_if_exists(driver, host, database, username, password)
+
+    converter = CukeTableDataConverter.new(table_name, table_data)
+
+    create_and_connect_to_database(driver, host, database, username, password) do |dbh|
+      dbh.do(converter.get_create_table_sql)
+      converter.get_insert_sql.each do |sql|
+        dbh.do(sql)
+      end
+    end
+  end
+end

data/lib/sqldump.rb

@@ -0,0 +1,4 @@
+require 'sqldump/options'
+require 'sqldump/connector'
+require 'sqldump/dumper'
+require 'sqldump/formatter'

data/lib/sqldump/connector.rb

@@ -0,0 +1,47 @@
+require 'dbi'
+
+module Sqldump
+
+  class Connector
+
+    def initialize(options)
+      @options = options
+    end
+
+    def connect
+      begin
+        dbh = DBI.connect(get_url, get_user, get_password)
+        yield dbh
+
+      ensure
+        dbh.disconnect if dbh
+      end
+
+    end
+
+    def get_url
+      database = @options.database
+      driver = get_driver
+      "DBI:#{driver}:#{database}"
+    end
+
+    def get_driver
+      case @options.database_type
+        when :sqlite3
+          "SQLite3"
+        when :postgresql
+          "Pg"
+      end
+    end
+
+    def get_user
+      @options.username
+    end
+
+    def get_password
+      @options.password
+    end
+
+  end
+
+end

data/lib/sqldump/csv_formatter.rb

@@ -0,0 +1,21 @@
+module Sqldump
+
+  class CsvFormatter
+
+    def initialize(sth, io, options)
+      @sth = sth
+      @io = io
+      @options = options
+    end
+
+    def output
+      if @options.csv_header
+        @io.puts @sth.column_names.join(",")
+      end
+      @sth.fetch do |row|
+        @io.puts row.join(",")
+      end
+    end
+  end
+
+end

data/lib/sqldump/dumper.rb

@@ -0,0 +1,23 @@
+module Sqldump
+
+  class Dumper
+
+    def initialize(dbh, options)
+      @dbh = dbh
+      @options = options
+    end
+
+    def dump
+      begin
+        sth = @dbh.execute(@options.sql)
+        yield sth
+
+      ensure
+        sth.finish if sth
+
+      end
+    end
+
+  end
+
+end

data/lib/sqldump/formatter.rb

@@ -0,0 +1,21 @@
+require 'sqldump/csv_formatter'
+require 'sqldump/insert_formatter'
+
+module Sqldump
+
+  class Formatter
+
+    private_class_method :new
+
+    def self.formatter(sth, io, options)
+      case options.dump_mode
+        when :csv
+          CsvFormatter.new(sth, io, options)
+        when :insert
+          InsertFormatter.new(sth, io, options)
+      end
+    end
+
+  end
+
+end

data/lib/sqldump/insert_formatter.rb

@@ -0,0 +1,59 @@
+module Sqldump
+
+  class InsertFormatter
+
+    def initialize(sth, io, options)
+      @sth = sth
+      @io = io
+      @options = options
+
+      setup_column_type_mapping()
+    end
+
+    def setup_column_type_mapping
+      @column_type_by_name = Hash[@sth.column_names.zip(@sth.column_types)]
+    end
+
+    def column_type(column_name)
+      @column_type_by_name[column_name]
+    end
+
+    def output_column_names
+      @io.print @sth.column_names.join(", ")
+    end
+
+    def output_values(row)
+      quoted_list = []
+      row.each_with_name do |value, column_name|
+        quoted_list.push quote(value, column_name)
+      end
+      @io.print quoted_list.join(", ")
+    end
+
+    def output
+      @sth.fetch do |row|
+        @io.print("INSERT INTO #{@options.table} (")
+        output_column_names()
+        @io.print ") VALUES ("
+        output_values(row)
+        @io.print ");\n"
+      end
+    end
+
+    def quote(value, column_name)
+      if value.nil?
+        "NULL"
+      else
+        type = column_type(column_name)
+        if type == DBI::Type::Integer or type == DBI::Type::Float or type == DBI::Type::Decimal
+          value
+        else
+          value = value.to_s.gsub(/'/, "''")
+          "'#{value}'"
+        end
+      end
+    end
+
+  end
+
+end

data/lib/sqldump/options.rb

@@ -0,0 +1,90 @@
+require 'optparse'
+
+module Sqldump
+
+  class Options
+
+    attr_accessor :database
+    attr_accessor :host
+    attr_accessor :username
+    attr_accessor :password
+    attr_accessor :database_type
+    attr_accessor :table
+    attr_accessor :sql
+    attr_accessor :csv_header
+    attr_accessor :dump_mode
+
+    def initialize(argv)
+      parse_options(argv)
+
+      set_derived_options(argv)
+    end
+
+    def set_derived_options(argv)
+      self.table = argv[0]
+
+      self.sql = "select * from " + argv.join(" ")
+    end
+
+    def parse_options(argv)
+      optparse = define_options()
+      optparse.parse!(argv)
+      if argv.size == 0
+        print optparse
+        exit
+      end
+    end
+
+    def setup_defaults
+      self.dump_mode = :csv
+      self.database_type = :sqlite3
+      self.host = 'localhost'
+    end
+
+    def define_options
+      optparse = OptionParser.new do |opts|
+        setup_defaults()
+
+        opts.banner = "Usage: sqldump [options] table [extra sql]"
+
+        opts.on_head('-h', '--help', 'Display this help.') do
+          puts opts
+          exit
+        end
+
+        # TODO: Handle line wrapping in description
+        opts.on('-d', '--database DATABASE', "Specify the database to dump data from. In the case of file-based databases, this should be the full path of the database file.") do |database|
+          self.database = database
+        end
+
+        opts.on('-S', '--host USER', 'Specifies the host where the database is located, if applicable. If not specified, the default host is localhost.') do |host|
+          self.host = host
+        end
+
+        opts.on('-U', '--username USER', 'Specifies the username to use') do |username|
+          self.username = username
+        end
+
+        opts.on('-P', '--password PASSWORD', 'Specifies the password to use') do |password|
+          self.password = password
+        end
+
+        opts.on('-T', '--dbtype TYPE', 'Specify the type of database to connect to. Supported types are sqlite3, postgresql/pg.') do |type|
+          type = 'postgresql' if type == 'pg'
+          self.database_type = type.to_sym
+        end
+
+        opts.on('-i', '--insert', 'Dump data as INSERT statements.') do
+          self.dump_mode = :insert
+        end
+
+        opts.on('-H', '--header', 'Include column names in csv mode.') do
+          self.csv_header = true
+        end
+      end
+      optparse
+    end
+
+  end
+
+end

data/lib/sqldump/version.rb

@@ -0,0 +1,3 @@
+module Sqldump
+  VERSION = "0.0.1"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'sqldump'
+require 'dbi'
+
+class Object
+
+  def create_dummy_database(database = '/tmp/foo.sqlite')
+    File.delete(database) if File.exists?(database)
+
+    dbh = DBI.connect("DBI:SQLite3:#{database}")
+    dbh.do("CREATE TABLE numbers (number int);")
+    dbh.do("INSERT INTO numbers (number) VALUES (42);")
+    dbh
+  end
+
+end

data/spec/sqldump/connector_spec.rb

@@ -0,0 +1,67 @@
+require 'rspec'
+require 'spec_helper'
+
+module Sqldump
+
+  describe 'Connector' do
+
+    before(:each) do
+      @options = double('options')
+      @options.stub(:database).and_return('database')
+      @options.stub(:database_type).and_return(:sqlite3)
+      @options.stub(:username).and_return(nil)
+      @options.stub(:password).and_return(nil)
+    end
+
+    describe '#connect' do
+
+      it 'connects to the specified database' do
+        database = "/tmp/foo.sqlite"
+        dbh = create_dummy_database(database)
+        dbh.disconnect
+
+        @options.stub(:database).and_return(database)
+
+        connector = Connector.new(@options)
+        connector.connect do |dbh|
+          sth = dbh.execute("SELECT * FROM numbers")
+          sth.fetch do |row|
+            row[0].should == 42
+          end
+          sth.finish
+        end
+      end
+
+    end
+
+    describe '#get_url' do
+      it 'uses the Pg driver when postgresql is specified' do
+        @options.stub(:database).and_return('numbers')
+        @options.stub(:database_type).and_return(:postgresql)
+
+        connector = Connector.new(@options)
+        connector.get_url.should == 'DBI:Pg:numbers'
+      end
+    end
+
+    describe '#get_user' do
+      it 'returns the specified password' do
+        @options.stub(:username).and_return('the_user')
+
+        connector = Connector.new(@options)
+        connector.get_user.should == 'the_user'
+      end
+    end
+
+    describe '#get_user' do
+      it 'returns the specified password' do
+        @options.stub(:password).and_return('top_secret')
+
+        connector = Connector.new(@options)
+        connector.get_password.should == 'top_secret'
+      end
+    end
+
+  end
+
+end

data/spec/sqldump/csv_formatter_spec.rb

@@ -0,0 +1,43 @@
+require 'rspec'
+require 'spec_helper'
+require 'dbi'
+
+module Sqldump
+
+  describe "CsvFormatter" do
+
+    def formatter_example(csv_header_option, expected_result)
+      strio = StringIO.new
+
+      options = double("Options")
+      options.stub(:csv_header).and_return(csv_header_option)
+
+      formatter = CsvFormatter.new(@sth, strio, options)
+      formatter.output
+      strio.close
+      strio.string.should == expected_result
+    end
+
+    before(:each) do
+      @dbh = create_dummy_database
+      @dbh.do("create table numbers_and_strings (number int, string varchar(100));")
+      @dbh.do("insert into numbers_and_strings values (42, 'thingy')")
+      @sth = @dbh.execute "select * from numbers_and_strings"
+    end
+
+    after(:each) do
+      @sth.finish
+      @dbh.disconnect
+    end
+
+    it "prints column values verbatim, semicolon-separated, to supplied IO object" do
+      formatter_example(false, "42,thingy\n")
+    end
+
+    it "prints column headings when given csv_header flag" do
+      formatter_example(true, "number,string\n42,thingy\n")
+    end
+
+  end
+
+end

data/spec/sqldump/dumper_spec.rb

@@ -0,0 +1,28 @@
+require 'rspec'
+require 'spec_helper'
+
+module Sqldump
+
+  describe 'Dumper' do
+
+    describe 'Dump' do
+
+      it 'Executes the select and passes an open statement handle to the supplied block' do
+        dbh = create_dummy_database
+
+        options = double('options')
+        options.stub(:sql).and_return("select * from numbers")
+
+        dumper = Dumper.new(dbh, options)
+        dumper.dump do |sth|
+          sth.fetch do |row|
+            row[0].should == 42
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/sqldump/formatter_spec.rb

@@ -0,0 +1,36 @@
+require 'rspec'
+require 'spec_helper'
+
+module Sqldump
+
+  describe Formatter do 
+
+    context "dump_mode is :csv" do
+
+      it "creates a CsvFormatter" do
+        options = double("Options")
+        options.stub(:dump_mode).and_return(:csv)
+        formatter = Formatter.formatter(nil, nil, options)
+        formatter.class.should == CsvFormatter
+      end
+
+    end
+
+    context "dump_mode is :insert" do
+
+      class InsertFormatter
+        def setup_column_type_mapping
+          @column_type_by_name = {}
+        end
+      end
+
+      it "creates an InsertFormatter" do
+        options = double("Options")
+        options.stub(:dump_mode).and_return(:insert)
+        formatter = Formatter.formatter(double("sth").as_null_object, nil, options)
+        formatter.class.should == InsertFormatter
+      end
+    end
+  end
+
+end

data/spec/sqldump/insert_formatter_spec.rb

@@ -0,0 +1,69 @@
+require 'rspec'
+require 'spec_helper'
+require 'dbi'
+
+module Sqldump
+
+  describe InsertFormatter do
+
+    describe "#output" do
+
+      def formatter_example(expected_result)
+        strio = StringIO.new
+
+        options = double("Options")
+        options.stub(:table).and_return('numbers_and_strings')
+
+        formatter = InsertFormatter.new(@sth, strio, options)
+        formatter.output
+        strio.close
+
+        strio.string.should == expected_result
+      end
+
+      before(:each) do
+        @dbh = create_dummy_database
+        @dbh.do("create table numbers_and_strings (number int, string varchar(100));")
+        @dbh.do("insert into numbers_and_strings values (42, 'thingy')")
+        @sth = @dbh.execute "select * from numbers_and_strings"
+      end
+
+      after(:each) do
+        @sth.finish
+        @dbh.disconnect
+      end
+
+      it "creates an insert statement for each row of the table" do
+        formatter_example("INSERT INTO numbers_and_strings (number, string) VALUES (42, 'thingy');\n")
+      end
+
+    end
+
+    describe "#quote" do
+
+      class InsertFormatter
+        def setup_column_type_mapping
+          @column_type_by_name = {
+              "number" => DBI::Type::Integer,
+              "string" => DBI::Type::Varchar
+          }
+        end
+      end
+
+      before(:each) do
+        @formatter = InsertFormatter.new(nil, nil, nil)
+      end
+
+      it "quotes a string" do
+        @formatter.quote("thing", "string").should == "'thing'"
+      end
+
+      it "doesn't quote an integer" do
+        @formatter.quote(17, "number").should == 17
+      end
+
+    end
+
+  end
+
+end

data/spec/sqldump/options_spec.rb

@@ -0,0 +1,111 @@
+require 'rspec'
+require 'spec_helper'
+
+def make_options(args)
+  args << 'table' unless args[-1] == 'table'
+  Sqldump::Options.new(args)
+end
+
+module Sqldump
+
+  describe 'Options handler' do
+
+
+    describe 'database and table' do
+      let(:options) { make_options(%w(-d dbname table)) }
+
+      it "extracts the database name" do
+        options.database.should == 'dbname'
+      end
+
+      it "extracts the table name" do
+        options.table.should == 'table'
+      end
+
+      it "generates select sql" do
+        options.sql.should match /select \* from table/i
+      end
+    end
+
+    describe 'host' do
+      it 'sets the host to localhost if not specified' do
+        options = make_options([])
+        options.host.should == 'localhost'
+      end
+
+      it 'sets the host to what is specified' do
+        options = make_options(%w(-S server.example.com))
+        options.host.should == 'server.example.com'
+      end
+    end
+
+    describe 'database type' do
+      it 'sets the default to SQLite3' do
+        options = make_options([])
+        options.database_type.should == :sqlite3
+      end
+
+      it 'sets the type to postgresql if specified' do
+        options = make_options(%w(-T postgresql))
+        options.database_type.should == :postgresql
+      end
+
+      it 'pg is an alias for postgresql' do
+        options = make_options(%w(-T pg))
+        options.database_type.should == :postgresql
+      end
+    end
+
+    describe 'username' do
+      it 'sets the username to nil if not specified' do
+        options = make_options([])
+        options.username.should be_nil
+      end
+
+      it 'sets the username to what is specified' do
+        options = make_options(%w(-U the_user))
+        options.username.should == 'the_user'
+      end
+    end
+
+    describe 'password' do
+      it 'sets the password to nil if not specified' do
+        options = make_options([])
+        options.password.should be_nil
+      end
+
+      it 'sets the username to what is specified' do
+        options = make_options(%w(-P top_secret table))
+        options.password.should == 'top_secret'
+      end
+    end
+
+    describe 'csv mode is default' do
+      it "sets the mode to :csv" do
+        options = make_options([])
+        options.dump_mode.should == :csv
+      end
+    end
+
+    describe 'csv header option' do
+      it "the csv_header flag is false by default" do
+        options = make_options([])
+        options.csv_header.should be_false
+      end
+
+      it "sets the options flag csv_header to true" do
+        options = make_options(%w(-H table))
+        options.csv_header.should be_true
+      end
+    end
+
+    describe 'insert mode option' do
+      it "sets the mode to :insert" do
+        options = make_options(%w(-i table))
+        options.dump_mode.should == :insert
+      end
+    end
+
+  end
+
+end

data/sqldump.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sqldump/version"
+
+Gem::Specification.new do |s|
+  s.name        = "sqldump"
+  s.version     = Sqldump::VERSION
+  s.authors     = ["Mats Sigge"]
+  s.email       = ["mats.sigge@gmail.com"]
+  s.homepage    = "http://github.com/matssigge/sqldump"
+  s.summary     = %q{Dumps data as insert statements}
+  s.description = %q{A command line tool to generate SQL insert or update statements from the data in a database.}
+
+  # s.rubyforge_project = "sqldump"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_dependency "dbi"
+  s.add_dependency "dbd-sqlite3"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "cucumber"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "rb-fsevent" if RUBY_PLATFORM =~ /darwin/i
+  s.add_development_dependency "dbd-pg"
+end

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: sqldump
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Mats Sigge
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-05 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dbi
+  requirement: &2160361380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2160361380
+- !ruby/object:Gem::Dependency
+  name: dbd-sqlite3
+  requirement: &2160360440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2160360440
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2160359900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2160359900
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: &2160359280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2160359280
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &2160358300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2160358300
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: &2160357060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2160357060
+- !ruby/object:Gem::Dependency
+  name: dbd-pg
+  requirement: &2160353280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2160353280
+description: A command line tool to generate SQL insert or update statements from
+  the data in a database.
+email:
+- mats.sigge@gmail.com
+executables:
+- sqldump
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .idea/inspectionProfiles/Project_Default.xml
+- .idea/inspectionProfiles/profiles_settings.xml
+- .rspec
+- CHANGELOG
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/sqldump
+- features/database_types.feature
+- features/dump_as_csv.feature
+- features/dump_as_insert.feature
+- features/step_definitions/sqldump_steps.rb
+- features/support/cuke_table_data_converter.rb
+- features/support/env.rb
+- lib/sqldump.rb
+- lib/sqldump/connector.rb
+- lib/sqldump/csv_formatter.rb
+- lib/sqldump/dumper.rb
+- lib/sqldump/formatter.rb
+- lib/sqldump/insert_formatter.rb
+- lib/sqldump/options.rb
+- lib/sqldump/version.rb
+- numbers
+- spec/spec_helper.rb
+- spec/sqldump/connector_spec.rb
+- spec/sqldump/csv_formatter_spec.rb
+- spec/sqldump/dumper_spec.rb
+- spec/sqldump/formatter_spec.rb
+- spec/sqldump/insert_formatter_spec.rb
+- spec/sqldump/options_spec.rb
+- sqldump.gemspec
+homepage: http://github.com/matssigge/sqldump
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Dumps data as insert statements
+test_files:
+- features/database_types.feature
+- features/dump_as_csv.feature
+- features/dump_as_insert.feature
+- features/step_definitions/sqldump_steps.rb
+- features/support/cuke_table_data_converter.rb
+- features/support/env.rb
+- spec/spec_helper.rb
+- spec/sqldump/connector_spec.rb
+- spec/sqldump/csv_formatter_spec.rb
+- spec/sqldump/dumper_spec.rb
+- spec/sqldump/formatter_spec.rb
+- spec/sqldump/insert_formatter_spec.rb
+- spec/sqldump/options_spec.rb