riak-client 2.1.0 → 2.2.0.pre1

data/lib/riak/robject.rb

@@ -96,6 +96,13 @@ module Riak
     # @see Bucket#get
     def initialize(bucket, key=nil)
       @bucket, @key = bucket, key
+
+      # fix a require-loop
+      require 'riak/bucket_typed/bucket'
+
+      if @bucket.is_a? BucketTyped::Bucket
+        @type = @bucket.type.name
+      end
       @siblings = [ RContent.new(self) ]
       yield self if block_given?
     end
@@ -128,7 +135,7 @@ module Riak
       raise Conflict, self if conflict?
       raise ArgumentError, t("content_type_undefined") unless content_type.present?
       raise ArgumentError, t("zero_length_key") if key == ''
-      @bucket.client.store_object(self, options)
+      @bucket.client.store_object(self, default(options))
       self
     end
 
@@ -143,7 +150,7 @@ module Riak
       force = options.delete(:force)
       return self unless @key && (@vclock || force)
       self.etag = self.last_modified = nil if force
-      bucket.client.reload_object(self, options)
+      bucket.client.reload_object(self, default(options))
     end
 
     alias :fetch :reload
@@ -154,7 +161,7 @@ module Riak
     def delete(options={})
       return if key.blank?
       options[:vclock] = vclock if vclock
-      @bucket.delete(key, options)
+      @bucket.delete(key, default(options))
       freeze
     end
 
@@ -189,5 +196,14 @@ module Riak
     def to_link(tag)
       Link.new(@bucket.name, @key, tag)
     end
+
+    private
+
+    def default(options)
+      return options unless options.is_a? Hash
+      return options unless @type
+
+      {type: @type}.merge options
+    end
   end
 end

data/lib/riak/search/index.rb

@@ -0,0 +1,73 @@
+require 'riak/search'
+require 'riak/errors/search_error'
+
+module Riak::Search
+  # A {Riak::Search::Index} is how Solr finds documents in Riak Search 2. A
+  # bucket or bucket type property must be configured to use the index in order
+  # for new and updated documents to be indexed and searchable.
+  class Index
+    # @return [String] the name of the index
+    attr_reader :name
+
+    # Initializes an index 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 index
+    def initialize(client, name)
+      @client = client
+      @name = name
+    end
+
+    # @return [Boolean] does this index exist on Riak?
+    def exists?
+      !!index_data
+    end
+
+    # @return [Integer] N-value/replication parameter of this index
+    def n_val
+      index_data[:n_val]
+    end
+
+    # @return [String] schema name of this index
+    def schema
+      index_data[:schema]
+    end
+
+    # Attempt to create this index
+    #
+    # @raise [Riak::SearchError::IndexExistsError] if an index with the given 
+    #   name already exists
+    def create!(schema = nil, n_val = nil)
+      raise Riak::SearchError::IndexExistsError.new name if exists?
+
+      @client.backend do |b|
+        b.create_search_index name, schema, n_val
+      end
+
+      @index_data = nil
+
+      true
+    end
+
+    private
+    def index_data
+      return @index_data if defined?(@index_data) && @index_data
+
+      id = nil
+
+      begin
+        id = @client.backend do |b|
+          b.get_search_index name
+        end.index
+      rescue Riak::ProtobuffsFailedRequest => e
+        return nil if e.not_found?
+        raise e
+      end
+
+      id = id.first if id.is_a? Array
+
+      return @index_data = id
+    end
+  end
+end

data/lib/riak/search/query.rb

