3.0

Release date: 2026-09-26

Summary

This release fixes multiple correctness issues where queries returned wrong rows or crashed the backend, rewrites RDF comparison and arithmetic to match the SPARQL specification, and requires manual steps when upgrading from 2.x (see “Before you upgrade” below).

The most impactful bug fixes: out-of-bounds reads and heap overflows that could segfault or corrupt results; flawed comparison logic that let queries return wrong rows depending on INSERT order; pushdown restrictions that re-evaluate conditions that were previously sent to the endpoint, making queries slower but correct. Highlights: language tags are now fully normalized; sparql.uri() returns rdfnode not text; arithmetic on rdfnode now follows SPARQL; GROUP BY and DISTINCT now sort/group by written term, not by value; redirects are now configurable in a single option.

Before you upgrade

The upgrade will refuse to run while any index exists on an rdfnode column, or any view, materialized view or SQL-body function that sorts, groups or de-duplicates on one. rdfnode_ops is rebuilt on comparisons of the stored term, and replacing an operator class does not rewrite what was built with it. Save the definitions, drop those objects, upgrade, and recreate them. REINDEX is not enough. Stored queries that only compare rdfnodes are unaffected.

One option value is no longer accepted. request_max_redirect '-1' is rejected; use a positive bound, or 0 to refuse redirects. request_redirect is deprecated but still works.

One function signature changed. sparql.uri() returns rdfnode rather than text, which is what its synonym sparql.iri() always returned; assigning its result straight into a text column now needs an explicit ::text.

Queries in specific cases might produce different results to align with SPARQL specification and improve consistency:

  • GROUP BY, DISTINCT, UNION and unique constraints on an rdfnode now compare terms by how they are written rather than by value, so "1"^^xsd:integer and "01"^^xsd:integer are treated as distinct. ORDER BY is unchanged.
  • sparql.sum() and sparql.avg() now follow SPARQL specification for empty groups (returning "0"^^xsd:integer instead of NULL) and for NaN comparisons.
  • Numeric literal comparisons and type coercion now follow SPARQL rules: literals compare in the wider of their two datatypes; IRIs and blank nodes are distinguished from literals; language tags compare case-insensitively.
  • ROUND(), ABS(), REPLACE(), GROUP_CONCAT(), SUBSTR() and float4 output now produce results consistent with SPARQL/RDF specifications.
  • Arithmetic between an rdfnode and a PostgreSQL number now correctly produces an rdfnode result computed in RDF datatypes, e.g., '"0.1"^^xsd:decimal'::rdfnode * 3.0 now answers "0.3"^^xsd:decimal instead of 0.30000000447034836 as a double.

Some specific query patterns are now evaluated locally for correctness: conditions that could not be safely sent to the endpoint without risking wrong rows now run in PostgreSQL. This is rare and affects edge cases like LIMIT with ORDER BY, comparisons between rdfnode and PostgreSQL temporal types, DISTINCT with aggregates, and a few pg_catalog functions with different SPARQL semantics. Most queries are unaffected. For performance-sensitive cases that do touch these patterns, explicit casts or column types can pin the comparison to PostgreSQL semantics and allow pushdown.

Enhancements

  • Arithmetic on rdfnode: +, -, * and / now combine two numeric rdfnodes, following the SPARQL 1.1 §17.3 operator mapping: the result takes the wider of the two datatypes, and dividing two xsd:integers gives an xsd:decimal. The type had no arithmetic operators at all before, so 1::rdfnode + 1::rdfnode did not fail for want of a definition — PostgreSQL fell back to resolving it through the type’s casts, four of which are implicit, and reported that several candidates tied. The same gap left the extension recommending rdfnode while only the deprecated native-typed columns could reach the arithmetic the deparser pushes into a SPARQL FILTER. A term that is not a numeric literal raises an error rather than producing a number.

    The same four operators also combine an rdfnode with a PostgreSQL smallint, int, bigint, real, double precision or numeric, written on either side — the coverage the comparison operators already had. The PostgreSQL operand stands for the term its cast to rdfnode produces, so an int is an xsd:int, a numeric an xsd:decimal and a double precision an xsd:double, and the promotion and the result’s datatype follow from the pair exactly as they do between two terms. Without these, PostgreSQL resolved such an expression through the type’s implicit casts, which either tied — '"1"^^xsd:integer'::rdfnode + 1 reported that the operator was not unique — or settled on the implicit rdfnode → real cast and did IEEE arithmetic, leaving RDF without saying so: '"0.1"^^xsd:decimal'::rdfnode * 3.0 answered 0.30000000447034836 as a double precision where xsd:decimal arithmetic is exact and SPARQL answers "0.3"^^xsd:decimal. Such an expression could not be pushed down either, since the cast stood between the column and the operator.

    Arithmetic that mixes an rdfnode with a real or a double precision is evaluated in PostgreSQL rather than sent to the endpoint. SPARQL’s bare numeric literals are xsd:integer and xsd:decimal — a double needs the exponent form, 2.5e0 — so the constant would arrive as an xsd:decimal and the endpoint would compute in a different datatype than the operator does. Integer and numeric operands are unaffected and still push down. Comparisons are unaffected as well: XPath promotes the decimal to the double before comparing, so the literal’s datatype cannot change the answer there.

  • request_max_redirect is now the single option controlling HTTP redirects: Redirection used to be governed by two options that had to agree with each other — request_redirect switched it on, and request_max_redirect bounded it — which made it possible to write server definitions whose two halves contradicted each other, and one of those combinations was silently broken (see the bug fix below). request_max_redirect now carries both meanings on its own: 0 (the default) refuses any redirect, and any higher value enables redirection and caps it at that many hops. The -1 (unlimited) value has been dropped, since an unbounded redirect chain has no practical use against a SPARQL endpoint and invites never-ending redirect loops.

  -- follow at most 5 redirects
  CREATE SERVER dbpedia
  FOREIGN DATA WRAPPER rdf_fdw
  OPTIONS (endpoint 'https://dbpedia.org/sparql', request_max_redirect '5');

request_redirect is deprecated but still accepted, so existing servers and dumps continue to work: setting it raises a warning, and request_redirect 'true' without an explicit request_max_redirect follows up to 30 redirects, which is what libcurl would have done before. It will be removed in a future major release.

Breaking Changes

  • sparql.uri() returns rdfnode, not text: SPARQL 1.1 §17.4.2.8 defines URI() as another name for IRI(), and both give back an IRI. sparql.uri() has declared a return type of text since 2.1, although it calls the same C function as sparql.iri() and produces the same term — so its result could not be given to any other sparql function without a cast, and sparql.isiri(sparql.uri(...)) was an error where sparql.isiri(sparql.iri(...)) was not. It now returns rdfnode, and the two are interchangeable as the specification says they are. A query that assigned its result straight into a text column will need an explicit ::text; there is no implicit cast from rdfnode to text.

  • rdfnodes are sorted and grouped by the stored term: ORDER BY, GROUP BY, SELECT DISTINCT, UNION and unique constraints take their comparisons from the type’s default B-tree operator class, not from the = and < operators directly. That class declared the RDF value operators but ordered terms by how they are written, and the two do not agree — which gave wrong answers, described in the bug fix below.

    The class now compares the stored term throughout. Two terms are the same to it when they are written the same way, so "1"^^xsd:integer and "01"^^xsd:integer are one value and two terms: they sort apart, and they are two groups rather than one. Group or order by a cast where the value’s ordering is the one wanted — GROUP BY term::numeric.

    ORDER BY itself is unchanged, since sorting already used this comparison. What changes is GROUP BY, DISTINCT, UNION and unique constraints, which previously merged value-equal spellings — but only sometimes, and never dependably.

    The value operators =, <>, <, <=, >= and > are untouched and still mean what they meant, including in a WHERE clause. The class is built on five operators of its own, ~=, ~<~, ~<=~, ~>=~ and ~>~, named after PostgreSQL’s text_pattern_ops. They are seldom written by hand; where they matter is an index, which can answer a condition written with one of them, while a value comparison is applied as a filter to the rows the scan returns.

    Upgrading from an earlier version requires manual steps. Replacing an operator class does not rewrite what was built with it, so ALTER EXTENSION rdf_fdw UPDATE TO '3.0' refuses to run while any index on an rdfnode exists, or any view, materialized view or SQL-body function that sorts, groups or de-duplicates on one. Save their definitions, drop them, upgrade, and recreate them. REINDEX is not enough — an index belongs to the operator class it was created with. A stored query that only compares rdfnodes does not have to be touched. Nothing is dropped automatically.

