marklogic 0.0.1

data/lib/marklogic/consts.rb

@@ -0,0 +1,35 @@
+module MarkLogic
+
+  ROOT_COLLATION = "http://marklogic.com/collation/"
+  CODEPOINT_COLLATION = "http://marklogic.com/collation/codepoint"
+  DEFAULT_COLLATION = ROOT_COLLATION
+
+  GEO_WGS84 = "wgs84"
+  GEO_RAW = "raw"
+
+  POINT = "point"
+  LONG_LAT_POINT = "long-lat-point"
+
+  INT = "int"
+  UNSIGNED_INT = "unsignedInt"
+  LONG = "long"
+  UNSIGNED_LONG = "unsignedLong"
+  FLOAT = "float"
+  DOUBLE = "double"
+  DECIMAL = "decimal"
+  DATE_TIME = "dateTime"
+  TIME = "time"
+  DATE = "date"
+  G_YEAR_MONTH = "gYearMonth"
+  G_YEAR = "gYear"
+  G_MONTH = "gMonth"
+  G_DAY = "gDay"
+  YEAR_MONTH_DURATION = "yearMonthDuration"
+  DAY_TIME_DURATION = "dayTimeDuration"
+  STRING = "string"
+  ANY_URI = "anyURI"
+
+  IGNORE = "ignore"
+  REJECT = "reject"
+
+end

data/lib/marklogic/cursor.rb

