embulk 0.7.0-java

data/lib/embulk/file_input_plugin.rb

@@ -0,0 +1,27 @@
+module Embulk
+
+  class FileInputPlugin
+    # TODO transaction, resume, cleanup
+    # TODO run
+
+    if Embulk.java?
+      # TODO to_java
+
+      def self.from_java(java_class)
+        JavaPlugin.ruby_adapter_class(java_class, FileInputPlugin, RubyAdapter)
+      end
+
+      module RubyAdapter
+        module ClassMethods
+          def new_java
+            Java::FileInputRunner.new(Java.injector.getInstance(java_class))
+          end
+          # TODO transaction, resume, cleanup
+        end
+
+        # TODO run
+      end
+    end
+  end
+
+end

data/lib/embulk/file_output.rb

@@ -0,0 +1,56 @@
+
+module Embulk
+  require 'embulk/buffer'
+
+  class FileOutput
+    def initialize(java_file_output)
+      @java_file_output = java_file_output
+      @buffer = Buffer.new
+      @buffer.force_encoding('ASCII-8BIT')
+      @flush_size = 32*1024
+    end
+
+    def next_file
+      flush
+      @java_file_output.nextFile
+      self
+    end
+
+    def write(buffer)
+      buffer.force_encoding('ASCII-8BIT')  # TODO this is destructively change buffer
+      @buffer << buffer
+      if @buffer.size > @flush_size
+        flush
+      end
+      nil
+    end
+
+    def add(buffer)
+      flush
+      @java_file_output.add(Buffer.from_ruby_string(buffer))
+      nil
+    end
+
+    def flush
+      unless @buffer.empty?
+        @java_file_output.add(@buffer.to_java)
+        @buffer.clear
+      end
+      nil
+    end
+
+    def finish
+      flush
+      @java_file_output.finish
+    end
+
+    def close
+      @java_file_output.close
+    end
+
+    def to_java
+      @java_file_output
+    end
+  end
+
+end

data/lib/embulk/file_output_plugin.rb

@@ -0,0 +1,27 @@
+module Embulk
+
+  class FileOutputPlugin
+    # TODO transaction, resume, cleanup
+    # TODO add, finish, close, abort, commit
+
+    if Embulk.java?
+      # TODO to_java
+
+      def self.from_java(java_class)
+        JavaPlugin.ruby_adapter_class(java_class, FileOutputPlugin, RubyAdapter)
+      end
+
+      module RubyAdapter
+        module ClassMethods
+          def new_java
+            Java::FileOutputRunner.new(Java.injector.getInstance(java_class))
+          end
+          # TODO transaction, resume, cleanup
+        end
+
+        # TODO add, finish, close, abort, commit
+      end
+    end
+  end
+
+end

data/lib/embulk/filter_plugin.rb

@@ -0,0 +1,105 @@
+module Embulk
+
+  require 'embulk/data_source'
+  require 'embulk/schema'
+  require 'embulk/page'
+  require 'embulk/page_builder'
+
+  class FilterPlugin
+    def self.transaction(config, in_schema, &control)
+      yield(config)
+      return {}
+    end
+
+    def initialize(task, in_schema, out_schema, page_builder)
+      @task = task
+      @in_schema = in_schema
+      @out_schema = out_schema
+      @page_builder = page_builder
+      init
+    end
+
+    attr_reader :task, :in_schema, :out_schema, :page_builder
+
+    def init
+    end
+
+    def add(page)
+      raise NotImplementedError, "FilterPlugin#add(page) must be implemented"
+    end
+
+    def finish
+    end
+
+    def close
+    end
+
+    if Embulk.java?
+      def self.new_java
+        JavaAdapter.new(self)
+      end
+
+      class JavaAdapter
+        include Java::FilterPlugin
+
+        def initialize(ruby_class)
+          @ruby_class = ruby_class
+        end
+
+        def transaction(java_config, java_in_schema, java_control)
+          config = DataSource.from_java(java_config)
+          in_schema = Schema.from_java(java_in_schema)
+          @ruby_class.transaction(config, in_schema) do |task_source_hash, out_columns|
+            java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
+            java_out_schemas = Schema.new(out_columns).to_java
+            java_control.run(java_task_source, java_out_schemas)
+          end
+          nil
+        end
+
+        def open(java_task_source, java_in_schema, java_out_schema, java_output)
+          task_source = DataSource.from_java(java_task_source)
+          in_schema = Schema.from_java(java_in_schema)
+          out_schema = Schema.from_java(java_out_schema)
+          page_builder = PageBuilder.new(out_schema, java_output)
+          ruby_object = @ruby_class.new(task_source, in_schema, out_schema, page_builder)
+          return OutputAdapter.new(ruby_object, in_schema, page_builder)
+        end
+
+        class OutputAdapter
+          include Java::TransactionalPageOutput
+
+          def initialize(ruby_object, in_schema, page_builder)
+            @ruby_object = ruby_object
+            @in_schema = in_schema
+            @page_builder = page_builder
+          end
+
+          def add(java_page)
+            @ruby_object.add Page.new(java_page, @in_schema)
+          end
+
+          def finish
+            @ruby_object.finish
+          end
+
+          def close
+            @ruby_object.close
+          ensure
+            @page_builder.close
+          end
+        end
+      end
+
+      def self.from_java(java_class)
+        JavaPlugin.ruby_adapter_class(java_class, FilterPlugin, RubyAdapter)
+      end
+
+      module RubyAdapter
+        module ClassMethods
+        end
+        # TODO
+      end
+    end
+  end
+end

