presto-client-legacy 0.4.17

data/modelgen/models.rb

@@ -0,0 +1,230 @@
+#
+# Presto client for Ruby
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+module PrestoLegacy::Client
+
+  ####
+  ## lib/presto/client/models.rb is automatically generated using "rake modelgen" command.
+  ## You should not edit this file directly. To modify the class definitions, edit
+  ## modelgen/models.rb file and run "rake modelgen".
+  ##
+
+  module Models
+    class Base < Struct
+      class << self
+        alias_method :new_struct, :new
+
+        def new(*args)
+          new_struct(*args) do
+            # make it immutable
+            undef_method :"[]="
+            members.each do |m|
+              undef_method :"#{m}="
+            end
+
+            # replace constructor to receive hash instead of array
+            alias_method :initialize_struct, :initialize
+
+            def initialize(params={})
+              initialize_struct(*members.map {|m| params[m] })
+            end
+          end
+        end
+      end
+    end
+
+    class StageId < String
+      def initialize(str)
+        super
+        splitted = split('.', 2)
+        @query_id = splitted[0]
+        @id = splitted[1]
+      end
+
+      attr_reader :query_id, :id
+    end
+
+    class TaskId < String
+      def initialize(str)
+        super
+        splitted = split('.', 3)
+        @stage_id = StageId.new("#{splitted[0]}.#{splitted[1]}")
+        @query_id = @stage_id.query_id
+        @id = splitted[2]
+      end
+
+      attr_reader :query_id, :stage_id, :id
+    end
+
+    class ConnectorSession < Hash
+      def initialize(hash)
+        super()
+        merge!(hash)
+      end
+    end
+
+    module PlanNode
+      def self.decode(hash)
+        unless hash.is_a?(Hash)
+          raise TypeError, "Can't convert #{hash.class} to Hash"
+        end
+        model_class = case hash["@type"]
+          when "output"             then OutputNode
+          when "project"            then ProjectNode
+          when "tablescan"          then TableScanNode
+          when "values"             then ValuesNode
+          when "aggregation"        then AggregationNode
+          when "markDistinct"       then MarkDistinctNode
+          when "filter"             then FilterNode
+          when "window"             then WindowNode
+          when "rowNumber"          then RowNumberNode
+          when "topnRowNumber"      then TopNRowNumberNode
+          when "limit"              then LimitNode
+          when "distinctlimit"      then DistinctLimitNode
+          when "topn"               then TopNNode
+          when "sample"             then SampleNode
+          when "sort"               then SortNode
+          when "remoteSource"       then RemoteSourceNode
+          when "join"               then JoinNode
+          when "semijoin"           then SemiJoinNode
+          when "indexjoin"          then IndexJoinNode
+          when "indexsource"        then IndexSourceNode
+          when "tablewriter"        then TableWriterNode
+          when "delete"             then DeleteNode
+          when "metadatadelete"     then MetadataDeleteNode
+          when "tablecommit"        then TableFinishNode
+          when "unnest"             then UnnestNode
+          when "exchange"           then ExchangeNode
+          when "union"              then UnionNode
+          when "scalar"             then EnforceSingleRowNode
+        end
+        if model_class
+           node = model_class.decode(hash)
+           class << node
+             attr_accessor :plan_node_type
+           end
+           node.plan_node_type = hash['@type']
+           node
+        end
+      end
+    end
+
+    # io.airlift.stats.Distribution.DistributionSnapshot
+    class << DistributionSnapshot =
+        Base.new(:max_error, :count, :total, :p01, :p05, :p10, :p25, :p50, :p75, :p90, :p95, :p99, :min, :max)
+      def decode(hash)
+        unless hash.is_a?(Hash)
+          raise TypeError, "Can't convert #{hash.class} to Hash"
+        end
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["maxError"],
+          hash["count"],
+          hash["total"],
+          hash["p01"],
+          hash["p05"],
+          hash["p10"],
+          hash["p25"],
+          hash["p50"],
+          hash["p75"],
+          hash["p90"],
+          hash["p95"],
+          hash["p99"],
+          hash["min"],
+          hash["max"],
+        )
+        obj
+      end
+    end
+
+    # This is a hybrid of JoinNode.EquiJoinClause and IndexJoinNode.EquiJoinClause
+    class << EquiJoinClause =
+        Base.new(:left, :right, :probe, :index)
+      def decode(hash)
+        unless hash.is_a?(Hash)
+          raise TypeError, "Can't convert #{hash.class} to Hash"
+        end
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["left"],
+          hash["right"],
+          hash["probe"],
+          hash["index"],
+        )
+        obj
+      end
+    end
+
+    class << WriterTarget =
+        Base.new(:type, :handle)
+      def decode(hash)
+        unless hash.is_a?(Hash)
+          raise TypeError, "Can't convert #{hash.class} to Hash"
+        end
+        obj = allocate
+        model_class = case hash["@type"]
+            when "CreateHandle"       then OutputTableHandle
+            when "InsertHandle"       then InsertTableHandle
+            when "DeleteHandle"       then TableHandle
+        end
+        obj.send(:initialize_struct,
+          hash["@type"],
+          model_class.decode(hash['handle'])
+        )
+        obj
+      end
+    end
+
+    class << DeleteHandle =
+        Base.new(:handle)
+      def decode(hash)
+        unless hash.is_a?(Hash)
+          raise TypeError, "Can't convert #{hash.class} to Hash"
+        end
+        obj = allocate
+        obj.send(:initialize_struct,
+          TableHandle.decode(hash['handle'])
+        )
+        obj
+      end
+    end
+
+
+    # A missing JsonCreator in Presto
+    class << PageBufferInfo =
+        Base.new(:partition, :buffered_pages, :queued_pages, :buffered_bytes, :pages_added)
+      def decode(hash)
+        unless hash.is_a?(Hash)
+          raise TypeError, "Can't convert #{hash.class} to Hash"
+        end
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["partition"],
+          hash["bufferedPages"],
+          hash["queuedPages"],
+          hash["bufferedBytes"],
+          hash["pagesAdded"],
+        )
+        obj
+      end
+    end
+
+    ##
+    # Those model classes are automatically generated
+    #
+
+<%= @contents %>
+  end
+end