Minor Changes

  • libcurl’s trace moved from DEBUG3 to DEBUG5: The extension logged libcurl’s verbose output, and the size of each chunk of a response body as it arrived, at the same level as its own tracing. None of it repeats between runs: it carries the response Date, whatever session cookie the server issues, the address the host resolved to, the server’s own request counter, and chunk sizes decided by how the body happens to arrive rather than by what it contains. That made client_min_messages = DEBUG3 unusable for anything comparing two runs — make installcheck INCLUDE_DEBUG_TESTS=1 failed on a clean tree with 948 lines differing, and two runs of the unmodified tree disagreed with each other. DEBUG3 now carries what the extension does and DEBUG5 how the bytes travel, and the debug test passes and repeats.

  • The extension is no longer declared relocatable: rdf_fdw.control set relocatable = true, but the extension creates a sparql schema and installs part of itself there, so its objects live in two schemas and ALTER EXTENSION rdf_fdw SET SCHEMA ... was refused by PostgreSQL regardless. The control file now says relocatable = false, which is what the extension actually is.

  • Regression tests that need a triplestore are now opt-in: make installcheck used to run the full suite by default, including the tests that query locally deployed triplestores and public SPARQL endpoints, and four SKIP_* variables had to be set to get a run that needs nothing but PostgreSQL. That default made the extension awkward to test for anyone building it in a sandbox, such as a distribution packager. The polarity is now inverted: make installcheck runs only the tests that need no external service, and the groups that do are enabled with INCLUDE_LOCAL_TESTS=1 (the triplestores deployed by scripts/postgres-env), INCLUDE_EXTERNAL_TESTS=1 (public SPARQL endpoints), INCLUDE_STRESS_TESTS=1, INCLUDE_DEBUG_TESTS=1, or INCLUDE_ALL_TESTS=1 for all of them.

Bug Fixes

Crashes, memory safety and leaks

  • Fixed datatype handling for bigint casts on 32-bit systems: Casts to rdfnode now correctly use 64-bit integers. On 32-bit systems where long is 32 bits, the conversion was reading only half the argument, so 42::bigint::rdfnode came back as "42"^^(null) instead of "42"^^xsd:long. Option validation also now correctly distinguishes bounded from unbounded settings on 32-bit systems. These fixes were found by building and testing on 32-bit platforms for the first time.

  • Fixed a crash when querying a foreign table with a dropped column: An accidental null dereference could crash the backend; this is now safely handled. (Tomas Vondra tomas@vondra.me)

  • Fixed resource leaks when a query does not finish normally: libcurl resources are now properly released on cancellation or errors, not just on normal completion. (Tomas Vondra tomas@vondra.me)

  • Fixed a buffer overrun in HTTP header collection: Headers are now collected with the correct length bounds, safely handling all content types. (Tomas Vondra tomas@vondra.me)

  • Fixed out-of-bounds read in boolean test deparsing: The column lookup for IS TRUE/IS FALSE now safely validates that a matching column exists before dereferencing, preventing reads past the array boundary. Conditions with no corresponding mapping are now correctly reported as not pushable.

  • Fixed libcurl initialization error handling and stderr output: Failures of curl_easy_init() or curl_easy_escape() are now detected and raise proper errors instead of being silently skipped. The extension no longer writes partial diagnostic messages directly to stderr, bypassing the server log’s formatting. (Tomas Vondra tomas@vondra.me)

  • Fixed a libcurl handle leak when max_response_size is exceeded: The callback that collects the HTTP response body raised the “response exceeds max_response_size” error with ereport(ERROR) from inside libcurl. That longjmps out of the middle of curl_easy_perform(), so neither curl_easy_cleanup() nor curl_slist_free_all() ever ran — and since libcurl allocates the easy handle, its header list and its connection outside PostgreSQL’s memory contexts, aborting the transaction did not reclaim them either. Every query that hit the limit therefore leaked a handle and a connection for the remaining life of the backend, on top of abandoning libcurl mid-transfer. The callback now flags the condition and aborts the transfer by returning a short write, which makes curl_easy_perform() fail cleanly; the very same error is raised afterwards, once the handle and the header list have been released. Requests aborted this way are also no longer retried, as every attempt would hit the same limit.

  • Fixed literal parsing with trailing backslashes: Literals ending in backslashes were misparsed; escape sequences are now handled correctly and literals round-trip through text unchanged. (Tomas Vondra tomas@vondra.me)

  • Fixed language tag extraction: The lang() function now safely bounds its buffer reads and correctly handles all literal formats. (Tomas Vondra tomas@vondra.me)

  • Fixed memory ownership in literal conversion: cstring_to_rdfliteral() now properly manages memory across all code paths. (Tomas Vondra tomas@vondra.me)

  • Fixed column validation to require variable option on foreign tables: Columns are now validated at table load time, preventing pstrdup(NULL) segfaults that occurred when planning queries with unvalidated columns. Clear error messages are now provided for missing options. (Tomas Vondra tomas@vondra.me)

  • Fixed buffer handling in rdf_fdw_clone_table(): The binding loop now correctly processes one value per column, with proper bounds checking. (Tomas Vondra tomas@vondra.me)

  • Fixed sparql.coalesce() to safely handle NULL variadic arrays: Calling sparql.coalesce(VARIADIC NULL::rdfnode[]) now correctly returns NULL instead of dereferencing a NULL array pointer. The function is non-STRICT to skip NULL arguments, so it gets called even when the variadic array itself is NULL. This issue affected all users and could cause sessions to crash.

Privileges and network safety

  • Fixed privilege checking in clones: Privileges are now re-checked for each page, ensuring a REVOKE issued by another session is respected. (Tomas Vondra tomas@vondra.me)

  • Enabled access to SPARQL functions for all users: The sparql schema is now properly granted to PUBLIC, making all 125 functions accessible. (Tomas Vondra tomas@vondra.me)

  • Restricted redirects to HTTP and HTTPS: rdf_fdw limits requests to the http and https protocols, but that restriction only covers the initial request — libcurl governs the protocols a redirect may lead to with a separate option, whose default also permits ftp and ftps. An endpoint could therefore answer with a redirect to an ftp:// URL and have the backend follow it. Redirect targets are now restricted to http and https as well.

  • Added privilege checks to rdf_fdw_clone_table() and sparql.describe(): Both functions now properly validate ACL_SELECT and ACL_USAGE on their targets. (Tomas Vondra tomas@vondra.me)

  • Improved IRI and blank node validation: Term syntax is now validated against the SPARQL grammar, preventing malformed terms from altering filter meaning or INSERT/DELETE statements. (Tomas Vondra tomas@vondra.me)

