presto-client 0.3.3 → 0.4.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NDc4YmQ2ZDQ1OTg4ZWJiYTJlMDgzMDIzNThmMDJmMzUxZjE2YzlhZg==
+    YjkzMDA1ZjE0N2U5NjQ2ODUwOTg4NDhkMTk3YTEwODcwZDNlYzE3Ng==
   data.tar.gz: !binary |-
-    MmIzYmIzOWVmNzRjOTc5ZDRiYTFiZjY5NTNlNjgwMjc1YWRlODBhMA==
+    ZDhkMzczNzM0YWE2OGFmZWYwZjAyZjM2Yzk0NGUzZDdlMzRlZGU1Yw==
 SHA512:
   metadata.gz: !binary |-
-    MjAyYTBlNzYzODMwMzJlNWU2OTI2ZjQ4MzM5ZDhlNWRhNjNmMWY0YWFiYWU1
-    YzkyMzg5NTUwNjlkZDY3Nzg0MTdlMGEwZTE1YzIxZDNiZmE4MjI5NzkxMmZj
-    ZDRhYThjNDgwMDk5YzMyNDA5ODQ1MjFjMTYzNjY2MjUxM2Y5YWQ=
+    ODczY2ZmNmU2YjU4ZjhiNzBhYWE1MDIxMTNhYjIyMDFlYTkxMzYwYWQwOTRj
+    NzI1YmE4MDRjNDVkMjIzN2FkMzVkYTFhZTdjZDU5YWQwMzEzZjA0ZTgwOGY4
+    MmYyNzdmODY5ZmNjZGIzY2Y2ZTIzOTgxZDk1ZTliMjc1YWE4OGQ=
   data.tar.gz: !binary |-
-    N2Q5NmI2N2ExOTEwMTI0OWFjM2U5Njc0NjlmNjRkNDhkOWYyYTY4OWU5YWFm
-    MDJmMTc4MzMwNmFjNDQ2YWMyYjI5YTI2NDVhZTc5ODFkYWEzNzYyNzE3NTE1
-    YjkyYjVmNTczNWM0OWFjYWQ0ZGY0NDVhM2QzM2QwMGVmMWJmMTk=
+    YzM1MmIwODUyOWIyZTU1MzM1MmUyNGNhMGE4NzYwZTQzYzY5MjBlNDAxYjdh
+    MWRjMWQyODBhZTRmZWIwN2I0NjUzOTI3MjAxYmMxZjk2YjA1YmJiMDgzOTY1
+    Zjk3NGMwZjRiNzg3NTY5NmRiOWRhYmQ5N2UwMTc5MDYwNzUzMmI=

data/README.md

@@ -44,9 +44,11 @@ end
 
 * **server** sets address[:port] to a Presto coordinator
 * **catalog** sets catalog (connector) name of Presto such as `hive-cdh4`, `hive-hadoop1`, etc.
-* **schema** sets default schema name of Presto. You can read other schemas by qualified name like `FROM myschema.table1`
+* **schema** sets default schema name of Presto. You can read other schemas by qualified name like `FROM myschema.table1`.
 * **source** sets source name to connect to a Presto. This name is shown on Presto web interface.
 * **user** sets user name to connect to a Presto.
+* **time_zone** sets time zone of the query. Time zone affects some functions such as `format_datetime`.
+* **language** sets language of the query. Language affects some functions such as `format_datetime`.
 * **http_debug** enables debug message to STDOUT for each HTTP requests
 * **http_open_timeout** sets timeout in seconds to open new HTTP connection
 * **http_timeout** sets timeout in seconds to read data from a server

data/Rakefile

@@ -11,3 +11,16 @@ RSpec::Core::RakeTask.new(:spec) do |t|
 end
 
 task :default => [:spec, :build]
+
+GEN_MODELS_VERSION = "0.69"
+
+task :modelgen do
+  unless Dir.exists?("presto-#{GEN_MODELS_VERSION}")
+    sh "curl -L -o presto-#{GEN_MODELS_VERSION}.tar.gz https://github.com/facebook/presto/archive/#{GEN_MODELS_VERSION}.tar.gz"
+    sh "tar zxvf presto-#{GEN_MODELS_VERSION}.tar.gz"
+  end
+
+  sh "#{RbConfig.ruby} modelgen/modelgen.rb presto-#{GEN_MODELS_VERSION} modelgen/models.rb lib/presto/client/models.rb"
+  puts "Generated lib/presto/client/models.rb."
+end
+

data/lib/presto/client/models.rb

@@ -15,231 +15,934 @@
 #
 module Presto::Client
 
