bricolage-mysql 5.26.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 40b5df765b4ebd354186a18ab772d9ea55029f48
+  data.tar.gz: 04beadc0f12491319d8ecbd7bf6cd59f6d832923
+SHA512:
+  metadata.gz: 94fa61e79d6690a6d68349934948cdb1b40721c24855c759464889525d7a6c9947ce457f0618294f6bfb94ace7f132c354220a745e6eff460e4dc878b9146eb9
+  data.tar.gz: a0c9b275eaf45b0f7bb9dc8083b05bbd939d870ab7f7c6d24ce1dc94cc789515e06914776e80f276db5458be9d7b2a226bc9bc8d9cd287eb9ca220f6b976af70

data/README.md

@@ -0,0 +1,25 @@
+# bricolage-mysql
+
+MySQL-related job classes for Bricolage batch job framework.
+
+## Home Page
+
+https://github.com/bricolages/bricolage-mysql
+
+## Usage
+
+Add following line in your Gemfile:
+```
+gem 'bricolage-mysql'
+```
+
+## License
+
+MIT license.
+See LICENSES file for details.
+
+## Credit
+
+Author: Minero Aoki
+
+This software is written in working time in Cookpad, Inc.

data/RELEASE.md

@@ -0,0 +1,5 @@
+# bricolage-mysql gem release note
+
+## version 5.26.0
+
+- first release.

data/jobclass/my-export.rb

@@ -0,0 +1,40 @@
+JobClass.define('my-export') {
+  parameters {|params|
+    params.add SQLFileParam.new(optional: true)
+    params.add DestFileParam.new
+    params.add SrcTableParam.new
+    params.add EnumParam.new('format', %w(json tsv csv), 'Target file format.', default: 'json')
+    params.add OptionalBoolParam.new('gzip', 'If true, compresses target file by gzip.')
+    params.add OptionalBoolParam.new('override', 'If true, clears target file.  Otherwise causes error.')
+    params.add OptionalBoolParam.new('sqldump', 'If true, clears use sqldump command to dump, only wheen usable.')
+    params.add DataSourceParam.new('mysql')
+  }
+
+  declarations {|params|
+    sql_statement(params).declarations
+  }
+
+  script {|params, script|
+    script.task(params['data-source']) {|task|
+      task.export sql_statement(params),
+        path: params['dest-file'],
+        format: params['format'],
+        override: params['override'],
+        gzip: params['gzip'],
+        sqldump: params['sqldump']
+    }
+  }
+
+  def sql_statement(params)
+    if sql = params['sql-file']
+      sql
+    else
+      srcs = params['src-tables']
+      raise ParameterError, "src-tables must be singleton when no sql-file is given" unless srcs.size == 1
+      src_table_var = srcs.keys.first
+      stmt = SQLStatement.for_string("select * from $#{src_table_var};")
+      stmt.declarations = Declarations.new({src_table_var => src_table_var})
+      stmt
+    end
+  end
+}

data/jobclass/my-import-delta.rb