RDF values, literals and functions

  • Fixed literal value escaping when reading from SPARQL endpoints: Backslashes in endpoint values are now properly escaped before storing as rdfnode. The XML of SPARQL results carries literal values with ordinary backslashes, but these weren’t being escaped when stored, causing values like C:\temp to be read back as C:, tab, emp. This broke UPDATE/DELETE operations which send the stored term back to identify triples. Clones and sparql.describe() are also fixed and no longer strip quotes from values. (Tomas Vondra tomas@vondra.me)

  • Fixed string functions to handle both typed and received literal values consistently: String functions now correctly interpret escape sequences in lexical forms, so typed and received values of the same string give the same answer. Previously, sparql.strlen() would count escape sequences (returning 4 for "a\"b" vs. 3 from the endpoint), sparql.md5() and sparql.encode_for_uri() would hash the raw backslashes, sparql.ucase() would produce invalid escapes like \N from \n, and substring operations would work with escape positions instead of actual characters. All string functions (strlen, substr, contains, strstarts, strends, strbefore, strafter, md5, encode_for_uri, ucase) now operate on the actual character values. (Tomas Vondra tomas@vondra.me)

  • Fixed sparql.sum() and sparql.avg() to correctly handle infinity on all PostgreSQL versions: On PostgreSQL versions before 14, numeric lacks infinity support, so the accumulator would reject "INF"^^xsd:double and raise an error. An infinity is now recorded separately from the accumulator, letting IEEE 754 rules govern the answer: an infinity absorbs any finite value, and opposing infinities produce NaN. All versions now return results consistent with Fuseki, GraphDB, Virtuoso and QLever.

  • Fixed ordering comparison error messages for unsupported datatypes: When comparing two literals with the same unsupported datatype (e.g., xsd:anyURI), the error message now correctly identifies the datatype and explains which datatypes SPARQL 1.1 supports for ordering. Previously, the message incorrectly suggested the datatypes were different.

  • Fixed sparql.min() and sparql.max() to handle negative xsd:duration values: Negative durations like "-P1D"^^xsd:duration now parse correctly, matching the behavior of comparison operators which already handled them. XSD 1.1 admits the leading - sign, and the aggregate comparators now strip it and negate the result like the comparison operators do.

  • Fixed xsd:anyURI literals to preserve their datatype and not merge with plain literals: xsd:anyURI terms now correctly remain distinct from plain string literals and from each other as written. Previously, "http://a"^^xsd:anyURI compared equal to "http://a" and "http://a"^^xsd:string, contradicting RDF 1.1 Concepts §3.3 and SPARQL 1.1 §17.3 which only define equality and ordering for specific datatypes. The datatype is now treated like other unrecognized datatypes: equal only to an identical term, unequal to different spellings or datatypes, and not ordered. This fixes result mismatches between pushdown and local evaluation.

  • Fixed sparql.replace() to correctly handle XPath capture-group references: Replacement strings now correctly interpret XPath syntax ($1 through $9 for groups, \$ for literal dollar, \\ for literal backslash) and rewrite them to PostgreSQL’s regexp_replace syntax. Previously, REPLACE("abab", "a(b)", "[$1]") returned "[$1][$1]" instead of the correct "[b][b]".

  • Fixed sparql.tz() to return empty string for timezone-naive literals: SPARQL 1.1 §17.4.5.8 specifies that tz() returns an empty string when there is no timezone. Now tz("2011-01-10T14:45:13.815"^^xsd:dateTime) correctly returns "" instead of raising an error. This aligns with Fuseki, GraphDB and QLever behavior.

  • Fixed sparql.sum() and sparql.avg() to compute in promoted IEEE 754 datatypes with correct spellings: Results are now written in proper IEEE 754 form with infinities spelled INF and -INF (not Infinity), matching Fuseki and GraphDB. Previously, accumulation in PostgreSQL’s numeric type could produce very large integers or incorrectly-spelled special values outside the IEEE 754 range.

  • Fixed division by zero on floating-point terms to follow IEEE 754 semantics: Dividing floating-point terms by zero now produces INF, -INF, or NaN according to IEEE 754 rules, as specified by XPath and SPARQL 1.1 §17.3. For example, "1"^^xsd:double / "0"^^xsd:double now correctly returns "INF"^^xsd:double. Exact numeric types (xs:decimal, xs:integer) still raise an error as specified.

  • Fixed numeric literal validation to check lexical form and value range against datatype: The isNumeric() function now properly validates literals against their declared datatype’s constraints. Previously, it accepted invalid spellings like hexadecimal in xsd:integer and ignored value ranges (e.g., "99999"^^xsd:short was incorrectly considered numeric). Validation now follows XSD specifications. (Tomas Vondra tomas@vondra.me)

  • Fixed blank node handling in sparql.describe(): Unnamed blank nodes are now correctly reported with generated labels and their statements. (Tomas Vondra tomas@vondra.me)

  • Fixed language tag normalization to lowercase the entire tag: Language tags are now fully normalized to lowercase per RDF 1.1 Concepts §3.3, not just the first component. Previously, only the part before the first hyphen was lowercased, causing @EN-GB, @en-gb, and @ZH-Hant-TW to be treated as three different terms. Existing data is unaffected until rewritten.

  • Fixed string functions to enforce correct types: STRLEN(), LANG() and REPLACE() now correctly require literal arguments and properly count code points. (Tomas Vondra tomas@vondra.me)

  • Fixed rdfnode comparison consistency in GROUP BY and DISTINCT: The operator class now correctly and consistently compares terms as stored, fixing results that varied based on data or query plan. (Tomas Vondra tomas@vondra.me)

  • Fixed sparql.sum() and sparql.avg() to return correct values for empty groups: Both functions now return "0"^^xsd:integer for empty multisets per the SPARQL specification, instead of NULL. This aligns with group_concat() and other SPARQL aggregates.

  • Fixed NaN equality handling: "NaN"^^xsd:double now correctly reports as not equal to itself, per the SPARQL specification. (Tomas Vondra tomas@vondra.me)

  • Fixed value accessor width on 32-bit systems: Integer comparisons and temporal Datum handling now use the correct widths, fixing incorrect results on 32-bit platforms. (Tomas Vondra tomas@vondra.me)

  • Fixed type checking in string comparison functions: sparql.contains(), sparql.strstarts(), sparql.strends(), sparql.strbefore() and sparql.strafter() now correctly reject IRIs and blank nodes instead of operating on their string representation. (Tomas Vondra tomas@vondra.me)

  • Fixed string comparison functions to handle language tags case-insensitively: sparql.contains(), sparql.strstarts(), sparql.strends(), sparql.strbefore() and sparql.strafter() now correctly compare language tags without regard to case. Previously, literals with the same tag in different cases (e.g., @en-GB vs @en-gb) were treated as incompatible, causing these functions to return NULL instead of a result. This is especially important for literals from different sources, where case variations are common. (Tomas Vondra tomas@vondra.me)

  • Fixed numeric literal comparison to consistently promote to the wider datatype: Comparisons now uniformly promote operands to the wider of their two datatypes per XPath specification, instead of using inconsistent logic based on operand order or comparison type. Previously, different operators made different decisions: ordering operators inspected only the left operand, equality promoted differently than aggregates, and "16777217"^^xsd:float could be equal to "16777216"^^xsd:float in sparql.min() but not in =. All comparisons now share one implementation, matching behavior across Fuseki, Virtuoso, and GraphDB. (Tomas Vondra tomas@vondra.me)

  • Fixed term classification to distinguish IRIs and blank nodes from literals: IRIs and blank nodes now properly rank below literals in sparql.min()/sparql.max(), and are no longer compared equal to plain literals with similar spelling. For example, IRI <http://example.org/v> is now correctly distinct from literal "<http://example.org/v>". (Tomas Vondra tomas@vondra.me)

  • Fixed sparql.describe() to correctly return blank-node subjects: Blank nodes in rdf:nodeID subjects are now properly returned as blank nodes instead of being converted to IRIs. Previously, _:b1 would be read as <b1>, causing a single blank node to appear under both spellings in results.

  • Fixed XML element content parsing: Terms with CDATA or comments are now read completely instead of partially. (Tomas Vondra tomas@vondra.me)

  • Fixed type conversion for result values: Result values are now converted with proper type modifiers and I/O parameters, fixing array columns and precision handling in temporal types. (Tomas Vondra tomas@vondra.me)

  • Fixed temporal type comparisons to handle incompatible datatypes gracefully: Comparisons between RDF terms and PostgreSQL date/time types now return no match for incompatible datatypes instead of raising an error. All five temporal families now share one unified conversion function. (Tomas Vondra tomas@vondra.me)

  • Fixed annotation preservation in REPLACE(): Language tags and datatypes are now correctly carried from the input literal to the result. (Tomas Vondra tomas@vondra.me)

  • Fixed GROUP_CONCAT() to return properly formatted RDF literals: Empty results are now returned as "" (a serialized RDF literal) instead of raw text, so sparql.isliteral() correctly returns true. (Tomas Vondra tomas@vondra.me)

  • Fixed Unicode escape parsing to respect exact widths: \u takes exactly four hex digits and \U exactly eight, but a hex digit following an escape was treated as though it belonged to it, and the whole sequence was then left undecoded — "\u004142" stayed as written instead of becoming "A42", and a surrogate pair followed by a hex digit lost its first half to a replacement character. An escaped backslash was also read as the start of an escape: "\\u0041" is a backslash followed by the characters u0041, but it decoded to \A, which is a different value. Each escape now consumes exactly its own width, and an escaped backslash is passed through.

  • Fixed SUBSTR() to handle positions outside string boundaries: SUBSTR() now correctly handles positions outside the string per SPARQL’s fn:substring specification, returning only the overlapping part. Starting positions below 1 and negative lengths are now processed correctly. (Tomas Vondra tomas@vondra.me)

  • Fixed float4 precision in RDF output: Values now round-trip correctly, using the type’s own output function and respecting extra_float_digits. (Tomas Vondra tomas@vondra.me)

  • Fixed precision handling in ABS(): Numeric datatypes other than floating-point now preserve their exact values and lexical form. (Tomas Vondra tomas@vondra.me)

  • Fixed rounding in ROUND(): Now correctly implements SPARQL’s rounding rule (round to nearest, ties toward positive infinity) for all numeric types. (Tomas Vondra tomas@vondra.me)

  • Fixed identifier generation in BNODE(), UUID() and STRUUID(): These functions now generate unique values per row and use proper counter/timestamp combination to avoid duplicates. (Tomas Vondra tomas@vondra.me)

  • Fixed type caching in rdf_fdw_clone_table(): The type OID cache is now properly initialized on entry, ensuring rdfnode columns are correctly recognized. (Tomas Vondra tomas@vondra.me)

  • Fixed Unicode escapes being truncated on non-UTF8 servers: Escape length was measured with pg_utf_mblen() after converting to server encoding, giving wrong results whenever the two differ. Buffers were also undersized. Length is now measured with strlen() on the result, and buffers are sized per PostgreSQL’s contract. The compatibility shim for pre-13 servers also had the same issues and is now fixed.

