coupler 0.0.1-java

data/tasks/db.rake

@@ -0,0 +1,120 @@
+namespace :db do
+  desc "Obliterate the local database"
+  task :nuke do
+    confirm("This will completely obliterate all of Coupler's databases.")
+
+    require 'fileutils'
+    files = Dir.glob(File.join(Coupler::Base.settings.data_path, "db", "*"))
+    FileUtils.rm_rf(files.reject { |d| d =~ /migrate$/ }, :verbose => true)
+  end
+
+  desc "Purge the database"
+  task :purge => :environment do
+    FileUtils.rm(Dir[Coupler::Base.settings.db_path('coupler')+".*"])
+  end
+
+  desc "Run migrations"
+  task :migrate => :environment do
+    version = ENV['VERSION']
+    Coupler::Database.instance.migrate!(version ? version.to_i : nil)
+  end
+
+  namespace :migrate do
+    desc "Reset the database"
+    task :reset => ['db:purge', 'db:migrate']
+  end
+
+  desc "Roll the database back a version"
+  task :rollback => [:start, :environment] do
+    Coupler::Database.instance.rollback!
+  end
+
+  desc "Reset and bootstrap the database"
+  task :bootstrap => [:start, :environment] do
+    require 'test/factories'
+    confirm("This will delete any existing configuration data.") if ENV['COUPLER_ENV'] != "test"
+
+    Rake::Task["db:migrate:reset"].invoke
+
+    project = Factory(:project, :name => "Fake")
+    connection = Factory(:connection, :name => "Fake")
+    resource = Factory(:resource, :name => "People", :project => project, :connection => connection)
+    scenario = Factory(:scenario, :name => "First to last", :project => project, :resource_1 => resource)
+    matcher = Factory(:matcher, {
+      :scenario => scenario,
+      :comparisons_attributes => [{
+        :lhs_type => 'field', :lhs_value => resource.fields_dataset[:name => 'first_name'].id, :lhs_which => 1,
+        :rhs_type => 'field', :rhs_value => resource.fields_dataset[:name => 'last_name'].id,  :rhs_which => 2,
+        :operator => 'equals'
+      }]
+    })
+    Factory(:transformer, :name => 'strlen', :code => 'value.length', :allowed_types => %w{string}, :result_type => 'integer')
+    Factory(:transformer, :name => 'square', :code => 'value * value', :allowed_types => %w{integer}, :result_type => 'integer')
+  end
+
+  require 'forgery'
+  require 'sequel'
+  desc "Create database with fake data"
+  task :fake do
+    db = Sequel.connect('jdbc:mysql://localhost/coupler_fake_data?user=coupler&password=cupla')
+    db.tables.each { |t| db.drop_table(t) }
+    db.create_table :people do
+      primary_key :id
+      String :first_name
+      String :last_name
+      Integer :age
+      index :first_name
+      index :last_name
+    end
+    db.create_table :pets do
+      primary_key :id
+      String :name
+      String :owner_first_name
+      String :owner_last_name
+    end
+    db.create_table :no_primary_key do
+      String :foo
+      String :bar
+    end
+    db.create_table :two_primary_keys do
+      String :foo
+      String :bar
+      primary_key [:foo, :bar]
+    end
+    db.execute("CREATE TABLE string_primary_key (foo VARCHAR(255), PRIMARY KEY(foo))")
+    db.create_table :avast_ye do
+      primary_key :arrr
+      String :scurvy_dog
+    end
+    db.create_table :lots_of_nulls do
+      primary_key :id
+      String :empty
+    end
+
+    people = db[:people]
+    pets = db[:pets]
+
+    num = ENV.has_key?('NUM') ? ENV['NUM'].to_i : 50
+    person_records = []
+    pet_records = []
+    num.times do |i|
+      person = [ Forgery(:name).first_name, Forgery(:name).last_name, rand(30) + 20 ]
+      pet = [ Forgery(:name).first_name, person[0], person[1] ]
+
+      person_records << person
+      pet_records << pet
+      if i % 10000 == 0
+        people.import([:first_name, :last_name, :age], person_records)
+        pets.import([:name, :owner_first_name, :owner_last_name], pet_records)
+        person_records.clear
+        pet_records.clear
+      end
+    end
+    people.import([:first_name, :last_name, :age], person_records)
+    pets.import([:name, :owner_first_name, :owner_last_name], pet_records)
+
+    pirates = db[:avast_ye]
+    pirates.insert(:scurvy_dog => "Pete")
+    pirates.insert(:scurvy_dog => "Westley")
+  end
+end