@@ -0,0 +1,66 @@
+require 'bricolage/psqldatasource'
+require 'bricolage/mysqldatasource'
+
+JobClass.define('my-import-delta') {
+  parameters {|params|
+    # S3Export
+    params.add SrcTableParam.new(optional: false)
+    params.add DataSourceParam.new('mysql', 'src-ds', 'Source data source.')
+    params.add SQLFileParam.new(optional: true)
+    params.add DataSourceParam.new('s3', 's3-ds', 'Temporary file storage.')
+    params.add DestFileParam.new('s3-prefix', 'PREFIX', 'Temporary S3 prefix.')
+    params.add KeyValuePairsParam.new('dump-options', 'KEY:VALUE', 'dump options.', optional: true)
+
+    # Delete, Load
+    params.add DataSourceParam.new('sql', 'dest-ds', 'Destination data source.')
+    params.add StringParam.new('delete-cond', 'SQL_EXPR', 'DELETE condition.')
+    params.add DestTableParam.new(optional: false)
+    params.add KeyValuePairsParam.new('options', 'OPTIONS', 'Loader options.',
+        optional: true, default: PSQLLoadOptions.new,
+        value_handler: lambda {|value, ctx, vars| PSQLLoadOptions.parse(value) })
+
+    # Misc
+    params.add OptionalBoolParam.new('analyze', 'ANALYZE table after SQL is executed.', default: true)
+    params.add OptionalBoolParam.new('vacuum', 'VACUUM table after SQL is executed.')
+    params.add OptionalBoolParam.new('vacuum-sort', 'VACUUM SORT table after SQL is executed.')
+
+    # All
+    params.add OptionalBoolParam.new('export', 'Runs EXPORT task.')
+    params.add OptionalBoolParam.new('load', 'Runs LOAD task.')
+    params.add OptionalBoolParam.new('gzip', 'Compress Temporary files.')
+  }
+
+  script {|params, script|
+    run_all = !params['export'] && !params['load']
+
+    # S3Export
+    if params['export'] || run_all
+      script.task(params['src-ds']) {|task|
+        task.s3export params['src-tables'].values.first.to_s,
+                      params['sql-file'],
+                      params['s3-ds'],
+                      params['s3-prefix'],
+                      params['gzip'],
+                      dump_options: params['dump-options']
+      }
+    end
+
+    # Load
+    if params['load'] || run_all
+      script.task(params['dest-ds']) {|task|
+        task.transaction {
+          # DELETE
+          task.exec SQLStatement.delete_where(params['delete-cond']) if params['delete-cond']
+
+          # COPY
+          task.load params['s3-ds'], params['s3-prefix'], params['dest-table'],
+              'json', nil, params['options'].merge('gzip' => params['gzip'])
+        }
+
+        # VACUUM, ANALYZE
+        task.vacuum_if params['vacuum'], params['vacuum-sort'], params['dest-table']
+        task.analyze_if params['analyze'], params['dest-table']
+      }
+    end
+  }
+}

data/jobclass/my-import.rb