Pushdown

  • A string constant spelled like a column name was pushed down as that column: The arguments of pushed-down functions and comparisons were recognised as columns by comparing their deparsed text with the column names, so a constant whose value equals a column’s name was sent as that column’s variable or expression. The endpoint then evaluated a different FILTER than the one written, and could return wrong results. A constant matching a dropped column also put a NULL pointer into the query, which some older PostgreSQL releases dereference, terminating the backend. Only column references are treated as columns now; constants are always sent as literals.

  • Fixed != pushdown to avoid SPARQL type errors on unsupported datatypes: Inequality comparisons against literals with unsupported datatypes (e.g., xsd:anyURI) are now evaluated locally instead of being sent to the endpoint. SPARQL raises a type error for such comparisons, which filters out matching rows, whereas PostgreSQL returns true for any non-matching term — causing queries to return fewer rows than expected. Equality (=) remains pushed down since both approaches select the same rows. Language-tagged literals and all supported datatypes continue to be pushed down. (Tomas Vondra tomas@vondra.me)

  • Fixed table planning to correctly handle dropped columns: Dropped columns are now properly skipped when reading the mapping, ensuring consistent query planning across PostgreSQL versions. Previously, dropped columns on PostgreSQL 17 and earlier appeared as still mapped, blocking rewrite logic and breaking pushdown. (Tomas Vondra tomas@vondra.me)

  • Improved function pushdown selectivity: Only functions from pg_catalog and rdf_fdw are sent to the endpoint, and semantic mismatches between PostgreSQL and SPARQL functions (like replace, upper/lower, concat, extract, round) are now avoided by keeping them local. (Tomas Vondra tomas@vondra.me)

  • Fixed SPARQL keyword detection to handle quoted strings correctly: Keywords are now recognized accurately by properly parsing all four SPARQL string forms, IRIs, and comments instead of merely counting quotes. Keywords are matched as whole words and recognized even at the very end of a query. Previously, keywords inside single-quoted strings were mistaken for actual keywords, breaking pushdown for affected queries. (Tomas Vondra tomas@vondra.me)

  • Fixed SPARQL query rewriting to be more conservative and correct: Queries are now rewritten only when provably safe: the SELECT clause names only variables including every mapped column, nothing follows the closing brace, and there is no BASE. Queries that don’t meet these criteria are sent as-is and evaluated locally. This prevents incorrect behavior like dropping meaningful clauses (e.g., SELECT DISTINCT). (Tomas Vondra tomas@vondra.me)

  • Fixed DISTINCT pushdown to not apply when row count changes: DISTINCT is now sent to the endpoint only when no aggregates or grouping operations are between the scan and the DISTINCT. Previously, DISTINCT would be pushed down even with such operations, changing results (e.g., SELECT DISTINCT count(predicate) would return 2 instead of the correct 5). (Tomas Vondra tomas@vondra.me)

  • Fixed LIKE pattern translation to SPARQL regular expressions: Patterns are now translated correctly with proper anchors, escaped literals, and control character handling. ILIKE is no longer pushed down because Unicode case-folding diverges from database collation, and non-constant patterns are also kept local. Previously, the translation had multiple bugs that could match different strings than the SQL pattern. (Tomas Vondra tomas@vondra.me)

  • Improved temporal type comparison handling: Comparisons with PostgreSQL temporal types are evaluated locally to ensure consistent results across all SPARQL endpoints, avoiding semantic mismatches. (Tomas Vondra tomas@vondra.me)

  • Fixed LIMIT pushdown to apply only when it won’t change results: LIMIT is now sent to the endpoint only on a single scan with no sort above. Previously, it was sent with ORDER BY (which is undefined for non-comparable terms in SPARQL), with aggregates, window functions, and joins — all contexts where it changes results. OFFSET now uses 64-bit accessors, fixing large offsets like 3000000000. (Tomas Vondra tomas@vondra.me)

  • Fixed arithmetic expression parenthesization in pushed-down filters: Arithmetic operators are now properly parenthesized to preserve correct order of operations. Previously, (n + 1) * 2 could be written as ?n + 1 * 2 without parentheses, changing the calculation. (Tomas Vondra tomas@vondra.me)

  • Fixed variable mapping to accept both ? and $ SPARQL sigils: Both ?x and $x are valid in SPARQL and refer to the same variable, but the mapping only recognized the ? sigil. Columns declared with $-prefixed variables now correctly match endpoint bindings. Previously, such columns would return NULL for all rows despite the endpoint returning correct values. (Tomas Vondra tomas@vondra.me)

  • Fixed EXPLAIN output to accurately report pushdown status: When a SPARQL query cannot be rewritten (because it carries its own LIMIT, ORDER BY, GROUP BY, UNION, or MINUS), EXPLAIN now correctly shows Pushdown: unsupported SPARQL instead of Pushdown: enabled with misleading Remote clauses. Previously, queries executed entirely locally could be reported as having remote operations, confusing users about actual execution. The Remote lines are now omitted when they don’t apply.

  • Fixed SPARQL keyword detection to find the earliest keyword occurrence: The search now considers all keyword spellings and correctly scans past string literals. Previously, the search would return the first matched spelling rather than the earliest in the query, causing clauses to be lost when keywords appeared in different forms. (Tomas Vondra tomas@vondra.me)

  • Fixed SPARQL whitespace handling in FROM clauses: All SPARQL whitespace forms (including newlines) are now correctly skipped when parsing FROM clauses. Previously, only literal spaces were recognized, causing multiline queries to lose graph IRIs. (Tomas Vondra tomas@vondra.me)

  • Fixed whole-row reference handling in SELECT: Whole-row references now correctly mark all columns as used, ensuring complete rows are fetched and fixing DELETE/UPDATE subqueries. (Tomas Vondra tomas@vondra.me)

  • Fixed condition evaluation when pushdown is disabled: Conditions in a SPARQL query are now only treated as remote when pushdown is enabled. Previously, with enable_pushdown 'false', conditions were recorded as pushed down but not actually sent to the endpoint, causing them to be evaluated nowhere and returning unfiltered results. Conditions are now properly evaluated locally when pushdown is disabled.

HTTP requests and responses

  • Fixed response validation to ensure proper SPARQL result format: Responses are now validated as proper SPARQL results documents instead of silently accepting any XML as results. Non-element nodes are properly skipped, and the page counter is reset per document load. This prevents misdirected endpoints from silently returning empty result sets. (Tomas Vondra tomas@vondra.me)

  • Fixed HTTP status code validation for write operations: Only 2xx HTTP status codes are now treated as successful requests; any other status is reported with the actual code. Previously, a completed transfer was assumed successful unless the status was 400 or higher, allowing 3xx responses to be silently treated as success. This caused INSERT and other writes to be acknowledged even when the endpoint had not performed them. (Tomas Vondra tomas@vondra.me)

  • Fixed request retry logic to stop when endpoint responds: The retry loop now stops as soon as an HTTP status is received, instead of continuing to retry failed transfers that already got a response from the server. Retrying is intended for requests that never reached the server; a response means the endpoint has answered. Cancellation requests are now checked between retry attempts.

  • Fixed long prefix context names to be passed as query parameters: Prefix context names are now passed as query parameters instead of being concatenated into the query string, preventing truncation. Previously, long names were truncated mid-statement, producing malformed SQL. (Tomas Vondra tomas@vondra.me)

  • Fixed response handling on connection retry: Response buffers are now properly cleared before each retry, preventing concatenation of partial and complete responses. (Tomas Vondra tomas@vondra.me)

  • Fixed the custom server option having no effect: Custom parameters weren’t appended; the SPARQL query was appended twice instead, doubling request size. Custom parameters are now appended correctly.

  • Fixed request_max_redirect '0' being silently ignored: The limit was only set for non-zero values, so '0' inherited libcurl’s default of 30 redirects. The limit is now always set explicitly. The option is also validated at CREATE SERVER time, rejecting non-integers and negative values.

