trino-client 1.0.2 → 2.0.1

data/modelgen/model_versions.rb

@@ -1,280 +0,0 @@
-#
-# Trino 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 Trino::Client::ModelVersions
-
-  ####
-  ## lib/trino/client/model_versions/*.rb is automatically generated using "rake modelgen:all" command.
-  ## You should not edit this file directly. To modify the class definitions, edit
-  ## modelgen/model_versions.rb file and run "rake modelgen:all".
-  ##
-
-  module V<%= @model_version.gsub(".", "_") %>
-    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 Lifespan < String
-      def initialize(str)
-        super
-        if str == "TaskWide"
-          @grouped = false
-          @group_id = 0
-        else
-          # Group1
-          @grouped = true
-          @group_id = str[5..-1].to_i
-        end
-      end
-
-      attr_reader :grouped, :group_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 "spatialjoin"        then SpatialJoinNode
-          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 "intersect"          then IntersectNode
-          when "scalar"             then EnforceSingleRowNode
-          when "groupid"            then GroupIdNode
-          when "explainAnalyze"     then ExplainAnalyzeNode
-          when "apply"              then ApplyNode
-          when "assignUniqueId"     then AssignUniqueId
-          when "correlatedJoin"     then CorrelatedJoinNode
-          when "statisticsWriterNode" then StatisticsWriterNode
-        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 "CreateTarget"       then CreateTarget
-            when "InsertTarget"       then InsertTarget
-            when "DeleteTarget"       then DeleteTarget
-        end
-        if model_class
-           model_class.decode(hash)
-        end
-      end
-    end
-
-    class << WriteStatisticsTarget =
-        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 "WriteStatisticsHandle"       then WriteStatisticsHandle
-        end
-        if model_class
-           model_class.decode(hash)
-        end
-      end
-    end
-
-    # Inner classes 
-    module OperatorInfo
-      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 "exchangeClientStatus"   then ExchangeClientStatus
-          when "localExchangeBuffer"    then LocalExchangeBufferInfo
-          when "tableFinish"            then TableFinishInfo
-          when "splitOperator"          then SplitOperatorInfo
-          when "hashCollisionsInfo"     then HashCollisionsInfo
-          when "partitionedOutput"      then PartitionedOutputInfo
-          when "joinOperatorInfo"       then JoinOperatorInfo
-          when "windowInfo"             then WindowInfo
-          when "tableWriter"            then TableWriterInfo
-        end
-        if model_class
-           model_class.decode(hash)
-        end
-      end
-    end
-
-    class << HashCollisionsInfo =
-        Base.new(:weighted_hash_collisions, :weighted_sum_squared_hash_collisions, :weighted_expectedHash_collisions)
-      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["weighted_hash_collisions"],
-          hash["weighted_sum_squared_hash_collisions"],
-          hash["weighted_expectedHash_collisions"]
-        )
-        obj
-      end
-    end
-
-    class ResourceGroupId < Array
-      def initialize(array)
-        super()
-        concat(array)
-      end
-    end
-
-    ##
-    # Those model classes are automatically generated
-    #
-
-<%= @contents %>
-  end
-end

data/modelgen/modelgen.rb

