rbhive 0.2.95 → 0.5.0

data/.gitignore

@@ -0,0 +1,2 @@
+*.gem
+.DS_Store

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) [2013] [Forward3D]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,204 @@
+# RBHive -- Ruby thrift lib for executing Hive queries
+
+RBHive is a simple Ruby gem to communicate with the [Apache Hive](http://hive.apache.org)
+Thrift server.
+
+It supports:
+* Hiveserver (the original Thrift service shipped with Hive since early releases)
+* Hiveserver2 (the new, concurrent Thrift service shipped with Hive releases since 0.10)
+* Any other 100% Hive-compatible Thrift service (e.g. [Sharkserver](https://github.com/amplab/shark))
+
+It is capable of using the following Thrift transports:
+* BufferedTransport (the default)
+* SaslClientTransport ([SASL-enabled](http://en.wikipedia.org/wiki/Simple_Authentication_and_Security_Layer) transport)
+* HTTPClientTransport (tunnels Thrift over HTTP)
+
+## About Thrift services and transports
+
+### Hiveserver
+
+Hiveserver (the original Thrift interface) only supports a single client at a time. RBHive
+implements this with the `RBHive::Connection` class. It only supports a single transport,
+BufferedTransport.
+
+### Hiveserver2
+
+[Hiveserver2](https://cwiki.apache.org/confluence/display/Hive/Setting+up+HiveServer2) 
+(the new Thrift interface) can support many concurrent client connections. It is shipped
+with Hive 0.10 and later. In Hive 0.10, only BufferedTranport and SaslClientTransport are
+supported; starting with Hive 0.12, HTTPClientTransport is also supported.
+
+Each of the versions after Hive 0.10 has a slightly different Thrift interface; when
+connecting, you must specify the Hive version or you may get an exception.
+
+RBHive implements this client with the `RBHive::TCLIConnection` class.
+
+### Other Hive-compatible services
+
+Consult the documentation for the service, as this will vary depending on the service you're using.
+
+## Connecting to Hiveserver and Hiveserver2
+
+### Hiveserver
+
+Since Hiveserver has no options, connection code is very simple:
+
+    RBHive.connect('hive.server.address', 10_000) do |connection|
+      connection.fetch 'SELECT city, country FROM cities'
+    end 
+    ➔ [{:city => "London", :country => "UK"}, {:city => "Mumbai", :country => "India"}, {:city => "New York", :country => "USA"}]
+
+### Hiveserver2
+
+Hiveserver2 has several options with how it is run. The connection code takes
+a hash with these possible parameters:
+* `:transport` - one of `:buffered` (BufferedTransport), `:http` (HTTPClientTransport), or `:sasl` (SaslClientTransport)
+* `:hive_version` - the number after the period in the Hive version; e.g. `10`, `11`, `12`
+* `:timeout` - if using BufferedTransport or SaslClientTransport, this is how long the timeout on the socket will be
+* `:sasl_params` - if using SaslClientTransport, this is a hash of parameters to set up the SASL connection
+
+If you pass either an empty hash or nil in place of the options (or do not supply them), the connection 
+is attempted with the Hive version set to 0.10, using `:buffered` as the transport, and a timeout of 1800 seconds.
+
+Connecting with the defaults:
+
+    RBHive.tcli_connect('hive.server.address', 10_000) do |connection|
+      connection.fetch('SHOW TABLES')
+    end
+
+Connecting with a specific Hive version (0.12 in this case):
+
+    RBHive.tcli_connect('hive.server.address', 10_000, {:hive_version => 12}) do |connection|
+      connection.fetch('SHOW TABLES')
+    end
+
+Connecting with a specific Hive version (0.12) and using the `:http` transport:
+
+    RBHive.tcli_connect('hive.server.address', 10_000, {:hive_version => 12, :transport => :http}) do |connection|
+      connection.fetch('SHOW TABLES')
+    end 
+
+We have not tested the SASL connection, as we don't run SASL; pull requests and testing are welcomed.
+
+## Examples
+
+### Fetching results
+
+#### Hiveserver
+
+    RBHive.connect('hive.server.address', 10_000) do |connection|
+      connection.fetch 'SELECT city, country FROM cities'
+    end 
+    ➔ [{:city => "London", :country => "UK"}, {:city => "Mumbai", :country => "India"}, {:city => "New York", :country => "USA"}]
+
+#### Hiveserver2
+
+    RBHive.tcli_connect('hive.server.address', 10_000) do |connection|
+      connection.fetch 'SELECT city, country FROM cities'
+    end 
+    ➔ [{:city => "London", :country => "UK"}, {:city => "Mumbai", :country => "India"}, {:city => "New York", :country => "USA"}]
+
+### Executing a query
+
+#### Hiveserver
+
+    RBHive.connect('hive.server.address') do |connection|
+      connection.execute 'DROP TABLE cities'
+    end
+    ➔ nil
+
+#### Hiveserver2
+
+    RBHive.tcli_connect('hive.server.address') do |connection|
+      connection.execute 'DROP TABLE cities'
+    end
+    ➔ nil
+
+### Creating tables
+
+    table = TableSchema.new('person', 'List of people that owe me money') do
+      column 'name', :string, 'Full name of debtor'
+      column 'address', :string, 'Address of debtor'
+      column 'amount', :float, 'The amount of money borrowed'
+
+      partition 'dated', :string, 'The date money was given'
+      partition 'country', :string, 'The country the person resides in'
+    end
+
+Then for Hiveserver:
+
+    RBHive.connect('hive.server.address', 10_000) do |connection|
+      connection.create_table(table)
+    end  
+
+Or Hiveserver2:
+
+    RBHive.tcli_connect('hive.server.address', 10_000) do |connection|
+      connection.create_table(table)
+    end  
+
+### Modifying table schema
+
+    table = TableSchema.new('person', 'List of people that owe me money') do
+      column 'name', :string, 'Full name of debtor'
+      column 'address', :string, 'Address of debtor'
+      column 'amount', :float, 'The amount of money borrowed'
+      column 'new_amount', :float, 'The new amount this person somehow convinced me to give them'
+
+      partition 'dated', :string, 'The date money was given'
+      partition 'country', :string, 'The country the person resides in'
+    end
+
+Then for Hiveserver:
+
+    RBHive.connect('hive.server.address') do |connection|
+      connection.replace_columns(table)
+    end  
+
+Or Hiveserver2:
+
+    RBHive.tcli_connect('hive.server.address') do |connection|
+      connection.replace_columns(table)
+    end  
+
+### Setting properties
+
+You can set various properties for Hive tasks, some of which change how they run. Consult the Apache
+Hive documentation and Hadoop's documentation for the various properties that can be set. 
+For example, you can set the map-reduce job's priority with the following:
+
+    connection.set("mapred.job.priority", "VERY_HIGH")
+
+### Inspecting tables
+
+#### Hiveserver
+
+    RBHive.connect('hive.hadoop.forward.co.uk', 10_000) {|connection| 
+      result = connection.fetch("describe some_table")
+      puts result.column_names.inspect
+      puts result.first.inspect
+    }
+
+#### Hiveserver2
+
+    RBHive.tcli_connect('hive.hadoop.forward.co.uk', 10_000) {|connection| 
+      result = connection.fetch("describe some_table")
+      puts result.column_names.inspect
+      puts result.first.inspect
+    }
+
+## Testing
+
+We use RBHive against Hive 0.10, 0.11 and 0.12, and have tested the BufferedTransport and
+HTTPClientTransport. We use it against both Hiveserver and Hiveserver2 with success.
+
+We have _not_ tested the SaslClientTransport, and would welcome reports
+on whether it works correctly.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/rbhive/connection.rb

@@ -2,6 +2,7 @@
 old_verbose, $VERBOSE = $VERBOSE, nil
 # require thrift autogenerated files
 require File.join(File.dirname(__FILE__), *%w[.. thrift thrift_hive])
+# require 'thrift'
 # restore warnings
 $VERBOSE = old_verbose
 
@@ -34,7 +35,7 @@ module RBHive
       @socket = Thrift::Socket.new(server, port)
       @transport = Thrift::BufferedTransport.new(@socket)
       @protocol = Thrift::BinaryProtocol.new(@transport)
-      @client = ThriftHive::Client.new(@protocol)
+      @client = Hive::Thrift::ThriftHive::Client.new(@protocol)
       @logger = logger
       @logger.info("Connecting to #{server} on port #{port}")
       @mutex = Mutex.new

data/lib/rbhive/t_c_l_i_connection.rb

@@ -0,0 +1,315 @@
+# suppress warnings
+old_verbose, $VERBOSE = $VERBOSE, nil
+
+raise 'Thrift is not loaded' unless defined?(Thrift)
+raise 'RBHive is not loaded' unless defined?(RBHive)
+
+# require thrift autogenerated files
+require File.join(File.dirname(__FILE__), *%w[.. thrift t_c_l_i_service_constants])
+require File.join(File.dirname(__FILE__), *%w[.. thrift t_c_l_i_service])
+require File.join(File.dirname(__FILE__), *%w[.. thrift sasl_client_transport])
+
+# restore warnings
+$VERBOSE = old_verbose
+
+# Monkey patch thrift to set an infinite read timeout
+module Thrift
+  class HTTPClientTransport < BaseTransport
+    def flush
+      http = Net::HTTP.new @url.host, @url.port
+      http.use_ssl = @url.scheme == 'https'
+      http.read_timeout = nil
+      http.verify_mode = @ssl_verify_mode if @url.scheme == 'https'
+      resp = http.post(@url.request_uri, @outbuf, @headers)
+      data = resp.body
+      data = Bytes.force_binary_encoding(data)
+      @inbuf = StringIO.new data
+      @outbuf = Bytes.empty_byte_buffer
+    end
+  end
+end
+
+module RBHive
+  
+  HIVE_THRIFT_MAPPING = {
+    10 => 0,
+    11 => 1,
+    12 => 2
+  }
+  
+  def tcli_connect(server, port=10_000, options)
+    connection = RBHive::TCLIConnection.new(server, port, options)
+    ret = nil
+    begin
+      connection.open
+      connection.open_session
+      ret = yield(connection)
+
+    ensure
+      # Try to close the session and our connection if those are still open, ignore io errors
+      begin
+        connection.close_session if connection.session
+        connection.close
+      rescue IOError => e
+        # noop
+      end
+    end
+
+    return ret
+  end
+  module_function :tcli_connect
+
+  class StdOutLogger
+    %w(fatal error warn info debug).each do |level|
+      define_method level.to_sym do |message|
+        STDOUT.puts(message)
+     end
+   end
+  end
+
+  class TCLIConnection
+    attr_reader :client
+
+    def initialize(server, port=10_000, options={}, logger=StdOutLogger.new)
+      options ||= {} # backwards compatibility
+      raise "'options' parameter must be a hash" unless options.is_a?(Hash)
+      
+      if options[:transport] == :sasl and options[:sasl_params].nil?
+        raise ":transport is set to :sasl, but no :sasl_params option was supplied"
+      end
+      
+      # Defaults to buffered transport, Hive 0.10, 1800 second timeout
+      options[:transport]     ||= :buffered
+      options[:hive_version]  ||= 10
+      options[:timeout]       ||= 1800
+      @options = options
+      
+      # Look up the appropriate Thrift protocol version for the supplied Hive version
+      @thrift_protocol_version = thrift_hive_protocol(options[:hive_version])
+      
+      @logger = logger
+      @transport = thrift_transport(server, port)
+      @protocol = Thrift::BinaryProtocol.new(@transport)
+      @client = Hive2::Thrift::TCLIService::Client.new(@protocol)
+      @session = nil
+      @logger.info("Connecting to HiveServer2 #{server} on port #{port}")
+      @mutex = Mutex.new
+    end
+    
+    def thrift_hive_protocol(version)
+      HIVE_THRIFT_MAPPING[version] || raise("Invalid Hive version")
+    end
+    
+    def thrift_transport(server, port)
+      @logger.info("Initializing transport #{@options[:transport]}")
+      case @options[:transport]
+      when :buffered
+        return Thrift::BufferedTransport.new(thrift_socket(server, port, @options[:timeout]))
+      when :sasl
+        return Thrift::SaslClientTransport.new(thrift_socket(server, port, @options[:timeout]),
+                                               parse_sasl_params(@options[:sasl_params]))
+      when :http
+        return Thrift::HTTPClientTransport.new("http://#{server}:#{port}/cliservice")
+      else
+        raise "Unrecognised transport type '#{transport}'"
+      end
+    end
+
+    def thrift_socket(server, port, timeout)
+      socket = Thrift::Socket.new(server, port)
+      socket.timeout = timeout
+      socket
+    end
+
+    # Processes SASL connection params and returns a hash with symbol keys or a nil
+    def parse_sasl_params(sasl_params)
+      # Symbilize keys in a hash
+      if sasl_params.kind_of?(Hash)
+        return sasl_params.inject({}) do |memo,(k,v)|
+          memo[k.to_sym] = v;
+          memo
+        end
+      end
+      return nil
+    end
+
+    def open
+      @transport.open
+    end
+
+    def close
+      @transport.close
+    end
+
+    def open_session
+      @session = @client.OpenSession(prepare_open_session(@thrift_protocol_version))
+    end
+
+    def close_session
+      @client.CloseSession prepare_close_session
+      @session = nil
+    end
+
+    def session
+      @session && @session.sessionHandle
+    end
+
+    def client
+      @client
+    end
+
+    def execute(query)
+      execute_safe(query)
+    end
+
+    def priority=(priority)
+      set("mapred.job.priority", priority)
+    end
+
+    def queue=(queue)
+      set("mapred.job.queue.name", queue)
+    end
+
+    def set(name,value)
+      @logger.info("Setting #{name}=#{value}")
+      self.execute("SET #{name}=#{value}")
+    end
+
+    # Performs a query on the server, fetches up to *max_rows* rows and returns them as an array.
+    def fetch(query, max_rows = 100)
+      safe do
+        # Execute the query and check the result
+        exec_result = execute_unsafe(query)
+        raise_error_if_failed!(exec_result)
+
+        # Get search operation handle to fetch the results
+        op_handle = exec_result.operationHandle
+
+        # Prepare and execute fetch results request
+        fetch_req = prepare_fetch_results(op_handle, :first, max_rows)
+        fetch_results = client.FetchResults(fetch_req)
+        raise_error_if_failed!(fetch_results)
+
+        # Get data rows and format the result
+        rows = fetch_results.results.rows
+        the_schema = TCLISchemaDefinition.new(get_schema_for( op_handle ), rows.first)
+        TCLIResultSet.new(rows, the_schema)
+      end
+    end
+
+    # Performs a query on the server, fetches the results in batches of *batch_size* rows
+    # and yields the result batches to a given block as arrays of rows.
+    def fetch_in_batch(query, batch_size = 1000, &block)
+      raise "No block given for the batch fetch request!" unless block_given?
+      safe do
+        # Execute the query and check the result
+        exec_result = execute_unsafe(query)
+        raise_error_if_failed!(exec_result)
+
+        # Get search operation handle to fetch the results
+        op_handle = exec_result.operationHandle
+
+        # Prepare fetch results request
+        fetch_req = prepare_fetch_results(op_handle, :next, batch_size)
+
+        # Now let's iterate over the results
+        loop do
+          # Fetch next batch and raise an exception if it failed
+          fetch_results = client.FetchResults(fetch_req)
+          raise_error_if_failed!(fetch_results)
+
+          # Get data rows from the result
+          rows = fetch_results.results.rows
+          break if rows.empty?
+
+          # Prepare schema definition for the row
+          schema_for_req ||= get_schema_for(op_handle)
+          the_schema ||= TCLISchemaDefinition.new(schema_for_req, rows.first)
+
+          # Format the results and yield them to the given block
+          yield TCLIResultSet.new(rows, the_schema)
+        end
+      end
+    end
+
+    def create_table(schema)
+      execute(schema.create_table_statement)
+    end
+
+    def drop_table(name)
+      name = name.name if name.is_a?(TableSchema)
+      execute("DROP TABLE `#{name}`")
+    end
+
+    def replace_columns(schema)
+      execute(schema.replace_columns_statement)
+    end
+
+    def add_columns(schema)
+      execute(schema.add_columns_statement)
+    end
+
+    def method_missing(meth, *args)
+      client.send(meth, *args)
+    end
+
+    private
+
+    def execute_safe(query)
+      safe { execute_unsafe(query) }
+    end
+
+    def execute_unsafe(query)
+      @logger.info("Executing Hive Query: #{query}")
+      req = prepare_execute_statement(query)
+      client.ExecuteStatement(req)
+    end
+
+    def safe
+      ret = nil
+      @mutex.synchronize { ret = yield }
+      ret
+    end
+
+    def prepare_open_session(client_protocol)
+      req = ::Hive2::Thrift::TOpenSessionReq.new( @options[:sasl_params].nil? ? [] : @options[:sasl_params] )
+      req.client_protocol = client_protocol
+      req
+    end
+
+    def prepare_close_session
+      ::Hive2::Thrift::TCloseSessionReq.new( sessionHandle: self.session )
+    end
+
+    def prepare_execute_statement(query)
+      ::Hive2::Thrift::TExecuteStatementReq.new( sessionHandle: self.session, statement: query.to_s, confOverlay: {} )
+    end
+
+    def prepare_fetch_results(handle, orientation=:first, rows=100)
+      orientation_value = "FETCH_#{orientation.to_s.upcase}"
+      valid_orientations = ::Hive2::Thrift::TFetchOrientation::VALUE_MAP.values
+      unless valid_orientations.include?(orientation_value)
+        raise ArgumentError, "Invalid orientation: #{orientation.inspect}"
+      end
+      orientation_const = eval("::Hive2::Thrift::TFetchOrientation::#{orientation_value}")
+      ::Hive2::Thrift::TFetchResultsReq.new(
+        operationHandle: handle,
+        orientation: orientation_const,
+        maxRows: rows
+      )
+    end
+
+    def get_schema_for(handle)
+      req = ::Hive2::Thrift::TGetResultSetMetadataReq.new( operationHandle: handle )
+      metadata = client.GetResultSetMetadata( req )
+      metadata.schema
+    end
+
+    # Raises an exception if given operation result is a failure
+    def raise_error_if_failed!(result)
+      return if result.status.statusCode == 0
+      error_message = result.status.errorMessage || 'Execution failed!'
+      raise error_message
+    end
+  end
+end

data/lib/rbhive/t_c_l_i_result_set.rb

@@ -0,0 +1,3 @@
+module RBHive
+  class TCLIResultSet < ResultSet; end
+end

data/lib/rbhive/t_c_l_i_schema_definition.rb

@@ -0,0 +1,87 @@
+require 'json'
+
+module RBHive
+  class TCLISchemaDefinition
+    attr_reader :schema
+
+    TYPES = {
+      :boolean  => :to_s,
+      :string   => :to_s,
+      :bigint   => :to_i,
+      :float    => :to_f,
+      :double   => :to_f,
+      :int      => :to_i,
+      :bigint   => :to_i,
+      :smallint => :to_i,
+      :tinyint  => :to_i,
+    }
+
+    def initialize(schema, example_row)
+      @schema = schema
+      @example_row = example_row ? example_row.colVals : []
+    end
+
+    def column_names
+      @column_names ||= begin
+        schema_names = @schema.columns.map {|c| c.columnName }
+
+        # In rare cases Hive can return two identical column names
+        # consider SELECT a.foo, b.foo...
+        # in this case you get two columns called foo with no disambiguation.
+        # as a (far from ideal) solution we detect this edge case and rename them
+        # a.foo => foo1, b.foo => foo2
+        # otherwise we will trample one of the columns during Hash mapping.
+        s = Hash.new(0)
+        schema_names.map! { |c| s[c] += 1; s[c] > 1 ? "#{c}---|---#{s[c]}" : c }
+        schema_names.map! { |c| s[c] > 1 ? "#{c}---|---1" : c }
+        schema_names.map! { |c| c.gsub('---|---', '_').to_sym }
+
+        # Lets fix the fact that Hive doesn't return schema data for partitions on SELECT * queries
+        # For now we will call them :_p1, :_p2, etc. to avoid collisions.
+        offset = 0
+        while schema_names.length < @example_row.length
+          schema_names.push(:"_p#{offset+=1}")
+        end
+        schema_names
+      end
+    end
+
+    def column_type_map
+      @column_type_map ||= column_names.inject({}) do |hsh, c| 
+        definition = @schema.columns.find {|s| s.columnName.to_sym == c }
+        # If the column isn't in the schema (eg partitions in SELECT * queries) assume they are strings
+        type = TYPE_NAMES[definition.typeDesc.types.first.primitiveEntry.type].downcase rescue nil
+        hsh[c] = definition && type ? type.to_sym : :string
+        hsh
+      end
+    end
+
+    def coerce_row(row)
+      column_names.zip(row.colVals.map(&:get_value).map(&:value)).inject({}) do |hsh, (column_name, value)|
+        hsh[column_name] = coerce_column(column_name, value)
+        hsh
+      end
+    end
+
+    def coerce_column(column_name, value)
+      type = column_type_map[column_name]
+      return 1.0/0.0 if(type != :string && value == "Infinity")
+      return 0.0/0.0 if(type != :string && value == "NaN")
+      return nil if value.nil? || value == 'NULL' || value == 'null'
+      return coerce_complex_value(value) if type.to_s =~ /^array/
+      conversion_method = TYPES[type]
+      conversion_method ? value.send(conversion_method) : value
+    end
+
+    def coerce_row_to_array(row)
+      column_names.map { |n| row[n] }
+    end
+
+    def coerce_complex_value(value)
+      return nil if value.nil?
+      return nil if value.length == 0
+      return nil if value == 'null'
+      JSON.parse(value)
+    end
+  end
+end

data/lib/rbhive/version.rb

@@ -0,0 +1,3 @@
+module RBHive
+  VERSION = '0.5.0'
+end

data/lib/rbhive.rb

@@ -2,4 +2,7 @@ require File.join(File.dirname(__FILE__), 'rbhive', 'connection')
 require File.join(File.dirname(__FILE__), 'rbhive', 'table_schema')
 require File.join(File.dirname(__FILE__), 'rbhive', 'result_set')
 require File.join(File.dirname(__FILE__), 'rbhive', 'explain_result')
-require File.join(File.dirname(__FILE__), 'rbhive', 'schema_definition')
+require File.join(File.dirname(__FILE__), 'rbhive', 'schema_definition')
+require File.join(File.dirname(__FILE__), *%w[rbhive t_c_l_i_result_set])
+require File.join(File.dirname(__FILE__), *%w[rbhive t_c_l_i_schema_definition])
+require File.join(File.dirname(__FILE__), *%w[rbhive t_c_l_i_connection])

data/lib/thrift/facebook_service.rb

@@ -1,12 +1,11 @@
 #
-# Autogenerated by Thrift
+# Autogenerated by Thrift Compiler (0.9.0)
 #
 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 #
 
 require 'thrift'
-require File.join(File.dirname(__FILE__), *%w[fb303_types])
-
+require_relative 'fb303_types'
 
 module FacebookService
   class Client
@@ -370,13 +369,13 @@ module FacebookService
     SUCCESS = 0
 
     FIELDS = {
-      SUCCESS => {:type => ::Thrift::Types::I32, :name => 'success', :enum_class => Fb_status}
+      SUCCESS => {:type => ::Thrift::Types::I32, :name => 'success', :enum_class => ::Fb_status}
     }
 
     def struct_fields; FIELDS; end
 
     def validate
-      unless @success.nil? || Fb_status::VALID_VALUES.include?(@success)
+      unless @success.nil? || ::Fb_status::VALID_VALUES.include?(@success)
         raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field success!')
       end
     end