@@ -0,0 +1,238 @@
+require 'pp'
+module MarkLogic
+  class Cursor
+    include Enumerable
+
+    attr_accessor :queries
+
+    DEFAULT_PAGE_LENGTH = 25
+
+    def initialize(collection, options = {})
+      @options = options || {}
+      @query = options.delete(:query)
+      @collection = collection
+      @transformer = options.delete(:transformer)
+      @fields = options.delete(:fields)
+      @fields = convert_fields_for_query(@fields) if @fields
+      @connection = @collection.database.connection
+      @limit = options.delete(:limit)
+      @cache = []
+      @query_run = false
+      @visited = 0
+    end
+
+    def count
+      col_name = collection.nil? ? "" : %Q{"#{collection.collection}"}
+      query_to_run = %Q{xdmp:estimate(cts:search(fn:collection(#{col_name}), #{query.to_xqy}, ("unfiltered")))}
+      response = @connection.run_query(query_to_run, "xquery")
+      raise Exception.new("Invalid response: #{response.code.to_i}: #{response.body}") if (response.code.to_i != 200)
+      response.body.to_i
+    end
+
+    def paged_results
+      refresh unless @query_run
+      @cache
+    end
+
+    def next
+      refresh unless @query_run
+
+      return nil if @visited == @limit
+
+      if @cache.length == 0
+        if page < total_pages
+          self.page = page + 1
+          refresh
+        end
+
+        if @cache.length == 0
+          return nil
+        end
+      end
+
+      @visited = @visited + 1
+      doc = @cache.shift
+
+      # TODO: Move this server side
+      if @fields
+        @fields << :_id unless @fields.include?(:_id) || @fields.include?('_id')
+        doc = @fields.each_with_object(doc.class.new) { |key, result| result[key] = doc[key.to_s] if doc.has_key?(key.to_s) }
+      end
+
+      if @transformer.nil?
+        doc
+      else
+        @transformer.call(doc) if doc
+      end
+    end
+    alias_method :next_document, :next
+
+    def convert_fields_for_query(fields)
+      case fields
+        when String, Symbol
+          [ fields ]
+        when Array
+          return nil if fields.length.zero?
+          fields
+        when Hash
+          return fields.keys
+      end
+    end
+
+    def each(&block)
+      while doc = self.next
+        yield doc
+      end
+    end
+
+    def to_a
+      super
+    end
+
+    def rewind!
+      self.page = 1
+      @query_run = false
+      @visited = 0
+    end
+
+    private
+
+    def start
+      if @options[:skip]
+        @options[:skip] + 1
+      else
+        (page - 1) * page_length + 1
+      end
+    end
+
+    def page
+      page = @options[:page] || 1
+      page.to_i
+    end
+
+    def page=(page)
+      @options[:page] = page.to_i
+    end
+
+    def page_length
+      @options[:per_page] || DEFAULT_PAGE_LENGTH
+    end
+
+    def total_pages
+      (count.to_f / page_length.to_f).ceil
+    end
+
+    def view
+      "none"
+    end
+
+    def format
+      @options[:format] || "json"
+    end
+
+    def collection
+      @collection
+    end
+
+    def return_results
+      @options[:return_results] || false
+    end
+
+    def return_metrics
+      @options[:return_metrics] || false
+    end
+
+    def return_qtext
+      @options[:return_qtext] || false
+    end
+
+    def return_query
+      @options[:return_query] || true
+    end
+
+    def debug
+      @options[:debug] || false
+    end
+
+    def has_sort?
+      @options.has_key?(:sort) or @options.has_key?(:order)
+    end
+
+    def query
+      @query || MarkLogic::Queries::AndQuery.new
+    end
+
+    def sort
+      return nil unless has_sort?
+
+      sorters = @options[:sort] || @options[:order]
+      sorters = [sorters] unless sorters.instance_of?(Array)
+
+      sorters.map do |sorter|
+        name = sorter[0].to_s
+        direction = (sorter[1] and (sorter[1] == -1)) ? "descending" : "ascending"
+
+
+        if @collection.database.has_range_index?(name)
+          index = @collection.database.range_index(name)
+          type = %Q{xs:#{index.scalar_type}}
+          collation = index.collation
+        else
+          raise MissingIndexError.new("Missing index on #{name}")
+        end
+        {
+          "direction" => direction || "ascending",
+          "type" => type,
+          "collation" => collation || "",
+          "json-property" => name
+        }
+      end
+    end
+
+    def sort_xqy
+      return %Q{cts:unordered()} unless has_sort?
+
+      sorters = @options[:sort] || @options[:order]
+      sorters = [sorters] unless sorters.instance_of?(Array)
+
+      sorters.map do |sorter|
+        name = sorter[0].to_s
+        direction = (sorter[1] and (sorter[1] == -1)) ? "descending" : "ascending"
+
+        unless @collection.database.has_range_index?(name)
+          raise MissingIndexError.new("Missing index on #{name}")
+        end
+
+        ref = @collection.database.range_index(name).to_ref
+
+        %Q{cts:index-order(#{ref}, "#{direction}")}
+      end.join(',')
+    end
+
+    def refresh
+      results = exec.body
+      if results.nil?
+        results = []
+      else
+        results = [results] unless results.instance_of?(Array)
+      end
+      @cache = results
+    end
+
+    def exec
+      query = to_xqy
+      response = @connection.run_query(query, "xquery")
+      raise Exception.new("Invalid response: #{response.code.to_i}: #{response.body}") if (response.code.to_i != 200)
+
+      @query_run = true
+      response
+    end
+
+    def to_xqy
+      start_index = start
+      end_index = start_index + page_length - 1
+      col_name = collection.nil? ? "" : %Q{"#{collection.collection}"}
+      %Q{(cts:search(fn:collection(#{col_name}), #{query.to_xqy}, ("unfiltered", "score-zero", #{sort_xqy})))[#{start_index} to #{end_index}]}
+    end
+  end
+end

data/lib/marklogic/database.rb

@@ -0,0 +1,205 @@
+require 'pp'
+
+module MarkLogic
+  class Database
+    include MarkLogic::Persistence
+
+    INDEX_KEYS = [
+      'range-element-index',
+      'element-word-lexicon',
+      'element-attribute-word-lexicon',
+      # 'path-namespace',
+      # 'field',
+      'range-path-index',
+      'range-field-index',
+      'geospatial-element-index',
+      'geospatial-element-child-index',
+      'geospatial-element-pair-index',
+      'geospatial-path-index'
+    ]
+
+    attr_accessor :database_name, :application
+    def initialize(database_name, conn = nil)
+      self.connection = conn
+
+      @database_name = database_name
+      @options = {
+        "database-name" => @database_name,
+        "collection-lexicon" => true
+      }
+
+      reset_indexes
+    end
+
+    def []=(key, value)
+      @options[key] = value
+    end
+
+    def [](key)
+      @options[key]
+    end
+
+    def has_key?(key)
+      @options.has_key?(key)
+    end
+
+    # def add_database_backup()
+    #   @options["database-backups"] <<
+    # end
+
+    # def add_fragment_root()
+    #   # @options["fragment-roots"] <<
+    # end
+
+    # def add_fragment_parent()
+    #   # @options["fragment-parents"] <<
+    # end
+
+    # def add_element_word_query_through()
+    #   # @options["element-word-query-throughs"] <<
+    # end
+
+    # def add_phrase_through()
+    #   # @options["phrase-throughs"] <<
+    # end
+
+    def add_range_element_index(name, options = {})
+      add_index "range-element-index", MarkLogic::DatabaseSettings::RangeElementIndex.new(name, options)
+    end
+
+    def add_element_word_lexicon(localname, options)
+       add_index "element-word-lexicons", MarkLogic::DatabaseSettings::ElementWordLexicon.new(localname, options)
+    end
+
+    def add_path_namespace()
+      # add_index "path-namespace"
+    end
+
+    def add_range_path_index(path_expression, options = {})
+      add_index "range-path-index", MarkLogic::DatabaseSettings::RangePathIndex.new(path_expression, options)
+    end
+
+    def add_field()
+      # add_index "fields"
+    end
+
+    def add_range_field_index(field_name, options = {})
+      add_index "range-field-index", MarkLogic::DatabaseSettings::RangeFieldIndex.new(field_name, options)
+    end
+
+    def add_geospatial_element_index(element_name, latitude_localname, longitude_localname, options = {})
+       add_index "geospatial-element-index", MarkLogic::DatabaseSettings::GeospatialElementIndex.new(element_name, latitude_localname, longitude_localname, options)
+    end
+
+    def add_geospatial_element_child_index(element_name, latitude_localname, longitude_localname, options = {})
+      add_index "geospatial-element-child-index", MarkLogic::DatabaseSettings::GeospatialElementChildIndex.new(element_name, latitude_localname, longitude_localname, options)
+    end
+
+    def add_geospatial_element_pair_index(element_name, latitude_localname, longitude_localname, options = {})
+      add_index "geospatial-element-pair-index", MarkLogic::DatabaseSettings::GeospatialElementPairIndex(element_name, latitude_localname, longitude_localname, options)
+    end
+
+    def add_geospatial_path_index(path_expression, latitude_localname, longitude_localname, options = {})
+      add_index "geospatial-path-index", MarkLogic::DatabaseSettings::GeospatialPathIndex.new(path_expression, latitude_localname, longitude_localname, options)
+    end
+
+    # def add_foreign_database()
+    #   add_index "foreign-database"
+    # end
+
+    def create
+      r = manage_connection.post_json(
+        %Q{/manage/v2/databases?format=json},
+        to_json)
+    end
+
+    def exists?
+      manage_connection.head(%Q{/manage/v2/databases/#{database_name}}).code.to_i  == 200
+    end
+
+    def stale?
+      response = manage_connection.get(%Q{/manage/v2/databases/#{database_name}/properties?format=json})
+      raise Exception.new("Invalid response: #{response.code.to_i}: #{response.body}") if (response.code.to_i != 200)
+
+      props = JSON.parse(response.body)
+
+      INDEX_KEYS.each do |key|
+        if props[key]
+          local = @options[key].uniq.sort
+          remote = props[key].map { |json| MarkLogic::DatabaseSettings::Index.from_json(key, json) }.uniq.sort
+          unless local == remote
+            logger.debug "#{database_name}: #{local} != #{remote}"
+            return true
+          end
+        elsif @options.has_key?(key) and @options[key] != []
+          logger.debug "#{database_name}: #{key} is not on the remote end"
+          return true
+        end
+      end
+
+      return false
+    end
+
+    def drop
+      r = manage_connection.delete(%Q{/manage/v2/databases/#{database_name}?format=json})
+    end
+
+    def to_json
+      json = {}
+      @options.each do |k, v|
+        if v.kind_of?(Array)
+          value = v.map { |item| item.to_json }
+        else
+          value = v
+        end
+        json[k] = value
+      end
+      # puts json
+      json
+    end
+
+    def update
+      url = %Q{/manage/v2/databases/#{database_name}/properties?format=json}
+      r = manage_connection.put(url, JSON.generate(to_json))
+    end
+
+    def reset_indexes
+      INDEX_KEYS.each do |key|
+        @options[key] = []
+       end
+    end
+
+    def add_index(index_type, index)
+      @options[index_type] = [] unless @options[index_type]
+      @options[index_type] << index
+      @options[index_type].uniq! { |ii| ii.key }
+      application.add_index(index) if application
+    end
+
+    def range_index(name)
+      @options["range-element-index"].each do |index|
+        return index if index.localname == name
+      end
+    end
+
+    def has_range_index?(name)
+      @options["range-element-index"].each do |index|
+        return true if index.localname == name
+      end
+
+      return false
+    end
+
+    def collection(name)
+      MarkLogic::Collection.new(name, self)
+    end
+
+    def clear
+      r = connection.delete(%Q{/v1/search})
+    end
+
+    def collections()
+      return connection.run_query('cts:collections()', "xquery").body || []
+    end
+  end
+end