-  class Column
-    attr_reader :name
-    attr_reader :type
+  ####
+  ## 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".
+  ##
 
-    def initialize(options={})
-      @name = options[:name]
-      @type = options[:type]
+  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
 
-    def self.decode_hash(hash)
-      new(
-        name: hash["name"],
-        type: hash["type"],
-      )
+    class QueryId < String
     end
-  end
 
-  class StageStats
-    attr_reader :stage_id
-    attr_reader :state
-    attr_reader :done
-    attr_reader :nodes
-    attr_reader :total_splits
-    attr_reader :queued_splits
-    attr_reader :running_splits
-    attr_reader :completed_splits
-    attr_reader :user_time_millis
-    attr_reader :cpu_time_millis
-    attr_reader :wall_time_millis
-    attr_reader :processed_rows
-    attr_reader :processed_bytes
-    attr_reader :sub_stages
-
-    def initialize(options={})
-      @stage_id = options[:stage_id]
-      @state = options[:state]
-      @done = options[:done]
-      @nodes = options[:nodes]
-      @total_splits = options[:total_splits]
-      @queued_splits = options[:queued_splits]
-      @running_splits = options[:running_splits]
-      @completed_splits = options[:completed_splits]
-      @user_time_millis = options[:user_time_millis]
-      @cpu_time_millis = options[:cpu_time_millis]
-      @wall_time_millis = options[:wall_time_millis]
-      @processed_rows = options[:processed_rows]
-      @processed_bytes = options[:processed_bytes]
-      @sub_stages = options[:sub_stages]
-    end
-
-    def self.decode_hash(hash)
-      new(
-        stage_id: hash["stageId"],
-        state: hash["state"],
-        done: hash["done"],
-        nodes: hash["nodes"],
-        total_splits: hash["totalSplits"],
-        queued_splits: hash["queuedSplits"],
-        running_splits: hash["runningSplits"],
-        completed_splits: hash["completedSplits"],
-        user_time_millis: hash["userTimeMillis"],
-        cpu_time_millis: hash["cpuTimeMillis"],
-        wall_time_millis: hash["wallTimeMillis"],
-        processed_rows: hash["processedRows"],
-        processed_bytes: hash["processedBytes"],
-        sub_stages: hash["subStages"] && hash["subStages"].map {|h| StageStats.decode_hash(h) },
-      )
+    class StageId < String
     end
-  end
 
-  class StatementStats
-    attr_reader :state
-    attr_reader :scheduled
-    attr_reader :nodes
-    attr_reader :total_splits
-    attr_reader :queued_splits
-    attr_reader :running_splits
-    attr_reader :completed_splits
-    attr_reader :user_time_millis
-    attr_reader :cpu_time_millis
-    attr_reader :wall_time_millis
-    attr_reader :processed_rows
-    attr_reader :processed_bytes
-    attr_reader :root_stage
-
-    def initialize(options={})
-      @state = options[:state]
-      @scheduled = options[:scheduled]
-      @nodes = options[:nodes]
-      @total_splits = options[:total_splits]
-      @queued_splits = options[:queued_splits]
-      @running_splits = options[:running_splits]
-      @completed_splits = options[:completed_splits]
-      @user_time_millis = options[:user_time_millis]
-      @cpu_time_millis = options[:cpu_time_millis]
-      @wall_time_millis = options[:wall_time_millis]
-      @processed_rows = options[:processed_rows]
-      @processed_bytes = options[:processed_bytes]
-      @root_stage = options[:root_stage]
-    end
-
-    def self.decode_hash(hash)
-      new(
-        state: hash["state"],
-        scheduled: hash["scheduled"],
-        nodes: hash["nodes"],
-        total_splits: hash["totalSplits"],
-        queued_splits: hash["queuedSplits"],
-        running_splits: hash["runningSplits"],
-        completed_splits: hash["completedSplits"],
-        user_time_millis: hash["userTimeMillis"],
-        cpu_time_millis: hash["cpuTimeMillis"],
-        wall_time_millis: hash["wallTimeMillis"],
-        processed_rows: hash["processedRows"],
-        processed_bytes: hash["processedBytes"],
-        root_stage: hash["rootStage"] && StageStats.decode_hash(hash["rootStage"]),
-      )
+    class TaskId < String
     end
-  end
 
-  class ErrorLocation
-    attr_reader :line_number
-    attr_reader :column_number
+    class PlanNodeId < String
+    end
 
-    def initialize(options={})
-      @line_number = options[:line_number]
-      @column_number = options[:column_number]
+    class PlanFragmentId < String
     end
 