data/tasks/environment.rake

@@ -0,0 +1,12 @@
+task :environment do
+  require 'bundler'
+  Bundler.setup(:default, :development)
+  require File.join(File.dirname(__FILE__), '..', 'lib', 'coupler')
+end
+
+namespace :environment do
+  task :test do
+    ENV['COUPLER_ENV'] = "test"
+    Rake::Task["environment"].execute
+  end
+end

data/tasks/jeweler.rake

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "coupler"
+  gem.homepage = "http://github.com/coupler/coupler"
+  gem.license = "MIT"
+  gem.summary = %Q{Coupler is a desktop application for linking datasets together}
+  gem.description = %Q{Coupler is a (JRuby) desktop application designed to link datasets together}
+  gem.email = "jeremy.f.stephens@vanderbilt.edu"
+  gem.authors = ["Jeremy Stephens"]
+  gem.platform = 'java'
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+#require 'rake/testtask'
+#Rake::TestTask.new(:test) do |test|
+  #test.libs << 'lib' << 'test'
+  #test.pattern = 'test/**/test_*.rb'
+  #test.verbose = true
+#end
+
+#require 'rcov/rcovtask'
+#Rcov::RcovTask.new do |test|
+  #test.libs << 'test'
+  #test.pattern = 'test/**/test_*.rb'
+  #test.verbose = true
+  #test.rcov_opts << '--exclude "gems/*"'
+#end
+
+#task :default => :test
+
+#require 'rake/rdoctask'
+#Rake::RDocTask.new do |rdoc|
+  #version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  #rdoc.rdoc_dir = 'rdoc'
+  #rdoc.title = "coupler #{version}"
+  #rdoc.rdoc_files.include('README*')
+  #rdoc.rdoc_files.include('lib/**/*.rb')
+#end

data/tasks/package.rake

@@ -0,0 +1,58 @@
+require 'ant'
+
+namespace :package do
+  build_dir = "build"
+  gem_inst_dir = File.join(build_dir, "gems")
+  coupler_home = File.join(build_dir, "coupler")
+
+  coupler_version = nil
+
+  task :init do
+    FileUtils.mkdir_p(gem_inst_dir)
+    FileUtils.mkdir_p(coupler_home)
+    coupler_version = `git rev-parse HEAD`
+  end
+
+  task :install_gems => :init do
+    require 'bundler'
+
+    begin
+      Bundler.settings[:path] = gem_inst_dir
+      Bundler.settings[:disable_shared_gems] = '1'
+      Bundler.settings.without = [:development]
+
+      Bundler::Installer.install(Bundler.root, Bundler.definition, { :path => gem_inst_dir, :without => [:development], :local => false })
+    ensure
+      Bundler.settings[:path] = nil
+      Bundler.settings[:disable_shared_gems] = nil
+      Bundler.settings.without = []
+      ant.delete :dir => '.bundle'
+    end
+  end
+
+  task :create_dependency_jar => [:install_gems, :environment] do
+    ant.jar :destfile => File.join(build_dir, "coupler-dependencies-#{coupler_version[0..6]}.jar"), :basedir => File.join(gem_inst_dir, 'jruby', '1.8') do
+      Coupler::Config.vendor_lib_paths('mysql-connector-java').each do |path|
+        zipfileset :src => path
+      end
+      Coupler::Config.vendor_lib_paths('mysql-connector-mxj').each do |path|
+        zipfileset :src => path
+      end
+    end
+  end
+
+  task :create_coupler_jar => :init do
+    ant.jar({
+      :destfile => File.join(build_dir, "coupler-#{coupler_version[0..6]}.jar"),
+      :basedir => '.',
+      :includes => "lib/**/* webroot/**/* db/migrate/* README.rdoc"
+    })
+  end
+
+  desc "Create a distributable JAR"
+  task :dist => [:create_dependency_jar, :create_coupler_jar]
+
+  task :clean do
+    ant.delete :dir => build_dir
+  end
+end