@@ -0,0 +1,84 @@
+require 'bricolage/psqldatasource'
+require 'bricolage/mysqldatasource'
+
+JobClass.define('my-import') {
+  parameters {|params|
+    # S3Export
+    params.add SrcTableParam.new(optional: false)
+    params.add DataSourceParam.new('mysql', 'src-ds', 'Source data source.')
+    params.add SQLFileParam.new(optional: true)
+    params.add DataSourceParam.new('s3', 's3-ds', 'Temporary file storage.')
+    params.add DestFileParam.new('s3-prefix', 'PREFIX', 'Temporary S3 prefix.')
+    params.add KeyValuePairsParam.new('dump-options', 'KEY:VALUE', 'dump options.', optional: true)
+
+    # Load
+    params.add DestTableParam.new(optional: false)
+    params.add DataSourceParam.new('sql', 'dest-ds', 'Destination data source.')
+    params.add KeyValuePairsParam.new('options', 'OPTIONS', 'Loader options.',
+        optional: true, default: PSQLLoadOptions.new,
+        value_handler: lambda {|value, ctx, vars| PSQLLoadOptions.parse(value) })
+    params.add SQLFileParam.new('table-def', 'PATH', 'Create table file.')
+    params.add OptionalBoolParam.new('no-backup', 'Do not backup current table with suffix "_old".', default: false)
+
+    # Misc
+    params.add OptionalBoolParam.new('analyze', 'ANALYZE table after SQL is executed.', default: true)
+    params.add OptionalBoolParam.new('vacuum', 'VACUUM table after SQL is executed.')
+    params.add OptionalBoolParam.new('vacuum-sort', 'VACUUM SORT table after SQL is executed.')
+    params.add KeyValuePairsParam.new('grant', 'KEY:VALUE', 'GRANT table after SQL is executed. (required keys: privilege, to)')
+
+    # All
+    params.add OptionalBoolParam.new('export', 'Runs EXPORT task.')
+    params.add OptionalBoolParam.new('put', 'Runs PUT task.')
+    params.add OptionalBoolParam.new('load', 'Runs LOAD task.')
+    params.add OptionalBoolParam.new('gzip', 'Compress Temporary files.')
+  }
+
+  script {|params, script|
+    run_all = !params['export'] && !params['put'] && !params['load']
+
+    # S3Export
+    if params['export'] || run_all
+      script.task(params['src-ds']) {|task|
+        task.s3export params['src-tables'].keys.first,
+                      params['sql-file'],
+                      params['s3-ds'],
+                      params['s3-prefix'],
+                      params['gzip'],
+                      dump_options: params['dump-options']
+      }
+    end
+
+    # Load
+    if params['load'] || run_all
+      script.task(params['dest-ds']) {|task|
+        prev_table = '${dest_table}_old'
+        work_table = '${dest_table}_wk'
+
+        task.transaction {
+          # CREATE
+          task.drop_force prev_table
+          task.drop_force work_table
+          task.exec params['table-def'].replace(/\$\{?dest_table\}?\b/, work_table)
+
+          # COPY
+          task.load params['s3-ds'], params['s3-prefix'], work_table,
+              'json', nil, params['options'].merge('gzip' => params['gzip'])
+
+          # GRANT, ANALYZE
+          task.grant_if params['grant'], work_table
+          task.analyze_if params['analyze'], work_table
+
+          # RENAME
+          task.create_dummy_table '${dest_table}'
+          task.rename_table params['dest-table'].to_s, "#{params['dest-table'].name}_old"
+          task.rename_table work_table, params['dest-table'].name
+        }
+
+        task.drop_force prev_table if params['no-backup']
+
+        # VACUUM: vacuum is needless for newly created table, applying vacuum after exposure is not a problem.
+        task.vacuum_if params['vacuum'], params['vacuum-sort'], params['dest-table'].to_s
+      }
+    end
+  }
+}

data/jobclass/my-migrate.rb

