libcouchbase-mapo 1.4.1

data/lib/libcouchbase/query_view.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+module Libcouchbase
+    class QueryView
+        # Set this flag to execute an actual get with each response
+        F_INCLUDE_DOCS = 1 << 16
+
+        # Set this flag to only parse the top level row, and not its constituent
+        # parts. Note this is incompatible with `F_INCLUDE_DOCS`
+        F_NOROWPARSE = 1 << 17
+
+        # This view is spatial. Modifies how the final view path will be constructed
+        F_SPATIAL = 1 << 18
+
+
+        def initialize(connection, reactor, design, view, **opts)
+            @connection = connection
+            @reactor = reactor
+
+            @design = design
+            @view = view
+            @options = opts
+
+            @include_docs = true
+            @is_spatial = false
+        end
+
+        attr_reader :options, :design, :view, :connection
+        attr_accessor :include_docs, :is_spatial
+
+        def get_count(metadata)
+            metadata[:total_rows]
+        end
+
+        def perform(**options, &blk)
+            raise 'not connected' unless @connection.handle
+            raise 'query already in progress' if @cmd
+            raise 'callback required' unless block_given?
+
+            options = @options.merge(options)
+            # We should never exceed the users results limit
+            orig_limit = @options[:limit]
+            limit = options[:limit]
+            if orig_limit && limit
+                options[:limit] = orig_limit if limit > orig_limit
+            end
+
+            pairs = []
+            options.each { |key, val|
+                if key.to_s.include?('key') && val[0] != "["
+                    pairs << "#{key}=#{[val].to_json[1...-1]}"
+                else
+                    pairs << "#{key}=#{val}"
+                end
+            }
+            opts = pairs.join('&')
+
+            @reactor.schedule {
+                @error = nil
+                @callback = blk
+
+                @cmd = Ext::CMDVIEWQUERY.new
+                Ext.view_query_initcmd(@cmd, @design.to_s, @view.to_s, opts, @connection.get_callback(:viewquery_callback))
+                @cmd[:cmdflags] |= F_INCLUDE_DOCS if include_docs
+                @cmd[:cmdflags] |= F_SPATIAL if is_spatial
+
+                pointer = @cmd.to_ptr
+
+                @connection.requests[pointer.address] = self
+                err = Ext.view_query(@connection.handle, pointer, @cmd)
+                if err != :success
+                    error(Error.lookup(err).new('view request not scheduled'))
+                end
+            }
+        end
+
+        def received(row)
+            return if @error
+
+            key = row[:key].read_string(row[:nkey])
+            cas = row[:cas]
+            emitted = row[:value].read_string(row[:nvalue]) if row[:nvalue] > 0
+            geometry = row[:geometry].read_string(row[:ngeometry]) if row[:ngeometry] > 0
+            doc_id = row[:docid].read_string(row[:ndocid]) if row[:ndocid] > 0
+
+            meta = {
+                emitted: emitted,
+                geometry: geometry,
+                key: key
+            }
+
+            resp = Response.new(:viewquery_callback, doc_id, cas)
+            resp.metadata = meta
+
+            # check for included document here
+            if @include_docs && row[:docresp]
+                doc = row[:docresp]
+                raw_string = doc[:value].null? ? '' : doc[:value].read_string(doc[:nvalue])
+                resp.value = @connection.parse_document(raw_string)
+                meta[:flags] = doc[:itmflags]
+            end
+
+            @callback.call(false, resp)
+        rescue => e
+            @error = e
+        end
+
+        def received_final(metadata)
+            @connection.requests.delete(@cmd.to_ptr.address)
+            @cmd = nil
+
+            if @error
+                if @error == :cancelled
+                    @callback.call(:final, metadata)
+                else
+                    @callback.call(:error, @error)
+                end
+            else
+                @callback.call(:final, metadata)
+            end
+        end
+
+        def error(obj)
+            @error = obj
+            received_final(nil)
+        end
+
+        # We don't ever actually cancel a request here.
+        # There is an API however it indicates that @connection.handle might be destroyed
+        # Testing also indicated that @connection.handle was destroyed with seg faults
+        def cancel
+            @error = :cancelled
+        end
+    end
+end