data/tasks/rdoc.rake

@@ -0,0 +1,13 @@
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "coupler #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/tasks/test.rake

@@ -0,0 +1,63 @@
+require 'rake/testtask'
+
+desc "Run all tests"
+task :test => ['test:unit', 'test:integration']
+
+namespace :test do
+  Rake::TestTask.new(:unit) do |test|
+    test.libs << 'lib' << 'test'
+    test.pattern = 'test/unit/**/test_*.rb'
+    #test.verbose = true
+    test.ruby_opts = %w{--debug}
+  end
+  task :unit => ['environment:test', 'db:purge', 'db:migrate', 'db:fake']
+
+  Rake::TestTask.new(:integration) do |test|
+    test.libs << 'lib' << 'test'
+    test.pattern = 'test/integration/**/test_*.rb'
+    #test.verbose = true
+    test.ruby_opts = %w{--debug}
+  end
+  task :integration => ['environment:test', 'db:purge', 'db:migrate', 'db:fake']
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+begin
+  require 'cucumber/rake/task'
+  require 'git'
+
+  Cucumber::Rake::Task.new(:features)
+  task :features => ['environment:test', 'db:purge', 'db:migrate', 'db:fake']
+
+  Cucumber::Rake::Task.new(:features_html, "Run Cucumber features with HTML output") do |t|
+    outfile = "pages/_posts/#{Date.today.to_s}-features.html"
+    t.cucumber_opts = "--format Butternut::Formatter --out #{outfile} features"
+  end
+  task :features_html => ['environment:test', 'db:purge', 'db:migrate', 'db:fake']
+
+  desc "Update github pages for coupler"
+  task :update_pages => :features_html do
+    repos = Git.open("pages")
+    repos.add('.')
+    repos.commit("Added post (from Rake task)")
+    repos.push
+  end
+
+rescue LoadError
+  task :features do
+    abort "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+  end
+end
+

data/tasks/vendor.rake

@@ -0,0 +1,43 @@
+namespace :vendor do
+  desc "Fetch vendor packages"
+  task :fetch do
+    # FIXME: There is some fast and loose code right here.
+    require 'lib/coupler/config'
+
+    Coupler::Config.each_vendor_lib do |name, info|
+      type_dir = File.join(Dir.pwd, 'vendor', info[:type])
+      destination = File.join(type_dir, info[:dir] || info[:filename])
+      if File.exist?(destination)
+        puts "Not downloading #{name}"
+        next
+      end
+
+      puts "Downloading #{name}..."
+      io = info[:filename] ? File.open(destination, "w") : Tempfile.new(name)
+      io.write(open(info[:url]).read)
+      io.close
+
+      if info[:uncompress] != false
+        case info[:filetype]
+        when "tarball"
+          `tar -xzf #{io.path} -C #{type_dir}`
+        when "jar", "zip"
+          FileUtils.mkdir(destination)
+          Dir.chdir(destination) do
+            if info[:filetype] == "jar"
+              `jar -xf #{io.path}`
+            else
+              `unzip #{io.path}`
+            end
+          end
+        end
+        io.unlink
+      end
+      if info[:filename] && info[:symlink]
+        Dir.chdir(type_dir) do
+          FileUtils.ln_sf("./#{info[:filename]}", info[:symlink], :verbose => true)
+        end
+      end
+    end
+  end
+end

data/test/README.txt

@@ -0,0 +1,6 @@
+Test notes
+==========
+
+* You need a local MySQL database running on port 3306 with the database
+  'coupler_fake_data' that the user 'coupler' can access with password
+  'cupla'.

data/test/config.yml

@@ -0,0 +1,9 @@
+h2:
+  :path: <%= File.join(File.dirname(__FILE__), '..', 'db', 'test', 'coupler_fake_data') %>
+
+mysql:
+  :host: localhost
+  :port: 3306
+  :username: coupler
+  :password: cupla
+  :database_name: coupler_fake_data