@@ -0,0 +1,133 @@
+require 'riak/search'
+
+module Riak::Search
+  # A {Riak::Search::Query} wraps a Solr query for Riak Search 2.
+  class Query
+    
+    # @!attribute rows
+    # @return [Numeric] the number of rows to return from the query
+    attr_accessor :rows
+
+    # @!attribute start
+    # @return [Numeric] the offset into the total result set to get results for
+    attr_accessor :start
+
+    # @!attribute sort
+    # @return [String] how Solr should sort the result set
+    attr_accessor :sort
+
+    # @!attribute filter
+    # @return [String] have Solr filter the results prior to returning them
+    attr_accessor :filter
+
+    # @!attribute df
+    # @return [Array<String>] default fields for Solr to search
+    attr_accessor :df
+
+    # @!attribute op
+    # @return [String] Solr search operator
+    attr_accessor :op
+
+    # @!attribute fl
+    # @return [Array<String>] fields for Solr to return
+    attr_accessor :fl
+
+    # @!attribute [r] term
+    # @return [String] the term to query
+    attr_reader :term
+
+    # Initializes a query object.
+    #
+    # @param [Riak::Client] client the client connected to the Riak cluster
+    # @param [String,Riak::Search::Index] index the index to query, either a
+    #   {Riak::Search::Index} instance or a {String}
+    # @param [String] term the query term
+    # @param [Hash] options a hash of options to quickly set attributes
+    def initialize(client, index, term, options={  })
+      @client = client
+      validate_index index
+      @term = term
+      @options = options.symbolize_keys
+
+      set_defaults
+      consume_options
+    end
+
+    # Get results from the query. Performs the query when called the first time.
+    #
+    # @return [Riak::Search::ResultCollection] collection of results
+    def results
+      return @results if defined? @results
+
+      @results = ResultCollection.new @client, raw_results
+    end
+
+    private
+    
+    def index_name
+      return @index if @index.is_a? String
+      return @index.name
+    end
+
+    def validate_index(index)
+      if index.is_a? String
+        index = Riak::Search::Index.new @client, index
+      end
+
+      unless index.is_a? Riak::Search::Index
+        raise Riak::SearchError::IndexArgumentError.new index
+      end
+
+      unless index.exists?
+        raise Riak::SearchError::IndexNonExistError.new index.name
+      end
+
+      @index = index
+    end
+
+    def set_defaults
+      @rows = nil
+      @start = nil
+
+      @sort = nil
+      @filter = nil
+
+      @df = %w{text}
+      @op = nil
+      @fl = %w{_yz_rb _yz_rk _yz_rt score}
+      
+      @presort = nil
+    end
+
+    def consume_options
+      @rows = @options[:rows] if @options[:rows]
+      @start = @options[:start] if @options[:start]
+      
+      @sort = @options[:sort] if @options[:sort]
+      @filter = @options[:filter] if @options[:filter]
+
+      @df = @options[:df] if @options[:df]
+      @op = @options[:op] if @options[:op]
+      @fl = @options[:fl] if @options[:fl]
+    end
+
+    def prepare_options
+      configured_options = { 
+        rows: @rows,
+        start: @start,
+        sort: @sort,
+        filter: @filter,
+        df: @df.join(' '),
+        op: @op,
+        fl: @fl
+      }
+      @options.merge configured_options
+    end
+
+    def raw_results
+      @client.backend do |be|
+        be.search index_name, @term, prepare_options
+      end
+    end
+  end
+end

data/lib/riak/search/result_collection.rb

@@ -0,0 +1,91 @@
+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.robject
+    end
+
+    # @return [Riak::RObject,NilClass] the first found object, or nil if the
+    #   index is out of range
+    def first
+      self[0]
+    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,59 @@
+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
+
+    # 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
+      @robject ||= bucket.get key
+    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)
+      raise 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
+      
+      return @schema_data = sd
+    end
+  end
+end
+

data/lib/riak/search.rb

@@ -0,0 +1,10 @@
+module Riak
+  module Search
+  end
+end
+
+require 'riak/search/index'
+require 'riak/search/query'
+require 'riak/search/result_collection'
+require 'riak/search/result_document'
+require 'riak/search/schema'

data/lib/riak/secondary_index.rb

@@ -1,4 +1,6 @@
 require 'riak/index_collection'
+require 'riak/bucket_typed/bucket'
+
 module Riak
   class SecondaryIndex
     include Util::Translation
@@ -16,6 +18,10 @@ module Riak
       @query = query
       @options = options
 
+      if @bucket.is_a? Riak::BucketTyped::Bucket
+        @options = { type: @bucket.type.name }.merge @options
+      end
+
       validate_options
     end
 

data/lib/riak/version.rb

@@ -1,3 +1,3 @@
 module Riak
-  VERSION = "2.1.0"
+  VERSION = "2.2.0.pre1"
 end

data/spec/fixtures/yz_schema_template.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<schema name="SCHEMA_NAME" version="1.5">
+<fields>
+   <field name="_yz_id" type="_yz_str" indexed="true" stored="true" multiValued="false" required="true" />
+   <field name="_yz_ed" type="_yz_str" indexed="true" stored="true" multiValued="false"/>
+   <field name="_yz_pn" type="_yz_str" indexed="true" stored="true" multiValued="false"/>
+   <field name="_yz_fpn" type="_yz_str" indexed="true" stored="true" multiValued="false"/>
+   <field name="_yz_vtag" type="_yz_str" indexed="true" stored="true" multiValued="false"/>
+   <field name="_yz_rk" type="_yz_str" indexed="true" stored="true" multiValued="false"/>
+   <field name="_yz_rb" type="_yz_str" indexed="true" stored="true" multiValued="false"/>
+   <field name="_yz_rt" type="_yz_str" indexed="true" stored="true" multiValued="false"/>
+   <field name="_yz_err" type="_yz_str" indexed="true" stored="true" multiValued="false"/>
+</fields>
+<uniqueKey>_yz_id</uniqueKey>
+<types>
+    <fieldType name="_yz_str" class="solr.StrField" sortMissingLast="true" />
+</types>
+</schema>