solis 0.125.0 → 0.126.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c29d1cb5fcfe9ad5579f22c3971aa794edc602b6afa3679a2113e0caecd01aa4
-  data.tar.gz: e067c8d0ad39a30dd49c921f5beded800d0f93de83817911c6fafd32486b89dd
+  metadata.gz: ce5b23eb71b6b7189377d4981fa8e6dc076128d60aec207e58310fbd162b8a16
+  data.tar.gz: 57c514df94596d89d76ea012cc946b2b521869f585f1d495609f8e0ec5cbdf71
 SHA512:
-  metadata.gz: 939e20fe0909c981ee02d29766b5ac43446db72d94df6a49ca68208a4a7c8d969a543c859b9f8c9e18bb843f5dd34e186356cdd245aa0abb8120b3bee0a7e4ad
-  data.tar.gz: 5fb1ae2ea0fd011eb0aab4d306252a27f9f238a0b908fe458895bd1d238974da59ee57d4520dc14a34e49e2fe2fa60bb6b4d8366f3cd4b9fed4c63ce15594527
+  metadata.gz: 912773a18a5b44da59e1bbb6b7e3472c5d8be9a8044df0b64acbb7da501a3156ead5615363bd23fbd595d42db1b862f3d776235758d92acf8d0942f42f2fde00
+  data.tar.gz: 90c434c26f367159078555cf9bfbc715d4179ad8f3ebffba12ba379000e7696bf25020cd9a033d90b1b1e95375574bd4600eb3492d67e703a07aaff901d6b251

data/lib/solis/query.rb

@@ -11,6 +11,15 @@ module Solis
     include Enumerable
     include Solis::QueryFilter
 
+    # XSD numeric datatypes must be ordered by value; wrapping them in STR() would sort
+    # them lexically ("100" < "9"). Every other datatype is STR()-wrapped in the outer
+    # ORDER BY (see #sort_key_expression) to dodge a Virtuoso collation bug.
+    XSD_NUMERIC_DATATYPES = %w[
+      integer decimal float double long int short byte
+      nonNegativeInteger nonPositiveInteger negativeInteger positiveInteger
+      unsignedLong unsignedInt unsignedShort unsignedByte
+    ].map { |t| "http://www.w3.org/2001/XMLSchema##{t}" }.freeze
+
     def self.run(entity, query, options = {})
       Solis::Query::Runner.run(entity, query, options)
     end
@@ -96,6 +105,13 @@ module Solis
       @filter = {values: ["VALUES ?type {#{target_class}}"], concepts: ['?concept a ?type .'] }
       @sort = 'ORDER BY ?concept'
       @sort_select = ''
+      # @sort_project carries the sort key(s) out of the inner (paginated) subquery so the
+      # outer query can re-sort on them; @sort_outer is that outer ORDER BY. A subquery's
+      # ORDER BY only decides which rows survive LIMIT/OFFSET — it does NOT propagate
+      # through the enclosing join — so the outer query must sort too. See #sort for the
+      # datatype-aware STR() handling that the outer ORDER BY needs.
+      @sort_project = ''
+      @sort_outer = ''
       @language = Graphiti.context[:object]&.language || Solis::Options.instance.get[:language] || 'en'
       @query_cache = self.class.shared_query_cache
     end
@@ -113,19 +129,31 @@ module Solis
     def sort(params)
       @sort = ''
       @sort_select = ''
+      @sort_project = ''
+      @sort_outer = ''
       if params.key?(:sort)
         i = 0
+        outer = ''
         params[:sort].each do |attribute, direction|
-          path = @model.class.metadata[:attributes][attribute.to_s][:path]
-          @sort_select += "optional {\n" if @model.class.metadata[:attributes][attribute.to_s][:mincount] == 0
+          meta = @model.class.metadata[:attributes][attribute.to_s]
+          path = meta[:path]
+          @sort_select += "optional {\n" if meta[:mincount] == 0
           @sort_select += "?concept <#{path}> ?__#{attribute} . "