-    def self.decode_hash(hash)
-      new(
-        line_number: hash["lineNumber"],
-        column_number: hash["columnNumber"],
-      )
+    class ConnectorSession < Hash
+      def initialize(hash)
+        super()
+        merge!(hash)
+      end
     end
-  end
 
-  class FailureInfo
-    attr_reader :type
-    attr_reader :message
-    attr_reader :cause
-    attr_reader :suppressed
-    attr_reader :stack
-    attr_reader :error_location
-
-    def initialize(options={})
-      @type = options[:type]
-      @message = options[:message]
-      @cause = options[:cause]
-      @suppressed = options[:suppressed]
-      @stack = options[:stack]
-      @error_location = options[:error_location]
-    end
-
-    def self.decode_hash(hash)
-      new(
-        type: hash["type"],
-        message: hash["message"],
-        cause: hash["cause"],
-        suppressed: hash["suppressed"] && hash["suppressed"].map {|h| FailureInfo.decode_hash(h) },
-        stack: hash["stack"],
-        error_location: hash["errorLocation"] && ErrorLocation.decode_hash(hash["errorLocation"]),
-      )
+    module PlanNode
+      def self.decode(hash)
+        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 "materializeSample"  then MaterializeSampleNode
+          when "filter"             then FilterNode
+          when "window"             then WindowNode
+          when "limit"              then LimitNode
+          when "distinctlimit"      then DistinctLimitNode
+          when "topn"               then TopNNode
+          when "sample"             then SampleNode
+          when "sort"               then SortNode
+          when "exchange"           then ExchangeNode
+          when "sink"               then SinkNode
+          when "join"               then JoinNode
+          when "INNER"              then JoinNode
+          when "LEFT"               then JoinNode
+          when "RIGHT"              then JoinNode
+          when "CROSS"              then JoinNode
+          when "semijoin"           then SemiJoinNode
+          when "indexjoin"          then IndexJoinNode
+          when "indexsource"        then IndexSourceNode
+          when "tablewriter"        then TableWriterNode
+          when "tablecommit"        then TableCommitNode
+          else
+          end
+        model_class.decode(hash) if model_class
+      end
     end
-  end
 
-  class QueryError
-    attr_reader :message
-    attr_reader :sql_state
-    attr_reader :error_code
-    attr_reader :error_location
-    attr_reader :failure_info
-
-    def initialize(options={})
-      @message = options[:message]
-      @sql_state = options[:sql_state]
-      @error_code = options[:error_code]
-      @error_location = options[:error_location]
-      @failure_info = options[:failure_info]
-    end
-
-    def self.decode_hash(hash)
-      new(
-        message: hash["message"],
-        sql_state: hash["sqlState"],
-        error_code: hash["errorCode"],
-        error_location: hash["errorLocation"] && ErrorLocation.decode_hash(hash["errorLocation"]),
-        failure_info: hash["failureInfo"] && FailureInfo.decode_hash(hash["failureInfo"]),
-      )
+    # 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)
+        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
-  end
 