data/modelgen/presto_models.rb

@@ -0,0 +1,228 @@
+
+module PrestoModels
+  require 'find'
+  require 'stringio'
+
+  PRIMITIVE_TYPES = %w[String boolean long int short byte double float Integer]
+
+  class Model < Struct.new(:name, :fields)
+  end
+
+  class Field < Struct.new(:key, :nullable, :array, :map, :type, :base_type, :map_value_base_type)
+    alias_method :nullable?, :nullable
+    alias_method :array?, :array
+    alias_method :map?, :map
+
+    def name
+      @name ||= key.gsub(/[A-Z]/) {|f| "_#{f.downcase}" }
+    end
+  end
+
+  class ModelAnalysisError < StandardError
+  end
+
+  class ModelAnalyzer
+    def initialize(source_path, options={})
+      @source_path = source_path
+      @ignore_types = PRIMITIVE_TYPES + (options[:skip_models] || [])
+      @path_mapping = options[:path_mapping] || {}
+      @name_mapping = options[:name_mapping] || {}
+      @models = {}
+      @skipped_models = []
+    end
+
+    attr_reader :skipped_models
+
+    def models
+      @models.values.sort_by {|model| model.name }
+    end
+
+    def analyze(root_models)
+      root_models.each {|model_name|
+        analyze_model(model_name)
+      }
+    end
+
+    private
+
+    PROPERTY_PATTERN = /@JsonProperty\(\"(\w+)\"\)\s+(@Nullable\s+)?([\w\<\>\,\s]+)\s+(\w+)/
+    CREATOR_PATTERN = /@JsonCreator[\w\s]+\((?:\s*#{PROPERTY_PATTERN}\s*,?)+\)/
+
+    def analyze_model(model_name, parent_model = nil)
+      return if @models[model_name] || @ignore_types.include?(model_name)
+
+      path = find_class_file(model_name, parent_model)
+      java = File.read(path)
+
+      m = CREATOR_PATTERN.match(java)
+      unless m
+        raise ModelAnalysisError, "Can't find JsonCreator of a model class #{model_name} of #{parent_model} at #{path}"
+      end
+
+      fields = m[0].scan(PROPERTY_PATTERN).map do |key,nullable,type,field|
+        map = false
+        array = false
+        nullable = !!nullable
+        if m = /(?:List|Set)<(\w+)>/.match(type)
+          base_type = m[1]
+          array = true
+        elsif m = /(?:Map|ListMultimap)<(\w+),\s*(\w+)>/.match(type)
+          base_type = m[1]
+          map_value_base_type = m[2]
+          map = true
+        elsif m = /Optional<(\w+)>/.match(type)
+          base_type = m[1]
+          nullable = true
+        elsif m = /OptionalInt/.match(type)
+          base_type = 'Integer'
+          nullable = true
+        elsif type =~ /\w+/
+          base_type = type
+        else
+          raise ModelAnalysisError, "Unsupported type #{type} in model #{model_name}"
+        end
+        base_type = @name_mapping[[model_name, base_type]] || base_type
+        map_value_base_type = @name_mapping[[model_name, map_value_base_type]] || map_value_base_type
+        Field.new(key, !!nullable, array, map, type, base_type, map_value_base_type)
+      end
+
+      @models[model_name] = Model.new(model_name, fields)
+
+      # recursive call
+      fields.each do |field|
+        analyze_model(field.base_type, model_name)
+        analyze_model(field.map_value_base_type, model_name) if field.map_value_base_type
+      end
+
+    rescue => e
+      puts "Skipping model #{parent_model}/#{model_name}: #{e}"
+      @skipped_models << model_name
+    end
+
+    def find_class_file(model_name, parent_model)
+      return @path_mapping[model_name] if @path_mapping.has_key? model_name
+
+      @source_files ||= Find.find(@source_path).to_a
+      pattern = /\/#{model_name}.java$/
+      matched = @source_files.find_all {|path| path =~ pattern }
+      if matched.empty?
+        raise ModelAnalysisError, "Model class #{model_name} is not found"
+      end
+      if matched.size == 1
+        return matched.first
+      else
+        raise ModelAnalysisError, "Model class #{model_name} of #{parent_model} found multiple match #{matched}"
+      end
+    end
+  end
+
+  class ModelFormatter
+    def initialize(options={})
+      @indent = options[:indent] || '  '
+      @base_indent_count = options[:base_indent_count] || 0
+      @struct_class = options[:struct_class] || 'Struct'
+      @special_struct_initialize_method = options[:special_struct_initialize_method]
+      @primitive_types = PRIMITIVE_TYPES + (options[:primitive_types] || [])
+      @skip_types = options[:skip_types] || []
+      @simple_classes = options[:simple_classes]
+      @enum_types = options[:enum_types]
+      @special_types = options[:special_types] || {}
+      @data = StringIO.new
+    end
+
+    def contents
+      @data.string
+    end
+
+    def format(models)
+      @models = models
+      models.each do |model|
+        @model = model
+
+        puts_with_indent 0, "class << #{model.name} ="
+        puts_with_indent 2, "#{@struct_class}.new(#{model.fields.map {|f| ":#{f.name}" }.join(', ')})"
+        format_decode
+        puts_with_indent 0, "end"
+        line
+      end
+    end
+
+    private
+
+    def line
+      @data.puts ""
+    end
+
+    def puts_with_indent(n, str)
+      @data.puts "#{@indent * (@base_indent_count + n)}#{str}"
+    end
+
+    def format_decode
+      puts_with_indent 1, "def decode(hash)"
+
+      puts_with_indent 2, "unless hash.is_a?(Hash)"
+      puts_with_indent 3, "raise TypeError, \"Can't convert \#{hash.class} to Hash\""
+      puts_with_indent 2, "end"
+
+      if @special_struct_initialize_method
+        puts_with_indent 2, "obj = allocate"
+        puts_with_indent 2, "obj.send(:#{@special_struct_initialize_method},"
+      else
+        puts_with_indent 2, "new("
+      end
+
+      @model.fields.each do |field|
+        next if @skip_types.include?(field.base_type) || @skip_types.include?(field.map_value_base_type)
+
+        if @primitive_types.include?(field.base_type) && !field.map?
+          expr = "hash[\"#{field.key}\"]"
+        else
+          expr = ""
+          expr << "hash[\"#{field.key}\"] && " #if field.nullable?
+
+          if field.map?
+            key_expr = convert_expression(field.base_type, field.base_type, "k")
+            value_expr = convert_expression(field.map_value_base_type, field.map_value_base_type, "v")
+            if key_expr == 'k' && value_expr == 'v'
+              expr = "hash[\"#{field.key}\"]"
+            else
+              expr << "Hash[hash[\"#{field.key}\"].to_a.map! {|k,v| [#{key_expr}, #{value_expr}] }]"
+            end
+          elsif field.array?
+            elem_expr = convert_expression(field.base_type, field.base_type, "h")
+            expr << "hash[\"#{field.key}\"].map {|h| #{elem_expr} }"
+          else
+            expr << convert_expression(field.type, field.base_type, "hash[\"#{field.key}\"]")
+          end
+        end
+
+        #comment = "# #{field.base_type}#{field.array? ? '[]' : ''} #{field.key}"
+        #puts_with_indent 3, "#{expr},  #{comment}"
+        puts_with_indent 3, "#{expr},"
+      end
+
+      puts_with_indent 2, ")"
+
+      if @special_struct_initialize_method
+        puts_with_indent 2, "obj"
+      end
+
+      puts_with_indent 1, "end"
+    end
+
+    def convert_expression(type, base_type, key)
+      if @special_types[type]
+        special.call(key)
+      elsif @enum_types.include?(type)
+        "#{key}.downcase.to_sym"
+      elsif @primitive_types.include?(base_type)
+        key
+      elsif @simple_classes.include?(base_type)
+        "#{base_type}.new(#{key})"
+      else  # model class
+        "#{base_type}.decode(#{key})"
+      end
+    end
+  end
+end
+

data/presto-client-legacy.gemspec

@@ -0,0 +1,29 @@
+require File.expand_path 'lib/presto/client/version', File.dirname(__FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "presto-client-legacy"
+  gem.version       = PrestoLegacy::Client::VERSION
+
+  gem.authors       = ["Sadayuki Furuhash", "Kai Sasaki"]
+  gem.email         = ["sf@treasure-data.com", "lewuathe@me.com"]
+  gem.description   = %q{Presto client library for legacy presto version}
+  gem.summary       = %q{Presto client library for legacy presto version (before 0.151)}
+  gem.homepage      = "https://github.com/Lewuathe/presto-client-ruby"
+  gem.license       = "Apache-2.0"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.has_rdoc = false
+
+  gem.required_ruby_version = ">= 1.9.1"
+
+  gem.add_dependency "faraday", [">= 0.8.8", "< 0.10.0"]
+  gem.add_dependency "multi_json", ["~> 1.0"]
+
+  gem.add_development_dependency "rake", [">= 0.9.2"]
+  gem.add_development_dependency "rspec", ["~> 2.13.0"]
+  gem.add_development_dependency "webmock", ["~> 1.16.1"]
+  gem.add_development_dependency "simplecov", ["~> 0.10.0"]
+end

data/spec/client_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe PrestoLegacy::Client::Client do
+  let(:client) { PrestoLegacy::Client.new({}) }
+
+  describe 'rehashes' do
+    let(:columns) do
+      [
+        Models::Column.new(name: 'animal', type: 'string'),
+        Models::Column.new(name: 'score', type: 'integer'),
+        Models::Column.new(name: 'name', type: 'string')
+      ]
+    end
+
+    it 'multiple rows' do
+      rows = [
+        ['dog', 1, 'Lassie'],
+        ['horse', 5, 'Mr. Ed'],
+        ['t-rex', 37, 'Doug']
+      ]
+      client.stub(:run).and_return([columns, rows])
+
+      rehashed = client.run_with_names('fake query')
+
+      rehashed.length.should == 3
+
+      rehashed[0]['animal'].should == 'dog'
+      rehashed[0]['score'].should == 1
+      rehashed[0]['name'].should == 'Lassie'
+
+      rehashed[0].values[0].should == 'dog'
+      rehashed[0].values[1].should == 1
+      rehashed[0].values[2].should == 'Lassie'
+
+      rehashed[1]['animal'].should == 'horse'
+      rehashed[1]['score'].should == 5
+      rehashed[1]['name'].should == 'Mr. Ed'
+
+      rehashed[1].values[0].should == 'horse'
+      rehashed[1].values[1].should == 5
+      rehashed[1].values[2].should == 'Mr. Ed'
+    end
+
+    it 'empty results' do
+      rows = []
+      client.stub(:run).and_return([columns, rows])
+
+      rehashed = client.run_with_names('fake query')
+
+      rehashed.length.should == 0
+    end
+
+    it 'handles too few result columns' do
+      rows = [['wrong', 'count']]
+      client.stub(:run).and_return([columns, rows])
+
+      client.run_with_names('fake query').should == [{
+        "animal" => "wrong",
+        "score" => "count",
+        "name" => nil,
+      }]
+    end
+
+    it 'handles too many result columns' do
+      rows = [['wrong', 'count', 'too', 'much', 'columns']]
+      client.stub(:run).and_return([columns, rows])
+
+      client.run_with_names('fake query').should == [{
+        "animal" => "wrong",
+        "score" => "count",
+        "name" => 'too',
+      }]
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :test)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'simplecov'
+SimpleCov.start
+
+require 'json'
+require 'webmock/rspec'
+
+require 'presto-client-legacy'
+include PrestoLegacy::Client