data/lib/libcouchbase/results_fiber.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'set'
+
+module Libcouchbase
+    class ResultsFiber < Results
+        def initialize(query, &row_modifier)
+            @query_in_progress = false
+            @query_completed = false
+            @complete_result_set = false
+
+            @results = []
+            @fiber = nil
+
+            # We don't want to resume a fiber that is waiting 
+            # in a yield to user code as then the Fiber might
+            # end before we've finished processing and this is
+            # very much not desirable - dead fiber errors
+            @resume_results = true
+
+            # This could be a view or n1ql query
+            @query = query
+            @row_modifier = row_modifier
+        end
+
+        def options(**opts)
+            reset
+            @query.options.merge!(opts)
+        end
+
+
+        def stream(&blk)
+            if @complete_result_set
+                @results.each &blk
+            else
+                perform is_complete: false
+                @fiber = Fiber.current
+
+                begin
+                    remaining = @results.length > 0
+                    while !@query_completed || remaining do
+                        if remaining
+                            @resume_results = false
+                            yield @results.shift
+                        else
+                            @resume_results = true
+                            resume
+                        end
+
+                        remaining = @results.length > 0
+                    end
+                ensure
+                    # cancel is executed on break or error
+                    @resume_results = true
+                    cancel unless @query_completed
+                    @fiber = nil
+                end
+            end
+            self
+        end
+
+        def reset
+            raise 'query in progress' if @query_in_progress
+            @query_in_progress = false
+            @complete_result_set = false
+            @results.clear
+        end
+
+        def each(&blk)
+            # return a valid enumerator
+            return load_all.each unless block_given?
+
+            if @complete_result_set
+                @results.each &blk
+            else
+                perform
+                @fiber = Fiber.current
+
+                begin
+                    index = 0
+                    remaining = index < @results.length
+                    while !@query_completed || remaining do
+                        if remaining
+                            @resume_results = false
+                            yield @results[index]
+                            index += 1
+                        else
+                            @resume_results = true
+                            resume
+                        end
+
+                        remaining = index < @results.length
+                    end
+                ensure
+                    # cancel is executed on break or error
+                    @resume_results = true
+                    cancel unless @query_completed
+                    @fiber = nil
+                end
+            end
+            self
+        end
+
+        def first
+            if @complete_result_set || @results.length > 0
+                @results[0]
+            else
+                perform is_complete: false, limit: 1
+
+                @fiber = Fiber.current
+                begin
+                    while not @query_completed do
+                        resume
+                    end
+                ensure
+                    @fiber = nil
+                end
+
+                result = @results[0]
+                result
+            end
+        end
+
+        def count
+            first unless @metadata
+            @query.get_count @metadata
+        end
+
+        def take(num)
+            if @complete_result_set || @results.length >= num
+                @results[0...num]
+            else
+                perform is_complete: false, limit: num
+                @fiber = Fiber.current
+                result = []
+
+                begin
+                    index = 0
+                    remaining = index < @results.length && index < num
+                    while !@query_completed || remaining do
+                        if remaining
+                            result << @results[index]
+                            index += 1
+                        else
+                            resume
+                        end
+
+                        remaining = index < @results.length && index < num
+                    end
+                ensure
+                    @fiber = nil
+                end
+
+                result
+            end
+        end
+
+        def cancel
+            @cancelled = true
+            @query.cancel
+            resume
+        end
+
+
+        protected
+
+
+        def load_all
+            return @results if @complete_result_set
+            perform
+
+            @fiber = Fiber.current
+            begin
+                while not @query_completed do; resume; end
+            ensure
+                @fiber = nil
+            end
+            @results
+        end
+
+        def perform(is_complete: true, **opts)
+            return if @query_in_progress
+            @query_in_progress = true
+            @query_completed = false
+
+            # This flag is required to prevent race conditions
+            @cancelled = false
+            @results.clear
+
+            # This performs the query against the server
+            @query.perform(**opts) { |final, item|
+                on_thread(is_complete, final, item)
+            }
+        end
+
+        def process_response(is_complete, final, item)
+            # Has the operation completed?
+            if final
+                if final == :error
+                    @error = item unless @cancelled
+                    @complete_result_set = false
+                elsif @cancelled
+                    @metadata = item
+                    @complete_result_set = false
+                else
+                    @metadata = item
+                    @complete_result_set = is_complete
+                end
+                @query_completed = true
+                @query_in_progress = false
+
+            # Do we want to transform the results
+            elsif @row_modifier
+                begin
+                    @results << @row_modifier.call(item)
+                rescue Exception => e
+                    @error = e
+                end
+            else
+                @results << item
+            end
+
+            # Resume processing
+            @fiber.resume if @fiber && @resume_results && (!@cancelled || final)
+        end
+    end
+
+    class ResultsLibuv < ResultsFiber
+        def initialize(query, thread = reactor, &row_modifier)
+            super(query, &row_modifier)
+            @reactor = thread
+        end
+
+
+        protected
+
+
+        def on_thread(is_complete, final, item)
+            @reactor.schedule {
+                process_response(is_complete, final, item)
+            }
+        end
+
+        def resume
+            @reactor = reactor
+
+            # Prevent the reactor from stopping
+            @reactor.ref
+            Fiber.yield
+            @reactor.unref
+
+            # Clear and raise the error
+            if @error
+                err = @error
+                @error = nil
+                raise err unless @cancelled
+            end
+        end 
+    end
+
+    class ResultsEM < ResultsFiber
+        protected
+
+        def on_thread(is_complete, final, item)
+            EM.next_tick {
+                process_response(is_complete, final, item)
+            }
+        end
+
+        def resume
+            Fiber.yield
+
+            # Clear and raise the error
+            if @error
+                err = @error
+                @error = nil
+                raise err unless @cancelled
+            end
+        end
+    end
+end