@@ -1,119 +0,0 @@
-
-if ARGV.length != 4
-  puts "usage: <model-version> <trino-source-dir> <template.erb> <output.rb>"
-  exit 1
-end
-
-model_version, source_dir, template_path, output_path = *ARGV
-
-require_relative 'trino_models'
-
-require 'erb'
-erb = ERB.new(File.read(template_path))
-
-source_path = source_dir
-
-predefined_simple_classes = %w[StageId TaskId Lifespan ConnectorSession ResourceGroupId]
-predefined_models = %w[DistributionSnapshot PlanNode EquiJoinClause WriterTarget WriteStatisticsTarget OperatorInfo HashCollisionsInfo]
-
-assume_primitive = %w[Object Type Long Symbol QueryId PlanNodeId PlanFragmentId MemoryPoolId TransactionId URI Duration DataSize DateTime ColumnHandle ConnectorTableHandle ConnectorOutputTableHandle ConnectorIndexHandle ConnectorColumnHandle ConnectorInsertTableHandle ConnectorTableLayoutHandle Expression FunctionCall TimeZoneKey Locale TypeSignature Frame TupleDomain<ColumnHandle> SerializableNativeValue ConnectorTransactionHandle OutputBufferId ConnectorPartitioningHandle NullableValue ConnectorId HostAddress JsonNode Node CatalogName QualifiedObjectName FunctionId DynamicFilterId Instant]
-enum_types = %w[QueryState StageState TaskState QueueState PlanDistribution OutputPartitioning Step SortOrder BufferState NullPartitioning BlockedReason ParameterKind FunctionKind PartitionFunctionHandle Scope ErrorType DistributionType PipelineExecutionStrategy JoinType ExchangeNode.Type ColumnStatisticType TableStatisticType StageExecutionStrategy SemanticErrorCode QueryType]
-
-root_models = %w[QueryResults QueryInfo BasicQueryInfo] + %w[
-OutputNode
-ProjectNode
-TableScanNode
-ValuesNode
-AggregationNode
-MarkDistinctNode
-FilterNode
-WindowNode
-RowNumberNode
-TopNRowNumberNode
-LimitNode
-DistinctLimitNode
-TopNNode
-SampleNode
-SortNode
-RemoteSourceNode
-JoinNode
-SemiJoinNode
-SpatialJoinNode
-IndexJoinNode
-IndexSourceNode
-TableWriterNode
-DeleteNode
-TableFinishNode
-UnnestNode
-ExchangeNode
-UnionNode
-IntersectNode
-EnforceSingleRowNode
-GroupIdNode
-ExplainAnalyzeNode
-ApplyNode
-AssignUniqueId
-CorrelatedJoinNode
-StatisticsWriterNode
-] + %w[
-ExchangeClientStatus
-LocalExchangeBufferInfo
-TableFinishInfo
-SplitOperatorInfo
-PartitionedOutputInfo
-JoinOperatorInfo
-WindowInfo
-TableWriterInfo
-]
-
-name_mapping = Hash[*%w[
-StatementStats StageStats ClientStageStats
-ClientStageStats StageStats ClientStageStats
-QueryResults Column ClientColumn
-].each_slice(3).map { |x, y, z| [[x,y], z] }.flatten(1)]
-
-path_mapping = Hash[*%w[
-ClientColumn client/trino-client/src/main/java/io/trino/client/Column.java
-ClientStageStats client/trino-client/src/main/java/io/trino/client/StageStats.java
-Column core/trino-main/src/main/java/io/trino/execution/Column.java
-QueryStats core/trino-main/src/main/java/io/trino/execution/QueryStats.java
-StageStats core/trino-main/src/main/java/io/trino/execution/StageStats.java
-PartitionedOutputInfo core/trino-main/src/main/java/io/trino/operator/PartitionedOutputOperator.java
-TableWriterInfo core/trino-main/src/main/java/io/trino/operator/TableWriterOperator.java
-TableInfo core/trino-main/src/main/java/io/trino/execution/TableInfo.java
-DynamicFiltersStats core/trino-main/src/main/java/io/trino/server/DynamicFilterService.java
-].map.with_index { |v,i| i % 2 == 0 ? v : (source_path + "/" + v) }]
-
-# model => [ [key,nullable,type], ... ]
-extra_fields = {
-    'QueryInfo' => [['finalQueryInfo', nil, 'boolean']]
-}
-
-analyzer = TrinoModels::ModelAnalyzer.new(
-  source_path,
-  skip_models: predefined_models + predefined_simple_classes + assume_primitive + enum_types,
-  path_mapping: path_mapping,
-  name_mapping: name_mapping,
-  extra_fields: extra_fields
-)
-analyzer.analyze(root_models)
-models = analyzer.models
-skipped_models = analyzer.skipped_models
-
-formatter = TrinoModels::ModelFormatter.new(
-  base_indent_count: 2,
-  struct_class: "Base",
-  special_struct_initialize_method: "initialize_struct",
-  primitive_types: assume_primitive,
-  skip_types: skipped_models,
-  simple_classes: predefined_simple_classes,
-  enum_types: enum_types,
-)
-formatter.format(models)
-
-@contents = formatter.contents
-@model_version = model_version
-
-data = erb.result
-File.write(output_path, data)
-

data/modelgen/models.rb

@@ -1,31 +0,0 @@
-#
-# Trino 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 Trino::Client
-
-  ####
-  ## lib/trino/client/models.rb is automatically generated using "rake modelgen:latest" command.
-  ## You should not edit this file directly. To modify the class definitions, edit
-  ## modelgen/models.rb file and run "rake modelgen:latest".
-  ##
-
-  module ModelVersions
-  end
-<% @versions.each do |ver| %>
-  require 'trino/client/model_versions/<%= ver %>.rb'<% end %>
-
-  Models = ModelVersions::V<%= @latest_version.gsub(".", "_") %>
-
-end

data/modelgen/trino_models.rb

@@ -1,270 +0,0 @@
-
-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
-