data/test/coupler/models/test_import.rb

@@ -0,0 +1,221 @@
+require File.dirname(__FILE__) + '/../../helper'
+
+module Coupler
+  module Models
+    class TestImport < Test::Unit::TestCase
+      def test_sequel_model
+        assert_equal ::Sequel::Model, Models::Import.superclass
+        assert_equal :imports, Import.table_name
+      end
+
+      def test_many_to_one_project
+        assert_respond_to Models::Import.new, :project
+      end
+
+      def test_gets_name_from_original_filename
+        import = Import.new(:data => fixture_file_upload('people.csv'))
+        assert_equal "People", import.name
+      end
+
+      def test_preview_with_headers
+        import = Factory.build(:import)
+        preview = import.preview
+        assert_kind_of Array, preview
+        assert_equal 50, preview.length
+        assert_kind_of Array, preview[0]
+        assert_not_equal %w{id first_name last_name age}, preview[0]
+      end
+
+      def test_discovers_field_names_and_types
+        import = Factory.build(:import, :data => fixture_file_upload("people.csv"))
+        expected_types = %w{integer string string integer}
+        expected_names = %w{id first_name last_name age}
+        assert_equal expected_names, import.field_names
+        assert_equal expected_types, import.field_types
+        assert_equal "id", import.primary_key_name
+        assert import.has_headers
+      end
+
+      def test_discover_for_csv_with_no_headers
+        tempfile = Tempfile.new('coupler-import')
+        tempfile.write("foo,bar,1,2,3\njunk,blah,4,5,6")
+        tempfile.close
+        import = Factory.build(:import, :data => file_upload(tempfile.path))
+        expected_types = %w{string string integer integer integer}
+        assert_equal expected_types, import.field_types
+        assert_nil import.field_names
+        assert_nil import.primary_key_name
+        assert !import.has_headers
+      end
+
+      def test_import!
+        project = Factory(:project)
+        import = Factory(:import, :data => fixture_file_upload("people.csv"), :project => project)
+        now = Time.now
+        Timecop.freeze(now) do
+          assert import.import!
+          assert_equal now, import.occurred_at
+        end
+
+        project.local_database do |db|
+          name = :"import_#{import.id}"
+          assert db.tables.include?(name)
+          schema = db.schema(name)
+          assert_equal [:integer, true], schema.assoc(:id)[1].values_at(:type, :primary_key)
+          assert_equal :string, schema.assoc(:first_name)[1][:type]
+          assert_equal :string, schema.assoc(:last_name)[1][:type]
+          assert_equal :integer, schema.assoc(:age)[1][:type]
+
+          ds = db[name]
+          assert_equal 50, ds.count
+        end
+      end
+
+      def test_requires_field_names
+        import = Factory.build(:import, :data => fixture_file_upload('no-headers.csv'))
+        assert_nil import.field_names
+        assert !import.valid?
+      end
+
+      def test_requires_primary_key_name
+        import = Factory.build(:import, :data => fixture_file_upload('no-headers.csv'))
+        import.field_names = %w{id first_name last_name age}
+        assert !import.valid?
+      end
+
+      def test_requires_valid_primary_key_name
+        import = Factory.build(:import, :data => fixture_file_upload('no-headers.csv'))
+        import.field_names = %w{id first_name last_name age}
+        import.primary_key_name = "foo"
+        assert !import.valid?
+      end
+
+      def test_flags_duplicate_primary_keys
+        tempfile = Tempfile.new('coupler-import')
+        tempfile.write("id,foo,bar\n1,abc,def\n2,ghi,jkl\n2,mno,pqr")
+        tempfile.close
+
+        project = Factory(:project)
+        import = Factory(:import, :data => file_upload(tempfile.path), :project => project)
+
+        now = Time.at(Time.now.to_i)  # dumb usecs
+        Timecop.freeze(now) do
+          assert !import.import!
+          assert import.has_duplicate_keys
+          assert_equal now, import.occurred_at, "now: %d-%d; occurred_at: %d-%d" % [now.to_i, now.usec, import.occurred_at.to_i, import.occurred_at.usec]
+        end
+
+        project.local_database do |db|
+          ds = db[:"import_#{import.id}"]
+          assert ds.filter(:id => 2).select_map(:dup_key_count).all?
+        end
+      end
+
+      def test_requires_unique_field_names
+        tempfile = Tempfile.new('coupler-import')
+        tempfile.write("id,foo,foo\n1,abc,def\n2,ghi,jkl\n3,mno,pqr")
+        tempfile.close
+
+        import = Factory.build(:import, :data => file_upload(tempfile.path))
+        assert !import.valid?
+      end
+
+      def test_requires_unused_resource_name
+        project = Factory(:project)
+        resource = Factory(:resource, :name => "Foo", :project => project)
+        import = Factory.build(:import, :data => fixture_file_upload('people.csv'), :name => "Foo", :project => project)
+        assert !import.valid?
+      end
+
+      def test_dataset
+        project = Factory(:project)
+        import = Factory(:import, :project => project)
+        import.import!
+        project.local_database do |db|
+          import.dataset do |ds|
+            expected = db[:"import_#{import.id}"]
+            assert_equal expected.first_source, ds.first_source
+            assert_equal db.uri, ds.db.uri
+          end
+        end
+      end
+
+      def test_filenames_dont_conflict
+        dir = make_tmpdir
+        filename = File.join(dir, "people.csv")
+        tempfile = File.open(filename, 'w')
+        tempfile.puts("id,foo,bar\n")
+        tempfile.puts("abc,def,ghi\n")
+        tempfile.close
+        import_1 = Factory(:import, :data => fixture_file_upload('people.csv'))
+        import_2 = Factory(:import, :data => file_upload(filename))
+        assert_not_equal import_1.data.store_path, import_2.data.store_path
+      end
+
+      def test_repair_duplicate_keys
+        project = Factory(:project)
+        import = Factory(:import, :data => fixture_file_upload('duplicate-keys.csv'), :project => project)
+        import.import!
+
+        import.repair_duplicate_keys!(nil)
+        import.dataset do |ds|
+          assert !ds.columns!.include?(:dup_key_count)
+          assert_equal 1, ds.filter(:id => 2).count
+          assert_equal 1, ds.filter(:id => 4).count
+        end
+        project.local_database do |db|
+          assert db.schema(:"import_#{import.id}").assoc(:id)[1][:primary_key]
+        end
+      end
+
+      def test_repair_duplicate_keys_with_deletions
+        tempfile = Tempfile.new('coupler-import')
+        tempfile.write("id,foo,bar\n1,2,3\n1,4,5\n1,6,7\n123,456,789\n")
+        tempfile.close
+
+        project = Factory(:project)
+        #puts "Project: #{project.id}"
+        import = Factory(:import, :data => file_upload(tempfile.path), :project => project)
+        #puts "Import: #{import.id}"
+        import.import!
+
+        import.repair_duplicate_keys!({"1" => ["1"]})
+        import.dataset do |ds|
+          assert !ds.columns!.include?(:dup_key_count)
+          assert_equal 1, ds.filter(:id => 1).count
+          assert_equal 1, ds.filter(:id => 124).count
+          assert_equal 0, ds.filter(:id => 125).count
+        end
+        project.local_database do |db|
+          assert db.schema(:"import_#{import.id}").assoc(:id)[1][:primary_key]
+        end
+      end
+
+      def test_discover_fields_for_csv_with_headers_and_varying_number_of_fields
+        tempfile = Tempfile.new('coupler-import')
+        tempfile.write("id,foo,bar\n1,2,3\n1,4,5\n1,6,7,\n123,456,789,,\n")
+        tempfile.close
+
+        import = Factory.build(:import, :data => file_upload(tempfile.path))
+        expected_types = %w{integer integer integer string string}
+        expected_names = %w{id foo bar}
+        assert_equal expected_names, import.field_names
+        assert_equal expected_types, import.field_types
+        assert_equal "id", import.primary_key_name
+        assert import.has_headers
+      end
+
+      def test_importing_bad_integers
+        tempfile = Tempfile.new('coupler-import')
+        tempfile.write(%{id,foo,bar\n1,2,3\n2,4,5\n3,6,7\n4,456,""\n})
+        tempfile.close
+
+        project = Factory(:project)
+        import = Factory(:import, :data => file_upload(tempfile.path), :project => project)
+        assert_nothing_raised do
+          import.import!
+        end
+      end
+    end
+  end
+end