Writes, cloning and configuration

  • Fixed count queries on foreign tables with no columns: Tables with no columns can now return counts by fetching results from the endpoint, which correctly answers count(*) queries even without mapped columns. (Tomas Vondra tomas@vondra.me)

  • Fixed large offset handling in table cloning: Offset and row count are now 64-bit values with overflow checking, supporting clones past two billion rows. Previously, they were held as 32-bit integers, causing large offsets to wrap to negative counts. (Tomas Vondra tomas@vondra.me)

  • Fixed old value retrieval in UPDATE and DELETE: Row identity columns are now resolved through the planner’s interface, ensuring correct old values and proper DELETE ... RETURNING behavior. (Tomas Vondra tomas@vondra.me)

  • Fixed variable substitution in SPARQL update templates: Variables are now matched as whole tokens, preventing partial matches (e.g., ?s matching inside ?subject) and preventing substitution of variables inside literals, IRIs, and comments. Multiple variables that modify the same value are now handled correctly. (Tomas Vondra tomas@vondra.me)

  • Fixed column binding in cloned records: Unbound columns are now properly represented as NULL instead of using table defaults, and memory is correctly freed for each record. (Tomas Vondra tomas@vondra.me)

  • Fixed 64-bit setting truncation during query execution: Settings are now carried at full width from planning to execution instead of being truncated to 32 bits. This fixes max_response_size silently becoming tiny limits and enable_xml_huge not being passed to libcurl. (Tomas Vondra tomas@vondra.me)

  • Fixed numeric option validation to prevent truncation and wrapping: Options are now validated with checked conversion at CREATE SERVER time, rejecting out-of-range values with clear error messages. Previously, large values were silently truncated or wrapped to negative numbers. (Tomas Vondra tomas@vondra.me)

  • Fixed fetch_size precedence on foreign tables: The table-level fetch_size option is now correctly read and takes precedence over the server-level value. Previously, only the server’s value was used. The procedure’s fetch_size argument still overrides both. (Tomas Vondra tomas@vondra.me)

  • Enabled custom schema installation: The extension can now be installed into schemas other than public with proper type resolution. (Tomas Vondra tomas@vondra.me)

  • Fixed sparql.* functions to work regardless of caller’s search_path: All type references now explicitly name the installation schema instead of relying on unqualified lookups at call time. This makes functions work correctly even when the extension is installed in non-standard schemas. (Tomas Vondra tomas@vondra.me)

2.7

Release date: 2026-07-26

Bug Fixes

  • Fixed a literal-escaping bug that could break out of the generated query: When serializing an RDF literal into the SPARQL/Turtle text sent to a triplestore — in FILTER pushdown, and in INSERT DATA/DELETE DATA bodies — both cstring_to_rdfliteral() and EscapeSPARQLLiteral() decided whether a " character needed a new escaping backslash using a single-character lookbehind (“was the byte immediately before this quote a backslash?”). That check only gives the right answer when at most one backslash precedes the quote: it cannot distinguish an even-length run of backslashes (which does not escape the quote — it’s N/2 independent, already-complete backslash-escape pairs) from an odd-length run (which does). A literal value ending in an unexpected number of backslashes could therefore desync the extension’s idea of escaping from the SPARQL/Turtle lexer that later parses the generated query on the endpoint, producing a stray, unescaped quote and letting content after it be interpreted as SPARQL syntax rather than string data. Both functions now determine escaping by counting the full backslash run and checking its parity (and, for locating a literal’s closing quote in EscapeSPARQLLiteral(), by scanning forward and consuming escape pairs as they’re found), which is correct for a run of any length. EscapeSPARQLLiteral() was also tightened so that a value with no unambiguous closing quote or with trailing bytes that don’t form a valid @lang/^^datatype suffix is always safely re-escaped as raw content, instead of being returned unmodified as before.

    Thanks Devrim Gündüz (@devrimgunduz) for reporting and fixing this issue!

  • Fixed libcurl lifecycle: curl_global_init()/curl_global_cleanup() were being called on every SPARQL request instead of once per backend process. This could interfere with other libcurl users loaded in the same backend (e.g. other FDWs). Global initialization now happens once in _PG_init(); cleanup is left to the OS at process exit.

2.6

Release date: 2026-06-23

Enhancements

  • Add token option to USER MAPPING: A new token option allows Bearer token authentication (RFC 6750) for SPARQL endpoints that use token-based access control instead of HTTP Basic Authentication. When set, rdf_fdw sends an Authorization: Bearer <token> HTTP header with every request.
  CREATE USER MAPPING FOR postgres
  SERVER myserver OPTIONS (token 'mysecrettoken');
  • Add max_response_size option to FOREIGN SERVERS: A new max_response_size server option caps the HTTP response body size in bytes. If the endpoint sends more data than the configured limit, the query is aborted with an error before PostgreSQL allocates further memory. The default is 0 (unlimited). This is particularly useful when connecting to public or untrusted SPARQL endpoints to prevent runaway memory consumption from unexpectedly large result sets.
  -- Reject responses larger than 100 MB
  CREATE SERVER dbpedia
  FOREIGN DATA WRAPPER rdf_fdw
  OPTIONS (endpoint 'https://dbpedia.org/sparql', max_response_size '104857600');

  • Pushdown now handles NOT boolean expressions: this allows NOT BOUND(), NOT isIRI(), NOT isLiteral(), and NOT isNumeric() to be translated to SPARQL FILTER (!...) and executed at the remote endpoint instead of being evaluated locally after fetching. This reduces the number of rows transferred from the endpoint when these conditions are selective.

  • Add support for BCE dates and timestamps in rdfnode casts: PostgreSQL represents BCE years using BC notation and has no year 0, while XML Schema uses astronomical year numbering (0000 = 1 BC, -0001 = 2 BC, etc.). Add conversion logic for date, timestamp, and timestamptz casts to ensure correct round-tripping of BCE values between PostgreSQL and RDF literals.

Deprecations

  • Native PostgreSQL column types in FOREIGN TABLE definitions: Declaring foreign table columns with standard PostgreSQL types (e.g. text, int, date, timestamp) is deprecated. The rdfnode type must be used instead, as it correctly represents the full RDF term — including IRIs, language tags, and XSD datatypes — and is required by all SPARQL functions. Existing tables continue to work but will emit a WARNING on every query listing the affected columns. The column options expression, language, literal_type, and nodetype are also deprecated, as they are only meaningful for native-typed columns. Support for native column types will be removed in a future release.

