riak-client-noenc 1.0.0

data/lib/riak/search/result_collection.rb

@@ -0,0 +1,144 @@
+require 'riak/search'
+
+module Riak::Search
+
+  # A collection of Riak Search 2 ("Yokozuna") results. Provides direct access
+  # to the {Riak::RObject} instances found, and access through the #docs method
+  # to the results as returned by Solr.
+  class ResultCollection
+    # @return [Riak::Client]
+    attr_reader :client
+
+    # @return [Hash] the de-serialzed hash returned from Solr
+    attr_reader :raw
+
+    # @return [Numeric] the maximum score found by Solr
+    attr_reader :max_score
+
+    # @return [Integer] the number of documents in this collection
+    attr_reader :length
+
+    # @return [Integer] the total number of documents matched, including ones
+    #   not returned due to row-limiting
+    attr_reader :num_found
+
+    # Initialize a {ResultCollection} with the client queried and the raw
+    # JSON returned from the search API.
+    #
+    # This is automatically called by {Riak::Search::Query}#results
+    #
+    # @api private
+    def initialize(client, raw_results)
+      @client = client
+      @raw = raw_results
+      @max_score = raw['max_score']
+      @num_found = raw['num_found']
+      @length = raw['docs'].length
+    end
+
+    # Access the individual documents from the search results. The document
+    # metadata are each wrapped in a {Riak::Search::ResultDocument}.
+    #
+    # @return [Array<Riak::Search::ResultDocument>] individual documents
+    def docs
+      @docs ||= raw['docs'].map do |result|
+        ResultDocument.new client, result
+      end
+    end
+
+    # @return [Boolean] does this collection contain any documents?
+    def empty?
+      length == 0
+    end
+
+    # @param [Integer] index the index of the [Riak::RObject] to load and return
+    # @return [Riak::RObject,NilClass] the found object, or nil if the index
+    #   is out of range
+    def [](index)
+      doc = docs[index]
+      return nil if doc.nil?
+
+      doc.object
+    end
+
+    # @return [Riak::RObject,NilClass] the first found object, or nil if the
+    #   index is out of range
+    def first
+      self[0]
+    end
+
+    # Materializes and returns an array of objects from search results.
+    # You'll probably need to type inspect its members.
+    #
+    # @return [Array] materialized objects
+    def objects
+      @objects ||= docs.map do |doc|
+        next doc.crdt if doc.crdt?
+        doc.robject
+      end
+    end
+
+    # Materializes [Riak::RObject]s from any key-value results. Refuses to
+    # return RObjects for any CRDT results.
+    #
+    # @return [Array<Riak::RObject>] key-value objects
+    def robjects
+      @robjects ||= docs.reject(&:crdt?).map(&:robject)
+    end
+
+    # Materializes [Riak::Crdt::Base] subclasses from any CRDT results.
+    #
+    # @return [Array<Riak::Crdt::Base>] CRDT objects
+    def crdts
+      @crdts ||= docs.select(&:crdt?).map(&:crdt)
+    end
+
+    # Materializes [Riak::Crdt::Counter] results.
+    #
+    # @return [Array<Riak::Crdt::Counter] counter objects
+    def counters
+      @counters ||= docs.
+                  select{ |d| d.type_class == Riak::Crdt::Counter }.
+                  map(&:counter)
+    end
+
+    # Materializes [Riak::Crdt::Map] results.
+    #
+    # @return [Array<Riak::Crdt::Map] map objects
+    def maps
+      @maps ||= docs.
+              select{ |d| d.type_class == Riak::Crdt::Map }.
+              map(&:map)
+    end
+
+    # Materializes [Riak::Crdt::Set] results.
+    #
+    # @return [Array<Riak::Crdt::Set>]
+    def sets
+      @sets ||= docs.
+              select{ |d| d.type_class == Riak::Crdt::Set }.
+              map(&:set)
+    end
+
+    # {Enumerable}-compatible iterator method. If a block is given, yields with
+    # each {Riak::RObject} in the collection. If no block is given, returns an
+    # {Enumerator} over each {Riak::RObject in the collection.
+    # @yieldparam robject [Riak::RObject]
+    # @return [Enumerator<Riak::RObject>]
+    def each_robject
+      enum = docs.each_with_index
+
+      if block_given?
+        enum.each do |doc, idx|
+          yield self[idx]
+        end
+      else
+        Enumerator.new do |yielder|
+          enum.each do |doc, idx|
+            yielder << self[idx]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/riak/search/result_document.rb

