trino-client 1.0.0

data/modelgen/trino_models.rb

@@ -0,0 +1,270 @@
+
+module TrinoModels
+  require 'find'
+  require 'stringio'
+
+  PRIMITIVE_TYPES = %w[String boolean long int short byte double float Integer Double Boolean]
+  ARRAY_PRIMITIVE_TYPES = PRIMITIVE_TYPES.map { |t| "#{t}[]" }
+
+  class Model < Struct.new(:name, :fields)
+  end
+
+  class Field < Struct.new(:key, :nullable, :array, :map, :type, :base_type, :map_value_base_type, :base_type_alias)
+    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 + ARRAY_PRIMITIVE_TYPES + (options[:skip_models] || [])
+      @path_mapping = options[:path_mapping] || {}
+      @name_mapping = options[:name_mapping] || {}
+      @extra_fields = options[:extra_fields] || {}
+      @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[\s]+public[\s]+(static\s+)?(\w+)[\w\s]*\((?:\s*#{PROPERTY_PATTERN}\s*,?)+\)/
+    GENERIC_PATTERN = /(\w+)\<(\w+)\>/
+
+    def analyze_fields(model_name, creator_block, generic: nil)
+      model_name = "#{model_name}_#{generic}" if generic
+      extra = @extra_fields[model_name] || []
+      fields = creator_block.scan(PROPERTY_PATTERN).concat(extra).map do |key,nullable,type|
+        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 m = /OptionalLong/.match(type)
+          base_type = 'Long'
+          nullable = true
+        elsif m = /OptionalDouble/.match(type)
+          base_type = 'Double'
+          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
+        
+        if generic
+          base_type = generic if base_type == 'T'
+          map_value_base_type = generic if map_value_base_type == 'T'  
+        end
+        if m = GENERIC_PATTERN.match(base_type)
+          base_type_alias = "#{m[1]}_#{m[2]}"
+        end
+
+        Field.new(key, !!nullable, array, map, type, base_type, map_value_base_type, base_type_alias)
+      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
+
+      return fields
+    end
+
+    def analyze_model(model_name, parent_model=  nil, generic: nil)
+      return if @models[model_name] || @ignore_types.include?(model_name)
+
+      if m = GENERIC_PATTERN.match(model_name)
+        analyze_model(m[1], generic: m[2])
+        analyze_model(m[2])
+        return
+      end
+
+      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
+
+      body = m[0] 
+      # check inner class first
+      while true
+        offset = m.end(0)
+        m = CREATOR_PATTERN.match(java, offset)
+        break unless m
+        inner_model_name = m[2]
+        next if @models[inner_model_name] || @ignore_types.include?(inner_model_name)
+        fields = analyze_fields(inner_model_name, m[0])
+      end
+
+      fields = analyze_fields(model_name, body, generic: generic)
+
+    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 && !path.include?('/test/') && !path.include?('/verifier/')}
+      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 + ARRAY_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_alias || 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) || @enum_types.include?(base_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/release.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+
+PREFIX = 'https://github.com/treasure-data/trino-client-ruby'
+RELEASE_NOTES_FILE = "ChangeLog.md"
+
+last_tag = `git describe --tags --abbrev=0`.chomp
+last_version = last_tag.sub("v", "")
+puts "last version: #{last_version}"
+
+print "next version? "
+next_version = STDIN.gets.chomp
+
+abort("Can't use empty version string") if next_version.empty?
+
+logs = `git log #{last_tag}..HEAD --pretty=format:'%h %s'`
+# Add links to GitHub issues
+logs = logs.gsub(/\#([0-9]+)/, "[#\\1](#{PREFIX}/issues/\\1)")
+
+new_release_notes = []
+new_release_notes <<= "\#\# #{next_version}\n"
+new_release_notes <<= logs.split(/\n/)
+  .reject{|line| line.include?("#{last_version} release notes")}
+  .map{|x|
+    rev = x[0..6]
+    "- #{x[8..-1]} [[#{rev}](#{PREFIX}/commit/#{rev})]\n"
+  }
+
+release_notes = []
+notes = File.readlines(RELEASE_NOTES_FILE)
+
+release_notes <<= notes[0..1]
+release_notes <<= new_release_notes
+release_notes <<= "\n"
+release_notes <<= notes[2..-1]
+
+TMP_RELEASE_NOTES_FILE = "#{RELEASE_NOTES_FILE}.tmp"
+File.delete(TMP_RELEASE_NOTES_FILE) if File.exists?(TMP_RELEASE_NOTES_FILE)
+File.write("#{TMP_RELEASE_NOTES_FILE}", release_notes.join)
+system("cat #{TMP_RELEASE_NOTES_FILE} | vim - -c ':f #{TMP_RELEASE_NOTES_FILE}' -c ':9'")
+
+abort("The release note file is not saved. Aborted") unless File.exists?(TMP_RELEASE_NOTES_FILE)
+
+def run(cmd)
+  puts cmd
+  system cmd
+end
+
+FileUtils.cp(TMP_RELEASE_NOTES_FILE, RELEASE_NOTES_FILE)
+File.delete(TMP_RELEASE_NOTES_FILE)
+
+# run "git commit #{RELEASE_NOTES_FILE} -m \"Add #{next_version} release notes\""
+# run "git tag v#{next_version}"
+# run "git push"
+# run "git push --tags"

data/spec/basic_query_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Trino::Client::Client do
+  before(:all) do
+    WebMock.disable!
+    @cluster = TinyPresto::Cluster.new()
+    @container = @cluster.run
+    @client = Trino::Client.new(server: 'localhost:8080', catalog: 'memory', user: 'test-user', schema: 'default')
+    loop do
+      begin
+        @client.run('show schemas')
+        break
+      rescue StandardError => exception
+        puts "Waiting for cluster ready... #{exception}"
+        sleep(3)
+      end
+    end
+    puts 'Cluster is ready'
+  end
+
+  after(:all) do
+    @cluster.stop
+    WebMock.enable!
+  end
+
+  it 'show schemas' do
+    columns, rows = run_with_retry(@client, 'show schemas')
+    expect(columns.length).to be(1)
+    expect(rows.length).to be(2)
+  end
+
+  it 'ctas' do
+    expected = [[1, 'a'], [2, 'b']]
+    run_with_retry(@client, "create table ctas1 as select * from (values (1, 'a'), (2, 'b')) t(c1, c2)")
+    columns, rows = run_with_retry(@client, 'select * from ctas1')
+    expect(columns.map(&:name)).to match_array(%w[c1 c2])
+    expect(rows).to eq(expected)
+  end
+
+  it 'next_uri' do
+    @client.query('show schemas') do |q|
+      expect(q.next_uri).to start_with('http://localhost:8080/v1/statement/')
+    end
+  end
+
+  it 'advance' do
+    @client.query('show schemas') do |q|
+      expect(q.advance).to be(true)
+    end
+  end
+
+  it 'current query result' do
+    @client.query('show schemas') do |q|
+      expect(q.current_results.info_uri).to start_with('http://localhost:8080/ui/query.html')
+    end
+  end
+
+  it 'statement stats' do
+    @client.query('show schemas') do |q|
+      stats = q.current_results.stats
+      # Immediate subsequent request should get queued result
+      expect(stats.queued).to be(true)
+      expect(stats.scheduled).to be(false)
+    end
+  end
+
+  it 'partial cancel' do
+    @client.query('show schemas') do |q|
+      q.cancel
+      expect { q.query_info }.to raise_error(Trino::Client::TrinoHttpError, /Error 410 Gone/)
+    end
+  end
+
+  it 'row chunk' do
+    expected_schemas = %w[default information_schema]
+    @client.query('show schemas') do |q|
+      q.each_row do |r|
+        expect(expected_schemas).to include(r[0])
+      end
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Trino::Client::Client do
+  let(:client) { Trino::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