-          @sort_select += "}\n" if @model.class.metadata[:attributes][attribute.to_s][:mincount] == 0
+          @sort_select += "}\n" if meta[:mincount] == 0
           @sort += ',' if i.positive?
           @sort += "#{direction.to_s.upcase}(?__#{attribute})"
+          # Carry the sort key out of the subquery so the outer query can re-sort on it.
+          @sort_project += " ?__#{attribute}"
+          outer += ',' if i.positive?
+          outer += "#{direction.to_s.upcase}(#{sort_key_expression(attribute, meta)})"
           i += 1
         end
 
-        @sort = "ORDER BY #{@sort}" if i.positive?
+        if i.positive?
+          @sort = "ORDER BY #{@sort}"
+          # ?s tiebreaker keeps each subject's triples contiguous and ties deterministic.
+          @sort_outer = "ORDER BY #{outer} ?s"
+        end
       end
 
       self
@@ -219,6 +247,11 @@ module Solis
       # object when the open `?s ?p ?o` pattern is combined with the disjunctive
       # language_filter, returning the rdf:type object for every row. Aliasing through
       # BIND blocks that optimizer rewrite and is a no-op on engines without the bug.
+      # Outer ordering: the inner subquery's ORDER BY only selects which rows survive
+      # LIMIT/OFFSET; it does NOT propagate through the enclosing join. The outer query
+      # therefore re-sorts on the same key(s) (@sort_outer, datatype-aware STR()). When
+      # no sort is requested, `order by ?s` gives a cheap deterministic default order.
+      outer_order = @sort_outer.empty? ? 'order by ?s' : @sort_outer
       query = %(
       #{prefixes}
 SELECT ?s ?p ?o WHERE {
@@ -229,7 +262,7 @@ SELECT ?s ?p ?o WHERE {
 }
 #{language_filter}
 }
-order by ?s
+#{outer_order}
 )
 
       Solis::LOGGER.info(query) if ConfigFile[:debug]
@@ -274,8 +307,12 @@ order by ?s
     end
 
     def core_query(relationship)
+      # @sort_project re-exposes the sort key(s) bound in @sort_select so the OUTER query
+      # can ORDER BY them. NB: for a multi-valued sort attribute this turns DISTINCT into
+      # one row per (concept, value) pair, which would skew LIMIT/OFFSET — sort attributes
+      # are expected to be single-valued.
       core_query = %(
-  SELECT distinct (?concept AS ?s) WHERE {
+  SELECT distinct (?concept AS ?s)#{@sort_project} WHERE {
     #{@filter[:values].join("\n")}
     #{relationship}
     #{@filter[:concepts].join("\n")}
@@ -286,6 +323,21 @@ order by ?s
 )
     end
 
+    # SPARQL expression to sort an attribute by in the OUTER query.
+    #
+    # The outer (post-join) ORDER BY on this Virtuoso build (08.03.3335) mis-collates
+    # language-tagged literals, so string-ish keys are wrapped in STR() — which fixes the
+    # ordering and is order-preserving for xsd:string, dates, gYear, booleans and EDTF.
+    # Numeric keys must NOT be wrapped: STR() would order them lexically ("100" < "9"),
+    # and numbers carry no language tag so they are unaffected by the collation bug.
+    def sort_key_expression(attribute, meta = @model.class.metadata[:attributes][attribute.to_s])
+      if XSD_NUMERIC_DATATYPES.include?(meta[:datatype_rdf].to_s)
+        "?__#{attribute}"
+      else
+        "STR(?__#{attribute})"
+      end
+    end
+
     def prefixes
       "
 PREFIX sh: <http://www.w3.org/ns/shacl#>

data/lib/solis/version.rb

@@ -1,3 +1,3 @@
 module Solis
-  VERSION = "0.125.0"
+  VERSION = "0.126.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solis
 version: !ruby/object:Gem::Version
-  version: 0.125.0
+  version: 0.126.0
 platform: ruby
 authors:
 - Mehmet Celik