@@ -0,0 +1,129 @@
+require 'riak/errors/crdt_error'
+
+module Riak::Search
+
+  # A single document from a Riak Search 2 response. Materializes the document
+  # fields into {Riak::BucketType}, {Riak::Bucket}, and {Riak::RObject}
+  # instances on demand.
+  class ResultDocument
+    # @return [Riak::Client]
+    attr_reader :client
+
+    # @return [Hash] the de-serialized hash returned from Solr
+    attr_reader :raw
+
+    # Iniitalize a {ResultDocument} with the client queried and the relevant
+    # part of the JSON returned from the search API.
+    #
+    # This is automatically called by {Riak::Search::ResultCollection}#docs
+    #
+    # @api private
+    def initialize(client, raw)
+      @client = client
+      @raw = raw
+    end
+
+    # @return [String] the key of the result
+    def key
+      @key ||= raw['_yz_rk']
+    end
+
+    # @return [Riak::BucketType] the bucket type containing the result
+    def bucket_type
+      @bucket_type ||= client.bucket_type raw['_yz_rt']
+    end
+
+    # @return [Riak::Bucket] the bucket containing the result
+    def bucket
+      @bucket ||= bucket_type.bucket raw['_yz_rb']
+    end
+
+    # @return [Numeric] the score of the match
+    def score
+      @score ||= Float(raw['score'])
+    end
+
+    # Determining if the object is a CRDT or regular K-V object requires
+    # figuring out what data type the bucket type contains. If the bucket type
+    # has no data type, treat it as a regular K-V object.
+    #
+    # @return [Class] the class of the object referred to by the search result
+    def type_class
+      bucket_type.data_type_class || Riak::RObject
+    end
+
+    # @return [Boolean] if the object is a CRDT
+    def crdt?
+      type_class != Riak::RObject
+    end
+
+    # @raise [Riak::CrdtError::NotACrdt] if the result is not a CRDT
+    # @return [Riak::Crdt::Base] the materialized CRDT
+    def crdt
+      fail Riak::CrdtError::NotACrdt unless crdt?
+
+      type_class.new bucket, key, bucket_type
+    end
+
+    # If the result document describes a counter, return it.
+    #
+    # @return [Riak::Crdt::Counter]
+    # @raise [Riak::CrdtError::NotACrdt] if the result is not a CRDT
+    # @raise [Riak::CrdtError::UnexpectedDataType] if the CRDT is not a counter
+    def counter
+      return crdt if check_type_class Riak::Crdt::Counter
+    end
+
+    # If the result document describes a map, return it.
+    #
+    # @return [Riak::Crdt::Map]
+    # @raise [Riak::CrdtError::NotACrdt] if the result is not a CRDT
+    # @raise [Riak::CrdtError::UnexpectedDataType] if the CRDT is not a map
+    def map
+      return crdt if check_type_class Riak::Crdt::Map
+    end
+
+    # If the result document describes a set, return it.
+    #
+    # @return [Riak::Crdt::Set]
+    # @raise [Riak::CrdtError::NotACrdt] if the result is not a CRDT
+    # @raise [Riak::CrdtError::UnexpectedDataType] if the CRDT is not a set
+    def set
+      return crdt if check_type_class Riak::Crdt::Set
+    end
+
+    # Provides access to other parts of the result document without
+    # materializing them. Useful when querying non-default fields.
+    #
+    # @return [String,Numeric] other search result document field
+    def [](field_name)
+      raw[field_name.to_s]
+    end
+
+    # Loads the {Riak::RObject} referred to by the result document.
+    #
+    # @return [Riak::RObject]
+    def robject
+      if crdt?
+        fail Riak::SearchError::UnexpectedResultError.
+              new(Riak::RObject, type_class)
+      end
+
+      @robject ||= bucket.get key
+    end
+
+    # Returns an appropriate object, be it CRDT or K-V.
+    def object
+      return crdt if crdt?
+      robject
+    end
+
+    private
+
+    def check_type_class(klass)
+      return true if type_class == klass
+      fail Riak::CrdtError::NotACrdt if type_class == Riak::RObject
+      fail Riak::CrdtError::UnexpectedDataType.new(klass, type_class)
+    end
+  end
+end

data/lib/riak/search/schema.rb