@@ -0,0 +1,116 @@
+require 'bricolage/psqldatasource'
+
+JobClass.define('my-migrate') {
+  parameters {|params|
+    # Export
+    params.add SrcTableParam.new(optional: false)
+    params.add DataSourceParam.new('mysql', 'src-ds', 'Source data source.')
+    params.add DestFileParam.new('tmp-file', 'PATH', 'Temporary local file path.')
+    params.add OptionalBoolParam.new('sqldump', 'If true, use sqldump command to dump, only on available.', default: true)
+    params.add SQLFileParam.new(optional: true)
+
+    # Put
+    params.add DestFileParam.new('s3-file', 'PATH', 'Temporary S3 file path.')
+    params.add DataSourceParam.new('s3', 's3-ds', 'Temporary file storage.')
+    params.add OptionalBoolParam.new('override', 'If true, overwrite s3 target file.  Otherwise causes error.')
+    params.add OptionalBoolParam.new('remove-tmp', 'Removes temporary local files after S3-PUT is succeeded.')
+
+    # Load
+    params.add DestTableParam.new(optional: false)
+    params.add DataSourceParam.new('sql', 'dest-ds', 'Destination data source.')
+    params.add KeyValuePairsParam.new('options', 'OPTIONS', 'Loader options.',
+        optional: true, default: PSQLLoadOptions.new,
+        value_handler: lambda {|value, ctx, vars| PSQLLoadOptions.parse(value) })
+    params.add SQLFileParam.new('table-def', 'PATH', 'Create table file.')
+    params.add OptionalBoolParam.new('no-backup', 'Do not backup current table with suffix "_old".', default: false)
+
+    # Misc
+    params.add OptionalBoolParam.new('analyze', 'ANALYZE table after SQL is executed.', default: true)
+    params.add OptionalBoolParam.new('vacuum', 'VACUUM table after SQL is executed.')
+    params.add OptionalBoolParam.new('vacuum-sort', 'VACUUM SORT table after SQL is executed.')
+    params.add KeyValuePairsParam.new('grant', 'KEY:VALUE', 'GRANT table after SQL is executed. (required keys: privilege, to)')
+
+    # All
+    params.add OptionalBoolParam.new('export', 'Runs EXPORT task.')
+    params.add OptionalBoolParam.new('put', 'Runs PUT task.')
+    params.add OptionalBoolParam.new('load', 'Runs LOAD task.')
+    params.add OptionalBoolParam.new('gzip', 'If true, compresses target file by gzip.', default: true)
+  }
+
+  declarations {|params|
+    decls = sql_statement(params).declarations
+    decls.declare 'dest-table', nil
+    decls
+  }
+
+  script {|params, script|
+    run_all = !params['export'] && !params['put'] && !params['load']
+
+    # Export
+    if params['export'] || run_all
+      script.task(params['src-ds']) {|task|
+        task.export sql_statement(params),
+          path: params['tmp-file'],
+          format: 'json',
+          override: true,
+          gzip: params['gzip'],
+          sqldump: params['sqldump']
+      }
+    end
+
+    # Put
+    if params['put'] || run_all
+      script.task(params['s3-ds']) {|task|
+        task.put params['tmp-file'], params['s3-file'], check_args: false
+      }
+      if params['remove-tmp']
+        script.task(params.file_ds) {|task|
+          task.remove params['tmp-file']
+        }
+      end
+    end
+
+    # Load
+    if params['load'] || run_all
+      script.task(params['dest-ds']) {|task|
+        prev_table = '${dest_table}_old'
+        work_table = '${dest_table}_wk'
+
+        task.transaction {
+          # CREATE
+          task.drop_force prev_table
+          task.drop_force work_table
+          task.exec params['table-def'].replace(/\$\{?dest_table\}?\b/, work_table)
+
+          # COPY
+          task.load params['s3-ds'], params['s3-file'], work_table,
+              'json', nil, params['options'].merge('gzip' => params['gzip'])
+
+          # GRANT, ANALYZE
+          task.grant_if params['grant'], work_table
+          task.analyze_if params['analyze'], work_table
+
+          # RENAME
+          task.create_dummy_table '${dest_table}'
+          task.rename_table params['dest-table'].to_s, "#{params['dest-table'].name}_old"
+          task.rename_table work_table, params['dest-table'].name
+        }
+
+        task.drop_force prev_table if params['no-backup']
+
+        # VACUUM: vacuum is needless for newly created table, applying vacuum after exposure is not a problem.
+        task.vacuum_if params['vacuum'], params['vacuum-sort'], params['dest-table'].to_s
+      }
+    end
+  }
+
+  def sql_statement(params)
+    return params['sql-file'] if params['sql-file']
+    srcs = params['src-tables']
+    raise ParameterError, "src-tables must be singleton when no sql-file is given" unless srcs.size == 1
+    src_table_var = srcs.keys.first
+    stmt = SQLStatement.for_string("select * from $#{src_table_var};")
+    stmt.declarations = Declarations.new({src_table_var => src_table_var})
+    stmt
+  end
+}

data/lib/bricolage/mysqldatasource.rb