data/test/factories.rb

@@ -0,0 +1,91 @@
+require 'factory_girl'
+
+Factory.sequence(:connection_name) { |n| "Connection #{n}" }
+Factory.define :connection, :class => Coupler::Models::Connection do |c|
+  c.name { Factory.next(:connection_name) }
+  c.adapter "h2"
+end
+
+Factory.sequence(:resource_name) { |n| "Resource #{n}" }
+Factory.define :resource, :class => Coupler::Models::Resource do |r|
+  r.name { Factory.next(:resource_name) }
+  r.table_name "people"
+  r.association :connection
+  r.association :project
+end
+
+Factory.define :project, :class => Coupler::Models::Project do |d|
+  d.sequence(:name) { |n| "Project #{n}" }
+end
+
+Factory.define :transformation, :class => Coupler::Models::Transformation do |t|
+  t.association :transformer
+  t.association :resource
+  t.source_field do |record|
+    record.resource.fields_dataset.first rescue nil
+  end
+end
+
+Factory.define :scenario, :class => Coupler::Models::Scenario do |s|
+  s.sequence(:name) { |n| "Scenario #{n}" }
+  s.association :project
+  s.resource_1 { |x| x.project ? Factory(:resource, :project => x.project) : nil }
+end
+
+Factory.define :matcher, :class => Coupler::Models::Matcher do |m|
+  m.association :scenario
+  m.comparisons_attributes do |record|
+    resources = record.scenario.resources
+    [{
+      'lhs_type' => 'field', 'raw_lhs_value' => resources[0].fields_dataset.order('id DESC').last.id, 'lhs_which' => 1,
+      'rhs_type' => 'field', 'raw_rhs_value' => resources[-1].fields_dataset.order('id DESC').last.id, 'rhs_which' => 2,
+      'operator' => 'equals'
+    }]
+  end
+end
+
+Factory.define :result, :class => Coupler::Models::Result do |r|
+  r.association :scenario
+end
+
+Factory.define :resource_job, :class => Coupler::Models::Job do |j|
+  j.name 'transform'
+  j.status 'scheduled'
+  j.association :resource
+end
+
+Factory.define :scenario_job, :class => Coupler::Models::Job do |j|
+  j.name 'run_scenario'
+  j.status 'scheduled'
+  j.association :scenario
+end
+
+Factory.define :transformer, :class => Coupler::Models::Transformer do |t|
+  t.sequence(:name) { |n| "Transformer #{n}" }
+  t.code "value"
+  t.allowed_types { |x| %w{string integer datetime} }
+  t.result_type "same"
+end
+
+Factory.define :field, :class => Coupler::Models::Field do |f|
+  f.sequence(:name) { |n| "field_#{n}" }
+  f.add_attribute :type, "integer"
+  f.db_type "int(11)"
+  f.is_primary_key 0
+  f.is_selected 1
+  f.association :resource
+end
+
+Factory.define :comparison, :class => Coupler::Models::Comparison do |c|
+  c.association :matcher
+  c.lhs_type "integer"
+  c.raw_lhs_value 1
+  c.rhs_type "integer"
+  c.raw_rhs_value 1
+  c.operator "equals"
+end
+
+Factory.define :import, :class => Coupler::Models::Import do |i|
+  i.data { File.open(File.join(File.dirname(__FILE__), 'fixtures', 'people.csv')) }
+  i.association :project
+end

data/test/fixtures/duplicate-keys.csv

@@ -0,0 +1,5 @@
+id,foo,bar
+1,abc,def
+2,ghi,jkl
+2,mno,pqr
+3,stu,vwx