-  class QueryResults
-    attr_reader :id
-    attr_reader :info_uri
-    attr_reader :partial_cache_uri
-    attr_reader :next_uri
-    attr_reader :columns
-    attr_reader :data
-    attr_reader :stats
-    attr_reader :error
-
-    def initialize(options={})
-      @id = options[:id]
-      @info_uri = options[:info_uri]
-      @partial_cache_uri = options[:partial_cache_uri]
-      @next_uri = options[:next_uri]
-      @columns = options[:columns]
-      @data = options[:data]
-      @stats = options[:stats]
-      @error = options[:error]
-    end
-
-    def self.decode_hash(hash)
-      new(
-        id: hash["id"],
-        info_uri: hash["infoUri"],
-        partial_cache_uri: hash["partialCancelUri"],
-        next_uri: hash["nextUri"],
-        columns: hash["columns"] && hash["columns"].map {|h| Column.decode_hash(h) },
-        data: hash["data"],
-        stats: hash["stats"] && StatementStats.decode_hash(hash["stats"]),
-        error: hash["error"] && QueryError.decode_hash(hash["error"]),
-      )
+
+    ##
+    # Those model classes are automatically generated
+    #
+
+    class << AggregationNode =
+        Base.new(:id, :source, :group_by, :aggregations, :functions, :masks, :step, :sample_weight, :confidence)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["source"] && PlanNode.decode(hash["source"]),
+          hash["groupBy"],
+          hash["aggregations"],
+          hash["functions"] && Hash[hash["functions"].to_a.map! {|k,v| [k, Signature.decode(v)] }],
+          hash["masks"],
+          hash["step"] && hash["step"].downcase.to_sym,
+          hash["sampleWeight"],
+          hash["confidence"],
+        )
+        obj
+      end
+    end
+
+    class << BufferInfo =
+        Base.new(:buffer_id, :finished, :buffered_pages, :pages_sent)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["bufferId"],
+          hash["finished"],
+          hash["bufferedPages"],
+          hash["pagesSent"],
+        )
+        obj
+      end
+    end
+
+    class << Column =
+        Base.new(:name, :type)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["name"],
+          hash["type"],
+        )
+        obj
+      end
+    end
+
+    class << ColumnHandle =
+        Base.new(:connector_id, :connector_handle)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["connectorId"],
+          hash["connectorHandle"],
+        )
+        obj
+      end
+    end
+
+    class << DistinctLimitNode =
+        Base.new(:id, :source, :limit)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["source"] && PlanNode.decode(hash["source"]),
+          hash["limit"],
+        )
+        obj
+      end
+    end
+
+    class << DriverStats =
+        Base.new(:create_time, :start_time, :end_time, :queued_time, :elapsed_time, :memory_reservation, :total_scheduled_time, :total_cpu_time, :total_user_time, :total_blocked_time, :raw_input_data_size, :raw_input_positions, :raw_input_read_time, :processed_input_data_size, :processed_input_positions, :output_data_size, :output_positions, :operator_stats)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["createTime"],
+          hash["startTime"],
+          hash["endTime"],
+          hash["queuedTime"],
+          hash["elapsedTime"],
+          hash["memoryReservation"],
+          hash["totalScheduledTime"],
+          hash["totalCpuTime"],
+          hash["totalUserTime"],
+          hash["totalBlockedTime"],
+          hash["rawInputDataSize"],
+          hash["rawInputPositions"],
+          hash["rawInputReadTime"],
+          hash["processedInputDataSize"],
+          hash["processedInputPositions"],
+          hash["outputDataSize"],
+          hash["outputPositions"],
+          hash["operatorStats"] && hash["operatorStats"].map {|h| OperatorStats.decode(h) },
+        )
+        obj
+      end
+    end
+
+    class << ErrorCode =
+        Base.new(:code, :name)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["code"],
+          hash["name"],
+        )
+        obj
+      end
+    end
+
+    class << ErrorLocation =
+        Base.new(:line_number, :column_number)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["lineNumber"],
+          hash["columnNumber"],
+        )
+        obj
+      end
+    end
+
+    class << ExchangeNode =
+        Base.new(:id, :source_fragment_ids, :outputs)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["sourceFragmentIds"] && hash["sourceFragmentIds"].map {|h| PlanFragmentId.new(h) },
+          hash["outputs"],
+        )
+        obj
+      end
+    end
+
+    class << ExecutionFailureInfo =
+        Base.new(:type, :message, :cause, :suppressed, :stack, :error_location, :error_code)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["type"],
+          hash["message"],
+          hash["cause"] && ExecutionFailureInfo.decode(hash["cause"]),
+          hash["suppressed"] && hash["suppressed"].map {|h| ExecutionFailureInfo.decode(h) },
+          hash["stack"],
+          hash["errorLocation"] && ErrorLocation.decode(hash["errorLocation"]),
+          hash["errorCode"] && ErrorCode.decode(hash["errorCode"]),
+        )
+        obj
+      end
+    end
+
+    class << FailureInfo =
+        Base.new(:type, :message, :cause, :suppressed, :stack, :error_location)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["type"],
+          hash["message"],
+          hash["cause"] && FailureInfo.decode(hash["cause"]),
+          hash["suppressed"] && hash["suppressed"].map {|h| FailureInfo.decode(h) },
+          hash["stack"],
+          hash["errorLocation"] && ErrorLocation.decode(hash["errorLocation"]),
+        )
+        obj
+      end
+    end
+
+    class << FilterNode =
+        Base.new(:id, :source, :predicate)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["source"] && PlanNode.decode(hash["source"]),
+          hash["predicate"],
+        )
+        obj
+      end
+    end
+
+    class << IndexHandle =
+        Base.new(:connector_id, :connector_handle)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["connectorId"],
+          hash["connectorHandle"],
+        )
+        obj
+      end
+    end
+
+    class << IndexJoinNode =
+        Base.new(:id, :type, :probe_source, :index_source, :criteria)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["type"],
+          hash["probeSource"] && PlanNode.decode(hash["probeSource"]),
+          hash["indexSource"] && PlanNode.decode(hash["indexSource"]),
+        )
+        obj
+      end
+    end
+
+    class << IndexSourceNode =
+        Base.new(:id, :index_handle, :table_handle, :lookup_symbols, :output_symbols, :assignments, :effective_tuple_domain)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["indexHandle"] && IndexHandle.decode(hash["indexHandle"]),
+          hash["tableHandle"] && TableHandle.decode(hash["tableHandle"]),
+          hash["lookupSymbols"],
+          hash["outputSymbols"],
+          hash["assignments"] && Hash[hash["assignments"].to_a.map! {|k,v| [k, ColumnHandle.decode(v)] }],
+        )
+        obj
+      end
+    end
+
+    class << Input =
+        Base.new(:connector_id, :schema, :table, :columns)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["connectorId"],
+          hash["schema"],
+          hash["table"],
+          hash["columns"] && hash["columns"].map {|h| Column.decode(h) },
+        )
+        obj
+      end
+    end
+
+    class << JoinNode =
+        Base.new(:id, :type, :left, :right, :criteria)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["type"],
+          hash["left"] && PlanNode.decode(hash["left"]),
+          hash["right"] && PlanNode.decode(hash["right"]),
+        )
+        obj
+      end
+    end
+
+    class << LimitNode =
+        Base.new(:id, :source, :count, :sample_weight)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["source"] && PlanNode.decode(hash["source"]),
+          hash["count"],
+          hash["sampleWeight"],
+        )
+        obj
+      end
+    end
+
+    class << MarkDistinctNode =
+        Base.new(:id, :source, :marker_symbol, :distinct_symbols, :sample_weight_symbol)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["source"] && PlanNode.decode(hash["source"]),
+          hash["markerSymbol"],
+          hash["distinctSymbols"],
+          hash["sampleWeightSymbol"],
+        )
+        obj
+      end
+    end
+
+    class << MaterializeSampleNode =
+        Base.new(:id, :source, :sample_weight_symbol)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["source"] && PlanNode.decode(hash["source"]),
+          hash["sampleWeightSymbol"],
+        )
+        obj
+      end
+    end
+
+    class << OperatorStats =
+        Base.new(:operator_id, :operator_type, :add_input_calls, :add_input_wall, :add_input_cpu, :add_input_user, :input_data_size, :input_positions, :get_output_calls, :get_output_wall, :get_output_cpu, :get_output_user, :output_data_size, :output_positions, :blocked_wall, :finish_calls, :finish_wall, :finish_cpu, :finish_user, :memory_reservation, :info)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["operatorId"],
+          hash["operatorType"],
+          hash["addInputCalls"],
+          hash["addInputWall"],
+          hash["addInputCpu"],
+          hash["addInputUser"],
+          hash["inputDataSize"],
+          hash["inputPositions"],
+          hash["getOutputCalls"],
+          hash["getOutputWall"],
+          hash["getOutputCpu"],
+          hash["getOutputUser"],
+          hash["outputDataSize"],
+          hash["outputPositions"],
+          hash["blockedWall"],
+          hash["finishCalls"],
+          hash["finishWall"],
+          hash["finishCpu"],
+          hash["finishUser"],
+          hash["memoryReservation"],
+          hash["info"],
+        )
+        obj
+      end
+    end
+
+    class << OutputNode =
+        Base.new(:id, :source, :columns, :outputs)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["source"] && PlanNode.decode(hash["source"]),
+          hash["columns"],
+          hash["outputs"],
+        )
+        obj
+      end
     end