data/lib/embulk/formatter_plugin.rb

@@ -0,0 +1,105 @@
+module Embulk
+
+  require 'embulk/data_source'
+  require 'embulk/schema'
+  require 'embulk/page'
+  require 'embulk/file_output'
+
+  class FormatterPlugin
+    def self.transaction(config, schema, &control)
+      yield(config)
+      return {}
+    end
+
+    def initialize(task, schema, file_output)
+      @task = task
+      @schema = schema
+      @file_output = file_output
+      init
+    end
+
+    attr_reader :task, :schema, :file_output
+
+    def init
+    end
+
+    def add(page)
+      raise NotImplementedError, "FormatterPlugin#add(page) must be implemented"
+    end
+
+    def finish
+    end
+
+    def close
+    end
+
+    if Embulk.java?
+      def self.new_java
+        JavaAdapter.new(self)
+      end
+
+      class JavaAdapter
+        include Java::FormatterPlugin
+
+        def initialize(ruby_class)
+          @ruby_class = ruby_class
+        end
+
+        def transaction(java_config, java_schema, java_control)
+          config = DataSource.from_java(java_config)
+          schema = Schema.from_java(java_schema)
+          @ruby_class.transaction(config, schema) do |task_source_hash|
+            java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
+            java_control.run(java_task_source)
+          end
+          nil
+        end
+
+        def open(java_task_source, java_schema, java_file_output)
+          task_source = DataSource.from_java(java_task_source)
+          schema = Schema.from_java(java_schema)
+          file_output = FileOutput.new(java_file_output)
+          ruby_object = @ruby_class.new(task_source, schema, file_output)
+          return OutputAdapter.new(ruby_object, schema, file_output)
+        end
+
+        class OutputAdapter
+          include Java::TransactionalPageOutput
+
+          def initialize(ruby_object, schema, file_output)
+            @ruby_object = ruby_object
+            @schema = schema
+            @file_output = file_output
+          end
+
+          def add(java_page)
+            # TODO reuse page reader
+            @ruby_object.add Page.new(java_page, @schema)
+          end
+
+          def finish
+            @ruby_object.finish
+          end
+
+          def close
+            @ruby_object.close
+          ensure
+            @file_output.close
+          end
+        end
+      end
+
+      def self.from_java(java_class)
+        JavaPlugin.ruby_adapter_class(java_class, FormatterPlugin, RubyAdapter)
+      end
+
+      module RubyAdapter
+        module ClassMethods
+          # TODO transaction, resume, cleanup
+        end
+        # TODO add, finish, close
+      end
+    end
+  end
+
+end

data/lib/embulk/guess/charset.rb