Bug Fixes

  • Fixed CURLE_WRITE_ERROR(23) on SPARQL UPDATE and unrecognised Content-Type responses: HeaderCallbackFunction was returning 0 for any Content-Type not recognised as an RDF or SPARQL XML type. Returning 0 from a libcurl write callback signals an abort and triggers CURLE_WRITE_ERROR(23), causing endpoints that respond with application/json — such as QLever on successful UPDATEs or Fuseki on HTTP 400 errors — to produce a spurious “unable to connect” error instead of the real outcome. Fixed by returning realsize for unrecognised Content-Type headers.

  • SPARQL UPDATE response body is now discarded: For INSERT, DELETE, and UPDATE operations only the HTTP status code matters; the response body is irrelevant. Previously the full body was accumulated in memory, which wasted resources for endpoints that return large JSON documents on success or failure. It now sets chunk.max_size = 0 to bypass the max_response_size limit.

  • HTTP error response bodies are now truncated in log and error messages: Error bodies included in errdetail() and server-log elog() calls were previously unbounded. A misconfigured proxy returning a large HTML error page would be written verbatim into the PostgreSQL server log. Error bodies are now truncated to 512 bytes (RDF_FDW_MAX_ERROR_BODY) before being included in any message.

  • Encoded credentials are no longer written to server logs via libcurl verbose output: When client_min_messages is set to DEBUG3, libcurl’s verbose output is now routed through PostgreSQL’s elog(DEBUG3) via a custom CURLOPT_DEBUGFUNCTION callback (CurlDebugCallback) instead of being written directly to stderr. Crucially, any outgoing or incoming HTTP header whose name matches Authorization: or Proxy-Authorization: has its value replaced with [REDACTED] before being logged, so Bearer tokens, Basic auth credentials (base64-encoded), and proxy passwords never appear in plaintext in the PostgreSQL server log.

  • rdfnodes with invalid trailing content now triggers an error: rdfnodes with trailing content, which can contain malicious SPARQL instructions, were being silently truncated. While this avoided any attempt at SPARQL injection, it could lead to confusion, since the user was never aware of this truncation. The function rdfnode_in now raises an error if such content is detected.

  • Fixes trailing whitespace truncation in rdfnode: rdfnode generated from strings containing trailing whitespaces were being truncated. This is now fixed.

  • Blank nodes in FILTER expressions: Blank nodes in FILTER expressions are now passed as blank nodes; previously, they were cast as literals. This allows triplestores that deviate from the SPARQL specification to handle blank nodes according to their own implementation.

  • Fixed wrong ordering of string and language-tagged literals in sparql.min() / sparql.max(): The aggregate comparator (rdfnode_cmp_for_aggregate) was using varstr_cmp with DEFAULT_COLLATION_OID for lexical comparisons of plain literals, xsd:string literals, and language-tagged literals. On databases whose locale is not C, this produces locale-dependent ordering (e.g., accented characters may be folded or reordered), which violates SPARQL 1.1 §17.3 — string ordering must follow Unicode codepoint order. Both calls have been replaced with strcmp.

  • Fixed negative xsd:duration round-trip: Casting a negative PostgreSQL interval to rdfnode produces a valid XSD duration with a leading - (e.g., -P1Y2M), but casting that value back to interval failed with invalid input syntax for type interval: "-P1Y2M" because PostgreSQL’s interval_in does not accept the XSD negative-duration notation. A helper xsd_duration_to_pg_interval now strips the leading -, parses the positive form, and negates the result.

  • Fixed trailing zeros in fractional seconds of xsd:duration output: interval_to_rdfnode was always formatting sub-second values with six decimal places (e.g., PT1M0.500000S). It now strips trailing zeros, producing the canonical lexical form (e.g., PT1M0.5S).

  • Fixed LANGMATCHES to correctly return false when the language tag is empty: Previously, LANGMATCHES("", "*") returned true, violating SPARQL 1.1 and RFC 4647 basic filtering semantics, which require "*" to match only non-empty language tags. This affected queries filtering untagged literals via FILTER LANGMATCHES(LANG(?x), "*"), which would incorrectly include untagged literals in results.

  • Fixed SECONDS() return type and value: the text overload was incorrectly declared as returning int instead of numeric, causing fractional seconds to be truncated. Additionally, timezone-aware xsd:dateTime values were returning the wrong seconds value due to implicit session timezone adjustment during timestamp casting; the lexical form is now cast to timestamptz to preserve the correct component.

  • Fixed TZ() to reject invalid timezone offsets: when given an xsd:dateTime literal with an out-of-range timezone offset (e.g., "2020-12-01T08:00:00+25:00"^^xsd:dateTime), the function would previously extract and return the offset as-is without validation. It now raises an error for offsets outside the valid XSD range of ±14:00.

  • Fixed session-timezone-dependent xsd:dateTime comparisons: All rdfnode comparison operators (=, <>, <, <=, >, >=) and the aggregate comparator were calling PostgreSQL’s timestamptz_in() for every xsd:dateTime literal, including timezone-naive ones. This caused two bugs: (1) comparing a timezone-naive literal with a timezone-aware one could return true instead of the correct SPARQL result of incomparable (false), depending on the session timezone; (2) the old timezone-detection heuristic used strpbrk(lex, "+-"), which matched the - separators in the date portion (e.g., 2025-04-25) and incorrectly classified every well-formed dateTime as timezone-aware. The fix introduces a datetime_has_tz() helper that restricts the search for Z, +, and - to the time portion of the lexical form (after the T or space separator). Timezone-aware pairs are compared via timestamptz_in() / timestamptz_cmp_internal(); timezone-naive pairs via timestamp_in() without any session-timezone influence; and mixed pairs return false (incomparable) per XSD §3.2.7.4 and SPARQL 1.1 §17.3 (Operator Mapping).

  • Fixed incomplete xsd:time support in rdfnode comparison operators: rdfnode_eq (=, <>) was missing xsd:time value-space comparison entirely, falling back to lexical comparison. The ordering operators (<, <=, >, >=) had xsd:time support but lacked timezone handling, unconditionally using time_in() for all literals. The fix adds xsd:time equality to rdfnode_eq and introduces a time_has_tz() helper that detects timezone designators (Z, +, -) in the time lexical form; timezone-aware pairs are now compared via timetz_in() / timetz_eq() (with UTC normalisation); timezone-naive pairs via time_in() without session-timezone influence; and mixed pairs return false (incomparable).

  • Fixed NaN‑NaN comparison bug: Previously the expression ?a = ?b returned true when both operands were the literal "NaN"^^xsd:double (or "NaN"^^xsd:float). According to SPARQL 1.1 (which follows the XSD 1.1 definition of xsd:double and the IEEE‑754 rules), a NaN value is never equal to any value, including another NaN; all numeric comparison operators must therefore evaluate to false for NaN operands. See XPath and XQuery Functions and Operators 3.1 at 4.3.1 op:numeric-equal, 4.3.2 op:numeric-less-than, and 4.3.3 op:numeric-greater-than.

  • Add missing boolean-boolean comparison: This adds xsd:boolean support to rdfnode comparison operators (=, <>, <, <=, >, >=), using PostgreSQL’s boolin / booleq / boollt / boolle / boolgt / boolge functions.

  • Fixed invalid XSD lexical forms for infinity in rdfnode cast functions: float4_to_rdfnode, float8_to_rdfnode, and numeric_to_rdfnode were producing "Infinity" and "-Infinity" as lexical forms, which are not valid XSD representations. XSD 1.1 Part 2 §3.3.4/§3.3.5 defines INF and -INF as the only valid lexical forms for positive and negative infinity in xsd:float and xsd:double.

  • Reject blank nodes in IRI, STRDT, and STRLANG: These functions require a simple literal as their first argument. Previously, passing a blank node (e.g. _:b1 or the result of sparql.bnode()) silently produced an invalid RDF term such as _:b1@en or a blank node with an attached datatype. Now these functions raise an error with a descriptive message when given a blank node.

  • Fixed cstring_to_rdfliteral() incorrectly treating literal content that resembles a blank node label (_:...) or IRI (<...>) as an actual blank node/IRI term, causing rdfnode_in() to strip quotes from literals such as "_:b1" and "<http://example.org>", making sparql.isblank() and sparql.isiri() return incorrect results for these literals.

  • Fixed SPARQL pushdown for IRI-valued constants: rdfnodes containing IRIs, when placed in the left side in an operation, were being incorrectly rendered as quoted literals, e.g. WHERE '<http://example.org/property>'::rdfnode = sparql.iri(p) was being pushed down as Remote Filter: (("http://example.org/property" = IRI(?p))) instead of Remote Filter: ((<http://example.org/property> = IRI(?p))). The T_OpExpr path in DeparseExpr now skips the rdfnode normalisation when dealing with IRIs and blank nodes.

  • Fixes isBlank result for NULL inputs: the SQL declaration of isBlank was defined as STRICT which led function calls with NULL inputs to directly return NULL, but isBlank should return false instead, as its companions isIRI, isLiteral, and isNumeric already do.

  • Fixed CONTAINS() result for incompatible arguments: CONTAINS() now correctly returns NULL instead of false when argument types are incompatible, e.g. a plain literal paired with a language-tagged literal such as @en). It now also now correctly returns NULL instead of true when either argument carries a non-string datatype (i.e. anything other than xsd:string or rdf:langString). The function was previously operating on the raw lexical form regardless of the datatype, which produced incorrect results for custom-typed literals such as "123"^^<http://example.com/int>.

  • Fixed incorrect XSD data type for numeric arguments in ROUND(): The function ROUND() was incorrectly returning xsd:double for PG numeric arguments, and it now returns xsd:decimal as also defined in other numeric functions, such as CEIL(), FLOOR(), or ABS().

  • Fixed TIMEZONE() consistently for invalid XSD types: TIMEZONE() now consistently raises an error when the argument carries a non-xsd:dateTime datatype (e.g. xsd:string) instead of returning NULL. A wrong datatype is a type error, not an unknown value, and should be surfaced explicitly.

  • Fixed DATATYPE() handling of malformed literals: DATATYPE() now correctly raises an error for syntactically malformed literals passed as text (e.g. "foo"^<xsd:string> with a single caret, or "foo"^^xsd:string> with an unbalanced angle bracket) by delegating validation to the rdfnode type cast before processing.

  • Fixed rdfnode input parser: rdfnode_in now correctly rejects typed literals with an unterminated IRI in the datatype annotation (e.g. "foo"^^<xsd:string missing the closing >). Previously the parser silently dropped the malformed datatype annotation and returned a plain literal ("foo"), which was incorrect and could mask data quality issues. Inputs to rdfnode_in that are not a (syntactically) valid RDF literal, IRI, or blank node now raise ERRCODE_INVALID_TEXT_REPRESENTATION instead of being silently coerced. IRIs and blank nodes are returned as-is without unnecessary literal parsing.

  • Accept ill-typed literals: Ill-typed literals are no longer rejected by rdfnode_in – a literal is ill-typed if its lexical form falls outside the lexical space of its datatype (e.g., "foo"^^xsd:int). While semantically inconsistent under RDF 1.1, these literals are syntactically valid RDF. Validation is now deferred to the underlying triplestore rather than being enforced at the database level.

  • Fixed REPLACE() to use regex semantics: REPLACE() now uses regexp_replace for the 3-argument form, consistent with the 4-argument form and the SPARQL 1.1 spec, which defines REPLACE() in terms of XPath regex in all forms. It now accepts empty string patterns, which are valid per XPath regex semantics and match at every position in the input string.

  • Fixed timetz to rdfnode cast: the function timetz_to_rdfnode relied entirely on PostgreSQL’s timetz_out to convert the strings, which led to a minute truncation when the timestamp’s minutes was :00. It now produces well-formed xsd:time timezone offsets (+02:00 instead of +02).

  • Fixed small memory leaks in ExecuteSPARQL: the buffer returned by curl_easy_escape was not being released with curl_free, and curl handles (curl_easy_cleanup, curl_slist_free_all, curl_global_cleanup) were not called on HTTP and network error paths.

2.5

Release date: 2026-04-20

Enhancements

  • Add ‘request_timeout’ to FOREIGN SERVERS: This option sets the maximum time in seconds allowed for a complete HTTP request (connect + transfer). 0 disables the limit (default). Unlike connect_timeout, this applies to the entire duration of the request, including data transfer.

  • Add ‘readonly’ option to FOREIGN SERVERS and FOREIGN TABLES: A new boolean readonly option can be set on both SERVER and FOREIGN TABLE to prevent INSERT, UPDATE, and DELETE operations before they reach the SPARQL endpoint. When set at the server level it applies to all foreign tables backed by that server; when set at the table level it overrides the server setting, allowing a read-only server to have individual writable tables (or a read-write server to have individual protected tables). PostgreSQL will report the correct updatability via IsForeignRelUpdatable, so client tools that inspect pg_catalog can also discover whether a table allows DML.

  -- Mark the entire server as read-only
  ALTER SERVER fuseki OPTIONS (ADD readonly 'true');

  -- Override at the table level: this table is still writable despite the server setting
  ALTER FOREIGN TABLE ft OPTIONS (ADD readonly 'false');

Minor Changes

  • Fixed rdfReScanForeignScan to reset the row index, making it correct for any future plan shape where PostgreSQL omits the Materialize node above a foreign scan.

2.4

Release date: 2026-02-14

Breaking Changes

  • Proxy authentication credentials moved to USER MAPPING: For improved security, proxy authentication credentials (proxy_user and proxy_password) must now be specified in USER MAPPING instead of SERVER options. This change prevents proxy passwords from being visible to all users with USAGE privilege on the foreign server, as PostgreSQL automatically hides USER MAPPING passwords from non-owners.

    Before (v2.3): sql CREATE SERVER myserver FOREIGN DATA WRAPPER rdf_fdw OPTIONS ( endpoint 'http://fuseki:3030/sparql', http_proxy 'http://proxy:3128', proxy_user 'proxyuser', proxy_user_password 'proxypass' );

    After (v2.4): ```sql CREATE SERVER myserver FOREIGN DATA WRAPPER rdf_fdw OPTIONS ( endpoint ‘http://fuseki:3030/sparql’, http_proxy ‘http://proxy:3128’ – Proxy URL stays in SERVER );

    CREATE USER MAPPING FOR myuser SERVER myserver OPTIONS ( user ‘admin’, password ‘secret’, proxy_user ‘proxyuser’, – Moved from SERVER proxy_password ‘proxypass’ – Moved from SERVER (previously ‘proxy_user_password’ ) ); ```

    Migration: Existing servers using proxy_user or proxy_user_password in SERVER options will need to be updated. Remove these options from the server and add them to user mappings instead. The validator will reject the old options with a clear error message.

2.3

Release date: 2026-01-28

Enhancements

  • Removed librdf dependency: The extension no longer depends on the Redland RDF Library (librdf). RDF/XML parsing for DESCRIBE queries is now performed using only libxml2, reducing external dependencies and improving maintainability.

  • Support to data modification queries: Introduced per-row SPARQL INSERT DATA, DELETE DATA, and UPDATE operations via the sparql_update_pattern option on foreign tables. The addition of the batch_size parameter enables efficient batching of these operations, significantly improving performance for bulk modifications.

  • Enhanced error handling in ExecuteSPARQL: Improved the handling of HTTP errors by capturing and displaying detailed error messages from the SPARQL endpoint. This includes disabling CURLOPT_FAILONERROR to capture response bodies for HTTP errors, adding specific error messages for common HTTP status codes (e.g., 400, 401, 404, 500).

Breaking Changes

  • The sparql.describe() function no longer accepts the raw_literal parameter. Users who need to extract plain text from literals can use the sparql.lex() function instead. This simplifies the function signature and encourages a more consistent approach to handling RDF literals.

  • The sparql.regex function is no longer available for local evaluation in PostgreSQL, as it turned out that its semantics cannot be reliably reproduced locally. Queries relying on local evaluation of sparql.regex will now fail with an error.

Minor Changes

  • The log_sparql option for foreign tables now defaults to false. Since INSERT, UPDATE, and DELETE operations can generate large SPARQL queries, enabling this option by default could result in unnecessarily large log entries.

Bug Fixes

  • Fixed URIs and blank nodes being incorrectly handled as plain literals in InsertRetrievedData() (used by rdf_fdw_clone_table()). When cloning foreign tables with rdfnode columns, URIs were being treated as plain text instead of being wrapped in angle brackets (e.g., <http://example.com>), and blank nodes were missing the _: prefix. The fix now checks the target column type: for rdfnode columns, it properly formats URIs with <> and blank nodes with _:, while for standard PostgreSQL types it extracts only the raw content. This ensures correct round-trip behavior when materializing RDF data into ordinary tables.

  • Fixed failure when extracting content from empty RDF literals in InsertRetrievedData(). The code was incorrectly using xmlNodeDump() to serialize RDF term nodes, which included XML tags in the output (e.g., <literal datatype="...">value</literal>). This caused rdf_fdw_clone_table() calls on columns containing empty literals (e.g., "", ""@en, or ""^^xsd:string) to fail. Now uses xmlNodeGetContent() to extract only the text content without XML tags, properly handling empty and non-empty RDF term nodes alike.

  • Fixed critical bug in all date comparison operators (>, >=, <, <=, =, !=) between rdfnode and PostgreSQL date types. Previously, the code used the wrong macro (PG_GETARG_INT16) to retrieve date arguments, causing all local date comparisons to fail or behave unpredictably. Now uses the correct PG_GETARG_DATEADT macro and adds robust error handling for non-date values. This ensures correct filtering and pushdown of date conditions, especially for queries like WHERE col > '1900-01-30'::date.

  • Fixed a bug in sparql.hours(rdfnode), sparql.minutes(rdfnode), and sparql.seconds(rdfnode) where RDF nodes containing only xsd:time were not handled correctly. These functions now properly extract the hour, minute, and second from both xsd:dateTime and xsd:time typed RDF nodes, instead of assuming all values are xsd:dateTime.

  • Updated sparql.concat() function to comply with SPARQL 1.1: now returns a simple literal (no language tag or datatype) when concatenating literals with conflicting language tags or incompatible datatypes, instead of throwing an error.

  • Empty RDF literals incorrectly returned as NULL: Fixed a bug where empty RDF literals (e.g., "", ""@en, or ""^^xsd:string) were being incorrectly returned as SQL NULL values instead of empty strings. The issue occurred in CreateTuple() where xmlNodeGetContent() returns NULL for empty XML elements. The fix now properly distinguishes between empty RDF terms (valid empty strings) and unbound SPARQL variables (SQL NULL) by checking the XML element type (<literal>, <uri>, or <bnode>).

  • Literals with escaped quotes corrupted during round-trip: Fixed a critical bug where literals containing escaped quotes (e.g., "\"WWU\""@en) were being corrupted when retrieved from SPARQL results. The CreateTuple() function was incorrectly reparsing raw XML text content as RDF syntax, causing quote characters to be interpreted as literal delimiters rather than data. This has been fixed by constructing rdfnode values directly from raw lexical content and manually appending language tags or datatypes.

  • Control characters not properly escaped in SPARQL statements: Control characters (newlines, tabs, carriage returns) in literals are now properly escaped in SPARQL INSERT and DELETE statements, ensuring correct round-trip behavior.

  • DESCRIBE queries with large result sets caused severe performance degradation: Fixed a critical performance issue where sparql.describe() queries returning large result sets took too long to complete. The root cause was in DescribeIRI(), which used librdf_parser_parse_string_into_model() to build a complete in-memory RDF graph model before extracting triples. This has been replaced with librdf_parser_parse_string_as_stream(), which processes RDF/XML on-the-fly without constructing an intermediate graph database. This dramatically reduces memory footprint and brings DESCRIBE query performance in line with SELECT queries handling similar-sized result sets.

  • UCASE and LCASE functions failed to convert multibyte UTF-8 characters: Fixed a bug where sparql.ucase() and sparql.lcase() were only converting ASCII characters (a-z, A-Z) and leaving multibyte UTF-8 characters unchanged. For example, sparql.ucase('"Westfälische Wilhelms-Universität Münster"@de') would incorrectly return "WESTFäLISCHE WILHELMS-UNIVERSITäT MüNSTER"@de instead of properly uppercasing ä, ö, ü to Ä, Ö, Ü. The functions now use PostgreSQL’s built-in upper() and lower() functions with proper collation support, correctly handling all Unicode characters according to the database’s locale settings.

  • SUBSTR function failed for multibyte UTF-8 characters and empty inputs: Fixed a bug in sparql.substr() where it incorrectly counted bytes instead of characters for multibyte UTF-8 strings, leading to truncated results. Additionally, the function now correctly returns an empty string when the start position is beyond the string length, instead of throwing an error.

  • Malformed SPARQL with FILTER(NULL) in older PostgreSQL versions: Fixed a bug in PostgreSQL 9.5 where NULL constants in expressions were being deparsed as the literal string “NULL” instead of returning a NULL pointer. This caused malformed SPARQL queries like FILTER(NULL) to be generated. The fix ensures that NULL constants are properly handled by preventing pushdown of such expressions.

  • Fixed unexpected behavior in sparql.bnode() where passing an already-formatted blank node (e.g., _:bnode1) would return SQL NULL instead of handling it gracefully. The function now implements idempotent behavior: if the input is already a blank node, it returns it as-is.

  • Fixed a bug where local filters (WHERE clauses) that were pushed down were also being evaluated locally, which was just redundant. Now, only conditions that cannot be pushed down are evaluated locally by PostgreSQL, ensuring correct results for non-pushable foreign tables.

2.2.0

Release date: 2025-12-07

Enhancements

  • SPARQL aggregate functions:

    Added support for SPARQL-style aggregate functions sparql.sum, sparql.avg, sparql.min, sparql.max, sparql.group_concat, and sparql.sample in SQL queries. These functions are now fully implemented and can be used for local aggregation in PostgreSQL, improving compatibility with SPARQL semantics and enabling more expressive analytics on RDF data. Aggregate pushdown to the SPARQL endpoint is not yet supported; all aggregation is performed locally by PostgreSQL.

  • Enhanced version information:

    The rdf_fdw_version() function now returns a comprehensive version string that includes PostgreSQL version, compiler information, and all dependency versions (libxml, librdf, libcurl) in a single formatted output. A new rdf_fdw_settings() function provides extended dependency information including optional components like SSL, zlib, libSSH, and nghttp2. The rdf_fdw_settings view parses this extended information into a table format for convenient programmatic access to individual component versions.

  • Improved EXPLAIN diagnostics for Foreign Scan nodes:

    EXPLAIN output now include rdf_fdw-specific details for each Foreign Scan node, showing which SQL clauses are pushed down to the remote SPARQL endpoint. The plan displays lines such as Pushdown: enabled/disabled, Remote Filter, Remote Sort Key, Remote Limit, and Remote Select, making it easier to understand query translation and pushdown behavior.

Bug Fixes

  • Fix lex() to correctly handle doubled-quote escapes in literals.

    RDF literals containing double-quotes were being truncated, leading to invalid results of sparql.lex() or any function that depends on it. This has now being fixed.

2.1.0

Release date: 2025-09-25

Enhancements

  • SPARQL Prefix Management:

    rdf_fdw now includes built-in support for SPARQL prefix management via a structured catalog and helper functions. This feature introduces:

    prefix_contexts: Named groups of reusable SPARQL prefixes.

    prefixes: Individual prefix → URI mappings associated with a context.

    A suite of SQL functions to add, update, delete, and override contexts and prefixes. This enhancement simplifies query generation, reduces redundancy, and makes SPARQL integration more maintainable — especially when dealing with multiple endpoints or vocabularies.

  • Add enable_xml_huge server option to support large XML result sets

    The new enable_xml_huge option allows users to enable libxml2’s XML_PARSE_HUGE flag when parsing SPARQL result sets. This is useful for consuming large XML responses that exceed libxml2’s default safety limits. By default, this option is disabled for security reasons.

Bug Fixes

  • NULL RDFNodes:

    This fixes a bug that could potentially lead the system to crash if the triple store returns a NULL value for an specific node (edge case).

  • xmlParseMemory errors

    An issue has been resolved where the system could potentially crash if libxml2 failed to parse a given XML string (for example, due to an out-of-memory error). A check has been added to detect and prevent such crashes.

  • xmlDocGetRootElement failing to get the root element

    A safeguard has been introduced to handle cases where xmlDocGetRootElement fails to parse the root node of an XML document. Instead of proceeding with an empty set, an error message is now displayed to inform the user of the issue.

2.0.0

Release date: 2025-05-22

This is a major release of rdf_fdw featuring substantial new features, improved standards compliance, and important infrastructure enhancements. Backward compatibility is preserved, but users are encouraged to review the new features and updated behavior.

Enhancements

  • PostgreSQL 9.5 and 18 (in beta1 as of this release) support.
  • SPARQL DESCRIBE query support via the new sparql.describe() support function.
  • New rdfnode data type, enabling:
    • Representation of RDF literals and IRIs with full lexical fidelity.
    • Precise round-tripping of SPARQL values within SQL.
    • Equality and order comparisons with native PostgreSQL types (e.g., int, float, text, date).
  • SPARQL 1.1 Built-in Function Support via SQL queries.

    These functions are translated to their SPARQL equivalents when pushed down to the foreign data wrapper.

Minor Changes

  • The FOREIGN TABLE option log_sparql is now set to true, if omitted. If you don’t want to log the SPARQL query, consider using ALTER FOREIGN TABLE to disable this option manually, e.g.
  ALTER FOREIGN TABLE myrdftable OPTIONS (ADD log_sparql 'false');

Bug Fixes

  • Query cancellation support:

    Added CHECK_FOR_INTERRUPTS() in key execution points to allow PostgreSQL backends to detect user-initiated query cancellations (e.g., Ctrl+C), improving long-running query handling.

External Libraries

  • Added a new dependency: Redland RDF Library (librdf) — used for parsing and serializing RDF data, and supporting DESCRIBE queries.

1.3.0

Release date: 2024-09-30

Enhancements

  • Support for PostgreSQL 9.6, 10, and 17: This adds support for the long EOL’d PostgreSQL versions 9.6 and 10. It is definitely discouraged to use these unsupported versions, but in case you’re for whatever reason unable to perform an upgrade you can now use the rdf_fdw.

1.2.0

Release date: 2024-05-22

Enhancements

  • Pushdown support for Math, String and Date/Time functions:
    • abs, ceil, floor, round
    • length, upper, lower, starts_with, substring, md5
    • extract(year from x), extract(month from x), extract(year from x), extract(hour from x), extract(minute from x), extract(second from x)
    • date_part(year, x), date_part('month',x), date_part('year', x), date_part('hour', x), date_part('minute', x), date_part('second', x)

    When used in the WHERE clause these functions will be translated to their correspondent SPARQL FILTER expressions.

Bug Fixes

  • Bug fix for WHERE conditions with “inverted” arguments - that is, value in the left side (T_Const) and column in the right side (T_Var): This fixes a bug that led the pushdown of WHERE condiditions containing “inverted” arguments to fail, e.g "foo" = column, 42 > column. Now the order of T_Const and T_Var in the arguments is irrelevant.

1.1.0

Release date: 2024-04-10

Enhancements

  • USER MAPPING support: This feature defines a mapping of a PostgreSQL user to an user in the target triplestore - user and password, so that the user can be authenticated. Requested by Matt Goldberg.

  • Pushdown suuport for pattern matching operators LIKE and ILIKE: these operators are now translated into SPARQL FILTER expressions as REGEX and pushed down.

  • Enables usage of non-pushable data types in FOREIGN TABLE columns: This disables a check that raised an excepetion when data types that cannot be pushed down were used. This includes non-standard data types, such as geometry or geography from PostGIS.

Bug Fixes

  • Empty SPARQL SELECT clause: This fixes a bug that led some SPARQL queries to be created without any variable in the SELECT clause. We now use SELECT * in case the planner cannot identify which nodes should be retrieved, which can be a bit inefficent if we’re dealing with many columns, but it is much better than an error message.

  • Missing schema from foreign tables in rdf_fdw_clone_table calls: This fixes a bug that led the rdf_fdw_clone_table procedure to always look for the given FOREIGN TABLE in the public schema.

  • xmlDoc* memory leak: The xml document containing the resulst sets from the SPARQL queries wasn’t beeing freed after the query was complete. This led to a memory leak that could potentially cause a system crash once all available memory was consumed by the orphan documents - which is an issue for rather modest server settings that execute mutliple queries in the same session. Reported by Filipe Pessoa.

1.0.0

Release date: 2024-03-15

Initial release.

Support for PostgreSQL 11, 12, 13, 14, 15 and 16.

Main Features

  • Pushdown: LIMIT, ORDER BY, DISTINCT, WHERE with several data types and operators
  • Table copy: This introduces the procedure rdf_fdw_clone_table(), that is designed to copy data from a FOREIGN TABLE into an ordinary TABLE. It provides the possibility to retrieve the data set in batches.
  • Proxy Support for SERVER: quite handy feature in case the PostgreSQL and SPARQL endpoint servers are in different networks and can only communicate through a proxy.