-  end
 
+    class << OutputTableHandle =
+        Base.new(:connector_id, :connector_handle)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["connectorId"],
+          hash["connectorHandle"],
+        )
+        obj
+      end
+    end
+
+    class << PipelineStats =
+        Base.new(:input_pipeline, :output_pipeline, :total_drivers, :queued_drivers, :running_drivers, :completed_drivers, :memory_reservation, :queued_time, :elapsed_time, :total_scheduled_time, :total_cpu_time, :total_user_time, :total_blocked_time, :raw_input_data_size, :raw_input_positions, :processed_input_data_size, :processed_input_positions, :output_data_size, :output_positions, :operator_summaries, :drivers)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["inputPipeline"],
+          hash["outputPipeline"],
+          hash["totalDrivers"],
+          hash["queuedDrivers"],
+          hash["runningDrivers"],
+          hash["completedDrivers"],
+          hash["memoryReservation"],
+          hash["queuedTime"] && DistributionSnapshot.decode(hash["queuedTime"]),
+          hash["elapsedTime"] && DistributionSnapshot.decode(hash["elapsedTime"]),
+          hash["totalScheduledTime"],
+          hash["totalCpuTime"],
+          hash["totalUserTime"],
+          hash["totalBlockedTime"],
+          hash["rawInputDataSize"],
+          hash["rawInputPositions"],
+          hash["processedInputDataSize"],
+          hash["processedInputPositions"],
+          hash["outputDataSize"],
+          hash["outputPositions"],
+          hash["operatorSummaries"] && hash["operatorSummaries"].map {|h| OperatorStats.decode(h) },
+          hash["drivers"] && hash["drivers"].map {|h| DriverStats.decode(h) },
+        )
+        obj
+      end
+    end
+
+    class << PlanFragment =
+        Base.new(:id, :root, :symbols, :distribution, :partitioned_source, :output_partitioning, :partition_by)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanFragmentId.new(hash["id"]),
+          hash["root"] && PlanNode.decode(hash["root"]),
+          hash["symbols"],
+          hash["distribution"] && hash["distribution"].downcase.to_sym,
+          hash["partitionedSource"] && PlanNodeId.new(hash["partitionedSource"]),
+          hash["outputPartitioning"] && hash["outputPartitioning"].downcase.to_sym,
+          hash["partitionBy"],
+        )
+        obj
+      end
+    end
+
+    class << ProjectNode =
+        Base.new(:id, :source, :assignments)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["source"] && PlanNode.decode(hash["source"]),
+          hash["assignments"],
+        )
+        obj
+      end
+    end
+
+    class << QueryError =
+        Base.new(:message, :sql_state, :error_code, :error_location, :failure_info)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["message"],
+          hash["sqlState"],
+          hash["errorCode"],
+          hash["errorLocation"] && ErrorLocation.decode(hash["errorLocation"]),
+          hash["failureInfo"] && FailureInfo.decode(hash["failureInfo"]),
+        )
+        obj
+      end
+    end
+
+    class << QueryInfo =
+        Base.new(:query_id, :session, :state, :self, :field_names, :query, :query_stats, :output_stage, :failure_info, :error_code, :inputs)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["queryId"] && QueryId.new(hash["queryId"]),
+          hash["session"] && ConnectorSession.new(hash["session"]),
+          hash["state"] && hash["state"].downcase.to_sym,
+          hash["self"],
+          hash["fieldNames"],
+          hash["query"],
+          hash["queryStats"] && QueryStats.decode(hash["queryStats"]),
+          hash["outputStage"] && StageInfo.decode(hash["outputStage"]),
+          hash["failureInfo"] && FailureInfo.decode(hash["failureInfo"]),
+          hash["errorCode"] && ErrorCode.decode(hash["errorCode"]),
+          hash["inputs"] && hash["inputs"].map {|h| Input.decode(h) },
+        )
+        obj
+      end
+    end
+
+    class << QueryResults =
+        Base.new(:id, :info_uri, :partial_cancel_uri, :next_uri, :columns, :data, :stats, :error)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"],
+          hash["infoUri"],
+          hash["partialCancelUri"],
+          hash["nextUri"],
+          hash["columns"] && hash["columns"].map {|h| Column.decode(h) },
+          hash["data"],
+          hash["stats"] && StatementStats.decode(hash["stats"]),
+          hash["error"] && QueryError.decode(hash["error"]),
+        )
+        obj
+      end
+    end
+
+    class << QueryStats =
+        Base.new(:create_time, :execution_start_time, :last_heartbeat, :end_time, :elapsed_time, :queued_time, :analysis_time, :distributed_planning_time, :total_planning_time, :total_tasks, :running_tasks, :completed_tasks, :total_drivers, :queued_drivers, :running_drivers, :completed_drivers, :total_memory_reservation, :total_scheduled_time, :total_cpu_time, :total_user_time, :total_blocked_time, :raw_input_data_size, :raw_input_positions, :processed_input_data_size, :processed_input_positions, :output_data_size, :output_positions)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["createTime"],
+          hash["executionStartTime"],
+          hash["lastHeartbeat"],
+          hash["endTime"],
+          hash["elapsedTime"],
+          hash["queuedTime"],
+          hash["analysisTime"],
+          hash["distributedPlanningTime"],
+          hash["totalPlanningTime"],
+          hash["totalTasks"],
+          hash["runningTasks"],
+          hash["completedTasks"],
+          hash["totalDrivers"],
+          hash["queuedDrivers"],
+          hash["runningDrivers"],
+          hash["completedDrivers"],
+          hash["totalMemoryReservation"],
+          hash["totalScheduledTime"],
+          hash["totalCpuTime"],
+          hash["totalUserTime"],
+          hash["totalBlockedTime"],
+          hash["rawInputDataSize"],
+          hash["rawInputPositions"],
+          hash["processedInputDataSize"],
+          hash["processedInputPositions"],
+          hash["outputDataSize"],
+          hash["outputPositions"],
+        )
+        obj
+      end
+    end
+
+    class << SampleNode =
+        Base.new(:id, :source, :sample_ratio, :sample_type, :rescaled, :sample_weight_symbol)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["source"] && PlanNode.decode(hash["source"]),
+          hash["sampleRatio"],
+          hash["sampleType"],
+          hash["rescaled"],
+          hash["sampleWeightSymbol"],
+        )
+        obj
+      end
+    end
+
+    class << SemiJoinNode =
+        Base.new(:id, :source, :filtering_source, :source_join_symbol, :filtering_source_join_symbol, :semi_join_output)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["source"] && PlanNode.decode(hash["source"]),
+          hash["filteringSource"] && PlanNode.decode(hash["filteringSource"]),
+          hash["sourceJoinSymbol"],
+          hash["filteringSourceJoinSymbol"],
+          hash["semiJoinOutput"],
+        )
+        obj
+      end
+    end
+
+    class << SharedBufferInfo =
+        Base.new(:state, :master_sequence_id, :pages_added, :buffers)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["state"] && hash["state"].downcase.to_sym,
+          hash["masterSequenceId"],
+          hash["pagesAdded"],
+          hash["buffers"] && hash["buffers"].map {|h| BufferInfo.decode(h) },
+        )
+        obj
+      end
+    end
+
+    class << Signature =
+        Base.new(:name, :return_type, :argument_types, :approximate)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["name"],
+          hash["returnType"],
+          hash["argumentTypes"],
+          hash["approximate"],
+        )
+        obj
+      end
+    end
+
+    class << SinkNode =
+        Base.new(:id, :source, :output_symbols)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["source"] && PlanNode.decode(hash["source"]),
+          hash["outputSymbols"],
+        )
+        obj
+      end
+    end
+
+    class << SortNode =
+        Base.new(:id, :source, :order_by, :orderings)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["source"] && PlanNode.decode(hash["source"]),
+          hash["orderBy"],
+          hash["orderings"] && Hash[hash["orderings"].to_a.map! {|k,v| [k, v.downcase.to_sym] }],
+        )
+        obj
+      end
+    end
+
+    class << StageInfo =
+        Base.new(:stage_id, :state, :self, :plan, :types, :stage_stats, :tasks, :sub_stages, :failures)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["stageId"] && StageId.new(hash["stageId"]),
+          hash["state"] && hash["state"].downcase.to_sym,
+          hash["self"],
+          hash["plan"] && PlanFragment.decode(hash["plan"]),
+          hash["types"],
+          hash["stageStats"] && StageStats.decode(hash["stageStats"]),
+          hash["tasks"] && hash["tasks"].map {|h| TaskInfo.decode(h) },
+          hash["subStages"] && hash["subStages"].map {|h| StageInfo.decode(h) },
+          hash["failures"] && hash["failures"].map {|h| ExecutionFailureInfo.decode(h) },
+        )
+        obj
+      end
+    end
+
+    class << StageStats =
+        Base.new(:stage_id, :state, :done, :nodes, :total_splits, :queued_splits, :running_splits, :completed_splits, :user_time_millis, :cpu_time_millis, :wall_time_millis, :processed_rows, :processed_bytes, :sub_stages)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["stageId"],
+          hash["state"],
+          hash["done"],
+          hash["nodes"],
+          hash["totalSplits"],
+          hash["queuedSplits"],
+          hash["runningSplits"],
+          hash["completedSplits"],
+          hash["userTimeMillis"],
+          hash["cpuTimeMillis"],
+          hash["wallTimeMillis"],
+          hash["processedRows"],
+          hash["processedBytes"],
+          hash["subStages"] && hash["subStages"].map {|h| StageStats.decode(h) },
+        )
+        obj
+      end
+    end
+
+    class << StatementStats =
+        Base.new(:state, :scheduled, :nodes, :total_splits, :queued_splits, :running_splits, :completed_splits, :user_time_millis, :cpu_time_millis, :wall_time_millis, :processed_rows, :processed_bytes, :root_stage)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["state"],
+          hash["scheduled"],
+          hash["nodes"],
+          hash["totalSplits"],
+          hash["queuedSplits"],
+          hash["runningSplits"],
+          hash["completedSplits"],
+          hash["userTimeMillis"],
+          hash["cpuTimeMillis"],
+          hash["wallTimeMillis"],
+          hash["processedRows"],
+          hash["processedBytes"],
+          hash["rootStage"] && StageStats.decode(hash["rootStage"]),
+        )
+        obj
+      end
+    end
+
+    class << TableCommitNode =
+        Base.new(:id, :source, :target, :outputs)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["source"] && PlanNode.decode(hash["source"]),
+          hash["target"] && OutputTableHandle.decode(hash["target"]),
+          hash["outputs"],
+        )
+        obj
+      end
+    end
+
+    class << TableHandle =
+        Base.new(:connector_id, :connector_handle)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["connectorId"],
+          hash["connectorHandle"],
+        )
+        obj
+      end
+    end
+
+    class << TableScanNode =
+        Base.new(:id, :table, :output_symbols, :assignments, :original_constraint)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["table"] && TableHandle.decode(hash["table"]),
+          hash["outputSymbols"],
+          hash["assignments"] && Hash[hash["assignments"].to_a.map! {|k,v| [k, ColumnHandle.decode(v)] }],
+          hash["originalConstraint"],
+        )
+        obj
+      end
+    end
+
+    class << TableWriterNode =
+        Base.new(:id, :source, :target, :columns, :column_names, :outputs, :sample_weight_symbol)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["source"] && PlanNode.decode(hash["source"]),
+          hash["target"] && OutputTableHandle.decode(hash["target"]),
+          hash["columns"],
+          hash["columnNames"],
+          hash["outputs"],
+          hash["sampleWeightSymbol"],
+        )
+        obj
+      end
+    end
+
+    class << TaskInfo =
+        Base.new(:task_id, :version, :state, :self, :last_heartbeat, :output_buffers, :no_more_splits, :stats, :failures)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["taskId"] && TaskId.new(hash["taskId"]),
+          hash["version"],
+          hash["state"] && hash["state"].downcase.to_sym,
+          hash["self"],
+          hash["lastHeartbeat"],
+          hash["outputBuffers"] && SharedBufferInfo.decode(hash["outputBuffers"]),
+          hash["noMoreSplits"] && hash["noMoreSplits"].map {|h| PlanNodeId.new(h) },
+          hash["stats"] && TaskStats.decode(hash["stats"]),
+          hash["failures"] && hash["failures"].map {|h| ExecutionFailureInfo.decode(h) },
+        )
+        obj
+      end
+    end
+
+    class << TaskStats =
+        Base.new(:create_time, :first_start_time, :last_start_time, :end_time, :elapsed_time, :queued_time, :total_drivers, :queued_drivers, :running_drivers, :completed_drivers, :memory_reservation, :total_scheduled_time, :total_cpu_time, :total_user_time, :total_blocked_time, :raw_input_data_size, :raw_input_positions, :processed_input_data_size, :processed_input_positions, :output_data_size, :output_positions, :pipelines)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["createTime"],
+          hash["firstStartTime"],
+          hash["lastStartTime"],
+          hash["endTime"],
+          hash["elapsedTime"],
+          hash["queuedTime"],
+          hash["totalDrivers"],
+          hash["queuedDrivers"],
+          hash["runningDrivers"],
+          hash["completedDrivers"],
+          hash["memoryReservation"],
+          hash["totalScheduledTime"],
+          hash["totalCpuTime"],
+          hash["totalUserTime"],
+          hash["totalBlockedTime"],
+          hash["rawInputDataSize"],
+          hash["rawInputPositions"],
+          hash["processedInputDataSize"],
+          hash["processedInputPositions"],
+          hash["outputDataSize"],
+          hash["outputPositions"],
+          hash["pipelines"] && hash["pipelines"].map {|h| PipelineStats.decode(h) },
+        )
+        obj
+      end
+    end
+
+    class << TopNNode =
+        Base.new(:id, :source, :count, :order_by, :orderings, :partial, :sample_weight)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["source"] && PlanNode.decode(hash["source"]),
+          hash["count"],
+          hash["orderBy"],
+          hash["orderings"] && Hash[hash["orderings"].to_a.map! {|k,v| [k, v.downcase.to_sym] }],
+          hash["partial"],
+          hash["sampleWeight"],
+        )
+        obj
+      end
+    end
+
+    class << ValuesNode =
+        Base.new(:id, :output_symbols, :rows)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["outputSymbols"],
+          hash["rows"],
+        )
+        obj
+      end
+    end
+
+    class << WindowNode =
+        Base.new(:id, :source, :partition_by, :order_by, :orderings, :window_functions, :signatures)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["id"] && PlanNodeId.new(hash["id"]),
+          hash["source"] && PlanNode.decode(hash["source"]),
+          hash["partitionBy"],
+          hash["orderBy"],
+          hash["orderings"] && Hash[hash["orderings"].to_a.map! {|k,v| [k, v.downcase.to_sym] }],
+          hash["windowFunctions"],
+          hash["signatures"] && Hash[hash["signatures"].to_a.map! {|k,v| [k, Signature.decode(v)] }],
+        )
+        obj
+      end
+    end
+
+
+  end
 end