adding serde to the data model: triple

Thanks to @jonassmedegaard

Issue #842
  
An error occurred
 

Issue #843
  
An error occurred
 

.clusterfuzzlite/Dockerfile

@@ -0,0 +1,4 @@
+FROM gcr.io/oss-fuzz-base/base-builder-rust:v1
+COPY . $SRC/oxigraph
+WORKDIR oxigraph
+COPY .clusterfuzzlite/build.sh $SRC/

.clusterfuzzlite/build.sh

@@ -0,0 +1,30 @@
+#!/bin/bash -eu
+shopt -s globstar
+
+function build_seed_corpus() {
+  mkdir "/tmp/oxigraph_$1"
+  for file in **/*."$2"
+  do
+    hash=$(sha256sum "$file" | awk '{print $1;}')
+    cp "$file" "/tmp/oxigraph_$1/$hash"
+  done
+  zip "$1_seed_corpus.zip" /tmp/"oxigraph_$1"/*
+  rm -r "/tmp/oxigraph_$1"
+}
+
+
+cd "$SRC"/oxigraph
+git submodule init
+git submodule update
+cargo fuzz build -O --debug-assertions
+for TARGET in sparql_eval sparql_results_json sparql_results_tsv sparql_results_xml n3 nquads trig rdf_xml
+do
+  cp fuzz/target/x86_64-unknown-linux-gnu/release/$TARGET "$OUT"/
+done
+build_seed_corpus sparql_results_json srj
+build_seed_corpus sparql_results_tsv tsv
+build_seed_corpus sparql_results_xml srx
+build_seed_corpus n3 n3
+build_seed_corpus nquads nq
+build_seed_corpus trig trig
+build_seed_corpus rdf_xml rdf

.clusterfuzzlite/project.yaml

@@ -0,0 +1 @@
+language: rust

.github/DEPENDABOT.yml

@@ -0,0 +1,16 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: weekly
+  - package-ecosystem: "pip"
+    directory: "/python/"
+    versioning-strategy: increase-if-necessary
+    schedule:
+      interval: weekly
+  - package-ecosystem: "npm"
+    directory: "/js/"
+    versioning-strategy: increase-if-necessary
+    schedule:
+      interval: weekly

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,16 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Which version of Oxigraph are you using? On which platform?
+2. A command-line or a code snippet that triggers the bug.

.github/ISSUE_TEMPLATE/feature-request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Please link to other systems implementing the feature, specification of it if it exists and/or existing documentation about this feature.

.github/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,10 @@
+---
+name: Question
+about: Please don't use issues but the Q&A section of the "discussions" space
+title: ''
+labels: question
+assignees: ''
+
+---
+
+

.github/actions/setup-rust/action.yml

@@ -0,0 +1,27 @@
+name: 'Setup Rust'
+description: 'Setup Rust using Rustup'
+inputs:
+  version:
+    description: 'Rust version to use. By default latest stable version'
+    required: false
+    default: 'stable'
+  component:
+    description: 'Rust extra component to install like clippy'
+    required: false
+  target:
+    description: 'Rust extra target to install like wasm32-unknown-unknown'
+    required: false
+runs:
+  using: "composite"
+  steps:
+    - run: rustup update
+      shell: bash
+    - run: rustup default ${{ inputs.version }}
+      shell: bash
+    - run: rustup component add ${{ inputs.component }}
+      shell: bash
+      if: ${{ inputs.component }}
+    - run: rustup target add ${{ inputs.target }}
+      shell: bash
+      if: ${{ inputs.target }}
+    - uses: Swatinem/rust-cache@v2

.github/workflows/artifacts.yml

@@ -1,55 +1,56 @@
-name: Nightly artifacts
+name: Artifacts
 
 on:
   push:
     branches:
       - main
+      - next
+  release:
+    types:
+      - published
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
 jobs:
-  python_doc:
-    runs-on: ubuntu-latest
+  binary_linux:
+    runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           submodules: true
-      - run: rustup update
-      - uses: actions/setup-python@v2
+      - uses: ./.github/actions/setup-rust
         with:
-          python-version: 3.8
-      - run: python -m venv python/venv
-      - run: source python/venv/bin/activate && pip install --upgrade maturin sphinx
-      - run: source venv/bin/activate && maturin develop
-        working-directory: ./python
-      - run: source ../venv/bin/activate && sphinx-build -M doctest . build
-        working-directory: ./python/docs
-      - run: source ../venv/bin/activate && sphinx-build -M html . build
-        working-directory: ./python/docs
-      - uses: actions/checkout@v2
-        with:
-          repository: oxigraph/oxigraph.github.io
-          path: website
-          token: ${{ secrets.FULL_ACCESS_TOKEN }}
-      - run: rm -rf ./website/pyoxigraph/latest && mkdir -p ./website/pyoxigraph/latest && cp -r ./python/docs/build/html/* ./website/pyoxigraph/latest/
+          target: aarch64-unknown-linux-gnu
       - run: |
-          git config user.name github-actions
-          git config user.email github-actions@github.com
-          git add .
-          git diff-index --quiet HEAD || git commit -m "Updates pyoxigraph documentation"
-          git push
-        working-directory: ./website
-
-  binary_linux:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
+          sudo apt-get update && sudo apt-get install -y g++-aarch64-linux-gnu
+          mkdir .cargo
+          echo -e "[target.aarch64-unknown-linux-gnu]\nlinker = \"aarch64-linux-gnu-gcc\"" >> .cargo/config.toml
+      - run: cargo build --release --no-default-features --features rustls-native
+        working-directory: ./cli
+      - run: cargo build --release --target aarch64-unknown-linux-gnu --no-default-features --features rustls-native
+        working-directory: ./cli
+        env:
+          BINDGEN_EXTRA_CLANG_ARGS: --sysroot /usr/aarch64-linux-gnu
+      - uses: actions/upload-artifact@v4
         with:
-          submodules: true
-      - run: cargo build --release
-        working-directory: ./server
-      - uses: actions/upload-artifact@v2
+          name: oxigraph_x86_64_linux_gnu
+          path: target/release/oxigraph
+      - uses: actions/upload-artifact@v4
         with:
-          name: oxigraph_server_x86_64_linux_gnu
-          path: target/release/oxigraph_server
+          name: oxigraph_aarch64_linux_gnu
+          path: target/aarch64-unknown-linux-gnu/release/oxigraph
+      - run: mv target/release/oxigraph oxigraph_${{ github.event.release.tag_name }}_x86_64_linux_gnu
+        if: github.event_name == 'release'
+      - run: mv target/aarch64-unknown-linux-gnu/release/oxigraph oxigraph_${{ github.event.release.tag_name }}_aarch64_linux_gnu
+        if: github.event_name == 'release'
+      - uses: softprops/action-gh-release@v1
+        with:
+          files: |
+            oxigraph_${{ github.event.release.tag_name }}_x86_64_linux_gnu
+            oxigraph_${{ github.event.release.tag_name }}_aarch64_linux_gnu
+        if: github.event_name == 'release'
 
   binary_mac:
     runs-on: macos-latest
@@ -58,43 +59,124 @@ jobs:
       SDKROOT: '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk'
       MACOSX_DEPLOYMENT_TARGET: '10.14'
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           submodules: true
-      - run: rustup update
+      - uses: ./.github/actions/setup-rust
+        with:
+          target: aarch64-apple-darwin
       - run: cargo build --release
-        working-directory: ./server
-      - uses: actions/upload-artifact@v2
+        working-directory: ./cli
+      - run: cargo build --release --target aarch64-apple-darwin
+        working-directory: ./cli
+      - uses: actions/upload-artifact@v4
+        with:
+          name: oxigraph_x86_64_apple
+          path: target/release/oxigraph
+      - uses: actions/upload-artifact@v4
+        with:
+          name: oxigraph_aarch64_apple
+          path: target/aarch64-apple-darwin/release/oxigraph
+      - run: mv target/release/oxigraph oxigraph_${{ github.event.release.tag_name }}_x86_64_apple
+        if: github.event_name == 'release'
+      - run: mv target/aarch64-apple-darwin/release/oxigraph oxigraph_${{ github.event.release.tag_name }}_aarch64_apple
+        if: github.event_name == 'release'
+      - uses: softprops/action-gh-release@v1
         with:
-          name: oxigraph_server_x86_64_apple
-          path: target/release/oxigraph_server
+          files: |
+            oxigraph_${{ github.event.release.tag_name }}_x86_64_apple
+            oxigraph_${{ github.event.release.tag_name }}_aarch64_apple
+        if: github.event_name == 'release'
 
   binary_windows:
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           submodules: true
-      - run: rustup update
+      - uses: ./.github/actions/setup-rust
       - run: Remove-Item -LiteralPath "C:\msys64\" -Force -Recurse
       - run: cargo build --release
-        working-directory: ./server
-      - uses: actions/upload-artifact@v2
+        working-directory: ./cli
+      - uses: actions/upload-artifact@v4
+        with:
+          name: oxigraph_x86_64_windows_msvc
+          path: target/release/oxigraph.exe
+      - run: mv target/release/oxigraph.exe oxigraph_${{ github.event.release.tag_name }}_x86_64_windows_msvc.exe
+        if: github.event_name == 'release'
+      - uses: softprops/action-gh-release@v1
         with:
-          name: oxigraph_server_x86_64_windows_msvc
-          path: target/release/oxigraph_server.exe
+          files: oxigraph_${{ github.event.release.tag_name }}_x86_64_windows_msvc.exe
+        if: github.event_name == 'release'
+
+  python_sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+          cache-dependency-path: '**/requirements.dev.txt'
+      - run: pip install -r python/requirements.dev.txt
+      - run: maturin build -m python/Cargo.toml
+      - run: pip install --no-index --find-links=target/wheels/ pyoxigraph
+      - run: rm -r target/wheels
+      - run: python generate_stubs.py pyoxigraph pyoxigraph.pyi --ruff
+        working-directory: ./python
+      - run: maturin sdist -m python/Cargo.toml
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pyoxigraph_sdist
+          path: target/wheels/*.tar.gz
 
   wheel_linux:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        architecture: [ "x86_64", "aarch64" ]
+    continue-on-error: true
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           submodules: true
-      - run: sed 's/%arch%/x86_64/g' .github/workflows/manylinux_build.sh > .github/workflows/manylinux_build_script.sh
-      - run: docker run -v "$(pwd)":/workdir --platform linux/x86_64 quay.io/pypa/manylinux2014_x86_64 /bin/bash /workdir/.github/workflows/manylinux_build_script.sh
-      - uses: actions/upload-artifact@v2
+      - uses: docker/setup-qemu-action@v2
+        with:
+          platforms: linux/${{ matrix.architecture }}
+        if: github.event_name == 'release' && matrix.architecture != 'x86_64'
+      - uses: ./.github/actions/setup-rust
+      - run: sed 's/%arch%/${{ matrix.architecture }}/g' .github/workflows/manylinux_build.sh | sed 's/%for_each_version%/${{ github.event_name == 'release' || '' }}/g' > .github/workflows/manylinux_build_script.sh
+      - run: docker run -v "$(pwd)":/workdir --platform linux/${{ matrix.architecture }} quay.io/pypa/manylinux2014_${{ matrix.architecture }} /bin/bash /workdir/.github/workflows/manylinux_build_script.sh
+        if: github.event_name == 'release' || matrix.architecture == 'x86_64'
+      - uses: actions/upload-artifact@v4
         with:
-          name: pyoxigraph_x86_64_linux
+          name: pyoxigraph_${{ matrix.architecture }}_linux_gnu
+          path: target/wheels/*.whl
+
+  wheel_linux_musl:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        architecture: [ "x86_64", "aarch64" ]
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: docker/setup-qemu-action@v2
+        with:
+          platforms: linux/${{ matrix.architecture }}
+        if: github.event_name == 'release' && matrix.architecture != 'x86_64'
+      - uses: ./.github/actions/setup-rust
+      - run: sed 's/%arch%/${{ matrix.architecture }}/g' .github/workflows/musllinux_build.sh | sed 's/%for_each_version%/${{ github.event_name == 'release' || '' }}/g' > .github/workflows/musllinux_build_script.sh
+      - run: docker run -v "$(pwd)":/workdir --platform linux/${{ matrix.architecture }} quay.io/pypa/musllinux_1_2_${{ matrix.architecture }} /bin/bash /workdir/.github/workflows/musllinux_build_script.sh
+        if: github.event_name == 'release' || matrix.architecture == 'x86_64'
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pyoxigraph_${{ matrix.architecture }}_linux_musl
           path: target/wheels/*.whl
 
   wheel_mac:
@@ -104,75 +186,237 @@ jobs:
       SDKROOT: '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk'
       MACOSX_DEPLOYMENT_TARGET: '10.14'
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           submodules: true
-      - uses: actions/setup-python@v2
+      - uses: ./.github/actions/setup-rust
         with:
-          python-version: 3.7
-      - run: rustup update && rustup target add aarch64-apple-darwin
-      - run: pip install maturin
-      - run: maturin build --release -m python/Cargo.toml --universal2
-      - uses: actions/upload-artifact@v2
+          target: aarch64-apple-darwin
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+          cache-dependency-path: '**/requirements.dev.txt'
+      - run: pip install -r python/requirements.dev.txt
+      - run: maturin build --release --features abi3
+        working-directory: ./python
+      - run: pip install --no-index --find-links=target/wheels/ pyoxigraph
+      - run: rm -r target/wheels
+      - run: python generate_stubs.py pyoxigraph pyoxigraph.pyi --ruff
+        working-directory: ./python
+      - run: maturin build --release --target universal2-apple-darwin --features abi3
+        working-directory: ./python
+      - run: maturin build --release --features abi3
+        working-directory: ./python
+        if: github.event_name == 'release'
+      - run: maturin build --release --target aarch64-apple-darwin --features abi3
+        working-directory: ./python
+        if: github.event_name == 'release'
+      - uses: actions/upload-artifact@v4
         with:
-          name: pyoxigraph_wheel_universal2_mac
+          name: pyoxigraph_macos
           path: target/wheels/*.whl
 
   wheel_windows:
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           submodules: true
-      - uses: actions/setup-python@v2
+      - uses: ./.github/actions/setup-rust
+      - uses: actions/setup-python@v5
         with:
-          python-version: 3.7
-      - run: rustup update
+          python-version: "3.12"
+          cache: pip
+          cache-dependency-path: '**/requirements.dev.txt'
       - run: Remove-Item -LiteralPath "C:\msys64\" -Force -Recurse
-      - run: pip install maturin
-      - run: maturin build --release -m python/Cargo.toml
-      - uses: actions/upload-artifact@v2
+      - run: pip install -r python/requirements.dev.txt
+      - run: maturin build --release --features abi3
+        working-directory: ./python
+      - run: pip install --no-index --find-links=target/wheels/ pyoxigraph
+      - run: rm -r target/wheels
+      - run: python generate_stubs.py pyoxigraph pyoxigraph.pyi --ruff
+        working-directory: ./python
+      - run: maturin build --release -m python/Cargo.toml --features abi3
+      - uses: actions/upload-artifact@v4
         with:
-          name: pyoxigraph_wheel_x86_64_windows
+          name: pyoxigraph_windows
           path: target/wheels/*.whl
 
+  publish_pypi:
+    if: github.event_name == 'release'
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/pyoxigraph
+    permissions:
+      id-token: write
+    needs:
+      - python_sdist
+      - wheel_windows
+      - wheel_mac
+      - wheel_linux
+      - wheel_linux_musl
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: pyoxigraph_*
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist
+          skip-existing: true
+
   npm_tarball:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - run: rustup update
-      - run: cargo install wasm-pack
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+      - uses: taiki-e/install-action@v2
+        with: { tool: wasm-pack }
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 16
+          cache: npm
+          cache-dependency-path: "js/package.json"
+          registry-url: https://registry.npmjs.org
       - run: npm run pack
         working-directory: ./js
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v4
         with:
           name: oxigraph_wasm_npm
           path: js/*.tgz
+      - run: npm run release
+        working-directory: ./js
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        if: github.event_name == 'release'
 
   docker:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
-          submodules: 'recursive'
-      - uses: docker/setup-buildx-action@v1
-      - uses: docker/login-action@v1
+          submodules: true
+      - uses: docker/setup-buildx-action@v3
+      - uses: docker/login-action@v3
         with:
           registry: ghcr.io
           username: ${{github.actor}}
           password: ${{secrets.GITHUB_TOKEN}}
-      - uses: docker/metadata-action@v3
+      - uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+        if: github.event_name == 'release'
+      - uses: docker/metadata-action@v5
         id: docker_meta
         with:
-          images: ghcr.io/${{ github.repository }}
-          tags: nightly
-      - uses: docker/build-push-action@v2
+          images: |
+            ${{ github.repository }},enable=${{ github.event_name == 'release' }}
+            ghcr.io/${{ github.repository }}
+          tags: |
+            type=ref,event=branch
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+      - uses: docker/build-push-action@v5
         with:
           context: .
           file: server/Dockerfile
+          platforms: linux/amd64,linux/arm64
           pull: true
           push: true
           tags: ${{ steps.docker_meta.outputs.tags }}
           labels: ${{ steps.docker_meta.outputs.labels }}
           cache-from: type=gha
           cache-to: type=gha,mode=max
+
+  publish_crates:
+    if: github.event_name == 'release'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - run: rustup update
+      - run: cargo login $CRATES_IO_TOKEN
+        env:
+          CRATES_IO_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}
+      - run: cargo publish
+        working-directory: ./oxrocksdb-sys
+        continue-on-error: true
+      - run: cargo publish
+        working-directory: ./lib/oxsdatatypes
+        continue-on-error: true
+      - run: cargo publish
+        working-directory: ./lib/oxrdf
+        continue-on-error: true
+      - run: cargo publish
+        working-directory: ./lib/oxrdfxml
+        continue-on-error: true
+      - run: cargo publish
+        working-directory: ./lib/oxttl
+        continue-on-error: true
+      - run: cargo publish
+        working-directory: ./lib/oxrdfio
+        continue-on-error: true
+      - run: cargo publish
+        working-directory: ./lib/sparesults
+        continue-on-error: true
+      - run: cargo publish
+        working-directory: ./lib/spargebra
+        continue-on-error: true
+      - run: cargo publish
+        working-directory: ./lib/sparopt
+        continue-on-error: true
+      - run: cargo publish
+        working-directory: ./lib/sparql-smith
+        continue-on-error: true
+      - run: cargo publish
+        working-directory: ./lib/oxigraph
+        continue-on-error: true
+      - run: cargo publish
+        working-directory: ./cli
+
+  homebrew:
+    if: "github.event_name == 'release' && !contains('-', github.event.release.tag_name)"
+    runs-on: ubuntu-latest
+    needs: full_archive
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          repository: oxigraph/homebrew-oxigraph
+          token: ${{ secrets.FULL_ACCESS_TOKEN }}
+      - run: |
+          wget "https://github.com/oxigraph/oxigraph/releases/download/${{ github.event.release.tag_name }}/oxigraph_${{ github.event.release.tag_name }}.tar.gz"
+          SHA=`shasum -a 256 "oxigraph_${{ github.event.release.tag_name }}.tar.gz" | awk '{ print $1 }'`
+          rm "oxigraph_${{ github.event.release.tag_name }}.tar.gz"
+          sed -i "s/download\/.*\.tar/download\/${{ github.event.release.tag_name }}\/oxigraph_${{ github.event.release.tag_name }}.tar/g" Formula/oxigraph.rb
+          sed -i "s/sha256 \".*\"/sha256 \"$SHA\"/g" Formula/oxigraph.rb
+          git config user.name github-actions
+          git config user.email github-actions@github.com
+          git add .
+          git diff-index --quiet HEAD || git commit -m "Upgrades to ${{ github.event.release.tag_name }}"
+          git push
+
+  full_archive:
+    if: github.event_name == 'release'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - run: |
+          rm -rf .git bench fuzz
+          zip -r oxigraph_${{ github.event.release.tag_name }}.zip .
+          tar -czf /tmp/oxigraph_${{ github.event.release.tag_name }}.tar.gz .
+          mv /tmp/oxigraph_${{ github.event.release.tag_name }}.tar.gz .
+      - uses: softprops/action-gh-release@v1
+        with:
+          files: |
+            oxigraph_${{ github.event.release.tag_name }}.zip
+            oxigraph_${{ github.event.release.tag_name }}.tar.gz

.github/workflows/install_rocksdb.sh

@@ -0,0 +1,11 @@
+if [ -f "rocksdb" ]
+then
+  cd rocksdb || exit
+else
+  git clone https://github.com/facebook/rocksdb.git
+  cd rocksdb || exit
+  git checkout v8.0.0
+  make shared_lib
+fi
+sudo make install-shared
+sudo ldconfig /usr/local/lib

.github/workflows/manylinux_build.sh

@@ -2,7 +2,23 @@ cd /workdir
 yum -y install centos-release-scl-rh
 yum -y install llvm-toolset-7.0
 source scl_source enable llvm-toolset-7.0
-curl https://sh.rustup.rs -sSf | sh -s -- -y --profile minimal
-curl --verbose -L "https://github.com/PyO3/maturin/releases/latest/download/maturin-%arch%-unknown-linux-musl.tar.gz" | tar -xz -C /usr/local/bin
-export PATH="${PATH}:/root/.cargo/bin:/opt/python/cp37-cp37m/bin:/opt/python/cp38-cp38/bin:/opt/python/cp39-cp39/bin:/opt/python/cp310-cp310/bin"
-maturin build --release --no-sdist -m python/Cargo.toml
+curl https://static.rust-lang.org/rustup/dist/%arch%-unknown-linux-gnu/rustup-init --output rustup-init
+chmod +x rustup-init
+./rustup-init -y --profile minimal
+source "$HOME/.cargo/env"
+export PATH="${PATH}:/opt/python/cp37-cp37m/bin:/opt/python/cp38-cp38/bin:/opt/python/cp39-cp39/bin:/opt/python/cp310-cp310/bin:/opt/python/cp311-cp311/bin"
+cd python
+python3.12 -m venv venv
+source venv/bin/activate
+pip install -r requirements.dev.txt
+maturin develop --release
+python generate_stubs.py pyoxigraph pyoxigraph.pyi --ruff
+maturin build --release --features abi3 --compatibility manylinux2014
+if [ %for_each_version% ]; then
+  for VERSION in 8 9 10 11 12; do
+    maturin build --release --interpreter "python3.$VERSION" --compatibility manylinux2014
+  done
+  for VERSION in 9 10; do
+    maturin build --release --interpreter "pypy3.$VERSION" --compatibility manylinux2014
+  done
+fi

.github/workflows/musllinux_build.sh

@@ -0,0 +1,19 @@
+cd /workdir
+apk add clang-dev
+curl https://static.rust-lang.org/rustup/dist/%arch%-unknown-linux-musl/rustup-init --output rustup-init
+chmod +x rustup-init
+./rustup-init -y --profile minimal
+source "$HOME/.cargo/env"
+export PATH="${PATH}:/opt/python/cp37-cp37m/bin:/opt/python/cp38-cp38/bin:/opt/python/cp39-cp39/bin:/opt/python/cp310-cp310/bin:/opt/python/cp311-cp311/bin"
+cd python
+python3.12 -m venv venv
+source venv/bin/activate
+pip install -r requirements.dev.txt
+maturin develop --release
+python generate_stubs.py pyoxigraph pyoxigraph.pyi --ruff
+maturin build --release --features abi3 --compatibility musllinux_1_2
+if [ %for_each_version% ]; then
+  for VERSION in 8 9 10 11 12; do
+    maturin build --release --interpreter "python3.$VERSION" --compatibility musllinux_1_2
+  done
+fi

.github/workflows/release.yml

@@ -1,286 +0,0 @@
-name: Release artifacts
-
-on:
-  release:
-    types: [ published ]
-
-jobs:
-  push_server_to_docker_registry:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - uses: docker/setup-buildx-action@v1
-      - uses: docker/metadata-action@v3
-        id: docker_meta
-        with:
-          images: |
-            ${{ github.repository }}
-            ghcr.io/${{ github.repository }}
-      - uses: docker/login-action@v1
-        with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-      - uses: docker/login-action@v1
-        with:
-          registry: ghcr.io
-          username: ${{github.actor}}
-          password: ${{secrets.GITHUB_TOKEN}}
-      - uses: docker/build-push-action@v2
-        with:
-          context: .
-          file: server/Dockerfile
-          pull: true
-          push: true
-          tags: ${{ steps.docker_meta.outputs.tags }}
-          labels: ${{ steps.docker_meta.outputs.labels }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-
-  publish_crates:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - run: rustup update
-      - run: cargo login $CRATES_IO_TOKEN
-        env:
-          CRATES_IO_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}
-      - run: cargo publish
-        working-directory: ./oxrocksdb-sys
-      - run: cargo publish
-        working-directory: ./lib/oxrdf
-      - run: sleep 60
-      - run: cargo publish
-        working-directory: ./lib/sparesults
-      - run: cargo publish
-        working-directory: ./lib/spargebra
-      - run: sleep 60
-      - run: cargo publish
-        working-directory: ./lib
-      - run: sleep 60
-      - run: cargo publish
-        working-directory: ./server
-
-  publish_pypi_linux:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        architecture: [ "x86_64", "aarch64" ]
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - uses: docker/setup-qemu-action@v1
-        with:
-          platforms: linux/${{ matrix.architecture }}
-        if: matrix.architecture != 'x86_64'
-      - run: sed 's/%arch%/${{ matrix.architecture }}/g' .github/workflows/manylinux_build.sh > .github/workflows/manylinux_build_script.sh
-      - run: docker run -v "$(pwd)":/workdir --platform linux/${{ matrix.architecture }} quay.io/pypa/manylinux2014_${{ matrix.architecture }} /bin/bash /workdir/.github/workflows/manylinux_build_script.sh
-      - uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          user: __token__
-          password: ${{ secrets.PYPI_PASSWORD }}
-          packages_dir: target/wheels
-      - uses: softprops/action-gh-release@v1
-        with:
-          files: target/wheels/*
-
-  publish_pypi_mac:
-    runs-on: macos-latest
-    env:
-      DEVELOPER_DIR: '/Applications/Xcode.app/Contents/Developer'
-      SDKROOT: '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk'
-      MACOSX_DEPLOYMENT_TARGET: '10.14'
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - uses: actions/setup-python@v2
-        with:
-          python-version: 3.7
-      - run: rustup update && rustup target add aarch64-apple-darwin
-      - run: pip install maturin
-      - run: maturin publish --no-sdist --universal2 -m python/Cargo.toml -u __token__ -p ${{ secrets.PYPI_PASSWORD }}
-      - run: maturin publish --no-sdist -m python/Cargo.toml -u __token__ -p ${{ secrets.PYPI_PASSWORD }}
-      - uses: softprops/action-gh-release@v1
-        with:
-          files: target/wheels/*
-
-  publish_pypi_windows:
-    runs-on: windows-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - uses: actions/setup-python@v2
-        with:
-          python-version: 3.7
-      - run: rustup update
-      - run: pip install maturin
-      - run: Remove-Item -LiteralPath "C:\msys64\" -Force -Recurse
-      - run: maturin publish --no-sdist -m python/Cargo.toml -u __token__ -p ${{ secrets.PYPI_PASSWORD }}
-      - uses: softprops/action-gh-release@v1
-        with:
-          files: target/wheels/*
-
-  publish_pypi_stdist:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - run: pip install maturin
-      - run: maturin sdist -m python/Cargo.toml
-      - uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          user: __token__
-          password: ${{ secrets.PYPI_PASSWORD }}
-          packages_dir: target/wheels
-      - uses: softprops/action-gh-release@v1
-        with:
-          files: target/wheels/*
-
-  publish_npm:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - uses: actions/setup-node@v2
-        with:
-          node-version: 14
-          registry-url: https://registry.npmjs.org
-      - run: rustup update
-      - run: cargo install wasm-pack
-      - run: npm install
-        working-directory: ./js
-      - run: npm run release
-        working-directory: ./js
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-      - run: npm run pack
-        working-directory: ./js
-      - uses: softprops/action-gh-release@v1
-        with:
-          files: js/*.tgz
-
-  publish_python_doc:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - run: rustup update
-      - uses: actions/setup-python@v2
-        with:
-          python-version: 3.8
-      - run: python -m venv python/venv
-      - run: source python/venv/bin/activate && pip install --upgrade maturin sphinx
-      - run: source venv/bin/activate && maturin develop
-        working-directory: ./python
-      - run: source ../venv/bin/activate && sphinx-build -M doctest . build
-        working-directory: ./python/docs
-      - run: source ../venv/bin/activate && sphinx-build -M html . build
-        working-directory: ./python/docs
-      - uses: actions/checkout@v2
-        with:
-          repository: oxigraph/oxigraph.github.io
-          path: website
-          token: ${{ secrets.FULL_ACCESS_TOKEN }}
-      - run: echo "RELEASE_VERSION=$(echo ${GITHUB_REF:10})" >> $GITHUB_ENV
-      - run: rm -rf ./website/pyoxigraph/stable && mkdir -p ./website/pyoxigraph/stable && cp -r ./python/docs/build/html/* ./website/pyoxigraph/stable/
-        if: "!contains('-', github.event.release.tag_name)"
-      - run: mkdir -p ./website/pyoxigraph/$RELEASE_VERSION && cp -r ./python/docs/build/html/* ./website/pyoxigraph/$RELEASE_VERSION/
-      - run: |
-          git config user.name github-actions
-          git config user.email github-actions@github.com
-          git add .
-          git diff-index --quiet HEAD || git commit -m "Updates pyoxigraph documentation"
-          git push
-        working-directory: ./website
-
-  publish_full_archive:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - run: |
-          zip -r oxigraph_${{ github.event.release.tag_name }}.zip .
-          tar -czf /tmp/oxigraph_${{ github.event.release.tag_name }}.tar.gz .
-          mv /tmp/oxigraph_${{ github.event.release.tag_name }}.tar.gz .
-      - uses: softprops/action-gh-release@v1
-        with:
-          files: |
-            oxigraph_${{ github.event.release.tag_name }}.zip
-            oxigraph_${{ github.event.release.tag_name }}.tar.gz
-
-  publish_homebrew:
-    if: "!contains('-', github.event.release.tag_name)"
-    runs-on: ubuntu-latest
-    needs: publish_full_archive
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          repository: oxigraph/homebrew-oxigraph
-          token: ${{ secrets.FULL_ACCESS_TOKEN }}
-      - run: |
-          wget "https://github.com/oxigraph/oxigraph/releases/download/${{ github.event.release.tag_name }}/oxigraph_${{ github.event.release.tag_name }}.tar.gz"
-          SHA=`shasum -a 256 "oxigraph_${{ github.event.release.tag_name }}.tar.gz" | awk '{ print $1 }'`
-          rm "oxigraph_${{ github.event.release.tag_name }}.tar.gz"
-          sed -i "s/download\/.*\.tar/download\/${{ github.event.release.tag_name }}\/oxigraph_${{ github.event.release.tag_name }}.tar/g" Formula/oxigraph.rb
-          sed -i "s/sha256 \".*\"/sha256 \"$SHA\"/g" Formula/oxigraph.rb
-          git config user.name github-actions
-          git config user.email github-actions@github.com
-          git add .
-          git diff-index --quiet HEAD || git commit -m "Upgrades to ${{ github.event.release.tag_name }}"
-          git push
-
-  publish_binary_linux:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - run: cargo build --release
-        working-directory: ./server
-      - run: mv target/release/oxigraph_server oxigraph_server_${{ github.event.release.tag_name }}_x86_64_linux_gnu
-      - uses: softprops/action-gh-release@v1
-        with:
-          files: oxigraph_server_${{ github.event.release.tag_name }}_x86_64_linux_gnu
-
-  publish_binary_mac:
-    runs-on: macos-latest
-    env:
-      DEVELOPER_DIR: '/Applications/Xcode.app/Contents/Developer'
-      SDKROOT: '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk'
-      MACOSX_DEPLOYMENT_TARGET: '10.14'
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - run: rustup update
-      - run: cargo build --release
-        working-directory: ./server
-      - run: mv target/release/oxigraph_server oxigraph_server_${{ github.event.release.tag_name }}_x86_64_apple
-      - uses: softprops/action-gh-release@v1
-        with:
-          files: oxigraph_server_${{ github.event.release.tag_name }}_x86_64_apple
-
-  publish_binary_windows:
-    runs-on: windows-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - run: rustup update
-      - run: Remove-Item -LiteralPath "C:\msys64\" -Force -Recurse
-      - run: cargo build --release
-        working-directory: ./server
-      - run: mv target/release/oxigraph_server.exe oxigraph_server_${{ github.event.release.tag_name }}_x86_64_windows_msvc.exe
-      - uses: softprops/action-gh-release@v1
-        with:
-          files: oxigraph_server_${{ github.event.release.tag_name }}_x86_64_windows_msvc.exe

.github/workflows/tests.yml

@@ -1,79 +1,276 @@
 name: Change tests
 
 on:
-  push:
-    branches:
-      - main
   pull_request:
     branches:
       - main
+      - next
   schedule:
-    - cron: "0 0 * * 0"
+    - cron: "12 3 * * *"
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
 jobs:
   fmt:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - run: rustup update && rustup component add rustfmt
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/setup-rust
+        with:
+          component: rustfmt
       - run: cargo fmt -- --check
 
   clippy:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+        with:
+          version: 1.76.0
+          component: clippy
+      - run: cargo clippy --all-targets -- -D warnings -D clippy::all
+        working-directory: ./lib/oxsdatatypes
+      - run: cargo clippy --all-targets -- -D warnings -D clippy::all
+        working-directory: ./lib/oxrdf
+      - run: cargo clippy --all-targets -- -D warnings -D clippy::all
+        working-directory: ./lib/oxrdfxml
+      - run: cargo clippy --all-targets -- -D warnings -D clippy::all
+        working-directory: ./lib/oxttl
+      - run: cargo clippy --all-targets -- -D warnings -D clippy::all
+        working-directory: ./lib/oxrdfio
+      - run: cargo clippy --all-targets --features async-tokio -- -D warnings -D clippy::all
+        working-directory: ./lib/oxrdfio
+      - run: cargo clippy --all-targets -- -D warnings -D clippy::all
+        working-directory: ./lib/sparesults
+      - run: cargo clippy --all-targets --features async-tokio -- -D warnings -D clippy::all
+        working-directory: ./lib/sparesults
+      - run: cargo clippy --all-targets -- -D warnings -D clippy::all
+        working-directory: ./lib/spargebra
+      - run: cargo clippy --all-targets -- -D warnings -D clippy::all
+        working-directory: ./lib/sparopt
+      - run: cargo clippy --all-targets --no-default-features -- -D warnings -D clippy::all
+        working-directory: ./lib/oxigraph
+      - run: cargo clippy --all-targets -- -D warnings -D clippy::all
+        working-directory: ./lib/oxigraph
+      - run: cargo clippy --all-targets -- -D warnings -D clippy::all
+        working-directory: ./python
+      - run: cargo clippy --all-targets -- -D warnings -D clippy::all
+        working-directory: ./cli
+      - run: cargo clippy --all-targets -- -D warnings -D clippy::all
+        working-directory: ./testsuite
+
+  clippy_wasm_js:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+        with:
+          version: 1.76.0
+          target: wasm32-unknown-unknown
+          component: clippy
+      - run: cargo clippy --lib --tests --target wasm32-unknown-unknown -- -D warnings -D clippy::all
+        working-directory: ./js
+
+  clippy_wasi:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+        with:
+          version: 1.76.0
+          target: wasm32-wasi
+          component: clippy
+      - run: cargo clippy --lib --tests --target wasm32-wasi -- -D warnings -D clippy::all
+        working-directory: ./lib/oxigraph
+      - run: cargo clippy --target wasm32-wasi --features abi3 --no-default-features -- -D warnings -D clippy::all
+        working-directory: ./python
+
+  clippy_wasm_emscripten:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
         with:
           submodules: true
-      - run: rustup update && rustup component add clippy
-      - run: cargo clippy --all-targets --all-features
+      - uses: ./.github/actions/setup-rust
+        with:
+          version: 1.76.0
+          target: wasm32-unknown-emscripten
+          component: clippy
+      - run: cargo clippy --lib --tests --target wasm32-unknown-emscripten -- -D warnings -D clippy::all
+        working-directory: ./lib/oxigraph
+      - run: cargo clippy --target wasm32-unknown-emscripten --features abi3 -- -D warnings -D clippy::all
+        working-directory: ./python
+
+  clippy_wasm_unknown:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+        with:
+          version: 1.76.0
+          target: wasm32-unknown-unknown
+          component: clippy
+      - run: cargo clippy --lib --tests --target wasm32-unknown-unknown --features getrandom/custom --features oxsdatatypes/custom-now -- -D warnings -D clippy::all
+        working-directory: ./lib/oxigraph
 
   deny:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: EmbarkStudios/cargo-deny-action@v1
+      - uses: actions/checkout@v4
+      - uses: taiki-e/install-action@v2
+        with: { tool: cargo-deny }
+      - run: cargo deny check
 
-  test_linux:
+  semver_checks:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           submodules: true
-      - run: rustup update
-      - run: cargo test --all-features
-        env:
-          RUST_BACKTRACE: 1
+      - uses: ./.github/actions/setup-rust
+      - uses: taiki-e/install-action@v2
+        with: { tool: cargo-semver-checks }
+      - uses: actions/cache@v4
+        with:
+          path: rocksdb
+          key: ${{ runner.os }}-rocksdb-8.0.0
+      - run: bash .github/workflows/install_rocksdb.sh
+      - run: cargo semver-checks check-release --exclude oxrocksdb-sys --exclude oxigraph-js --exclude pyoxigraph --exclude oxigraph-testsuite --exclude oxigraph-cli
+
+  test_linux_x86_64:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+      - run: cargo test
+
+  test_linux_i686:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+        with:
+          target: i686-unknown-linux-gnu
+      - run: sudo apt-get update && sudo apt-get install -y g++-multilib
+      - run: cargo test --target i686-unknown-linux-gnu --no-default-features --features http-client-rustls-native
+        working-directory: ./lib/oxigraph
 
-  address_sanitizer:
+  test_linux_msv:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           submodules: true
-      - run: rustup update && rustup toolchain install nightly
-      - run: cargo +nightly test --tests --target x86_64-unknown-linux-gnu --workspace --exclude pyoxigraph --exclude oxigraph_testsuite
+      - name: Read MSRV from Cargo.toml
+        id: metadata
+        run: echo "rust-version=$(sed -ne 's/rust-version *= *\"\(.*\)\"/\1/p' Cargo.toml)" >> $GITHUB_OUTPUT
+      - uses: ./.github/actions/setup-rust
+        with:
+          version: ${{ steps.metadata.outputs.rust-version }}
+      - run: rustup toolchain install nightly
+      - run: rm Cargo.lock && cargo +nightly update -Z direct-minimal-versions && cargo update -p bumpalo --precise 3.14.0
+      - run: cargo test
+
+  test_linux_latest:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+      - run: rm Cargo.lock && cargo update
+      - run: cargo test
+
+  test_linux_address_sanitizer:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+        with:
+          version: nightly
+      - run: sudo apt-get update && sudo apt-get install -y llvm
+      - run: cargo test --tests --target x86_64-unknown-linux-gnu --workspace --exclude pyoxigraph --exclude oxigraph-testsuite --exclude oxigraph-cli
         env:
-          RUST_BACKTRACE: 1
           RUSTFLAGS: -Z sanitizer=address
 
+  test_linux_dynamic_linking:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+      - uses: actions/cache@v4
+        with:
+          path: rocksdb
+          key: ${{ runner.os }}-rocksdb-8.0.0
+      - run: bash .github/workflows/install_rocksdb.sh
+      - run: cargo test --tests --features oxrocksdb-sys/pkg-config
+
   test_windows:
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           submodules: true
-      - run: rustup update
+      - uses: ./.github/actions/setup-rust
       - run: Remove-Item -LiteralPath "C:\msys64\" -Force -Recurse
-      - run: cargo test --all-features
+      - run: cargo test
+
+  test_wasi:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+        with:
+          target: wasm32-wasi
+      - uses: taiki-e/install-action@v2
+        with: { tool: "wasmtime,cargo-wasi" }
+      - run: cargo wasi test --workspace --exclude oxigraph-js --exclude oxigraph-cli --exclude oxigraph-testsuite --exclude oxrocksdb-sys --exclude pyoxigraph
+
+  rustdoc:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+        with:
+          version: 1.76.0
+      - run: cargo doc
         env:
-          RUST_BACKTRACE: 1
+          RUSTDOCFLAGS: -D warnings
 
   js:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - run: rustup update
-      - run: cargo install wasm-pack
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/setup-rust
+      - uses: taiki-e/install-action@v2
+        with: { tool: wasm-pack }
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 18
+          cache: npm
+          cache-dependency-path: "js/package.json"
       - run: npm install
         working-directory: ./js
       - run: npm test
@@ -82,19 +279,258 @@ jobs:
   python:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           submodules: true
-      - run: rustup update
-      - uses: actions/setup-python@v2
+      - uses: ./.github/actions/setup-rust
+      - uses: actions/setup-python@v5
         with:
-          python-version: "3.10"
-      - run: pip install --upgrade maturin sphinx
-      - run: maturin sdist -m python/Cargo.toml
-      - run: pip install target/wheels/*.tar.gz
+          python-version: "3.12"
+          cache: pip
+          cache-dependency-path: '**/requirements.dev.txt'
+      - run: pip install -r python/requirements.dev.txt
+      - run: maturin build -m python/Cargo.toml
+      - run: pip install --no-index --find-links=target/wheels/ pyoxigraph
+      - run: rm -r target/wheels
       - run: python -m unittest
         working-directory: ./python/tests
-      - run: sphinx-build -M doctest . build
-        working-directory: ./python/docs
       - run: sphinx-build -M html . build
         working-directory: ./python/docs
+      - run: python generate_stubs.py pyoxigraph pyoxigraph.pyi --ruff
+        working-directory: ./python
+      - run: python -m mypy.stubtest pyoxigraph  --allowlist=mypy_allowlist.txt
+        working-directory: ./python
+      - run: python -m mypy generate_stubs.py tests --strict
+        working-directory: ./python
+      - run: python -m ruff format --check .
+        working-directory: ./python
+      - run: python -m ruff check --output-format=github .
+        working-directory: ./python
+      - run: sphinx-lint docs
+        working-directory: ./python
+
+  python_msv:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - name: Read MSRV from Cargo.toml
+        id: metadata
+        run: echo "rust-version=$(sed -ne 's/rust-version *= *\"\(.*\)\"/\1/p' Cargo.toml)" >> $GITHUB_OUTPUT
+      - uses: ./.github/actions/setup-rust
+        with:
+          version: ${{ steps.metadata.outputs.rust-version }}
+      - run: rustup toolchain install nightly
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.8"
+          cache: pip
+          cache-dependency-path: '**/requirements.dev.txt'
+      - run: pip install -r python/requirements.dev.txt
+      - run: rm Cargo.lock && cargo +nightly update -Z direct-minimal-versions
+      - run: maturin build -m python/Cargo.toml
+      - run: pip install --no-index --find-links=target/wheels/ pyoxigraph
+      - run: rm -r target/wheels
+      - run: python -m unittest
+        working-directory: ./python/tests
+
+  python_pypy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "pypy3.10"
+          cache: pip
+          cache-dependency-path: '**/requirements.dev.txt'
+      - run: pip install -r python/requirements.dev.txt
+      - run: maturin build -m python/Cargo.toml
+      - run: pip install --no-index --find-links=target/wheels/ pyoxigraph
+      - run: rm -r target/wheels
+      - run: python -m unittest
+        working-directory: ./python/tests
+
+  python_windows:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+          cache-dependency-path: '**/requirements.dev.txt'
+      - run: pip install "maturin~=1.0"
+      - run: maturin build -m python/Cargo.toml
+      - run: pip install --no-index --find-links=target/wheels/ pyoxigraph
+      - run: rm -r target/wheels
+      - run: python -m unittest
+        working-directory: ./python/tests
+
+  python_pyodide:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+          cache: pip
+          cache-dependency-path: '**/requirements.dev.txt'
+      - uses: ./.github/actions/setup-rust
+        with:
+          version: nightly
+          target: wasm32-unknown-emscripten
+      - run: |
+          pip install pyodide-build
+          echo EMSCRIPTEN_VERSION=$(pyodide config get emscripten_version) >> $GITHUB_ENV
+      - uses: mymindstorm/setup-emsdk@v13
+        with:
+          version: ${{ env.EMSCRIPTEN_VERSION }}
+      - run: pyodide build
+        working-directory: ./python
+      - run: |
+          pyodide venv venv
+          source venv/bin/activate
+          pip install --no-index --find-links=../dist/ pyoxigraph
+          python -m unittest
+        working-directory: ./python/tests
+
+  typos:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: taiki-e/install-action@v2
+        with: { tool: typos-cli }
+      - run: typos
+
+  clang_fmt:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: sudo apt-get update && sudo apt-get install -y clang-format
+      - run: clang-format --Werror --dry-run oxrocksdb-sys/api/*
+
+  fuzz_changes:
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: google/clusterfuzzlite/actions/build_fuzzers@v1
+        with:
+          language: rust
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          sanitizer: address
+          storage-repo: https://${{ secrets.FULL_ACCESS_TOKEN }}@github.com/oxigraph/clusterfuzzlite-oxigraph.git
+      - uses: google/clusterfuzzlite/actions/run_fuzzers@v1
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          fuzz-seconds: 900
+          mode: code-change
+          sanitizer: address
+          minimize-crashes: true
+          parallel-fuzzing: true
+          storage-repo: https://${{ secrets.FULL_ACCESS_TOKEN }}@github.com/oxigraph/clusterfuzzlite-oxigraph.git
+
+  fuzz_repo:
+    if: github.event_name != 'pull_request'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: google/clusterfuzzlite/actions/build_fuzzers@v1
+        with:
+          language: rust
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          sanitizer: address
+      - uses: google/clusterfuzzlite/actions/run_fuzzers@v1
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          fuzz-seconds: 7200
+          mode: batch
+          sanitizer: address
+          minimize-crashes: true
+          parallel-fuzzing: true
+          storage-repo: https://${{ secrets.FULL_ACCESS_TOKEN }}@github.com/oxigraph/clusterfuzzlite-oxigraph.git
+        continue-on-error: true
+      - uses: google/clusterfuzzlite/actions/run_fuzzers@v1
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          fuzz-seconds: 3600
+          mode: prune
+          storage-repo: https://${{ secrets.FULL_ACCESS_TOKEN }}@github.com/oxigraph/clusterfuzzlite-oxigraph.git
+        continue-on-error: true
+
+  fuzz_coverage:
+    if: github.event_name != 'pull_request'
+    needs: fuzz_repo
+    runs-on: ubuntu-latest
+    steps:
+      - uses: google/clusterfuzzlite/actions/build_fuzzers@v1
+        with:
+          language: rust
+          sanitizer: coverage
+      - uses: google/clusterfuzzlite/actions/run_fuzzers@v1
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          fuzz-seconds: 3600
+          mode: coverage
+          sanitizer: coverage
+          storage-repo: https://${{ secrets.FULL_ACCESS_TOKEN }}@github.com/oxigraph/clusterfuzzlite-oxigraph.git
+
+  shellcheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: sudo apt-get update && sudo apt-get install -y shellcheck
+      - run: git grep -l '^#\( *shellcheck \|!\(/bin/\|/usr/bin/env \)\(sh\|bash\|dash\|ksh\)\)' | xargs shellcheck
+
+  spec_links:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: python lints/test_spec_links.py
+
+  debian_compatibility:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/setup-rust
+      - run: python lints/test_debian_compatibility.py
+
+  codspeed:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+      - uses: taiki-e/install-action@v2
+        with: { tool: cargo-codspeed }
+      - run: cargo codspeed build -p oxigraph --features http-client-native-tls
+      - run: cargo codspeed build -p oxigraph-testsuite
+      - uses: CodSpeedHQ/action@v2
+        with:
+          run: cargo codspeed run
+          token: ${{ secrets.CODSPEED_TOKEN }}
+
+  codecov:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: ./.github/actions/setup-rust
+      - uses: taiki-e/install-action@v2
+        with: { tool: cargo-llvm-cov }
+      - run: cargo llvm-cov --codecov --output-path codecov.json
+      - uses: codecov/codecov-action@v4
+        with:
+          files: codecov.json
+          flags: rust
+          fail_ci_if_error: true
+          token: ${{ secrets.CODECOV_TOKEN }}

.gitignore

@@ -8,4 +8,9 @@ lib/tests/rocksdb_bc_data
 venv
 .env
 data/
-.htpasswd
+.htpasswd
+**/docs/_build
+**/docs/build
+*.so
+*.pyc
+**.pyi

.gitmodules

@@ -7,9 +7,13 @@
 [submodule "bench/bsbm-tools"]
 	path = bench/bsbm-tools
 	url = https://github.com/Tpt/bsbm-tools.git
-[submodule "oxrocksdb-sys/rocksdb"]
-	path = oxrocksdb-sys/rocksdb
-	url = https://github.com/facebook/rocksdb.git
 [submodule "oxrocksdb-sys/lz4"]
 	path = oxrocksdb-sys/lz4
 	url = https://github.com/lz4/lz4.git
+[submodule "testsuite/N3"]
+	path = testsuite/N3
+	url = https://github.com/w3c/N3.git
+	branch = master
+[submodule "testsuite/rdf-canon"]
+	path = testsuite/rdf-canon
+	url = https://github.com/w3c/rdf-canon.git

.mailmap

@@ -0,0 +1,3 @@
+Thomas Tanon <thomas@pellissier-tanon.fr> <thomaspt@hotmail.fr> <Tpt@users.noreply.github.com>
+Thomas Tanon <thomas@pellissier-tanon.fr>
+Thomas Tanon <thomas.pellissier-tanon@helsing.ai>

.readthedocs.yaml

@@ -0,0 +1,21 @@
+version: 2
+
+sphinx:
+  builder: html
+
+build:
+  os: "ubuntu-22.04"
+  tools:
+    python: "3"
+    rust: "1.70"
+  apt_packages:
+    - clang
+
+python:
+  install:
+    - requirements: python/requirements.dev.txt
+    - method: pip
+      path: python
+
+submodules:
+  include: all

CHANGELOG.md

@@ -1,3 +1,377 @@
+## [0.4.0-alpha.6] - 2024-03-25
+
+### Changed
+- Fixes compatibility with OxIRI 0.2.3.
+
+
+## [0.4.0-alpha.5] - 2024-03-23
+
+### Added
+- Python: `Dataset` class
+
+### Changed
+- Rust: `Dataset::canonicalize` and `Graph::canonicalize` takes for input a `CanonicalizationAlgorithm` to set which algorithm to use.
+- Upgrades RocksDB to 9.0.0
+- JS: Drops NodeJS 12-16 and older web browsers (Edge before Chromium...) support.
+
+
+## [0.4.0-alpha.4] - 2024-03-07
+
+### Added
+- Rust: `From<spargebra::Update` on `Update`.
+- `sparesults`: Tokio Async readers for SPARQL query results (XML, JSON and TSV).
+- `oxrdf`: `Term::from_terms` constructor.
+- JS: options to set query and update base IRI and query union default graph.
+
+## Changed
+- Uses RocksDB atomic multi-columns flush.
+- Rust: RocksDB is optional but enabled by default.
+- Upgrades RocksDB to 8.11.3.
+- Rust: `oxigraph` crate has been moved to `lib/oxigraph`.
+- Rust: `QueryResults::write` returns the `Write` impl and not `()`.
+- Rust: use `thierror` for errors.
+- Rust: rename `oxrdfio::{Parse,Syntax}Error` to `oxrdfio::Rdf{Parse,Syntax}Error`,
+  `oxrdfxml::{Parse,Syntax}Error` to `oxrdfxml::RdfXml{Parse,Syntax}Error`,
+  `oxttl::{Parse,Syntax}Error` to `oxttl::Turtle{Parse,Syntax}Error`,
+  `sparesults::{Parse,Syntax}Error` to `sparesults::QueryResults{Parse,Syntax}Error` and
+  `spargebra::SyntaxError` to `spargebra::SparqlSyntaxError`.
+
+
+## [0.4.0-alpha.3] - 2024-01-25
+
+### Added
+- `oxttl`: expose base IRIs.
+- `oxttl`: allows to inject prefixes for serialization.
+- `oxrdf`: `vocab::geosparql::WKT_LITERAL`.
+
+### Changed
+- Turtle: Fixes parsing bug with escaped dot at the end of local name.
+- `oxttl`: Changes `prefixes` getter return type. 
+- JS: simplify build.
+- Python: uses rustls by default all platforms that are not Windows/macOS/iOS/WASM.
+- Strips debug info of the Rust std library in release build.
+
+
+## [0.4.0-alpha.2] - 2024-01-08
+
+### Added
+- i686 linux support
+
+### Changed
+- Docker: fixes Docker image Glib version error.
+- Docker: tags now use semver e.g. `0.3.22` and not `v0.3.22`. Preversions are also not tagged `latest` anymore.
+- Python: `QuerySolution` is now thread safe.
+
+
+## [0.4.0-alpha.1] - 2024-01-03
+
+### Added
+- `sparopt` crate: A new still quite naive query optimizer.
+- `oxttl` crate: A N-Triples/N-Quads/Turtle/TriG/N3 parser and serializer compatible with Tokio.
+- `oxrdfxml` crate: A RDF/XML parser and serializer compatible with Tokio.
+- `oxrdfio` crate: A stand-alone crate with oxigraph I/O related APIs.
+- Rust: SPARQL results I/O is now exposed in the `oxigraph` crate (`oxigraph::sparql::results` module).
+- Rust: It is now possible to dynamically link rocksdb with the `rocksdb-pkg-config` feature.
+- Python: error location is now included in some `SyntaxError` exceptions.
+- Python: the file type can be guessed from the file path extension during parsing and serialization.
+- Python: the serialization method returns a `bytes` value if no output-related argument is given.
+- Python: SPARQL query results I/O is now exposed (`parse_query_results` function and `.serialize` method).
+- Python: `RdfFormat` and `QueryResultsFormat` enum to encode supported formats.
+- CLI: a `convert` command to convert RDF file between different formats.
+
+### Removed
+- Rust: automated flush at the end of serialization. This should be done explicitly now.
+- oxsdatatypes: Deprecated methods.
+- Python: 3.7 and Musl linux 1.1 support.
+- Python: `GraphName.value`.
+
+### Changed
+- SPARQL: a digit after `.` is now required for `xsd:decimal`.
+- SPARQL: calendar subtraction returns `xsd:dayTimeDuration` and not `xsd:duration`.
+- SPARQL: Unicode escapes (`\u` and `\U`) are now only supported in IRIs and strings and not everywhere.
+- Literal serialization now produces canonical N-Triples according to the RDF 1.2 and RDF Dataset Canonicalization drafts
+- Rust: MSRV is now 1.70.
+- Rust Makes `GraphName` implement `Default`.
+- Rust: `wasm32-unknown-unknown` does not assumes JS platform by default. Enable the `js` feature for that.
+- Rust: Parsers take `Read` and not `BufRead` for input.
+- Rust: `GraphFormat` and `DatasetFormat` have been merged into `RdfFormat`.
+- Rust: `GraphParser` and `DatasetParser` have been merged into `RdfParser`.
+- Rust: `GraphSerializer` and `DatasetSerializer` have been merged into `RdfSerializer`.
+- Rust: query results are now `Send` and `Sync`.
+- Rust: `Store.load_graph` and `Store.load_dataset` have been merged into a `load_from_read` method.
+- Rust: `Store.dump_graph` and `Store.dump_dataset` have been renamed to `dump_graph_to_write` and `dump_to_write`.
+- Rust: `BulkLoader.set_*` methods have been renamed to `BulkLoader.with_*`.
+- oxsdatatypes: pass by-values instead of by-reference parameters when relevant.
+- oxsdatatypes: error types have been redesigned.
+- oxsdatatypes: return an error when building not serializable duration (year-month and day-time of opposite signs).
+- sparesults: renames some methods to move closer to the new oxrdfio crate.
+- Python: raise `OSError` instead of `IOError` on OS errors.
+- Python: the `mime_type` parameter have been renamed to `format`.
+- Python: boolean SPARQL results are now encoded with a `QueryBoolean` class and not a simple `bool`.
+- Python: a `path` parameter has been added to all I/O method to read from a file.
+  The existing `input` parameter now consider `str` values to be a serialization to parse.
+- JS: the `mime_type` parameter have been renamed to `format`.
+- CLI: the `oxigraph_server` binary has been renamed to `oxigraph`.
+- CLI: the `--location` argument is now part of sub-commands where it is relevant.
+  `oxigraph_server --location foo serve` is not possible anymore.
+  One need to write `oxigraph serve --location foo`.
+- CLI: is is now possible to upload gzip encoded files to the HTTP API with the `Content-Encoding: gzip` header.
+
+
+## [0.3.22] - 2023-11-29
+
+### Changed
+- Allows to compile with more recent `bindgen` and `cc`
+- Fixes compatibility with `spin_no_std` feature of `lazy_static`
+
+
+## [0.3.21] - 2023-11-29
+
+### Changed
+- Bulk loader: do not fail when loading empty files.
+- Python: fixes source distribution.
+- Upgrades RocksDB to 7.8.1.
+
+
+## [0.3.20] - 2023-10-23
+
+### Changed
+- SPARQL: fixes `STR` evaluation on small IRI (less than 16 bytes) that was broken.
+- SPARQL update: fixes `WHERE` clause evaluation that was generating too many solutions in some cases.
+- Upgrades RocksDB to 8.7.1.
+
+
+## [0.3.19] - 2023-08-18
+
+### Added
+- Python: allows to give `pathlib.Path` argument when a path is expected.
+- Cargo.toml: add a documentation field to link to docs.rs documentation.
+
+### Changed
+- Upgrades RocksDB to 8.3.2.
+
+
+## [0.3.18] - 2023-06-13
+
+### Changed
+- SPARQL: fixes evaluation of `||` when all alternatives are `false`. The results must be `false` and not an error.
+- SPARQL: `xsd:duration` it is now possible to properly parse and serialize all numbers that can be internally represented by the encoding used by Oxigraph.
+- Python: fixes `Store.contains_named_graph` return type annotation.
+
+
+## [0.3.17] - 2023-06-11
+
+### Added
+- SPARQL: support of `xsd:duration` to SPARQL `SUM` aggregate function.
+- Server: support for systemd "notify" service option.
+- Server: uses the target graph name as base URI when `POST`ing and `PUT`ing data.
+- Python: `Store.contains_named_graph` method.
+
+### Changed
+- SPARQL: `xsd:decimal` multiplication and division have been improved to avoid raising overflow because of internal operations in some cases.
+- SPARQL: `xsd:decimal` parser is now able to properly parse all numbers that can be internally represented by the encoding used by Oxigraph.
+- SPARQL: `xsd:decimal` avoids bad overflow on unary `-` operator.
+- SPARQL: reduces loss of precision when casting `xsd:decimal` to `xsd:float` or `xsd:double`.
+- SPARQL: improves a bit the AST in case of a lot of `&&`, `||` or `IN` operators.
+- SPARQL: fixes some optimization bugs around `MINUS` inside `OPTIONAL`.
+- SPARQL: makes for loop join choice instead of hash join a bit more aggressive.
+- Avoids random crashes when building RocksDB for aarch64. 
+- Python: fixes support of text I/O with not-ASCII char.
+- Python: upgrades PyO3 to 0.19.
+- `spargebra`: `GroundTermPattern::Triple` is now properly gated behind the `"rdf-star"` feature.
+- `oxsdatatypes`: Deprecates `is_naan` that is renamed to `is_nan` (we like bread but prefer numbers).
+- `oxsdatatypes`: Adds `checked_neg` methods on numerical types.
+- `oxsdatatypes`: Drops `nom` dependency and uses hand-written parsers instead.
+
+
+## [0.3.16] - 2023-04-29
+
+### Changed
+- Fixes flush and compaction on the GSPO index. It might improve Oxigraph performances and storage space.
+- SPARQL: fixes some optimizations in presence quoted triples with nested variables.
+- SPARQL profiler: adds EXISTS operation to the explanation and profiling tree.
+- Upgrades RocksDB to 8.1.1.
+
+
+## [0.3.15] - 2023-04-18
+
+### Added
+- Rust: adds `Store.explain_query_opt` method that allows to get an explanation of the evaluation with profiling statistics.
+- Server: adds explanation and profiling to the `query` action (`--explain`, `--explain-file` and `--stats` options).
+- Python: implements the `__match_args__` attribute on terms (literals, triples, quads...) to allow `match` operator usage.
+- Server: adds the `--cors` option to the `serve` actions to allow cross-origin resource sharing.
+
+### Changed
+- SPARQL: fixes evaluation of empty aggregation without GROUP BY: aggregators now return their default value (0 for COUNT...) and not an empty row.
+- SPARQL: fixes parsing of decimal with more than 19 digits in the fractional part.
+- Server docker image: switch to the smaller distroless base images.
+- Bulk loader: by default only uses 2 concurrent threads and around 2GB of RAM.
+- Server load: progress is now printed to stderr much more regularly.
+
+
+## [0.3.14] - 2023-03-19
+
+### Added
+- Read only and secondary RocksDB storage. Allows to open the data as read-only or to follow a primary instance.
+- Server: adds multiple commands:
+  - `serve-secondary` and `serve-read-only` to serve the HTTP server in secondary and read-only modes.
+  - `dump` to dump the database content to a file.
+  - `query` and `update` to execute SPARQL query and updates.
+  - `backup` to do a database backup.
+  - `optimize` to optimize the database storage.
+- Server: adds `format` and `graph` options to the `load` command in order to select the loaded data format and the target graph.
+- Python: `Store.extend` and `Store.bulk_extend` methods.
+- Python: allows to pickle basic data model classes.
+
+### Changed
+- Upgrades RocksDB to 8.0.0.
+- Server: listening to localhost now properly listen to both IPv4 and IPv6.
+- RDF/XML and XML parser results: avoid an ever growing buffer.
+- JSON SPARQL results: allows the "head" key to be at the end of the document.
+- TSV SPARQL results: properly quote `\t` and print trailing line jumps.
+- `Term::from_str`: fixes parsing of blank nodes in object position of quoted triples.
+- `QuerySolution`: implements `Eq` and `Debug`.
+- JS: Reduces WASM build size.
+- OxRDF: fixes `Graph` and `Dataset` serialization to output proper N-Triples and N-Quads.
+
+
+## [0.3.13] - 2023-02-23
+
+### Changed
+- Fixes serialization of times with a decimal number of seconds lower than 10 (now `01:01:01.01` and not `01:01:1.01`).
+- Turtle and TriG: fixes parsing for prefixes named after keywords (`prefix`, `base`, `graph`, `true` and `false`).
+
+
+## [0.3.12] - 2023-02-18
+
+### Added
+- `From<NamedOrBlankNode>` for `GraphName` (and similarly for `*Ref`).
+- Prebuilt Python wheels for Linux with [musl libc](https://www.musl-libc.org/).
+
+### Changed
+- Fixes TriG serialization.
+- `QueryDataset` is now properly exposed in the public Rust API.
+
+
+## [0.3.11] - 2023-01-18
+
+### Added
+- SPARQL: Implementation of the `LATERAL` operator following [SPARQL SEP-0006](https://github.com/w3c/sparql-12/blob/main/SEP/SEP-0006/sep-0006.md).
+  Support is behind the `sep-0006` feature in `spargebra` and enabled by default in Oxigraph. 
+- SPARQL: Implementation of the `ADJUST` function following [SPARQL SEP-0002](https://github.com/w3c/sparql-12/blob/main/SEP/SEP-0002/sep-0002.md).
+  Support is behind the `sep-0002` feature in `spargebra` and enabled by default in Oxigraph.
+- Rust: There is a new stand-alone crate `oxsdatatypes` implementing Rust structs for the common XML schema datatypes.
+  It was part of the Oxigraph crate and it might be useful for other SPARQL or XPath implementations.
+- Rust: The `oxigraph` crate can now be compiled for `wasm32-wasi` with the basic in-memory backend but without RocksDB.
+
+### Changed
+- SPARQL: The property path evaluator was sometime emitting duplicates when evaluating disjunctive patterns (`a|b`). It is now fixed.
+- SPARQL: If written explicitly in the SPARQL query, the regular expressions are now compiled once and not for each row.
+- SPARQL: Property path evaluation with both start and end variables bound has been optimized.
+- SPARQL: Casts to `xsd:decimal` from `xsd:float` and `xsd:double` now properly fails on overflow instead of overflowing the internal 128-bits representation.
+  This follows [XPath casting rules](https://www.w3.org/TR/xpath-functions-31/#casting-to-decimal).
+- Rust: The minimal supported Rust version is set at 1.60 and enforced using the CI.
+- Python: Local builds will now target the specific Python version instead of [abi3](https://docs.python.org/3/c-api/stable.html).
+  abi3 wheels are still released on Pypi alongside new Python-version specific builds for Linux+GNU.
+- SPARQL: Fixes a panic when the estimated upper bound of the results size was overflowing a `usize`.
+- Python: Uses `typing.IO` in Python stubs instead of narrower interfaces. 
+- Upgrades RocksDB to 7.9.2, `quick-xml` to 0.27 and `pyo3` to 0.18.
+
+
+## [0.3.10] - 2022-12-21
+
+### Added
+- SPARQL: Property path with unbound graph are now evaluated.
+  For example, `SELECT * WHERE { GRAPH ?g { ?s ex:p+ ?o } }` now works.
+- SPARQL: The query optimizer is now fuzzed for better testing.
+
+### Changed
+- SPARQL: Evaluation of zero-length paths with both start and end unbounded now return only terms defined in the current graph but not terms only defined in the query.
+  For example, in `SELECT * WHERE { VALUES ?s { 1 } { ?s ex:p? ?o } }` the literal `1` won't be returned anymore if not in the queried graph.
+- Python: type stubs are now compatible with Python 3.7 and Mypy strict mode.
+- RDF/XML: allows entities declared using other entities.
+- Upgrades `quick-xml` to 0.26.
+
+
+## [0.3.9] - 2022-12-07
+
+### Added
+- Server: The `/store` endpoints now has a `no_transaction` HTTP option for `POST` and `PUT` request to get better performances at the cost of transactional guarantees.
+- Server: The `/store` endpoints now has a `lenient` HTTP option for `POST` and `PUT` request to ignore syntax errors (requires the  `no_transaction` option).
+- Server: allows path that are not valid UTF-8 in file path CLI arguments.
+- Rust: `From<spargebra::Query>` to `oxigraph::Query` (thanks to @hobofan).
+
+### Changed
+- SPARQL: `NOW()` function properly returns the current time and not 1970-01-01
+- SPARQL: fixes serialization of SPARQL queries (property path and STRSTARTS function).
+- SPARQL: slightly optimize aggregates by avoiding an unneeded projection.
+- SPARQL: the parser now cleanly fails if invalid `VALUES` clauses are provided.
+- SPARQL: In DELETE/INSERT UPDATE the currently written values can't be read anymore ("Halloween problem").
+- `oxrdf`: makes Clippy run without warnings when `rdf-star` is disable.
+- Python: makes type annotations compatible with Python 3.7.
+- Python: makes sure the parameter default value is always included in the type annotation.
+
+
+## [0.3.8] - 2022-10-22
+
+### Changed
+- Python: avoid uploading debug wheels to pypi.
+
+
+## [0.3.7] - 2022-10-22
+
+### Added
+- Python type stubs are now generated and distributed alongside wheels.
+
+### Changed
+- SPARQL: Fixes evaluation of sub queries in which some variables might not be always bound.
+- Python: Uses https://pyoxigraph.readthedocs.io instead of https://oxigraph.org/pyoxigraph/ to store pyoxigraph documentation.
+- Server: Migration to Clap v4. Slight changes to the console textual outputs.
+
+
+## [0.3.6] - 2022-08-16
+
+### Changed
+- Server: Makes sure body is always sent for all HTTP response codes that are not explicitly to not do that according to the HTTP specification.
+- Python: Adds support of reading from `io.TextIOBase`.
+
+
+## [0.3.5] - 2022-08-02
+
+### Changed
+- Fixes a bug in the SPARQL parser with nested anonymous blank nodes (`[]`).
+- Migrates the Python documentation skin to [Furo](https://pradyunsg.me/furo/).
+
+
+## [0.3.4] - 2022-07-17
+
+### Changed
+- Allows multiple value to be given to `oxigraph_server` `--file` parameter.
+- Limits parallelism of `oxigraph_server` file loader to avoid stack overflows.
+
+
+## [0.3.3] - 2022-06-12
+
+### Added
+- `QueryResults::with_http_redirection_limit` that allows to set a limit on the number of HTTP redirection followed (`0` by default).
+
+### Changed
+- Fixes a bug in SPARQL parser that was always enabling the `SILENT` option of the `SERVICE` operator.
+- Allows unknown keys in the objects present in the SPARQL JSON query results. It allows to parse e.g. Virtuoso query results.
+- Allows `"typed-literal"` as an alias of `"literal"` in SPARQL JSON query results. 
+- Improves the HTTP client error reporting: no silent failures on 4XX and 5XX responses.
+- Upgrades RocksDB to 7.3.1.
+- Upgrades quick-xml to 0.23.
+
+
+## [0.3.2] - 2022-04-24
+
+### Changed
+- Fixes a bug in the server bulk loader that crashed on very small files.
+- Upgrades RocksDB to v7.1.
+- Removes some dead code in the bulk loader.
+
+
 ## [0.3.1] - 2022-04-02
 
 ### Changed
@@ -66,8 +440,8 @@
 ## [0.3.0-beta.1] - 2022-01-29
 
 ### Added
-- [RDF-star](https://w3c.github.io/rdf-star/cg-spec) support. `Triple` is now a possible `Term`. Serialization formats and SPARQL support have been updated to match the [latest version of the specification draft](https://w3c.github.io/rdf-star/cg-spec/2021-07-01.html).
-- Fast data bulk load with the `Store` `bulk_load_dataset` and `bulk_load_graph` methods and a special command line option of the server.
+- [RDF-star](https://w3c.github.io/rdf-star/cg-spec/2021-12-17.html) support. `Triple` is now a possible `Term`. Serialization formats and SPARQL support have been updated to match the [latest version of the specification draft](https://w3c.github.io/rdf-star/cg-spec/2021-12-17.html).
+- Fast data bulk load with the `Store` `bulk_load_dataset` and `bulk_load_graph` methods and a special command-line option of the server.
 - It is now possible to quickly backup the database using the `backup` method.
 - Rust: `*Syntax::from_extension` to easy guess a graph/dataset/sparql result format from a file extension.
 - Rust: Custom SPARQL functions are now supported using `QueryOptions::with_custom_function`.
@@ -76,14 +450,14 @@
 - `Store` operations are now transactional using the "repeatable read" isolation level:
   the store only exposes changes that have been "committed" (i.e. no partial writes) and the exposed state does not change for the complete duration of a read operation (e.g. a SPARQL query) or a read/write operation (e.g. a SPARQL update).
   the `Store` `transaction` method now allows to do read/write transactions.
--`RDF-star <https://w3c.github.io/rdf-star/cg-spec>`_ is now supported (including serialization formats and SPARQL-star). :py:class:`.Triple` can now be used in :py:attr:`.Triple.object`, :py:attr:`.Triple.object`, :py:attr:`.Quad.subject` and :py:attr:`.Quad.object`.
+-`RDF-star <https://w3c.github.io/rdf-star/cg-spec/2021-12-17.html>`_ is now supported (including serialization formats and SPARQL-star). :py:class:`.Triple` can now be used in :py:attr:`.Triple.object`, :py:attr:`.Triple.object`, :py:attr:`.Quad.subject` and :py:attr:`.Quad.object`.
 
 ### Changed
 - SPARQL: It is now possible to compare `rdf:langString` literals with the same language tag.
 - SPARQL: The parser now validates more carefully the inputs following the SPARQL specification and test suite.
 - SPARQL: Variable scoping was buggy with "FILTER EXISTS". It is now fixed.
 - Rust: RDF model, SPARQL parser and SPARQL result parsers have been moved to stand-alone reusable libraries.
-- Rust: HTTPS is not supported by default with the `http_client` option. You need to enable the `native-tls` or the `rustls` feature of the `oxhttp` crate to enable a TSL layer.
+- Rust: HTTPS is not supported by default with the `http_client` option. You need to enable the `native-tls` or the `rustls` feature of the `oxhttp` crate to enable a TLS layer.
 - Rust: The error types have been cleaned.
   Most of the `Store` methods now return a `StorageError` that is more descriptive than the previous `std::io::Error`.
   The new error type all implements `Into<std::io::Error>` for easy conversion.
@@ -91,12 +465,12 @@
   It is The used type of the `subject` field of the `Triple` and `Quad` structs.
 - Rust: The SPARQL algebra is not anymore publicly exposed in the `oxigraph` crate. The new `oxalgebra` crate exposes it.
 - Rust: `UpdateOptions` API have been rewritten. It can now be built using `From<QueryOptions>` or `Default`.
-- Server: The command line API has been redesign. See the [server README](server/README.md) for more information.
+- Server: The command-line API has been redesign. See the [server README](server/README.md) for more information.
 - Server: The HTTP implementation is now provided by [`oxhttp`](https://github.com/oxigraph/oxhttp).
 - Server: The HTTP response bodies are now generated on the fly instead of being buffered.
 - Python: The `SledStore` and `MemoryStore` classes have been removed in favor of the `Store` class.
 - JS: The `MemoryStore` class has been renamed to `Store`.
-- JS: The [RDF/JS `DataFactory` interface](http://rdf.js.org/data-model-spec/#datafactory-interface) is now implemented by the `oxigraph` module itself and the `MemoryStore.dataFactory` propery has been removed.
+- JS: The [RDF/JS `DataFactory` interface](http://rdf.js.org/data-model-spec/#datafactory-interface) is now implemented by the `oxigraph` module itself and the `MemoryStore.dataFactory` property has been removed.
 - The implementation of SPARQL evaluation has been improved for better performances (especially joins).
 - The TLS implementation used in SPARQL HTTP calls is now [rustls](https://github.com/rustls/rustls) and not [native-tls](https://github.com/sfackler/rust-native-tls). The host system certificate registry is still used.
 - Spargebra: The basic RDF terms are now the ones of the `oxrdf` crate.
@@ -112,7 +486,7 @@ Many thanks to [Thad Guidry](https://github.com/thadguidry), [James Overton](htt
 ## [0.2.5] - 2021-07-11
 
 ### Added
-- [SPARQL 1.1 Query Results JSON Format](http://www.w3.org/TR/sparql11-results-json/) parser.
+- [SPARQL 1.1 Query Results JSON Format](https://www.w3.org/TR/sparql11-results-json/) parser.
 - Python wheels for macOS are now universal2 binaries.
 
 ### Changed

CITATION.cff

@@ -0,0 +1,16 @@
+cff-version: 1.2.0
+abstract: "Oxigraph is a graph database implementing the SPARQL standard."
+authors:
+  - given-names: Thomas
+    family-names: Pellissier Tanon
+    email: thomas@pellissier-tanon.fr
+    orcid: "https://orcid.org/0000-0002-0620-6486"
+doi: 10.5281/zenodo.7408022
+license:
+  - Apache-2.0
+  - MIT
+message: "If you use this software, please cite it as below."
+repository-code: "https://github.com/oxigraph/oxigraph"
+title: Oxigraph
+type: software
+url: "https://oxigraph.org"

Cargo.toml

@@ -1,16 +1,272 @@
 [workspace]
 members = [
     "js",
-    "lib",
+    "lib/oxigraph",
     "lib/oxrdf",
-    "lib/spargebra",
+    "lib/oxrdfio",
+    "lib/oxrdfxml",
+    "lib/oxsdatatypes",
+    "lib/oxttl",
     "lib/sparesults",
-    "python",
-    "oxrocksdb-sys",
-    "server",
+    "lib/spargebra",
+    "lib/sparopt",
+    "lib/sparql-smith",
     "testsuite"
 ]
+resolver = "2"
+
+[workspace.package]
+version = "0.4.0-alpha.7-dev"
+authors = ["Tpt <thomas@pellissier-tanon.fr>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.70"
+
+[workspace.dependencies]
+rocksdb = {git = "https://git.nextgraph.org/NextGraph/rust-rocksdb.git", branch = "master", features = [  ] }
+serde = { version = "1.0.142", features = ["derive"] }
+anyhow = "1.0.72"
+arbitrary = "1.3"
+assert_cmd = "2.0"
+assert_fs = "1.0"
+bindgen = ">=0.60, <0.70"
+cc = "1.0.73"
+clap = "4.0"
+codspeed-criterion-compat = "2.3.3"
+console_error_panic_hook = "0.1.7"
+digest = "0.10"
+flate2 = "1.0"
+getrandom = "0.2.8"
+hex = "0.4"
+js-sys = "0.3.60"
+json-event-parser = "0.2.0-alpha.2"
+md-5 = "0.10"
+memchr = "2.5"
+oxilangtag = "0.1"
+oxiri = "0.2.3"
+peg = "0.8"
+pkg-config = "0.3.25"
+predicates = ">=2.0, <4.0"
+pyo3 = "0.21.0"
+quick-xml = ">=0.29, <0.32"
+rand = "0.8"
+rayon-core = "1.11"
+regex = "1.7"
+sha1 = "0.10"
+sha2 = "0.10"
+siphasher = ">=0.3, <2.0"
+text-diff = "0.4"
+thiserror = "1.0.50"
+time = "0.3"
+tokio = "1.29"
+url = "2.4"
+wasm-bindgen = "0.2.83"
+zstd = ">=0.12, <0.14"
+
+# Internal dependencies
+oxigraph = { version = "=0.4.0-alpha.7-dev", path = "lib/oxigraph" }
+oxrdf = { version = "=0.2.0-alpha.4", path = "lib/oxrdf" }
+oxrdfio = { version = "=0.1.0-alpha.5", path = "lib/oxrdfio" }
+oxrdfxml = { version = "=0.1.0-alpha.5", path = "lib/oxrdfxml" }
+oxsdatatypes = { version = "=0.2.0-alpha.1", path = "lib/oxsdatatypes" }
+oxttl = { version = "=0.1.0-alpha.5", path = "lib/oxttl" }
+sparesults = { version = "=0.2.0-alpha.4", path = "lib/sparesults" }
+spargebra = { version = "=0.3.0-alpha.4", path = "lib/spargebra" }
+sparopt = { version = "=0.1.0-alpha.5-dev", path = "lib/sparopt" }
+
+[workspace.lints.rust]
+absolute_paths_not_starting_with_crate = "warn"
+elided_lifetimes_in_paths = "warn"
+explicit_outlives_requirements = "warn"
+let_underscore_drop = "warn"
+macro_use_extern_crate = "warn"
+# TODO missing_docs = "warn"
+trivial_casts = "warn"
+trivial_numeric_casts = "warn"
+unsafe_code = "warn"
+unused_import_braces = "warn"
+unused_lifetimes = "warn"
+unused_macro_rules = "warn"
+unused_qualifications = "warn"
+
+[workspace.lints.clippy]
+allow_attributes = "warn"
+allow_attributes_without_reason = "warn"
+as_underscore = "warn"
+assertions_on_result_states = "warn"
+bool_to_int_with_if = "warn"
+borrow_as_ptr = "warn"
+case_sensitive_file_extension_comparisons = "warn"
+cast_lossless = "warn"
+cast_possible_truncation = "warn"
+cast_possible_wrap = "warn"
+cast_precision_loss = "warn"
+cast_ptr_alignment = "warn"
+cast_sign_loss = "warn"
+checked_conversions = "warn"
+clone_on_ref_ptr = "warn"
+cloned_instead_of_copied = "warn"
+copy_iterator = "warn"
+create_dir = "warn"
+dbg_macro = "warn"
+decimal_literal_representation = "warn"
+default_trait_access = "warn"
+default_union_representation = "warn"
+deref_by_slicing = "warn"
+disallowed_script_idents = "warn"
+doc_link_with_quotes = "warn"
+empty_drop = "warn"
+empty_enum = "warn"
+empty_structs_with_brackets = "warn"
+enum_glob_use = "warn"
+error_impl_error = "warn"
+exit = "warn"
+expect_used = "warn"
+expl_impl_clone_on_copy = "warn"
+explicit_deref_methods = "warn"
+explicit_into_iter_loop = "warn"
+explicit_iter_loop = "warn"
+filetype_is_file = "warn"
+filter_map_next = "warn"
+flat_map_option = "warn"
+fn_params_excessive_bools = "warn"
+fn_to_numeric_cast_any = "warn"
+format_push_string = "warn"
+from_iter_instead_of_collect = "warn"
+get_unwrap = "warn"
+host_endian_bytes = "warn"
+if_not_else = "warn"
+if_then_some_else_none = "warn"
+ignored_unit_patterns = "warn"
+implicit_clone = "warn"
+implicit_hasher = "warn"
+inconsistent_struct_constructor = "warn"
+index_refutable_slice = "warn"
+inefficient_to_string = "warn"
+infinite_loop = "warn"
+inline_always = "warn"
+inline_asm_x86_att_syntax = "warn"
+inline_asm_x86_intel_syntax = "warn"
+into_iter_without_iter = "warn"
+invalid_upcast_comparisons = "warn"
+items_after_statements = "warn"
+iter_not_returning_iterator = "warn"
+iter_without_into_iter = "warn"
+large_digit_groups = "warn"
+large_futures = "warn"
+large_include_file = "warn"
+large_stack_arrays = "warn"
+large_types_passed_by_value = "warn"
+let_underscore_must_use = "warn"
+let_underscore_untyped = "warn"
+linkedlist = "warn"
+lossy_float_literal = "warn"
+macro_use_imports = "warn"
+manual_assert = "warn"
+manual_instant_elapsed = "warn"
+manual_let_else = "warn"
+manual_ok_or = "warn"
+manual_string_new = "warn"
+many_single_char_names = "warn"
+map_unwrap_or = "warn"
+match_bool = "warn"
+match_on_vec_items = "warn"
+match_same_arms = "warn"
+match_wild_err_arm = "warn"
+match_wildcard_for_single_variants = "warn"
+maybe_infinite_iter = "warn"
+mem_forget = "warn"
+mismatching_type_param_order = "warn"
+missing_assert_message = "warn"
+missing_asserts_for_indexing = "warn"
+missing_fields_in_debug = "warn"
+multiple_inherent_impl = "warn"
+mut_mut = "warn"
+mutex_atomic = "warn"
+naive_bytecount = "warn"
+needless_bitwise_bool = "warn"
+needless_continue = "warn"
+needless_for_each = "warn"
+needless_pass_by_value = "warn"
+needless_raw_string_hashes = "warn"
+needless_raw_strings = "warn"
+negative_feature_names = "warn"
+no_effect_underscore_binding = "warn"
+no_mangle_with_rust_abi = "warn"
+non_ascii_literal = "warn"
+panic = "warn"
+panic_in_result_fn = "warn"
+partial_pub_fields = "warn"
+print_stderr = "warn"
+print_stdout = "warn"
+ptr_as_ptr = "warn"
+ptr_cast_constness = "warn"
+pub_without_shorthand = "warn"
+range_minus_one = "warn"
+range_plus_one = "warn"
+rc_buffer = "warn"
+rc_mutex = "warn"
+redundant_closure_for_method_calls = "warn"
+redundant_else = "warn"
+redundant_feature_names = "warn"
+redundant_type_annotations = "warn"
+ref_binding_to_reference = "warn"
+ref_option_ref = "warn"
+ref_patterns = "warn"
+rest_pat_in_fully_bound_structs = "warn"
+return_self_not_must_use = "warn"
+same_functions_in_if_condition = "warn"
+same_name_method = "warn"
+semicolon_inside_block = "warn"
+shadow_same = "warn"
+should_panic_without_expect = "warn"
+single_match_else = "warn"
+stable_sort_primitive = "warn"
+str_to_string = "warn"
+string_add = "warn"
+string_add_assign = "warn"
+string_lit_chars_any = "warn"
+string_to_string = "warn"
+struct_excessive_bools = "warn"
+struct_field_names = "warn"
+suspicious_xor_used_as_pow = "warn"
+tests_outside_test_module = "warn"
+todo = "warn"
+transmute_ptr_to_ptr = "warn"
+trivially_copy_pass_by_ref = "warn"
+try_err = "warn"
+unchecked_duration_subtraction = "warn"
+undocumented_unsafe_blocks = "warn"
+unicode_not_nfc = "warn"
+unimplemented = "warn"
+uninlined_format_args = "warn"
+unnecessary_box_returns = "warn"
+unnecessary_join = "warn"
+unnecessary_safety_comment = "warn"
+unnecessary_safety_doc = "warn"
+unnecessary_self_imports = "warn"
+unnecessary_wraps = "warn"
+unneeded_field_pattern = "warn"
+unnested_or_patterns = "warn"
+unreadable_literal = "warn"
+unsafe_derive_deserialize = "warn"
+unseparated_literal_suffix = "warn"
+unused_async = "warn"
+unused_self = "warn"
+unwrap_in_result = "warn"
+use_debug = "warn"
+used_underscore_binding = "warn"
+verbose_bit_mask = "warn"
+verbose_file_reads = "warn"
+wildcard_dependencies = "warn"
+zero_sized_map_values = "warn"
 
 [profile.release]
 lto = true
 codegen-units = 1
+strip = "debuginfo"
+
+[profile.release.package.oxigraph-js]
+codegen-units = 1
+opt-level = "z"
+strip = "debuginfo"

LICENSE.md

@@ -1,10 +0,0 @@
-This project is licensed under either of
-
- * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
-   http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license ([LICENSE-MIT](LICENSE-MIT) or
-   http://opensource.org/licenses/MIT)
-   
-at your option.
-
-SPDX-License-Identifier: MIT OR Apache-2.0

README.md

@@ -1,13 +1,13 @@
-Oxigraph
-========
+# Oxigraph
 
-[![Latest Version](https://img.shields.io/crates/v/oxigraph.svg)](https://crates.io/crates/oxigraph) 
+[![Latest Version](https://img.shields.io/crates/v/oxigraph.svg)](https://crates.io/crates/oxigraph)
 [![Released API docs](https://docs.rs/oxigraph/badge.svg)](https://docs.rs/oxigraph)
 [![PyPI](https://img.shields.io/pypi/v/pyoxigraph)](https://pypi.org/project/pyoxigraph/)
 [![npm](https://img.shields.io/npm/v/oxigraph)](https://www.npmjs.com/package/oxigraph)
-[![actions status](https://github.com/oxigraph/oxigraph/workflows/build/badge.svg)](https://github.com/oxigraph/oxigraph/actions)
+[![tests status](https://github.com/oxigraph/oxigraph/actions/workflows/tests.yml/badge.svg)](https://github.com/oxigraph/oxigraph/actions)
+[![artifacts status](https://github.com/oxigraph/oxigraph/actions/workflows/artifacts.yml/badge.svg)](https://github.com/oxigraph/oxigraph/actions)
 [![dependency status](https://deps.rs/repo/github/oxigraph/oxigraph/status.svg)](https://deps.rs/repo/github/oxigraph/oxigraph)
-[![Gitter](https://badges.gitter.im/oxigraph/community.svg)](https://gitter.im/oxigraph/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+[![Gitter](https://badges.gitter.im/oxigraph/community.svg)](https://gitter.im/oxigraph/community)
 [![Twitter URL](https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Ftwitter.com%2Foxigraph)](https://twitter.com/oxigraph)
 
 Oxigraph is a graph database implementing the [SPARQL](https://www.w3.org/TR/sparql11-overview/) standard.
@@ -20,24 +20,43 @@ Oxigraph is in heavy development and SPARQL query evaluation has not been optimi
 The development roadmap is using [GitHub milestones](https://github.com/oxigraph/oxigraph/milestones?direction=desc&sort=completeness&state=open).
 Oxigraph internal design [is described on the wiki](https://github.com/oxigraph/oxigraph/wiki/Architecture).
 
+Oxigraph implements the following specifications:
+
+- [SPARQL 1.1 Query](https://www.w3.org/TR/sparql11-query/), [SPARQL 1.1 Update](https://www.w3.org/TR/sparql11-update/), and [SPARQL 1.1 Federated Query](https://www.w3.org/TR/sparql11-federated-query/).
+- [Turtle](https://www.w3.org/TR/turtle/), [TriG](https://www.w3.org/TR/trig/), [N-Triples](https://www.w3.org/TR/n-triples/), [N-Quads](https://www.w3.org/TR/n-quads/), and [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/) RDF serialization formats for both data ingestion and retrieval.
+- [SPARQL Query Results XML Format](https://www.w3.org/TR/rdf-sparql-XMLres/), [SPARQL 1.1 Query Results JSON Format](https://www.w3.org/TR/sparql11-results-json/) and [SPARQL 1.1 Query Results CSV and TSV Formats](https://www.w3.org/TR/sparql11-results-csv-tsv/).
+
 It is split into multiple parts:
-* [The database written as a Rust library](https://crates.io/crates/oxigraph). Its source code is in the `lib` directory.
-[![Latest Version](https://img.shields.io/crates/v/oxigraph.svg)](https://crates.io/crates/oxigraph) 
-[![Released API docs](https://docs.rs/oxigraph/badge.svg)](https://docs.rs/oxigraph)
-* [`pyoxigraph` that exposes Oxigraph to the Python world](https://oxigraph.org/pyoxigraph/). Its source code is in the `python` directory. [![PyPI](https://img.shields.io/pypi/v/pyoxigraph)](https://pypi.org/project/pyoxigraph/)
-* [JavaScript bindings for Oxigraph](https://www.npmjs.com/package/oxigraph). WebAssembly is used to package Oxigraph into a NodeJS compatible NPM package. Its source code is in the `js` directory.
-[![npm](https://img.shields.io/npm/v/oxigraph)](https://www.npmjs.com/package/oxigraph)
-* [Oxigraph server](https://crates.io/crates/oxigraph_server) that provides a standalone binary of a web server implementing the [SPARQL 1.1 Protocol](https://www.w3.org/TR/sparql11-protocol/) and the [SPARQL 1.1 Graph Store Protocol](https://www.w3.org/TR/sparql11-http-rdf-update/). Its source code is in the `server` directory.
-[![Latest Version](https://img.shields.io/crates/v/oxigraph_server.svg)](https://crates.io/crates/oxigraph_server) 
-[![Docker Image Version (latest semver)](https://img.shields.io/docker/v/oxigraph/oxigraph?sort=semver)](https://hub.docker.com/r/oxigraph/oxigraph)
 
-Oxigraph implements the following specifications:
-* [SPARQL 1.1 Query](https://www.w3.org/TR/sparql11-query/), [SPARQL 1.1 Update](https://www.w3.org/TR/sparql11-update/), and [SPARQL 1.1 Federated Query](https://www.w3.org/TR/sparql11-federated-query/).
-* [Turtle](https://www.w3.org/TR/turtle/), [TriG](https://www.w3.org/TR/trig/), [N-Triples](https://www.w3.org/TR/n-triples/), [N-Quads](https://www.w3.org/TR/n-quads/), and [RDF XML](https://www.w3.org/TR/rdf-syntax-grammar/) RDF serialization formats for both data ingestion and retrieval using the [Rio library](https://github.com/oxigraph/rio).
-* [SPARQL Query Results XML Format](http://www.w3.org/TR/rdf-sparql-XMLres/), [SPARQL 1.1 Query Results JSON Format](https://www.w3.org/TR/sparql11-results-json/) and [SPARQL 1.1 Query Results CSV and TSV Formats](https://www.w3.org/TR/sparql11-results-csv-tsv/).
+- [The database written as a Rust library](https://crates.io/crates/oxigraph). Its source code is in the `lib` directory.
+  [![Latest Version](https://img.shields.io/crates/v/oxigraph.svg)](https://crates.io/crates/oxigraph)
+  [![Released API docs](https://docs.rs/oxigraph/badge.svg)](https://docs.rs/oxigraph)
+- [`pyoxigraph` that exposes Oxigraph to the Python world](https://pyoxigraph.readthedocs.io/). Its source code is in the `python` directory. [![PyPI](https://img.shields.io/pypi/v/pyoxigraph)](https://pypi.org/project/pyoxigraph/)
+- [JavaScript bindings for Oxigraph](https://www.npmjs.com/package/oxigraph). WebAssembly is used to package Oxigraph into a NodeJS compatible NPM package. Its source code is in the `js` directory.
+  [![npm](https://img.shields.io/npm/v/oxigraph)](https://www.npmjs.com/package/oxigraph)
+- [Oxigraph binary](https://crates.io/crates/oxigraph-cli) that provides a standalone command-line tool allowing to manipulate RDF data and spawn a a web server implementing the [SPARQL 1.1 Protocol](https://www.w3.org/TR/sparql11-protocol/) and the [SPARQL 1.1 Graph Store Protocol](https://www.w3.org/TR/sparql11-http-rdf-update/). Its source code is in the `cli` directory.
+  Note that it was previously named [Oxigraph server](https://crates.io/crates/oxigraph-server).
+  [![Latest Version](https://img.shields.io/crates/v/oxigraph-cli.svg)](https://crates.io/crates/oxigraph-cli)
+
+Also, some parts of Oxigraph are available as standalone Rust crates:
+* [`oxrdf`](https://crates.io/crates/oxrdf), datastructures encoding RDF basic concepts (the [`oxigraph::model`](crate::model) module).
+* [`oxrdfio`](https://crates.io/crates/oxrdfio), a unified parser and serializer API for RDF formats (the [`oxigraph::io`](crate::io) module). It itself relies on:
+  * [`oxttl`](https://crates.io/crates/oxttl), N-Triple, N-Quad, Turtle, TriG and N3 parsing and serialization.
+  * [`oxrdfxml`](https://crates.io/crates/oxrdfxml), RDF/XML parsing and serialization.
+* [`spargebra`](https://crates.io/crates/spargebra), a SPARQL parser.
+* [`sparesults`](https://crates.io/crates/sparesults), parsers and serializers for SPARQL result formats.
+* [`sparopt`](https://crates.io/crates/sparesults), a SPARQL optimizer.
+* [`oxsdatatypes`](https://crates.io/crates/oxsdatatypes), an implementation of some XML Schema datatypes.
+
+The library layers in Oxigraph. The elements above depend on the elements below:
+![Oxigraph libraries architecture diagram](./docs/arch-diagram.svg)
 
 A preliminary benchmark [is provided](bench/README.md). There is also [a document describing Oxigraph technical architecture](https://github.com/oxigraph/oxigraph/wiki/Architecture).
 
+When cloning this codebase, don't forget to clone the submodules using
+`git clone --recursive https://github.com/oxigraph/oxigraph.git` to clone the repository including submodules or
+`git submodule update --init` to add the submodules to the already cloned repository.
+
 
 ## Help
 
@@ -51,14 +70,25 @@ If you need advanced support or are willing to pay to get some extra features, f
 
 This project is licensed under either of
 
- * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
-   http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license ([LICENSE-MIT](LICENSE-MIT) or
-   http://opensource.org/licenses/MIT)
-   
-at your option.
+- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
+  http://www.apache.org/licenses/LICENSE-2.0)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or
+  http://opensource.org/licenses/MIT)
 
+at your option.
 
 ### Contribution
 
 Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Oxigraph by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
+
+
+## Sponsors
+
+* [RelationLabs](https://relationlabs.ai/) that is building [Relation-Graph](https://github.com/relationlabs/Relation-Graph), a SPARQL database module for the [Substrate blockchain platform](https://substrate.io/) based on Oxigraph.
+* [Field 33](https://field33.com) that was building [an ontology management platform](https://plow.pm/).
+* [Magnus Bakken](https://github.com/magbak) who is building [Data Treehouse](https://www.data-treehouse.com/), a time-series + RDF datalake platform, and [chrontext](https://github.com/magbak/chrontext), a SPARQL query endpoint on top of joint RDF and time series databases.
+* [DeciSym.AI](https://www.decisym.ai/) a cyber security consulting company providing RDF-based software.
+* [ACE IoT Solutions](https://aceiotsolutions.com/), a building IOT platform.
+* [Albin Larsson](https://byabbe.se/) who is building [GovDirectory](https://www.govdirectory.org/), a directory of public agencies based on Wikidata.
+
+And [others](https://github.com/sponsors/Tpt). Many thanks to them!

bench/bsbm_blazegraph.sh

@@ -2,18 +2,19 @@
 
 DATASET_SIZE=100000
 PARALLELISM=16
-cd bsbm-tools
+
+set -eu
+wget -nc https://github.com/blazegraph/database/releases/download/BLAZEGRAPH_RELEASE_2_1_5/blazegraph.jar
+cd bsbm-tools || exit
 ./generate -fc -pc ${DATASET_SIZE} -s nt -fn "explore-${DATASET_SIZE}" -ud -ufn "explore-update-${DATASET_SIZE}"
-wget https://github.com/blazegraph/database/releases/download/BLAZEGRAPH_RELEASE_2_1_5/blazegraph.jar
-/usr/lib/jvm/java-8-openjdk/bin/java -server -jar blazegraph.jar &
+/usr/lib/jvm/java-8-openjdk/bin/java -server -jar ../blazegraph.jar &
 sleep 10
 curl -f -X POST -H 'Content-Type:text/turtle' -T "explore-${DATASET_SIZE}.nt" http://localhost:9999/blazegraph/sparql
 ./testdriver -mt ${PARALLELISM} -ucf usecases/explore/sparql.txt -o "../bsbm.explore.blazegraph.2.1.5.${DATASET_SIZE}.${PARALLELISM}.xml" http://localhost:9999/blazegraph/sparql
 ./testdriver -mt ${PARALLELISM} -ucf usecases/exploreAndUpdate/sparql.txt -o "../bsbm.exploreAndUpdate.blazegraph.2.1.5.${DATASET_SIZE}.${PARALLELISM}.xml" http://localhost:9999/blazegraph/sparql -u http://localhost:9999/blazegraph/sparql -udataset "explore-update-${DATASET_SIZE}.nt"
 #./testdriver -mt ${PARALLELISM} -ucf usecases/businessIntelligence/sparql.txt -o "../bsbm.businessIntelligence.blazegraph.2.1.5.${DATASET_SIZE}.${PARALLELISM}.xml" http://localhost:9999/blazegraph/sparql
 kill $!
-rm blazegraph.jar
-rm blazegraph.jnl
-rm "explore-${DATASET_SIZE}.nt"
-rm "explore-update-${DATASET_SIZE}.nt"
-rm -r td_data
+rm -f blazegraph.jnl
+rm -f "explore-${DATASET_SIZE}.nt"
+rm -f "explore-update-${DATASET_SIZE}.nt"
+rm -rf td_data

bench/bsbm_graphdb.sh

@@ -3,21 +3,22 @@
 DATASET_SIZE=100000
 PARALLELISM=16
 VERSION="9.3.3"
+
+set -eu
 cd bsbm-tools
 ./generate -fc -pc ${DATASET_SIZE} -s nt -fn "explore-${DATASET_SIZE}" -ud -ufn "explore-update-${DATASET_SIZE}"
-export JAVA_HOME=/usr/lib/jvm/java-11-openjdk
 ../graphdb-free-9.3.3/bin/graphdb -s -Dgraphdb.logger.root.level=WARN &
 sleep 10
 curl -f -X POST http://localhost:7200/rest/repositories -H 'Content-Type:application/json' -d '
-{"id":"test","params":{"ruleset":{"label":"Ruleset","name":"ruleset","value":"empty"},"title":{"label":"Repository title","name":"title","value":"GraphDB Free repository"},"checkForInconsistencies":{"label":"Check for inconsistencies","name":"checkForInconsistencies","value":"false"},"disableSameAs":{"label":"Disable owl:sameAs","name":"disableSameAs","value":"true"},"baseURL":{"label":"Base URL","name":"baseURL","value":"http://example.org/owlim#"},"repositoryType":{"label":"Repository type","name":"repositoryType","value":"file-repository"},"id":{"label":"Repository ID","name":"id","value":"repo-test"},"storageFolder":{"label":"Storage folder","name":"storageFolder","value":"storage"}},"title":"Test","type":"free"}
+{"id":"bsbm","params":{"ruleset":{"label":"Ruleset","name":"ruleset","value":"empty"},"title":{"label":"Repository title","name":"title","value":"GraphDB Free repository"},"checkForInconsistencies":{"label":"Check for inconsistencies","name":"checkForInconsistencies","value":"false"},"disableSameAs":{"label":"Disable owl:sameAs","name":"disableSameAs","value":"true"},"baseURL":{"label":"Base URL","name":"baseURL","value":"http://example.org/owlim#"},"repositoryType":{"label":"Repository type","name":"repositoryType","value":"file-repository"},"id":{"label":"Repository ID","name":"id","value":"repo-bsbm"},"storageFolder":{"label":"Storage folder","name":"storageFolder","value":"storage"}},"title":"BSBM","type":"free"}
 '
-curl -f -X PUT -H 'Content-Type:application/n-triples' -T "explore-${DATASET_SIZE}.nt" http://localhost:7200/repositories/test/statements
-./testdriver -mt ${PARALLELISM} -ucf usecases/explore/sparql.txt -o "../bsbm.explore.graphdb.${VERSION}.${DATASET_SIZE}.${PARALLELISM}.xml" http://localhost:7200/repositories/test
-./testdriver -mt ${PARALLELISM} -ucf usecases/exploreAndUpdate/sparql.txt -o "../bsbm.exploreAndUpdate.graphdb.${VERSION}.${DATASET_SIZE}.${PARALLELISM}.xml" http://localhost:7200/repositories/test -u http://localhost:7200/repositories/test/statements -udataset "explore-update-${DATASET_SIZE}.nt"
-#./testdriver -mt ${PARALLELISM} -ucf usecases/businessIntelligence/sparql.txt -o "../bsbm.businessIntelligence.graphdb.${VERSION}.${DATASET_SIZE}.${PARALLELISM}.xml" http://localhost:7200/repositories/test
+curl -f -X PUT -H 'Content-Type:application/n-triples' -T "explore-${DATASET_SIZE}.nt" http://localhost:7200/repositories/bsbm/statements
+./testdriver -mt ${PARALLELISM} -ucf usecases/explore/sparql.txt -o "../bsbm.explore.graphdb.${VERSION}.${DATASET_SIZE}.${PARALLELISM}.xml" http://localhost:7200/repositories/bsbm
+./testdriver -mt ${PARALLELISM} -ucf usecases/exploreAndUpdate/sparql.txt -o "../bsbm.exploreAndUpdate.graphdb.${VERSION}.${DATASET_SIZE}.${PARALLELISM}.xml" http://localhost:7200/repositories/bsbm -u http://localhost:7200/repositories/bsbm/statements -udataset "explore-update-${DATASET_SIZE}.nt"
+#./testdriver -mt ${PARALLELISM} -ucf usecases/businessIntelligence/sparql.txt -o "../bsbm.businessIntelligence.graphdb.${VERSION}.${DATASET_SIZE}.${PARALLELISM}.xml" http://localhost:7200/repositories/bsbm
 kill $!
 sleep 5
-rm -r ../graphdb-free-9.3.3/data
-rm "explore-${DATASET_SIZE}.nt"
-rm "explore-update-${DATASET_SIZE}.nt"
-rm -r td_data
+rm -rf ../graphdb-free-9.3.3/data
+rm -f "explore-${DATASET_SIZE}.nt"
+rm -f "explore-update-${DATASET_SIZE}.nt"
+rm -rf td_data

bench/bsbm_jena.sh

@@ -3,11 +3,12 @@
 DATASET_SIZE=100000 # number of products in the dataset. There is around 350 triples generated by product.
 PARALLELISM=16
 VERSION="4.3.2"
-cd bsbm-tools
+
+set -eu
+wget -nc https://downloads.apache.org/jena/binaries/apache-jena-${VERSION}.zip
+cd bsbm-tools || exit
 ./generate -fc -pc ${DATASET_SIZE} -s nt -fn "explore-${DATASET_SIZE}" -ud -ufn "explore-update-${DATASET_SIZE}"
-wget https://downloads.apache.org/jena/binaries/apache-jena-${VERSION}.zip
-unzip apache-jena-${VERSION}.zip
-rm apache-jena-${VERSION}.zip
+unzip ../"apache-jena-${VERSION}.zip"
 ./apache-jena-${VERSION}/bin/tdb2.tdbloader --loader=parallel --loc=td_data "explore-${DATASET_SIZE}.nt"
 wget https://downloads.apache.org/jena/binaries/apache-jena-fuseki-${VERSION}.zip
 unzip apache-jena-fuseki-${VERSION}.zip
@@ -19,9 +20,9 @@ sleep 10
 ./testdriver -mt ${PARALLELISM} -ucf usecases/exploreAndUpdate/sparql.txt -o "../bsbm.exploreAndUpdate.jena.${VERSION}.${DATASET_SIZE}.${PARALLELISM}.xml" http://localhost:3030/bsbm/query -u http://localhost:3030/bsbm/update -udataset "explore-update-${DATASET_SIZE}.nt"
 #./testdriver -mt ${PARALLELISM} -ucf usecases/businessIntelligence/sparql.txt -o "../bsbm.businessIntelligence.jena.${VERSION}.${DATASET_SIZE}.${PARALLELISM}.xml" http://localhost:3030/bsbm/query
 kill $!
-rm "explore-${DATASET_SIZE}.nt"
-rm "explore-update-${DATASET_SIZE}.nt"
-rm -r td_data
-rm -r run
-rm -r apache-jena-${VERSION}
-rm -r apache-jena-fuseki-${VERSION}
+rm -f "explore-${DATASET_SIZE}.nt"
+rm -f "explore-update-${DATASET_SIZE}.nt"
+rm -rf td_data
+rm -rf run
+rm -rf apache-jena-${VERSION}
+rm -rf apache-jena-fuseki-${VERSION}

bench/bsbm_oxigraph.sh

@@ -2,18 +2,20 @@
 
 DATASET_SIZE=100000 # number of products in the dataset. There is around 350 triples generated by product.
 PARALLELISM=16
+
+set -eu
 cd bsbm-tools
 ./generate -fc -pc ${DATASET_SIZE} -s nt -fn "explore-${DATASET_SIZE}" -ud -ufn "explore-update-${DATASET_SIZE}"
-cargo build --release --manifest-path="../../server/Cargo.toml"
-VERSION=$(./../../target/release/oxigraph_server --version | sed 's/oxigraph_server //g')
-./../../target/release/oxigraph_server --location oxigraph_data load --file "explore-${DATASET_SIZE}.nt"
-./../../target/release/oxigraph_server --location oxigraph_data serve --bind 127.0.0.1:7878 &
+cargo build --release --manifest-path="../../cli/Cargo.toml"
+VERSION=$(./../../target/release/oxigraph --version | sed 's/oxigraph //g')
+./../../target/release/oxigraph --location oxigraph_data load --file "explore-${DATASET_SIZE}.nt"
+./../../target/release/oxigraph --location oxigraph_data serve --bind 127.0.0.1:7878 &
 sleep 1
 ./testdriver -mt ${PARALLELISM} -ucf usecases/explore/sparql.txt -o "../bsbm.explore.oxigraph.${VERSION}.${DATASET_SIZE}.${PARALLELISM}.xml" http://127.0.0.1:7878/query
 ./testdriver -mt ${PARALLELISM} -ucf usecases/exploreAndUpdate/sparql.txt -o "../bsbm.exploreAndUpdate.oxigraph.${VERSION}.${DATASET_SIZE}.${PARALLELISM}.xml" http://127.0.0.1:7878/query -u http://127.0.0.1:7878/update -udataset "explore-update-${DATASET_SIZE}.nt"
 #./testdriver -mt ${PARALLELISM} -ucf usecases/businessIntelligence/sparql.txt -o "../bsbm.businessIntelligence.${VERSION}.${DATASET_SIZE}.${PARALLELISM}.xml" "http://127.0.0.1:7878/query"
 kill $!
-rm -r oxigraph_data
-rm "explore-${DATASET_SIZE}.nt"
-rm "explore-update-${DATASET_SIZE}.nt"
-rm -r td_data
+rm -rf oxigraph_data
+rm -f "explore-${DATASET_SIZE}.nt"
+rm -f "explore-update-${DATASET_SIZE}.nt"
+rm -rf td_data

bench/bsbm_rdf4j.sh

@@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+
+DATASET_SIZE=100000
+PARALLELISM=16
+VERSION="4.2.2"
+TOMCAT_VERSION="9.0.71"
+
+set -eu
+wget -nc -O "rdf4j-${VERSION}.zip" "https://www.eclipse.org/downloads/download.php?file=/rdf4j/eclipse-rdf4j-${VERSION}-sdk.zip&mirror_id=1"
+wget -nc -O "tomcat-${TOMCAT_VERSION}.zip" "https://dlcdn.apache.org/tomcat/tomcat-9/v${TOMCAT_VERSION}/bin/apache-tomcat-${TOMCAT_VERSION}.zip"
+cd bsbm-tools || exit
+./generate -fc -pc ${DATASET_SIZE} -s nt -fn "explore-${DATASET_SIZE}" -ud -ufn "explore-update-${DATASET_SIZE}"
+wget -nc -O "rdf4j-${VERSION}.zip" "https://www.eclipse.org/downloads/download.php?file=/rdf4j/eclipse-rdf4j-${VERSION}-sdk.zip&mirror_id=1"
+unzip ../"rdf4j-${VERSION}.zip"
+unzip ../"tomcat-${TOMCAT_VERSION}.zip"
+CATALINA_HOME="$(pwd)/apache-tomcat-${TOMCAT_VERSION}"
+export CATALINA_HOME
+export JAVA_OPTS="-Dorg.eclipse.rdf4j.appdata.basedir=${CATALINA_HOME}/rdf4j"
+cp "eclipse-rdf4j-${VERSION}"/war/rdf4j-server.war "${CATALINA_HOME}"/webapps/
+chmod +x "${CATALINA_HOME}"/bin/*.sh
+"${CATALINA_HOME}"/bin/startup.sh
+sleep 30
+curl -f -X PUT http://localhost:8080/rdf4j-server/repositories/bsbm -H 'Content-Type:text/turtle' -d '
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
+@prefix rep: <http://www.openrdf.org/config/repository#>.
+@prefix sr: <http://www.openrdf.org/config/repository/sail#>.
+@prefix sail: <http://www.openrdf.org/config/sail#>.
+
+[] a rep:Repository ;
+  rep:repositoryID "bsbm" ;
+  rdfs:label "BSBM" ;
+  rep:repositoryImpl [
+    rep:repositoryType "openrdf:SailRepository" ;
+    sr:sailImpl [
+      sail:sailType "rdf4j:LmdbStore"
+    ]
+  ] .
+'
+sleep 10
+curl -f -X PUT -H 'Content-Type:application/n-triples' -T "explore-${DATASET_SIZE}.nt" http://localhost:8080/rdf4j-server/repositories/bsbm/statements
+./testdriver -mt ${PARALLELISM} -ucf usecases/explore/sparql.txt -o "../bsbm.explore.rdf4j-lmdb.${VERSION}.${DATASET_SIZE}.${PARALLELISM}.xml" http://localhost:8080/rdf4j-server/repositories/bsbm
+./testdriver -mt ${PARALLELISM} -ucf usecases/exploreAndUpdate/sparql.txt -o "../bsbm.exploreAndUpdate.rdf4j-lmdb.${VERSION}.${DATASET_SIZE}.${PARALLELISM}.xml" http://localhost:8080/rdf4j-server/repositories/bsbm -u http://localhost:8080/rdf4j-server/repositories/bsbm/statements -udataset "explore-update-${DATASET_SIZE}.nt"
+#./testdriver -mt ${PARALLELISM} -ucf usecases/businessIntelligence/sparql.txt -o "../bsbm.businessIntelligence.rdf4j-lmdb.${VERSION}.${DATASET_SIZE}.${PARALLELISM}.xml" http://localhost:8080/rdf4j-server/repositories/bsbm
+"${CATALINA_HOME}"/bin/shutdown.sh
+rm -f "explore-${DATASET_SIZE}.nt"
+rm -f "explore-update-${DATASET_SIZE}.nt"
+rm -rf td_data
+rm -rf "eclipse-rdf4j-${VERSION}"
+rm -rf "apache-tomcat-${TOMCAT_VERSION}"

bench/bsbm_virtuoso.sh

@@ -3,6 +3,8 @@
 DATASET_SIZE=100000 # number of products in the dataset. There is around 350 triples generated by product.
 PARALLELISM=16
 VERSION="7.2.5"
+
+set -eu
 cd bsbm-tools
 ./generate -fc -pc ${DATASET_SIZE} -s nt -fn "explore-${DATASET_SIZE}" -ud -ufn "explore-update-${DATASET_SIZE}"
 cp ../virtuoso-opensource/database/virtuoso.ini.sample virtuoso.ini
@@ -18,7 +20,7 @@ EOF
 # ./testdriver -mt ${PARALLELISM} -ucf usecases/exploreAndUpdate/sparql.txt -o "../bsbm.exploreAndUpdate.virtuoso.${DATASET_SIZE}.${PARALLELISM}.${PARALLELISM}.${VERSION}.xml" 'http://localhost:8890/sparql?graph-uri=urn:graph:test' -u 'http://dba:dba@localhost:8890/sparql-auth?graph-uri=urn:graph:test' -udataset "explore-update-${DATASET_SIZE}.nt"
 # ./testdriver -mt ${PARALLELISM} -ucf usecases/businessIntelligence/sparql.txt -o "../bsbm.businessIntelligence.virtuoso.${VERSION}.${DATASET_SIZE}.${PARALLELISM}.xml" 'http://localhost:8890/sparql?graph-uri=urn:graph:test'
 kill $!
-rm -r ../database
-rm "explore-${DATASET_SIZE}.nt"
-rm "explore-update-${DATASET_SIZE}.nt"
-rm -r td_data
+rm -rf ../database
+rm -f "explore-${DATASET_SIZE}.nt"
+rm -f "explore-update-${DATASET_SIZE}.nt"
+rm -rf td_data

bench/explanation_to_flamegraph.py

@@ -0,0 +1,63 @@
+"""
+Converts a SPARQL query JSON explanation file to a flamegraph.
+Usage: python explanation_to_flamegraph.py explanation.json flamegraph.svg
+"""
+import json
+import subprocess
+from argparse import ArgumentParser
+from pathlib import Path
+from shutil import which
+from tempfile import NamedTemporaryFile
+
+parser = ArgumentParser(
+    prog='OxigraphFlamegraph',
+    description='Builds a flamegraph from the Oxigraph query explanation JSON format',
+    epilog='Text at the bottom of help')
+parser.add_argument('json_explanation', type=Path)
+parser.add_argument('flamegraph_svg', type=Path)
+args = parser.parse_args()
+
+
+def trace_line(label: str, value: float):
+    return f"{label} {int(value * 1_000_000)}"
+
+
+with args.json_explanation.open('rt') as fp:
+    explanation = json.load(fp)
+trace = []
+if "parsing duration in seconds" in explanation:
+    trace.append(trace_line("parsing", explanation['parsing duration in seconds']))
+if "planning duration in seconds" in explanation:
+    trace.append(trace_line("planning", explanation['planning duration in seconds']))
+already_used_names = {}
+
+
+def add_to_trace(node, path):
+    path = f"{path};{node['name'].replace(' ', '`')}"
+    if path in already_used_names:
+        already_used_names[path] += 1
+        path = f"{path}`{already_used_names[path]}"
+    else:
+        already_used_names[path] = 0
+    samples = node['duration in seconds'] - sum(child['duration in seconds'] for child in node.get("children", ()))
+    if int(samples * 1_000_000) > 0:
+        trace.append(trace_line(path, samples))
+    for i, child in enumerate(node.get("children", ())):
+        add_to_trace(child, path)
+
+
+add_to_trace(explanation["plan"], 'eval')
+inferno = which('inferno-flamegraph')
+flamegraph_pl = which('flamegraph.pl')
+if inferno:
+    args.flamegraph_svg.write_text(
+        subprocess.run([inferno], input='\n'.join(trace), stdout=subprocess.PIPE, text=True).stdout)
+elif flamegraph_pl:
+    with NamedTemporaryFile('w+t') as fp:
+        fp.write('\n'.join(trace))
+        fp.flush()
+        args.flamegraph_svg.write_text(
+            subprocess.run([flamegraph_pl, fp.name], stdout=subprocess.PIPE, text=True).stdout)
+else:
+    raise Exception(
+        'This script requires either the inferno-flamegraph from https://github.com/jonhoo/inferno either the flamegraph.pl script from https://github.com/brendangregg/FlameGraph to be installed and be in $PATH.')

bench/explanation_to_trace.py

@@ -0,0 +1,52 @@
+"""
+Converts a SPARQL query JSON explanation file to a tracing event file compatible with Chrome.
+Usage: python explanation_to_trace.py explanation.json trace.json
+"""
+import json
+from argparse import ArgumentParser
+from pathlib import Path
+
+parser = ArgumentParser(
+    prog='OxigraphTracing',
+    description='Builds a Trace Event Format file from the Oxigraph query explanation JSON format')
+parser.add_argument('json_explanation', type=Path)
+parser.add_argument('json_trace_event', type=Path)
+args = parser.parse_args()
+
+with args.json_explanation.open('rt') as fp:
+    explanation = json.load(fp)
+trace = []
+
+
+def trace_element(name: str, cat: str, start_s: float, duration_s: float):
+    return {
+        "name": name,
+        "cat": cat,
+        "ph": "X",
+        "ts": int(start_s * 1_000_000),
+        "dur": int(duration_s * 1_000_000),
+        "pid": 1
+    }
+
+
+def add_to_trace(node, path, start_time: float):
+    path = f"{path};{node['name'].replace(' ', '`')}"
+    trace.append(trace_element(node["name"], node["name"].split("(")[0], start_time, node["duration in seconds"]))
+    for child in node.get("children", ()):
+        add_to_trace(child, path, start_time)
+        start_time += child["duration in seconds"]
+
+
+current_time = 0
+if "parsing duration in seconds" in explanation:
+    d = explanation["parsing duration in seconds"]
+    trace.append(trace_element(f"parsing", "parsing", current_time, d))
+    current_time += d
+if "planning duration in seconds" in explanation:
+    d = explanation["planning duration in seconds"]
+    trace.append(trace_element(f"planning", "planning", current_time, d))
+    current_time += d
+add_to_trace(explanation["plan"], 'eval', current_time)
+
+with args.json_trace_event.open("wt") as fp:
+    json.dump(trace, fp)

deny.toml

@@ -1,12 +1,18 @@
+[advisories]
+version = 2
+ignore = ["RUSTSEC-2018-0015"]
+
 [licenses]
-unlicensed = "deny"
+version = 2
 allow = [
-    "MIT",
     "Apache-2.0",
-    "Apache-2.0 WITH LLVM-exception"
+    "Apache-2.0 WITH LLVM-exception",
+    "BSD-3-Clause",
+    "ISC",
+    "MIT",
+    "OpenSSL",
+    "Unicode-DFS-2016"
 ]
-allow-osi-fsf-free = "either"
-default = "deny"
 
 [[licenses.clarify]]
 name = "ring"

docs/arch-diagram.svg

@@ -0,0 +1,120 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="624" height="384" class="svgbob">
+    <style>.svgbob line, .svgbob path, .svgbob circle, .svgbob rect, .svgbob polygon {
+        stroke: black;
+        stroke-width: 2;
+        stroke-opacity: 1;
+        fill-opacity: 1;
+        stroke-linecap: round;
+        stroke-linejoin: miter;
+        }
+        .svgbob text {
+        white-space: pre;
+        fill: black;
+        font-family: Iosevka Fixed, monospace;
+        font-size: 14px;
+        }
+        .svgbob rect.backdrop {
+        stroke: none;
+        fill: white;
+        }
+        .svgbob .broken {
+        stroke-dasharray: 8;
+        }
+        .svgbob .filled {
+        fill: black;
+        }
+        .svgbob .bg_filled {
+        fill: white;
+        stroke-width: 1;
+        }
+        .svgbob .nofill {
+        fill: white;
+        }
+        .svgbob .end_marked_arrow {
+        marker-end: url(#arrow);
+        }
+        .svgbob .start_marked_arrow {
+        marker-start: url(#arrow);
+        }
+        .svgbob .end_marked_diamond {
+        marker-end: url(#diamond);
+        }
+        .svgbob .start_marked_diamond {
+        marker-start: url(#diamond);
+        }
+        .svgbob .end_marked_circle {
+        marker-end: url(#circle);
+        }
+        .svgbob .start_marked_circle {
+        marker-start: url(#circle);
+        }
+        .svgbob .end_marked_open_circle {
+        marker-end: url(#open_circle);
+        }
+        .svgbob .start_marked_open_circle {
+        marker-start: url(#open_circle);
+        }
+        .svgbob .end_marked_big_open_circle {
+        marker-end: url(#big_open_circle);
+        }
+        .svgbob .start_marked_big_open_circle {
+        marker-start: url(#big_open_circle);
+        }<!--separator-->.svgbob .r{
+        fill: papayawhip;
+        }
+        .svgbob .p{
+        fill: lightyellow;
+        }
+        .svgbob .j{
+        fill: lightgreen;
+        }
+    </style>
+    <defs>
+        <marker id="arrow" viewBox="-2 -2 8 8" refX="4" refY="2" markerWidth="7" markerHeight="7"
+                orient="auto-start-reverse">
+            <polygon points="0,0 0,4 4,2 0,0"></polygon>
+        </marker>
+        <marker id="diamond" viewBox="-2 -2 8 8" refX="4" refY="2" markerWidth="7" markerHeight="7"
+                orient="auto-start-reverse">
+            <polygon points="0,2 2,0 4,2 2,4 0,2"></polygon>
+        </marker>
+        <marker id="circle" viewBox="0 0 8 8" refX="4" refY="4" markerWidth="7" markerHeight="7"
+                orient="auto-start-reverse">
+            <circle cx="4" cy="4" r="2" class="filled"></circle>
+        </marker>
+        <marker id="open_circle" viewBox="0 0 8 8" refX="4" refY="4" markerWidth="7" markerHeight="7"
+                orient="auto-start-reverse">
+            <circle cx="4" cy="4" r="2" class="bg_filled"></circle>
+        </marker>
+        <marker id="big_open_circle" viewBox="0 0 8 8" refX="4" refY="4" markerWidth="7" markerHeight="7"
+                orient="auto-start-reverse">
+            <circle cx="4" cy="4" r="3" class="bg_filled"></circle>
+        </marker>
+    </defs>
+    <rect class="backdrop" x="0" y="0" width="624" height="384"></rect>
+    <rect x="4" y="8" width="152" height="32" class="solid nofill r" rx="0"></rect>
+    <text x="18" y="28">oxigraph CLI</text>
+    <rect x="244" y="8" width="136" height="32" class="solid nofill p" rx="0"></rect>
+    <text x="258" y="28">pyoxigraph</text>
+    <rect x="468" y="8" width="144" height="32" class="solid nofill j" rx="0"></rect>
+    <text x="482" y="28">oxigraph</text>
+    <text x="554" y="28">JS</text>
+    <rect x="4" y="72" width="608" height="32" class="solid nofill r" rx="0"></rect>
+    <text x="18" y="92">oxigraph</text>
+    <rect x="68" y="136" width="232" height="32" class="solid nofill r" rx="0"></rect>
+    <text x="82" y="156">oxrdfio</text>
+    <rect x="348" y="136" width="112" height="32" class="solid nofill r" rx="0"></rect>
+    <text x="362" y="156">sparopt</text>
+    <rect x="68" y="200" width="96" height="32" class="solid nofill r" rx="0"></rect>
+    <text x="82" y="220">oxttl</text>
+    <rect x="180" y="200" width="120" height="32" class="solid nofill r" rx="0"></rect>
+    <text x="194" y="220">oxrdfxml</text>
+    <rect x="316" y="200" width="144" height="32" class="solid nofill r" rx="0"></rect>
+    <text x="330" y="220">spargebra</text>
+    <rect x="476" y="200" width="136" height="32" class="solid nofill r" rx="0"></rect>
+    <text x="490" y="220">sparesults</text>
+    <rect x="36" y="264" width="576" height="32" class="solid nofill r" rx="0"></rect>
+    <text x="50" y="284">oxrdf</text>
+    <rect x="4" y="328" width="152" height="32" class="solid nofill r" rx="0"></rect>
+    <text x="18" y="348">oxsdatatypes</text>
+</svg>

docs/arch-diagram.txt

@@ -0,0 +1,35 @@
++------------------+          +----------------+          +-----------------+
++ oxigraph CLI {r} +          + pyoxigraph {p} +          + oxigraph JS {j} +
++------------------+          +----------------+          +-----------------+
+
++---------------------------------------------------------------------------+
++ oxigraph (Rust) {r}                                                       +
++---------------------------------------------------------------------------+
+
+        +----------------------------+     +-------------+
+        + oxrdfio {r}                +     + sparopt {r} +
+        +----------------------------+     +-------------+
+
+        +-----------+ +--------------+ +-----------------+ +----------------+
+        + oxttl {r} + + oxrdfxml {r} + + spargebra {r}   + + sparesults {r} +
+        +-----------+ +--------------+ +-----------------+ +----------------+
+
+    +-----------------------------------------------------------------------+
+    + oxrdf {r}                                                             +
+    +-----------------------------------------------------------------------+
+
++------------------+
++ oxsdatatypes {r} +
++------------------+
+
+
+# Legend:
+r = {
+    fill: papayawhip;
+}
+p = {
+    fill: lightyellow;
+}
+j = {
+    fill: lightgreen;
+}

fuzz/Cargo.toml

@@ -1,7 +1,6 @@
 [package]
 name = "oxigraph-fuzz"
 version = "0.0.0"
-authors = ["Automatically generated"]
 publish = false
 edition = "2021"
 
@@ -9,12 +8,38 @@ edition = "2021"
 cargo-fuzz = true
 
 [dependencies]
+anyhow = "1.0.72"
 libfuzzer-sys = "0.4"
-spargebra = { path = "../lib/spargebra", features = ["rdf-star"] }
+oxigraph = { path = "../lib/oxigraph", default-features = false }
+oxrdf = { path = "../lib/oxrdf", features = ["rdf-star"] }
+oxrdfxml = { path = "../lib/oxrdfxml" }
+oxttl = { path = "../lib/oxttl", features = ["rdf-star"] }
 sparesults = { path = "../lib/sparesults", features = ["rdf-star"] }
+spargebra = { path = "../lib/spargebra", features = ["rdf-star", "sep-0006"] }
+sparql-smith = { path = "../lib/sparql-smith", features = ["sep-0006"] }
+
+[profile.release]
+codegen-units = 1
+debug = true
 
 [workspace]
 
+[[bin]]
+name = "nquads"
+path = "fuzz_targets/nquads.rs"
+
+[[bin]]
+name = "n3"
+path = "fuzz_targets/n3.rs"
+
+[[bin]]
+name = "rdf_xml"
+path = "fuzz_targets/rdf_xml.rs"
+
+[[bin]]
+name = "sparql_eval"
+path = "fuzz_targets/sparql_eval.rs"
+
 [[bin]]
 name = "sparql_query"
 path = "fuzz_targets/sparql_query.rs"
@@ -34,3 +59,7 @@ path = "fuzz_targets/sparql_results_xml.rs"
 [[bin]]
 name = "sparql_results_tsv"
 path = "fuzz_targets/sparql_results_tsv.rs"
+
+[[bin]]
+name = "trig"
+path = "fuzz_targets/trig.rs"

fuzz/fuzz_targets/n3.rs

@@ -0,0 +1,28 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use oxttl::N3Parser;
+
+fuzz_target!(|data: &[u8]| {
+    let mut quads = Vec::new();
+    let mut parser = N3Parser::new()
+        .with_base_iri("http://example.com/")
+        .unwrap()
+        .parse();
+    for chunk in data.split(|c| *c == 0xFF) {
+        parser.extend_from_slice(chunk);
+        while let Some(result) = parser.read_next() {
+            if let Ok(quad) = result {
+                quads.push(quad);
+            }
+        }
+    }
+    parser.end();
+    while let Some(result) = parser.read_next() {
+        if let Ok(quad) = result {
+            quads.push(quad);
+        }
+    }
+    assert!(parser.is_end());
+    //TODO: serialize
+});

fuzz/fuzz_targets/nquads.rs

@@ -0,0 +1,84 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use oxrdf::Quad;
+use oxttl::{NQuadsParser, NQuadsSerializer};
+
+fn parse<'a>(
+    chunks: impl IntoIterator<Item = &'a [u8]>,
+    unchecked: bool,
+) -> (Vec<Quad>, Vec<String>) {
+    let mut quads = Vec::new();
+    let mut errors = Vec::new();
+    let mut parser = NQuadsParser::new().with_quoted_triples();
+    if unchecked {
+        parser = parser.unchecked();
+    }
+    let mut reader = parser.parse();
+    for chunk in chunks {
+        reader.extend_from_slice(chunk);
+        while let Some(result) = reader.read_next() {
+            match result {
+                Ok(quad) => quads.push(quad),
+                Err(error) => errors.push(error.to_string()),
+            }
+        }
+    }
+    reader.end();
+    while let Some(result) = reader.read_next() {
+        match result {
+            Ok(quad) => quads.push(quad),
+            Err(error) => errors.push(error.to_string()),
+        }
+    }
+    assert!(reader.is_end());
+    (quads, errors)
+}
+
+fuzz_target!(|data: &[u8]| {
+    // We parse with splitting
+    let (quads, errors) = parse(data.split(|c| *c == 0xFF), false);
+    // We parse without splitting
+    let (quads_without_split, errors_without_split) = parse(
+        [data
+            .iter()
+            .copied()
+            .filter(|c| *c != 0xFF)
+            .collect::<Vec<_>>()
+            .as_slice()],
+        false,
+    );
+    assert_eq!(quads, quads_without_split);
+    assert_eq!(errors, errors_without_split);
+
+    // We test also unchecked if valid
+    if errors.is_empty() {
+        let (quads_unchecked, errors_unchecked) = parse(data.split(|c| *c == 0xFF), true);
+        assert!(errors_unchecked.is_empty());
+        assert_eq!(quads, quads_unchecked);
+    }
+
+    // We serialize
+    let mut writer = NQuadsSerializer::new().serialize_to_write(Vec::new());
+    for quad in &quads {
+        writer.write_quad(quad).unwrap();
+    }
+    let new_serialization = writer.finish();
+
+    // We parse the serialization
+    let new_quads = NQuadsParser::new()
+        .with_quoted_triples()
+        .parse_read(new_serialization.as_slice())
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|e| {
+            format!(
+                "Error on {:?} from {quads:?} based on {:?}: {e}",
+                String::from_utf8_lossy(&new_serialization),
+                String::from_utf8_lossy(data)
+            )
+        })
+        .unwrap();
+
+    // We check the roundtrip has not changed anything
+    assert_eq!(new_quads, quads);
+});

fuzz/fuzz_targets/rdf_xml.rs

@@ -0,0 +1,35 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use oxrdfxml::{RdfXmlParser, RdfXmlSerializer};
+
+fuzz_target!(|data: &[u8]| {
+    // We parse
+    let triples = RdfXmlParser::new()
+        .parse_read(data)
+        .flatten()
+        .collect::<Vec<_>>();
+
+    // We serialize
+    let mut writer = RdfXmlSerializer::new().serialize_to_write(Vec::new());
+    for triple in &triples {
+        writer.write_triple(triple).unwrap();
+    }
+    let new_serialization = writer.finish().unwrap();
+
+    // We parse the serialization
+    let new_triples = RdfXmlParser::new()
+        .parse_read(new_serialization.as_slice())
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|e| {
+            format!(
+                "Error on {:?} from {triples:?} based on {:?}: {e}",
+                String::from_utf8_lossy(&new_serialization),
+                String::from_utf8_lossy(data)
+            )
+        })
+        .unwrap();
+
+    // We check the roundtrip has not changed anything
+    assert_eq!(new_triples, triples);
+});

fuzz/fuzz_targets/sparql_eval.rs

@@ -0,0 +1,61 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use oxigraph::io::RdfFormat;
+use oxigraph::sparql::{Query, QueryOptions, QueryResults, QuerySolutionIter};
+use oxigraph::store::Store;
+use std::sync::OnceLock;
+
+fuzz_target!(|data: sparql_smith::Query| {
+    static STORE: OnceLock<Store> = OnceLock::new();
+    let store = STORE.get_or_init(|| {
+        let store = Store::new().unwrap();
+        store
+            .load_from_read(RdfFormat::TriG, sparql_smith::DATA_TRIG.as_bytes())
+            .unwrap();
+        store
+    });
+
+    let query_str = data.to_string();
+    if let Ok(query) = Query::parse(&query_str, None) {
+        let options = QueryOptions::default();
+        let with_opt = store.query_opt(query.clone(), options.clone()).unwrap();
+        let without_opt = store
+            .query_opt(query, options.without_optimizations())
+            .unwrap();
+        match (with_opt, without_opt) {
+            (QueryResults::Solutions(with_opt), QueryResults::Solutions(without_opt)) => {
+                assert_eq!(
+                    query_solutions_key(with_opt, query_str.contains(" REDUCED ")),
+                    query_solutions_key(without_opt, query_str.contains(" REDUCED "))
+                )
+            }
+            (QueryResults::Graph(_), QueryResults::Graph(_)) => unimplemented!(),
+            (QueryResults::Boolean(with_opt), QueryResults::Boolean(without_opt)) => {
+                assert_eq!(with_opt, without_opt)
+            }
+            _ => panic!("Different query result types"),
+        }
+    }
+});
+
+fn query_solutions_key(iter: QuerySolutionIter, is_reduced: bool) -> String {
+    // TODO: ordering
+    let mut b = iter
+        .into_iter()
+        .map(|t| {
+            let mut b = t
+                .unwrap()
+                .iter()
+                .map(|(var, val)| format!("{var}: {val}"))
+                .collect::<Vec<_>>();
+            b.sort_unstable();
+            b.join(" ")
+        })
+        .collect::<Vec<_>>();
+    b.sort_unstable();
+    if is_reduced {
+        b.dedup();
+    }
+    b.join("\n")
+}

fuzz/fuzz_targets/sparql_query.rs

@@ -1,10 +1,7 @@
 #![no_main]
 use libfuzzer_sys::fuzz_target;
 use spargebra::Query;
-use std::str;
 
-fuzz_target!(|data: &[u8]| {
-    if let Ok(data) = str::from_utf8(data) {
-        Query::parse(data, None);
-    }
+fuzz_target!(|data: &str| {
+    let _ = Query::parse(data, None);
 });

fuzz/fuzz_targets/sparql_results_json.rs

@@ -1,15 +1,6 @@
 #![no_main]
 use libfuzzer_sys::fuzz_target;
-use sparesults::{QueryResultsFormat, QueryResultsParser, QueryResultsReader};
+use oxigraph_fuzz::result_format::fuzz_result_format;
+use sparesults::QueryResultsFormat;
 
-fuzz_target!(|data: &[u8]| {
-    let parser = QueryResultsParser::from_format(QueryResultsFormat::Json);
-    if let Ok(QueryResultsReader::Solutions(solutions)) = parser.read_results(data) {
-        for s in solutions {
-            if s.is_err() {
-                // TODO: avoid infinite loop of errors
-                break;
-            }
-        }
-    }
-});
+fuzz_target!(|data: &[u8]| fuzz_result_format(QueryResultsFormat::Json, data));

fuzz/fuzz_targets/sparql_results_tsv.rs

@@ -1,10 +1,6 @@
 #![no_main]
 use libfuzzer_sys::fuzz_target;
-use sparesults::{QueryResultsFormat, QueryResultsParser, QueryResultsReader};
+use oxigraph_fuzz::result_format::fuzz_result_format;
+use sparesults::QueryResultsFormat;
 
-fuzz_target!(|data: &[u8]| {
-    let parser = QueryResultsParser::from_format(QueryResultsFormat::Tsv);
-    if let Ok(QueryResultsReader::Solutions(solutions)) = parser.read_results(data) {
-        for _ in solutions {}
-    }
-});
+fuzz_target!(|data: &[u8]| fuzz_result_format(QueryResultsFormat::Tsv, data));

fuzz/fuzz_targets/sparql_results_xml.rs

@@ -1,10 +1,6 @@
 #![no_main]
 use libfuzzer_sys::fuzz_target;
-use sparesults::{QueryResultsFormat, QueryResultsParser, QueryResultsReader};
+use oxigraph_fuzz::result_format::fuzz_result_format;
+use sparesults::QueryResultsFormat;
 
-fuzz_target!(|data: &[u8]| {
-    let parser = QueryResultsParser::from_format(QueryResultsFormat::Xml);
-    if let Ok(QueryResultsReader::Solutions(solutions)) = parser.read_results(data) {
-        for _ in solutions {}
-    }
-});
+fuzz_target!(|data: &[u8]| fuzz_result_format(QueryResultsFormat::Xml, data));

fuzz/fuzz_targets/sparql_update.rs

@@ -3,8 +3,6 @@ use libfuzzer_sys::fuzz_target;
 use spargebra::Update;
 use std::str;
 
-fuzz_target!(|data: &[u8]| {
-    if let Ok(data) = str::from_utf8(data) {
-        Update::parse(data, None);
-    }
+fuzz_target!(|data: &str| {
+    let _ = Update::parse(data, None);
 });

fuzz/fuzz_targets/trig.rs

@@ -0,0 +1,166 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use oxrdf::graph::CanonicalizationAlgorithm;
+use oxrdf::{Dataset, GraphName, Quad, Subject, Term, Triple};
+use oxttl::{TriGParser, TriGSerializer};
+
+fn parse<'a>(
+    chunks: impl IntoIterator<Item = &'a [u8]>,
+    unchecked: bool,
+) -> (Vec<Quad>, Vec<String>, Vec<(String, String)>) {
+    let mut quads = Vec::new();
+    let mut errors = Vec::new();
+    let mut parser = TriGParser::new()
+        .with_quoted_triples()
+        .with_base_iri("http://example.com/")
+        .unwrap();
+    if unchecked {
+        parser = parser.unchecked();
+    }
+    let mut reader = parser.parse();
+    for chunk in chunks {
+        reader.extend_from_slice(chunk);
+        while let Some(result) = reader.read_next() {
+            match result {
+                Ok(quad) => quads.push(quad),
+                Err(error) => errors.push(error.to_string()),
+            }
+        }
+    }
+    reader.end();
+    while let Some(result) = reader.read_next() {
+        match result {
+            Ok(quad) => quads.push(quad),
+            Err(error) => errors.push(error.to_string()),
+        }
+    }
+    assert!(reader.is_end());
+    (
+        quads,
+        errors,
+        reader
+            .prefixes()
+            .map(|(k, v)| (k.to_owned(), v.to_owned()))
+            .collect(),
+    )
+}
+
+fn count_triple_blank_nodes(triple: &Triple) -> usize {
+    (match &triple.subject {
+        Subject::BlankNode(_) => 1,
+        Subject::Triple(t) => count_triple_blank_nodes(t),
+        _ => 0,
+    }) + (match &triple.object {
+        Term::BlankNode(_) => 1,
+        Term::Triple(t) => count_triple_blank_nodes(t),
+        _ => 0,
+    })
+}
+
+fn count_quad_blank_nodes(quad: &Quad) -> usize {
+    (match &quad.subject {
+        Subject::BlankNode(_) => 1,
+        Subject::Triple(t) => count_triple_blank_nodes(t),
+        _ => 0,
+    }) + (match &quad.object {
+        Term::BlankNode(_) => 1,
+        Term::Triple(t) => count_triple_blank_nodes(t),
+        _ => 0,
+    }) + usize::from(matches!(quad.graph_name, GraphName::BlankNode(_)))
+}
+
+fn serialize_quads(quads: &[Quad], prefixes: Vec<(String, String)>) -> Vec<u8> {
+    let mut serializer = TriGSerializer::new();
+    for (prefix_name, prefix_iri) in prefixes {
+        serializer = serializer.with_prefix(prefix_name, prefix_iri).unwrap();
+    }
+    let mut writer = serializer.serialize_to_write(Vec::new());
+    for quad in quads {
+        writer.write_quad(quad).unwrap();
+    }
+    writer.finish().unwrap()
+}
+
+fuzz_target!(|data: &[u8]| {
+    // We parse with splitting
+    let (quads, errors, prefixes) = parse(data.split(|c| *c == 0xFF), false);
+    // We parse without splitting
+    let (quads_without_split, errors_without_split, _) = parse(
+        [data
+            .iter()
+            .copied()
+            .filter(|c| *c != 0xFF)
+            .collect::<Vec<_>>()
+            .as_slice()],
+        false,
+    );
+    let (quads_unchecked, errors_unchecked, _) = parse(data.split(|c| *c == 0xFF), true);
+    if errors.is_empty() {
+        assert!(errors_unchecked.is_empty());
+    }
+
+    let bnodes_count = quads.iter().map(count_quad_blank_nodes).sum::<usize>();
+    if bnodes_count == 0 {
+        assert_eq!(
+            quads,
+            quads_without_split,
+            "With split:\n{}\nWithout split:\n{}",
+            String::from_utf8_lossy(&serialize_quads(&quads, Vec::new())),
+            String::from_utf8_lossy(&serialize_quads(&quads_without_split, Vec::new()))
+        );
+        if errors.is_empty() {
+            assert_eq!(
+                quads,
+                quads_unchecked,
+                "Validating:\n{}\nUnchecked:\n{}",
+                String::from_utf8_lossy(&serialize_quads(&quads, Vec::new())),
+                String::from_utf8_lossy(&serialize_quads(&quads_unchecked, Vec::new()))
+            );
+        }
+    } else if bnodes_count <= 4 {
+        let mut dataset_with_split = quads.iter().collect::<Dataset>();
+        let mut dataset_without_split = quads_without_split.iter().collect::<Dataset>();
+        dataset_with_split.canonicalize(CanonicalizationAlgorithm::Unstable);
+        dataset_without_split.canonicalize(CanonicalizationAlgorithm::Unstable);
+        assert_eq!(
+            dataset_with_split,
+            dataset_without_split,
+            "With split:\n{}\nWithout split:\n{}",
+            String::from_utf8_lossy(&serialize_quads(&quads, Vec::new())),
+            String::from_utf8_lossy(&serialize_quads(&quads_without_split, Vec::new()))
+        );
+        if errors.is_empty() {
+            let mut dataset_unchecked = quads_unchecked.iter().collect::<Dataset>();
+            dataset_unchecked.canonicalize(CanonicalizationAlgorithm::Unstable);
+            assert_eq!(
+                dataset_with_split,
+                dataset_unchecked,
+                "Validating:\n{}\nUnchecked:\n{}",
+                String::from_utf8_lossy(&serialize_quads(&quads, Vec::new())),
+                String::from_utf8_lossy(&serialize_quads(&quads_unchecked, Vec::new()))
+            );
+        }
+    }
+    assert_eq!(errors, errors_without_split);
+
+    // We serialize
+    let new_serialization = serialize_quads(&quads, prefixes);
+
+    // We parse the serialization
+    let new_quads = TriGParser::new()
+        .with_quoted_triples()
+        .parse_read(new_serialization.as_slice())
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|e| {
+            format!(
+                "Error on {:?} from {quads:?} based on {:?}: {e}",
+                String::from_utf8_lossy(&new_serialization),
+                String::from_utf8_lossy(data)
+            )
+        })
+        .unwrap();
+
+    // We check the roundtrip has not changed anything
+    assert_eq!(new_quads, quads);
+});

fuzz/src/lib.rs

@@ -0,0 +1 @@
+pub mod result_format;

fuzz/src/result_format.rs

@@ -0,0 +1,63 @@
+use anyhow::Context;
+use sparesults::{
+    FromReadQueryResultsReader, QueryResultsFormat, QueryResultsParser, QueryResultsSerializer,
+};
+
+pub fn fuzz_result_format(format: QueryResultsFormat, data: &[u8]) {
+    let parser = QueryResultsParser::from_format(format);
+    let serializer = QueryResultsSerializer::from_format(format);
+
+    let Ok(reader) = parser.parse_read(data) else {
+        return;
+    };
+    match reader {
+        FromReadQueryResultsReader::Solutions(solutions) => {
+            let Ok(solutions) = solutions.collect::<Result<Vec<_>, _>>() else {
+                return;
+            };
+
+            // We try to write again
+            let mut writer = serializer
+                .serialize_solutions_to_write(
+                    Vec::new(),
+                    solutions
+                        .first()
+                        .map_or_else(Vec::new, |s| s.variables().to_vec()),
+                )
+                .unwrap();
+            for solution in &solutions {
+                writer.write(solution).unwrap();
+            }
+            let serialized = String::from_utf8(writer.finish().unwrap()).unwrap();
+
+            // And to parse again
+            if let FromReadQueryResultsReader::Solutions(roundtrip_solutions) = parser
+                .parse_read(serialized.as_bytes())
+                .with_context(|| format!("Parsing {serialized:?}"))
+                .unwrap()
+            {
+                assert_eq!(
+                    roundtrip_solutions
+                        .collect::<Result<Vec<_>, _>>()
+                        .with_context(|| format!("Parsing {serialized:?}"))
+                        .unwrap(),
+                    solutions
+                )
+            }
+        }
+        FromReadQueryResultsReader::Boolean(value) => {
+            // We try to write again
+            let mut serialized = Vec::new();
+            serializer
+                .serialize_boolean_to_write(&mut serialized, value)
+                .unwrap();
+
+            // And to parse again
+            if let FromReadQueryResultsReader::Boolean(roundtrip_value) =
+                parser.parse_read(serialized.as_slice()).unwrap()
+            {
+                assert_eq!(roundtrip_value, value)
+            }
+        }
+    }
+}

js/Cargo.toml

@@ -1,23 +1,26 @@
 [package]
-name = "oxigraph_js"
-version = "0.3.1"
-authors = ["Tpt <thomas@pellissier-tanon.fr>"]
-license = "MIT OR Apache-2.0"
+name = "oxigraph-js"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
 readme = "README.md"
-keywords = ["RDF", "N-Triples", "Turtle", "RDF/XML", "SPARQL"]
+keywords = ["RDF", "N-Triples", "Turtle", "XML", "SPARQL"]
 repository = "https://github.com/oxigraph/oxigraph/tree/main/js"
 description = "JavaScript bindings of Oxigraph"
-edition = "2021"
+edition.workspace = true
+rust-version.workspace = true
+publish = false
 
 [lib]
 crate-type = ["cdylib"]
 name = "oxigraph"
+doc = false
 
 [dependencies]
-oxigraph = { version = "0.3.1", path="../lib" }
-wasm-bindgen = "0.2"
-js-sys = "0.3"
-console_error_panic_hook = "0.1"
+console_error_panic_hook.workspace = true
+js-sys.workspace = true
+oxigraph = { workspace = true, features = ["js"] }
+wasm-bindgen.workspace = true
 
-[dev-dependencies]
-wasm-bindgen-test = "0.3"
+[lints]
+workspace = true

js/README.md

@@ -3,7 +3,7 @@ Oxigraph for JavaScript
 
 [![npm](https://img.shields.io/npm/v/oxigraph)](https://www.npmjs.com/package/oxigraph)
 [![actions status](https://github.com/oxigraph/oxigraph/workflows/build/badge.svg)](https://github.com/oxigraph/oxigraph/actions)
-[![Gitter](https://badges.gitter.im/oxigraph/community.svg)](https://gitter.im/oxigraph/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+[![Gitter](https://badges.gitter.im/oxigraph/community.svg)](https://gitter.im/oxigraph/community)
 
 This package provides a JavaScript API on top of [Oxigraph](https://crates.io/crates/oxigraph), compiled with WebAssembly.
 
@@ -13,7 +13,7 @@ Oxigraph for JavaScript is a work in progress and currently offers a simple in-m
 
 The store is also able to load RDF serialized in [Turtle](https://www.w3.org/TR/turtle/), [TriG](https://www.w3.org/TR/trig/), [N-Triples](https://www.w3.org/TR/n-triples/), [N-Quads](https://www.w3.org/TR/n-quads/) and [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/).
 
-It is distributed using a [a NPM package](https://www.npmjs.com/package/oxigraph) that should work with Node.JS 12+ and modern web browsers compatible with WebAssembly.
+It is distributed using a [a NPM package](https://www.npmjs.com/package/oxigraph) that should work with Node.JS 18+ and [modern web browsers compatible with WebAssembly reference types and JavaScript `WeakRef`](https://caniuse.com/wasm-reference-types,mdn-javascript_builtins_weakref).
 
 To install:
 ```bash
@@ -188,6 +188,18 @@ if (store.query("ASK { ?s ?s ?s }")) {
 }
 ```
 
+It is also possible to provide some options in an object given as second argument:
+
+```js
+if (store.query("ASK { <s> ?p ?o }", {
+  base_iri: "http://example.com/", // base IRI to resolve relative IRIs in the query
+  use_default_graph_as_union: true, // the default graph in the query is the union of all the dataset graphs
+
+})) {
+  console.log("there is a triple with same subject, predicate and object");
+}
+```
+
 #### `Store.prototype.update(String query)`
 Executes a [SPARQL 1.1 Update](https://www.w3.org/TR/sparql11-update/).
 The [`LOAD` operation](https://www.w3.org/TR/sparql11-update/#load) is not supported yet.
@@ -197,40 +209,50 @@ Example of update:
 store.update("DELETE WHERE { <http://example.com/s> ?p ?o }")
 ```
 
-#### `Store.prototype.load(String data, String mimeType, NamedNode|String? baseIRI, NamedNode|BlankNode|DefaultGraph? toNamedGraph)`
+It is also possible to provide some options in an object given as second argument:
+
+```js
+store.update("DELETE WHERE { <s> ?p ?o }", {
+  base_iri: "http://example.com/" // base IRI to resolve relative IRIs in the update
+})
+```
+
+#### `Store.prototype.load(String data, String format, NamedNode|String? baseIRI, NamedNode|BlankNode|DefaultGraph? toNamedGraph)`
 
 Loads serialized RDF triples or quad into the store.
 The method arguments are:
 1. `data`: the serialized RDF triples or quads.
-2. `mimeType`: the MIME type of the serialization. See below for the supported mime types.
+2. `format`: the format of the serialization. See below for the supported formats.
 3. `baseIRI`: the base IRI to use to resolve the relative IRIs in the serialization.
 4. `toNamedGraph`: for triple serialization formats, the name of the named graph the triple should be loaded to.
 
 The available formats are:
-* [Turtle](https://www.w3.org/TR/turtle/): `text/turtle`
-* [TriG](https://www.w3.org/TR/trig/): `application/trig`
-* [N-Triples](https://www.w3.org/TR/n-triples/): `application/n-triples`
-* [N-Quads](https://www.w3.org/TR/n-quads/): `application/n-quads`
-* [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/): `application/rdf+xml`
+* [Turtle](https://www.w3.org/TR/turtle/): `text/turtle` or `ttl`
+* [TriG](https://www.w3.org/TR/trig/): `application/trig` or `trig`
+* [N-Triples](https://www.w3.org/TR/n-triples/): `application/n-triples` or `nt`
+* [N-Quads](https://www.w3.org/TR/n-quads/): `application/n-quads` or `nq`
+* [N3](https://w3c.github.io/N3/spec/): `text/n3` or `n3`
+* [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/): `application/rdf+xml` or `rdf`
 
 Example of loading a Turtle file into the named graph `<http://example.com/graph>` with the base IRI `http://example.com`:
 ```js
 store.load("<http://example.com> <http://example.com> <> .", "text/turtle", "http://example.com", oxigraph.namedNode("http://example.com/graph"));
 ```
 
-#### `Store.prototype.dump(String mimeType, NamedNode|BlankNode|DefaultGraph? fromNamedGraph)`
+#### `Store.prototype.dump(String format, NamedNode|BlankNode|DefaultGraph? fromNamedGraph)`
 
 Returns serialized RDF triples or quad from the store.
 The method arguments are:
-1. `mimeType`: the MIME type of the serialization. See below for the supported mime types.
+1. `format`: the format type of the serialization. See below for the supported types.
 2. `fromNamedGraph`: for triple serialization formats, the name of the named graph the triple should be loaded from.
 
 The available formats are:
-* [Turtle](https://www.w3.org/TR/turtle/): `text/turtle`
-* [TriG](https://www.w3.org/TR/trig/): `application/trig`
-* [N-Triples](https://www.w3.org/TR/n-triples/): `application/n-triples`
-* [N-Quads](https://www.w3.org/TR/n-quads/): `application/n-quads`
-* [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/): `application/rdf+xml`
+* [Turtle](https://www.w3.org/TR/turtle/): `text/turtle` or `ttl`
+* [TriG](https://www.w3.org/TR/trig/): `application/trig` or `trig`
+* [N-Triples](https://www.w3.org/TR/n-triples/): `application/n-triples` or `nt`
+* [N-Quads](https://www.w3.org/TR/n-quads/): `application/n-quads` or `nq`
+* [N3](https://w3c.github.io/N3/spec/): `text/n3` or `n3`
+* [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/): `application/rdf+xml` or `rdf`
 
 Example of building a Turtle file from the named graph `<http://example.com/graph>`:
 ```js
@@ -242,7 +264,8 @@ store.dump("text/turtle", oxigraph.namedNode("http://example.com/graph"));
 ### From 0.2 to 0.3
 * The `MemoryStore` class is now called `Store` (there is no other kind of stores...).
 * RDF/JS datamodel functions (`namedNode`...) are now available at the root of the `oxigraph` package. You now need to call `oxigraph.namedNode` instead of `store.dataFactory.namedNode`.
-* [RDF-star](https://w3c.github.io/rdf-star/cg-spec) is now implemented. `Quad` is now a valid value for the `Ωuad` `subject` and `object` properties.
+* [RDF-star](https://w3c.github.io/rdf-star/cg-spec/2021-12-17.html) is now implemented. `Quad` is now a valid value for the `Ωuad` `subject` and `object` properties.
+
 
 ## How to contribute
 
@@ -250,7 +273,17 @@ The Oxigraph bindings are written in Rust using [the Rust WASM toolkit](https://
 
 The [The Rust Wasm Book](https://rustwasm.github.io/docs/book/) is a great tutorial to get started.
 
-To run the tests of the JS bindings written in JS run `npm test`.
+To setup a dev environment:
+- ensure to have a Rust toolchain with `rustup` and `cargo` installed ([possible instructions](https://www.rust-lang.org/tools/install)).
+- install [`wasm-pack`](https://rustwasm.github.io/wasm-pack/): `cargo install wasm-pack` (it is also in some Linux distribution repositories).
+- `npm install` to install pure JS dependencies.
+- you are good to go!
+
+Testing and linting:
+- Rust code is formatted with [rustfmt](https://github.com/rust-lang/rustfmt) and linted with [clippy](https://github.com/rust-lang/rust-clippy).
+  You can execute them with `cargo fmt` and `cargo clippy`.
+- JS code is formatted and linted with [Biome](https://biomejs.dev/). `npm run fmt` to auto-format and `npm test` to lint and test.
+- Tests are written in JavaScript using [Mocha](https://mochajs.org/) in the `test` directory. `npm test` to run them.
 
 
 ## License

js/biome.json

@@ -0,0 +1,14 @@
+{
+    "$schema": "https://biomejs.dev/schemas/1.0.0/schema.json",
+    "formatter": {
+        "indentStyle": "space",
+        "indentWidth": 4,
+        "lineWidth": 100
+    },
+    "linter": {
+        "ignore": ["pkg"]
+    },
+    "organizeImports": {
+        "enabled": true
+    }
+}

js/build_package.js

@@ -1,31 +1,19 @@
 #! /usr/bin/env node
 
-const fs = require('fs')
-
-// We copy file to the new directory
-fs.mkdirSync('pkg')
-for (const file of fs.readdirSync('./pkg-web')) {
-  fs.copyFileSync('./pkg-web/' + file, './pkg/' + file)
-}
-for (const file of fs.readdirSync('./pkg-node')) {
-  fs.copyFileSync('./pkg-node/' + file, './pkg/' + file)
-}
-
-const pkg = JSON.parse(fs.readFileSync('./pkg/package.json'))
-pkg.name = 'oxigraph'
-pkg.main = 'node.js'
-pkg.browser = 'web.js'
-pkg.files = [
-  '*.{js,wasm,d.ts}'
-]
-pkg.homepage = 'https://github.com/oxigraph/oxigraph/tree/main/js'
+const fs = require("node:fs");
+const pkg = JSON.parse(fs.readFileSync("./pkg/package.json"));
+pkg.name = "oxigraph";
+pkg.main = "node.js";
+pkg.browser = "web.js";
+pkg.files = ["*.{js,wasm,d.ts}"];
+pkg.homepage = "https://github.com/oxigraph/oxigraph/tree/main/js";
 pkg.bugs = {
-  url: 'https://github.com/oxigraph/oxigraph/issues'
-}
-pkg.collaborators = undefined
+    url: "https://github.com/oxigraph/oxigraph/issues",
+};
+pkg.collaborators = undefined;
 pkg.repository = {
-  type: 'git',
-  url: 'https://github.com/oxigraph/oxigraph.git',
-  directory: 'js'
-}
-fs.writeFileSync('./pkg/package.json', JSON.stringify(pkg, null, 2))
+    type: "git",
+    url: "https://github.com/oxigraph/oxigraph.git",
+    directory: "js",
+};
+fs.writeFileSync("./pkg/package.json", JSON.stringify(pkg, null, 2));

js/package.json

@@ -1,21 +1,20 @@
 {
-  "name": "oxigraph_tests",
-  "description": "Oxigraph JS build and tests",
-  "private": true,
-  "devDependencies": {
-    "mocha": "^9.0.0",
-    "@rdfjs/data-model": "^2.0.0",
-    "standard": "^16.0.0"
-  },
-  "scripts": {
-    "test": "standard && wasm-pack build --debug --target nodejs && mocha",
-    "build": "rm -rf pkg && wasm-pack build --release --target web --out-name web && mv pkg pkg-web && wasm-pack build --release --target nodejs --out-name node && mv pkg pkg-node && node build_package.js && rm -r pkg-web && rm -r pkg-node",
-    "release": "npm run build && npm publish ./pkg",
-    "pack": "npm run build && npm pack ./pkg"
-  },
-  "standard": {
-    "ignore": [
-      "pkg*"
-    ]
-  }
+    "name": "oxigraph_tests",
+    "description": "Oxigraph JS build and tests",
+    "private": true,
+    "devDependencies": {
+        "@biomejs/biome": "^1.0.0",
+        "@rdfjs/data-model": "^2.0.1",
+        "mocha": "^10.0.0"
+    },
+    "scripts": {
+        "fmt": "biome format . --write && biome check . --apply-unsafe && biome format . --write",
+        "test": "biome ci . && wasm-pack build --debug --target nodejs --weak-refs --reference-types && mocha",
+        "build": "wasm-pack build --release --target web --out-name web --weak-refs --reference-types && wasm-pack build --release --target nodejs --out-name node --weak-refs --reference-types && node build_package.js",
+        "release": "npm run build && npm publish ./pkg",
+        "pack": "npm run build && npm pack ./pkg"
+    },
+    "standard": {
+        "ignore": ["pkg*"]
+    }
 }

js/src/lib.rs

@@ -1,4 +1,4 @@
-#![allow(clippy::unused_unit)]
+#![allow(clippy::mem_forget)]
 use wasm_bindgen::prelude::*;
 
 mod model;

js/src/model.rs

@@ -1,10 +1,9 @@
-#![allow(dead_code, clippy::inherent_to_string)]
+#![allow(dead_code, clippy::inherent_to_string, clippy::unused_self)]
 
 use crate::format_err;
 use crate::utils::to_err;
 use js_sys::{Reflect, UriError};
 use oxigraph::model::*;
-use oxigraph::sparql::Variable;
 use wasm_bindgen::prelude::*;
 
 thread_local! {
@@ -14,7 +13,7 @@ thread_local! {
 #[wasm_bindgen(js_name = namedNode)]
 pub fn named_node(value: String) -> Result<JsNamedNode, JsValue> {
     NamedNode::new(value)
-        .map(|v| v.into())
+        .map(Into::into)
         .map_err(|v| UriError::new(&v.to_string()).into())
 }
 
@@ -51,7 +50,7 @@ pub fn literal(
 
 #[wasm_bindgen(js_name = defaultGraph)]
 pub fn default_graph() -> JsDefaultGraph {
-    JsDefaultGraph {}
+    JsDefaultGraph
 }
 
 #[wasm_bindgen(js_name = variable)]
@@ -297,7 +296,7 @@ impl From<JsLiteral> for Term {
 
 #[wasm_bindgen(js_name = DefaultGraph)]
 #[derive(Eq, PartialEq, Debug, Clone, Hash)]
-pub struct JsDefaultGraph {}
+pub struct JsDefaultGraph;
 
 #[wasm_bindgen(js_class = DefaultGraph)]
 impl JsDefaultGraph {
@@ -308,12 +307,12 @@ impl JsDefaultGraph {
 
     #[wasm_bindgen(getter)]
     pub fn value(&self) -> String {
-        "".to_owned()
+        String::new()
     }
 
     #[wasm_bindgen(js_name = toString)]
     pub fn to_string(&self) -> String {
-        "DEFAULT".to_string()
+        "DEFAULT".to_owned()
     }
 
     pub fn equals(&self, other: &JsValue) -> bool {
@@ -388,7 +387,7 @@ impl JsQuad {
 
     #[wasm_bindgen(getter)]
     pub fn value(&self) -> String {
-        "".to_owned()
+        String::new()
     }
 
     #[wasm_bindgen(getter = subject)]
@@ -476,19 +475,19 @@ impl From<JsTerm> for JsValue {
 
 impl From<NamedNode> for JsTerm {
     fn from(node: NamedNode) -> Self {
-        JsTerm::NamedNode(node.into())
+        Self::NamedNode(node.into())
     }
 }
 
 impl From<BlankNode> for JsTerm {
     fn from(node: BlankNode) -> Self {
-        JsTerm::BlankNode(node.into())
+        Self::BlankNode(node.into())
     }
 }
 
 impl From<Literal> for JsTerm {
     fn from(literal: Literal) -> Self {
-        JsTerm::Literal(literal.into())
+        Self::Literal(literal.into())
     }
 }
 
@@ -527,20 +526,20 @@ impl From<GraphName> for JsTerm {
         match name {
             GraphName::NamedNode(node) => node.into(),
             GraphName::BlankNode(node) => node.into(),
-            GraphName::DefaultGraph => JsTerm::DefaultGraph(JsDefaultGraph {}),
+            GraphName::DefaultGraph => Self::DefaultGraph(JsDefaultGraph),
         }
     }
 }
 
 impl From<Variable> for JsTerm {
     fn from(variable: Variable) -> Self {
-        JsTerm::Variable(variable.into())
+        Self::Variable(variable.into())
     }
 }
 
 impl From<Triple> for JsTerm {
     fn from(triple: Triple) -> Self {
-        JsTerm::Quad(triple.into())
+        Self::Quad(triple.into())
     }
 }
 
@@ -552,14 +551,14 @@ impl From<Box<Triple>> for JsTerm {
 
 impl From<Quad> for JsTerm {
     fn from(quad: Quad) -> Self {
-        JsTerm::Quad(quad.into())
+        Self::Quad(quad.into())
     }
 }
 
 impl TryFrom<JsTerm> for NamedNode {
     type Error = JsValue;
 
-    fn try_from(value: JsTerm) -> Result<Self, JsValue> {
+    fn try_from(value: JsTerm) -> Result<Self, Self::Error> {
         match value {
             JsTerm::NamedNode(node) => Ok(node.into()),
             JsTerm::BlankNode(node) => Err(format_err!(
@@ -583,7 +582,7 @@ impl TryFrom<JsTerm> for NamedNode {
 impl TryFrom<JsTerm> for NamedOrBlankNode {
     type Error = JsValue;
 
-    fn try_from(value: JsTerm) -> Result<Self, JsValue> {
+    fn try_from(value: JsTerm) -> Result<Self, Self::Error> {
         match value {
             JsTerm::NamedNode(node) => Ok(node.into()),
             JsTerm::BlankNode(node) => Ok(node.into()),
@@ -609,7 +608,7 @@ impl TryFrom<JsTerm> for NamedOrBlankNode {
 impl TryFrom<JsTerm> for Subject {
     type Error = JsValue;
 
-    fn try_from(value: JsTerm) -> Result<Self, JsValue> {
+    fn try_from(value: JsTerm) -> Result<Self, Self::Error> {
         match value {
             JsTerm::NamedNode(node) => Ok(node.into()),
             JsTerm::BlankNode(node) => Ok(node.into()),
@@ -632,7 +631,7 @@ impl TryFrom<JsTerm> for Subject {
 impl TryFrom<JsTerm> for Term {
     type Error = JsValue;
 
-    fn try_from(value: JsTerm) -> Result<Self, JsValue> {
+    fn try_from(value: JsTerm) -> Result<Self, Self::Error> {
         match value {
             JsTerm::NamedNode(node) => Ok(node.into()),
             JsTerm::BlankNode(node) => Ok(node.into()),
@@ -652,7 +651,7 @@ impl TryFrom<JsTerm> for Term {
 impl TryFrom<JsTerm> for GraphName {
     type Error = JsValue;
 
-    fn try_from(value: JsTerm) -> Result<Self, JsValue> {
+    fn try_from(value: JsTerm) -> Result<Self, Self::Error> {
         match value {
             JsTerm::NamedNode(node) => Ok(node.into()),
             JsTerm::BlankNode(node) => Ok(node.into()),
@@ -660,7 +659,7 @@ impl TryFrom<JsTerm> for GraphName {
                 "The literal {} is not a possible graph name",
                 literal.inner
             )),
-            JsTerm::DefaultGraph(_) => Ok(GraphName::DefaultGraph),
+            JsTerm::DefaultGraph(_) => Ok(Self::DefaultGraph),
             JsTerm::Variable(variable) => Err(format_err!(
                 "The variable {} is not a possible RDF term",
                 variable.inner
@@ -712,7 +711,7 @@ impl FromJsConverter {
                 .map_err(|v| UriError::new(&v.to_string()))?
                 .into()),
                 "BlankNode" => Ok(BlankNode::new(
-                    &Reflect::get(value, &self.value)?
+                    Reflect::get(value, &self.value)?
                         .as_string()
                         .ok_or_else(|| format_err!("BlankNode should have a string value"))?,
                 )
@@ -739,9 +738,9 @@ impl FromJsConverter {
                         ))
                     }
                 }
-                "DefaultGraph" => Ok(JsTerm::DefaultGraph(JsDefaultGraph {})),
+                "DefaultGraph" => Ok(JsTerm::DefaultGraph(JsDefaultGraph)),
                 "Variable" => Ok(Variable::new(
-                    &Reflect::get(value, &self.value)?
+                    Reflect::get(value, &self.value)?
                         .as_string()
                         .ok_or_else(|| format_err!("Variable should have a string value"))?,
                 )
@@ -749,8 +748,7 @@ impl FromJsConverter {
                 .into()),
                 "Quad" => Ok(self.to_quad(value)?.into()),
                 _ => Err(format_err!(
-                    "The termType {} is not supported by Oxigraph",
-                    term_type
+                    "The termType {term_type} is not supported by Oxigraph"
                 )),
             }
         } else if term_type.is_undefined() {

js/src/store.rs

@@ -1,12 +1,11 @@
 use crate::format_err;
 use crate::model::*;
 use crate::utils::to_err;
-use js_sys::{Array, Map};
-use oxigraph::io::{DatasetFormat, GraphFormat};
+use js_sys::{Array, Map, Reflect};
+use oxigraph::io::{RdfFormat, RdfParser};
 use oxigraph::model::*;
-use oxigraph::sparql::QueryResults;
+use oxigraph::sparql::{Query, QueryResults, Update};
 use oxigraph::store::Store;
-use std::io::Cursor;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name = Store)]
@@ -17,6 +16,7 @@ pub struct JsStore {
 #[wasm_bindgen(js_class = Store)]
 impl JsStore {
     #[wasm_bindgen(constructor)]
+    #[allow(clippy::use_self)]
     pub fn new(quads: Option<Box<[JsValue]>>) -> Result<JsStore, JsValue> {
         console_error_panic_hook::set_once();
 
@@ -24,7 +24,7 @@ impl JsStore {
             store: Store::new().map_err(to_err)?,
         };
         if let Some(quads) = quads {
-            for quad in quads.iter() {
+            for quad in &*quads {
                 store.add(quad)?;
             }
         }
@@ -73,28 +73,28 @@ impl JsStore {
                     None
                 }
                 .as_ref()
-                .map(|t: &NamedOrBlankNode| t.into()),
+                .map(<&Subject>::into),
                 if let Some(predicate) = FROM_JS.with(|c| c.to_optional_term(predicate))? {
                     Some(NamedNode::try_from(predicate)?)
                 } else {
                     None
                 }
                 .as_ref()
-                .map(|t: &NamedNode| t.into()),
+                .map(<&NamedNode>::into),
                 if let Some(object) = FROM_JS.with(|c| c.to_optional_term(object))? {
                     Some(object.try_into()?)
                 } else {
                     None
                 }
                 .as_ref()
-                .map(|t: &Term| t.into()),
+                .map(<&Term>::into),
                 if let Some(graph_name) = FROM_JS.with(|c| c.to_optional_term(graph_name))? {
                     Some(graph_name.try_into()?)
                 } else {
                     None
                 }
                 .as_ref()
-                .map(|t: &GraphName| t.into()),
+                .map(<&GraphName>::into),
             )
             .map(|v| v.map(|v| JsQuad::from(v).into()))
             .collect::<Result<Vec<_>, _>>()
@@ -102,7 +102,21 @@ impl JsStore {
             .into_boxed_slice())
     }
 
-    pub fn query(&self, query: &str) -> Result<JsValue, JsValue> {
+    pub fn query(&self, query: &str, options: &JsValue) -> Result<JsValue, JsValue> {
+        // Parsing options
+        let mut base_iri = None;
+        let mut use_default_graph_as_union = false;
+        if !options.is_undefined() {
+            base_iri = Reflect::get(options, &JsValue::from_str("base_iri"))?.as_string();
+            use_default_graph_as_union =
+                Reflect::get(options, &JsValue::from_str("use_default_graph_as_union"))?
+                    .is_truthy();
+        }
+
+        let mut query = Query::parse(query, base_iri.as_deref()).map_err(to_err)?;
+        if use_default_graph_as_union {
+            query.dataset_mut().set_default_graph_as_union();
+        }
         let results = self.store.query(query).map_err(to_err)?;
         let output = match results {
             QueryResults::Solutions(solutions) => {
@@ -135,17 +149,25 @@ impl JsStore {
         Ok(output)
     }
 
-    pub fn update(&self, update: &str) -> Result<(), JsValue> {
+    pub fn update(&self, update: &str, options: &JsValue) -> Result<(), JsValue> {
+        // Parsing options
+        let mut base_iri = None;
+        if !options.is_undefined() {
+            base_iri = Reflect::get(options, &JsValue::from_str("base_iri"))?.as_string();
+        }
+
+        let update = Update::parse(update, base_iri.as_deref()).map_err(to_err)?;
         self.store.update(update).map_err(to_err)
     }
 
     pub fn load(
         &self,
         data: &str,
-        mime_type: &str,
+        format: &str,
         base_iri: &JsValue,
         to_graph_name: &JsValue,
     ) -> Result<(), JsValue> {
+        let format = rdf_format(format)?;
         let base_iri = if base_iri.is_null() || base_iri.is_undefined() {
             None
         } else if base_iri.is_string() {
@@ -158,65 +180,41 @@ impl JsStore {
             ));
         };
 
-        let to_graph_name =
-            if let Some(graph_name) = FROM_JS.with(|c| c.to_optional_term(to_graph_name))? {
-                Some(graph_name.try_into()?)
-            } else {
-                None
-            };
-
-        if let Some(graph_format) = GraphFormat::from_media_type(mime_type) {
-            self.store
-                .load_graph(
-                    Cursor::new(data),
-                    graph_format,
-                    &to_graph_name.unwrap_or(GraphName::DefaultGraph),
-                    base_iri.as_deref(),
-                )
-                .map_err(to_err)
-        } else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) {
-            if to_graph_name.is_some() {
-                return Err(format_err!(
-                    "The target graph name parameter is not available for dataset formats"
-                ));
-            }
-            self.store
-                .load_dataset(Cursor::new(data), dataset_format, base_iri.as_deref())
-                .map_err(to_err)
-        } else {
-            Err(format_err!("Not supported MIME type: {}", mime_type))
+        let mut parser = RdfParser::from_format(format);
+        if let Some(to_graph_name) = FROM_JS.with(|c| c.to_optional_term(to_graph_name))? {
+            parser = parser.with_default_graph(GraphName::try_from(to_graph_name)?);
+        }
+        if let Some(base_iri) = base_iri {
+            parser = parser.with_base_iri(base_iri).map_err(to_err)?;
         }
+        self.store
+            .load_from_read(parser, data.as_bytes())
+            .map_err(to_err)
     }
 
-    pub fn dump(&self, mime_type: &str, from_graph_name: &JsValue) -> Result<String, JsValue> {
-        let from_graph_name =
-            if let Some(graph_name) = FROM_JS.with(|c| c.to_optional_term(from_graph_name))? {
-                Some(graph_name.try_into()?)
-            } else {
-                None
-            };
-
-        let mut buffer = Vec::new();
-        if let Some(graph_format) = GraphFormat::from_media_type(mime_type) {
-            self.store
-                .dump_graph(
-                    &mut buffer,
-                    graph_format,
-                    &from_graph_name.unwrap_or(GraphName::DefaultGraph),
+    pub fn dump(&self, format: &str, from_graph_name: &JsValue) -> Result<String, JsValue> {
+        let format = rdf_format(format)?;
+        let buffer =
+            if let Some(from_graph_name) = FROM_JS.with(|c| c.to_optional_term(from_graph_name))? {
+                self.store.dump_graph_to_write(
+                    &GraphName::try_from(from_graph_name)?,
+                    format,
+                    Vec::new(),
                 )
-                .map_err(to_err)?;
-        } else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) {
-            if from_graph_name.is_some() {
-                return Err(format_err!(
-                    "The target graph name parameter is not available for dataset formats"
-                ));
+            } else {
+                self.store.dump_to_write(format, Vec::new())
             }
-            self.store
-                .dump_dataset(&mut buffer, dataset_format)
-                .map_err(to_err)?;
-        } else {
-            return Err(format_err!("Not supported MIME type: {}", mime_type));
-        }
+            .map_err(to_err)?;
         String::from_utf8(buffer).map_err(to_err)
     }
 }
+
+fn rdf_format(format: &str) -> Result<RdfFormat, JsValue> {
+    if format.contains('/') {
+        RdfFormat::from_media_type(format)
+            .ok_or_else(|| format_err!("Not supported RDF format media type: {format}"))
+    } else {
+        RdfFormat::from_extension(format)
+            .ok_or_else(|| format_err!("Not supported RDF format extension: {format}"))
+    }
+}

js/src/utils.rs

@@ -11,6 +11,7 @@ macro_rules! format_err {
     };
 }
 
+#[allow(clippy::needless_pass_by_value)]
 pub fn to_err(e: impl ToString) -> JsValue {
     JsValue::from(Error::new(&e.to_string()))
 }

js/test/model.mjs

@@ -1,38 +1,52 @@
 /* global describe, it */
 
-import oxigraph from '../pkg/oxigraph.js'
-import assert from 'assert'
-import runTests from '../node_modules/@rdfjs/data-model/test/index.js'
-
-runTests({ factory: oxigraph })
-
-describe('DataModel', function () {
-  describe('#toString()', function () {
-    it('namedNode().toString() should return SPARQL compatible syntax', function () {
-      assert.strictEqual('<http://example.com>', oxigraph.namedNode('http://example.com').toString())
-    })
-
-    it('blankNode().toString() should return SPARQL compatible syntax', function () {
-      assert.strictEqual('_:a', oxigraph.blankNode('a').toString())
-    })
-
-    it('literal().toString() should return SPARQL compatible syntax', function () {
-      assert.strictEqual('"a\\"b"@en', oxigraph.literal('a"b', 'en').toString())
-    })
-
-    it('defaultGraph().toString() should return SPARQL compatible syntax', function () {
-      assert.strictEqual('DEFAULT', oxigraph.defaultGraph().toString())
-    })
-
-    it('variable().toString() should return SPARQL compatible syntax', function () {
-      assert.strictEqual('?a', oxigraph.variable('a').toString())
-    })
-
-    it('quad().toString() should return SPARQL compatible syntax', function () {
-      assert.strictEqual(
-        '<http://example.com/s> <http://example.com/p> <<<http://example.com/s1> <http://example.com/p1> <http://example.com/o1>>> <http://example.com/g>',
-        oxigraph.quad(oxigraph.namedNode('http://example.com/s'), oxigraph.namedNode('http://example.com/p'), oxigraph.quad(oxigraph.namedNode('http://example.com/s1'), oxigraph.namedNode('http://example.com/p1'), oxigraph.namedNode('http://example.com/o1')), oxigraph.namedNode('http://example.com/g')).toString()
-      )
-    })
-  })
-})
+import assert from "node:assert";
+import runTests from "../node_modules/@rdfjs/data-model/test/index.js";
+import oxigraph from "../pkg/oxigraph.js";
+
+runTests({ factory: oxigraph });
+
+describe("DataModel", () => {
+    describe("#toString()", () => {
+        it("namedNode().toString() should return SPARQL compatible syntax", () => {
+            assert.strictEqual(
+                "<http://example.com>",
+                oxigraph.namedNode("http://example.com").toString(),
+            );
+        });
+
+        it("blankNode().toString() should return SPARQL compatible syntax", () => {
+            assert.strictEqual("_:a", oxigraph.blankNode("a").toString());
+        });
+
+        it("literal().toString() should return SPARQL compatible syntax", () => {
+            assert.strictEqual('"a\\"b"@en', oxigraph.literal('a"b', "en").toString());
+        });
+
+        it("defaultGraph().toString() should return SPARQL compatible syntax", () => {
+            assert.strictEqual("DEFAULT", oxigraph.defaultGraph().toString());
+        });
+
+        it("variable().toString() should return SPARQL compatible syntax", () => {
+            assert.strictEqual("?a", oxigraph.variable("a").toString());
+        });
+
+        it("quad().toString() should return SPARQL compatible syntax", () => {
+            assert.strictEqual(
+                "<http://example.com/s> <http://example.com/p> <<<http://example.com/s1> <http://example.com/p1> <http://example.com/o1>>> <http://example.com/g>",
+                oxigraph
+                    .quad(
+                        oxigraph.namedNode("http://example.com/s"),
+                        oxigraph.namedNode("http://example.com/p"),
+                        oxigraph.quad(
+                            oxigraph.namedNode("http://example.com/s1"),
+                            oxigraph.namedNode("http://example.com/p1"),
+                            oxigraph.namedNode("http://example.com/o1"),
+                        ),
+                        oxigraph.namedNode("http://example.com/g"),
+                    )
+                    .toString(),
+            );
+        });
+    });
+});

js/test/store.mjs

@@ -1,161 +1,208 @@
 /* global describe, it */
 
-import { Store } from '../pkg/oxigraph.js'
-import assert from 'assert'
-import dataModel from '@rdfjs/data-model'
+import assert from "node:assert";
+import dataModel from "@rdfjs/data-model";
+import { Store } from "../pkg/oxigraph.js";
 
-const ex = dataModel.namedNode('http://example.com')
+const ex = dataModel.namedNode("http://example.com");
 const triple = dataModel.quad(
-  dataModel.blankNode('s'),
-  dataModel.namedNode('http://example.com/p'),
-  dataModel.literal('o')
-)
-
-describe('Store', function () {
-  describe('#add()', function () {
-    it('an added quad should be in the store', function () {
-      const store = new Store()
-      store.add(dataModel.quad(ex, ex, triple))
-      assert(store.has(dataModel.quad(ex, ex, triple)))
-    })
-  })
-
-  describe('#delete()', function () {
-    it('an removed quad should not be in the store anymore', function () {
-      const store = new Store([dataModel.quad(triple, ex, ex)])
-      assert(store.has(dataModel.quad(triple, ex, ex)))
-      store.delete(dataModel.quad(triple, ex, ex))
-      assert(!store.has(dataModel.quad(triple, ex, ex)))
-    })
-  })
-
-  describe('#has()', function () {
-    it('an added quad should be in the store', function () {
-      const store = new Store([dataModel.quad(ex, ex, ex)])
-      assert(store.has(dataModel.quad(ex, ex, ex)))
-    })
-  })
-
-  describe('#size()', function () {
-    it('A store with one quad should have 1 for size', function () {
-      const store = new Store([dataModel.quad(ex, ex, ex)])
-      assert.strictEqual(1, store.size)
-    })
-  })
-
-  describe('#match_quads()', function () {
-    it('blank pattern should return all quads', function () {
-      const store = new Store([dataModel.quad(ex, ex, ex)])
-      const results = store.match()
-      assert.strictEqual(1, results.length)
-      assert(dataModel.quad(ex, ex, ex).equals(results[0]))
-    })
-  })
-
-  describe('#query()', function () {
-    it('ASK true', function () {
-      const store = new Store([dataModel.quad(ex, ex, ex)])
-      assert.strictEqual(true, store.query('ASK { ?s ?s ?s }'))
-    })
-
-    it('ASK false', function () {
-      const store = new Store()
-      assert.strictEqual(false, store.query('ASK { FILTER(false)}'))
-    })
-
-    it('CONSTRUCT', function () {
-      const store = new Store([dataModel.quad(ex, ex, ex)])
-      const results = store.query('CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o }')
-      assert.strictEqual(1, results.length)
-      assert(dataModel.quad(ex, ex, ex).equals(results[0]))
-    })
-
-    it('SELECT', function () {
-      const store = new Store([dataModel.quad(ex, ex, ex)])
-      const results = store.query('SELECT ?s WHERE { ?s ?p ?o }')
-      assert.strictEqual(1, results.length)
-      assert(ex.equals(results[0].get('s')))
-    })
-
-    it('SELECT with NOW()', function () {
-      const store = new Store([dataModel.quad(ex, ex, ex)])
-      const results = store.query('SELECT (YEAR(NOW()) AS ?y) WHERE {}')
-      assert.strictEqual(1, results.length)
-    })
-
-    it('SELECT with RAND()', function () {
-      const store = new Store([dataModel.quad(ex, ex, ex)])
-      const results = store.query('SELECT (RAND() AS ?y) WHERE {}')
-      assert.strictEqual(1, results.length)
-    })
-  })
-
-  describe('#update()', function () {
-    it('INSERT DATA', function () {
-      const store = new Store()
-      store.update('INSERT DATA { <http://example.com> <http://example.com> <http://example.com> }')
-      assert.strictEqual(1, store.size)
-    })
-
-    it('DELETE DATA', function () {
-      const store = new Store([dataModel.quad(ex, ex, ex)])
-      store.update('DELETE DATA { <http://example.com> <http://example.com> <http://example.com> }')
-      assert.strictEqual(0, store.size)
-    })
-
-    it('DELETE WHERE', function () {
-      const store = new Store([dataModel.quad(ex, ex, ex)])
-      store.update('DELETE WHERE { ?v ?v ?v }')
-      assert.strictEqual(0, store.size)
-    })
-  })
-
-  describe('#load()', function () {
-    it('load NTriples in the default graph', function () {
-      const store = new Store()
-      store.load('<http://example.com> <http://example.com> <http://example.com> .', 'application/n-triples')
-      assert(store.has(dataModel.quad(ex, ex, ex)))
-    })
-
-    it('load NTriples in an other graph', function () {
-      const store = new Store()
-      store.load('<http://example.com> <http://example.com> <http://example.com> .', 'application/n-triples', null, ex)
-      assert(store.has(dataModel.quad(ex, ex, ex, ex)))
-    })
-
-    it('load Turtle with a base IRI', function () {
-      const store = new Store()
-      store.load('<http://example.com> <http://example.com> <> .', 'text/turtle', 'http://example.com')
-      assert(store.has(dataModel.quad(ex, ex, ex)))
-    })
-
-    it('load NQuads', function () {
-      const store = new Store()
-      store.load('<http://example.com> <http://example.com> <http://example.com> <http://example.com> .', 'application/n-quads')
-      assert(store.has(dataModel.quad(ex, ex, ex, ex)))
-    })
-
-    it('load TriG with a base IRI', function () {
-      const store = new Store()
-      store.load('GRAPH <> { <http://example.com> <http://example.com> <> }', 'application/trig', 'http://example.com')
-      assert(store.has(dataModel.quad(ex, ex, ex, ex)))
-    })
-  })
-
-  describe('#dump()', function () {
-    it('dump dataset content', function () {
-      const store = new Store([dataModel.quad(ex, ex, ex, ex)])
-      assert.strictEqual('<http://example.com> <http://example.com> <http://example.com> <http://example.com> .\n', store.dump('application/n-quads'))
-    })
-
-    it('dump named graph content', function () {
-      const store = new Store([dataModel.quad(ex, ex, ex, ex)])
-      assert.strictEqual('<http://example.com> <http://example.com> <http://example.com> .\n', store.dump('application/n-triples', ex))
-    })
-
-    it('dump default graph content', function () {
-      const store = new Store([dataModel.quad(ex, ex, ex, ex)])
-      assert.strictEqual('', store.dump('application/n-triples'))
-    })
-  })
-})
+    dataModel.blankNode("s"),
+    dataModel.namedNode("http://example.com/p"),
+    dataModel.literal("o"),
+);
+
+describe("Store", () => {
+    describe("#add()", () => {
+        it("an added quad should be in the store", () => {
+            const store = new Store();
+            store.add(dataModel.quad(ex, ex, triple));
+            assert(store.has(dataModel.quad(ex, ex, triple)));
+        });
+    });
+
+    describe("#delete()", () => {
+        it("an removed quad should not be in the store anymore", () => {
+            const store = new Store([dataModel.quad(triple, ex, ex)]);
+            assert(store.has(dataModel.quad(triple, ex, ex)));
+            store.delete(dataModel.quad(triple, ex, ex));
+            assert(!store.has(dataModel.quad(triple, ex, ex)));
+        });
+    });
+
+    describe("#has()", () => {
+        it("an added quad should be in the store", () => {
+            const store = new Store([dataModel.quad(ex, ex, ex)]);
+            assert(store.has(dataModel.quad(ex, ex, ex)));
+        });
+    });
+
+    describe("#size()", () => {
+        it("A store with one quad should have 1 for size", () => {
+            const store = new Store([dataModel.quad(ex, ex, ex)]);
+            assert.strictEqual(1, store.size);
+        });
+    });
+
+    describe("#match_quads()", () => {
+        it("blank pattern should return all quads", () => {
+            const store = new Store([dataModel.quad(ex, ex, ex)]);
+            const results = store.match();
+            assert.strictEqual(1, results.length);
+            assert(dataModel.quad(ex, ex, ex).equals(results[0]));
+        });
+    });
+
+    describe("#query()", () => {
+        it("ASK true", () => {
+            const store = new Store([dataModel.quad(ex, ex, ex)]);
+            assert.strictEqual(true, store.query("ASK { ?s ?s ?s }"));
+        });
+
+        it("ASK false", () => {
+            const store = new Store();
+            assert.strictEqual(false, store.query("ASK { FILTER(false)}"));
+        });
+
+        it("CONSTRUCT", () => {
+            const store = new Store([dataModel.quad(ex, ex, ex)]);
+            const results = store.query("CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o }");
+            assert.strictEqual(1, results.length);
+            assert(dataModel.quad(ex, ex, ex).equals(results[0]));
+        });
+
+        it("SELECT", () => {
+            const store = new Store([dataModel.quad(ex, ex, ex)]);
+            const results = store.query("SELECT ?s WHERE { ?s ?p ?o }");
+            assert.strictEqual(1, results.length);
+            assert(ex.equals(results[0].get("s")));
+        });
+
+        it("SELECT with NOW()", () => {
+            const store = new Store([dataModel.quad(ex, ex, ex)]);
+            const results = store.query(
+                "SELECT * WHERE { FILTER(2022 <= YEAR(NOW()) && YEAR(NOW()) <= 2100) }",
+            );
+            assert.strictEqual(1, results.length);
+        });
+
+        it("SELECT with RAND()", () => {
+            const store = new Store([dataModel.quad(ex, ex, ex)]);
+            const results = store.query("SELECT (RAND() AS ?y) WHERE {}");
+            assert.strictEqual(1, results.length);
+        });
+
+        it("SELECT with base IRI", () => {
+            const store = new Store();
+            const results = store.query("SELECT * WHERE { BIND(<t> AS ?t) }", {
+                base_iri: "http://example.com/",
+            });
+            assert.strictEqual(1, results.length);
+        });
+
+        it("SELECT with union graph", () => {
+            const store = new Store([dataModel.quad(ex, ex, ex, ex)]);
+            const results = store.query("SELECT * WHERE { ?s ?p ?o }", {
+                use_default_graph_as_union: true,
+            });
+            assert.strictEqual(1, results.length);
+        });
+    });
+
+    describe("#update()", () => {
+        it("INSERT DATA", () => {
+            const store = new Store();
+            store.update(
+                "INSERT DATA { <http://example.com> <http://example.com> <http://example.com> }",
+            );
+            assert.strictEqual(1, store.size);
+        });
+
+        it("DELETE DATA", () => {
+            const store = new Store([dataModel.quad(ex, ex, ex)]);
+            store.update(
+                "DELETE DATA { <http://example.com> <http://example.com> <http://example.com> }",
+            );
+            assert.strictEqual(0, store.size);
+        });
+
+        it("DELETE WHERE", () => {
+            const store = new Store([dataModel.quad(ex, ex, ex)]);
+            store.update("DELETE WHERE { ?v ?v ?v }");
+            assert.strictEqual(0, store.size);
+        });
+    });
+
+    describe("#load()", () => {
+        it("load NTriples in the default graph", () => {
+            const store = new Store();
+            store.load(
+                "<http://example.com> <http://example.com> <http://example.com> .",
+                "application/n-triples",
+            );
+            assert(store.has(dataModel.quad(ex, ex, ex)));
+        });
+
+        it("load NTriples in an other graph", () => {
+            const store = new Store();
+            store.load(
+                "<http://example.com> <http://example.com> <http://example.com> .",
+                "application/n-triples",
+                null,
+                ex,
+            );
+            assert(store.has(dataModel.quad(ex, ex, ex, ex)));
+        });
+
+        it("load Turtle with a base IRI", () => {
+            const store = new Store();
+            store.load(
+                "<http://example.com> <http://example.com> <> .",
+                "text/turtle",
+                "http://example.com",
+            );
+            assert(store.has(dataModel.quad(ex, ex, ex)));
+        });
+
+        it("load NQuads", () => {
+            const store = new Store();
+            store.load(
+                "<http://example.com> <http://example.com> <http://example.com> <http://example.com> .",
+                "application/n-quads",
+            );
+            assert(store.has(dataModel.quad(ex, ex, ex, ex)));
+        });
+
+        it("load TriG with a base IRI", () => {
+            const store = new Store();
+            store.load(
+                "GRAPH <> { <http://example.com> <http://example.com> <> }",
+                "application/trig",
+                "http://example.com",
+            );
+            assert(store.has(dataModel.quad(ex, ex, ex, ex)));
+        });
+    });
+
+    describe("#dump()", () => {
+        it("dump dataset content", () => {
+            const store = new Store([dataModel.quad(ex, ex, ex, ex)]);
+            assert.strictEqual(
+                "<http://example.com> <http://example.com> <http://example.com> <http://example.com> .\n",
+                store.dump("application/n-quads"),
+            );
+        });
+
+        it("dump named graph content", () => {
+            const store = new Store([dataModel.quad(ex, ex, ex, ex)]);
+            assert.strictEqual(
+                "<http://example.com> <http://example.com> <http://example.com> .\n",
+                store.dump("application/n-triples", ex),
+            );
+        });
+
+        it("dump default graph content", () => {
+            const store = new Store([dataModel.quad(ex, ex, ex, ex)]);
+            assert.strictEqual("", store.dump("application/n-triples", dataModel.defaultGraph()));
+        });
+    });
+});

lib/Cargo.toml

@@ -1,63 +0,0 @@
-[package]
-name = "oxigraph"
-version = "0.3.1"
-authors = ["Tpt <thomas@pellissier-tanon.fr>"]
-license = "MIT OR Apache-2.0"
-readme = "README.md"
-keywords = ["RDF", "SPARQL", "graph-database", "database"]
-categories = ["database-implementations"]
-repository = "https://github.com/oxigraph/oxigraph/tree/main/lib"
-homepage = "https://oxigraph.org/"
-description = """
-a SPARQL database and RDF toolkit
-"""
-edition = "2021"
-
-[package.metadata.docs.rs]
-all-features = true
-
-[features]
-default = []
-http_client = ["oxhttp", "oxhttp/rustls"]
-
-[dependencies]
-rand = "0.8"
-md-5 = "0.10"
-sha-1 = "0.10"
-sha2 = "0.10"
-digest = "0.10"
-regex = "1"
-oxilangtag = "0.1"
-oxiri = "0.2"
-rio_api = "0.7"
-rio_turtle = "0.7"
-rio_xml = "0.7"
-hex = "0.4"
-nom = "7"
-siphasher = "0.3"
-lazy_static = "1"
-sysinfo = "0.23"
-oxrdf = { version = "0.1.0", path="oxrdf", features = ["rdf-star"] }
-spargebra = { version = "0.2.0", path="spargebra", features = ["rdf-star"] }
-sparesults = { version = "0.1.0", path="sparesults", features = ["rdf-star"] }
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-libc = "0.2"
-oxrocksdb-sys = { version = "0.3.1", path="../oxrocksdb-sys" }
-oxhttp = { version = "0.1", optional = true }
-
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-js-sys = "0.3"
-getrandom = {version="0.2", features=["js"]}
-
-[dev-dependencies]
-criterion = "0.3"
-oxhttp = "0.1"
-zstd = "0.11"
-
-[target.'cfg(target_arch = "wasm32")'.dev-dependencies]
-wasm-bindgen-test = "0.3"
-
-[[bench]]
-name = "store"
-harness = false

lib/README.md

@@ -1,69 +1,13 @@
-Oxigraph
-========
-
-[![Latest Version](https://img.shields.io/crates/v/oxigraph.svg)](https://crates.io/crates/oxigraph)
-[![Released API docs](https://docs.rs/oxigraph/badge.svg)](https://docs.rs/oxigraph)
-[![Crates.io downloads](https://img.shields.io/crates/d/oxigraph)](https://crates.io/crates/oxigraph)
-[![actions status](https://github.com/oxigraph/oxigraph/workflows/build/badge.svg)](https://github.com/oxigraph/oxigraph/actions)
-[![Gitter](https://badges.gitter.im/oxigraph/community.svg)](https://gitter.im/oxigraph/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
-
-Oxigraph is a graph database library implementing the [SPARQL](https://www.w3.org/TR/sparql11-overview/) standard.
-
-Its goal is to provide a compliant, safe and fast on-disk graph database.
-It also provides a set of utility functions for reading, writing, and processing RDF files.
-
-Oxigraph is in heavy development and SPARQL query evaluation has not been optimized yet.
-
-Oxigraph also provides [a standalone HTTP server](https://crates.io/crates/oxigraph_server) and [a Python library](https://oxigraph.org/pyoxigraph/) based on this library.
-
-
-Oxigraph implements the following specifications:
-* [SPARQL 1.1 Query](https://www.w3.org/TR/sparql11-query/), [SPARQL 1.1 Update](https://www.w3.org/TR/sparql11-update/), and [SPARQL 1.1 Federated Query](https://www.w3.org/TR/sparql11-federated-query/).
-* [Turtle](https://www.w3.org/TR/turtle/), [TriG](https://www.w3.org/TR/trig/), [N-Triples](https://www.w3.org/TR/n-triples/), [N-Quads](https://www.w3.org/TR/n-quads/), and [RDF XML](https://www.w3.org/TR/rdf-syntax-grammar/) RDF serialization formats for both data ingestion and retrieval using the [Rio library](https://github.com/oxigraph/rio).
-* [SPARQL Query Results XML Format](http://www.w3.org/TR/rdf-sparql-XMLres/), [SPARQL 1.1 Query Results JSON Format](https://www.w3.org/TR/sparql11-results-json/) and [SPARQL 1.1 Query Results CSV and TSV Formats](https://www.w3.org/TR/sparql11-results-csv-tsv/).
-
-A preliminary benchmark [is provided](../bench/README.md). Oxigraph internal design [is described on the wiki](https://github.com/oxigraph/oxigraph/wiki/Architecture).
-
-The main entry point of Oxigraph is the [`Store`](store::Store) struct:
-```rust
-use oxigraph::store::Store;
-use oxigraph::model::*;
-use oxigraph::sparql::QueryResults;
-
-let store = Store::new().unwrap();
-
-// insertion
-let ex = NamedNode::new("http://example.com").unwrap();
-let quad = Quad::new(ex.clone(), ex.clone(), ex.clone(), GraphName::DefaultGraph);
-store.insert(&quad).unwrap();
-
-// quad filter
-let results = store.quads_for_pattern(Some(ex.as_ref().into()), None, None, None).collect::<Result<Vec<Quad>,_>>().unwrap();
-assert_eq!(vec![quad], results);
-
-// SPARQL query
-if let QueryResults::Solutions(mut solutions) =  store.query("SELECT ?s WHERE { ?s ?p ?o }").unwrap() {
-    assert_eq!(solutions.next().unwrap().unwrap().get("s"), Some(&ex.into()));
-}
-```
-
-Some parts of this library are available as standalone crates:
-* [`oxrdf`](https://crates.io/crates/oxrdf) provides datastructures encoding RDF basic concepts (the `oxigraph::model` module).
-* [`spargebra`](https://crates.io/crates/spargebra) provides a SPARQL parser.
-* [`sparesults`](https://crates.io/crates/sparesults) provides parsers and serializers for SPARQL result formats.
-
-## License
-
-This project is licensed under either of
-
-* Apache License, Version 2.0, ([LICENSE-APACHE](../LICENSE-APACHE) or
-  `<http://www.apache.org/licenses/LICENSE-2.0>`)
-* MIT license ([LICENSE-MIT](../LICENSE-MIT) or
-  `<http://opensource.org/licenses/MIT>`)
-
-at your option.
-
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Oxigraph by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
+Oxigraph Rust crates
+====================
+
+Oxigraph is implemented in Rust.
+It is composed on a main library, [`oxigraph`](./oxigraph) and a set of smaller crates used by the `oxigraph` crate:
+* [`oxrdf`](./oxrdf), datastructures encoding RDF basic concepts (the `model` module of the `oxigraph` crate).
+* [`oxrdfio`](./oxrdfio), a unified parser and serializer API for RDF formats (the `io` module of the `oxigraph` crate). It itself relies on:
+    * [`oxttl`](./oxttl), N-Triple, N-Quad, Turtle, TriG and N3 parsing and serialization.
+    * [`oxrdfxml`](./oxrdfxml), RDF/XML parsing and serialization.
+* [`spargebra`](./spargebra), a SPARQL parser.
+* [`sparesults`](./sparesults), parsers and serializers for SPARQL result formats (the `sparql::results` module of the `oxigraph` crate).
+* [`sparopt`](./sparesults), a SPARQL optimizer.
+* [`oxsdatatypes`](./oxsdatatypes), an implementation of some XML Schema datatypes.

lib/benches/store.rs

@@ -1,208 +0,0 @@
-use criterion::{criterion_group, criterion_main, Criterion, Throughput};
-use oxhttp::model::{Method, Request, Status};
-use oxigraph::io::GraphFormat;
-use oxigraph::model::GraphNameRef;
-use oxigraph::sparql::{Query, QueryResults, Update};
-use oxigraph::store::Store;
-use rand::random;
-use std::env::temp_dir;
-use std::fs::{remove_dir_all, File};
-use std::io::{BufRead, BufReader, Cursor, Read};
-use std::path::{Path, PathBuf};
-
-fn store_load(c: &mut Criterion) {
-    {
-        let mut data = Vec::new();
-        read_data("explore-1000.nt.zst")
-            .read_to_end(&mut data)
-            .unwrap();
-
-        let mut group = c.benchmark_group("store load");
-        group.throughput(Throughput::Bytes(data.len() as u64));
-        group.sample_size(10);
-        group.bench_function("load BSBM explore 1000 in memory", |b| {
-            b.iter(|| {
-                let store = Store::new().unwrap();
-                do_load(&store, &data);
-            })
-        });
-        group.bench_function("load BSBM explore 1000 in on disk", |b| {
-            b.iter(|| {
-                let path = TempDir::default();
-                let store = Store::open(&path.0).unwrap();
-                do_load(&store, &data);
-            })
-        });
-        group.bench_function("load BSBM explore 1000 in on disk with bulk load", |b| {
-            b.iter(|| {
-                let path = TempDir::default();
-                let store = Store::open(&path.0).unwrap();
-                do_bulk_load(&store, &data);
-            })
-        });
-    }
-
-    {
-        let mut data = Vec::new();
-        read_data("explore-10000.nt.zst")
-            .read_to_end(&mut data)
-            .unwrap();
-
-        let mut group = c.benchmark_group("store load large");
-        group.throughput(Throughput::Bytes(data.len() as u64));
-        group.sample_size(10);
-        group.bench_function("load BSBM explore 10000 in on disk with bulk load", |b| {
-            b.iter(|| {
-                let path = TempDir::default();
-                let store = Store::open(&path.0).unwrap();
-                do_bulk_load(&store, &data);
-            })
-        });
-    }
-}
-
-fn do_load(store: &Store, data: &[u8]) {
-    store
-        .load_graph(
-            Cursor::new(&data),
-            GraphFormat::NTriples,
-            GraphNameRef::DefaultGraph,
-            None,
-        )
-        .unwrap();
-    store.optimize().unwrap();
-}
-
-fn do_bulk_load(store: &Store, data: &[u8]) {
-    store
-        .bulk_loader()
-        .load_graph(
-            Cursor::new(&data),
-            GraphFormat::NTriples,
-            GraphNameRef::DefaultGraph,
-            None,
-        )
-        .unwrap();
-    store.optimize().unwrap();
-}
-
-fn store_query_and_update(c: &mut Criterion) {
-    let mut data = Vec::new();
-    read_data("explore-1000.nt.zst")
-        .read_to_end(&mut data)
-        .unwrap();
-
-    let operations = read_data("mix-exploreAndUpdate-1000.tsv.zst")
-        .lines()
-        .map(|l| {
-            let l = l.unwrap();
-            let mut parts = l.trim().split('\t');
-            let kind = parts.next().unwrap();
-            let operation = parts.next().unwrap();
-            match kind {
-                "query" => Operation::Query(Query::parse(operation, None).unwrap()),
-                "update" => Operation::Update(Update::parse(operation, None).unwrap()),
-                _ => panic!("Unexpected operation kind {}", kind),
-            }
-        })
-        .collect::<Vec<_>>();
-    let query_operations = operations
-        .iter()
-        .filter(|o| matches!(o, Operation::Query(_)))
-        .cloned()
-        .collect::<Vec<_>>();
-
-    let mut group = c.benchmark_group("store operations");
-    group.throughput(Throughput::Elements(operations.len() as u64));
-    group.sample_size(10);
-
-    {
-        let memory_store = Store::new().unwrap();
-        do_bulk_load(&memory_store, &data);
-        group.bench_function("BSBM explore 1000 query in memory", |b| {
-            b.iter(|| run_operation(&memory_store, &query_operations))
-        });
-        group.bench_function("BSBM explore 1000 queryAndUpdate in memory", |b| {
-            b.iter(|| run_operation(&memory_store, &operations))
-        });
-    }
-
-    {
-        let path = TempDir::default();
-        let disk_store = Store::open(&path.0).unwrap();
-        do_bulk_load(&disk_store, &data);
-        group.bench_function("BSBM explore 1000 query on disk", |b| {
-            b.iter(|| run_operation(&disk_store, &query_operations))
-        });
-        group.bench_function("BSBM explore 1000 queryAndUpdate on disk", |b| {
-            b.iter(|| run_operation(&disk_store, &operations))
-        });
-    }
-}
-
-fn run_operation(store: &Store, operations: &[Operation]) {
-    for operation in operations {
-        match operation {
-            Operation::Query(q) => match store.query(q.clone()).unwrap() {
-                QueryResults::Boolean(_) => (),
-                QueryResults::Solutions(s) => {
-                    for s in s {
-                        s.unwrap();
-                    }
-                }
-                QueryResults::Graph(g) => {
-                    for t in g {
-                        t.unwrap();
-                    }
-                }
-            },
-            Operation::Update(u) => store.update(u.clone()).unwrap(),
-        }
-    }
-}
-
-criterion_group!(store, store_query_and_update, store_load);
-
-criterion_main!(store);
-
-fn read_data(file: &str) -> impl BufRead {
-    if !Path::new(file).exists() {
-        let mut client = oxhttp::Client::new();
-        client.set_redirection_limit(5);
-        let url = format!(
-            "https://github.com/Tpt/bsbm-tools/releases/download/v0.2/{}",
-            file
-        );
-        let request = Request::builder(Method::GET, url.parse().unwrap()).build();
-        let response = client.request(request).unwrap();
-        assert_eq!(
-            response.status(),
-            Status::OK,
-            "{}",
-            response.into_body().to_string().unwrap()
-        );
-        std::io::copy(&mut response.into_body(), &mut File::create(file).unwrap()).unwrap();
-    }
-    BufReader::new(zstd::Decoder::new(File::open(file).unwrap()).unwrap())
-}
-
-#[allow(clippy::large_enum_variant)]
-#[derive(Clone)]
-enum Operation {
-    Query(Query),
-    Update(Update),
-}
-
-struct TempDir(PathBuf);
-
-impl Default for TempDir {
-    fn default() -> Self {
-        Self(temp_dir().join(format!("oxigraph-bench-{}", random::<u128>())))
-    }
-}
-
-impl Drop for TempDir {
-    fn drop(&mut self) {
-        remove_dir_all(&self.0).unwrap()
-    }
-}

lib/oxigraph/Cargo.toml

@@ -0,0 +1,59 @@
+[package]
+name = "oxigraph"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+readme = "README.md"
+keywords = ["RDF", "SPARQL", "graph-database", "database"]
+categories = ["database-implementations"]
+repository = "https://github.com/oxigraph/oxigraph/tree/main/lib/oxigraph"
+homepage = "https://oxigraph.org/"
+documentation = "https://docs.rs/oxigraph"
+description = """
+a SPARQL database and RDF toolkit
+"""
+edition.workspace = true
+rust-version.workspace = true
+
+[features]
+js = ["getrandom/js", "oxsdatatypes/js", "js-sys"]
+
+
+[dependencies]
+digest.workspace = true
+hex.workspace = true
+json-event-parser.workspace = true
+md-5.workspace = true
+oxilangtag.workspace = true
+oxiri.workspace = true
+oxrdf = { workspace = true, features = ["rdf-star", "oxsdatatypes"] }
+oxrdfio = { workspace = true, features = ["rdf-star"] }
+oxsdatatypes.workspace = true
+rand.workspace = true
+regex.workspace = true
+sha1.workspace = true
+sha2.workspace = true
+siphasher.workspace = true
+sparesults = { workspace = true, features = ["rdf-star"] }
+spargebra = { workspace = true, features = ["rdf-star", "sep-0002", "sep-0006"] }
+sparopt = { workspace = true, features = ["rdf-star", "sep-0002", "sep-0006"] }
+thiserror.workspace = true
+
+[target.'cfg(not(target_family = "wasm"))'.dependencies]
+libc = "0.2"
+rocksdb.workspace = true
+
+[target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
+getrandom.workspace = true
+js-sys = { workspace = true, optional = true }
+
+[target.'cfg(not(target_family = "wasm"))'.dev-dependencies]
+codspeed-criterion-compat.workspace = true
+zstd.workspace = true
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+rustdoc-args = ["--cfg", "docsrs"]
+

lib/oxigraph/README.md

@@ -0,0 +1,82 @@
+Oxigraph
+========
+
+[![Latest Version](https://img.shields.io/crates/v/oxigraph.svg)](https://crates.io/crates/oxigraph)
+[![Released API docs](https://docs.rs/oxigraph/badge.svg)](https://docs.rs/oxigraph)
+[![Crates.io downloads](https://img.shields.io/crates/d/oxigraph)](https://crates.io/crates/oxigraph)
+[![actions status](https://github.com/oxigraph/oxigraph/workflows/build/badge.svg)](https://github.com/oxigraph/oxigraph/actions)
+[![Gitter](https://badges.gitter.im/oxigraph/community.svg)](https://gitter.im/oxigraph/community)
+
+Oxigraph is a graph database library implementing the [SPARQL](https://www.w3.org/TR/sparql11-overview/) standard.
+
+Its goal is to provide a compliant, safe and fast on-disk graph database.
+It also provides a set of utility functions for reading, writing, and processing RDF files.
+
+Oxigraph is in heavy development and SPARQL query evaluation has not been optimized yet.
+
+Oxigraph also provides [a CLI tool](https://crates.io/crates/oxigraph-cli) and [a Python library](https://pyoxigraph.readthedocs.io/) based on this library.
+
+
+Oxigraph implements the following specifications:
+* [SPARQL 1.1 Query](https://www.w3.org/TR/sparql11-query/), [SPARQL 1.1 Update](https://www.w3.org/TR/sparql11-update/), and [SPARQL 1.1 Federated Query](https://www.w3.org/TR/sparql11-federated-query/).
+* [Turtle](https://www.w3.org/TR/turtle/), [TriG](https://www.w3.org/TR/trig/), [N-Triples](https://www.w3.org/TR/n-triples/), [N-Quads](https://www.w3.org/TR/n-quads/), and [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/) RDF serialization formats for both data ingestion and retrieval.
+* [SPARQL Query Results XML Format](https://www.w3.org/TR/rdf-sparql-XMLres/), [SPARQL 1.1 Query Results JSON Format](https://www.w3.org/TR/sparql11-results-json/) and [SPARQL 1.1 Query Results CSV and TSV Formats](https://www.w3.org/TR/sparql11-results-csv-tsv/).
+
+A preliminary benchmark [is provided](../bench/README.md). Oxigraph internal design [is described on the wiki](https://github.com/oxigraph/oxigraph/wiki/Architecture).
+
+The main entry point of Oxigraph is the [`Store`](store::Store) struct:
+```rust
+use oxigraph::store::Store;
+use oxigraph::model::*;
+use oxigraph::sparql::QueryResults;
+
+let store = Store::new().unwrap();
+
+// insertion
+let ex = NamedNode::new("http://example.com").unwrap();
+let quad = Quad::new(ex.clone(), ex.clone(), ex.clone(), GraphName::DefaultGraph);
+store.insert(&quad).unwrap();
+
+// quad filter
+let results = store.quads_for_pattern(Some(ex.as_ref().into()), None, None, None).collect::<Result<Vec<Quad>,_>>().unwrap();
+assert_eq!(vec![quad], results);
+
+// SPARQL query
+if let QueryResults::Solutions(mut solutions) =  store.query("SELECT ?s WHERE { ?s ?p ?o }").unwrap() {
+    assert_eq!(solutions.next().unwrap().unwrap().get("s"), Some(&ex.into()));
+}
+```
+
+It is based on these crates that can be used separately:
+* [`oxrdf`](https://crates.io/crates/oxrdf), datastructures encoding RDF basic concepts (the [`oxigraph::model`](crate::model) module).
+* [`oxrdfio`](https://crates.io/crates/oxrdfio), a unified parser and serializer API for RDF formats (the [`oxigraph::io`](crate::io) module). It itself relies on:
+  * [`oxttl`](https://crates.io/crates/oxttl), N-Triple, N-Quad, Turtle, TriG and N3 parsing and serialization.
+  * [`oxrdfxml`](https://crates.io/crates/oxrdfxml), RDF/XML parsing and serialization.
+* [`spargebra`](https://crates.io/crates/spargebra), a SPARQL parser.
+* [`sparesults`](https://crates.io/crates/sparesults), parsers and serializers for SPARQL result formats (the [`oxigraph::sparql::results`](crate::sparql::results) module).
+* [`sparopt`](https://crates.io/crates/sparesults), a SPARQL optimizer.
+* [`oxsdatatypes`](https://crates.io/crates/oxsdatatypes), an implementation of some XML Schema datatypes.
+
+To build the library locally, don't forget to clone the submodules using `git clone --recursive https://github.com/oxigraph/oxigraph.git` to clone the repository including submodules or `git submodule update --init` to add submodules to the already cloned repository.
+
+It is possible to disable the RocksDB storage backend to only use the in-memory fallback by disabling the `rocksdb` default feature:
+```toml
+oxigraph = { version = "*", default-features = false }
+```
+This is the default behavior when compiling Oxigraph to WASM.
+
+## License
+
+This project is licensed under either of
+
+* Apache License, Version 2.0, ([LICENSE-APACHE](../LICENSE-APACHE) or
+  `<http://www.apache.org/licenses/LICENSE-2.0>`)
+* MIT license ([LICENSE-MIT](../LICENSE-MIT) or
+  `<http://opensource.org/licenses/MIT>`)
+
+at your option.
+
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Oxigraph by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

lib/oxigraph/src/io/format.rs

@@ -1,8 +1,13 @@
-/// [RDF graph](https://www.w3.org/TR/rdf11-concepts/#dfn-graph) serialization formats.
+#![allow(deprecated)]
+
+use oxrdfio::{RdfFormat, RdfParser, RdfSerializer};
+
+/// [RDF graph](https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-graph) serialization formats.
 ///
 /// This enumeration is non exhaustive. New formats like JSON-LD will be added in the future.
 #[derive(Eq, PartialEq, Debug, Clone, Copy, Hash)]
 #[non_exhaustive]
+#[deprecated(note = "use RdfFormat instead", since = "0.4.0")]
 pub enum GraphFormat {
     /// [N-Triples](https://www.w3.org/TR/n-triples/)
     NTriples,
@@ -18,14 +23,17 @@ impl GraphFormat {
     /// ```
     /// use oxigraph::io::GraphFormat;
     ///
-    /// assert_eq!(GraphFormat::NTriples.iri(), "http://www.w3.org/ns/formats/N-Triples")
+    /// assert_eq!(
+    ///     GraphFormat::NTriples.iri(),
+    ///     "http://www.w3.org/ns/formats/N-Triples"
+    /// )
     /// ```
     #[inline]
     pub fn iri(self) -> &'static str {
         match self {
-            GraphFormat::NTriples => "http://www.w3.org/ns/formats/N-Triples",
-            GraphFormat::Turtle => "http://www.w3.org/ns/formats/Turtle",
-            GraphFormat::RdfXml => "http://www.w3.org/ns/formats/RDF_XML",
+            Self::NTriples => "http://www.w3.org/ns/formats/N-Triples",
+            Self::Turtle => "http://www.w3.org/ns/formats/Turtle",
+            Self::RdfXml => "http://www.w3.org/ns/formats/RDF_XML",
         }
     }
 
@@ -39,9 +47,9 @@ impl GraphFormat {
     #[inline]
     pub fn media_type(self) -> &'static str {
         match self {
-            GraphFormat::NTriples => "application/n-triples",
-            GraphFormat::Turtle => "text/turtle",
-            GraphFormat::RdfXml => "application/rdf+xml",
+            Self::NTriples => "application/n-triples",
+            Self::Turtle => "text/turtle",
+            Self::RdfXml => "application/rdf+xml",
         }
     }
 
@@ -55,11 +63,12 @@ impl GraphFormat {
     #[inline]
     pub fn file_extension(self) -> &'static str {
         match self {
-            GraphFormat::NTriples => "nt",
-            GraphFormat::Turtle => "ttl",
-            GraphFormat::RdfXml => "rdf",
+            Self::NTriples => "nt",
+            Self::Turtle => "ttl",
+            Self::RdfXml => "rdf",
         }
     }
+
     /// Looks for a known format from a media type.
     ///
     /// It supports some media type aliases.
@@ -69,7 +78,10 @@ impl GraphFormat {
     /// ```
     /// use oxigraph::io::GraphFormat;
     ///
-    /// assert_eq!(GraphFormat::from_media_type("text/turtle; charset=utf-8"), Some(GraphFormat::Turtle))
+    /// assert_eq!(
+    ///     GraphFormat::from_media_type("text/turtle; charset=utf-8"),
+    ///     Some(GraphFormat::Turtle)
+    /// )
     /// ```
     #[inline]
     pub fn from_media_type(media_type: &str) -> Option<Self> {
@@ -89,7 +101,10 @@ impl GraphFormat {
     /// ```
     /// use oxigraph::io::GraphFormat;
     ///
-    /// assert_eq!(GraphFormat::from_extension("nt"), Some(GraphFormat::NTriples))
+    /// assert_eq!(
+    ///     GraphFormat::from_extension("nt"),
+    ///     Some(GraphFormat::NTriples)
+    /// )
     /// ```
     #[inline]
     pub fn from_extension(extension: &str) -> Option<Self> {
@@ -102,11 +117,37 @@ impl GraphFormat {
     }
 }
 
+impl From<GraphFormat> for RdfFormat {
+    #[inline]
+    fn from(format: GraphFormat) -> Self {
+        match format {
+            GraphFormat::NTriples => Self::NTriples,
+            GraphFormat::Turtle => Self::Turtle,
+            GraphFormat::RdfXml => Self::RdfXml,
+        }
+    }
+}
+
+impl From<GraphFormat> for RdfParser {
+    #[inline]
+    fn from(format: GraphFormat) -> Self {
+        RdfFormat::from(format).into()
+    }
+}
+
+impl From<GraphFormat> for RdfSerializer {
+    #[inline]
+    fn from(format: GraphFormat) -> Self {
+        RdfFormat::from(format).into()
+    }
+}
+
 /// [RDF dataset](https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-dataset) serialization formats.
 ///
 /// This enumeration is non exhaustive. New formats like JSON-LD will be added in the future.
 #[derive(Eq, PartialEq, Debug, Clone, Copy, Hash)]
 #[non_exhaustive]
+#[deprecated(note = "use RdfFormat instead", since = "0.4.0")]
 pub enum DatasetFormat {
     /// [N-Quads](https://www.w3.org/TR/n-quads/)
     NQuads,
@@ -120,13 +161,16 @@ impl DatasetFormat {
     /// ```
     /// use oxigraph::io::DatasetFormat;
     ///
-    /// assert_eq!(DatasetFormat::NQuads.iri(), "http://www.w3.org/ns/formats/N-Quads")
+    /// assert_eq!(
+    ///     DatasetFormat::NQuads.iri(),
+    ///     "http://www.w3.org/ns/formats/N-Quads"
+    /// )
     /// ```
     #[inline]
     pub fn iri(self) -> &'static str {
         match self {
-            DatasetFormat::NQuads => "http://www.w3.org/ns/formats/N-Quads",
-            DatasetFormat::TriG => "http://www.w3.org/ns/formats/TriG",
+            Self::NQuads => "http://www.w3.org/ns/formats/N-Quads",
+            Self::TriG => "http://www.w3.org/ns/formats/TriG",
         }
     }
 
@@ -140,8 +184,8 @@ impl DatasetFormat {
     #[inline]
     pub fn media_type(self) -> &'static str {
         match self {
-            DatasetFormat::NQuads => "application/n-quads",
-            DatasetFormat::TriG => "application/trig",
+            Self::NQuads => "application/n-quads",
+            Self::TriG => "application/trig",
         }
     }
 
@@ -155,10 +199,11 @@ impl DatasetFormat {
     #[inline]
     pub fn file_extension(self) -> &'static str {
         match self {
-            DatasetFormat::NQuads => "nq",
-            DatasetFormat::TriG => "trig",
+            Self::NQuads => "nq",
+            Self::TriG => "trig",
         }
     }
+
     /// Looks for a known format from a media type.
     ///
     /// It supports some media type aliases.
@@ -167,7 +212,10 @@ impl DatasetFormat {
     /// ```
     /// use oxigraph::io::DatasetFormat;
     ///
-    /// assert_eq!(DatasetFormat::from_media_type("application/n-quads; charset=utf-8"), Some(DatasetFormat::NQuads))
+    /// assert_eq!(
+    ///     DatasetFormat::from_media_type("application/n-quads; charset=utf-8"),
+    ///     Some(DatasetFormat::NQuads)
+    /// )
     /// ```
     #[inline]
     pub fn from_media_type(media_type: &str) -> Option<Self> {
@@ -186,7 +234,10 @@ impl DatasetFormat {
     /// ```
     /// use oxigraph::io::DatasetFormat;
     ///
-    /// assert_eq!(DatasetFormat::from_extension("nq"), Some(DatasetFormat::NQuads))
+    /// assert_eq!(
+    ///     DatasetFormat::from_extension("nq"),
+    ///     Some(DatasetFormat::NQuads)
+    /// )
     /// ```
     #[inline]
     pub fn from_extension(extension: &str) -> Option<Self> {
@@ -198,12 +249,36 @@ impl DatasetFormat {
     }
 }
 
+impl From<DatasetFormat> for RdfFormat {
+    #[inline]
+    fn from(format: DatasetFormat) -> Self {
+        match format {
+            DatasetFormat::NQuads => Self::NQuads,
+            DatasetFormat::TriG => Self::TriG,
+        }
+    }
+}
+
+impl From<DatasetFormat> for RdfParser {
+    #[inline]
+    fn from(format: DatasetFormat) -> Self {
+        RdfFormat::from(format).into()
+    }
+}
+
+impl From<DatasetFormat> for RdfSerializer {
+    #[inline]
+    fn from(format: DatasetFormat) -> Self {
+        RdfFormat::from(format).into()
+    }
+}
+
 impl TryFrom<DatasetFormat> for GraphFormat {
     type Error = ();
 
     /// Attempts to find a graph format that is a subset of this [`DatasetFormat`].
     #[inline]
-    fn try_from(value: DatasetFormat) -> Result<Self, ()> {
+    fn try_from(value: DatasetFormat) -> Result<Self, Self::Error> {
         match value {
             DatasetFormat::NQuads => Ok(Self::NTriples),
             DatasetFormat::TriG => Ok(Self::Turtle),
@@ -216,7 +291,7 @@ impl TryFrom<GraphFormat> for DatasetFormat {
 
     /// Attempts to find a dataset format that is a superset of this [`GraphFormat`].
     #[inline]
-    fn try_from(value: GraphFormat) -> Result<Self, ()> {
+    fn try_from(value: GraphFormat) -> Result<Self, Self::Error> {
         match value {
             GraphFormat::NTriples => Ok(Self::NQuads),
             GraphFormat::Turtle => Ok(Self::TriG),

lib/oxigraph/src/io/mod.rs

@@ -0,0 +1,39 @@
+//! Utilities to read and write RDF graphs and datasets using [OxRDF I/O](https://crates.io/crates/oxrdfio).
+//!
+//! The entry points of this module are the two [`RdfParser`] and [`RdfSerializer`] structs.
+//!
+//! Usage example converting a Turtle file to a N-Triples file:
+//! ```
+//! use oxigraph::io::{RdfFormat, RdfParser, RdfSerializer};
+//!
+//! let turtle_file = b"@base <http://example.com/> .
+//! @prefix schema: <http://schema.org/> .
+//! <foo> a schema:Person ;
+//!     schema:name \"Foo\" .
+//! <bar> a schema:Person ;
+//!     schema:name \"Bar\" .";
+//!
+//! let ntriples_file = b"<http://example.com/foo> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
+//! <http://example.com/foo> <http://schema.org/name> \"Foo\" .
+//! <http://example.com/bar> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
+//! <http://example.com/bar> <http://schema.org/name> \"Bar\" .
+//! ";
+//!
+//! let mut writer = RdfSerializer::from_format(RdfFormat::NTriples).serialize_to_write(Vec::new());
+//! for quad in RdfParser::from_format(RdfFormat::Turtle).parse_read(turtle_file.as_ref()) {
+//!     writer.write_quad(&quad.unwrap()).unwrap();
+//! }
+//! assert_eq!(writer.finish().unwrap(), ntriples_file);
+//! ```
+
+mod format;
+pub mod read;
+pub mod write;
+
+#[allow(deprecated)]
+pub use self::format::{DatasetFormat, GraphFormat};
+#[allow(deprecated)]
+pub use self::read::{DatasetParser, GraphParser};
+#[allow(deprecated)]
+pub use self::write::{DatasetSerializer, GraphSerializer};
+pub use oxrdfio::*;

lib/oxigraph/src/io/read.rs

@@ -0,0 +1,199 @@
+#![allow(deprecated)]
+
+//! Utilities to read RDF graphs and datasets.
+
+use crate::io::{DatasetFormat, GraphFormat};
+use crate::model::*;
+use oxrdfio::{FromReadQuadReader, RdfParseError, RdfParser};
+use std::io::Read;
+
+/// Parsers for RDF graph serialization formats.
+///
+/// It currently supports the following formats:
+/// * [N-Triples](https://www.w3.org/TR/n-triples/) ([`GraphFormat::NTriples`])
+/// * [Turtle](https://www.w3.org/TR/turtle/) ([`GraphFormat::Turtle`])
+/// * [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/) ([`GraphFormat::RdfXml`])
+///
+/// ```
+/// use oxigraph::io::{GraphFormat, GraphParser};
+///
+/// let file = "<http://example.com/s> <http://example.com/p> <http://example.com/o> .";
+///
+/// let parser = GraphParser::from_format(GraphFormat::NTriples);
+/// let triples = parser
+///     .read_triples(file.as_bytes())
+///     .collect::<Result<Vec<_>, _>>()?;
+///
+/// assert_eq!(triples.len(), 1);
+/// assert_eq!(triples[0].subject.to_string(), "<http://example.com/s>");
+/// # std::io::Result::Ok(())
+/// ```
+#[deprecated(note = "use RdfParser instead", since = "0.4.0")]
+pub struct GraphParser {
+    inner: RdfParser,
+}
+
+impl GraphParser {
+    /// Builds a parser for the given format.
+    #[inline]
+    pub fn from_format(format: GraphFormat) -> Self {
+        Self {
+            inner: RdfParser::from_format(format.into())
+                .without_named_graphs()
+                .rename_blank_nodes(),
+        }
+    }
+
+    /// Provides an IRI that could be used to resolve the file relative IRIs.
+    ///
+    /// ```
+    /// use oxigraph::io::{GraphFormat, GraphParser};
+    ///
+    /// let file = "</s> </p> </o> .";
+    ///
+    /// let parser =
+    ///     GraphParser::from_format(GraphFormat::Turtle).with_base_iri("http://example.com")?;
+    /// let triples = parser
+    ///     .read_triples(file.as_bytes())
+    ///     .collect::<Result<Vec<_>, _>>()?;
+    ///
+    /// assert_eq!(triples.len(), 1);
+    /// assert_eq!(triples[0].subject.to_string(), "<http://example.com/s>");
+    /// # Result::<_,Box<dyn std::error::Error>>::Ok(())
+    /// ```
+    #[inline]
+    pub fn with_base_iri(self, base_iri: impl Into<String>) -> Result<Self, IriParseError> {
+        Ok(Self {
+            inner: self.inner.with_base_iri(base_iri)?,
+        })
+    }
+
+    /// Executes the parsing itself on a [`Read`] implementation and returns an iterator of triples.
+    pub fn read_triples<R: Read>(self, reader: R) -> TripleReader<R> {
+        TripleReader {
+            parser: self.inner.parse_read(reader),
+        }
+    }
+}
+
+/// An iterator yielding read triples.
+/// Could be built using a [`GraphParser`].
+///
+/// ```
+/// use oxigraph::io::{GraphFormat, GraphParser};
+///
+/// let file = "<http://example.com/s> <http://example.com/p> <http://example.com/o> .";
+///
+/// let parser = GraphParser::from_format(GraphFormat::NTriples);
+/// let triples = parser
+///     .read_triples(file.as_bytes())
+///     .collect::<Result<Vec<_>, _>>()?;
+///
+/// assert_eq!(triples.len(), 1);
+/// assert_eq!(triples[0].subject.to_string(), "<http://example.com/s>");
+/// # std::io::Result::Ok(())
+/// ```
+#[must_use]
+pub struct TripleReader<R: Read> {
+    parser: FromReadQuadReader<R>,
+}
+
+impl<R: Read> Iterator for TripleReader<R> {
+    type Item = Result<Triple, RdfParseError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        Some(self.parser.next()?.map(Into::into).map_err(Into::into))
+    }
+}
+
+/// A parser for RDF dataset serialization formats.
+///
+/// It currently supports the following formats:
+/// * [N-Quads](https://www.w3.org/TR/n-quads/) ([`DatasetFormat::NQuads`])
+/// * [TriG](https://www.w3.org/TR/trig/) ([`DatasetFormat::TriG`])
+///
+/// ```
+/// use oxigraph::io::{DatasetFormat, DatasetParser};
+///
+/// let file = "<http://example.com/s> <http://example.com/p> <http://example.com/o> <http://example.com/g> .";
+///
+/// let parser = DatasetParser::from_format(DatasetFormat::NQuads);
+/// let quads = parser.read_quads(file.as_bytes()).collect::<Result<Vec<_>,_>>()?;
+///
+/// assert_eq!(quads.len(), 1);
+/// assert_eq!(quads[0].subject.to_string(), "<http://example.com/s>");
+/// # std::io::Result::Ok(())
+/// ```
+#[deprecated(note = "use RdfParser instead", since = "0.4.0")]
+pub struct DatasetParser {
+    inner: RdfParser,
+}
+
+impl DatasetParser {
+    /// Builds a parser for the given format.
+    #[inline]
+    pub fn from_format(format: DatasetFormat) -> Self {
+        Self {
+            inner: RdfParser::from_format(format.into()).rename_blank_nodes(),
+        }
+    }
+
+    /// Provides an IRI that could be used to resolve the file relative IRIs.
+    ///
+    /// ```
+    /// use oxigraph::io::{DatasetFormat, DatasetParser};
+    ///
+    /// let file = "<g> { </s> </p> </o> }";
+    ///
+    /// let parser =
+    ///     DatasetParser::from_format(DatasetFormat::TriG).with_base_iri("http://example.com")?;
+    /// let triples = parser
+    ///     .read_quads(file.as_bytes())
+    ///     .collect::<Result<Vec<_>, _>>()?;
+    ///
+    /// assert_eq!(triples.len(), 1);
+    /// assert_eq!(triples[0].subject.to_string(), "<http://example.com/s>");
+    /// # Result::<_,Box<dyn std::error::Error>>::Ok(())
+    /// ```
+    #[inline]
+    pub fn with_base_iri(self, base_iri: impl Into<String>) -> Result<Self, IriParseError> {
+        Ok(Self {
+            inner: self.inner.with_base_iri(base_iri)?,
+        })
+    }
+
+    /// Executes the parsing itself on a [`Read`] implementation and returns an iterator of quads.
+    pub fn read_quads<R: Read>(self, reader: R) -> QuadReader<R> {
+        QuadReader {
+            parser: self.inner.parse_read(reader),
+        }
+    }
+}
+
+/// An iterator yielding read quads.
+/// Could be built using a [`DatasetParser`].
+///
+/// ```
+/// use oxigraph::io::{DatasetFormat, DatasetParser};
+///
+/// let file = "<http://example.com/s> <http://example.com/p> <http://example.com/o> <http://example.com/g> .";
+///
+/// let parser = DatasetParser::from_format(DatasetFormat::NQuads);
+/// let quads = parser.read_quads(file.as_bytes()).collect::<Result<Vec<_>,_>>()?;
+///
+/// assert_eq!(quads.len(), 1);
+/// assert_eq!(quads[0].subject.to_string(), "<http://example.com/s>");
+/// # std::io::Result::Ok(())
+/// ```
+#[must_use]
+pub struct QuadReader<R: Read> {
+    parser: FromReadQuadReader<R>,
+}
+
+impl<R: Read> Iterator for QuadReader<R> {
+    type Item = Result<Quad, RdfParseError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        Some(self.parser.next()?.map_err(Into::into))
+    }
+}

lib/oxigraph/src/io/write.rs

@@ -0,0 +1,185 @@
+#![allow(deprecated)]
+
+//! Utilities to write RDF graphs and datasets.
+
+use crate::io::{DatasetFormat, GraphFormat};
+use crate::model::*;
+use oxrdfio::{RdfSerializer, ToWriteQuadWriter};
+use std::io::{self, Write};
+
+/// A serializer for RDF graph serialization formats.
+///
+/// It currently supports the following formats:
+/// * [N-Triples](https://www.w3.org/TR/n-triples/) ([`GraphFormat::NTriples`])
+/// * [Turtle](https://www.w3.org/TR/turtle/) ([`GraphFormat::Turtle`])
+/// * [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/) ([`GraphFormat::RdfXml`])
+///
+/// ```
+/// use oxigraph::io::{GraphFormat, GraphSerializer};
+/// use oxigraph::model::*;
+///
+/// let mut buffer = Vec::new();
+/// let mut writer = GraphSerializer::from_format(GraphFormat::NTriples).triple_writer(&mut buffer);
+/// writer.write(&Triple {
+///     subject: NamedNode::new("http://example.com/s")?.into(),
+///     predicate: NamedNode::new("http://example.com/p")?,
+///     object: NamedNode::new("http://example.com/o")?.into(),
+/// })?;
+/// writer.finish()?;
+///
+/// assert_eq!(
+///     buffer.as_slice(),
+///     "<http://example.com/s> <http://example.com/p> <http://example.com/o> .\n".as_bytes()
+/// );
+/// # Result::<_,Box<dyn std::error::Error>>::Ok(())
+/// ```
+#[deprecated(note = "use RdfSerializer instead", since = "0.4.0")]
+pub struct GraphSerializer {
+    inner: RdfSerializer,
+}
+
+impl GraphSerializer {
+    /// Builds a serializer for the given format
+    #[inline]
+    pub fn from_format(format: GraphFormat) -> Self {
+        Self {
+            inner: RdfSerializer::from_format(format.into()),
+        }
+    }
+
+    /// Returns a [`TripleWriter`] allowing writing triples into the given [`Write`] implementation
+    pub fn triple_writer<W: Write>(self, write: W) -> TripleWriter<W> {
+        TripleWriter {
+            writer: self.inner.serialize_to_write(write),
+        }
+    }
+}
+
+/// Allows writing triples.
+/// Could be built using a [`GraphSerializer`].
+///
+/// <div class="warning">
+///
+/// Do not forget to run the [`finish`](TripleWriter::finish()) method to properly write the last bytes of the file.</div>
+///
+/// ```
+/// use oxigraph::io::{GraphFormat, GraphSerializer};
+/// use oxigraph::model::*;
+///
+/// let mut buffer = Vec::new();
+/// let mut writer = GraphSerializer::from_format(GraphFormat::NTriples).triple_writer(&mut buffer);
+/// writer.write(&Triple {
+///     subject: NamedNode::new("http://example.com/s")?.into(),
+///     predicate: NamedNode::new("http://example.com/p")?,
+///     object: NamedNode::new("http://example.com/o")?.into(),
+/// })?;
+/// writer.finish()?;
+///
+/// assert_eq!(
+///     buffer.as_slice(),
+///     "<http://example.com/s> <http://example.com/p> <http://example.com/o> .\n".as_bytes()
+/// );
+/// # Result::<_,Box<dyn std::error::Error>>::Ok(())
+/// ```
+#[must_use]
+pub struct TripleWriter<W: Write> {
+    writer: ToWriteQuadWriter<W>,
+}
+
+impl<W: Write> TripleWriter<W> {
+    /// Writes a triple
+    pub fn write<'a>(&mut self, triple: impl Into<TripleRef<'a>>) -> io::Result<()> {
+        self.writer.write_triple(triple)
+    }
+
+    /// Writes the last bytes of the file
+    pub fn finish(self) -> io::Result<()> {
+        self.writer.finish()?.flush()
+    }
+}
+
+/// A serializer for RDF graph serialization formats.
+///
+/// It currently supports the following formats:
+/// * [N-Quads](https://www.w3.org/TR/n-quads/) ([`DatasetFormat::NQuads`])
+/// * [TriG](https://www.w3.org/TR/trig/) ([`DatasetFormat::TriG`])
+///
+/// ```
+/// use oxigraph::io::{DatasetFormat, DatasetSerializer};
+/// use oxigraph::model::*;
+///
+/// let mut buffer = Vec::new();
+/// let mut writer = DatasetSerializer::from_format(DatasetFormat::NQuads).quad_writer(&mut buffer);
+/// writer.write(&Quad {
+///    subject: NamedNode::new("http://example.com/s")?.into(),
+///    predicate: NamedNode::new("http://example.com/p")?,
+///    object: NamedNode::new("http://example.com/o")?.into(),
+///    graph_name: NamedNode::new("http://example.com/g")?.into(),
+/// })?;
+/// writer.finish()?;
+///
+/// assert_eq!(buffer.as_slice(), "<http://example.com/s> <http://example.com/p> <http://example.com/o> <http://example.com/g> .\n".as_bytes());
+/// # Result::<_,Box<dyn std::error::Error>>::Ok(())
+/// ```
+#[deprecated(note = "use RdfSerializer instead", since = "0.4.0")]
+pub struct DatasetSerializer {
+    inner: RdfSerializer,
+}
+
+impl DatasetSerializer {
+    /// Builds a serializer for the given format
+    #[inline]
+    pub fn from_format(format: DatasetFormat) -> Self {
+        Self {
+            inner: RdfSerializer::from_format(format.into()),
+        }
+    }
+
+    /// Returns a [`QuadWriter`] allowing writing triples into the given [`Write`] implementation
+    pub fn quad_writer<W: Write>(self, write: W) -> QuadWriter<W> {
+        QuadWriter {
+            writer: self.inner.serialize_to_write(write),
+        }
+    }
+}
+
+/// Allows writing triples.
+/// Could be built using a [`DatasetSerializer`].
+///
+/// <div class="warning">
+///
+/// Do not forget to run the [`finish`](QuadWriter::finish()) method to properly write the last bytes of the file.</div>
+///
+/// ```
+/// use oxigraph::io::{DatasetFormat, DatasetSerializer};
+/// use oxigraph::model::*;
+///
+/// let mut buffer = Vec::new();
+/// let mut writer = DatasetSerializer::from_format(DatasetFormat::NQuads).quad_writer(&mut buffer);
+/// writer.write(&Quad {
+///    subject: NamedNode::new("http://example.com/s")?.into(),
+///    predicate: NamedNode::new("http://example.com/p")?,
+///    object: NamedNode::new("http://example.com/o")?.into(),
+///    graph_name: NamedNode::new("http://example.com/g")?.into(),
+/// })?;
+/// writer.finish()?;
+///
+/// assert_eq!(buffer.as_slice(), "<http://example.com/s> <http://example.com/p> <http://example.com/o> <http://example.com/g> .\n".as_bytes());
+/// # Result::<_,Box<dyn std::error::Error>>::Ok(())
+/// ```
+#[must_use]
+pub struct QuadWriter<W: Write> {
+    writer: ToWriteQuadWriter<W>,
+}
+
+impl<W: Write> QuadWriter<W> {
+    /// Writes a quad
+    pub fn write<'a>(&mut self, quad: impl Into<QuadRef<'a>>) -> io::Result<()> {
+        self.writer.write_quad(quad)
+    }
+
+    /// Writes the last bytes of the file
+    pub fn finish(self) -> io::Result<()> {
+        self.writer.finish()?.flush()
+    }
+}

lib/oxigraph/src/lib.rs

@@ -0,0 +1,12 @@
+#![doc = include_str!("../README.md")]
+#![doc(test(attr(deny(warnings))))]
+#![doc(test(attr(allow(deprecated))))]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![doc(html_favicon_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/main/logo.svg")]
+#![doc(html_logo_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/main/logo.svg")]
+
+pub mod io;
+pub mod model;
+pub mod sparql;
+mod storage;
+pub mod store;

lib/oxigraph/src/model.rs

@@ -0,0 +1,22 @@
+//! Implements data structures for [RDF 1.1 Concepts](https://www.w3.org/TR/rdf11-concepts/) using [OxRDF](https://crates.io/crates/oxrdf).
+//!
+//! Usage example:
+//!
+//! ```
+//! use oxigraph::model::*;
+//!
+//! let mut graph = Graph::default();
+//!
+//! // insertion
+//! let ex = NamedNodeRef::new("http://example.com").unwrap();
+//! let triple = TripleRef::new(ex, ex, ex);
+//! graph.insert(triple);
+//!
+//! // simple filter
+//! let results: Vec<_> = graph.triples_for_subject(ex).collect();
+//! assert_eq!(vec![triple], results);
+//! ```
+
+pub use oxrdf::*;
+
+pub use spargebra::term::GroundQuad;

lib/oxigraph/src/sparql/algebra.rs

@@ -1,10 +1,10 @@
 //! [SPARQL 1.1 Query Algebra](https://www.w3.org/TR/sparql11-query/#sparqlQuery)
 //!
 //! The root type for SPARQL queries is [`Query`] and the root type for updates is [`Update`].
-//!
-//! Warning: this implementation is an unstable work in progress
 
 use crate::model::*;
+use crate::sparql::eval::Timer;
+use oxsdatatypes::DayTimeDuration;
 use spargebra::GraphUpdateOperation;
 use std::fmt;
 use std::str::FromStr;
@@ -23,27 +23,31 @@ use std::str::FromStr;
 /// // We edit the query dataset specification
 /// let default = vec![NamedNode::new("http://example.com")?.into()];
 /// query.dataset_mut().set_default_graph(default.clone());
-/// assert_eq!(query.dataset().default_graph_graphs(), Some(default.as_slice()));
-/// # Result::Ok::<_, Box<dyn std::error::Error>>(())
+/// assert_eq!(
+///     query.dataset().default_graph_graphs(),
+///     Some(default.as_slice())
+/// );
+/// # Ok::<_, Box<dyn std::error::Error>>(())
 /// ```
 #[derive(Eq, PartialEq, Debug, Clone, Hash)]
 pub struct Query {
     pub(super) inner: spargebra::Query,
     pub(super) dataset: QueryDataset,
+    pub(super) parsing_duration: Option<DayTimeDuration>,
 }
 
 impl Query {
     /// Parses a SPARQL query with an optional base IRI to resolve relative IRIs in the query.
-    pub fn parse(query: &str, base_iri: Option<&str>) -> Result<Self, spargebra::ParseError> {
-        let query = spargebra::Query::parse(query, base_iri)?;
+    pub fn parse(
+        query: &str,
+        base_iri: Option<&str>,
+    ) -> Result<Self, spargebra::SparqlSyntaxError> {
+        let start = Timer::now();
+        let query = Self::from(spargebra::Query::parse(query, base_iri)?);
         Ok(Self {
-            dataset: QueryDataset::from_algebra(match &query {
-                spargebra::Query::Select { dataset, .. }
-                | spargebra::Query::Construct { dataset, .. }
-                | spargebra::Query::Describe { dataset, .. }
-                | spargebra::Query::Ask { dataset, .. } => dataset,
-            }),
-            inner: query,
+            dataset: query.dataset,
+            inner: query.inner,
+            parsing_duration: start.elapsed(),
         })
     }
 
@@ -60,34 +64,49 @@ impl Query {
 
 impl fmt::Display for Query {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.inner.fmt(f) //TODO: override
+        self.inner.fmt(f) // TODO: override
     }
 }
 
 impl FromStr for Query {
-    type Err = spargebra::ParseError;
+    type Err = spargebra::SparqlSyntaxError;
 
-    fn from_str(query: &str) -> Result<Self, spargebra::ParseError> {
+    fn from_str(query: &str) -> Result<Self, Self::Err> {
         Self::parse(query, None)
     }
 }
 
-impl<'a> TryFrom<&'a str> for Query {
-    type Error = spargebra::ParseError;
+impl TryFrom<&str> for Query {
+    type Error = spargebra::SparqlSyntaxError;
 
-    fn try_from(query: &str) -> Result<Self, spargebra::ParseError> {
+    fn try_from(query: &str) -> Result<Self, Self::Error> {
         Self::from_str(query)
     }
 }
 
-impl<'a> TryFrom<&'a String> for Query {
-    type Error = spargebra::ParseError;
+impl TryFrom<&String> for Query {
+    type Error = spargebra::SparqlSyntaxError;
 
-    fn try_from(query: &String) -> Result<Self, spargebra::ParseError> {
+    fn try_from(query: &String) -> Result<Self, Self::Error> {
         Self::from_str(query)
     }
 }
 
+impl From<spargebra::Query> for Query {
+    fn from(query: spargebra::Query) -> Self {
+        Self {
+            dataset: QueryDataset::from_algebra(match &query {
+                spargebra::Query::Select { dataset, .. }
+                | spargebra::Query::Construct { dataset, .. }
+                | spargebra::Query::Describe { dataset, .. }
+                | spargebra::Query::Ask { dataset, .. } => dataset,
+            }),
+            inner: query,
+            parsing_duration: None,
+        }
+    }
+}
+
 /// A parsed [SPARQL update](https://www.w3.org/TR/sparql11-update/).
 ///
 /// ```
@@ -97,7 +116,7 @@ impl<'a> TryFrom<&'a String> for Query {
 /// let update = Update::parse(update_str, None)?;
 ///
 /// assert_eq!(update.to_string().trim(), update_str);
-/// # Result::Ok::<_, oxigraph::sparql::ParseError>(())
+/// # Ok::<_, oxigraph::sparql::SparqlSyntaxError>(())
 /// ```
 #[derive(Eq, PartialEq, Debug, Clone, Hash)]
 pub struct Update {
@@ -107,36 +126,21 @@ pub struct Update {
 
 impl Update {
     /// Parses a SPARQL update with an optional base IRI to resolve relative IRIs in the query.
-    pub fn parse(update: &str, base_iri: Option<&str>) -> Result<Self, spargebra::ParseError> {
-        let update = spargebra::Update::parse(update, base_iri)?;
-        Ok(Self {
-            using_datasets: update
-                .operations
-                .iter()
-                .map(|operation| {
-                    if let GraphUpdateOperation::DeleteInsert { using, .. } = operation {
-                        Some(QueryDataset::from_algebra(using))
-                    } else {
-                        None
-                    }
-                })
-                .collect(),
-            inner: update,
-        })
+    pub fn parse(
+        update: &str,
+        base_iri: Option<&str>,
+    ) -> Result<Self, spargebra::SparqlSyntaxError> {
+        Ok(spargebra::Update::parse(update, base_iri)?.into())
     }
 
     /// Returns [the query dataset specification](https://www.w3.org/TR/sparql11-query/#specifyingDataset) in [DELETE/INSERT operations](https://www.w3.org/TR/sparql11-update/#deleteInsert).
     pub fn using_datasets(&self) -> impl Iterator<Item = &QueryDataset> {
-        self.using_datasets
-            .iter()
-            .filter_map(std::option::Option::as_ref)
+        self.using_datasets.iter().filter_map(Option::as_ref)
     }
 
     /// Returns [the query dataset specification](https://www.w3.org/TR/sparql11-query/#specifyingDataset) in [DELETE/INSERT operations](https://www.w3.org/TR/sparql11-update/#deleteInsert).
     pub fn using_datasets_mut(&mut self) -> impl Iterator<Item = &mut QueryDataset> {
-        self.using_datasets
-            .iter_mut()
-            .filter_map(std::option::Option::as_mut)
+        self.using_datasets.iter_mut().filter_map(Option::as_mut)
     }
 }
 
@@ -147,29 +151,48 @@ impl fmt::Display for Update {
 }
 
 impl FromStr for Update {
-    type Err = spargebra::ParseError;
+    type Err = spargebra::SparqlSyntaxError;
 
-    fn from_str(update: &str) -> Result<Self, spargebra::ParseError> {
+    fn from_str(update: &str) -> Result<Self, Self::Err> {
         Self::parse(update, None)
     }
 }
 
-impl<'a> TryFrom<&'a str> for Update {
-    type Error = spargebra::ParseError;
+impl TryFrom<&str> for Update {
+    type Error = spargebra::SparqlSyntaxError;
 
-    fn try_from(update: &str) -> Result<Self, spargebra::ParseError> {
+    fn try_from(update: &str) -> Result<Self, Self::Error> {
         Self::from_str(update)
     }
 }
 
-impl<'a> TryFrom<&'a String> for Update {
-    type Error = spargebra::ParseError;
+impl TryFrom<&String> for Update {
+    type Error = spargebra::SparqlSyntaxError;
 
-    fn try_from(update: &String) -> Result<Self, spargebra::ParseError> {
+    fn try_from(update: &String) -> Result<Self, Self::Error> {
         Self::from_str(update)
     }
 }
 
+impl From<spargebra::Update> for Update {
+    fn from(update: spargebra::Update) -> Self {
+        Self {
+            using_datasets: update
+                .operations
+                .iter()
+                .map(|operation| {
+                    if let GraphUpdateOperation::DeleteInsert { using, .. } = operation {
+                        Some(QueryDataset::from_algebra(using))
+                    } else {
+                        None
+                    }
+                })
+                .collect(),
+            inner: update,
+        }
+    }
+}
+
 /// A SPARQL query [dataset specification](https://www.w3.org/TR/sparql11-query/#specifyingDataset)
 #[derive(Eq, PartialEq, Debug, Clone, Hash)]
 pub struct QueryDataset {
@@ -208,10 +231,17 @@ impl QueryDataset {
     /// ```
     /// use oxigraph::sparql::Query;
     ///
-    /// assert!(Query::parse("SELECT ?s ?p ?o WHERE { ?s ?p ?o . }", None)?.dataset().is_default_dataset());
-    /// assert!(!Query::parse("SELECT ?s ?p ?o FROM <http://example.com> WHERE { ?s ?p ?o . }", None)?.dataset().is_default_dataset());
+    /// assert!(Query::parse("SELECT ?s ?p ?o WHERE { ?s ?p ?o . }", None)?
+    ///     .dataset()
+    ///     .is_default_dataset());
+    /// assert!(!Query::parse(
+    ///     "SELECT ?s ?p ?o FROM <http://example.com> WHERE { ?s ?p ?o . }",
+    ///     None
+    /// )?
+    /// .dataset()
+    /// .is_default_dataset());
     ///
-    /// # Result::Ok::<_, Box<dyn std::error::Error>>(())
+    /// # Ok::<_, Box<dyn std::error::Error>>(())
     /// ```
     pub fn is_default_dataset(&self) -> bool {
         self.default
@@ -241,9 +271,12 @@ impl QueryDataset {
     /// let mut query = Query::parse("SELECT ?s ?p ?o WHERE { ?s ?p ?o . }", None)?;
     /// let default = vec![NamedNode::new("http://example.com")?.into()];
     /// query.dataset_mut().set_default_graph(default.clone());
-    /// assert_eq!(query.dataset().default_graph_graphs(), Some(default.as_slice()));    
+    /// assert_eq!(
+    ///     query.dataset().default_graph_graphs(),
+    ///     Some(default.as_slice())
+    /// );
     ///
-    /// # Result::Ok::<_, Box<dyn std::error::Error>>(())
+    /// # Ok::<_, Box<dyn std::error::Error>>(())
     /// ```
     pub fn set_default_graph(&mut self, graphs: Vec<GraphName>) {
         self.default = Some(graphs)
@@ -262,10 +295,15 @@ impl QueryDataset {
     ///
     /// let mut query = Query::parse("SELECT ?s ?p ?o WHERE { ?s ?p ?o . }", None)?;
     /// let named = vec![NamedNode::new("http://example.com")?.into()];
-    /// query.dataset_mut().set_available_named_graphs(named.clone());
-    /// assert_eq!(query.dataset().available_named_graphs(), Some(named.as_slice()));
+    /// query
+    ///     .dataset_mut()
+    ///     .set_available_named_graphs(named.clone());
+    /// assert_eq!(
+    ///     query.dataset().available_named_graphs(),
+    ///     Some(named.as_slice())
+    /// );
     ///
-    /// # Result::Ok::<_, Box<dyn std::error::Error>>(())
+    /// # Ok::<_, Box<dyn std::error::Error>>(())
     /// ```
     pub fn set_available_named_graphs(&mut self, named_graphs: Vec<NamedOrBlankNode>) {
         self.named = Some(named_graphs);

lib/oxigraph/src/sparql/dataset.rs

@@ -1,9 +1,7 @@
 use crate::model::TermRef;
 use crate::sparql::algebra::QueryDataset;
 use crate::sparql::EvaluationError;
-use crate::storage::numeric_encoder::{
-    insert_term, EncodedQuad, EncodedTerm, StrHash, StrLookup, TermDecoder,
-};
+use crate::storage::numeric_encoder::{insert_term, EncodedQuad, EncodedTerm, StrHash, StrLookup};
 use crate::storage::{StorageError, StorageReader};
 use std::cell::RefCell;
 use std::collections::hash_map::Entry;
@@ -18,20 +16,13 @@ pub struct DatasetView {
 
 impl DatasetView {
     pub fn new(reader: StorageReader, dataset: &QueryDataset) -> Self {
-        let encoder = reader.term_encoder();
         let dataset = EncodedDatasetSpec {
-            default: dataset.default_graph_graphs().map(|graphs| {
-                graphs
-                    .iter()
-                    .map(|g| encoder.encode_graph_name(g))
-                    .collect::<Vec<_>>()
-            }),
-            named: dataset.available_named_graphs().map(|graphs| {
-                graphs
-                    .iter()
-                    .map(|g| encoder.encode_term(g))
-                    .collect::<Vec<_>>()
-            }),
+            default: dataset
+                .default_graph_graphs()
+                .map(|graphs| graphs.iter().map(|g| g.as_ref().into()).collect::<Vec<_>>()),
+            named: dataset
+                .available_named_graphs()
+                .map(|graphs| graphs.iter().map(|g| g.as_ref().into()).collect::<Vec<_>>()),
         };
         Self {
             reader,
@@ -49,7 +40,7 @@ impl DatasetView {
     ) -> impl Iterator<Item = Result<EncodedQuad, EvaluationError>> + 'static {
         self.reader
             .quads_for_pattern(subject, predicate, object, graph_name)
-            .map(|t| t.map_err(|e| e.into()))
+            .map(|t| t.map_err(Into::into))
     }
 
     #[allow(clippy::needless_collect)]
@@ -151,7 +142,7 @@ impl DatasetView {
                 self.store_encoded_quads_for_pattern(subject, predicate, object, None)
                     .filter(|quad| match quad {
                         Err(_) => true,
-                        Ok(quad) => quad.graph_name != EncodedTerm::DefaultGraph,
+                        Ok(quad) => !quad.graph_name.is_default_graph(),
                     }),
             )
         }
@@ -159,7 +150,7 @@ impl DatasetView {
 
     pub fn encode_term<'a>(&self, term: impl Into<TermRef<'a>>) -> EncodedTerm {
         let term = term.into();
-        let encoded = self.reader.term_encoder().encode_term(term);
+        let encoded = term.into();
         insert_term(term, &encoded, &mut |key, value| {
             self.insert_str(key, value);
             Ok(())
@@ -168,10 +159,6 @@ impl DatasetView {
         encoded
     }
 
-    pub fn term_decoder(&self) -> TermDecoder<Self> {
-        TermDecoder::new(self)
-    }
-
     pub fn insert_str(&self, key: &StrHash, value: &str) {
         if let Entry::Vacant(e) = self.extra.borrow_mut().entry(*key) {
             if !matches!(self.reader.contains_str(key), Ok(true)) {
@@ -189,10 +176,6 @@ impl StrLookup for DatasetView {
             self.reader.get_str(key)?
         })
     }
-
-    fn contains_str(&self, key: &StrHash) -> Result<bool, StorageError> {
-        Ok(self.extra.borrow().contains_key(key) || self.reader.contains_str(key)?)
-    }
 }
 
 struct EncodedDatasetSpec {

lib/oxigraph/src/sparql/error.rs

@@ -0,0 +1,84 @@
+use crate::io::RdfParseError;
+use crate::model::NamedNode;
+use crate::sparql::results::QueryResultsParseError as ResultsParseError;
+use crate::sparql::SparqlSyntaxError;
+use crate::storage::StorageError;
+use std::convert::Infallible;
+use std::error::Error;
+use std::io;
+
+/// A SPARQL evaluation error.
+#[derive(Debug, thiserror::Error)]
+#[non_exhaustive]
+pub enum EvaluationError {
+    /// An error in SPARQL parsing.
+    #[error(transparent)]
+    Parsing(#[from] SparqlSyntaxError),
+    /// An error from the storage.
+    #[error(transparent)]
+    Storage(#[from] StorageError),
+    /// An error while parsing an external RDF file.
+    #[error(transparent)]
+    GraphParsing(#[from] RdfParseError),
+    /// An error while parsing an external result file (likely from a federated query).
+    #[error(transparent)]
+    ResultsParsing(#[from] ResultsParseError),
+    /// An error returned during results serialization.
+    #[error(transparent)]
+    ResultsSerialization(#[from] io::Error),
+    /// Error during `SERVICE` evaluation
+    #[error("{0}")]
+    Service(#[source] Box<dyn Error + Send + Sync + 'static>),
+    /// Error when `CREATE` tries to create an already existing graph
+    #[error("The graph {0} already exists")]
+    GraphAlreadyExists(NamedNode),
+    /// Error when `DROP` or `CLEAR` tries to remove a not existing graph
+    #[error("The graph {0} does not exist")]
+    GraphDoesNotExist(NamedNode),
+    /// The variable storing the `SERVICE` name is unbound
+    #[error("The variable encoding the service name is unbound")]
+    UnboundService,
+    /// The given `SERVICE` is not supported
+    #[error("The service {0} is not supported")]
+    UnsupportedService(NamedNode),
+    /// The given content media type returned from an HTTP response is not supported (`SERVICE` and `LOAD`)
+    #[error("The content media type {0} is not supported")]
+    UnsupportedContentType(String),
+    /// The `SERVICE` call has not returns solutions
+    #[error("The service is not returning solutions but a boolean or a graph")]
+    ServiceDoesNotReturnSolutions,
+    /// The results are not a RDF graph
+    #[error("The query results are not a RDF graph")]
+    NotAGraph,
+}
+
+impl From<Infallible> for EvaluationError {
+    #[inline]
+    fn from(error: Infallible) -> Self {
+        match error {}
+    }
+}
+
+impl From<EvaluationError> for io::Error {
+    #[inline]
+    fn from(error: EvaluationError) -> Self {
+        match error {
+            EvaluationError::Parsing(error) => Self::new(io::ErrorKind::InvalidData, error),
+            EvaluationError::GraphParsing(error) => error.into(),
+            EvaluationError::ResultsParsing(error) => error.into(),
+            EvaluationError::ResultsSerialization(error) => error,
+            EvaluationError::Storage(error) => error.into(),
+            EvaluationError::Service(error) => match error.downcast() {
+                Ok(error) => *error,
+                Err(error) => Self::new(io::ErrorKind::Other, error),
+            },
+            EvaluationError::GraphAlreadyExists(_)
+            | EvaluationError::GraphDoesNotExist(_)
+            | EvaluationError::UnboundService
+            | EvaluationError::UnsupportedService(_)
+            | EvaluationError::UnsupportedContentType(_)
+            | EvaluationError::ServiceDoesNotReturnSolutions
+            | EvaluationError::NotAGraph => Self::new(io::ErrorKind::InvalidInput, error),
+        }
+    }
+}

lib/oxigraph/src/sparql/http/dummy.rs

@@ -3,30 +3,32 @@
 use std::io::{Empty, Error, ErrorKind, Result};
 use std::time::Duration;
 
-pub struct Client {}
+pub struct Client;
 
 impl Client {
-    pub fn new(_timeout: Option<Duration>) -> Self {
-        Self {}
+    pub fn new(_timeout: Option<Duration>, _redirection_limit: usize) -> Self {
+        Self
     }
 
-    pub fn get(&self, _url: &str, _accept: &str) -> Result<(String, Empty)> {
+    #[allow(clippy::unused_self)]
+    pub fn get(&self, _url: &str, _accept: &'static str) -> Result<(String, Empty)> {
         Err(Error::new(
             ErrorKind::Unsupported,
-            "HTTP client is not available. Enable the feature 'http_client'",
+            "HTTP client is not available. Enable the feature 'http-client'",
         ))
     }
 
+    #[allow(clippy::unused_self, clippy::needless_pass_by_value)]
     pub fn post(
         &self,
         _url: &str,
         _payload: Vec<u8>,
-        _content_type: &str,
-        _accept: &str,
+        _content_type: &'static str,
+        _accept: &'static str,
     ) -> Result<(String, Empty)> {
         Err(Error::new(
             ErrorKind::Unsupported,
-            "HTTP client is not available. Enable the feature 'http_client'",
+            "HTTP client is not available. Enable the feature 'http-client'",
         ))
     }
 }

lib/oxigraph/src/sparql/http/mod.rs

@@ -0,0 +1,9 @@
+#[cfg(not(feature = "http-client"))]
+mod dummy;
+#[cfg(feature = "http-client")]
+mod simple;
+
+#[cfg(not(feature = "http-client"))]
+pub use dummy::Client;
+#[cfg(feature = "http-client")]
+pub use simple::Client;

lib/oxigraph/src/sparql/http/simple.rs

@@ -7,26 +7,38 @@ pub struct Client {
 }
 
 impl Client {
-    pub fn new(timeout: Option<Duration>) -> Self {
-        let mut client = oxhttp::Client::new();
+    pub fn new(timeout: Option<Duration>, redirection_limit: usize) -> Self {
+        let mut client = oxhttp::Client::new()
+            .with_redirection_limit(redirection_limit)
+            .with_user_agent(concat!("Oxigraph/", env!("CARGO_PKG_VERSION")))
+            .unwrap();
         if let Some(timeout) = timeout {
-            client.set_global_timeout(timeout);
+            client = client.with_global_timeout(timeout);
         }
-        client
-            .set_user_agent(concat!("Oxigraph/", env!("CARGO_PKG_VERSION")))
-            .unwrap();
         Self { client }
     }
 
-    pub fn get(&self, url: &str, accept: &str) -> Result<(String, Body)> {
+    pub fn get(&self, url: &str, accept: &'static str) -> Result<(String, Body)> {
         let request = Request::builder(Method::GET, url.parse().map_err(invalid_input_error)?)
             .with_header(HeaderName::ACCEPT, accept)
             .map_err(invalid_input_error)?
             .build();
         let response = self.client.request(request)?;
+        let status = response.status();
+        if !status.is_successful() {
+            return Err(Error::new(
+                ErrorKind::Other,
+                format!(
+                    "Error {} returned by {} with payload:\n{}",
+                    status,
+                    url,
+                    response.into_body().to_string()?
+                ),
+            ));
+        }
         let content_type = response
             .header(&HeaderName::CONTENT_TYPE)
-            .ok_or_else(|| invalid_data_error(format!("No Content-Type returned by {}", url)))?
+            .ok_or_else(|| invalid_data_error(format!("No Content-Type returned by {url}")))?
             .to_str()
             .map_err(invalid_data_error)?
             .to_owned();
@@ -37,19 +49,31 @@ impl Client {
         &self,
         url: &str,
         payload: Vec<u8>,
-        content_type: &str,
-        accept: &str,
+        content_type: &'static str,
+        accept: &'static str,
     ) -> Result<(String, Body)> {
-        let request = Request::builder(Method::GET, url.parse().map_err(invalid_input_error)?)
+        let request = Request::builder(Method::POST, url.parse().map_err(invalid_input_error)?)
             .with_header(HeaderName::ACCEPT, accept)
             .map_err(invalid_input_error)?
             .with_header(HeaderName::CONTENT_TYPE, content_type)
             .map_err(invalid_input_error)?
             .with_body(payload);
         let response = self.client.request(request)?;
+        let status = response.status();
+        if !status.is_successful() {
+            return Err(Error::new(
+                ErrorKind::Other,
+                format!(
+                    "Error {} returned by {} with payload:\n{}",
+                    status,
+                    url,
+                    response.into_body().to_string()?
+                ),
+            ));
+        }
         let content_type = response
             .header(&HeaderName::CONTENT_TYPE)
-            .ok_or_else(|| invalid_data_error(format!("No Content-Type returned by {}", url)))?
+            .ok_or_else(|| invalid_data_error(format!("No Content-Type returned by {url}")))?
             .to_str()
             .map_err(invalid_data_error)?
             .to_owned();

lib/oxigraph/src/sparql/mod.rs

@@ -0,0 +1,328 @@
+//! [SPARQL](https://www.w3.org/TR/sparql11-overview/) implementation.
+//!
+//! Stores execute SPARQL. See [`Store`](crate::store::Store::query()) for an example.
+
+mod algebra;
+mod dataset;
+mod error;
+mod eval;
+mod http;
+mod model;
+pub mod results;
+mod service;
+mod update;
+
+use crate::model::{NamedNode, Term};
+pub use crate::sparql::algebra::{Query, QueryDataset, Update};
+use crate::sparql::dataset::DatasetView;
+pub use crate::sparql::error::EvaluationError;
+use crate::sparql::eval::{EvalNodeWithStats, SimpleEvaluator, Timer};
+pub use crate::sparql::model::{QueryResults, QuerySolution, QuerySolutionIter, QueryTripleIter};
+pub use crate::sparql::service::ServiceHandler;
+use crate::sparql::service::{EmptyServiceHandler, ErrorConversionServiceHandler};
+pub(crate) use crate::sparql::update::evaluate_update;
+use crate::storage::StorageReader;
+use json_event_parser::{JsonEvent, ToWriteJsonWriter};
+pub use oxrdf::{Variable, VariableNameParseError};
+use oxsdatatypes::{DayTimeDuration, Float};
+pub use spargebra::SparqlSyntaxError;
+use sparopt::algebra::GraphPattern;
+use sparopt::Optimizer;
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::time::Duration;
+use std::{fmt, io};
+
+#[allow(clippy::needless_pass_by_value)]
+pub(crate) fn evaluate_query(
+    reader: StorageReader,
+    query: impl TryInto<Query, Error = impl Into<EvaluationError>>,
+    options: QueryOptions,
+    run_stats: bool,
+) -> Result<(Result<QueryResults, EvaluationError>, QueryExplanation), EvaluationError> {
+    let query = query.try_into().map_err(Into::into)?;
+    let dataset = DatasetView::new(reader, &query.dataset);
+    let start_planning = Timer::now();
+    let (results, plan_node_with_stats, planning_duration) = match query.inner {
+        spargebra::Query::Select {
+            pattern, base_iri, ..
+        } => {
+            let mut pattern = GraphPattern::from(&pattern);
+            if !options.without_optimizations {
+                pattern = Optimizer::optimize_graph_pattern(pattern);
+            }
+            let planning_duration = start_planning.elapsed();
+            let (results, explanation) = SimpleEvaluator::new(
+                Rc::new(dataset),
+                base_iri.map(Rc::new),
+                options.service_handler(),
+                Arc::new(options.custom_functions),
+                run_stats,
+            )
+            .evaluate_select(&pattern);
+            (Ok(results), explanation, planning_duration)
+        }
+        spargebra::Query::Ask {
+            pattern, base_iri, ..
+        } => {
+            let mut pattern = GraphPattern::from(&pattern);
+            if !options.without_optimizations {
+                pattern = Optimizer::optimize_graph_pattern(GraphPattern::Reduced {
+                    inner: Box::new(pattern),
+                });
+            }
+            let planning_duration = start_planning.elapsed();
+            let (results, explanation) = SimpleEvaluator::new(
+                Rc::new(dataset),
+                base_iri.map(Rc::new),
+                options.service_handler(),
+                Arc::new(options.custom_functions),
+                run_stats,
+            )
+            .evaluate_ask(&pattern);
+            (results, explanation, planning_duration)
+        }
+        spargebra::Query::Construct {
+            template,
+            pattern,
+            base_iri,
+            ..
+        } => {
+            let mut pattern = GraphPattern::from(&pattern);
+            if !options.without_optimizations {
+                pattern = Optimizer::optimize_graph_pattern(GraphPattern::Reduced {
+                    inner: Box::new(pattern),
+                });
+            }
+            let planning_duration = start_planning.elapsed();
+            let (results, explanation) = SimpleEvaluator::new(
+                Rc::new(dataset),
+                base_iri.map(Rc::new),
+                options.service_handler(),
+                Arc::new(options.custom_functions),
+                run_stats,
+            )
+            .evaluate_construct(&pattern, &template);
+            (Ok(results), explanation, planning_duration)
+        }
+        spargebra::Query::Describe {
+            pattern, base_iri, ..
+        } => {
+            let mut pattern = GraphPattern::from(&pattern);
+            if !options.without_optimizations {
+                pattern = Optimizer::optimize_graph_pattern(GraphPattern::Reduced {
+                    inner: Box::new(pattern),
+                });
+            }
+            let planning_duration = start_planning.elapsed();
+            let (results, explanation) = SimpleEvaluator::new(
+                Rc::new(dataset),
+                base_iri.map(Rc::new),
+                options.service_handler(),
+                Arc::new(options.custom_functions),
+                run_stats,
+            )
+            .evaluate_describe(&pattern);
+            (Ok(results), explanation, planning_duration)
+        }
+    };
+    let explanation = QueryExplanation {
+        inner: plan_node_with_stats,
+        with_stats: run_stats,
+        parsing_duration: query.parsing_duration,
+        planning_duration,
+    };
+    Ok((results, explanation))
+}
+
+/// Options for SPARQL query evaluation.
+///
+///
+/// If the `"http-client"` optional feature is enabled,
+/// a simple HTTP 1.1 client is used to execute [SPARQL 1.1 Federated Query](https://www.w3.org/TR/sparql11-federated-query/) SERVICE calls.
+///
+/// Usage example disabling the federated query support:
+/// ```
+/// use oxigraph::sparql::QueryOptions;
+/// use oxigraph::store::Store;
+///
+/// let store = Store::new()?;
+/// store.query_opt(
+///     "SELECT * WHERE { SERVICE <https://query.wikidata.org/sparql> {} }",
+///     QueryOptions::default().without_service_handler(),
+/// )?;
+/// # Result::<_,Box<dyn std::error::Error>>::Ok(())
+/// ```
+#[derive(Clone, Default)]
+pub struct QueryOptions {
+    service_handler: Option<Arc<dyn ServiceHandler<Error = EvaluationError>>>,
+    custom_functions: CustomFunctionRegistry,
+    http_timeout: Option<Duration>,
+    http_redirection_limit: usize,
+    without_optimizations: bool,
+}
+
+pub(crate) type CustomFunctionRegistry =
+    HashMap<NamedNode, Arc<dyn (Fn(&[Term]) -> Option<Term>) + Send + Sync>>;
+
+impl QueryOptions {
+    /// Use a given [`ServiceHandler`] to execute [SPARQL 1.1 Federated Query](https://www.w3.org/TR/sparql11-federated-query/) SERVICE calls.
+    #[inline]
+    #[must_use]
+    pub fn with_service_handler(mut self, service_handler: impl ServiceHandler + 'static) -> Self {
+        self.service_handler = Some(Arc::new(ErrorConversionServiceHandler::wrap(
+            service_handler,
+        )));
+        self
+    }
+
+    /// Disables the `SERVICE` calls
+    #[inline]
+    #[must_use]
+    pub fn without_service_handler(mut self) -> Self {
+        self.service_handler = Some(Arc::new(EmptyServiceHandler));
+        self
+    }
+
+    /// Sets a timeout for HTTP requests done during SPARQL evaluation.
+    #[cfg(feature = "http-client")]
+    #[inline]
+    #[must_use]
+    pub fn with_http_timeout(mut self, timeout: Duration) -> Self {
+        self.http_timeout = Some(timeout);
+        self
+    }
+
+    /// Sets an upper bound of the number of HTTP redirection followed per HTTP request done during SPARQL evaluation.
+    ///
+    /// By default this value is `0`.
+    #[cfg(feature = "http-client")]
+    #[inline]
+    #[must_use]
+    pub fn with_http_redirection_limit(mut self, redirection_limit: usize) -> Self {
+        self.http_redirection_limit = redirection_limit;
+        self
+    }
+
+    /// Adds a custom SPARQL evaluation function.
+    ///
+    /// Example with a function serializing terms to N-Triples:
+    /// ```
+    /// use oxigraph::model::*;
+    /// use oxigraph::sparql::{QueryOptions, QueryResults};
+    /// use oxigraph::store::Store;
+    ///
+    /// let store = Store::new()?;
+    ///
+    /// if let QueryResults::Solutions(mut solutions) = store.query_opt(
+    ///     "SELECT (<http://www.w3.org/ns/formats/N-Triples>(1) AS ?nt) WHERE {}",
+    ///     QueryOptions::default().with_custom_function(
+    ///         NamedNode::new("http://www.w3.org/ns/formats/N-Triples")?,
+    ///         |args| args.get(0).map(|t| Literal::from(t.to_string()).into()),
+    ///     ),
+    /// )? {
+    ///     assert_eq!(
+    ///         solutions.next().unwrap()?.get("nt"),
+    ///         Some(&Literal::from("\"1\"^^<http://www.w3.org/2001/XMLSchema#integer>").into())
+    ///     );
+    /// }
+    /// # Result::<_,Box<dyn std::error::Error>>::Ok(())
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn with_custom_function(
+        mut self,
+        name: NamedNode,
+        evaluator: impl Fn(&[Term]) -> Option<Term> + Send + Sync + 'static,
+    ) -> Self {
+        self.custom_functions.insert(name, Arc::new(evaluator));
+        self
+    }
+
+    fn service_handler(&self) -> Arc<dyn ServiceHandler<Error = EvaluationError>> {
+        self.service_handler.clone().unwrap_or_else(|| {
+            if cfg!(feature = "http-client") {
+                Arc::new(service::SimpleServiceHandler::new(
+                    self.http_timeout,
+                    self.http_redirection_limit,
+                ))
+            } else {
+                Arc::new(EmptyServiceHandler)
+            }
+        })
+    }
+
+    #[doc(hidden)]
+    #[inline]
+    #[must_use]
+    pub fn without_optimizations(mut self) -> Self {
+        self.without_optimizations = true;
+        self
+    }
+}
+
+/// Options for SPARQL update evaluation.
+#[derive(Clone, Default)]
+pub struct UpdateOptions {
+    query_options: QueryOptions,
+}
+
+impl From<QueryOptions> for UpdateOptions {
+    #[inline]
+    fn from(query_options: QueryOptions) -> Self {
+        Self { query_options }
+    }
+}
+
+/// The explanation of a query.
+#[derive(Clone)]
+pub struct QueryExplanation {
+    inner: Rc<EvalNodeWithStats>,
+    with_stats: bool,
+    parsing_duration: Option<DayTimeDuration>,
+    planning_duration: Option<DayTimeDuration>,
+}
+
+impl QueryExplanation {
+    /// Writes the explanation as JSON.
+    pub fn write_in_json(&self, write: impl io::Write) -> io::Result<()> {
+        let mut writer = ToWriteJsonWriter::new(write);
+        writer.write_event(JsonEvent::StartObject)?;
+        if let Some(parsing_duration) = self.parsing_duration {
+            writer.write_event(JsonEvent::ObjectKey("parsing duration in seconds".into()))?;
+            writer.write_event(JsonEvent::Number(
+                parsing_duration.as_seconds().to_string().into(),
+            ))?;
+        }
+        if let Some(planning_duration) = self.planning_duration {
+            writer.write_event(JsonEvent::ObjectKey("planning duration in seconds".into()))?;
+            writer.write_event(JsonEvent::Number(
+                planning_duration.as_seconds().to_string().into(),
+            ))?;
+        }
+        writer.write_event(JsonEvent::ObjectKey("plan".into()))?;
+        self.inner.json_node(&mut writer, self.with_stats)?;
+        writer.write_event(JsonEvent::EndObject)
+    }
+}
+
+impl fmt::Debug for QueryExplanation {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut obj = f.debug_struct("QueryExplanation");
+        if let Some(parsing_duration) = self.parsing_duration {
+            obj.field(
+                "parsing duration in seconds",
+                &f32::from(Float::from(parsing_duration.as_seconds())),
+            );
+        }
+        if let Some(planning_duration) = self.planning_duration {
+            obj.field(
+                "planning duration in seconds",
+                &f32::from(Float::from(planning_duration.as_seconds())),
+            );
+        }
+        obj.field("tree", &self.inner);
+        obj.finish_non_exhaustive()
+    }
+}

lib/oxigraph/src/sparql/model.rs

@@ -0,0 +1,371 @@
+use crate::io::{RdfFormat, RdfSerializer};
+use crate::model::*;
+use crate::sparql::error::EvaluationError;
+use crate::sparql::results::{
+    FromReadQueryResultsReader, FromReadSolutionsReader, QueryResultsFormat,
+    QueryResultsParseError, QueryResultsParser, QueryResultsSerializer,
+};
+pub use sparesults::QuerySolution;
+use std::io::{Read, Write};
+use std::sync::Arc;
+
+/// Results of a [SPARQL query](https://www.w3.org/TR/sparql11-query/).
+pub enum QueryResults {
+    /// Results of a [SELECT](https://www.w3.org/TR/sparql11-query/#select) query.
+    Solutions(QuerySolutionIter),
+    /// Result of a [ASK](https://www.w3.org/TR/sparql11-query/#ask) query.
+    Boolean(bool),
+    /// Results of a [CONSTRUCT](https://www.w3.org/TR/sparql11-query/#construct) or [DESCRIBE](https://www.w3.org/TR/sparql11-query/#describe) query.
+    Graph(QueryTripleIter),
+}
+
+impl QueryResults {
+    /// Reads a SPARQL query results serialization.
+    pub fn read(
+        read: impl Read + 'static,
+        format: QueryResultsFormat,
+    ) -> Result<Self, QueryResultsParseError> {
+        Ok(QueryResultsParser::from_format(format)
+            .parse_read(read)?
+            .into())
+    }
+
+    /// Writes the query results (solutions or boolean).
+    ///
+    /// This method fails if it is called on the `Graph` results.
+    ///
+    /// ```
+    /// use oxigraph::store::Store;
+    /// use oxigraph::model::*;
+    /// use oxigraph::sparql::results::QueryResultsFormat;
+    ///
+    /// let store = Store::new()?;
+    /// let ex = NamedNodeRef::new("http://example.com")?;
+    /// store.insert(QuadRef::new(ex, ex, ex, GraphNameRef::DefaultGraph))?;
+    ///
+    /// let results = store.query("SELECT ?s WHERE { ?s ?p ?o }")?;
+    /// assert_eq!(
+    ///     results.write(Vec::new(), QueryResultsFormat::Json)?,
+    ///     r#"{"head":{"vars":["s"]},"results":{"bindings":[{"s":{"type":"uri","value":"http://example.com"}}]}}"#.as_bytes()
+    /// );
+    /// # Result::<_,Box<dyn std::error::Error>>::Ok(())
+    /// ```
+    pub fn write<W: Write>(
+        self,
+        write: W,
+        format: QueryResultsFormat,
+    ) -> Result<W, EvaluationError> {
+        let serializer = QueryResultsSerializer::from_format(format);
+        match self {
+            Self::Boolean(value) => serializer.serialize_boolean_to_write(write, value),
+            Self::Solutions(solutions) => {
+                let mut writer = serializer
+                    .serialize_solutions_to_write(write, solutions.variables().to_vec())
+                    .map_err(EvaluationError::ResultsSerialization)?;
+                for solution in solutions {
+                    writer
+                        .write(&solution?)
+                        .map_err(EvaluationError::ResultsSerialization)?;
+                }
+                writer.finish()
+            }
+            Self::Graph(triples) => {
+                let s = VariableRef::new_unchecked("subject");
+                let p = VariableRef::new_unchecked("predicate");
+                let o = VariableRef::new_unchecked("object");
+                let mut writer = serializer
+                    .serialize_solutions_to_write(
+                        write,
+                        vec![s.into_owned(), p.into_owned(), o.into_owned()],
+                    )
+                    .map_err(EvaluationError::ResultsSerialization)?;
+                for triple in triples {
+                    let triple = triple?;
+                    writer
+                        .write([
+                            (s, &triple.subject.into()),
+                            (p, &triple.predicate.into()),
+                            (o, &triple.object),
+                        ])
+                        .map_err(EvaluationError::ResultsSerialization)?;
+                }
+                writer.finish()
+            }
+        }
+        .map_err(EvaluationError::ResultsSerialization)
+    }
+
+    /// Writes the graph query results.
+    ///
+    /// This method fails if it is called on the `Solution` or `Boolean` results.
+    ///
+    /// ```
+    /// use oxigraph::io::RdfFormat;
+    /// use oxigraph::model::*;
+    /// use oxigraph::store::Store;
+    ///
+    /// let graph = "<http://example.com> <http://example.com> <http://example.com> .\n";
+    ///
+    /// let store = Store::new()?;
+    /// store.load_graph(
+    ///     graph.as_bytes(),
+    ///     RdfFormat::NTriples,
+    ///     GraphName::DefaultGraph,
+    ///     None,
+    /// )?;
+    ///
+    /// let results = store.query("CONSTRUCT WHERE { ?s ?p ?o }")?;
+    /// assert_eq!(
+    ///     results.write_graph(Vec::new(), RdfFormat::NTriples)?,
+    ///     graph.as_bytes()
+    /// );
+    /// # Result::<_,Box<dyn std::error::Error>>::Ok(())
+    /// ```
+    pub fn write_graph<W: Write>(
+        self,
+        write: W,
+        format: impl Into<RdfFormat>,
+    ) -> Result<W, EvaluationError> {
+        if let Self::Graph(triples) = self {
+            let mut writer = RdfSerializer::from_format(format.into()).serialize_to_write(write);
+            for triple in triples {
+                writer
+                    .write_triple(&triple?)
+                    .map_err(EvaluationError::ResultsSerialization)?;
+            }
+            writer
+                .finish()
+                .map_err(EvaluationError::ResultsSerialization)
+        } else {
+            Err(EvaluationError::NotAGraph)
+        }
+    }
+}
+
+impl From<QuerySolutionIter> for QueryResults {
+    #[inline]
+    fn from(value: QuerySolutionIter) -> Self {
+        Self::Solutions(value)
+    }
+}
+
+impl<R: Read + 'static> From<FromReadQueryResultsReader<R>> for QueryResults {
+    fn from(reader: FromReadQueryResultsReader<R>) -> Self {
+        match reader {
+            FromReadQueryResultsReader::Solutions(s) => Self::Solutions(s.into()),
+            FromReadQueryResultsReader::Boolean(v) => Self::Boolean(v),
+        }
+    }
+}
+
+/// An iterator over [`QuerySolution`]s.
+///
+/// ```
+/// use oxigraph::sparql::QueryResults;
+/// use oxigraph::store::Store;
+///
+/// let store = Store::new()?;
+/// if let QueryResults::Solutions(solutions) = store.query("SELECT ?s WHERE { ?s ?p ?o }")? {
+///     for solution in solutions {
+///         println!("{:?}", solution?.get("s"));
+///     }
+/// }
+/// # Result::<_,Box<dyn std::error::Error>>::Ok(())
+/// ```
+pub struct QuerySolutionIter {
+    variables: Arc<[Variable]>,
+    iter: Box<dyn Iterator<Item = Result<QuerySolution, EvaluationError>>>,
+}
+
+impl QuerySolutionIter {
+    /// Construct a new iterator of solution from an ordered list of solution variables and an iterator of solution tuples
+    /// (each tuple using the same ordering as the variable list such that tuple element 0 is the value for the variable 0...)
+    pub fn new(
+        variables: Arc<[Variable]>,
+        iter: impl Iterator<Item = Result<Vec<Option<Term>>, EvaluationError>> + 'static,
+    ) -> Self {
+        Self {
+            variables: Arc::clone(&variables),
+            iter: Box::new(
+                iter.map(move |t| t.map(|values| (Arc::clone(&variables), values).into())),
+            ),
+        }
+    }
+
+    /// The variables used in the solutions.
+    ///
+    /// ```
+    /// use oxigraph::sparql::{QueryResults, Variable};
+    /// use oxigraph::store::Store;
+    ///
+    /// let store = Store::new()?;
+    /// if let QueryResults::Solutions(solutions) = store.query("SELECT ?s ?o WHERE { ?s ?p ?o }")? {
+    ///     assert_eq!(
+    ///         solutions.variables(),
+    ///         &[Variable::new("s")?, Variable::new("o")?]
+    ///     );
+    /// }
+    /// # Result::<_,Box<dyn std::error::Error>>::Ok(())
+    /// ```
+    #[inline]
+    pub fn variables(&self) -> &[Variable] {
+        &self.variables
+    }
+}
+
+impl<R: Read + 'static> From<FromReadSolutionsReader<R>> for QuerySolutionIter {
+    fn from(reader: FromReadSolutionsReader<R>) -> Self {
+        Self {
+            variables: reader.variables().into(),
+            iter: Box::new(reader.map(|t| t.map_err(EvaluationError::from))),
+        }
+    }
+}
+
+impl Iterator for QuerySolutionIter {
+    type Item = Result<QuerySolution, EvaluationError>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+}
+
+/// An iterator over the triples that compose a graph solution.
+///
+/// ```
+/// use oxigraph::sparql::QueryResults;
+/// use oxigraph::store::Store;
+///
+/// let store = Store::new()?;
+/// if let QueryResults::Graph(triples) = store.query("CONSTRUCT WHERE { ?s ?p ?o }")? {
+///     for triple in triples {
+///         println!("{}", triple?);
+///     }
+/// }
+/// # Result::<_,Box<dyn std::error::Error>>::Ok(())
+/// ```
+pub struct QueryTripleIter {
+    pub(crate) iter: Box<dyn Iterator<Item = Result<Triple, EvaluationError>>>,
+}
+
+impl Iterator for QueryTripleIter {
+    type Item = Result<Triple, EvaluationError>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+
+    #[inline]
+    fn fold<Acc, G>(self, init: Acc, g: G) -> Acc
+    where
+        G: FnMut(Acc, Self::Item) -> Acc,
+    {
+        self.iter.fold(init, g)
+    }
+}
+
+#[cfg(test)]
+#[allow(clippy::panic_in_result_fn)]
+mod tests {
+    use super::*;
+    use std::io::Cursor;
+
+    #[test]
+    fn test_serialization_roundtrip() -> Result<(), EvaluationError> {
+        use std::str;
+
+        for format in [
+            QueryResultsFormat::Json,
+            QueryResultsFormat::Xml,
+            QueryResultsFormat::Tsv,
+        ] {
+            let results = vec![
+                QueryResults::Boolean(true),
+                QueryResults::Boolean(false),
+                QueryResults::Solutions(QuerySolutionIter::new(
+                    [
+                        Variable::new_unchecked("foo"),
+                        Variable::new_unchecked("bar"),
+                    ]
+                    .as_ref()
+                    .into(),
+                    Box::new(
+                        vec![
+                            Ok(vec![None, None]),
+                            Ok(vec![
+                                Some(NamedNode::new_unchecked("http://example.com").into()),
+                                None,
+                            ]),
+                            Ok(vec![
+                                None,
+                                Some(NamedNode::new_unchecked("http://example.com").into()),
+                            ]),
+                            Ok(vec![
+                                Some(BlankNode::new_unchecked("foo").into()),
+                                Some(BlankNode::new_unchecked("bar").into()),
+                            ]),
+                            Ok(vec![Some(Literal::new_simple_literal("foo").into()), None]),
+                            Ok(vec![
+                                Some(
+                                    Literal::new_language_tagged_literal_unchecked("foo", "fr")
+                                        .into(),
+                                ),
+                                None,
+                            ]),
+                            Ok(vec![
+                                Some(Literal::from(1).into()),
+                                Some(Literal::from(true).into()),
+                            ]),
+                            Ok(vec![
+                                Some(Literal::from(1.33).into()),
+                                Some(Literal::from(false).into()),
+                            ]),
+                            Ok(vec![
+                                Some(
+                                    Triple::new(
+                                        NamedNode::new_unchecked("http://example.com/s"),
+                                        NamedNode::new_unchecked("http://example.com/p"),
+                                        Triple::new(
+                                            NamedNode::new_unchecked("http://example.com/os"),
+                                            NamedNode::new_unchecked("http://example.com/op"),
+                                            NamedNode::new_unchecked("http://example.com/oo"),
+                                        ),
+                                    )
+                                    .into(),
+                                ),
+                                None,
+                            ]),
+                        ]
+                        .into_iter(),
+                    ),
+                )),
+            ];
+
+            for ex in results {
+                let mut buffer = Vec::new();
+                ex.write(&mut buffer, format)?;
+                let ex2 = QueryResults::read(Cursor::new(buffer.clone()), format)?;
+                let mut buffer2 = Vec::new();
+                ex2.write(&mut buffer2, format)?;
+                assert_eq!(
+                    str::from_utf8(&buffer).unwrap(),
+                    str::from_utf8(&buffer2).unwrap()
+                );
+            }
+        }
+
+        Ok(())
+    }
+}

lib/oxigraph/src/sparql/results.rs

@@ -0,0 +1,44 @@
+//! Utilities to read and write RDF results formats  using [sparesults](https://crates.io/crates/sparesults).
+//!
+//! It supports [SPARQL Query Results XML Format (Second Edition)](https://www.w3.org/TR/rdf-sparql-XMLres/), [SPARQL 1.1 Query Results JSON Format](https://www.w3.org/TR/sparql11-results-json/) and [SPARQL 1.1 Query Results CSV and TSV Formats](https://www.w3.org/TR/sparql11-results-csv-tsv/).
+//!
+//! Usage example converting a JSON result file into a TSV result file:
+//!
+//! ```
+//! use oxigraph::sparql::results::{QueryResultsFormat, QueryResultsParser, FromReadQueryResultsReader, QueryResultsSerializer};
+//! use std::io::Result;
+//!
+//! fn convert_json_to_tsv(json_file: &[u8]) -> Result<Vec<u8>> {
+//!     let json_parser = QueryResultsParser::from_format(QueryResultsFormat::Json);
+//!     let tsv_serializer = QueryResultsSerializer::from_format(QueryResultsFormat::Tsv);
+//!     // We start to read the JSON file and see which kind of results it is
+//!     match json_parser.parse_read(json_file)? {
+//!         FromReadQueryResultsReader::Boolean(value) => {
+//!             // it's a boolean result, we copy it in TSV to the output buffer
+//!             tsv_serializer.serialize_boolean_to_write(Vec::new(), value)
+//!         }
+//!         FromReadQueryResultsReader::Solutions(solutions_reader) => {
+//!             // it's a set of solutions, we create a writer and we write to it while reading in streaming from the JSON file
+//!             let mut serialize_solutions_to_write = tsv_serializer.serialize_solutions_to_write(Vec::new(), solutions_reader.variables().to_vec())?;
+//!             for solution in solutions_reader {
+//!                 serialize_solutions_to_write.write(&solution?)?;
+//!             }
+//!             serialize_solutions_to_write.finish()
+//!         }
+//!     }
+//! }
+//!
+//! // Let's test with a boolean
+//! assert_eq!(
+//!     convert_json_to_tsv(br#"{"boolean":true}"#.as_slice()).unwrap(),
+//!     b"true"
+//! );
+//!
+//! // And with a set of solutions
+//! assert_eq!(
+//!     convert_json_to_tsv(br#"{"head":{"vars":["foo","bar"]},"results":{"bindings":[{"foo":{"type":"literal","value":"test"}}]}}"#.as_slice()).unwrap(),
+//!     b"?foo\t?bar\n\"test\"\t\n"
+//! );
+//! ```
+
+pub use sparesults::*;

lib/oxigraph/src/sparql/service.rs

@@ -3,9 +3,8 @@ use crate::sparql::algebra::Query;
 use crate::sparql::error::EvaluationError;
 use crate::sparql::http::Client;
 use crate::sparql::model::QueryResults;
-use crate::sparql::QueryResultsFormat;
+use crate::sparql::results::QueryResultsFormat;
 use std::error::Error;
-use std::io::BufReader;
 use std::time::Duration;
 
 /// Handler for [SPARQL 1.1 Federated Query](https://www.w3.org/TR/sparql11-federated-query/) SERVICE.
@@ -14,18 +13,22 @@ use std::time::Duration;
 /// before evaluating a SPARQL query that uses SERVICE calls.
 ///
 /// ```
-/// use oxigraph::store::Store;
 /// use oxigraph::model::*;
-/// use oxigraph::sparql::{QueryOptions, QueryResults, ServiceHandler, Query, EvaluationError};
+/// use oxigraph::sparql::{EvaluationError, Query, QueryOptions, QueryResults, ServiceHandler};
+/// use oxigraph::store::Store;
 ///
 /// struct TestServiceHandler {
-///     store: Store
+///     store: Store,
 /// }
 ///
 /// impl ServiceHandler for TestServiceHandler {
 ///     type Error = EvaluationError;
 ///
-///     fn handle(&self,service_name: NamedNode, query: Query) -> Result<QueryResults,EvaluationError> {
+///     fn handle(
+///         &self,
+///         service_name: NamedNode,
+///         query: Query,
+///     ) -> Result<QueryResults, Self::Error> {
 ///         if service_name == "http://example.com/service" {
 ///             self.store.query(query)
 ///         } else {
@@ -36,23 +39,26 @@ use std::time::Duration;
 ///
 /// let store = Store::new()?;
 /// let service = TestServiceHandler {
-///     store: Store::new()?
+///     store: Store::new()?,
 /// };
 /// let ex = NamedNodeRef::new("http://example.com")?;
-/// service.store.insert(QuadRef::new(ex, ex, ex, GraphNameRef::DefaultGraph))?;
+/// service
+///     .store
+///     .insert(QuadRef::new(ex, ex, ex, GraphNameRef::DefaultGraph))?;
 ///
 /// if let QueryResults::Solutions(mut solutions) = store.query_opt(
 ///     "SELECT ?s WHERE { SERVICE <http://example.com/service> { ?s ?p ?o } }",
-///     QueryOptions::default().with_service_handler(service)
+///     QueryOptions::default().with_service_handler(service),
 /// )? {
 ///     assert_eq!(solutions.next().unwrap()?.get("s"), Some(&ex.into()));
 /// }
 /// # Result::<_,Box<dyn std::error::Error>>::Ok(())
 /// ```
-pub trait ServiceHandler {
+pub trait ServiceHandler: Send + Sync {
+    /// The service evaluation error.
     type Error: Error + Send + Sync + 'static;
 
-    /// Evaluates a [`Query`] against a given service identified by a [`NamedNode`](crate::model::NamedNode).
+    /// Evaluates a [`Query`] against a given service identified by a [`NamedNode`].
     fn handle(&self, service_name: NamedNode, query: Query) -> Result<QueryResults, Self::Error>;
 }
 
@@ -61,10 +67,8 @@ pub struct EmptyServiceHandler;
 impl ServiceHandler for EmptyServiceHandler {
     type Error = EvaluationError;
 
-    fn handle(&self, _: NamedNode, _: Query) -> Result<QueryResults, EvaluationError> {
-        Err(EvaluationError::msg(
-            "The SERVICE feature is not implemented",
-        ))
+    fn handle(&self, name: NamedNode, _: Query) -> Result<QueryResults, Self::Error> {
+        Err(EvaluationError::UnsupportedService(name))
     }
 }
 
@@ -81,14 +85,10 @@ impl<S: ServiceHandler> ErrorConversionServiceHandler<S> {
 impl<S: ServiceHandler> ServiceHandler for ErrorConversionServiceHandler<S> {
     type Error = EvaluationError;
 
-    fn handle(
-        &self,
-        service_name: NamedNode,
-        query: Query,
-    ) -> Result<QueryResults, EvaluationError> {
+    fn handle(&self, service_name: NamedNode, query: Query) -> Result<QueryResults, Self::Error> {
         self.handler
             .handle(service_name, query)
-            .map_err(EvaluationError::wrap)
+            .map_err(|e| EvaluationError::Service(Box::new(e)))
     }
 }
 
@@ -97,9 +97,9 @@ pub struct SimpleServiceHandler {
 }
 
 impl SimpleServiceHandler {
-    pub fn new(http_timeout: Option<Duration>) -> Self {
+    pub fn new(http_timeout: Option<Duration>, http_redirection_limit: usize) -> Self {
         Self {
-            client: Client::new(http_timeout),
+            client: Client::new(http_timeout, http_redirection_limit),
         }
     }
 }
@@ -107,23 +107,18 @@ impl SimpleServiceHandler {
 impl ServiceHandler for SimpleServiceHandler {
     type Error = EvaluationError;
 
-    fn handle(
-        &self,
-        service_name: NamedNode,
-        query: Query,
-    ) -> Result<QueryResults, EvaluationError> {
-        let (content_type, body) = self.client.post(
-            service_name.as_str(),
-            query.to_string().into_bytes(),
-            "application/sparql-query",
-            "application/sparql-results+json, application/sparql-results+xml",
-        )?;
-        let format = QueryResultsFormat::from_media_type(&content_type).ok_or_else(|| {
-            EvaluationError::msg(format!(
-                "Unsupported Content-Type returned by {}: {}",
-                service_name, content_type
-            ))
-        })?;
-        Ok(QueryResults::read(BufReader::new(body), format)?)
+    fn handle(&self, service_name: NamedNode, query: Query) -> Result<QueryResults, Self::Error> {
+        let (content_type, body) = self
+            .client
+            .post(
+                service_name.as_str(),
+                query.to_string().into_bytes(),
+                "application/sparql-query",
+                "application/sparql-results+json, application/sparql-results+xml",
+            )
+            .map_err(|e| EvaluationError::Service(Box::new(e)))?;
+        let format = QueryResultsFormat::from_media_type(&content_type)
+            .ok_or_else(|| EvaluationError::UnsupportedContentType(content_type))?;
+        Ok(QueryResults::read(body, format)?)
     }
 }

lib/oxigraph/src/sparql/update.rs

@@ -1,14 +1,11 @@
-use crate::io::read::ParseError;
-use crate::io::{GraphFormat, GraphParser};
+use crate::io::{RdfFormat, RdfParser};
 use crate::model::{GraphName as OxGraphName, GraphNameRef, Quad as OxQuad};
 use crate::sparql::algebra::QueryDataset;
 use crate::sparql::dataset::DatasetView;
-use crate::sparql::eval::SimpleEvaluator;
+use crate::sparql::eval::{EncodedTuple, SimpleEvaluator};
 use crate::sparql::http::Client;
-use crate::sparql::plan::EncodedTuple;
-use crate::sparql::plan_builder::PlanBuilder;
 use crate::sparql::{EvaluationError, Update, UpdateOptions};
-use crate::storage::numeric_encoder::EncodedTerm;
+use crate::storage::numeric_encoder::{Decoder, EncodedTerm};
 use crate::storage::StorageWriter;
 use oxiri::Iri;
 use spargebra::algebra::{GraphPattern, GraphTarget};
@@ -18,9 +15,11 @@ use spargebra::term::{
     Quad, QuadPattern, Subject, Term, TermPattern, Triple, TriplePattern, Variable,
 };
 use spargebra::GraphUpdateOperation;
+use sparopt::Optimizer;
 use std::collections::HashMap;
-use std::io::BufReader;
+use std::io;
 use std::rc::Rc;
+use std::sync::Arc;
 
 pub fn evaluate_update<'a, 'b: 'a>(
     transaction: &'a mut StorageWriter<'b>,
@@ -31,7 +30,10 @@ pub fn evaluate_update<'a, 'b: 'a>(
         transaction,
         base_iri: update.inner.base_iri.clone().map(Rc::new),
         options: options.clone(),
-        client: Client::new(options.query_options.http_timeout),
+        client: Client::new(
+            options.query_options.http_timeout,
+            options.query_options.http_redirection_limit,
+        ),
     }
     .eval_all(&update.inner.operations, &update.using_datasets)
 }
@@ -68,7 +70,12 @@ impl<'a, 'b: 'a> SimpleUpdateEvaluator<'a, 'b> {
                 insert,
                 pattern,
                 ..
-            } => self.eval_delete_insert(delete, insert, using_dataset.as_ref().unwrap(), pattern),
+            } => self.eval_delete_insert(
+                delete,
+                insert,
+                using_dataset.as_ref().unwrap_or(&QueryDataset::new()),
+                pattern,
+            ),
             GraphUpdateOperation::Load {
                 silent,
                 source,
@@ -115,21 +122,25 @@ impl<'a, 'b: 'a> SimpleUpdateEvaluator<'a, 'b> {
         algebra: &GraphPattern,
     ) -> Result<(), EvaluationError> {
         let dataset = Rc::new(DatasetView::new(self.transaction.reader(), using));
-        let (plan, variables) = PlanBuilder::build(
-            dataset.as_ref(),
-            algebra,
-            false,
-            &self.options.query_options.custom_functions,
-        )?;
+        let mut pattern = sparopt::algebra::GraphPattern::from(algebra);
+        if !self.options.query_options.without_optimizations {
+            pattern = Optimizer::optimize_graph_pattern(sparopt::algebra::GraphPattern::Reduced {
+                inner: Box::new(pattern),
+            });
+        }
         let evaluator = SimpleEvaluator::new(
-            dataset.clone(),
+            Rc::clone(&dataset),
             self.base_iri.clone(),
             self.options.query_options.service_handler(),
-            Rc::new(self.options.query_options.custom_functions.clone()),
+            Arc::new(self.options.query_options.custom_functions.clone()),
+            false,
         );
+        let mut variables = Vec::new();
         let mut bnodes = HashMap::new();
-        for tuple in evaluator.plan_evaluator(&plan)(EncodedTuple::with_capacity(variables.len())) {
-            let tuple = tuple?;
+        let (eval, _) = evaluator.graph_pattern_evaluator(&pattern, &mut variables);
+        let tuples =
+            eval(EncodedTuple::with_capacity(variables.len())).collect::<Result<Vec<_>, _>>()?; // TODO: would be much better to stream
+        for tuple in tuples {
             for quad in delete {
                 if let Some(quad) =
                     Self::convert_ground_quad_pattern(quad, &variables, &tuple, &dataset)?
@@ -150,29 +161,31 @@ impl<'a, 'b: 'a> SimpleUpdateEvaluator<'a, 'b> {
     }
 
     fn eval_load(&mut self, from: &NamedNode, to: &GraphName) -> Result<(), EvaluationError> {
-        let (content_type, body) = self.client.get(
-            from.as_str(),
-            "application/n-triples, text/turtle, application/rdf+xml",
-        )?;
-        let format = GraphFormat::from_media_type(&content_type).ok_or_else(|| {
-            EvaluationError::msg(format!(
-                "Unsupported Content-Type returned by {}: {}",
-                from, content_type
-            ))
-        })?;
+        let (content_type, body) = self
+            .client
+            .get(
+                from.as_str(),
+                "application/n-triples, text/turtle, application/rdf+xml",
+            )
+            .map_err(|e| EvaluationError::Service(Box::new(e)))?;
+        let format = RdfFormat::from_media_type(&content_type)
+            .ok_or_else(|| EvaluationError::UnsupportedContentType(content_type))?;
         let to_graph_name = match to {
             GraphName::NamedNode(graph_name) => graph_name.into(),
             GraphName::DefaultGraph => GraphNameRef::DefaultGraph,
         };
-        let mut parser = GraphParser::from_format(format);
-        if let Some(base_iri) = &self.base_iri {
-            parser = parser
-                .with_base_iri(base_iri.as_str())
-                .map_err(|e| ParseError::invalid_base_iri(base_iri, e))?;
-        }
-        for t in parser.read_triples(BufReader::new(body))? {
-            self.transaction
-                .insert(t?.as_ref().in_graph(to_graph_name))?;
+        let mut parser = RdfParser::from_format(format)
+            .rename_blank_nodes()
+            .without_named_graphs()
+            .with_default_graph(to_graph_name);
+        parser = parser.with_base_iri(from.as_str()).map_err(|e| {
+            EvaluationError::Service(Box::new(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                format!("Invalid URL: {from}: {e}"),
+            )))
+        })?;
+        for q in parser.parse_read(body) {
+            self.transaction.insert(q?.as_ref())?;
         }
         Ok(())
     }
@@ -181,30 +194,23 @@ impl<'a, 'b: 'a> SimpleUpdateEvaluator<'a, 'b> {
         if self.transaction.insert_named_graph(graph_name.into())? || silent {
             Ok(())
         } else {
-            Err(EvaluationError::msg(format!(
-                "The graph {} already exists",
-                graph_name
-            )))
+            Err(EvaluationError::GraphAlreadyExists(graph_name.clone()))
         }
     }
 
     fn eval_clear(&mut self, graph: &GraphTarget, silent: bool) -> Result<(), EvaluationError> {
         match graph {
             GraphTarget::NamedNode(graph_name) => {
-                if self.transaction.reader().contains_named_graph(
-                    &self
-                        .transaction
-                        .term_encoder()
-                        .encode_graph_name(graph_name),
-                )? {
+                if self
+                    .transaction
+                    .reader()
+                    .contains_named_graph(&graph_name.as_ref().into())?
+                {
                     Ok(self.transaction.clear_graph(graph_name.into())?)
                 } else if silent {
                     Ok(())
                 } else {
-                    Err(EvaluationError::msg(format!(
-                        "The graph {} does not exists",
-                        graph
-                    )))
+                    Err(EvaluationError::GraphDoesNotExist(graph_name.clone()))
                 }
             }
             GraphTarget::DefaultGraph => {
@@ -222,10 +228,7 @@ impl<'a, 'b: 'a> SimpleUpdateEvaluator<'a, 'b> {
                 if self.transaction.remove_named_graph(graph_name.into())? || silent {
                     Ok(())
                 } else {
-                    Err(EvaluationError::msg(format!(
-                        "The graph {} does not exists",
-                        graph_name
-                    )))
+                    Err(EvaluationError::GraphDoesNotExist(graph_name.clone()))
                 }
             }
             GraphTarget::DefaultGraph => {
@@ -372,10 +375,10 @@ impl<'a, 'b: 'a> SimpleUpdateEvaluator<'a, 'b> {
             TermPattern::Literal(term) => Some(term.clone().into()),
             TermPattern::Triple(triple) => {
                 Self::convert_triple_pattern(triple, variables, values, dataset, bnodes)?
-                    .map(|t| t.into())
+                    .map(Into::into)
             }
             TermPattern::Variable(v) => Self::lookup_variable(v, variables, values)
-                .map(|node| dataset.term_decoder().decode_term(&node))
+                .map(|node| dataset.decode_term(&node))
                 .transpose()?,
         })
     }
@@ -389,7 +392,7 @@ impl<'a, 'b: 'a> SimpleUpdateEvaluator<'a, 'b> {
         Ok(match term {
             NamedNodePattern::NamedNode(term) => Some(term.clone()),
             NamedNodePattern::Variable(v) => Self::lookup_variable(v, variables, values)
-                .map(|node| dataset.term_decoder().decode_named_node(&node))
+                .map(|node| dataset.decode_named_node(&node))
                 .transpose()?,
         })
     }
@@ -408,7 +411,7 @@ impl<'a, 'b: 'a> SimpleUpdateEvaluator<'a, 'b> {
                     Ok(if node == EncodedTerm::DefaultGraph {
                         OxGraphName::DefaultGraph
                     } else {
-                        dataset.term_decoder().decode_named_node(&node)?.into()
+                        dataset.decode_named_node(&node)?.into()
                     })
                 })
                 .transpose(),
@@ -505,10 +508,10 @@ impl<'a, 'b: 'a> SimpleUpdateEvaluator<'a, 'b> {
             GroundTermPattern::Literal(term) => Some(term.clone().into()),
             GroundTermPattern::Triple(triple) => {
                 Self::convert_ground_triple_pattern(triple, variables, values, dataset)?
-                    .map(|t| t.into())
+                    .map(Into::into)
             }
             GroundTermPattern::Variable(v) => Self::lookup_variable(v, variables, values)
-                .map(|node| dataset.term_decoder().decode_term(&node))
+                .map(|node| dataset.decode_term(&node))
                 .transpose()?,
         })
     }

lib/oxigraph/src/storage/backend/fallback.rs

@@ -1,6 +1,7 @@
 //! TODO: This storage is dramatically naive.
 
 use crate::storage::StorageError;
+use crate::store::CorruptionError;
 use std::cell::RefCell;
 use std::collections::{BTreeMap, HashMap};
 use std::error::Error;
@@ -19,6 +20,7 @@ pub struct ColumnFamilyDefinition {
 pub struct Db(Arc<RwLock<HashMap<ColumnFamily, BTreeMap<Vec<u8>, Vec<u8>>>>>);
 
 impl Db {
+    #[allow(clippy::unnecessary_wraps)]
     pub fn new(column_families: Vec<ColumnFamilyDefinition>) -> Result<Self, StorageError> {
         let mut trees = HashMap::new();
         for cf in column_families {
@@ -28,20 +30,22 @@ impl Db {
         Ok(Self(Arc::new(RwLock::new(trees))))
     }
 
-    pub fn column_family(&self, name: &'static str) -> Option<ColumnFamily> {
-        let name = ColumnFamily(name);
-        if self.0.read().unwrap().contains_key(&name) {
-            Some(name)
+    #[allow(clippy::unwrap_in_result)]
+    pub fn column_family(&self, name: &'static str) -> Result<ColumnFamily, StorageError> {
+        let column_family = ColumnFamily(name);
+        if self.0.read().unwrap().contains_key(&column_family) {
+            Ok(column_family)
         } else {
-            None
+            Err(CorruptionError::from_missing_column_family_name(name).into())
         }
     }
 
     #[must_use]
     pub fn snapshot(&self) -> Reader {
-        Reader(InnerReader::Simple(self.0.clone()))
+        Reader(InnerReader::Simple(Arc::clone(&self.0)))
     }
 
+    #[allow(clippy::unwrap_in_result)]
     pub fn transaction<'a, 'b: 'a, T, E: Error + 'static + From<StorageError>>(
         &'b self,
         f: impl Fn(Transaction<'a>) -> Result<T, E>,
@@ -63,6 +67,7 @@ enum InnerReader {
 }
 
 impl Reader {
+    #[allow(clippy::unwrap_in_result)]
     pub fn get(
         &self,
         column_family: &ColumnFamily,
@@ -89,6 +94,7 @@ impl Reader {
         }
     }
 
+    #[allow(clippy::unwrap_in_result)]
     pub fn contains_key(
         &self,
         column_family: &ColumnFamily,
@@ -115,10 +121,12 @@ impl Reader {
         }
     }
 
+    #[allow(clippy::iter_not_returning_iterator)]
     pub fn iter(&self, column_family: &ColumnFamily) -> Result<Iter, StorageError> {
         self.scan_prefix(column_family, &[])
     }
 
+    #[allow(clippy::unwrap_in_result)]
     pub fn scan_prefix(
         &self,
         column_family: &ColumnFamily,
@@ -127,9 +135,7 @@ impl Reader {
         let data: Vec<_> = match &self.0 {
             InnerReader::Simple(reader) => {
                 let trees = reader.read().unwrap();
-                let tree = if let Some(tree) = trees.get(column_family) {
-                    tree
-                } else {
+                let Some(tree) = trees.get(column_family) else {
                     return Ok(Iter {
                         iter: Vec::new().into_iter(),
                         current: None,
@@ -145,28 +151,25 @@ impl Reader {
                 }
             }
             InnerReader::Transaction(reader) => {
-                if let Some(reader) = reader.upgrade() {
-                    let trees = (*reader).borrow();
-                    let tree = if let Some(tree) = trees.get(column_family) {
-                        tree
-                    } else {
-                        return Ok(Iter {
-                            iter: Vec::new().into_iter(),
-                            current: None,
-                        });
-                    };
-                    if prefix.is_empty() {
-                        tree.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
-                    } else {
-                        tree.range(prefix.to_vec()..)
-                            .take_while(|(k, _)| k.starts_with(prefix))
-                            .map(|(k, v)| (k.clone(), v.clone()))
-                            .collect()
-                    }
-                } else {
+                let Some(reader) = reader.upgrade() else {
                     return Err(StorageError::Other(
                         "The transaction is already ended".into(),
                     ));
+                };
+                let trees = (*reader).borrow();
+                let Some(tree) = trees.get(column_family) else {
+                    return Ok(Iter {
+                        iter: Vec::new().into_iter(),
+                        current: None,
+                    });
+                };
+                if prefix.is_empty() {
+                    tree.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
+                } else {
+                    tree.range(prefix.to_vec()..)
+                        .take_while(|(k, _)| k.starts_with(prefix))
+                        .map(|(k, v)| (k.clone(), v.clone()))
+                        .collect()
                 }
             }
         };
@@ -175,19 +178,20 @@ impl Reader {
         Ok(Iter { iter, current })
     }
 
+    #[allow(clippy::unwrap_in_result)]
     pub fn len(&self, column_family: &ColumnFamily) -> Result<usize, StorageError> {
         match &self.0 {
             InnerReader::Simple(reader) => Ok(reader
                 .read()
                 .unwrap()
                 .get(column_family)
-                .map_or(0, |tree| tree.len())),
+                .map_or(0, BTreeMap::len)),
             InnerReader::Transaction(reader) => {
                 if let Some(reader) = reader.upgrade() {
                     Ok((*reader)
                         .borrow()
                         .get(column_family)
-                        .map_or(0, |tree| tree.len()))
+                        .map_or(0, BTreeMap::len))
                 } else {
                     Err(StorageError::Other(
                         "The transaction is already ended".into(),
@@ -197,19 +201,20 @@ impl Reader {
         }
     }
 
+    #[allow(clippy::unwrap_in_result)]
     pub fn is_empty(&self, column_family: &ColumnFamily) -> Result<bool, StorageError> {
         match &self.0 {
             InnerReader::Simple(reader) => Ok(reader
                 .read()
                 .unwrap()
                 .get(column_family)
-                .map_or(true, |tree| tree.is_empty())),
+                .map_or(true, BTreeMap::is_empty)),
             InnerReader::Transaction(reader) => {
                 if let Some(reader) = reader.upgrade() {
                     Ok((*reader)
                         .borrow()
                         .get(column_family)
-                        .map_or(true, |tree| tree.is_empty()))
+                        .map_or(true, BTreeMap::is_empty))
                 } else {
                     Err(StorageError::Other(
                         "The transaction is already ended".into(),
@@ -225,14 +230,15 @@ pub struct Transaction<'a>(
 );
 
 impl Transaction<'_> {
-    #[allow(unsafe_code)]
+    #[allow(unsafe_code, clippy::useless_transmute)]
     pub fn reader(&self) -> Reader {
-        // This transmute is safe because we take a weak reference and the only Rc reference used is guarded by the lifetime.
+        // SAFETY: This transmute is safe because we take a weak reference and the only Rc reference used is guarded by the lifetime.
         Reader(InnerReader::Transaction(Rc::downgrade(unsafe {
             transmute(&self.0)
         })))
     }
 
+    #[allow(clippy::unnecessary_wraps)]
     pub fn contains_key_for_update(
         &self,
         column_family: &ColumnFamily,
@@ -244,6 +250,7 @@ impl Transaction<'_> {
             .map_or(false, |cf| cf.contains_key(key)))
     }
 
+    #[allow(clippy::unnecessary_wraps, clippy::unwrap_in_result)]
     pub fn insert(
         &mut self,
         column_family: &ColumnFamily,
@@ -266,6 +273,7 @@ impl Transaction<'_> {
         self.insert(column_family, key, &[])
     }
 
+    #[allow(clippy::unnecessary_wraps, clippy::unwrap_in_result)]
     pub fn remove(&mut self, column_family: &ColumnFamily, key: &[u8]) -> Result<(), StorageError> {
         self.0
             .borrow_mut()
@@ -286,6 +294,7 @@ impl Iter {
         Some(&self.current.as_ref()?.0)
     }
 
+    #[allow(dead_code)]
     pub fn value(&self) -> Option<&[u8]> {
         Some(&self.current.as_ref()?.1)
     }
@@ -294,6 +303,7 @@ impl Iter {
         self.current = self.iter.next();
     }
 
+    #[allow(clippy::unnecessary_wraps, clippy::unused_self)]
     pub fn status(&self) -> Result<(), StorageError> {
         Ok(())
     }

lib/oxigraph/src/storage/backend/mod.rs

@@ -0,0 +1,12 @@
+//! A storage backend
+//! RocksDB is available, if not in memory
+
+#[cfg(any(target_family = "wasm"))]
+pub use fallback::{ColumnFamily, ColumnFamilyDefinition, Db, Iter, Reader, Transaction};
+#[cfg(all(not(target_family = "wasm")))]
+pub use oxi_rocksdb::{ColumnFamily, ColumnFamilyDefinition, Db, Iter, Reader, Transaction};
+
+#[cfg(any(target_family = "wasm"))]
+mod fallback;
+#[cfg(all(not(target_family = "wasm")))]
+mod oxi_rocksdb;

lib/oxigraph/src/storage/binary_encoder.rs

@@ -1,13 +1,11 @@
+use crate::storage::error::{CorruptionError, StorageError};
 use crate::storage::numeric_encoder::{EncodedQuad, EncodedTerm, EncodedTriple, StrHash};
 use crate::storage::small_string::SmallString;
-use crate::storage::StorageError;
-use crate::store::CorruptionError;
-use crate::xsd::*;
-use std::io::{Cursor, Read};
+use oxsdatatypes::*;
+use std::io::Read;
 use std::mem::size_of;
-use std::rc::Rc;
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(not(target_family = "wasm")))]
 pub const LATEST_STORAGE_VERSION: u64 = 1;
 pub const WRITTEN_TERM_MAX_SIZE: usize = size_of::<u8>() + 2 * size_of::<StrHash>();
 
@@ -64,24 +62,23 @@ pub enum QuadEncoding {
 }
 
 impl QuadEncoding {
-    pub fn decode(self, buffer: &[u8]) -> Result<EncodedQuad, StorageError> {
-        let mut cursor = Cursor::new(&buffer);
+    pub fn decode(self, mut buffer: &[u8]) -> Result<EncodedQuad, StorageError> {
         match self {
-            QuadEncoding::Spog => cursor.read_spog_quad(),
-            QuadEncoding::Posg => cursor.read_posg_quad(),
-            QuadEncoding::Ospg => cursor.read_ospg_quad(),
-            QuadEncoding::Gspo => cursor.read_gspo_quad(),
-            QuadEncoding::Gpos => cursor.read_gpos_quad(),
-            QuadEncoding::Gosp => cursor.read_gosp_quad(),
-            QuadEncoding::Dspo => cursor.read_dspo_quad(),
-            QuadEncoding::Dpos => cursor.read_dpos_quad(),
-            QuadEncoding::Dosp => cursor.read_dosp_quad(),
+            Self::Spog => buffer.read_spog_quad(),
+            Self::Posg => buffer.read_posg_quad(),
+            Self::Ospg => buffer.read_ospg_quad(),
+            Self::Gspo => buffer.read_gspo_quad(),
+            Self::Gpos => buffer.read_gpos_quad(),
+            Self::Gosp => buffer.read_gosp_quad(),
+            Self::Dspo => buffer.read_dspo_quad(),
+            Self::Dpos => buffer.read_dpos_quad(),
+            Self::Dosp => buffer.read_dosp_quad(),
         }
     }
 }
 
-pub fn decode_term(buffer: &[u8]) -> Result<EncodedTerm, StorageError> {
-    Cursor::new(&buffer).read_term()
+pub fn decode_term(mut buffer: &[u8]) -> Result<EncodedTerm, StorageError> {
+    buffer.read_term()
 }
 
 pub trait TermReader {
@@ -314,100 +311,89 @@ impl<R: Read> TermReader for R {
                     value_id: StrHash::from_be_bytes(buffer),
                 })
             }
-            TYPE_BOOLEAN_LITERAL_TRUE => Ok(EncodedTerm::BooleanLiteral(true)),
-            TYPE_BOOLEAN_LITERAL_FALSE => Ok(EncodedTerm::BooleanLiteral(false)),
+            TYPE_BOOLEAN_LITERAL_TRUE => Ok(true.into()),
+            TYPE_BOOLEAN_LITERAL_FALSE => Ok(false.into()),
             TYPE_FLOAT_LITERAL => {
                 let mut buffer = [0; 4];
                 self.read_exact(&mut buffer)?;
-                Ok(EncodedTerm::FloatLiteral(Float::from_be_bytes(buffer)))
+                Ok(Float::from_be_bytes(buffer).into())
             }
             TYPE_DOUBLE_LITERAL => {
                 let mut buffer = [0; 8];
                 self.read_exact(&mut buffer)?;
-                Ok(EncodedTerm::DoubleLiteral(Double::from_be_bytes(buffer)))
+                Ok(Double::from_be_bytes(buffer).into())
             }
             TYPE_INTEGER_LITERAL => {
                 let mut buffer = [0; 8];
                 self.read_exact(&mut buffer)?;
-                Ok(EncodedTerm::IntegerLiteral(i64::from_be_bytes(buffer)))
+                Ok(Integer::from_be_bytes(buffer).into())
             }
             TYPE_DECIMAL_LITERAL => {
                 let mut buffer = [0; 16];
                 self.read_exact(&mut buffer)?;
-                Ok(EncodedTerm::DecimalLiteral(Decimal::from_be_bytes(buffer)))
+                Ok(Decimal::from_be_bytes(buffer).into())
             }
             TYPE_DATE_TIME_LITERAL => {
                 let mut buffer = [0; 18];
                 self.read_exact(&mut buffer)?;
-                Ok(EncodedTerm::DateTimeLiteral(DateTime::from_be_bytes(
-                    buffer,
-                )))
+                Ok(DateTime::from_be_bytes(buffer).into())
             }
             TYPE_TIME_LITERAL => {
                 let mut buffer = [0; 18];
                 self.read_exact(&mut buffer)?;
-                Ok(EncodedTerm::TimeLiteral(Time::from_be_bytes(buffer)))
+                Ok(Time::from_be_bytes(buffer).into())
             }
             TYPE_DATE_LITERAL => {
                 let mut buffer = [0; 18];
                 self.read_exact(&mut buffer)?;
-                Ok(EncodedTerm::DateLiteral(Date::from_be_bytes(buffer)))
+                Ok(Date::from_be_bytes(buffer).into())
             }
             TYPE_G_YEAR_MONTH_LITERAL => {
                 let mut buffer = [0; 18];
                 self.read_exact(&mut buffer)?;
-                Ok(EncodedTerm::GYearMonthLiteral(GYearMonth::from_be_bytes(
-                    buffer,
-                )))
+                Ok(GYearMonth::from_be_bytes(buffer).into())
             }
             TYPE_G_YEAR_LITERAL => {
                 let mut buffer = [0; 18];
                 self.read_exact(&mut buffer)?;
-                Ok(EncodedTerm::GYearLiteral(GYear::from_be_bytes(buffer)))
+                Ok(GYear::from_be_bytes(buffer).into())
             }
             TYPE_G_MONTH_DAY_LITERAL => {
                 let mut buffer = [0; 18];
                 self.read_exact(&mut buffer)?;
-                Ok(EncodedTerm::GMonthDayLiteral(GMonthDay::from_be_bytes(
-                    buffer,
-                )))
+                Ok(GMonthDay::from_be_bytes(buffer).into())
             }
             TYPE_G_DAY_LITERAL => {
                 let mut buffer = [0; 18];
                 self.read_exact(&mut buffer)?;
-                Ok(EncodedTerm::GDayLiteral(GDay::from_be_bytes(buffer)))
+                Ok(GDay::from_be_bytes(buffer).into())
             }
             TYPE_G_MONTH_LITERAL => {
                 let mut buffer = [0; 18];
                 self.read_exact(&mut buffer)?;
-                Ok(EncodedTerm::GMonthLiteral(GMonth::from_be_bytes(buffer)))
+                Ok(GMonth::from_be_bytes(buffer).into())
             }
             TYPE_DURATION_LITERAL => {
                 let mut buffer = [0; 24];
                 self.read_exact(&mut buffer)?;
-                Ok(EncodedTerm::DurationLiteral(Duration::from_be_bytes(
-                    buffer,
-                )))
+                Ok(Duration::from_be_bytes(buffer).into())
             }
             TYPE_YEAR_MONTH_DURATION_LITERAL => {
                 let mut buffer = [0; 8];
                 self.read_exact(&mut buffer)?;
-                Ok(EncodedTerm::YearMonthDurationLiteral(
-                    YearMonthDuration::from_be_bytes(buffer),
-                ))
+                Ok(YearMonthDuration::from_be_bytes(buffer).into())
             }
             TYPE_DAY_TIME_DURATION_LITERAL => {
                 let mut buffer = [0; 16];
                 self.read_exact(&mut buffer)?;
-                Ok(EncodedTerm::DayTimeDurationLiteral(
-                    DayTimeDuration::from_be_bytes(buffer),
-                ))
+                Ok(DayTimeDuration::from_be_bytes(buffer).into())
             }
-            TYPE_TRIPLE => Ok(EncodedTerm::Triple(Rc::new(EncodedTriple {
+            TYPE_TRIPLE => Ok(EncodedTriple {
                 subject: self.read_term()?,
                 predicate: self.read_term()?,
                 object: self.read_term()?,
-            }))),
+            }
+            .into()),
             _ => Err(CorruptionError::msg("the term buffer has an invalid type id").into()),
         }
     }
@@ -571,8 +557,11 @@ pub fn write_term(sink: &mut Vec<u8>, term: &EncodedTerm) {
             sink.extend_from_slice(&datatype_id.to_be_bytes());
             sink.extend_from_slice(&value_id.to_be_bytes());
         }
-        EncodedTerm::BooleanLiteral(true) => sink.push(TYPE_BOOLEAN_LITERAL_TRUE),
-        EncodedTerm::BooleanLiteral(false) => sink.push(TYPE_BOOLEAN_LITERAL_FALSE),
+        EncodedTerm::BooleanLiteral(value) => sink.push(if bool::from(*value) {
+            TYPE_BOOLEAN_LITERAL_TRUE
+        } else {
+            TYPE_BOOLEAN_LITERAL_FALSE
+        }),
         EncodedTerm::FloatLiteral(value) => {
             sink.push(TYPE_FLOAT_LITERAL);
             sink.extend_from_slice(&value.to_be_bytes())
@@ -643,6 +632,7 @@ pub fn write_term(sink: &mut Vec<u8>, term: &EncodedTerm) {
 }
 
 #[cfg(test)]
+#[allow(clippy::panic_in_result_fn)]
 mod tests {
     use super::*;
     use crate::model::TermRef;
@@ -659,10 +649,6 @@ mod tests {
         fn get_str(&self, key: &StrHash) -> Result<Option<String>, StorageError> {
             Ok(self.id2str.borrow().get(key).cloned())
         }
-
-        fn contains_str(&self, key: &StrHash) -> Result<bool, StorageError> {
-            Ok(self.id2str.borrow().contains_key(key))
-        }
     }
 
     impl MemoryStrStore {
@@ -742,17 +728,15 @@ mod tests {
             )
             .into(),
         ];
-        let decoder = TermDecoder::new(&store);
         for term in terms {
-            let encoder = TermEncoder::new();
-            let encoded = encoder.encode_term(&term);
-            assert_eq!(encoded, encoder.encode_term(&term));
+            let encoded = term.as_ref().into();
             store.insert_term(term.as_ref(), &encoded);
-            assert_eq!(term, decoder.decode_term(&encoded).unwrap());
+            assert_eq!(encoded, term.as_ref().into());
+            assert_eq!(term, store.decode_term(&encoded).unwrap());
 
             let mut buffer = Vec::new();
             write_term(&mut buffer, &encoded);
-            assert_eq!(encoded, Cursor::new(&buffer).read_term().unwrap());
+            assert_eq!(encoded, buffer.as_slice().read_term().unwrap());
         }
     }
 }

lib/oxigraph/src/storage/error.rs

@@ -0,0 +1,139 @@
+use crate::io::{RdfFormat, RdfParseError};
+use crate::storage::numeric_encoder::EncodedTerm;
+use oxiri::IriParseError;
+use oxrdf::TermRef;
+use std::error::Error;
+use std::io;
+
+/// An error related to storage operations (reads, writes...).
+#[derive(Debug, thiserror::Error)]
+#[non_exhaustive]
+pub enum StorageError {
+    /// Error from the OS I/O layer.
+    #[error(transparent)]
+    Io(#[from] io::Error),
+    /// Error related to data corruption.
+    #[error(transparent)]
+    Corruption(#[from] CorruptionError),
+    #[doc(hidden)]
+    #[error("{0}")]
+    Other(#[source] Box<dyn Error + Send + Sync + 'static>),
+}
+
+impl From<StorageError> for io::Error {
+    #[inline]
+    fn from(error: StorageError) -> Self {
+        match error {
+            StorageError::Io(error) => error,
+            StorageError::Corruption(error) => error.into(),
+            StorageError::Other(error) => Self::new(io::ErrorKind::Other, error),
+        }
+    }
+}
+
+/// An error return if some content in the database is corrupted.
+#[derive(Debug, thiserror::Error)]
+#[error(transparent)]
+pub struct CorruptionError(#[from] CorruptionErrorKind);
+
+/// An error return if some content in the database is corrupted.
+#[derive(Debug, thiserror::Error)]
+enum CorruptionErrorKind {
+    #[error("{0}")]
+    Msg(String),
+    #[error("{0}")]
+    Other(#[source] Box<dyn Error + Send + Sync + 'static>),
+}
+
+impl CorruptionError {
+    /// Builds an error from a printable error message.
+    #[inline]
+    pub(crate) fn new(error: impl Into<Box<dyn Error + Send + Sync + 'static>>) -> Self {
+        Self(CorruptionErrorKind::Other(error.into()))
+    }
+
+    #[inline]
+    pub(crate) fn from_encoded_term(encoded: &EncodedTerm, term: &TermRef<'_>) -> Self {
+        // TODO: eventually use a dedicated error enum value
+        Self::msg(format!("Invalid term encoding {encoded:?} for {term}"))
+    }
+
+    #[inline]
+    pub(crate) fn from_missing_column_family_name(name: &'static str) -> Self {
+        // TODO: eventually use a dedicated error enum value
+        Self::msg(format!("Column family {name} does not exist"))
+    }
+
+    /// Builds an error from a printable error message.
+    #[inline]
+    pub(crate) fn msg(msg: impl Into<String>) -> Self {
+        Self(CorruptionErrorKind::Msg(msg.into()))
+    }
+}
+
+impl From<CorruptionError> for io::Error {
+    #[inline]
+    fn from(error: CorruptionError) -> Self {
+        Self::new(io::ErrorKind::InvalidData, error)
+    }
+}
+
+/// An error raised while loading a file into a [`Store`](crate::store::Store).
+#[derive(Debug, thiserror::Error)]
+pub enum LoaderError {
+    /// An error raised while reading the file.
+    #[error(transparent)]
+    Parsing(#[from] RdfParseError),
+    /// An error raised during the insertion in the store.
+    #[error(transparent)]
+    Storage(#[from] StorageError),
+    /// The base IRI is invalid.
+    #[error("Invalid base IRI '{iri}': {error}")]
+    InvalidBaseIri {
+        /// The IRI itself.
+        iri: String,
+        /// The parsing error.
+        #[source]
+        error: IriParseError,
+    },
+}
+
+impl From<LoaderError> for io::Error {
+    #[inline]
+    fn from(error: LoaderError) -> Self {
+        match error {
+            LoaderError::Storage(error) => error.into(),
+            LoaderError::Parsing(error) => error.into(),
+            LoaderError::InvalidBaseIri { .. } => {
+                Self::new(io::ErrorKind::InvalidInput, error.to_string())
+            }
+        }
+    }
+}
+
+/// An error raised while writing a file from a [`Store`](crate::store::Store).
+#[derive(Debug, thiserror::Error)]
+pub enum SerializerError {
+    /// An error raised while writing the content.
+    #[error(transparent)]
+    Io(#[from] io::Error),
+    /// An error raised during the lookup in the store.
+    #[error(transparent)]
+    Storage(#[from] StorageError),
+    /// A format compatible with [RDF dataset](https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-dataset) is required.
+    #[error("A RDF format supporting datasets was expected, {0} found")]
+    DatasetFormatExpected(RdfFormat),
+}
+
+impl From<SerializerError> for io::Error {
+    #[inline]
+    fn from(error: SerializerError) -> Self {
+        match error {
+            SerializerError::Storage(error) => error.into(),
+            SerializerError::Io(error) => error,
+            SerializerError::DatasetFormatExpected(_) => {
+                Self::new(io::ErrorKind::InvalidInput, error.to_string())
+            }
+        }
+    }
+}

lib/oxigraph/src/storage/mod.rs

@@ -1,6 +1,9 @@
-use crate::model::{GraphNameRef, NamedOrBlankNodeRef, Quad, QuadRef, TermRef};
+#![allow(clippy::same_name_method)]
+#[cfg(all(not(target_family = "wasm")))]
+use crate::model::Quad;
+use crate::model::{GraphNameRef, NamedOrBlankNodeRef, QuadRef, TermRef};
 use crate::storage::backend::{Reader, Transaction};
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(not(target_family = "wasm")))]
 use crate::storage::binary_encoder::LATEST_STORAGE_VERSION;
 use crate::storage::binary_encoder::{
     decode_term, encode_term, encode_term_pair, encode_term_quad, encode_term_triple,
@@ -9,25 +12,23 @@ use crate::storage::binary_encoder::{
     WRITTEN_TERM_MAX_SIZE,
 };
 pub use crate::storage::error::{CorruptionError, LoaderError, SerializerError, StorageError};
-use crate::storage::numeric_encoder::{
-    insert_term, EncodedQuad, EncodedTerm, StrHash, StrLookup, TermDecoder, TermEncoder,
-};
+#[cfg(all(not(target_family = "wasm")))]
+use crate::storage::numeric_encoder::Decoder;
+use crate::storage::numeric_encoder::{insert_term, EncodedQuad, EncodedTerm, StrHash, StrLookup};
 use backend::{ColumnFamily, ColumnFamilyDefinition, Db, Iter};
-use std::cmp::{max, min};
+#[cfg(all(not(target_family = "wasm")))]
 use std::collections::VecDeque;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(not(target_family = "wasm")))]
 use std::collections::{HashMap, HashSet};
 use std::error::Error;
-#[cfg(not(target_arch = "wasm32"))]
-use std::mem::take;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(not(target_family = "wasm")))]
+use std::mem::{swap, take};
+#[cfg(all(not(target_family = "wasm")))]
 use std::path::{Path, PathBuf};
-use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::Arc;
-#[cfg(not(target_arch = "wasm32"))]
-use std::thread::spawn;
-use std::thread::JoinHandle;
-use sysinfo::{System, SystemExt};
+#[cfg(all(not(target_family = "wasm")))]
+use std::sync::Mutex;
+#[cfg(all(not(target_family = "wasm")))]
+use std::{io, thread};
 
 mod backend;
 mod binary_encoder;
@@ -46,15 +47,16 @@ const DSPO_CF: &str = "dspo";
 const DPOS_CF: &str = "dpos";
 const DOSP_CF: &str = "dosp";
 const GRAPHS_CF: &str = "graphs";
+#[cfg(all(not(target_family = "wasm")))]
 const DEFAULT_CF: &str = "default";
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(not(target_family = "wasm")))]
 const DEFAULT_BULK_LOAD_BATCH_SIZE: usize = 1_000_000;
-const MAX_BULK_LOAD_BATCH_SIZE: usize = 100_000_000;
 
 /// Low level storage primitives
 #[derive(Clone)]
 pub struct Storage {
     db: Db,
+    #[cfg(all(not(target_family = "wasm")))]
     default_cf: ColumnFamily,
     id2str_cf: ColumnFamily,
     spog_cf: ColumnFamily,
@@ -74,9 +76,39 @@ impl Storage {
         Self::setup(Db::new(Self::column_families())?)
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn open(path: &Path) -> Result<Self, StorageError> {
-        Self::setup(Db::open(path, Self::column_families())?)
+    #[cfg(all(not(target_family = "wasm")))]
+    pub fn open(path: &Path, key: Option<[u8; 32]>) -> Result<Self, StorageError> {
+        Self::setup(Db::open_read_write(
+            Some(path),
+            Self::column_families(),
+            key,
+        )?)
+    }
+
+    // #[cfg(all(not(target_family = "wasm")))]
+    // pub fn open_secondary(primary_path: &Path) -> Result<Self, StorageError> {
+    //     Self::setup(Db::open_secondary(
+    //         primary_path,
+    //         None,
+    //         Self::column_families(),
+    //     )?)
+    // }
+
+    // #[cfg(all(not(target_family = "wasm")))]
+    // pub fn open_persistent_secondary(
+    //     primary_path: &Path,
+    //     secondary_path: &Path,
+    // ) -> Result<Self, StorageError> {
+    //     Self::setup(Db::open_secondary(
+    //         primary_path,
+    //         Some(secondary_path),
+    //         Self::column_families(),
+    //     )?)
+    // }
+
+    #[cfg(all(not(target_family = "wasm")))]
+    pub fn open_read_only(path: &Path, key: Option<[u8; 32]>) -> Result<Self, StorageError> {
+        Self::setup(Db::open_read_only(path, Self::column_families(), key)?)
     }
 
     fn column_families() -> Vec<ColumnFamilyDefinition> {
@@ -152,26 +184,27 @@ impl Storage {
 
     fn setup(db: Db) -> Result<Self, StorageError> {
         let this = Self {
-            default_cf: db.column_family(DEFAULT_CF).unwrap(),
-            id2str_cf: db.column_family(ID2STR_CF).unwrap(),
-            spog_cf: db.column_family(SPOG_CF).unwrap(),
-            posg_cf: db.column_family(POSG_CF).unwrap(),
-            ospg_cf: db.column_family(OSPG_CF).unwrap(),
-            gspo_cf: db.column_family(GSPO_CF).unwrap(),
-            gpos_cf: db.column_family(GPOS_CF).unwrap(),
-            gosp_cf: db.column_family(GOSP_CF).unwrap(),
-            dspo_cf: db.column_family(DSPO_CF).unwrap(),
-            dpos_cf: db.column_family(DPOS_CF).unwrap(),
-            dosp_cf: db.column_family(DOSP_CF).unwrap(),
-            graphs_cf: db.column_family(GRAPHS_CF).unwrap(),
+            #[cfg(all(not(target_family = "wasm")))]
+            default_cf: db.column_family(DEFAULT_CF)?,
+            id2str_cf: db.column_family(ID2STR_CF)?,
+            spog_cf: db.column_family(SPOG_CF)?,
+            posg_cf: db.column_family(POSG_CF)?,
+            ospg_cf: db.column_family(OSPG_CF)?,
+            gspo_cf: db.column_family(GSPO_CF)?,
+            gpos_cf: db.column_family(GPOS_CF)?,
+            gosp_cf: db.column_family(GOSP_CF)?,
+            dspo_cf: db.column_family(DSPO_CF)?,
+            dpos_cf: db.column_family(DPOS_CF)?,
+            dosp_cf: db.column_family(DOSP_CF)?,
+            graphs_cf: db.column_family(GRAPHS_CF)?,
             db,
         };
-        #[cfg(not(target_arch = "wasm32"))]
+        #[cfg(all(not(target_family = "wasm")))]
         this.migrate()?;
         Ok(this)
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(not(target_family = "wasm")))]
     fn migrate(&self) -> Result<(), StorageError> {
         let mut version = self.ensure_version()?;
         if version == 0 {
@@ -200,24 +233,24 @@ impl Storage {
 
         match version {
             _ if version < LATEST_STORAGE_VERSION => Err(CorruptionError::msg(format!(
-                "The RocksDB database is using the outdated encoding version {}. Automated migration is not supported, please dump the store dataset using a compatible Oxigraph version and load it again using the current version",
-                version
+                "The RocksDB database is using the outdated encoding version {version}. Automated migration is not supported, please dump the store dataset using a compatible Oxigraph version and load it again using the current version"
+
             )).into()),
             LATEST_STORAGE_VERSION => Ok(()),
             _ => Err(CorruptionError::msg(format!(
-                "The RocksDB database is using the too recent version {}. Upgrade to the latest Oxigraph version to load this database",
-                version
+                "The RocksDB database is using the too recent version {version}. Upgrade to the latest Oxigraph version to load this database"
+
             )).into())
         }
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(not(target_family = "wasm")))]
     fn ensure_version(&self) -> Result<u64, StorageError> {
         Ok(
             if let Some(version) = self.db.get(&self.default_cf, b"oxversion")? {
-                let mut buffer = [0; 8];
-                buffer.copy_from_slice(&version);
-                u64::from_be_bytes(buffer)
+                u64::from_be_bytes(version.as_ref().try_into().map_err(|e| {
+                    CorruptionError::new(format!("Error while parsing the version key: {e}"))
+                })?)
             } else {
                 self.update_version(LATEST_STORAGE_VERSION)?;
                 LATEST_STORAGE_VERSION
@@ -225,11 +258,11 @@ impl Storage {
         )
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(not(target_family = "wasm")))]
     fn update_version(&self, version: u64) -> Result<(), StorageError> {
         self.db
             .insert(&self.default_cf, b"oxversion", &version.to_be_bytes())?;
-        self.db.flush(&self.default_cf)
+        self.db.flush()
     }
 
     pub fn snapshot(&self) -> StorageReader {
@@ -252,25 +285,15 @@ impl Storage {
         })
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(not(target_family = "wasm")))]
     pub fn flush(&self) -> Result<(), StorageError> {
-        self.db.flush(&self.default_cf)?;
-        self.db.flush(&self.gpos_cf)?;
-        self.db.flush(&self.gpos_cf)?;
-        self.db.flush(&self.gosp_cf)?;
-        self.db.flush(&self.spog_cf)?;
-        self.db.flush(&self.posg_cf)?;
-        self.db.flush(&self.ospg_cf)?;
-        self.db.flush(&self.dspo_cf)?;
-        self.db.flush(&self.dpos_cf)?;
-        self.db.flush(&self.dosp_cf)?;
-        self.db.flush(&self.id2str_cf)
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
+        self.db.flush()
+    }
+
+    #[cfg(all(not(target_family = "wasm")))]
     pub fn compact(&self) -> Result<(), StorageError> {
         self.db.compact(&self.default_cf)?;
-        self.db.compact(&self.gpos_cf)?;
+        self.db.compact(&self.gspo_cf)?;
         self.db.compact(&self.gpos_cf)?;
         self.db.compact(&self.gosp_cf)?;
         self.db.compact(&self.spog_cf)?;
@@ -282,7 +305,7 @@ impl Storage {
         self.db.compact(&self.id2str_cf)
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(not(target_family = "wasm")))]
     pub fn backup(&self, target_directory: &Path) -> Result<(), StorageError> {
         self.db.backup(target_directory)
     }
@@ -294,15 +317,6 @@ pub struct StorageReader {
 }
 
 impl StorageReader {
-    #[allow(clippy::unused_self)]
-    pub fn term_encoder(&self) -> TermEncoder {
-        TermEncoder::new()
-    }
-
-    pub fn term_decoder(&self) -> TermDecoder<Self> {
-        TermDecoder::new(self)
-    }
-
     pub fn len(&self) -> Result<usize, StorageError> {
         Ok(self.reader.len(&self.storage.gspo_cf)? + self.reader.len(&self.storage.dspo_cf)?)
     }
@@ -559,7 +573,7 @@ impl StorageReader {
 
     pub fn named_graphs(&self) -> DecodingGraphIterator {
         DecodingGraphIterator {
-            iter: self.reader.iter(&self.storage.graphs_cf).unwrap(), //TODO: propagate error?
+            iter: self.reader.iter(&self.storage.graphs_cf).unwrap(), // TODO: propagate error?
         }
     }
 
@@ -616,7 +630,7 @@ impl StorageReader {
         }
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(not(target_family = "wasm")))]
     pub fn get_str(&self, key: &StrHash) -> Result<Option<String>, StorageError> {
         Ok(self
             .storage
@@ -627,31 +641,31 @@ impl StorageReader {
             .map_err(CorruptionError::new)?)
     }
 
-    #[cfg(target_arch = "wasm32")]
+    #[cfg(any(target_family = "wasm"))]
     pub fn get_str(&self, key: &StrHash) -> Result<Option<String>, StorageError> {
         Ok(self
             .reader
             .get(&self.storage.id2str_cf, &key.to_be_bytes())?
-            .map(|v| String::from_utf8(v.into()))
+            .map(String::from_utf8)
             .transpose()
             .map_err(CorruptionError::new)?)
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(not(target_family = "wasm")))]
     pub fn contains_str(&self, key: &StrHash) -> Result<bool, StorageError> {
         self.storage
             .db
             .contains_key(&self.storage.id2str_cf, &key.to_be_bytes())
     }
 
-    #[cfg(target_arch = "wasm32")]
+    #[cfg(any(target_family = "wasm"))]
     pub fn contains_str(&self, key: &StrHash) -> Result<bool, StorageError> {
         self.reader
             .contains_key(&self.storage.id2str_cf, &key.to_be_bytes())
     }
 
     /// Validates that all the storage invariants held in the data
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(not(target_family = "wasm")))]
     pub fn validate(&self) -> Result<(), StorageError> {
         // triples
         let dspo_size = self.dspo_quads(&[]).count();
@@ -663,7 +677,7 @@ impl StorageReader {
         }
         for spo in self.dspo_quads(&[]) {
             let spo = spo?;
-            self.term_decoder().decode_quad(&spo)?; // We ensure that the quad is readable
+            self.decode_quad(&spo)?; // We ensure that the quad is readable
             if !self.storage.db.contains_key(
                 &self.storage.dpos_cf,
                 &encode_term_triple(&spo.predicate, &spo.object, &spo.subject),
@@ -693,7 +707,7 @@ impl StorageReader {
         }
         for gspo in self.gspo_quads(&[]) {
             let gspo = gspo?;
-            self.term_decoder().decode_quad(&gspo)?; // We ensure that the quad is readable
+            self.decode_quad(&gspo)?; // We ensure that the quad is readable
             if !self.storage.db.contains_key(
                 &self.storage.gpos_cf,
                 &encode_term_quad(
@@ -761,6 +775,13 @@ impl StorageReader {
         }
         Ok(())
     }
+
+    /// Validates that all the storage invariants held in the data
+    #[cfg(any(target_family = "wasm"))]
+    #[allow(clippy::unused_self, clippy::unnecessary_wraps)]
+    pub fn validate(&self) -> Result<(), StorageError> {
+        Ok(()) // TODO
+    }
 }
 
 pub struct ChainedDecodingQuadIterator {
@@ -787,7 +808,7 @@ impl ChainedDecodingQuadIterator {
 impl Iterator for ChainedDecodingQuadIterator {
     type Item = Result<EncodedQuad, StorageError>;
 
-    fn next(&mut self) -> Option<Result<EncodedQuad, StorageError>> {
+    fn next(&mut self) -> Option<Self::Item> {
         if let Some(result) = self.first.next() {
             Some(result)
         } else if let Some(second) = self.second.as_mut() {
@@ -806,7 +827,7 @@ pub struct DecodingQuadIterator {
 impl Iterator for DecodingQuadIterator {
     type Item = Result<EncodedQuad, StorageError>;
 
-    fn next(&mut self) -> Option<Result<EncodedQuad, StorageError>> {
+    fn next(&mut self) -> Option<Self::Item> {
         if let Err(e) = self.iter.status() {
             return Some(Err(e));
         }
@@ -823,7 +844,7 @@ pub struct DecodingGraphIterator {
 impl Iterator for DecodingGraphIterator {
     type Item = Result<EncodedTerm, StorageError>;
 
-    fn next(&mut self) -> Option<Result<EncodedTerm, StorageError>> {
+    fn next(&mut self) -> Option<Self::Item> {
         if let Err(e) = self.iter.status() {
             return Some(Err(e));
         }
@@ -837,10 +858,6 @@ impl StrLookup for StorageReader {
     fn get_str(&self, key: &StrHash) -> Result<Option<String>, StorageError> {
         self.get_str(key)
     }
-
-    fn contains_str(&self, key: &StrHash) -> Result<bool, StorageError> {
-        self.contains_str(key)
-    }
 }
 
 pub struct StorageWriter<'a> {
@@ -857,13 +874,8 @@ impl<'a> StorageWriter<'a> {
         }
     }
 
-    #[allow(clippy::unused_self)]
-    pub fn term_encoder(&self) -> TermEncoder {
-        TermEncoder::new()
-    }
-
     pub fn insert(&mut self, quad: QuadRef<'_>) -> Result<bool, StorageError> {
-        let encoded = self.term_encoder().encode_quad(quad);
+        let encoded = quad.into();
         self.buffer.clear();
         let result = if quad.graph_name.is_default_graph() {
             write_spo_quad(&mut self.buffer, &encoded);
@@ -951,7 +963,7 @@ impl<'a> StorageWriter<'a> {
         &mut self,
         graph_name: NamedOrBlankNodeRef<'_>,
     ) -> Result<bool, StorageError> {
-        let encoded_graph_name = self.term_encoder().encode_graph_name(graph_name);
+        let encoded_graph_name = graph_name.into();
 
         self.buffer.clear();
         write_term(&mut self.buffer, &encoded_graph_name);
@@ -989,7 +1001,7 @@ impl<'a> StorageWriter<'a> {
         }
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(not(target_family = "wasm")))]
     fn insert_str(&mut self, key: &StrHash, value: &str) -> Result<(), StorageError> {
         if self
             .storage
@@ -1005,7 +1017,7 @@ impl<'a> StorageWriter<'a> {
         )
     }
 
-    #[cfg(target_arch = "wasm32")]
+    #[cfg(any(target_family = "wasm"))]
     fn insert_str(&mut self, key: &StrHash, value: &str) -> Result<(), StorageError> {
         self.transaction.insert(
             &self.storage.id2str_cf,
@@ -1015,7 +1027,7 @@ impl<'a> StorageWriter<'a> {
     }
 
     pub fn remove(&mut self, quad: QuadRef<'_>) -> Result<bool, StorageError> {
-        self.remove_encoded(&self.term_encoder().encode_quad(quad))
+        self.remove_encoded(&quad.into())
     }
 
     fn remove_encoded(&mut self, quad: &EncodedQuad) -> Result<bool, StorageError> {
@@ -1091,15 +1103,14 @@ impl<'a> StorageWriter<'a> {
                 self.remove_encoded(&quad?)?;
             }
         } else {
-            let graph_name = self.term_encoder().encode_graph_name(graph_name);
             self.buffer.clear();
-            write_term(&mut self.buffer, &graph_name);
+            write_term(&mut self.buffer, &graph_name.into());
             if self
                 .transaction
                 .contains_key_for_update(&self.storage.graphs_cf, &self.buffer)?
             {
                 // The condition is useful to lock the graph itself and ensure no quad is inserted at the same time
-                for quad in self.reader().quads_for_graph(&graph_name) {
+                for quad in self.reader().quads_for_graph(&graph_name.into()) {
                     self.remove_encoded(&quad?)?;
                 }
             }
@@ -1125,7 +1136,7 @@ impl<'a> StorageWriter<'a> {
         &mut self,
         graph_name: NamedOrBlankNodeRef<'_>,
     ) -> Result<bool, StorageError> {
-        self.remove_encoded_named_graph(&self.term_encoder().encode_graph_name(graph_name))
+        self.remove_encoded_named_graph(&graph_name.into())
     }
 
     fn remove_encoded_named_graph(
@@ -1171,7 +1182,8 @@ impl<'a> StorageWriter<'a> {
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(not(target_family = "wasm")))]
+#[must_use]
 pub struct StorageBulkLoader {
     storage: Storage,
     hooks: Vec<Box<dyn Fn(u64)>>,
@@ -1179,7 +1191,7 @@ pub struct StorageBulkLoader {
     max_memory_size: Option<usize>,
 }
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(not(target_family = "wasm")))]
 impl StorageBulkLoader {
     pub fn new(storage: Storage) -> Self {
         Self {
@@ -1190,12 +1202,12 @@ impl StorageBulkLoader {
         }
     }
 
-    pub fn set_num_threads(mut self, num_threads: usize) -> Self {
+    pub fn with_num_threads(mut self, num_threads: usize) -> Self {
         self.num_threads = Some(num_threads);
         self
     }
 
-    pub fn set_max_memory_size_in_megabytes(mut self, max_memory_size: usize) -> Self {
+    pub fn with_max_memory_size_in_megabytes(mut self, max_memory_size: usize) -> Self {
         self.max_memory_size = Some(max_memory_size);
         self
     }
@@ -1205,142 +1217,146 @@ impl StorageBulkLoader {
         self
     }
 
-    pub fn load<EI, EO: From<StorageError> + From<EI>, I: IntoIterator<Item = Result<Quad, EI>>>(
+    #[allow(clippy::trait_duplication_in_bounds)]
+    pub fn load<EI, EO: From<StorageError> + From<EI>>(
         &self,
-        quads: I,
+        quads: impl IntoIterator<Item = Result<Quad, EI>>,
     ) -> Result<(), EO> {
-        let system = System::new_all();
-        let cpu_count = min(4, system.physical_core_count().unwrap_or(2));
-        let num_threads = max(
-            if let Some(num_threads) = self.num_threads {
-                num_threads
-            } else if let Some(max_memory_size) = self.max_memory_size {
-                min(
-                    cpu_count,
-                    max_memory_size * 1000 / DEFAULT_BULK_LOAD_BATCH_SIZE,
-                )
-            } else {
-                cpu_count
-            },
-            2,
-        );
-        let batch_size = min(
-            if let Some(max_memory_size) = self.max_memory_size {
-                max(1000, max_memory_size * 1000 / num_threads)
-            } else {
-                max(
-                    usize::try_from(system.free_memory()).unwrap() / num_threads,
-                    DEFAULT_BULK_LOAD_BATCH_SIZE,
-                )
-            },
-            MAX_BULK_LOAD_BATCH_SIZE,
-        );
-        let mut threads = VecDeque::with_capacity(num_threads - 1);
-        let mut buffer = Vec::with_capacity(batch_size);
-        let done_counter = Arc::new(AtomicU64::new(0));
-        let mut done_and_displayed_counter = 0;
-        for quad in quads {
-            let quad = quad?;
-            buffer.push(quad);
-            if buffer.len() >= batch_size {
-                self.spawn_load_thread(
-                    &mut buffer,
-                    &mut threads,
-                    &done_counter,
-                    &mut done_and_displayed_counter,
-                    num_threads,
-                )?;
-            }
+        let num_threads = self.num_threads.unwrap_or(2);
+        if num_threads < 2 {
+            return Err(
+                StorageError::Other("The bulk loader needs at least 2 threads".into()).into(),
+            );
         }
-        self.spawn_load_thread(
-            &mut buffer,
-            &mut threads,
-            &done_counter,
-            &mut done_and_displayed_counter,
-            num_threads,
-        )?;
-        for thread in threads {
-            thread.join().unwrap()?;
-            self.on_possible_progress(&done_counter, &mut done_and_displayed_counter);
+        let batch_size = if let Some(max_memory_size) = self.max_memory_size {
+            max_memory_size * 1000 / num_threads
+        } else {
+            DEFAULT_BULK_LOAD_BATCH_SIZE
+        };
+        if batch_size < 10_000 {
+            return Err(StorageError::Other(
+                "The bulk loader memory bound is too low. It needs at least 100MB".into(),
+            )
+            .into());
         }
-        Ok(())
+        let done_counter = Mutex::new(0);
+        let mut done_and_displayed_counter = 0;
+        thread::scope(|thread_scope| {
+            let mut threads = VecDeque::with_capacity(num_threads - 1);
+            let mut buffer = Vec::with_capacity(batch_size);
+            for quad in quads {
+                let quad = quad?;
+                buffer.push(quad);
+                if buffer.len() >= batch_size {
+                    self.spawn_load_thread(
+                        &mut buffer,
+                        &mut threads,
+                        thread_scope,
+                        &done_counter,
+                        &mut done_and_displayed_counter,
+                        num_threads,
+                        batch_size,
+                    )?;
+                }
+            }
+            self.spawn_load_thread(
+                &mut buffer,
+                &mut threads,
+                thread_scope,
+                &done_counter,
+                &mut done_and_displayed_counter,
+                num_threads,
+                batch_size,
+            )?;
+            for thread in threads {
+                map_thread_result(thread.join()).map_err(StorageError::Io)??;
+                self.on_possible_progress(&done_counter, &mut done_and_displayed_counter)?;
+            }
+            Ok(())
+        })
     }
 
-    fn spawn_load_thread(
-        &self,
+    fn spawn_load_thread<'scope>(
+        &'scope self,
         buffer: &mut Vec<Quad>,
-        threads: &mut VecDeque<JoinHandle<Result<(), StorageError>>>,
-        done_counter: &Arc<AtomicU64>,
+        threads: &mut VecDeque<thread::ScopedJoinHandle<'scope, Result<(), StorageError>>>,
+        thread_scope: &'scope thread::Scope<'scope, '_>,
+        done_counter: &'scope Mutex<u64>,
         done_and_displayed_counter: &mut u64,
         num_threads: usize,
+        batch_size: usize,
     ) -> Result<(), StorageError> {
-        self.on_possible_progress(done_counter, done_and_displayed_counter);
+        self.on_possible_progress(done_counter, done_and_displayed_counter)?;
         // We avoid to have too many threads
         if threads.len() >= num_threads {
             if let Some(thread) = threads.pop_front() {
-                thread.join().unwrap()?;
-                self.on_possible_progress(done_counter, done_and_displayed_counter);
+                map_thread_result(thread.join()).map_err(StorageError::Io)??;
+                self.on_possible_progress(done_counter, done_and_displayed_counter)?;
             }
         }
-        let buffer = take(buffer);
-        let storage = self.storage.clone();
-        let done_counter_clone = done_counter.clone();
-        threads.push_back(spawn(move || {
-            FileBulkLoader::new(storage).load(buffer, &done_counter_clone)
+        let mut buffer_to_load = Vec::with_capacity(batch_size);
+        swap(buffer, &mut buffer_to_load);
+        let storage = &self.storage;
+        threads.push_back(thread_scope.spawn(move || {
+            FileBulkLoader::new(storage, batch_size).load(buffer_to_load, done_counter)
         }));
-        self.on_possible_progress(done_counter, done_and_displayed_counter);
         Ok(())
     }
 
-    fn on_possible_progress(&self, done: &AtomicU64, done_and_displayed: &mut u64) {
-        let new_counter = done.fetch_max(*done_and_displayed, Ordering::Relaxed);
-        let display_step = u64::try_from(DEFAULT_BULK_LOAD_BATCH_SIZE).unwrap();
-        if new_counter % display_step > *done_and_displayed % display_step {
+    fn on_possible_progress(
+        &self,
+        done: &Mutex<u64>,
+        done_and_displayed: &mut u64,
+    ) -> Result<(), StorageError> {
+        let new_counter = *done
+            .lock()
+            .map_err(|_| io::Error::new(io::ErrorKind::Other, "Mutex poisoned"))?;
+        let display_step = DEFAULT_BULK_LOAD_BATCH_SIZE as u64;
+        if new_counter / display_step > *done_and_displayed / display_step {
             for hook in &self.hooks {
                 hook(new_counter);
             }
         }
         *done_and_displayed = new_counter;
+        Ok(())
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-struct FileBulkLoader {
-    storage: Storage,
+#[cfg(all(not(target_family = "wasm")))]
+struct FileBulkLoader<'a> {
+    storage: &'a Storage,
     id2str: HashMap<StrHash, Box<str>>,
     quads: HashSet<EncodedQuad>,
     triples: HashSet<EncodedQuad>,
     graphs: HashSet<EncodedTerm>,
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-impl FileBulkLoader {
-    fn new(storage: Storage) -> Self {
+#[cfg(all(not(target_family = "wasm")))]
+impl<'a> FileBulkLoader<'a> {
+    fn new(storage: &'a Storage, batch_size: usize) -> Self {
         Self {
             storage,
-            id2str: HashMap::default(),
-            quads: HashSet::default(),
-            triples: HashSet::default(),
+            id2str: HashMap::with_capacity(3 * batch_size),
+            quads: HashSet::with_capacity(batch_size),
+            triples: HashSet::with_capacity(batch_size),
             graphs: HashSet::default(),
         }
     }
 
-    fn load(
-        &mut self,
-        quads: impl IntoIterator<Item = Quad>,
-        counter: &AtomicU64,
-    ) -> Result<(), StorageError> {
+    fn load(&mut self, quads: Vec<Quad>, counter: &Mutex<u64>) -> Result<(), StorageError> {
         self.encode(quads)?;
         let size = self.triples.len() + self.quads.len();
         self.save()?;
-        counter.fetch_add(size.try_into().unwrap(), Ordering::Relaxed);
+        *counter
+            .lock()
+            .map_err(|_| io::Error::new(io::ErrorKind::Other, "Mutex poisoned"))? +=
+            size.try_into().unwrap_or(u64::MAX);
         Ok(())
     }
 
-    fn encode(&mut self, quads: impl IntoIterator<Item = Quad>) -> Result<(), StorageError> {
-        let encoder = TermEncoder::new();
+    fn encode(&mut self, quads: Vec<Quad>) -> Result<(), StorageError> {
         for quad in quads {
-            let encoded = encoder.encode_quad(&quad);
+            let encoded = EncodedQuad::from(quad.as_ref());
             if quad.graph_name.is_default_graph() {
                 if self.triples.insert(encoded.clone()) {
                     self.insert_term(quad.subject.as_ref().into(), &encoded.subject)?;
@@ -1357,7 +1373,12 @@ impl FileBulkLoader {
                         match quad.graph_name.as_ref() {
                             GraphNameRef::NamedNode(n) => n.into(),
                             GraphNameRef::BlankNode(n) => n.into(),
-                            GraphNameRef::DefaultGraph => unreachable!(),
+                            GraphNameRef::DefaultGraph => {
+                                return Err(CorruptionError::new(
+                                    "Default graph this not the default graph",
+                                )
+                                .into())
+                            }
                         },
                         &encoded.graph_name,
                     )?;
@@ -1515,3 +1536,17 @@ impl FileBulkLoader {
         sst.finish()
     }
 }
+
+#[cfg(all(not(target_family = "wasm")))]
+fn map_thread_result<R>(result: thread::Result<R>) -> io::Result<R> {
+    result.map_err(|e| {
+        io::Error::new(
+            io::ErrorKind::Other,
+            if let Ok(e) = e.downcast::<&dyn std::fmt::Display>() {
+                format!("A loader processed crashed with {e}")
+            } else {
+                "A loader processed crashed with and unknown error".into()
+            },
+        )
+    })
+}

lib/oxigraph/src/storage/numeric_encoder.rs

@@ -1,15 +1,14 @@
 #![allow(clippy::unreadable_literal)]
 
 use crate::model::*;
+use crate::storage::error::{CorruptionError, StorageError};
 use crate::storage::small_string::SmallString;
-use crate::store::{CorruptionError, StorageError};
-use crate::xsd::*;
+use oxsdatatypes::*;
 use siphasher::sip128::{Hasher128, SipHasher24};
 use std::fmt::Debug;
-use std::hash::Hash;
-use std::hash::Hasher;
-use std::rc::Rc;
+use std::hash::{Hash, Hasher};
 use std::str;
+use std::sync::Arc;
 
 #[derive(Eq, PartialEq, Debug, Clone, Copy, Hash)]
 #[repr(transparent)]
@@ -80,10 +79,10 @@ pub enum EncodedTerm {
         value_id: StrHash,
         datatype_id: StrHash,
     },
-    BooleanLiteral(bool),
+    BooleanLiteral(Boolean),
     FloatLiteral(Float),
     DoubleLiteral(Double),
-    IntegerLiteral(i64),
+    IntegerLiteral(Integer),
     DecimalLiteral(Decimal),
     DateTimeLiteral(DateTime),
     TimeLiteral(Time),
@@ -96,7 +95,7 @@ pub enum EncodedTerm {
     DurationLiteral(Duration),
     YearMonthDurationLiteral(YearMonthDuration),
     DayTimeDurationLiteral(DayTimeDuration),
-    Triple(Rc<EncodedTriple>),
+    Triple(Arc<EncodedTriple>),
 }
 
 impl PartialEq for EncodedTerm {
@@ -183,21 +182,25 @@ impl PartialEq for EncodedTerm {
                 },
             ) => value_id_a == value_id_b && datatype_id_a == datatype_id_b,
             (Self::BooleanLiteral(a), Self::BooleanLiteral(b)) => a == b,
-            (Self::FloatLiteral(a), Self::FloatLiteral(b)) => a == b,
-            (Self::DoubleLiteral(a), Self::DoubleLiteral(b)) => a == b,
-            (Self::IntegerLiteral(a), Self::IntegerLiteral(b)) => a == b,
-            (Self::DecimalLiteral(a), Self::DecimalLiteral(b)) => a == b,
-            (Self::DateTimeLiteral(a), Self::DateTimeLiteral(b)) => a.is_identical_with(b),
-            (Self::TimeLiteral(a), Self::TimeLiteral(b)) => a.is_identical_with(b),
-            (Self::DateLiteral(a), Self::DateLiteral(b)) => a.is_identical_with(b),
-            (Self::GYearMonthLiteral(a), Self::GYearMonthLiteral(b)) => a.is_identical_with(b),
-            (Self::GYearLiteral(a), Self::GYearLiteral(b)) => a.is_identical_with(b),
-            (Self::GMonthDayLiteral(a), Self::GMonthDayLiteral(b)) => a.is_identical_with(b),
-            (Self::GMonthLiteral(a), Self::GMonthLiteral(b)) => a.is_identical_with(b),
-            (Self::GDayLiteral(a), Self::GDayLiteral(b)) => a.is_identical_with(b),
-            (Self::DurationLiteral(a), Self::DurationLiteral(b)) => a == b,
-            (Self::YearMonthDurationLiteral(a), Self::YearMonthDurationLiteral(b)) => a == b,
-            (Self::DayTimeDurationLiteral(a), Self::DayTimeDurationLiteral(b)) => a == b,
+            (Self::FloatLiteral(a), Self::FloatLiteral(b)) => a.is_identical_with(*b),
+            (Self::DoubleLiteral(a), Self::DoubleLiteral(b)) => a.is_identical_with(*b),
+            (Self::IntegerLiteral(a), Self::IntegerLiteral(b)) => a.is_identical_with(*b),
+            (Self::DecimalLiteral(a), Self::DecimalLiteral(b)) => a.is_identical_with(*b),
+            (Self::DateTimeLiteral(a), Self::DateTimeLiteral(b)) => a.is_identical_with(*b),
+            (Self::TimeLiteral(a), Self::TimeLiteral(b)) => a.is_identical_with(*b),
+            (Self::DateLiteral(a), Self::DateLiteral(b)) => a.is_identical_with(*b),
+            (Self::GYearMonthLiteral(a), Self::GYearMonthLiteral(b)) => a.is_identical_with(*b),
+            (Self::GYearLiteral(a), Self::GYearLiteral(b)) => a.is_identical_with(*b),
+            (Self::GMonthDayLiteral(a), Self::GMonthDayLiteral(b)) => a.is_identical_with(*b),
+            (Self::GMonthLiteral(a), Self::GMonthLiteral(b)) => a.is_identical_with(*b),
+            (Self::GDayLiteral(a), Self::GDayLiteral(b)) => a.is_identical_with(*b),
+            (Self::DurationLiteral(a), Self::DurationLiteral(b)) => a.is_identical_with(*b),
+            (Self::YearMonthDurationLiteral(a), Self::YearMonthDurationLiteral(b)) => {
+                a.is_identical_with(*b)
+            }
+            (Self::DayTimeDurationLiteral(a), Self::DayTimeDurationLiteral(b)) => {
+                a.is_identical_with(*b)
+            }
             (Self::Triple(a), Self::Triple(b)) => a == b,
             (_, _) => false,
         }
@@ -247,8 +250,8 @@ impl Hash for EncodedTerm {
                 datatype_id.hash(state);
             }
             Self::BooleanLiteral(value) => value.hash(state),
-            Self::FloatLiteral(value) => value.hash(state),
-            Self::DoubleLiteral(value) => value.hash(state),
+            Self::FloatLiteral(value) => value.to_be_bytes().hash(state),
+            Self::DoubleLiteral(value) => value.to_be_bytes().hash(state),
             Self::IntegerLiteral(value) => value.hash(state),
             Self::DecimalLiteral(value) => value.hash(state),
             Self::DateTimeLiteral(value) => value.hash(state),
@@ -329,13 +332,13 @@ impl EncodedTerm {
 
 impl From<bool> for EncodedTerm {
     fn from(value: bool) -> Self {
-        Self::BooleanLiteral(value)
+        Self::BooleanLiteral(value.into())
     }
 }
 
 impl From<i64> for EncodedTerm {
     fn from(value: i64) -> Self {
-        Self::IntegerLiteral(value)
+        Self::IntegerLiteral(value.into())
     }
 }
 
@@ -375,12 +378,24 @@ impl From<f64> for EncodedTerm {
     }
 }
 
+impl From<Boolean> for EncodedTerm {
+    fn from(value: Boolean) -> Self {
+        Self::BooleanLiteral(value)
+    }
+}
+
 impl From<Double> for EncodedTerm {
     fn from(value: Double) -> Self {
         Self::DoubleLiteral(value)
     }
 }
 
+impl From<Integer> for EncodedTerm {
+    fn from(value: Integer) -> Self {
+        Self::IntegerLiteral(value)
+    }
+}
+
 impl From<Decimal> for EncodedTerm {
     fn from(value: Decimal) -> Self {
         Self::DecimalLiteral(value)
@@ -405,112 +420,87 @@ impl From<Date> for EncodedTerm {
     }
 }
 
-impl From<Duration> for EncodedTerm {
-    fn from(value: Duration) -> Self {
-        Self::DurationLiteral(value)
+impl From<GMonthDay> for EncodedTerm {
+    fn from(value: GMonthDay) -> Self {
+        Self::GMonthDayLiteral(value)
     }
 }
 
-impl From<YearMonthDuration> for EncodedTerm {
-    fn from(value: YearMonthDuration) -> Self {
-        Self::YearMonthDurationLiteral(value)
+impl From<GDay> for EncodedTerm {
+    fn from(value: GDay) -> Self {
+        Self::GDayLiteral(value)
     }
 }
 
-impl From<DayTimeDuration> for EncodedTerm {
-    fn from(value: DayTimeDuration) -> Self {
-        Self::DayTimeDurationLiteral(value)
+impl From<GMonth> for EncodedTerm {
+    fn from(value: GMonth) -> Self {
+        Self::GMonthLiteral(value)
     }
 }
 
-impl From<EncodedTriple> for EncodedTerm {
-    fn from(value: EncodedTriple) -> Self {
-        Self::Triple(Rc::new(value))
+impl From<GYearMonth> for EncodedTerm {
+    fn from(value: GYearMonth) -> Self {
+        Self::GYearMonthLiteral(value)
     }
 }
 
-#[derive(Eq, PartialEq, Debug, Clone, Hash)]
-pub struct EncodedTriple {
-    pub subject: EncodedTerm,
-    pub predicate: EncodedTerm,
-    pub object: EncodedTerm,
-}
-
-impl EncodedTriple {
-    pub fn new(subject: EncodedTerm, predicate: EncodedTerm, object: EncodedTerm) -> Self {
-        Self {
-            subject,
-            predicate,
-            object,
-        }
+impl From<GYear> for EncodedTerm {
+    fn from(value: GYear) -> Self {
+        Self::GYearLiteral(value)
     }
 }
 
-#[derive(Eq, PartialEq, Debug, Clone, Hash)]
-pub struct EncodedQuad {
-    pub subject: EncodedTerm,
-    pub predicate: EncodedTerm,
-    pub object: EncodedTerm,
-    pub graph_name: EncodedTerm,
+impl From<Duration> for EncodedTerm {
+    fn from(value: Duration) -> Self {
+        Self::DurationLiteral(value)
+    }
 }
 
-impl EncodedQuad {
-    pub fn new(
-        subject: EncodedTerm,
-        predicate: EncodedTerm,
-        object: EncodedTerm,
-        graph_name: EncodedTerm,
-    ) -> Self {
-        Self {
-            subject,
-            predicate,
-            object,
-            graph_name,
-        }
+impl From<YearMonthDuration> for EncodedTerm {
+    fn from(value: YearMonthDuration) -> Self {
+        Self::YearMonthDurationLiteral(value)
     }
 }
 
-pub struct TermEncoder {}
-
-impl TermEncoder {
-    pub fn new() -> Self {
-        Self {}
+impl From<DayTimeDuration> for EncodedTerm {
+    fn from(value: DayTimeDuration) -> Self {
+        Self::DayTimeDurationLiteral(value)
     }
+}
 
-    pub fn encode_term<'a>(&self, term: impl Into<TermRef<'a>>) -> EncodedTerm {
-        match term.into() {
-            TermRef::NamedNode(named_node) => self.encode_named_node(named_node),
-            TermRef::BlankNode(blank_node) => self.encode_blank_node(blank_node),
-            TermRef::Literal(literal) => self.encode_literal(literal),
-            TermRef::Triple(triple) => self.encode_triple(triple.as_ref()).into(),
-        }
+impl From<EncodedTriple> for EncodedTerm {
+    fn from(value: EncodedTriple) -> Self {
+        Self::Triple(Arc::new(value))
     }
+}
 
-    #[allow(clippy::unused_self)]
-    fn encode_named_node(&self, named_node: NamedNodeRef<'_>) -> EncodedTerm {
-        EncodedTerm::NamedNode {
+impl From<NamedNodeRef<'_>> for EncodedTerm {
+    fn from(named_node: NamedNodeRef<'_>) -> Self {
+        Self::NamedNode {
             iri_id: StrHash::new(named_node.as_str()),
         }
     }
+}
 
-    #[allow(clippy::unused_self)]
-    fn encode_blank_node(&self, blank_node: BlankNodeRef<'_>) -> EncodedTerm {
+impl From<BlankNodeRef<'_>> for EncodedTerm {
+    fn from(blank_node: BlankNodeRef<'_>) -> Self {
         if let Some(id) = blank_node.unique_id() {
-            EncodedTerm::NumericalBlankNode { id }
+            Self::NumericalBlankNode { id }
         } else {
             let id = blank_node.as_str();
             if let Ok(id) = id.try_into() {
-                EncodedTerm::SmallBlankNode(id)
+                Self::SmallBlankNode(id)
             } else {
-                EncodedTerm::BigBlankNode {
+                Self::BigBlankNode {
                     id_id: StrHash::new(id),
                 }
             }
         }
     }
+}
 
-    #[allow(clippy::unused_self)]
-    fn encode_literal(&self, literal: LiteralRef<'_>) -> EncodedTerm {
+impl From<LiteralRef<'_>> for EncodedTerm {
+    fn from(literal: LiteralRef<'_>) -> Self {
         let value = literal.value();
         let datatype = literal.datatype().as_str();
         let native_encoding = match datatype {
@@ -518,20 +508,20 @@ impl TermEncoder {
                 literal.language().map(|language| {
                     if let Ok(value) = SmallString::try_from(value) {
                         if let Ok(language) = SmallString::try_from(language) {
-                            EncodedTerm::SmallSmallLangStringLiteral { value, language }
+                            Self::SmallSmallLangStringLiteral { value, language }
                         } else {
-                            EncodedTerm::SmallBigLangStringLiteral {
+                            Self::SmallBigLangStringLiteral {
                                 value,
                                 language_id: StrHash::new(language),
                             }
                         }
                     } else if let Ok(language) = SmallString::try_from(language) {
-                        EncodedTerm::BigSmallLangStringLiteral {
+                        Self::BigSmallLangStringLiteral {
                             value_id: StrHash::new(value),
                             language,
                         }
                     } else {
-                        EncodedTerm::BigBigLangStringLiteral {
+                        Self::BigBigLangStringLiteral {
                             value_id: StrHash::new(value),
                             language_id: StrHash::new(language),
                         }
@@ -540,11 +530,10 @@ impl TermEncoder {
             }
             "http://www.w3.org/2001/XMLSchema#boolean" => parse_boolean_str(value),
             "http://www.w3.org/2001/XMLSchema#string" => {
-                let value = value;
                 Some(if let Ok(value) = SmallString::try_from(value) {
-                    EncodedTerm::SmallStringLiteral(value)
+                    Self::SmallStringLiteral(value)
                 } else {
-                    EncodedTerm::BigStringLiteral {
+                    Self::BigStringLiteral {
                         value_id: StrHash::new(value),
                     }
                 })
@@ -587,12 +576,12 @@ impl TermEncoder {
             Some(term) => term,
             None => {
                 if let Ok(value) = SmallString::try_from(value) {
-                    EncodedTerm::SmallTypedLiteral {
+                    Self::SmallTypedLiteral {
                         value,
                         datatype_id: StrHash::new(datatype),
                     }
                 } else {
-                    EncodedTerm::BigTypedLiteral {
+                    Self::BigTypedLiteral {
                         value_id: StrHash::new(value),
                         datatype_id: StrHash::new(datatype),
                     }
@@ -600,38 +589,118 @@ impl TermEncoder {
             }
         }
     }
+}
+
+impl From<NamedOrBlankNodeRef<'_>> for EncodedTerm {
+    fn from(term: NamedOrBlankNodeRef<'_>) -> Self {
+        match term {
+            NamedOrBlankNodeRef::NamedNode(named_node) => named_node.into(),
+            NamedOrBlankNodeRef::BlankNode(blank_node) => blank_node.into(),
+        }
+    }
+}
 
-    pub fn encode_graph_name<'a>(&self, name: impl Into<GraphNameRef<'a>>) -> EncodedTerm {
-        match name.into() {
-            GraphNameRef::NamedNode(named_node) => self.encode_named_node(named_node),
-            GraphNameRef::BlankNode(blank_node) => self.encode_blank_node(blank_node),
-            GraphNameRef::DefaultGraph => EncodedTerm::DefaultGraph,
+impl From<SubjectRef<'_>> for EncodedTerm {
+    fn from(term: SubjectRef<'_>) -> Self {
+        match term {
+            SubjectRef::NamedNode(named_node) => named_node.into(),
+            SubjectRef::BlankNode(blank_node) => blank_node.into(),
+            SubjectRef::Triple(triple) => triple.as_ref().into(),
         }
     }
+}
 
-    fn encode_triple(&self, triple: TripleRef<'_>) -> EncodedTriple {
-        EncodedTriple {
-            subject: self.encode_term(triple.subject),
-            predicate: self.encode_term(triple.predicate),
-            object: self.encode_term(triple.object),
+impl From<TermRef<'_>> for EncodedTerm {
+    fn from(term: TermRef<'_>) -> Self {
+        match term {
+            TermRef::NamedNode(named_node) => named_node.into(),
+            TermRef::BlankNode(blank_node) => blank_node.into(),
+            TermRef::Literal(literal) => literal.into(),
+            TermRef::Triple(triple) => triple.as_ref().into(),
         }
     }
+}
 
-    pub fn encode_quad<'a>(&self, quad: impl Into<QuadRef<'a>>) -> EncodedQuad {
-        let quad = quad.into();
-        EncodedQuad {
-            subject: self.encode_term(quad.subject),
-            predicate: self.encode_term(quad.predicate),
-            object: self.encode_term(quad.object),
-            graph_name: self.encode_graph_name(quad.graph_name),
+impl From<GraphNameRef<'_>> for EncodedTerm {
+    fn from(name: GraphNameRef<'_>) -> Self {
+        match name {
+            GraphNameRef::NamedNode(named_node) => named_node.into(),
+            GraphNameRef::BlankNode(blank_node) => blank_node.into(),
+            GraphNameRef::DefaultGraph => Self::DefaultGraph,
+        }
+    }
+}
+
+impl From<TripleRef<'_>> for EncodedTerm {
+    fn from(triple: TripleRef<'_>) -> Self {
+        Self::Triple(Arc::new(triple.into()))
+    }
+}
+
+#[derive(Eq, PartialEq, Debug, Clone, Hash)]
+pub struct EncodedTriple {
+    pub subject: EncodedTerm,
+    pub predicate: EncodedTerm,
+    pub object: EncodedTerm,
+}
+
+impl EncodedTriple {
+    pub fn new(subject: EncodedTerm, predicate: EncodedTerm, object: EncodedTerm) -> Self {
+        Self {
+            subject,
+            predicate,
+            object,
+        }
+    }
+}
+
+impl From<TripleRef<'_>> for EncodedTriple {
+    fn from(triple: TripleRef<'_>) -> Self {
+        Self {
+            subject: triple.subject.into(),
+            predicate: triple.predicate.into(),
+            object: triple.object.into(),
+        }
+    }
+}
+
+#[derive(Eq, PartialEq, Debug, Clone, Hash)]
+pub struct EncodedQuad {
+    pub subject: EncodedTerm,
+    pub predicate: EncodedTerm,
+    pub object: EncodedTerm,
+    pub graph_name: EncodedTerm,
+}
+
+impl EncodedQuad {
+    pub fn new(
+        subject: EncodedTerm,
+        predicate: EncodedTerm,
+        object: EncodedTerm,
+        graph_name: EncodedTerm,
+    ) -> Self {
+        Self {
+            subject,
+            predicate,
+            object,
+            graph_name,
+        }
+    }
+}
+
+impl From<QuadRef<'_>> for EncodedQuad {
+    fn from(quad: QuadRef<'_>) -> Self {
+        Self {
+            subject: quad.subject.into(),
+            predicate: quad.predicate.into(),
+            object: quad.object.into(),
+            graph_name: quad.graph_name.into(),
         }
     }
 }
 
 pub trait StrLookup {
     fn get_str(&self, key: &StrHash) -> Result<Option<String>, StorageError>;
-
-    fn contains_str(&self, key: &StrHash) -> Result<bool, StorageError>;
 }
 
 pub fn insert_term<F: FnMut(&StrHash, &str) -> Result<(), StorageError>>(
@@ -644,13 +713,13 @@ pub fn insert_term<F: FnMut(&StrHash, &str) -> Result<(), StorageError>>(
             if let EncodedTerm::NamedNode { iri_id } = encoded {
                 insert_str(iri_id, node.as_str())
             } else {
-                unreachable!("Invalid term encoding {:?} for {}", encoded, term)
+                Err(CorruptionError::from_encoded_term(encoded, &term).into())
             }
         }
         TermRef::BlankNode(node) => match encoded {
             EncodedTerm::BigBlankNode { id_id } => insert_str(id_id, node.as_str()),
             EncodedTerm::SmallBlankNode(..) | EncodedTerm::NumericalBlankNode { .. } => Ok(()),
-            _ => unreachable!("Invalid term encoding {:?} for {}", encoded, term),
+            _ => Err(CorruptionError::from_encoded_term(encoded, &term).into()),
         },
         TermRef::Literal(literal) => match encoded {
             EncodedTerm::BigStringLiteral { value_id }
@@ -661,7 +730,7 @@ pub fn insert_term<F: FnMut(&StrHash, &str) -> Result<(), StorageError>>(
                 if let Some(language) = literal.language() {
                     insert_str(language_id, language)
                 } else {
-                    unreachable!("Invalid term encoding {:?} for {}", encoded, term)
+                    Err(CorruptionError::from_encoded_term(encoded, &term).into())
                 }
             }
             EncodedTerm::BigBigLangStringLiteral {
@@ -672,7 +741,7 @@ pub fn insert_term<F: FnMut(&StrHash, &str) -> Result<(), StorageError>>(
                 if let Some(language) = literal.language() {
                     insert_str(language_id, language)
                 } else {
-                    unreachable!("Invalid term encoding {:?} for {}", encoded, term)
+                    Err(CorruptionError::from_encoded_term(encoded, &term).into())
                 }
             }
             EncodedTerm::SmallTypedLiteral { datatype_id, .. } => {
@@ -703,7 +772,7 @@ pub fn insert_term<F: FnMut(&StrHash, &str) -> Result<(), StorageError>>(
             | EncodedTerm::DurationLiteral(..)
             | EncodedTerm::YearMonthDurationLiteral(..)
             | EncodedTerm::DayTimeDurationLiteral(..) => Ok(()),
-            _ => unreachable!("Invalid term encoding {:?} for {}", encoded, term),
+            _ => Err(CorruptionError::from_encoded_term(encoded, &term).into()),
         },
         TermRef::Triple(triple) => {
             if let EncodedTerm::Triple(encoded) = encoded {
@@ -715,18 +784,14 @@ pub fn insert_term<F: FnMut(&StrHash, &str) -> Result<(), StorageError>>(
                 )?;
                 insert_term(triple.object.as_ref(), &encoded.object, insert_str)
             } else {
-                unreachable!("Invalid term encoding {:?} for {}", encoded, term)
+                Err(CorruptionError::from_encoded_term(encoded, &term).into())
             }
         }
     }
 }
 
 pub fn parse_boolean_str(value: &str) -> Option<EncodedTerm> {
-    match value {
-        "true" | "1" => Some(EncodedTerm::BooleanLiteral(true)),
-        "false" | "0" => Some(EncodedTerm::BooleanLiteral(false)),
-        _ => None,
-    }
+    value.parse().map(EncodedTerm::BooleanLiteral).ok()
 }
 
 pub fn parse_float_str(value: &str) -> Option<EncodedTerm> {
@@ -792,95 +857,10 @@ pub fn parse_day_time_duration_str(value: &str) -> Option<EncodedTerm> {
     value.parse().map(EncodedTerm::DayTimeDurationLiteral).ok()
 }
 
-pub struct TermDecoder<'a, S: StrLookup> {
-    lookup: &'a S,
-}
-
-impl<'a, S: StrLookup> TermDecoder<'a, S> {
-    pub fn new(lookup: &'a S) -> Self {
-        Self { lookup }
-    }
-
-    pub fn decode_term(&self, encoded: &EncodedTerm) -> Result<Term, StorageError> {
-        match encoded {
-            EncodedTerm::DefaultGraph => {
-                Err(CorruptionError::msg("The default graph tag is not a valid term").into())
-            }
-            EncodedTerm::NamedNode { iri_id } => {
-                Ok(NamedNode::new_unchecked(get_required_str(self.lookup, iri_id)?).into())
-            }
-            EncodedTerm::NumericalBlankNode { id } => Ok(BlankNode::new_from_unique_id(*id).into()),
-            EncodedTerm::SmallBlankNode(id) => Ok(BlankNode::new_unchecked(id.as_str()).into()),
-            EncodedTerm::BigBlankNode { id_id } => {
-                Ok(BlankNode::new_unchecked(get_required_str(self.lookup, id_id)?).into())
-            }
-            EncodedTerm::SmallStringLiteral(value) => {
-                Ok(Literal::new_simple_literal(*value).into())
-            }
-            EncodedTerm::BigStringLiteral { value_id } => {
-                Ok(Literal::new_simple_literal(get_required_str(self.lookup, value_id)?).into())
-            }
-            EncodedTerm::SmallSmallLangStringLiteral { value, language } => {
-                Ok(Literal::new_language_tagged_literal_unchecked(*value, *language).into())
-            }
-            EncodedTerm::SmallBigLangStringLiteral { value, language_id } => {
-                Ok(Literal::new_language_tagged_literal_unchecked(
-                    *value,
-                    get_required_str(self.lookup, language_id)?,
-                )
-                .into())
-            }
-            EncodedTerm::BigSmallLangStringLiteral { value_id, language } => {
-                Ok(Literal::new_language_tagged_literal_unchecked(
-                    get_required_str(self.lookup, value_id)?,
-                    *language,
-                )
-                .into())
-            }
-            EncodedTerm::BigBigLangStringLiteral {
-                value_id,
-                language_id,
-            } => Ok(Literal::new_language_tagged_literal_unchecked(
-                get_required_str(self.lookup, value_id)?,
-                get_required_str(self.lookup, language_id)?,
-            )
-            .into()),
-            EncodedTerm::SmallTypedLiteral { value, datatype_id } => {
-                Ok(Literal::new_typed_literal(
-                    *value,
-                    NamedNode::new_unchecked(get_required_str(self.lookup, datatype_id)?),
-                )
-                .into())
-            }
-            EncodedTerm::BigTypedLiteral {
-                value_id,
-                datatype_id,
-            } => Ok(Literal::new_typed_literal(
-                get_required_str(self.lookup, value_id)?,
-                NamedNode::new_unchecked(get_required_str(self.lookup, datatype_id)?),
-            )
-            .into()),
-            EncodedTerm::BooleanLiteral(value) => Ok(Literal::from(*value).into()),
-            EncodedTerm::FloatLiteral(value) => Ok(Literal::from(*value).into()),
-            EncodedTerm::DoubleLiteral(value) => Ok(Literal::from(*value).into()),
-            EncodedTerm::IntegerLiteral(value) => Ok(Literal::from(*value).into()),
-            EncodedTerm::DecimalLiteral(value) => Ok(Literal::from(*value).into()),
-            EncodedTerm::DateTimeLiteral(value) => Ok(Literal::from(*value).into()),
-            EncodedTerm::DateLiteral(value) => Ok(Literal::from(*value).into()),
-            EncodedTerm::TimeLiteral(value) => Ok(Literal::from(*value).into()),
-            EncodedTerm::GYearMonthLiteral(value) => Ok(Literal::from(*value).into()),
-            EncodedTerm::GYearLiteral(value) => Ok(Literal::from(*value).into()),
-            EncodedTerm::GMonthDayLiteral(value) => Ok(Literal::from(*value).into()),
-            EncodedTerm::GDayLiteral(value) => Ok(Literal::from(*value).into()),
-            EncodedTerm::GMonthLiteral(value) => Ok(Literal::from(*value).into()),
-            EncodedTerm::DurationLiteral(value) => Ok(Literal::from(*value).into()),
-            EncodedTerm::YearMonthDurationLiteral(value) => Ok(Literal::from(*value).into()),
-            EncodedTerm::DayTimeDurationLiteral(value) => Ok(Literal::from(*value).into()),
-            EncodedTerm::Triple(triple) => Ok(self.decode_triple(triple)?.into()),
-        }
-    }
+pub trait Decoder: StrLookup {
+    fn decode_term(&self, encoded: &EncodedTerm) -> Result<Term, StorageError>;
 
-    pub fn decode_subject(&self, encoded: &EncodedTerm) -> Result<Subject, StorageError> {
+    fn decode_subject(&self, encoded: &EncodedTerm) -> Result<Subject, StorageError> {
         match self.decode_term(encoded)? {
             Term::NamedNode(named_node) => Ok(named_node.into()),
             Term::BlankNode(blank_node) => Ok(blank_node.into()),
@@ -892,7 +872,7 @@ impl<'a, S: StrLookup> TermDecoder<'a, S> {
         }
     }
 
-    pub fn decode_named_or_blank_node(
+    fn decode_named_or_blank_node(
         &self,
         encoded: &EncodedTerm,
     ) -> Result<NamedOrBlankNode, StorageError> {
@@ -910,7 +890,7 @@ impl<'a, S: StrLookup> TermDecoder<'a, S> {
         }
     }
 
-    pub fn decode_named_node(&self, encoded: &EncodedTerm) -> Result<NamedNode, StorageError> {
+    fn decode_named_node(&self, encoded: &EncodedTerm) -> Result<NamedNode, StorageError> {
         match self.decode_term(encoded)? {
             Term::NamedNode(named_node) => Ok(named_node),
             Term::BlankNode(_) => Err(CorruptionError::msg(
@@ -926,7 +906,7 @@ impl<'a, S: StrLookup> TermDecoder<'a, S> {
         }
     }
 
-    pub fn decode_triple(&self, encoded: &EncodedTriple) -> Result<Triple, StorageError> {
+    fn decode_triple(&self, encoded: &EncodedTriple) -> Result<Triple, StorageError> {
         Ok(Triple::new(
             self.decode_subject(&encoded.subject)?,
             self.decode_named_node(&encoded.predicate)?,
@@ -934,7 +914,7 @@ impl<'a, S: StrLookup> TermDecoder<'a, S> {
         ))
     }
 
-    pub fn decode_quad(&self, encoded: &EncodedQuad) -> Result<Quad, StorageError> {
+    fn decode_quad(&self, encoded: &EncodedQuad) -> Result<Quad, StorageError> {
         Ok(Quad::new(
             self.decode_subject(&encoded.subject)?,
             self.decode_named_node(&encoded.predicate)?,
@@ -961,11 +941,91 @@ impl<'a, S: StrLookup> TermDecoder<'a, S> {
     }
 }
 
+impl<S: StrLookup> Decoder for S {
+    fn decode_term(&self, encoded: &EncodedTerm) -> Result<Term, StorageError> {
+        match encoded {
+            EncodedTerm::DefaultGraph => {
+                Err(CorruptionError::msg("The default graph tag is not a valid term").into())
+            }
+            EncodedTerm::NamedNode { iri_id } => {
+                Ok(NamedNode::new_unchecked(get_required_str(self, iri_id)?).into())
+            }
+            EncodedTerm::NumericalBlankNode { id } => Ok(BlankNode::new_from_unique_id(*id).into()),
+            EncodedTerm::SmallBlankNode(id) => Ok(BlankNode::new_unchecked(id.as_str()).into()),
+            EncodedTerm::BigBlankNode { id_id } => {
+                Ok(BlankNode::new_unchecked(get_required_str(self, id_id)?).into())
+            }
+            EncodedTerm::SmallStringLiteral(value) => {
+                Ok(Literal::new_simple_literal(*value).into())
+            }
+            EncodedTerm::BigStringLiteral { value_id } => {
+                Ok(Literal::new_simple_literal(get_required_str(self, value_id)?).into())
+            }
+            EncodedTerm::SmallSmallLangStringLiteral { value, language } => {
+                Ok(Literal::new_language_tagged_literal_unchecked(*value, *language).into())
+            }
+            EncodedTerm::SmallBigLangStringLiteral { value, language_id } => {
+                Ok(Literal::new_language_tagged_literal_unchecked(
+                    *value,
+                    get_required_str(self, language_id)?,
+                )
+                .into())
+            }
+            EncodedTerm::BigSmallLangStringLiteral { value_id, language } => {
+                Ok(Literal::new_language_tagged_literal_unchecked(
+                    get_required_str(self, value_id)?,
+                    *language,
+                )
+                .into())
+            }
+            EncodedTerm::BigBigLangStringLiteral {
+                value_id,
+                language_id,
+            } => Ok(Literal::new_language_tagged_literal_unchecked(
+                get_required_str(self, value_id)?,
+                get_required_str(self, language_id)?,
+            )
+            .into()),
+            EncodedTerm::SmallTypedLiteral { value, datatype_id } => {
+                Ok(Literal::new_typed_literal(
+                    *value,
+                    NamedNode::new_unchecked(get_required_str(self, datatype_id)?),
+                )
+                .into())
+            }
+            EncodedTerm::BigTypedLiteral {
+                value_id,
+                datatype_id,
+            } => Ok(Literal::new_typed_literal(
+                get_required_str(self, value_id)?,
+                NamedNode::new_unchecked(get_required_str(self, datatype_id)?),
+            )
+            .into()),
+            EncodedTerm::BooleanLiteral(value) => Ok(Literal::from(*value).into()),
+            EncodedTerm::FloatLiteral(value) => Ok(Literal::from(*value).into()),
+            EncodedTerm::DoubleLiteral(value) => Ok(Literal::from(*value).into()),
+            EncodedTerm::IntegerLiteral(value) => Ok(Literal::from(*value).into()),
+            EncodedTerm::DecimalLiteral(value) => Ok(Literal::from(*value).into()),
+            EncodedTerm::DateTimeLiteral(value) => Ok(Literal::from(*value).into()),
+            EncodedTerm::DateLiteral(value) => Ok(Literal::from(*value).into()),
+            EncodedTerm::TimeLiteral(value) => Ok(Literal::from(*value).into()),
+            EncodedTerm::GYearMonthLiteral(value) => Ok(Literal::from(*value).into()),
+            EncodedTerm::GYearLiteral(value) => Ok(Literal::from(*value).into()),
+            EncodedTerm::GMonthDayLiteral(value) => Ok(Literal::from(*value).into()),
+            EncodedTerm::GDayLiteral(value) => Ok(Literal::from(*value).into()),
+            EncodedTerm::GMonthLiteral(value) => Ok(Literal::from(*value).into()),
+            EncodedTerm::DurationLiteral(value) => Ok(Literal::from(*value).into()),
+            EncodedTerm::YearMonthDurationLiteral(value) => Ok(Literal::from(*value).into()),
+            EncodedTerm::DayTimeDurationLiteral(value) => Ok(Literal::from(*value).into()),
+            EncodedTerm::Triple(triple) => Ok(self.decode_triple(triple)?.into()),
+        }
+    }
+}
+
 fn get_required_str<L: StrLookup>(lookup: &L, id: &StrHash) -> Result<String, StorageError> {
     Ok(lookup.get_str(id)?.ok_or_else(|| {
         CorruptionError::new(format!(
-            "Not able to find the string with id {:?} in the string store",
-            id
+            "Not able to find the string with id {id:?} in the string store"
         ))
     })?)
 }

lib/oxigraph/src/storage/small_string.rs

@@ -1,11 +1,9 @@
 use std::borrow::Borrow;
 use std::cmp::Ordering;
-use std::error::Error;
-use std::fmt;
 use std::hash::{Hash, Hasher};
 use std::ops::Deref;
-use std::str;
 use std::str::{FromStr, Utf8Error};
+use std::{fmt, str};
 
 /// A small inline string
 #[derive(Clone, Copy, Default)]
@@ -46,10 +44,8 @@ impl SmallString {
     #[inline]
     #[allow(unsafe_code)]
     pub fn as_str(&self) -> &str {
-        unsafe {
-            // safe because we ensured it in constructors
-            str::from_utf8_unchecked(self.as_bytes())
-        }
+        // SAFETY: safe because we ensured it in constructors
+        unsafe { str::from_utf8_unchecked(self.as_bytes()) }
     }
 
     #[inline]
@@ -67,7 +63,7 @@ impl Deref for SmallString {
     type Target = str;
 
     #[inline]
-    fn deref(&self) -> &str {
+    fn deref(&self) -> &Self::Target {
         self.as_str()
     }
 }
@@ -103,7 +99,7 @@ impl fmt::Display for SmallString {
 impl PartialEq for SmallString {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
-        self.as_str().eq(&**other)
+        self.as_str() == other.as_str()
     }
 }
 
@@ -112,7 +108,7 @@ impl Eq for SmallString {}
 impl PartialOrd for SmallString {
     #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.as_str().partial_cmp(other.as_str())
+        Some(self.cmp(other))
     }
 }
 
@@ -148,17 +144,17 @@ impl FromStr for SmallString {
     type Err = BadSmallStringError;
 
     #[inline]
-    fn from_str(value: &str) -> Result<Self, BadSmallStringError> {
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
         if value.len() <= 15 {
             let mut inner = [0; 16];
             inner[..value.len()].copy_from_slice(value.as_bytes());
             inner[15] = value
                 .len()
                 .try_into()
-                .map_err(|_| BadSmallStringError::TooLong(value.len()))?;
+                .map_err(|_| Self::Err::TooLong(value.len()))?;
             Ok(Self { inner })
         } else {
-            Err(BadSmallStringError::TooLong(value.len()))
+            Err(Self::Err::TooLong(value.len()))
         }
     }
 }
@@ -167,37 +163,15 @@ impl<'a> TryFrom<&'a str> for SmallString {
     type Error = BadSmallStringError;
 
     #[inline]
-    fn try_from(value: &'a str) -> Result<Self, BadSmallStringError> {
+    fn try_from(value: &'a str) -> Result<Self, Self::Error> {
         Self::from_str(value)
     }
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, thiserror::Error)]
 pub enum BadSmallStringError {
+    #[error("small strings could only contain at most 15 characters, found {0}")]
     TooLong(usize),
-    BadUtf8(Utf8Error),
-}
-
-impl fmt::Display for BadSmallStringError {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::TooLong(v) => write!(
-                f,
-                "small strings could only contain at most 15 characters, found {}",
-                v
-            ),
-            Self::BadUtf8(e) => e.fmt(f),
-        }
-    }
-}
-
-impl Error for BadSmallStringError {
-    #[inline]
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        match self {
-            Self::TooLong(_) => None,
-            Self::BadUtf8(e) => Some(e),
-        }
-    }
+    #[error(transparent)]
+    BadUtf8(#[from] Utf8Error),
 }

lib/oxigraph/tests/store.rs

@@ -1,16 +1,29 @@
-use oxigraph::io::{DatasetFormat, GraphFormat};
+#![cfg(test)]
+#![allow(clippy::panic_in_result_fn)]
+
+use oxigraph::io::RdfFormat;
 use oxigraph::model::vocab::{rdf, xsd};
 use oxigraph::model::*;
 use oxigraph::store::Store;
+#[cfg(all(not(target_family = "wasm")))]
 use rand::random;
+#[cfg(all(not(target_family = "wasm")))]
 use std::env::temp_dir;
 use std::error::Error;
-use std::fs::{create_dir, remove_dir_all, File};
-use std::io::{Cursor, Write};
+#[cfg(all(not(target_family = "wasm")))]
+use std::fs::{create_dir_all, remove_dir_all, File};
+#[cfg(all(not(target_family = "wasm")))]
+use std::io::Write;
+#[cfg(all(not(target_family = "wasm")))]
+use std::iter::empty;
+#[cfg(all(target_os = "linux"))]
 use std::iter::once;
-use std::path::PathBuf;
+#[cfg(all(not(target_family = "wasm")))]
+use std::path::{Path, PathBuf};
+#[cfg(all(target_os = "linux"))]
 use std::process::Command;
 
+#[allow(clippy::non_ascii_literal)]
 const DATA: &str = r#"
 @prefix schema: <http://schema.org/> .
 @prefix wd: <http://www.wikidata.org/entity/> .
@@ -24,6 +37,8 @@ wd:Q90 a schema:City ;
     schema:url "https://www.paris.fr/"^^xsd:anyURI ;
     schema:postalCode "75001" .
 "#;
+
+#[allow(clippy::non_ascii_literal)]
 const GRAPH_DATA: &str = r#"
 @prefix schema: <http://schema.org/> .
 @prefix wd: <http://www.wikidata.org/entity/> .
@@ -63,7 +78,7 @@ fn quads(graph_name: impl Into<GraphNameRef<'static>>) -> Vec<QuadRef<'static>>
         QuadRef::new(
             paris,
             name,
-            LiteralRef::new_language_tagged_literal_unchecked("la ville lumière", "fr"),
+            LiteralRef::new_language_tagged_literal_unchecked("la ville lumi\u{E8}re", "fr"),
             graph_name,
         ),
         QuadRef::new(paris, country, france, graph_name),
@@ -97,12 +112,7 @@ fn quads(graph_name: impl Into<GraphNameRef<'static>>) -> Vec<QuadRef<'static>>
 #[test]
 fn test_load_graph() -> Result<(), Box<dyn Error>> {
     let store = Store::new()?;
-    store.load_graph(
-        Cursor::new(DATA),
-        GraphFormat::Turtle,
-        GraphNameRef::DefaultGraph,
-        None,
-    )?;
+    store.load_from_read(RdfFormat::Turtle, DATA.as_bytes())?;
     for q in quads(GraphNameRef::DefaultGraph) {
         assert!(store.contains(q)?);
     }
@@ -111,14 +121,12 @@ fn test_load_graph() -> Result<(), Box<dyn Error>> {
 }
 
 #[test]
+#[cfg(all(not(target_family = "wasm")))]
 fn test_bulk_load_graph() -> Result<(), Box<dyn Error>> {
     let store = Store::new()?;
-    store.bulk_loader().load_graph(
-        Cursor::new(DATA),
-        GraphFormat::Turtle,
-        GraphNameRef::DefaultGraph,
-        None,
-    )?;
+    store
+        .bulk_loader()
+        .load_from_read(RdfFormat::Turtle, DATA.as_bytes())?;
     for q in quads(GraphNameRef::DefaultGraph) {
         assert!(store.contains(q)?);
     }
@@ -127,13 +135,12 @@ fn test_bulk_load_graph() -> Result<(), Box<dyn Error>> {
 }
 
 #[test]
+#[cfg(all(not(target_family = "wasm")))]
 fn test_bulk_load_graph_lenient() -> Result<(), Box<dyn Error>> {
     let store = Store::new()?;
-    store.bulk_loader().on_parse_error(|_| Ok(())).load_graph(
-        Cursor::new(b"<http://example.com> <http://example.com> <http://example.com##> .\n<http://example.com> <http://example.com> <http://example.com> ."),
-        GraphFormat::NTriples,
-        GraphNameRef::DefaultGraph,
-        None,
+    store.bulk_loader().on_parse_error(|_| Ok(())).load_from_read(
+        RdfFormat::NTriples,
+        b"<http://example.com> <http://example.com> <http://example.com##> .\n<http://example.com> <http://example.com> <http://example.com> .".as_slice(),
     )?;
     assert_eq!(store.len()?, 1);
     assert!(store.contains(QuadRef::new(
@@ -146,10 +153,20 @@ fn test_bulk_load_graph_lenient() -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
+#[test]
+#[cfg(all(not(target_family = "wasm")))]
+fn test_bulk_load_empty() -> Result<(), Box<dyn Error>> {
+    let store = Store::new()?;
+    store.bulk_loader().load_quads(empty::<Quad>())?;
+    assert!(store.is_empty()?);
+    store.validate()?;
+    Ok(())
+}
+
 #[test]
 fn test_load_dataset() -> Result<(), Box<dyn Error>> {
     let store = Store::new()?;
-    store.load_dataset(Cursor::new(GRAPH_DATA), DatasetFormat::TriG, None)?;
+    store.load_from_read(RdfFormat::TriG, GRAPH_DATA.as_bytes())?;
     for q in quads(NamedNodeRef::new_unchecked(
         "http://www.wikidata.org/wiki/Special:EntityData/Q90",
     )) {
@@ -160,11 +177,12 @@ fn test_load_dataset() -> Result<(), Box<dyn Error>> {
 }
 
 #[test]
+#[cfg(all(not(target_family = "wasm")))]
 fn test_bulk_load_dataset() -> Result<(), Box<dyn Error>> {
-    let store = Store::new().unwrap();
+    let store = Store::new()?;
     store
         .bulk_loader()
-        .load_dataset(Cursor::new(GRAPH_DATA), DatasetFormat::TriG, None)?;
+        .load_from_read(RdfFormat::TriG, GRAPH_DATA.as_bytes())?;
     let graph_name =
         NamedNodeRef::new_unchecked("http://www.wikidata.org/wiki/Special:EntityData/Q90");
     for q in quads(graph_name) {
@@ -179,11 +197,9 @@ fn test_bulk_load_dataset() -> Result<(), Box<dyn Error>> {
 fn test_load_graph_generates_new_blank_nodes() -> Result<(), Box<dyn Error>> {
     let store = Store::new()?;
     for _ in 0..2 {
-        store.load_graph(
-            Cursor::new("_:a <http://example.com/p> <http://example.com/p> ."),
-            GraphFormat::NTriples,
-            GraphNameRef::DefaultGraph,
-            None,
+        store.load_from_read(
+            RdfFormat::NTriples,
+            "_:a <http://example.com/p> <http://example.com/p> .".as_bytes(),
         )?;
     }
     assert_eq!(store.len()?, 2);
@@ -198,11 +214,7 @@ fn test_dump_graph() -> Result<(), Box<dyn Error>> {
     }
 
     let mut buffer = Vec::new();
-    store.dump_graph(
-        &mut buffer,
-        GraphFormat::NTriples,
-        GraphNameRef::DefaultGraph,
-    )?;
+    store.dump_graph_to_write(GraphNameRef::DefaultGraph, RdfFormat::NTriples, &mut buffer)?;
     assert_eq!(
         buffer.into_iter().filter(|c| *c == b'\n').count(),
         NUMBER_OF_TRIPLES
@@ -217,8 +229,7 @@ fn test_dump_dataset() -> Result<(), Box<dyn Error>> {
         store.insert(q)?;
     }
 
-    let mut buffer = Vec::new();
-    store.dump_dataset(&mut buffer, DatasetFormat::NQuads)?;
+    let buffer = store.dump_to_write(RdfFormat::NQuads, Vec::new())?;
     assert_eq!(
         buffer.into_iter().filter(|c| *c == b'\n').count(),
         NUMBER_OF_TRIPLES
@@ -229,24 +240,25 @@ fn test_dump_dataset() -> Result<(), Box<dyn Error>> {
 #[test]
 fn test_snapshot_isolation_iterator() -> Result<(), Box<dyn Error>> {
     let quad = QuadRef::new(
-        NamedNodeRef::new_unchecked("http://example.com/s"),
-        NamedNodeRef::new_unchecked("http://example.com/p"),
-        NamedNodeRef::new_unchecked("http://example.com/o"),
-        NamedNodeRef::new_unchecked("http://www.wikidata.org/wiki/Special:EntityData/Q90"),
+        NamedNodeRef::new("http://example.com/s")?,
+        NamedNodeRef::new("http://example.com/p")?,
+        NamedNodeRef::new("http://example.com/o")?,
+        NamedNodeRef::new("http://www.wikidata.org/wiki/Special:EntityData/Q90")?,
     );
     let store = Store::new()?;
     store.insert(quad)?;
     let iter = store.iter();
     store.remove(quad)?;
-    store.validate()?;
     assert_eq!(
         iter.collect::<Result<Vec<_>, _>>()?,
         vec![quad.into_owned()]
     );
+    store.validate()?;
     Ok(())
 }
 
 #[test]
+#[cfg(all(not(target_family = "wasm")))]
 fn test_bulk_load_on_existing_delete_overrides_the_delete() -> Result<(), Box<dyn Error>> {
     let quad = QuadRef::new(
         NamedNodeRef::new_unchecked("http://example.com/s"),
@@ -262,9 +274,10 @@ fn test_bulk_load_on_existing_delete_overrides_the_delete() -> Result<(), Box<dy
 }
 
 #[test]
+#[cfg(all(not(target_family = "wasm")))]
 fn test_open_bad_dir() -> Result<(), Box<dyn Error>> {
     let dir = TempDir::default();
-    create_dir(&dir.0)?;
+    create_dir_all(&dir.0)?;
     {
         File::create(dir.0.join("CURRENT"))?.write_all(b"foo")?;
     }
@@ -273,65 +286,84 @@ fn test_open_bad_dir() -> Result<(), Box<dyn Error>> {
 }
 
 #[test]
-#[cfg(target_os = "linux")]
+#[cfg(all(target_os = "linux"))]
 fn test_bad_stt_open() -> Result<(), Box<dyn Error>> {
     let dir = TempDir::default();
     let store = Store::open(&dir.0)?;
     remove_dir_all(&dir.0)?;
-    assert!(store
+    store
         .bulk_loader()
-        .load_quads(once(Quad {
-            subject: NamedNode::new_unchecked("http://example.com/s").into(),
-            predicate: NamedNode::new_unchecked("http://example.com/p"),
-            object: NamedNode::new_unchecked("http://example.com/o").into(),
-            graph_name: GraphName::DefaultGraph
-        }))
-        .is_err());
+        .load_quads(once(Quad::new(
+            NamedNode::new_unchecked("http://example.com/s"),
+            NamedNode::new_unchecked("http://example.com/p"),
+            NamedNode::new_unchecked("http://example.com/o"),
+            GraphName::DefaultGraph,
+        )))
+        .unwrap_err();
     Ok(())
 }
 
-#[test]
-fn test_backup() -> Result<(), Box<dyn Error>> {
-    let quad = QuadRef {
-        subject: NamedNodeRef::new_unchecked("http://example.com/s").into(),
-        predicate: NamedNodeRef::new_unchecked("http://example.com/p"),
-        object: NamedNodeRef::new_unchecked("http://example.com/o").into(),
-        graph_name: GraphNameRef::DefaultGraph,
-    };
-    let store_dir = TempDir::default();
-    let backup_dir = TempDir::default();
+// #[test]
+// #[cfg(all(not(target_family = "wasm")))]
+// fn test_backup() -> Result<(), Box<dyn Error>> {
+//     let quad = QuadRef::new(
+//         NamedNodeRef::new_unchecked("http://example.com/s"),
+//         NamedNodeRef::new_unchecked("http://example.com/p"),
+//         NamedNodeRef::new_unchecked("http://example.com/o"),
+//         GraphNameRef::DefaultGraph,
+//     );
+//     let store_dir = TempDir::default();
+//     let backup_from_rw_dir = TempDir::default();
+//     let backup_from_ro_dir = TempDir::default();
+//     let backup_from_secondary_dir = TempDir::default();
 
-    let store = Store::open(&store_dir.0)?;
-    store.insert(quad)?;
-    store.backup(&backup_dir.0)?;
-    store.remove(quad)?;
+//     let store = Store::open(&store_dir)?;
+//     store.insert(quad)?;
+//     let secondary_store = Store::open_secondary(&store_dir)?;
+//     store.flush()?;
 
-    assert!(!store.contains(quad)?);
-    let backup = Store::open(&backup_dir.0)?;
-    backup.validate()?;
-    assert!(backup.contains(quad)?);
-    Ok(())
-}
+//     store.backup(&backup_from_rw_dir)?;
+//     secondary_store.backup(&backup_from_secondary_dir)?;
+//     store.remove(quad)?;
+//     assert!(!store.contains(quad)?);
+
+//     let backup_from_rw = Store::open_read_only(&backup_from_rw_dir.0)?;
+//     backup_from_rw.validate()?;
+//     assert!(backup_from_rw.contains(quad)?);
+//     backup_from_rw.backup(&backup_from_ro_dir)?;
+
+//     let backup_from_ro = Store::open_read_only(&backup_from_ro_dir.0)?;
+//     backup_from_ro.validate()?;
+//     assert!(backup_from_ro.contains(quad)?);
+
+//     let backup_from_secondary = Store::open_read_only(&backup_from_secondary_dir.0)?;
+//     backup_from_secondary.validate()?;
+//     assert!(backup_from_secondary.contains(quad)?);
+
+//     Ok(())
+// }
 
 #[test]
+#[cfg(all(not(target_family = "wasm")))]
 fn test_bad_backup() -> Result<(), Box<dyn Error>> {
     let store_dir = TempDir::default();
     let backup_dir = TempDir::default();
 
-    create_dir(&backup_dir.0)?;
-    assert!(Store::open(&store_dir.0)?.backup(&backup_dir.0).is_err());
+    create_dir_all(&backup_dir.0)?;
+    Store::open(&store_dir)?.backup(&backup_dir.0).unwrap_err();
     Ok(())
 }
 
 #[test]
+#[cfg(all(not(target_family = "wasm")))]
 fn test_backup_on_in_memory() -> Result<(), Box<dyn Error>> {
     let backup_dir = TempDir::default();
-    assert!(Store::new()?.backup(&backup_dir.0).is_err());
+    Store::new()?.backup(&backup_dir).unwrap_err();
     Ok(())
 }
 
 #[test]
-#[cfg(target_os = "linux")]
+#[cfg(all(target_os = "linux"))]
 fn test_backward_compatibility() -> Result<(), Box<dyn Error>> {
     // We run twice to check if data is properly saved and closed
     for _ in 0..2 {
@@ -354,28 +386,157 @@ fn test_backward_compatibility() -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
+// #[test]
+// #[cfg(all(not(target_family = "wasm")))]
+// fn test_secondary() -> Result<(), Box<dyn Error>> {
+//     let quad = QuadRef::new(
+//         NamedNodeRef::new_unchecked("http://example.com/s"),
+//         NamedNodeRef::new_unchecked("http://example.com/p"),
+//         NamedNodeRef::new_unchecked("http://example.com/o"),
+//         GraphNameRef::DefaultGraph,
+//     );
+//     let primary_dir = TempDir::default();
+
+//     // We open the store
+//     let primary = Store::open(&primary_dir)?;
+//     let secondary = Store::open_secondary(&primary_dir)?;
+
+//     // We insert a quad
+//     primary.insert(quad)?;
+//     primary.flush()?;
+
+//     // It is readable from both stores
+//     for store in &[&primary, &secondary] {
+//         assert!(store.contains(quad)?);
+//         assert_eq!(
+//             store.iter().collect::<Result<Vec<_>, _>>()?,
+//             vec![quad.into_owned()]
+//         );
+//     }
+
+//     // We validate the states
+//     primary.validate()?;
+//     secondary.validate()?;
+
+//     // We close the primary store and remove its content
+//     drop(primary);
+//     remove_dir_all(&primary_dir)?;
+
+//     // We secondary store is still readable
+//     assert!(secondary.contains(quad)?);
+//     secondary.validate()?;
+
+//     Ok(())
+// }
+
+// #[test]
+// #[cfg(all(not(target_family = "wasm")))]
+// fn test_open_secondary_bad_dir() -> Result<(), Box<dyn Error>> {
+//     let primary_dir = TempDir::default();
+//     create_dir_all(&primary_dir.0)?;
+//     {
+//         File::create(primary_dir.0.join("CURRENT"))?.write_all(b"foo")?;
+//     }
+//     assert!(Store::open_secondary(&primary_dir).is_err());
+//     Ok(())
+// }
+
+#[test]
+#[cfg(all(not(target_family = "wasm")))]
+fn test_read_only() -> Result<(), Box<dyn Error>> {
+    let s = NamedNodeRef::new_unchecked("http://example.com/s");
+    let p = NamedNodeRef::new_unchecked("http://example.com/p");
+    let first_quad = QuadRef::new(
+        s,
+        p,
+        NamedNodeRef::new_unchecked("http://example.com/o"),
+        GraphNameRef::DefaultGraph,
+    );
+    let second_quad = QuadRef::new(
+        s,
+        p,
+        NamedNodeRef::new_unchecked("http://example.com/o2"),
+        GraphNameRef::DefaultGraph,
+    );
+    let store_dir = TempDir::default();
+
+    // We write to the store and close it
+    {
+        let read_write = Store::open(&store_dir)?;
+        read_write.insert(first_quad)?;
+        read_write.flush()?;
+    }
+
+    // We open as read-only
+    let read_only = Store::open_read_only(&store_dir, None)?;
+    assert!(read_only.contains(first_quad)?);
+    assert_eq!(
+        read_only.iter().collect::<Result<Vec<_>, _>>()?,
+        vec![first_quad.into_owned()]
+    );
+    read_only.validate()?;
+
+    // We open as read-write again
+    let read_write = Store::open(&store_dir)?;
+    read_write.insert(second_quad)?;
+    read_write.flush()?;
+    read_write.optimize()?; // Makes sure it's well flushed
+
+    // The new quad is in the read-write instance but not the read-only instance
+    assert!(read_write.contains(second_quad)?);
+    assert!(!read_only.contains(second_quad)?);
+    read_only.validate()?;
+
+    Ok(())
+}
+
+#[test]
+#[cfg(all(not(target_family = "wasm")))]
+fn test_open_read_only_bad_dir() -> Result<(), Box<dyn Error>> {
+    let dir = TempDir::default();
+    create_dir_all(&dir.0)?;
+    {
+        File::create(dir.0.join("CURRENT"))?.write_all(b"foo")?;
+    }
+    assert!(Store::open_read_only(&dir, None).is_err());
+    Ok(())
+}
+
+#[cfg(all(target_os = "linux"))]
 fn reset_dir(dir: &str) -> Result<(), Box<dyn Error>> {
     assert!(Command::new("git")
-        .args(&["clean", "-fX", dir])
+        .args(["clean", "-fX", dir])
         .status()?
         .success());
     assert!(Command::new("git")
-        .args(&["checkout", "HEAD", "--", dir])
+        .args(["checkout", "HEAD", "--", dir])
         .status()?
         .success());
     Ok(())
 }
 
+#[cfg(all(not(target_family = "wasm")))]
 struct TempDir(PathBuf);
 
+#[cfg(all(not(target_family = "wasm")))]
 impl Default for TempDir {
     fn default() -> Self {
         Self(temp_dir().join(format!("oxigraph-test-{}", random::<u128>())))
     }
 }
 
+#[cfg(all(not(target_family = "wasm")))]
+impl AsRef<Path> for TempDir {
+    fn as_ref(&self) -> &Path {
+        &self.0
+    }
+}
+
+#[cfg(all(not(target_family = "wasm")))]
 impl Drop for TempDir {
     fn drop(&mut self) {
-        let _ = remove_dir_all(&self.0);
+        if self.0.is_dir() {
+            remove_dir_all(&self.0).unwrap();
+        }
     }
 }

lib/oxrdf/Cargo.toml

@@ -1,26 +1,33 @@
 [package]
 name = "oxrdf"
-version = "0.1.0"
-authors = ["Tpt <thomas@pellissier-tanon.fr>"]
-license = "MIT OR Apache-2.0"
+version = "0.2.0-alpha.4"
+authors.workspace = true
+license.workspace = true
 readme = "README.md"
 keywords = ["RDF"]
 repository = "https://github.com/oxigraph/oxigraph/tree/main/lib/oxrdf"
-homepage = "https://oxigraph.org/"
 description = """
 A library providing basic data structures related to RDF
 """
-edition = "2021"
+documentation = "https://docs.rs/oxrdf"
+edition.workspace = true
+rust-version.workspace = true
 
 [features]
 default = []
 rdf-star = []
 
 [dependencies]
-rand = "0.8"
-oxilangtag = "0.1"
-oxiri = "0.2"
-lasso = { version = "0.6", features = ["inline-more"] }
+oxilangtag.workspace = true
+oxiri.workspace = true
+oxsdatatypes = { workspace = true, optional = true }
+rand.workspace = true
+thiserror.workspace = true
+serde.workspace = true
+
+[lints]
+workspace = true
 
 [package.metadata.docs.rs]
 all-features = true
+rustdoc-args = ["--cfg", "docsrs"]