data/lib/libcouchbase/results_native.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'set'
+
+module Libcouchbase
+    class ResultsNative < Results
+        def initialize(query, &row_modifier)
+            @query_in_progress = false
+            @query_completed = false
+            @complete_result_set = false
+
+            @results = []
+
+            # This could be a view or n1ql query
+            @query = query
+            @row_modifier = row_modifier
+        end
+
+        def options(**opts)
+            reset
+            @query.options.merge!(opts)
+        end
+
+        def stream(&blk)
+            if @complete_result_set
+                @results.each &blk
+            else
+                perform is_complete: false
+                begin
+                    remaining = @results.length > 0
+                    while !@query_completed || remaining do
+                        if remaining
+                            yield @results.shift
+                        else
+                            process_next_item
+                        end
+
+                        remaining = @results.length > 0
+                    end
+                ensure
+                    # cancel is executed on break or error
+                    cancel unless @query_completed
+                end
+
+                raise @error if @error
+            end
+            self
+        end
+
+        def reset
+            raise 'query in progress' if @query_in_progress
+            @query_in_progress = false
+            @complete_result_set = false
+            @results.clear
+        end
+
+        def each(&blk)
+            # return a valid enumerator
+            return load_all.each unless block_given?
+
+            if @complete_result_set
+                @results.each &blk
+            else
+                perform
+
+                begin
+                    index = 0
+                    remaining = index < @results.length
+                    while !@query_completed || remaining do
+                        if remaining
+                            yield @results[index]
+                            index += 1
+                        else
+                            process_next_item
+                        end
+
+                        remaining = index < @results.length
+                    end
+                ensure
+                    # cancel is executed on break or error
+                    cancel unless @query_completed
+                end
+
+                raise @error if @error
+            end
+            self
+        end
+
+        def first
+            if @complete_result_set || @results.length > 0
+                @results[0]
+            else
+                perform is_complete: false, limit: 1
+
+                while not @query_completed do
+                    process_next_item
+                end
+                raise @error if @error
+
+                result = @results[0]
+                result
+            end
+        end
+
+        def count
+            first unless @metadata
+            @query.get_count @metadata
+        end
+
+        def take(num)
+            if @complete_result_set || @results.length >= num
+                @results[0...num]
+            else
+                perform is_complete: false, limit: num
+
+                index = 0
+                result = []
+                remaining = index < @results.length && index < num
+                while !@query_completed || remaining do
+                    if remaining
+                        result << @results[index]
+                        index += 1
+                    else
+                        process_next_item
+                    end
+
+                    remaining = index < @results.length && index < num
+                end
+
+                raise @error if @error
+                result
+            end
+        end
+
+        def cancel
+            return if @cancelled
+            @cancelled = true
+            @query.cancel
+            process_next_item
+        end
+
+
+        protected
+
+
+        def process_next_item(can_loop = true)
+            return if @query_completed
+            final, item = @queue.pop
+            
+            if final
+                if final == :error
+                    @error = item unless @cancelled
+                    @complete_result_set = false
+                elsif @cancelled
+                    @metadata = item
+                    @complete_result_set = false
+                else
+                    @metadata = item
+                    @complete_result_set = @is_complete
+                end
+                @query_completed = true
+                @query_in_progress = false
+
+            elsif not @cancelled
+                # Do we want to transform the results
+                if @row_modifier
+                    begin
+                        @results << @row_modifier.call(item)
+                    rescue Exception => e
+                        @error = e
+                        @cancelled = true
+                        @query.cancel
+                    end
+                else
+                    @results << item
+                end
+            end
+
+            # This prevents the stack from blowing out
+            if can_loop
+                while !@queue.empty? || (@cancelled && !final) do
+                    final = process_next_item(false)
+                end
+            end
+
+            final
+        end
+
+        def load_all
+            return @results if @complete_result_set
+            perform
+
+            while not @query_completed do
+                process_next_item
+            end
+            raise @error if @error
+
+            @results
+        end
+
+        def perform(is_complete: true, **opts)
+            return if @query_in_progress
+            @query_in_progress = true
+            @query_completed = false
+            @is_complete = is_complete
+            @cancelled = false
+            @error = nil
+
+            # This flag is required so we don't 
+            @results.clear
+            @queue = Queue.new
+
+            # This performs the query against the server
+            # The callback will always be on another thread
+            @query.perform(**opts) { |final, item|
+                @queue.push([final, item])
+            }
+        end
+    end
+end