@@ -0,0 +1,65 @@
+require 'riak/search'
+require 'riak/errors/search_error'
+
+module Riak::Search
+  # A schema is a Riak Search 2 concept that describes how to index documents.
+  # They're implemented as a standard Solr XML schema.
+  class Schema
+    # @return [String] the name of the schema
+    attr_reader :name
+
+    # Initializes a schema object, that may or may not exist.
+    #
+    # @param [Riak::Client] client the client connected to the Riak cluster
+    #   you wish to operate on
+    # @param [String] name the name of the schema
+    def initialize(client, name)
+      @client = client
+      @name = name
+    end
+
+    # @return [Boolean] does this schema exist on Riak?
+    def exists?
+      !!schema_data
+    end
+
+    # @return [String] the XML content of this schema
+    def content
+      schema_data.content
+    end
+
+    # @param [String] content the XML content of this schema
+    # @raise [Riak::SearchError::SchemaExistsError] if a schema with the given
+    #   name already exists
+    def create!(content)
+      fail Riak::SearchError::SchemaExistsError.new name if exists?
+
+      @client.backend do |b|
+        b.create_search_schema name, content
+      end
+
+      @schema_data = nil
+
+      true
+    end
+
+    private
+
+    def schema_data
+      return @schema_data if defined?(@schema_data) && @schema_data
+
+      sd = nil
+
+      begin
+        sd = @client.backend do |b|
+          b.get_search_schema name
+        end
+      rescue Riak::ProtobuffsFailedRequest => e
+        return nil if e.not_found?
+        raise e
+      end
+
+      @schema_data = sd
+    end
+  end
+end

data/lib/riak/secondary_index.rb

@@ -0,0 +1,81 @@
+require 'riak/index_collection'
+require 'riak/bucket_typed/bucket'
+
+module Riak
+  # {Riak::SecondaryIndex} provides an object-oriented interface to secondary
+  # index ("2i") functionality in Riak, available on the `memory` and `leveldb`
+  # backends.
+  class SecondaryIndex
+    include Util::Translation
+    include Client::FeatureDetection
+
+    # Create a Riak Secondary Index operation
+    # @param [Bucket] bucket the {Riak::Bucket} we'll query against
+    # @param [String] index the index name
+    # @param [String,Integer,Range<String,Integer>] query
+    #   a single value or range of values to query for
+    def initialize(bucket, index, query, options = {})
+      @bucket = bucket
+      @client = @bucket.client
+      @index = index
+      @query = query
+      @options = options
+
+      if @bucket.is_a? Riak::BucketTyped::Bucket
+        @options = { type: @bucket.type.name }.merge @options
+      end
+
+      validate_options
+    end
+
+    def get_server_version
+      @client.backend { |b| b.send :get_server_version }
+    end
+
+    # Get the array of matched keys
+    def keys(&block)
+      @collection ||=
+        @client.backend do |b|
+          b.get_index @bucket, @index, @query, @options, &block
+        end
+    end
+
+    # Get the array of values
+    def values
+      @values ||= @bucket.get_many(keys).values
+    end
+
+    # Get a new SecondaryIndex fetch for the next page
+    def next_page
+      fail t('index.no_next_page') unless keys.continuation
+
+      self.class.new(@bucket,
+                     @index,
+                     @query,
+                     @options.merge(continuation: keys.continuation))
+    end
+
+    # Determine whether a SecondaryIndex fetch has a next page available
+    def has_next_page?
+      !!keys.continuation
+    end
+
+    private
+
+    def validate_options
+      if paginated? && !index_pagination?
+        fail t('index.pagination_not_available')
+      end
+
+      if @options[:return_terms] && !index_return_terms?
+        fail t('index.return_terms_not_available')
+      end
+
+      fail t('index.include_terms_is_wrong') if @options[:include_terms]
+    end
+
+    def paginated?
+      @options[:continuation] || @options[:max_results]
+    end
+  end
+end

data/lib/riak/serializers.rb

@@ -0,0 +1,73 @@
+module Riak
+  module Serializers
+    include Util::Translation
+    extend self
+
+    def [](content_type)
+      serializers[content_type]
+    end
+
+    def []=(content_type, serializer)
+      serializers[content_type] = serializer
+    end
+
+    def serialize(content_type, content)
+      serializer_for(content_type).dump(content)
+    end
+
+    def deserialize(content_type, content)
+      serializer_for(content_type).load(content)
+    end
+
+    private
+
+    def serializer_for(content_type)
+      serializers.fetch(content_type[/^[^;\s]+/]) do
+        raise IOError.new(t('serializer_not_implemented', :content_type => content_type.inspect))
+      end
+    end
+
+    def serializers
+      @serializers ||= {}
+    end
+
+    module TextPlain
+      extend self
+
+      def dump(object)
+        object.to_s
+      end
+
+      def load(string)
+        string
+      end
+    end
+
+    module ApplicationJSON
+      extend self
+
+      def dump(object)
+        object.to_json(Riak.json_options)
+      end
+
+      def load(string)
+        Riak::JSON.parse(string)
+      end
+    end
+
+    Serializers['text/plain'] = TextPlain
+    Serializers['application/json'] = ApplicationJSON
+    Serializers['application/x-ruby-marshal'] = ::Marshal
+
+    YAML_MIME_TYPES = %w[
+      text/yaml
+      text/x-yaml
+      application/yaml
+      application/x-yaml
+    ]
+
+    YAML_MIME_TYPES.each do |mime_type|
+      Serializers[mime_type] = ::YAML
+    end
+  end
+end