presto-client 0.4.4 → 0.4.5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MjJiOTFmZDNlNzFmYzlkM2ZkMmE1ZGJkMDkzMjVkMjc5MjA3YzcyMg==
+    MjgzOWE1ZjExOWQzMWUxZmFiZTgwODcyYzMyZTMyNzcyZDkyYWI4Nw==
   data.tar.gz: !binary |-
-    Nzk0NGEzODRlMzBlNjVlNWJkOTZjYWJiZjM2ODc0Y2UxMDBiNGI4Zg==
+    NmU2YzJlZDBmN2ZmYzAxNzJhMmY4N2I1NGMyNGE5N2U4MzQzYzkxYg==
 SHA512:
   metadata.gz: !binary |-
-    MGZlNzViNTA4OWVjNmQ2MmRkMTBiN2E0MzBiN2RkMTQzZDI5ZWZjZDBjOTU5
-    ZGU5MGVlZTA4ZjE5OGZkZDYyY2I4ZTY4ZjM0OGUwNmE5MmJlYTBiNjQ2MjE3
-    YTY4NWZkZTVmYmYwMGM3ODBjMzgwYjBiMTgyMTJkMGMzZjk5MGU=
+    N2U2ZTNkOWVjZmEyZWZjOGVhMTA4M2FhYWU2YTBkZGY1ZDE5Yjg0YTU4Njc3
+    ZWMzOWU2NjQzODViYjhiOGFkZGY0MmY4YjI1ZTk4MmY3ZmE5NmM1ZDQyZjAz
+    MjY1Mjc2MGVlN2M2ZDE5OWI2YzIxNzQwMGU3OTE0MGQ2M2FhY2M=
   data.tar.gz: !binary |-
-    NmMzZmM1NjhmNTI5NDEwODA0MWYzYmM0NjlkYmNmOGExMmRkYTY4MWNlZTQy
-    YzA0ODMyNTE5ZDI5MTQ0ZDQ0ZTk4Yjg5OWNlYTQ4ZTBhZjE0OWIzMDFkZDAz
-    MjllZTdmM2ZlYzZiNjgwOWFkNmRlZmU5OTEzZTRlN2IzMWIwNzg=
+    OTAzNjk1ZDEyNDc0NTljZjNkMWM0ZGJkYzk1N2JmOTRmZDcwZGQ5MTQ2YWQw
+    MjQ5NDA3MTc0MDZjNjJkMGIxNWNmYWU5ZGFiYTY0NTk4MzkxNTEyMWRmYTdh
+    OTAxYzJiNTNiNDFkYjQ5MGUxNGVkMDY1ZmRiZjQ4M2RiN2QyMzA=

data/ChangeLog

@@ -1,4 +1,9 @@
 
+2015-04-01 version 0.4.5:
+
+* Upgraded Presto model version to 0.99
+
+
 2014-11-20 version 0.4.3:
 
 * Updated gem dependency to accept faraday ~> 0.9.x as well as ~> 0.8.8

data/Rakefile

@@ -12,7 +12,7 @@ end
 
 task :default => [:spec, :build]
 
-GEN_MODELS_VERSION = "0.85"
+GEN_MODELS_VERSION = "0.99"
 
 task :modelgen do
   unless Dir.exists?("presto-#{GEN_MODELS_VERSION}")

data/lib/presto/client/models.rb

@@ -102,7 +102,7 @@ module Presto::Client
           when "sample"             then SampleNode
           when "sort"               then SortNode
           when "exchange"           then ExchangeNode
-          when "sink"               then SinkNode
+          when "remoteSource"       then RemoteSourceNode
           when "join"               then JoinNode
           when "INNER"              then JoinNode
           when "LEFT"               then JoinNode
@@ -155,12 +155,24 @@ module Presto::Client
       end
     end
 
+    class << WriterTarget =
+        Base.new(:type, :handle)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["type"],
+          hash["type"] == 'InsertHandle' ? InsertTableHandle.decode(hash['handle']) : OutputTableHandle.decode(hash['handle'])
+        )
+        obj
+      end
+    end
+
     ##
     # Those model classes are automatically generated
     #
 
     class << AggregationNode =