@@ -0,0 +1,44 @@
+module Embulk
+  module Guess
+
+    class CharsetGuessPlugin < GuessPlugin
+      Plugin.register_guess('charset', self)
+
+      STATIC_MAPPING = {
+        # ISO-8859-1 means ASCII which is a subset of UTF-8 in most of cases
+        # due to lack of sample data set.
+        "ISO-8859-1" => "UTF-8",
+
+        # Shift_JIS is used almost only by Windows that uses "CP932" in fact.
+        # And "CP932" called by Microsoft actually means "MS932" in Java.
+        "Shift_JIS" => "MS932",
+      }
+
+      def guess(config, sample_buffer)
+        # ICU4J
+        begin
+          detector_class = com.ibm.icu.text.CharsetDetector
+        rescue NameError
+          # icu4j is removed from embulk.gem package explicitly at embulk.gemspec
+          # if gem is packaged for JRuby to reduce binary size. Instead, if it's
+          # packaged for JRuby, embulk.gemspec adds rjack-icu to its dependency.
+          require 'rjack-icu'
+          detector_class = com.ibm.icu.text.CharsetDetector
+        end
+        detector = detector_class.new
+        detector.setText(sample_buffer.to_java_bytes)
+        best_match = detector.detect
+        if best_match.getConfidence < 50
+          name = "UTF-8"
+        else
+          name = best_match.getName
+          if mapped_name = STATIC_MAPPING[name]
+            name = mapped_name
+          end
+        end
+        return {"parser" => {"charset" => name}}
+      end
+    end
+
+  end
+end

data/lib/embulk/guess/csv.rb