@@ -0,0 +1,363 @@
+require 'bricolage/datasource'
+require 'mysql2'
+require 'json'
+require 'csv'
+require 'stringio'
+require 'open3'
+
+module Bricolage
+
+  class MySQLDataSource < DataSource
+    declare_type 'mysql'
+
+    def initialize(**mysql_options)
+      @mysql_options = mysql_options
+      @client = nil
+    end
+
+    attr_reader :mysql_options
+
+    def host
+      @mysql_options[:host]
+    end
+
+    def port
+      @mysql_options[:port]
+    end
+
+    def username
+      @mysql_options[:username]
+    end
+
+    def password
+      @mysql_options[:password]
+    end
+
+    def database
+      @mysql_options[:database]
+    end
+
+    def new_task
+      MySQLTask.new(self)
+    end
+
+    def open
+      @client = Mysql2::Client.new(**@mysql_options)
+      begin
+        yield self
+      ensure
+        c = @client
+        @client = nil
+        c.close
+      end
+    end
+
+    def query(sql, **opts)
+      logger.info "[SQL] #{sql}"
+      connection_check
+      @client.query(sql, **opts)
+    end
+
+    private
+
+    def connection_check
+      unless @client
+        raise FatalError, "#{self.class} used outside of \#open block"
+      end
+    end
+  end
+
+  class MySQLTask < DataSourceTask
+    def export(stmt, path: nil, format: nil, override: false, gzip: false, sqldump: false)
+      add Export.new(stmt, path: path, format: format, override: override, gzip: gzip, sqldump: sqldump)
+    end
+
+    class Export < Action
+      def initialize(stmt, path: nil, format: nil, override: false, gzip: false, sqldump: false)
+        @statement = stmt
+        @path = path
+        @format = format
+        @override = override
+        @gzip = gzip
+        @sqldump = sqldump
+      end
+
+      def bind(*args)
+        @statement.bind(*args)
+      end
+
+      def source
+        @statement.stripped_source
+      end
+
+      def run
+        if @sqldump and sqldump_available? and sqldump_usable?
+          export_by_sqldump
+        else
+          export_by_ruby
+        end
+        JobResult.success
+      end
+
+      def export_by_sqldump
+        cmds = [[{"SQLDUMP_PASSWORD" => ds.password}, sqldump_path.to_s, "--#{@format}", ds.host, ds.port.to_s, ds.username, ds.database, @statement.stripped_source]]
+        cmds.push [GZIP_COMMAND] if @gzip
+        cmds.last.push({out: @path.to_s})
+        ds.logger.info '[CMD] ' + format_pipeline(cmds)
+        statuses = Open3.pipeline(*cmds)
+        statuses.each_with_index do |st, idx|
+          unless st.success?
+            cmd = cmds[idx].first
+            raise JobFailure, "sqldump failed (status #{st.to_i})"
+          end
+        end
+      end
+
+      def format_pipeline(cmds)
+        cmds = cmds.map {|args| args[0].kind_of?(Hash) ? args[1..-1] : args.dup }   # do not show env
+        cmds.map {|args| %Q("#{args.join('" "')}") }.join(' | ')
+      end
+
+      def sqldump_available?
+        sqldump_real_path.executable?
+      end
+
+      def sqldump_path
+        Pathname(__dir__).parent.parent + "libexec/sqldump"
+      end
+
+      def sqldump_real_path
+        Pathname("#{sqldump_path}.#{platform_name}")
+      end
+
+      def platform_name
+        @platform_name ||= `uname -s`.strip
+      end
+
+      def sqldump_usable?
+        %w[json tsv].include?(@format)
+      end
+
+      def export_by_ruby
+        ds.logger.info "exporting table into #{@path} ..."
+        count = 0
+        open_target_file(@path) {|f|
+          writer_class = WRITER_CLASSES[@format] or raise ArgumentError, "unknown export format: #{@format.inspect}"
+          writer = writer_class.new(f)
+          rs = ds.query(@statement.stripped_source, as: writer_class.record_format, stream: true, cache_rows: false)
+          ds.logger.info "got result set, writing..."
+          rs.each do |values|
+            writer.write_record values
+            count += 1
+            ds.logger.info "#{count} records exported..." if count % 10_0000 == 0
+          end
+        }
+        ds.logger.info "#{count} records exported; export finished"
+      end
+
+      private
+
+      # FIXME: parameterize
+      GZIP_COMMAND = 'gzip'
+
+      def open_target_file(path, &block)
+        unless @override
+          raise JobFailure, "destination file already exists: #{path}" if File.exist?(path)
+        end
+        if @gzip
+          ds.logger.info "enable compression: gzip"
+          IO.popen(%Q(#{GZIP_COMMAND} > "#{path}"), 'w', &block)
+        else
+          File.open(path, 'w', &block)
+        end
+      end
+    end
+
+    def s3export(table, stmt, s3ds, prefix, gzip, dump_options)
+      options = dump_options.nil? ? {} : dump_options[:dump_options]
+      add S3Export.new(table, stmt, s3ds, prefix, gzip: gzip,
+        format: options['format'],
+        partition_column: options['partition_column'],
+        partition_number: options['partition_number'],
+        write_concurrency: options['write_concurrency'],
+        rotation_size: options['rotation_size'],
+        delete_objects: options['delete_objects'],
+        object_key_delimiter: options['object_key_delimiter'],
+        src_zone_offset: options['src_zone_offset'],
+        dst_zone_offset: options['dst_zone_offset'])
+    end
+
+    class S3Export < Action
+
+      def initialize(table, stmt, s3ds, prefix, gzip: true,
+         format: "json",
+         partition_column: nil,
+         partition_number: 4,
+         write_concurrency: 4,
+         rotation_size: nil,
+         delete_objects: false,
+         object_key_delimiter: nil,
+         src_zone_offset: nil,
+         dst_zone_offset: nil)
+        @table = table
+        @statement = stmt
+        @s3ds = s3ds
+        @prefix = build_prefix @s3ds.prefix, prefix
+        @format = format
+        @gzip = gzip
+        @partition_column = partition_column
+        @partition_number = partition_number
+        @write_concurrency = write_concurrency
+        @rotation_size = rotation_size
+        @delete_objects = delete_objects
+        @object_key_delimiter = object_key_delimiter
+        @src_zone_offset = src_zone_offset
+        @dst_zone_offset = dst_zone_offset
+      end
+
+      def run
+        s3export
+        JobResult.success
+      end
+
+      def bind(*args)
+        @statement.bind(*args) if @statement
+      end
+
+      def source
+        "-- myexport #{@table} -> #{@s3ds.bucket_name}/#{@prefix}" +
+          (@statement ? "\n#{@statement.stripped_source}" : "")
+      end
+
+      def s3export
+        cmd = build_cmd(command_parameters)
+        ds.logger.info "[CMD] #{cmd}"
+        out, st = Open3.capture2e(environment_variables, cmd)
+        ds.logger.info "[CMDOUT] #{out}"
+        unless st.success?
+          msg = extract_exception_message(out)
+          raise JobFailure, "mys3dump failed (status: #{st.to_i}): #{msg}"
+        end
+      end
+
+      def environment_variables
+        {
+          'AWS_ACCESS_KEY_ID' => @s3ds.access_key,
+          'AWS_SECRET_ACCESS_KEY' => @s3ds.secret_key,
+          'MYS3DUMP_PASSWORD' => ds.password
+        }
+      end
+
+      def command_parameters
+        params = {
+          jar: mys3dump_path.to_s,
+          h: ds.host,
+          P: ds.port.to_s,
+          D: ds.database,
+          u: ds.username,
+          #p: ds.password,
+          o: connection_property,
+          t: @table,
+          b: @s3ds.bucket.name,
+          x: @prefix
+        }
+        params[:q] = @statement.stripped_source.chomp(';') if @statement
+        params[:f] = @format if @format
+        params[:C] = nil if @gzip
+        params[:c] = @partition_column if @partition_column
+        params[:n] = @partition_number if @partition_number
+        params[:w] = @write_concurrency if @write_concurrency
+        params[:r] = @rotation_size if @rotation_size
+        params[:d] = nil if @delete_objects
+        params[:k] = @object_key_delimiter if @object_key_delimiter
+        if src_zone_offset = @src_zone_offset || ds.mysql_options[:src_zone_offset]
+          params[:S] = src_zone_offset
+        end
+        if dst_zone_offset = @dst_zone_offset || ds.mysql_options[:dst_zone_offset]
+          params[:T] = dst_zone_offset
+        end
+        params
+      end
+
+      OPTION_MAP = {
+        encoding: 'useUnicode=true&characterEncoding',
+        read_timeout: 'netTimeoutForStreamingResults',
+        connect_timeout: 'connectTimeout',
+        reconnect: 'autoReconnect',
+        collation: 'connectionCollation'
+      }
+
+      def connection_property
+        ds.mysql_options.map {|k, v| opt = OPTION_MAP[k] ; opt ? "#{opt}=#{v}" : nil }.compact.join('&')
+      end
+
+      def build_prefix(ds_prefix, pm_prefix)
+        ((ds_prefix || "") + "//" +  (pm_prefix.to_s || "")).gsub(%r<\A/>, '').gsub(%r<//>, '/')
+      end
+
+      def mys3dump_path
+        Pathname(__dir__).parent.parent + "libexec/mys3dump.jar"
+      end
+
+      def build_cmd(options)
+        (['java'] + options.flat_map {|k, v| v ? ["-#{k}", v.to_s] : ["-#{k}"] }.map {|o| %Q("#{o}") }).join(" ")
+      end
+
+      def extract_exception_message(out)
+        out.lines do |line|
+          if /^.*Exception: (?<msg>.*)$/ =~ line
+            return msg
+          end
+        end
+      end
+    end
+
+    WRITER_CLASSES = {}
+
+    class JSONWriter
+      def JSONWriter.record_format
+        :hash
+      end
+
+      def initialize(f)
+        @f = f
+      end
+
+      def write_record(values)
+        @f.puts JSON.dump(values)
+      end
+    end
+    WRITER_CLASSES['json'] = JSONWriter
+
+    class TSVWriter
+      def TSVWriter.record_format
+        :array
+      end
+
+      def initialize(f)
+        @f = f
+      end
+
+      def write_record(values)
+        @f.puts values.join("\t")
+      end
+    end
+    WRITER_CLASSES['tsv'] = TSVWriter
+
+    class CSVWriter
+      def CSVWriter.record_format
+        :array
+      end
+
+      def initialize(f)
+        @csv = CSV.new(f)
+      end
+
+      def write_record(values)
+        @csv.add_row values
+      end
+    end
+    WRITER_CLASSES['csv'] = CSVWriter
+  end
+
+end

data/lib/bricolage-mysql.rb

@@ -0,0 +1,5 @@
+require 'bricolage/jobclass'
+require 'pathname'
+
+jobclass_path = Pathname(__dir__).realpath.parent.cleanpath + 'jobclass'
+Bricolage::JobClass.add_load_path jobclass_path

data/libexec/sqldump

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+binary="$0.$(uname -s)"
+if ! [[ -x $binary ]]
+then
+    echo "$0: error: sqldump does not support $(uname -s)" 1>&2
+    exit 1
+fi
+exec "$binary" "$@"

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: bricolage-mysql
+version: !ruby/object:Gem::Version
+  version: 5.26.0
+platform: ruby
+authors:
+- Minero Aoki
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bricolage
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.26.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.26.0
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: aamine@loveruby.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- RELEASE.md
+- jobclass/my-export.rb
+- jobclass/my-import-delta.rb
+- jobclass/my-import.rb
+- jobclass/my-migrate.rb
+- lib/bricolage-mysql.rb
+- lib/bricolage/mysqldatasource.rb
+- libexec/mys3dump.jar
+- libexec/sqldump
+- libexec/sqldump.Darwin
+- libexec/sqldump.Linux
+homepage: https://github.com/bricolages/bricolage-mysql
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: MySQL-related job classes for Bricolage batch framework
+test_files: []