-        Base.new(:id, :source, :group_by, :aggregations, :functions, :masks, :step, :sample_weight, :confidence)
+        Base.new(:id, :source, :group_by, :aggregations, :functions, :masks, :step, :sample_weight, :confidence, :hash_symbol)
       def decode(hash)
         obj = allocate
         obj.send(:initialize_struct,
@@ -173,6 +185,7 @@ module Presto::Client
           hash["step"] && hash["step"].downcase.to_sym,
           hash["sampleWeight"],
           hash["confidence"],
+          hash["hashSymbol"],
         )
         obj
       end
@@ -183,7 +196,7 @@ module Presto::Client
       def decode(hash)
         obj = allocate
         obj.send(:initialize_struct,
-          hash["bufferId"],
+          hash["bufferId"] && TaskId.new(hash["bufferId"]),
           hash["finished"],
           hash["bufferedPages"],
           hash["pagesSent"],
@@ -192,13 +205,27 @@ module Presto::Client
       end
     end
 
+    class << ClientTypeSignature =
+        Base.new(:raw_type, :type_arguments, :literal_arguments)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["rawType"],
+          hash["typeArguments"] && hash["typeArguments"].map {|h| ClientTypeSignature.decode(h) },
+          hash["literalArguments"],
+        )
+        obj
+      end
+    end
+
     class << Column =
-        Base.new(:name, :type)
+        Base.new(:name, :type, :type_signature)
       def decode(hash)
         obj = allocate
         obj.send(:initialize_struct,
           hash["name"],
           hash["type"],
+          hash["typeSignature"] && ClientTypeSignature.decode(hash["typeSignature"]),
         )
         obj
       end
@@ -217,13 +244,14 @@ module Presto::Client
     end
 
     class << DistinctLimitNode =
-        Base.new(:id, :source, :limit)
+        Base.new(:id, :source, :limit, :hash_symbol)
       def decode(hash)
         obj = allocate
         obj.send(:initialize_struct,
           hash["id"] && PlanNodeId.new(hash["id"]),
           hash["source"] && PlanNode.decode(hash["source"]),
           hash["limit"],
+          hash["hashSymbol"],
         )
         obj
       end
@@ -282,13 +310,17 @@ module Presto::Client
     end
 
     class << ExchangeNode =
-        Base.new(:id, :source_fragment_ids, :outputs)
+        Base.new(:id, :type, :partition_keys, :hash_symbol, :sources, :outputs, :inputs)
       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["type"],
+          hash["partitionKeys"],
+          hash["hashSymbol"],
+          hash["sources"] && hash["sources"].map {|h| PlanNode.decode(h) },
           hash["outputs"],
+          hash["inputs"],
         )
         obj
       end
@@ -353,7 +385,7 @@ module Presto::Client
     end
 
     class << IndexJoinNode =
-        Base.new(:id, :type, :probe_source, :index_source, :criteria)
+        Base.new(:id, :type, :probe_source, :index_source, :criteria, :probe_hash_symbol, :index_hash_symbol)
       def decode(hash)
         obj = allocate
         obj.send(:initialize_struct,
@@ -362,6 +394,8 @@ module Presto::Client
           hash["probeSource"] && PlanNode.decode(hash["probeSource"]),
           hash["indexSource"] && PlanNode.decode(hash["indexSource"]),
           hash["criteria"] && hash["criteria"].map {|h| EquiJoinClause.decode(h) },
+          hash["probeHashSymbol"],
+          hash["indexHashSymbol"],
         )
         obj
       end
@@ -397,8 +431,20 @@ module Presto::Client
       end
     end
 
+    class << InsertTableHandle =
+        Base.new(:connector_id, :connector_handle)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["connectorId"],
+          hash["connectorHandle"],
+        )
+        obj
+      end
+    end
+
     class << JoinNode =
-        Base.new(:id, :type, :left, :right, :criteria)
+        Base.new(:id, :type, :left, :right, :criteria, :left_hash_symbol, :right_hash_symbol)
       def decode(hash)
         obj = allocate
         obj.send(:initialize_struct,
@@ -407,27 +453,28 @@ module Presto::Client
           hash["left"] && PlanNode.decode(hash["left"]),
           hash["right"] && PlanNode.decode(hash["right"]),
           hash["criteria"] && hash["criteria"].map {|h| EquiJoinClause.decode(h) },
+          hash["leftHashSymbol"],
+          hash["rightHashSymbol"],
         )
         obj
       end
     end
 
     class << LimitNode =