@@ -0,0 +1,327 @@
+module Embulk
+  module Guess
+    require 'embulk/guess/schema_guess'
+
+    class CsvGuessPlugin < LineGuessPlugin
+      Plugin.register_guess('csv', self)
+
+      DELIMITER_CANDIDATES = [
+        ",", "\t", "|"
+      ]
+
+      QUOTE_CANDIDATES = [
+        "\"", "'"
+      ]
+
+      ESCAPE_CANDIDATES = [
+        "\\", '"'
+      ]
+
+      NULL_STRING_CANDIDATES = [
+        "null",
+        "NULL",
+        "#N/A",
+        "\\N",  # MySQL LOAD, Hive STORED AS TEXTFILE
+      ]
+
+      COMMENT_LINE_MARKER_CANDIDATES = [
+        "#",
+        "//",
+      ]
+
+      MAX_SKIP_LINES = 10
+      NO_SKIP_DETECT_LINES = 10
+
+      def guess_lines(config, sample_lines)
+        return {} unless config.fetch("parser", {}).fetch("type", "csv") == "csv"
+
+        parser_config = config["parser"] || {}
+        if parser_config["type"] == "csv" && parser_config["delimiter"]
+          delim = parser_config["delimiter"]
+        else
+          delim = guess_delimiter(sample_lines)
+          unless delim
+            # not CSV file
+            return {}
+          end
+        end
+
+        parser_guessed = DataSource.new.merge(parser_config).merge({"type" => "csv", "delimiter" => delim})
+
+        unless parser_guessed.has_key?("quote")
+          quote = guess_quote(sample_lines, delim)
+          unless quote
+            if !guess_force_no_quote(sample_lines, delim, '"')
+              # assuming CSV follows RFC for quoting
+              quote = '"'
+            else
+              # disable quoting (set null)
+            end
+          end
+          parser_guessed["quote"] = quote
+        end
+        parser_guessed["quote"] = '"' if parser_guessed["quote"] == ''  # setting '' is not allowed any more. this line converts obsoleted config syntax to explicit syntax.
+
+        unless parser_guessed.has_key?("escape")
+          if quote = parser_guessed["quote"]
+            escape = guess_escape(sample_lines, delim, quote)
+            unless escape
+              if quote == '"'
+                # assuming this CSV follows RFC for escaping
+                escape = '"'
+              else
+                # disable escaping (set null)
+              end
+              parser_guessed["escape"] = escape
+            end
+          else
+            # escape does nothing if quote is disabled
+          end
+        end
+
+        unless parser_guessed.has_key?("null_string")
+          null_string = guess_null_string(sample_lines, delim)
+          parser_guessed["null_string"] = null_string if null_string
+          # don't even set null_string to avoid confusion of null and 'null' in YAML format
+        end
+
+        # guessing skip_header_lines should be before guessing guess_comment_line_marker
+        # because lines supplied to CsvTokenizer already don't include skipped header lines.
+        # skipping empty lines is also disabled here because skipping header lines is done by
+        # CsvParser which doesn't skip empty lines automatically
+        sample_records = split_lines(parser_guessed, false, sample_lines, delim, {})
+        skip_header_lines = guess_skip_header_lines(sample_records)
+        sample_lines = sample_lines[skip_header_lines..-1]
+        sample_records = sample_records[skip_header_lines..-1]
+
+        unless parser_guessed.has_key?("comment_line_marker")
+          comment_line_marker, sample_lines =
+            guess_comment_line_marker(sample_lines, delim, parser_guessed["quote"], parser_guessed["null_string"])
+          if comment_line_marker
+            parser_guessed["comment_line_marker"] = comment_line_marker
+          end
+        end
+
+        sample_records = split_lines(parser_guessed, true, sample_lines, delim, {})
+
+        first_types = SchemaGuess.types_from_array_records(sample_records[0, 1])
+        other_types = SchemaGuess.types_from_array_records(sample_records[1..-1] || [])
+
+        if first_types.size <= 1 || other_types.size <= 1
+          # guess failed
+          return {}
+        end
+
+        unless parser_guessed.has_key?("trim_if_not_quoted")
+          sample_records_trimmed = split_lines(parser_guessed, true, sample_lines, delim, {"trim_if_not_quoted" => true})
+          other_types_trimmed = SchemaGuess.types_from_array_records(sample_records_trimmed[1..-1] || [])
+          if other_types != other_types_trimmed
+            parser_guessed["trim_if_not_quoted"] = true
+            other_types = other_types_trimmed
+          else
+            parser_guessed["trim_if_not_quoted"] = false
+          end
+        end
+
+        header_line = (first_types != other_types && first_types.all? {|t| ["string", "boolean"].include?(t) })
+
+        if header_line
+          parser_guessed["skip_header_lines"] = skip_header_lines + 1
+        else
+          parser_guessed["skip_header_lines"] = skip_header_lines
+        end
+
+        parser_guessed["allow_extra_columns"] = false unless parser_guessed.has_key?("allow_extra_columns")
+        parser_guessed["allow_optional_columns"] = false unless parser_guessed.has_key?("allow_optional_columns")
+
+        if header_line
+          column_names = sample_records.first
+        else
+          column_names = (0..other_types.size).to_a.map {|i| "c#{i}" }
+        end
+        schema = []
+        column_names.zip(other_types).each do |name,type|
+          if name && type
+            if type.is_a?(SchemaGuess::TimestampTypeMatch)
+              schema << {"name" => name, "type" => type, "format" => type.format}
+            else
+              schema << {"name" => name, "type" => type}
+            end
+          end
+        end
+        parser_guessed["columns"] = schema
+
+        return {"parser" => parser_guessed}
+      end
+
+      private
+
+      def split_lines(parser_config, skip_empty_lines, sample_lines, delim, extra_config)
+        null_string = parser_config["null_string"]
+        config = parser_config.merge(extra_config).merge({"charset" => "UTF-8", "columns" => []})
+        parser_task = config.load_config(org.embulk.standards.CsvParserPlugin::PluginTask)
+        data = sample_lines.map {|line| line.force_encoding('UTF-8') }.join(parser_task.getNewline.getString.encode('UTF-8'))
+        sample = Buffer.from_ruby_string(data)
+        decoder = Java::LineDecoder.new(Java::ListFileInput.new([[sample.to_java]]), parser_task)
+        tokenizer = org.embulk.standards.CsvTokenizer.new(decoder, parser_task)
+        rows = []
+        while tokenizer.nextFile
+          while tokenizer.nextRecord(skip_empty_lines)
+            begin
+              columns = []
+              while true
+                begin
+                  column = tokenizer.nextColumn
+                  quoted = tokenizer.wasQuotedColumn
+                  if null_string && !quoted && column == null_string
+                    column = nil
+                  end
+                  columns << column
+                rescue org.embulk.standards.CsvTokenizer::TooFewColumnsException
+                  rows << columns
+                  break
+                end
+              end
+            rescue org.embulk.standards.CsvTokenizer::InvalidValueException
+              # TODO warning
+              tokenizer.skipCurrentLine
+            end
+          end
+        end
+        return rows
+      rescue
+        # TODO warning if fallback to this ad-hoc implementation
+        sample_lines.map {|line| line.split(delim) }
+      end
+
+      def guess_delimiter(sample_lines)
+        delim_weights = DELIMITER_CANDIDATES.map do |d|
+          counts = sample_lines.map {|line| line.count(d) }
+          total = array_sum(counts)
+          if total > 0
+            stddev = array_standard_deviation(counts)
+            stddev = 0.000000001 if stddev == 0.0
+            weight = total / stddev
+            [d, weight]
+          else
+            [nil, 0]
+          end
+        end
+
+        delim, weight = *delim_weights.sort_by {|d,weight| weight }.last
+        if delim != nil && weight > 1
+          return delim
+        else
+          return nil
+        end
+      end
+
+      def guess_quote(sample_lines, delim)
+        delim_regexp = Regexp.escape(delim)
+        quote_weights = QUOTE_CANDIDATES.map do |q|
+          weights = sample_lines.map do |line|
+            q_regexp = Regexp.escape(q)
+            count = line.count(q)
+            if count > 0
+              weight = count
+              weight += line.scan(/(?:\A|#{delim_regexp})\s*#{q_regexp}(?:(?!#{q_regexp}).)*\s*#{q_regexp}(?:$|#{delim_regexp})/).size * 20
+              weight += line.scan(/(?:\A|#{delim_regexp})\s*#{q_regexp}(?:(?!#{delim_regexp}).)*\s*#{q_regexp}(?:$|#{delim_regexp})/).size * 40
+              weight
+            else
+              nil
+            end
+          end.compact
+          weights.empty? ? 0 : array_avg(weights)
+        end
+        quote, weight = QUOTE_CANDIDATES.zip(quote_weights).sort_by {|q,w| w }.last
+        if weight >= 10.0
+          return quote
+        else
+          return nil
+        end
+      end
+
+      def guess_force_no_quote(sample_lines, delim, quote_candidate)
+        delim_regexp = Regexp.escape(delim)
+        q_regexp = Regexp.escape(quote_candidate)
+        sample_lines.any? do |line|
+          # quoting character appear at the middle of a non-quoted value
+          line =~ /(?:\A|#{delim_regexp})\s*[^#{q_regexp}]+#{q_regexp}/
+        end
+      end
+
+      def guess_escape(sample_lines, delim, quote)
+        guessed = ESCAPE_CANDIDATES.map do |str|
+          regexp = /#{Regexp.quote(str)}(?:#{Regexp.quote(delim)}|#{Regexp.quote(quote)})/
+          counts = sample_lines.map {|line| line.scan(regexp).count }
+          count = counts.inject(0) {|r,c| r + c }
+          [str, count]
+        end.select {|str,count| count > 0 }.sort_by {|str,count| -count }
+        found = guessed.first
+        return found ? found[0] : nil
+      end
+
+      def guess_null_string(sample_lines, delim)
+        guessed = NULL_STRING_CANDIDATES.map do |str|
+          regexp = /(?:^|#{Regexp.quote(delim)})#{Regexp.quote(str)}(?:$|#{Regexp.quote(delim)})/
+          counts = sample_lines.map {|line| line.scan(regexp).count }
+          count = counts.inject(0) {|r,c| r + c }
+          [str, count]
+        end.select {|str,count| count > 0 }.sort_by {|str,count| -count }
+        found_str, found_count = guessed.first
+        return found_str ? found_str : nil
+      end
+
+      def guess_skip_header_lines(sample_records)
+        counts = sample_records.map {|records| records.size }
+        (1..[MAX_SKIP_LINES, counts.length - 1].min).each do |i|
+          check_row_count = counts[i-1]
+          if counts[i, NO_SKIP_DETECT_LINES].all? {|c| c <= check_row_count }
+            return i - 1
+          end
+        end
+        return 0
+      end
+
+      def guess_comment_line_marker(sample_lines, delim, quote, null_string)
+        exclude = []
+        exclude << /^#{Regexp.escape(quote)}/ if quote && !quote.empty?
+        exclude << /^#{Regexp.escape(null_string)}(?:#{Regexp.escape(delim)}|$)/ if null_string
+
+        guessed = COMMENT_LINE_MARKER_CANDIDATES.map do |str|
+          regexp = /^#{Regexp.quote(str)}/
+          unmatch_lines = sample_lines.reject do |line|
+            exclude.all? {|ex| line !~ ex } && line =~ regexp
+          end
+          match_count = sample_lines.size - unmatch_lines.size
+          [str, match_count, unmatch_lines]
+        end.select {|str,match_count,unmatch_lines| match_count > 0 }.sort_by {|str,match_count,unmatch_lines| -match_count }
+
+        str, match_count, unmatch_lines = guessed.first
+        if str
+          return str, unmatch_lines
+        else
+          return nil, sample_lines
+        end
+      end
+
+      def array_sum(array)
+        array.inject(0) {|r,i| r += i }
+      end
+
+      def array_avg(array)
+        array.inject(0.0) {|r,i| r += i } / array.size
+      end
+
+      def array_variance(array)
+        avg = array_avg(array)
+        array.inject(0.0) {|r,i| r += (i - avg) ** 2 } / array.size
+      end
+
+      def array_standard_deviation(array)
+        Math.sqrt(array_variance(array))
+      end
+    end
+
+  end
+end