-        Base.new(:id, :source, :count, :sample_weight)
+        Base.new(:id, :source, :count)
       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)
+        Base.new(:id, :source, :marker_symbol, :distinct_symbols, :hash_symbol)
       def decode(hash)
         obj = allocate
         obj.send(:initialize_struct,
@@ -435,20 +482,7 @@ module Presto::Client
           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"],
+          hash["hashSymbol"],
         )
         obj
       end
@@ -512,7 +546,7 @@ module Presto::Client
     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)
+        Base.new(:input_pipeline, :output_pipeline, :total_drivers, :queued_drivers, :queued_partitioned_drivers, :running_drivers, :running_partitioned_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,
@@ -520,7 +554,9 @@ module Presto::Client
           hash["outputPipeline"],
           hash["totalDrivers"],
           hash["queuedDrivers"],
+          hash["queuedPartitionedDrivers"],
           hash["runningDrivers"],
+          hash["runningPartitionedDrivers"],
           hash["completedDrivers"],
           hash["memoryReservation"],
           hash["queuedTime"] && DistributionSnapshot.decode(hash["queuedTime"]),
@@ -543,17 +579,19 @@ module Presto::Client
     end
 
     class << PlanFragment =
-        Base.new(:id, :root, :symbols, :distribution, :partitioned_source, :output_partitioning, :partition_by)
+        Base.new(:id, :root, :symbols, :output_layout, :distribution, :partitioned_source, :output_partitioning, :partition_by, :hash)
       def decode(hash)
         obj = allocate
         obj.send(:initialize_struct,
           hash["id"] && PlanFragmentId.new(hash["id"]),
           hash["root"] && PlanNode.decode(hash["root"]),
           hash["symbols"],
+          hash["outputLayout"],
           hash["distribution"] && hash["distribution"].downcase.to_sym,
           hash["partitionedSource"] && PlanNodeId.new(hash["partitionedSource"]),
           hash["outputPartitioning"] && hash["outputPartitioning"].downcase.to_sym,
           hash["partitionBy"],
+          hash["hash"],
         )
         obj
       end
@@ -588,17 +626,21 @@ module Presto::Client
     end
 
     class << QueryInfo =
-        Base.new(:query_id, :session, :state, :self, :field_names, :query, :query_stats, :output_stage, :failure_info, :error_code, :inputs)
+        Base.new(:query_id, :session, :state, :scheduled, :self, :field_names, :query, :query_stats, :set_session_properties, :reset_session_properties, :update_type, :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["session"] && Session.decode(hash["session"]),
           hash["state"] && hash["state"].downcase.to_sym,
+          hash["scheduled"],
           hash["self"],
           hash["fieldNames"],
           hash["query"],
           hash["queryStats"] && QueryStats.decode(hash["queryStats"]),
+          hash["setSessionProperties"],
+          hash["resetSessionProperties"],
+          hash["updateType"],
           hash["outputStage"] && StageInfo.decode(hash["outputStage"]),
           hash["failureInfo"] && FailureInfo.decode(hash["failureInfo"]),
           hash["errorCode"] && ErrorCode.decode(hash["errorCode"]),
@@ -609,7 +651,7 @@ module Presto::Client
     end
 
     class << QueryResults =
-        Base.new(:id, :info_uri, :partial_cancel_uri, :next_uri, :columns, :data, :stats, :error)
+        Base.new(:id, :info_uri, :partial_cancel_uri, :next_uri, :columns, :data, :stats, :error, :update_type, :update_count)
       def decode(hash)
         obj = allocate
         obj.send(:initialize_struct,
@@ -621,6 +663,8 @@ module Presto::Client
           hash["data"],
           hash["stats"] && StatementStats.decode(hash["stats"]),
           hash["error"] && QueryError.decode(hash["error"]),
+          hash["updateType"],
+          hash["updateCount"],
         )
         obj
       end
@@ -663,6 +707,19 @@ module Presto::Client
       end
     end
 
+    class << RemoteSourceNode =
+        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 << SampleNode =
         Base.new(:id, :source, :sample_ratio, :sample_type, :rescaled, :sample_weight_symbol)
       def decode(hash)
@@ -680,7 +737,7 @@ module Presto::Client
     end
 
     class << SemiJoinNode =
-        Base.new(:id, :source, :filtering_source, :source_join_symbol, :filtering_source_join_symbol, :semi_join_output)
+        Base.new(:id, :source, :filtering_source, :source_join_symbol, :filtering_source_join_symbol, :semi_join_output, :source_hash_symbol, :filtering_source_hash_symbol)
       def decode(hash)
         obj = allocate
         obj.send(:initialize_struct,
@@ -690,6 +747,29 @@ module Presto::Client
           hash["sourceJoinSymbol"],
           hash["filteringSourceJoinSymbol"],
           hash["semiJoinOutput"],
+          hash["sourceHashSymbol"],
+          hash["filteringSourceHashSymbol"],
+        )
+        obj
+      end
+    end
+
+    class << Session =
+        Base.new(:user, :source, :catalog, :schema, :time_zone_key, :locale, :remote_user_address, :user_agent, :start_time, :system_properties, :catalog_properties)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["user"],
+          hash["source"],
+          hash["catalog"],
+          hash["schema"],
+          hash["timeZoneKey"],
+          hash["locale"],
+          hash["remoteUserAddress"],
+          hash["userAgent"],
+          hash["startTime"],
+          hash["systemProperties"],
+          hash["catalogProperties"],
         )
         obj
       end
@@ -710,27 +790,16 @@ module Presto::Client
     end
 
     class << Signature =
-        Base.new(:name, :return_type, :argument_types, :approximate)
+        Base.new(:name, :type_parameters, :return_type, :argument_types, :variable_arity, :internal)
       def decode(hash)
         obj = allocate
         obj.send(:initialize_struct,
           hash["name"],
+          hash["typeParameters"] && hash["typeParameters"].map {|h| TypeParameter.decode(h) },
           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"],
+          hash["variableArity"],
+          hash["internal"],
         )
         obj
       end
@@ -823,7 +892,7 @@ module Presto::Client
         obj.send(:initialize_struct,
           hash["id"] && PlanNodeId.new(hash["id"]),
           hash["source"] && PlanNode.decode(hash["source"]),
-          hash["target"] && OutputTableHandle.decode(hash["target"]),
+          hash["target"] && WriterTarget.decode(hash["target"]),
           hash["outputs"],
         )
         obj
@@ -864,7 +933,7 @@ module Presto::Client
         obj.send(:initialize_struct,
           hash["id"] && PlanNodeId.new(hash["id"]),
           hash["source"] && PlanNode.decode(hash["source"]),
-          hash["target"] && OutputTableHandle.decode(hash["target"]),
+          hash["target"] && WriterTarget.decode(hash["target"]),
           hash["columns"],
           hash["columnNames"],
           hash["outputs"],
@@ -875,11 +944,12 @@ module Presto::Client
     end
 
     class << TaskInfo =
-        Base.new(:task_id, :version, :state, :self, :last_heartbeat, :output_buffers, :no_more_splits, :stats, :failures)
+        Base.new(:task_id, :node_instance_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["nodeInstanceId"],
           hash["version"],
           hash["state"] && hash["state"].downcase.to_sym,
           hash["self"],
@@ -894,7 +964,7 @@ module Presto::Client
     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)
+        Base.new(:create_time, :first_start_time, :last_start_time, :end_time, :elapsed_time, :queued_time, :total_drivers, :queued_drivers, :queued_partitioned_drivers, :running_drivers, :running_partitioned_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,
@@ -906,7 +976,9 @@ module Presto::Client
           hash["queuedTime"],
           hash["totalDrivers"],
           hash["queuedDrivers"],
+          hash["queuedPartitionedDrivers"],
           hash["runningDrivers"],
+          hash["runningPartitionedDrivers"],
           hash["completedDrivers"],
           hash["memoryReservation"],
           hash["totalScheduledTime"],
@@ -926,7 +998,7 @@ module Presto::Client
     end
 
     class << TopNNode =
-        Base.new(:id, :source, :count, :order_by, :orderings, :partial, :sample_weight)
+        Base.new(:id, :source, :count, :order_by, :orderings, :partial)
       def decode(hash)
         obj = allocate
         obj.send(:initialize_struct,
@@ -936,7 +1008,20 @@ module Presto::Client
           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 << TypeParameter =
+        Base.new(:name, :comparable_required, :orderable_required, :variadic_bound)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["name"],
+          hash["comparableRequired"],
+          hash["orderableRequired"],
+          hash["variadicBound"],
         )
         obj
       end
@@ -956,7 +1041,7 @@ module Presto::Client
     end
 
     class << WindowNode =
-        Base.new(:id, :source, :partition_by, :order_by, :orderings, :window_functions, :signatures)
+        Base.new(:id, :source, :partition_by, :order_by, :orderings, :frame, :window_functions, :signatures, :hash_symbol)
       def decode(hash)
         obj = allocate
         obj.send(:initialize_struct,
@@ -965,8 +1050,10 @@ module Presto::Client
           hash["partitionBy"],
           hash["orderBy"],
           hash["orderings"] && Hash[hash["orderings"].to_a.map! {|k,v| [k, v.downcase.to_sym] }],
+          hash["frame"],
           hash["windowFunctions"],
           hash["signatures"] && Hash[hash["signatures"].to_a.map! {|k,v| [k, Signature.decode(v)] }],
+          hash["hashSymbol"],
         )
         obj
       end

data/lib/presto/client/version.rb

@@ -15,6 +15,6 @@
 #
 module Presto
   module Client
-    VERSION = "0.4.4"
+    VERSION = "0.4.5"
   end
 end

data/modelgen/modelgen.rb

@@ -10,13 +10,13 @@ require_relative 'presto_models'
 require 'erb'
 erb = ERB.new(File.read(template_path))
 
-source_path = "/Users/frsyuki/project/presto-client-ruby/presto"
+source_path = source_dir
 
 predefined_simple_classes = %w[QueryId StageId TaskId PlanNodeId PlanFragmentId ConnectorSession]
-predefined_models = %w[DistributionSnapshot PlanNode EquiJoinClause]
+predefined_models = %w[DistributionSnapshot PlanNode EquiJoinClause WriterTarget]
 
-assume_primitive = %w[Object Type Symbol URI Duration DataSize DateTime ConnectorTableHandle ConnectorOutputTableHandle ConnectorIndexHandle ConnectorColumnHandle Expression FunctionCall]
-enum_types = %w[QueryState StageState TaskState QueueState PlanDistribution OutputPartitioning Step SortOrder]
+assume_primitive = %w[Object Type Long Symbol URI Duration DataSize DateTime ConnectorTableHandle ConnectorOutputTableHandle ConnectorIndexHandle ConnectorColumnHandle ConnectorInsertTableHandle Expression FunctionCall TimeZoneKey Locale TypeSignature Frame]
+enum_types = %w[QueryState StageState TaskState QueueState PlanDistribution OutputPartitioning Step SortOrder BufferState]
 
 root_models = %w[QueryResults QueryInfo] + %w[
 OutputNode
@@ -25,7 +25,6 @@ TableScanNode
 ValuesNode
 AggregationNode
 MarkDistinctNode
-MaterializeSampleNode
 FilterNode
 WindowNode
 LimitNode
@@ -34,14 +33,14 @@ TopNNode
 SampleNode
 SortNode
 ExchangeNode
-SinkNode
+RemoteSourceNode
 JoinNode
 SemiJoinNode
 IndexJoinNode
 IndexSourceNode
 TableWriterNode
 TableCommitNode
-]
+] + %w[InsertTableHandle OutputTableHandle]
 
 analyzer = PrestoModels::ModelAnalyzer.new(
   source_path,

data/modelgen/models.rb

@@ -102,7 +102,7 @@ module Presto::Client
           when "sample"             then SampleNode
           when "sort"               then SortNode
           when "exchange"           then ExchangeNode
-          when "sink"               then SinkNode
+          when "remoteSource"       then RemoteSourceNode
           when "join"               then JoinNode
           when "INNER"              then JoinNode
           when "LEFT"               then JoinNode
@@ -155,6 +155,18 @@ module Presto::Client
       end
     end
 
+    class << WriterTarget =
+        Base.new(:type, :handle)
+      def decode(hash)
+        obj = allocate
+        obj.send(:initialize_struct,
+          hash["type"],
+          hash["type"] == 'InsertHandle' ? InsertTableHandle.decode(hash['handle']) : OutputTableHandle.decode(hash['handle'])
+        )
+        obj
+      end
+    end
+
     ##
     # Those model classes are automatically generated
     #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: presto-client
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.5
 platform: ruby
 authors:
 - Sadayuki Furuhashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-05 00:00:00.000000000 Z
+date: 2015-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -110,7 +110,6 @@ files:
 - modelgen/models.rb
 - modelgen/presto_models.rb
 - presto-client.gemspec
-- presto-client.rb
 - spec/spec_helper.rb
 - spec/statement_client_spec.rb
 homepage: https://github.com/treasure-data/presto-client-ruby
@@ -140,3 +139,4 @@ summary: Presto client library
 test_files:
 - spec/spec_helper.rb
 - spec/statement_client_spec.rb
+has_rdoc: false

data/presto-client.rb

@@ -1,420 +0,0 @@
-
-module PrestoClient
-  VERSION = "0.1.0"
-
-  require 'faraday'
-  require 'json'
-
-  class ClientSession
-    def initialize(options)
-      @server = options[:server]
-      @user = options[:user]
-      @source = options[:source]
-      @catalog = options[:catalog]
-      @schema = options[:schema]
-      @debug = !!options[:debug]
-    end
-
-    attr_reader :server
-    attr_reader :user
-    attr_reader :source
-    attr_reader :catalog
-    attr_reader :schema
-
-    def debug?
-      @debug
-    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"].map {|h| StageStats.decode_hash(h) },
-  #    )
-  #  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 = state
-      @scheduled = scheduled
-      @nodes = nodes
-      @total_splits = total_splits
-      @queued_splits = queued_splits
-      @running_splits = running_splits
-      @completed_splits = completed_splits
-      @user_time_millis = user_time_millis
-      @cpu_time_millis = cpu_time_millis
-      @wall_time_millis = wall_time_millis
-      @processed_rows = processed_rows
-      @processed_bytes = processed_bytes
-      #@root_stage = 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: StageStats.decode_hash(hash["rootStage"]),
-      )
-    end
-  end
-
-  class Column
-    attr_reader :name
-    attr_reader :type
-
-    def initialize(options={})
-      @name = options[:name]
-      @type = options[:type]
-    end
-
-    def self.decode_hash(hash)
-      new(
-        name: hash["name"],
-        type: hash["type"],
-      )
-    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) } : nil,
-        data: hash["data"]
-        stats: StatementStats.decode_hash(hash["stats"]),
-        error: hash["error"],  # TODO
-      )
-    end
-  end
-
-  module PrestoHeaders
-    PRESTO_USER = "X-Presto-User"
-    PRESTO_SOURCE = "X-Presto-Source"
-    PRESTO_CATALOG = "X-Presto-Catalog"
-    PRESTO_SCHEMA = "X-Presto-Schema"
-
-    PRESTO_CURRENT_STATE = "X-Presto-Current-State"
-    PRESTO_MAX_WAIT = "X-Presto-Max-Wait"
-    PRESTO_MAX_SIZE = "X-Presto-Max-Size"
-    PRESTO_PAGE_SEQUENCE_ID = "X-Presto-Page-Sequence-Id"
-  end
-
-  class StatementClient
-    HEADERS = {
-      "User-Agent" => "presto-ruby/#{VERSION}"
-    }
-
-    def initialize(faraday, session, query)
-      @faraday = faraday
-      @faraday.headers.merge!(HEADERS)
-
-      @session = session
-      @query = query
-      @closed = false
-      @exception = nil
-      post_query_request!
-    end
-
-    def post_query_request!
-      response = @faraday.post do |req|
-        req.url "/v1/statement"
-
-        if v = @session.user
-          req.headers[PrestoHeaders::PRESTO_USER] = v
-        end
-        if v = @session.source
-          req.headers[PrestoHeaders::PRESTO_SOURCE] = v
-        end
-        if catalog = @session.catalog
-          req.headers[PrestoHeaders::PRESTO_CATALOG] = catalog
-        end
-        if v = @session.schema
-          req.headers[PrestoHeaders::PRESTO_SCHEMA] = v
-        end
-
-        req.body = @query
-      end
-
-      # TODO error handling
-      if response.status != 200
-        raise "Failed to start query: #{response.body}"  # TODO error class
-      end
-
-      body = response.body
-      hash = JSON.parse(body)
-      @results = QueryResults.decode_hash(hash)
-    end
-
-    private :post_query_request!
-
-    attr_reader :query
-
-    def debug?
-      @session.debug?
-    end
-
-    def closed?
-      @closed
-    end
-
-    attr_reader :exception
-
-    def exception?
-      @exception
-    end
-
-    def query_failed?
-      @results.error != nil
-    end
-
-    def query_succeeded?
-      @results.error == nil && !@exception && !@closed
-    end
-
-    def current_results
-      @results
-    end
-
-    def has_next?
-      !!@results.next_uri
-    end
-
-    def advance
-      if closed? || !has_next?
-        return false
-      end
-      uri = @results.next_uri
-
-      start = Time.now
-      attempts = 0
-
-      begin
-        begin
-          response = @faraday.get do |req|
-            req.url uri
-          end
-        rescue => e
-          @exception = e
-          raise @exception
-        end
-
-        if response.status == 200 && !response.body.to_s.empty?
-          @results = QueryResults.decode_hash(JSON.parse(response.body))
-          return true
-        end
-
-        if response.status != 503  # retry on 503 Service Unavailable
-          # deterministic error
-          @exception = StandardError.new("Error fetching next at #{uri} returned #{response.status}: #{response.body}")  # TODO error class
-          raise @exception
-        end
-
-        attempts += 1
-        sleep attempts * 0.1
-      end while (Time.now - start) < 2*60*60 && !@closed
-
-      @exception = StandardError.new("Error fetching next")  # TODO error class
-      raise @exception
-    end
-
-    def close
-      return if @closed
-
-      # cancel running statement
-      if uri = @results.next_uri
-        # TODO error handling
-        # TODO make async reqeust and ignore response
-        @faraday.delete do |req|
-          req.url uri
-        end
-      end
-
-      @closed = true
-      nil
-    end
-  end
-
-  class Query
-    def self.start(session, query)
-      faraday = Faraday.new(url: "http://#{session.server}") do |faraday|
-        faraday.request :url_encoded
-        faraday.response :logger
-        faraday.adapter Faraday.default_adapter
-      end
-
-      new StatementClient.new(faraday, session, query)
-    end
-
-    def initialize(client)
-      @client = client
-    end
-
-    def wait_for_data
-      while @client.has_next? && @client.current_results.data == nil
-        @client.advance
-      end
-    end
-
-    private :wait_for_data
-
-    def columns
-      wait_for_data
-
-      raise_error unless @client.query_succeeded?
-
-      return @client.current_results.columns
-    end
-
-    def each_row(&block)
-      wait_for_data
-
-      raise_error unless @client.query_succeeded?
-
-      if self.columns == nil
-        raise "Query #{@client.current_results.id} has no columns"
-      end
-
-      begin
-        if data = @client.current_results.data
-          data.each(&block)
-        end
-        @client.advance
-      end while @client.has_next?
-    end
-
-    def raise_error
-      if @client.closed?
-        raise "Query aborted by user"
-      elsif @client.exception?
-        raise "Query is gone: #{@client.exception}"
-      elsif @client.query_failed?
-        results = @client.current_results
-        # TODO error location
-        raise "Query #{results.id} failed: #{results.error}"
-      end
-    end
-
-    private :raise_error
-  end
-
-  class Client
-    def initialize(options)
-      @session = ClientSession.new(options)
-    end
-
-    def query(query)
-      Query.start(@session, query)
-    end
-  end
-end
-
-require 'pp'
-
-client = PrestoClient::Client.new(
-  server: "localhost:8880",
-  user: "frsyuki",
-  catalog: "native",
-  schema: "default",
-  debug: true
-)
-
-q = client.query("select * from sys.query")
-p q.columns
-q.each_row {|row|
-  p row
-}
-