diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c018e5021..3816f720a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -10,16 +10,16 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Set up JDK 17
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
         with:
           distribution: "temurin"
           java-version: 17
 
       - name: Cache Maven dependencies
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: ~/.m2/repository
           key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
@@ -32,17 +32,17 @@ jobs:
     runs-on: ubuntu-latest
     needs: format
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 0
       - name: Set up Maven Central Repository
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
         with:
           java-version: 17
           distribution: "adopt"
       # Also exclude vtl-prov because of vtl-sdmx scope test dependency
       - name: Test
-        run: mvn test -pl '!vtl-sdmx,!vtl-prov'
+        run: mvn install -pl vtl-parser && mvn test -pl '!vtl-sdmx,!vtl-prov'
   test:
     name: Run Trevas tests
     if: (github.repository != 'InseeFr/Trevas' &&
@@ -53,15 +53,15 @@ jobs:
     runs-on: ubuntu-latest
     needs: format
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 0
       - name: Set up Maven Central Repository
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
         with:
           java-version: 17
           distribution: "adopt"
-      - uses: s4u/maven-settings-action@v3.0.0
+      - uses: s4u/maven-settings-action@v4.0.0
         with:
           githubServer: false
           servers: |
@@ -71,22 +71,70 @@ jobs:
                 "password": "${{ secrets.GH_PACKAGES_PASSWORD }}"
             }]
       - name: Test
-        run: mvn test
+        run: mvn install -pl vtl-parser && mvn test
+
+  spark-integration:
+    name: Spark ${{ matrix.spark-label }}
+    runs-on: ubuntu-latest
+    needs: format
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - module: vtl-spark
+            spark-label: "3.x (Scala 2.12)"
+            extra-args: ""
+          - module: vtl-spark4
+            spark-label: "4.x (Scala 2.13)"
+            extra-args: ""
+          - module: vtl-prov
+            spark-label: "vtl-prov + Spark 4 (tests)"
+            extra-args: "-Pspark4-tests"
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: Set up JDK 17
+        uses: actions/setup-java@v5
+        with:
+          java-version: 17
+          distribution: temurin
+      - name: Cache Maven dependencies
+        uses: actions/cache@v5
+        with:
+          path: ~/.m2/repository
+          key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
+          restore-keys: |
+            ${{ runner.os }}-maven-
+      - uses: s4u/maven-settings-action@v4.0.0
+        with:
+          githubServer: false
+          servers: |
+            [{
+                "id": "Github",
+                "username": "${{ secrets.GH_PACKAGES_USERNAME }}",
+                "password": "${{ secrets.GH_PACKAGES_PASSWORD }}"
+            }]
+      # Install shaded vtl-parser first, then exclude it from the reactor so dependent
+      # modules resolve the installed jar (JPMS fr.insee.vtl.parser.shaded), not target/classes.
+      - name: Test ${{ matrix.module }} (and upstream modules)
+        run: mvn install -pl vtl-parser -DskipTests && mvn -B test -pl ${{ matrix.module }} -am --projects '!vtl-parser' ${{ matrix.extra-args }}
+
   package:
     name: Package Trevas modules
     # Filter thanks to test job
     runs-on: ubuntu-latest
-    needs: test
+    needs: [ test, spark-integration ]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 0
       - name: Set up Maven Central Repository
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
         with:
           java-version: 17
           distribution: "adopt"
-      - uses: s4u/maven-settings-action@v3.0.0
+      - uses: s4u/maven-settings-action@v4.0.0
         with:
           githubServer: false
           servers: |
@@ -134,16 +182,16 @@ jobs:
     name: Publish Trevas modules on Maven
     if: startsWith(github.event.ref, 'refs/tags/v')
     # Temp update because of sonar token issue
-    needs: test
+    needs: [ test, spark-integration ]
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - name: Import GPG Key
-        uses: crazy-max/ghaction-import-gpg@v1
+        uses: crazy-max/ghaction-import-gpg@v7
         env:
           GPG_PRIVATE_KEY: ${{ secrets.MAVEN_GPG_PRIVATE_KEY }}
           PASSPHRASE: ${{ secrets.MAVEN_GPG_PASSPHRASE }}
-      - uses: s4u/maven-settings-action@v3.0.0
+      - uses: s4u/maven-settings-action@v4.0.0
         with:
           githubServer: false
           servers: |
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 26b09d597..cff15e0f8 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -10,8 +10,8 @@ jobs:
     if: github.repository == 'inseefr/trevas'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v5
         with:
           node-version: 24
       - name: Install dependencies
@@ -21,7 +21,7 @@ jobs:
         run: yarn build
         working-directory: docs
       - name: Deploy to GitHub Pages
-        uses: peaceiris/actions-gh-pages@v3
+        uses: peaceiris/actions-gh-pages@v4
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           # Build output to publish to the `gh-pages` branch:
diff --git a/.github/workflows/tck-vtl-tf.yml b/.github/workflows/tck-vtl-tf-spark3.yml
similarity index 58%
rename from .github/workflows/tck-vtl-tf.yml
rename to .github/workflows/tck-vtl-tf-spark3.yml
index c740d5a48..0bd571b06 100644
--- a/.github/workflows/tck-vtl-tf.yml
+++ b/.github/workflows/tck-vtl-tf-spark3.yml
@@ -1,4 +1,4 @@
-name: Run VTL TF TCK
+name: Run VTL TF TCK (Spark 3)
 
 on:
   push:
@@ -7,12 +7,15 @@ on:
     branches: [ master, develop ]
 
 jobs:
-  test:
+  tck-spark3:
+    name: TCK VTL v2.1 (Spark 3)
     runs-on: ubuntu-latest
+    env:
+      TCK_REPORT_TITLE: 'TCK VTL v2.1 (Spark 3)'
 
     steps:
       - name: Checkout main project
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
 
@@ -20,7 +23,7 @@ jobs:
         run: git clone --branch fix/tck-2.1 https://github.com/sdmx-twg/vtl.git
 
       - name: Install Python 3
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: '3.11'
 
@@ -34,12 +37,12 @@ jobs:
           mv vtl/tck/v2.1.zip coverage/src/main/resources/
 
       - name: Set up Java
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
-      - uses: s4u/maven-settings-action@v3.0.0
+      - uses: s4u/maven-settings-action@v4.0.0
         with:
           githubServer: false
           servers: |
@@ -50,28 +53,43 @@ jobs:
             }]
 
       - name: Cache Maven packages
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: ~/.m2/repository
-          key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
+          key: ${{ runner.os }}-maven-tck-spark3-${{ hashFiles('**/pom.xml') }}
           restore-keys: |
             ${{ runner.os }}-maven-
 
-      - name: Build and run tests
+      - name: Build dependencies and run TCK (coverage only)
         continue-on-error: true
-        run: mvn clean test --batch-mode
+        run: |
+          mvn clean install -pl coverage -am -DskipTests --batch-mode
+          mvn test -pl coverage --batch-mode
 
-      # dorny/test-reporter titles come from Surefire <testcase name="…">; rewrite TCK names so
-      # passed tests show "Test N" + newline + tab + path (see coverage/scripts/prettify_tck_surefire_xml.py).
       - name: Prettify TCK Surefire XML for GitHub
         if: always()
         run: python3 coverage/scripts/prettify_tck_surefire_xml.py
 
       - name: Publish JUnit test results
-        uses: dorny/test-reporter@v2
+        uses: dorny/test-reporter@v3
         if: always()
         with:
-          name: JUnit Test Report
+          name: JUnit (Spark 3)
           path: coverage/target/surefire-reports/*.xml
           reporter: java-junit
+          only-summary: 'true'
+          max-annotations: 0
           fail-on-error: 'false'
+          fail-on-empty: 'false'
+
+      - name: Generate TCK scripts report
+        if: always()
+        run: python3 coverage/scripts/render_tck_job_summary.py
+
+      - name: Upload full TCK script report artifact
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: tck-scripts-report-spark3
+          path: coverage/target/tck-scripts-report.md
+          if-no-files-found: ignore
diff --git a/.github/workflows/tck-vtl-tf-spark4.yml b/.github/workflows/tck-vtl-tf-spark4.yml
new file mode 100644
index 000000000..6d188714e
--- /dev/null
+++ b/.github/workflows/tck-vtl-tf-spark4.yml
@@ -0,0 +1,95 @@
+name: Run VTL TF TCK (Spark 4)
+
+on:
+  push:
+    branches: [ '**' ]
+  pull_request:
+    branches: [ master, develop ]
+
+jobs:
+  tck-spark4:
+    name: TCK VTL v2.1 (Spark 4)
+    runs-on: ubuntu-latest
+    env:
+      TCK_REPORT_TITLE: 'TCK VTL v2.1 (Spark 4)'
+
+    steps:
+      - name: Checkout main project
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Clone vtl spec repo (branch fix/tck-2.1)
+        run: git clone --branch fix/tck-2.1 https://github.com/sdmx-twg/vtl.git
+
+      - name: Install Python 3
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.11'
+
+      - name: Run TCK generator script
+        run: |
+          DOC_VERSION=v2.1 python3 vtl/scripts/generate_tck_files.py
+
+      - name: Move generated TCK zip to resources
+        run: |
+          mkdir -p coverage/src/main/resources
+          mv vtl/tck/v2.1.zip coverage/src/main/resources/
+
+      - name: Set up Java
+        uses: actions/setup-java@v5
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - uses: s4u/maven-settings-action@v4.0.0
+        with:
+          githubServer: false
+          servers: |
+            [{
+                "id": "Github",
+                "username": "${{ secrets.GH_PACKAGES_USERNAME }}",
+                "password": "${{ secrets.GH_PACKAGES_PASSWORD }}"
+            }]
+
+      - name: Cache Maven packages
+        uses: actions/cache@v5
+        with:
+          path: ~/.m2/repository
+          key: ${{ runner.os }}-maven-tck-spark4-${{ hashFiles('**/pom.xml') }}
+          restore-keys: |
+            ${{ runner.os }}-maven-
+
+      - name: Build dependencies and run TCK (coverage only, Spark 4 profile)
+        continue-on-error: true
+        run: |
+          mvn clean install -pl coverage -am -DskipTests --batch-mode -Pspark4-tck
+          mvn test -pl coverage --batch-mode -Pspark4-tck
+
+      - name: Prettify TCK Surefire XML for GitHub
+        if: always()
+        run: python3 coverage/scripts/prettify_tck_surefire_xml.py
+
+      - name: Publish JUnit test results
+        uses: dorny/test-reporter@v3
+        if: always()
+        with:
+          name: JUnit (Spark 4)
+          path: coverage/target/surefire-reports/*.xml
+          reporter: java-junit
+          only-summary: 'true'
+          max-annotations: 0
+          fail-on-error: 'false'
+          fail-on-empty: 'false'
+
+      - name: Generate TCK scripts report
+        if: always()
+        run: python3 coverage/scripts/render_tck_job_summary.py
+
+      - name: Upload full TCK script report artifact
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: tck-scripts-report-spark4
+          path: coverage/target/tck-scripts-report.md
+          if-no-files-found: ignore
diff --git a/.gitignore b/.gitignore
index 87c2c4a52..9ee113d25 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,4 +7,6 @@ target/
 **/.settings/
 **/pom.xml.versionsBackup
 
-*-dev.properties
\ No newline at end of file
+*-dev.properties
+**/__pycache__/
+**/*.pyc
\ No newline at end of file
diff --git a/coverage/pom.xml b/coverage/pom.xml
index bc86b4215..8c56b1b5c 100644
--- a/coverage/pom.xml
+++ b/coverage/pom.xml
@@ -18,6 +18,9 @@
         <sonar.coverage.jacoco.xmlReportPaths>
             ${project.basedir}/../coverage/target/site/jacoco-aggregate/jacoco.xml
         </sonar.coverage.jacoco.xmlReportPaths>
+        <!-- Spark backend for TCK: default vtl-spark (Spark 3); profile spark4-tck uses vtl-spark4 -->
+        <trevas.spark.artifact>vtl-spark</trevas.spark.artifact>
+        <tck.suite.title>TCK VTL v2.1 (Spark 3)</tck.suite.title>
     </properties>
 
     <dependencies>
@@ -48,7 +51,7 @@
         </dependency>
         <dependency>
             <groupId>fr.insee.trevas</groupId>
-            <artifactId>vtl-spark</artifactId>
+            <artifactId>${trevas.spark.artifact}</artifactId>
             <version>2.4.0-SNAPSHOT</version>
         </dependency>
         <dependency>
@@ -70,6 +73,9 @@
                 <version>3.5.4</version>
                 <configuration>
                     <argLine>--add-exports java.base/sun.nio.ch=ALL-UNNAMED</argLine>
+                    <systemPropertyVariables>
+                        <tck.suite.title>${tck.suite.title}</tck.suite.title>
+                    </systemPropertyVariables>
                     <!-- GitHub / Surefire legacy XML uses technical names unless JUnit 5 phrased
                          reporters are enabled (see Surefire "JUnit Platform" examples). -->
                     <statelessTestsetReporter
@@ -111,4 +117,14 @@
             </plugin>
         </plugins>
     </build>
+
+    <profiles>
+        <profile>
+            <id>spark4-tck</id>
+            <properties>
+                <trevas.spark.artifact>vtl-spark4</trevas.spark.artifact>
+                <tck.suite.title>TCK VTL v2.1 (Spark 4)</tck.suite.title>
+            </properties>
+        </profile>
+    </profiles>
 </project>
\ No newline at end of file
diff --git a/coverage/scripts/render_tck_job_summary.py b/coverage/scripts/render_tck_job_summary.py
new file mode 100644
index 000000000..13cb188a9
--- /dev/null
+++ b/coverage/scripts/render_tck_job_summary.py
@@ -0,0 +1,501 @@
+#!/usr/bin/env python3
+"""
+After `mvn test` (+ optional prettify), build a plain-text-friendly Markdown report:
+
+  TCK scripts output
+  Source zip: …
+  Total cases: …
+
+  Per test (same shape for pass / skip / fail):
+    ✅ Test N
+    folder » with » chevrons » ex_k
+
+    <script body from zip>
+
+  Failures: one-line header `✅ Test N - path » …`; script in ```vtl`; detail
+  without Java stacks or `--- inputs ---`; subtitles bold (datasets / Trevas / TCK);
+  ASCII tables → GFM; `[path] output …` → **Cause: output …**.
+
+Inputs:
+  - Surefire XML (test order = execution order; names carry Test N + path).
+  - v2.1.zip (transformation.vtl per folder path).
+
+Writes: coverage/target/tck-scripts-report.md
+Appends to GITHUB_STEP_SUMMARY when set (after existing summary from test-reporter).
+
+Optional env TCK_REPORT_TITLE: prepended as Markdown H1 (e.g. TCK VTL v2.1 (Spark 4)).
+"""
+from __future__ import annotations
+
+import os
+import re
+import zipfile
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+FULL_REPORT_PATH = Path("coverage/target/tck-scripts-report.md")
+TCK_ZIP_CANDIDATES = [
+    Path("coverage/src/main/resources/v2.1.zip"),
+    Path("vtl/tck/v2.1.zip"),
+    Path("coverage/target/classes/v2.1.zip"),
+]
+SUREFIRE_XML_PATH = Path("coverage/target/surefire-reports/TEST-fr.insee.vtl.coverage.TCKTest.xml")
+
+_DISPLAY_SEP = " \u00bb "
+
+
+def resolve_tck_zip() -> Path | None:
+    for path in TCK_ZIP_CANDIDATES:
+        if path.exists():
+            return path
+    return None
+
+
+def zip_path_for_report(zip_path: Path) -> str:
+    try:
+        return str(zip_path.relative_to(Path.cwd()))
+    except ValueError:
+        return str(zip_path)
+
+
+def decode_xml_entities(text: str) -> str:
+    out = text
+    for _ in range(5):
+        nxt = (
+            out.replace("&quot;", '"')
+            .replace("&#34;", '"')
+            .replace("&apos;", "'")
+            .replace("&#39;", "'")
+            .replace("&lt;", "<")
+            .replace("&#60;", "<")
+            .replace("&gt;", ">")
+            .replace("&#62;", ">")
+            .replace("&amp;", "&")
+            .replace("&#38;", "&")
+            .replace("&#10;", "\n")
+            .replace("&#13;", "\r")
+            .replace("&#9;", "\t")
+        )
+        if nxt == out:
+            break
+        out = nxt
+    return out
+
+
+def split_testcase_name(name_attr: str) -> tuple[int, str] | None:
+    s = decode_xml_entities(name_attr).strip()
+    if "\n" in s:
+        lines = [ln.strip() for ln in s.split("\n") if ln.strip()]
+        if len(lines) >= 2:
+            m0 = re.match(r"^Test\s+(\d+)\s*$", lines[0])
+            if m0:
+                return int(m0.group(1)), lines[1].lstrip("\t").strip()
+    m = re.search(r"Test\s+(\d+)\s+—\s+(.+)$", s)
+    if m:
+        return int(m.group(1)), m.group(2).strip()
+    return None
+
+
+def display_path_to_zip_key(display_path: str) -> str:
+    return display_path.replace(_DISPLAY_SEP, "/")
+
+
+def lookup_script(scripts: dict[str, str], display_path: str) -> str:
+    """Resolve transformation.vtl folder key in zip (handles trailing duplicate segment, e.g. ex_1/ex_1)."""
+    key = display_path_to_zip_key(display_path)
+    if key in scripts:
+        return scripts[key]
+    parts = key.split("/")
+    if len(parts) >= 2 and parts[-1] == parts[-2]:
+        parent = "/".join(parts[:-1])
+        if parent in scripts:
+            return scripts[parent]
+    for end in range(len(parts), 0, -1):
+        prefix = "/".join(parts[:end])
+        if prefix in scripts:
+            return scripts[prefix]
+    return "(script not found in zip for this path)"
+
+
+def load_scripts_from_zip(zip_path: Path) -> dict[str, str]:
+    scripts: dict[str, str] = {}
+    with zipfile.ZipFile(zip_path) as zf:
+        for name in zf.namelist():
+            if not name.endswith("transformation.vtl"):
+                continue
+            key = name[: -len("transformation.vtl")].rstrip("/")
+            body = zf.read(name).decode("utf-8", errors="replace").replace("\r", "")
+            scripts[key] = body
+    return scripts
+
+
+def local_tag(elem: ET.Element) -> str:
+    if elem.tag.startswith("{"):
+        return elem.tag.split("}", 1)[1]
+    return elem.tag
+
+
+_FAILURE_OR_ERROR_TAGS = frozenset(
+    {"failure", "error", "rerunFailure", "rerunError", "flakyFailure"}
+)
+
+
+def find_failure_or_error_node(tc: ET.Element) -> ET.Element | None:
+    """JUnit5Xml30 / Surefire 3.x may nest failure/error under wrappers, not only direct children."""
+    for el in tc.iter():
+        if el is tc:
+            continue
+        if local_tag(el) in _FAILURE_OR_ERROR_TAGS:
+            return el
+    return None
+
+
+def iter_surefire_testcases(root: ET.Element) -> list[ET.Element]:
+    """Ordered testcase elements (JUnit5 may wrap testsuite(s))."""
+    found: list[ET.Element] = []
+    for parent in root.iter():
+        if local_tag(parent) != "testsuite":
+            continue
+        for child in parent:
+            if local_tag(child) == "testcase":
+                found.append(child)
+    if found:
+        return found
+    # Fallback: any testcase in document order (namespaced or alternate layout).
+    return [e for e in root.iter() if local_tag(e) == "testcase"]
+
+
+_ASSERTJ_MULTI = re.compile(r"^Multiple Failures\s*\([^)]+\)\s*$", re.IGNORECASE)
+_ASSERTJ_FAILURE_HDR = re.compile(r"^--\s*failure\s+\d+\s*--\s*$", re.IGNORECASE)
+_ASSERTJ_CLASS_HDR = re.compile(
+    r"^\s*org\.assertj\..*AssertJMultipleFailuresError:\s*$", re.IGNORECASE
+)
+
+
+def strip_assertj_noise(text: str) -> str:
+    """Drop AssertJMultipleFailures boilerplate lines."""
+    lines = text.splitlines()
+    kept: list[str] = []
+    for line in lines:
+        s = line.strip()
+        if (
+            _ASSERTJ_MULTI.match(s)
+            or _ASSERTJ_FAILURE_HDR.match(s)
+            or _ASSERTJ_CLASS_HDR.match(s)
+        ):
+            continue
+        kept.append(line)
+    return "\n".join(kept).strip()
+
+
+def strip_embedded_tck_script_block(text: str) -> str:
+    """Remove TckScriptText.appendFull section (already printed above from zip)."""
+    key_vtl = "VTL script:"
+    key_sep = "--- transformation.vtl ---"
+    markers = ("--- inputs ---", "Trevas (actual):")
+    i = text.find(key_vtl)
+    if i == -1:
+        return text
+    start_cut = i
+    if start_cut > 0 and text[start_cut - 1] == "\n":
+        start_cut -= 1
+        if start_cut > 0 and text[start_cut - 1] == "\r":
+            start_cut -= 1
+
+    j = text.find(key_sep, i)
+    if j == -1:
+        line_end = text.find("\n", i)
+        if line_end == -1:
+            return text[:start_cut].rstrip()
+        tail = text[line_end + 1 :].lstrip("\n\r")
+        return (text[:start_cut].rstrip() + ("\n\n" + tail if tail else "")).strip()
+
+    after_sep = j + len(key_sep)
+    while after_sep < len(text) and text[after_sep] in "\r\n":
+        after_sep += 1
+
+    next_pos: list[int] = []
+    for mk in markers:
+        k = text.find(mk, after_sep)
+        if k != -1:
+            next_pos.append(k)
+    if not next_pos:
+        head = text[:start_cut].rstrip()
+        return head
+
+    k = min(next_pos)
+    tail = text[k:].lstrip("\n\r")
+    head = text[:start_cut].rstrip()
+    return (head + ("\n\n" + tail if tail else "")).strip()
+
+
+def _split_ascii_pipe_row(line: str) -> list[str]:
+    parts = [p.strip() for p in line.split("|")]
+    while parts and parts[0] == "":
+        parts.pop(0)
+    while parts and parts[-1] == "":
+        parts.pop()
+    return parts
+
+
+def _is_ascii_separator_row(line: str) -> bool:
+    """Java renderTable separator is -----+-----+----- (no '|'); single-column is just dashes."""
+    s = line.strip()
+    if not s or "-" not in s or "|" in s:
+        return False
+    if "+" in s:
+        return bool(re.fullmatch(r"[\s\-+]+", s))
+    return bool(re.fullmatch(r"-+", s))
+
+
+def _ascii_table_block_to_markdown(header_line: str, data_lines: list[str]) -> str | None:
+    headers = _split_ascii_pipe_row(header_line)
+    n = len(headers)
+    if n < 2:
+        return None
+
+    def esc_cell(c: str) -> str:
+        return c.replace("|", "\\|").replace("\n", " ").strip()
+
+    rows_md = [
+        "| " + " | ".join(esc_cell(h) for h in headers) + " |",
+        "| " + " | ".join("---" for _ in headers) + " |",
+    ]
+    for raw in data_lines:
+        cells = _split_ascii_pipe_row(raw)
+        if len(cells) < n:
+            cells = cells + [""] * (n - len(cells))
+        cells = cells[:n]
+        rows_md.append("| " + " | ".join(esc_cell(c) for c in cells) + " |")
+    return "\n".join(rows_md)
+
+
+def convert_ascii_tables_to_markdown(text: str) -> str:
+    """Turn TCK ASCII pipe tables into GFM tables (renders nicely on GitHub)."""
+    lines = text.splitlines()
+    out: list[str] = []
+    i = 0
+    while i < len(lines):
+        header = lines[i]
+        if (
+            "|" in header
+            and not header.strip().startswith("|")
+            and not _is_ascii_separator_row(header)
+            and i + 1 < len(lines)
+            and _is_ascii_separator_row(lines[i + 1])
+        ):
+            j = i + 2
+            data: list[str] = []
+            while j < len(lines):
+                ln = lines[j]
+                if not ln.strip():
+                    break
+                if "|" not in ln or _is_ascii_separator_row(ln):
+                    break
+                data.append(ln)
+                j += 1
+            md = _ascii_table_block_to_markdown(header, data)
+            if md:
+                out.append(md)
+                out.append("")
+                i = j
+                continue
+        out.append(lines[i])
+        i += 1
+    return "\n".join(out).strip()
+
+
+_CAUSE_LINE = re.compile(r"^\s*\[[^\]]+\]\s+(.*)$")
+
+
+_STACK_FRAME = re.compile(r"^\s*at\s+.+")
+_STACK_MORE = re.compile(r"^\s*\.\.\.\s*\d+\s+more\b")
+_SUPPRESSED_HDR = re.compile(r"^\s*Suppressed:\s*")
+
+
+def strip_java_stack_trace(text: str) -> str:
+    """Drop Java stack frames (lines starting with `at …`), Suppressed headers, '… more'."""
+    lines = text.splitlines()
+    out: list[str] = []
+    for ln in lines:
+        if (
+            _SUPPRESSED_HDR.match(ln)
+            or _STACK_FRAME.match(ln)
+            or _STACK_MORE.match(ln)
+            or ln.strip() == "... <omitted />"
+        ):
+            continue
+        out.append(ln)
+    return "\n".join(out)
+
+
+def tidy_failure_section_headers(text: str) -> str:
+    """Remove --- inputs ---; bold compact subtitles for datasets / Trevas / TCK."""
+    t = re.sub(r"^--- inputs ---\s*\n", "", text, flags=re.MULTILINE | re.IGNORECASE)
+    t = re.sub(r"^« ([^»]+) »\s*$", r"**« \1 »**", t, flags=re.MULTILINE)
+    t = re.sub(r"^Trevas \(actual\):\s*$", "**Trevas (actual)**", t, flags=re.MULTILINE)
+    t = re.sub(r"^TCK \(expected\):\s*$", "**TCK (expected)**", t, flags=re.MULTILINE)
+    return t
+
+
+def rewrite_failure_cause_summary(text: str) -> str:
+    """[path] output `DS_r` — … → **Cause: output `DS_r` — …** (path already shown above)."""
+    out_lines: list[str] = []
+    for line in text.splitlines():
+        m = _CAUSE_LINE.match(line)
+        if m:
+            rest = m.group(1).strip()
+            if rest.startswith("output"):
+                line = f"**Cause: {rest}**"
+        out_lines.append(line)
+    return "\n".join(out_lines)
+
+
+def sanitize_failure_detail(detail: str) -> str:
+    """Remove duplicated script and AssertJ noise; keep inputs/tables."""
+    t = strip_assertj_noise(detail)
+    # Some Surefire variants duplicate the payload (message + body).
+    # Strip embedded script sections repeatedly until stable.
+    while True:
+        nxt = strip_embedded_tck_script_block(t)
+        if nxt == t:
+            break
+        t = nxt
+    t = strip_java_stack_trace(t)
+    t = convert_ascii_tables_to_markdown(t)
+    t = tidy_failure_section_headers(t)
+    t = rewrite_failure_cause_summary(t)
+    return re.sub(r"\n{3,}", "\n\n", t).strip()
+
+
+def failure_or_error_text(node: ET.Element | None) -> str:
+    if node is None:
+        return ""
+    msg = (node.attrib.get("message") or "").strip()
+    body = "".join(node.itertext()).strip()
+    typ = (node.attrib.get("type") or "").strip()
+    # Prefer body: in Surefire/JUnit5 it usually contains the full useful failure payload.
+    if body:
+        return body
+    if msg:
+        return msg
+    if typ:
+        return typ
+    return ""
+
+
+def parse_ordered_results(xml_path: Path) -> list[dict[str, str]]:
+    if not xml_path.exists():
+        return []
+    tree = ET.parse(xml_path)
+    root = tree.getroot()
+    out: list[dict[str, str]] = []
+    for tc in iter_surefire_testcases(root):
+        name = tc.attrib.get("name", "")
+        parsed = split_testcase_name(name)
+        if parsed is None:
+            continue
+        idx, display_path = parsed
+        node = find_failure_or_error_node(tc)
+        if node is not None:
+            detail = failure_or_error_text(node)
+            out.append(
+                {
+                    "index": idx,
+                    "display_path": display_path,
+                    "status": "FAIL",
+                    "detail": detail or "Unknown failure",
+                }
+            )
+        else:
+            skipped = any(
+                local_tag(el) == "skipped" for el in tc.iter() if el is not tc
+            )
+            out.append(
+                {
+                    "index": idx,
+                    "display_path": display_path,
+                    "status": "SKIP" if skipped else "PASS",
+                    "detail": "",
+                }
+            )
+    return out
+
+
+def fenced_vtl(script: str) -> str:
+    body = (script.strip() if script else "(empty)").rstrip()
+    return "```vtl\n" + body + "\n```"
+
+
+def render_case_plain(i: int, display_path: str, script: str, row: dict[str, str]) -> str:
+    if row["status"] == "PASS":
+        mark = "✅"
+    elif row["status"] == "SKIP":
+        mark = "⏭️"
+    else:
+        mark = "❌"
+    lines: list[str] = [f"{mark} Test {i} - {display_path}", "", fenced_vtl(script)]
+    if row["status"] == "FAIL":
+        cleaned = sanitize_failure_detail(row["detail"].strip())
+        if cleaned:
+            lines.extend(["", cleaned])
+    lines.extend(["", ""])
+    return "\n".join(lines)
+
+
+def main() -> None:
+    summary_path = os.environ.get("GITHUB_STEP_SUMMARY")
+    zip_path = resolve_tck_zip()
+    report_title = os.environ.get("TCK_REPORT_TITLE", "").strip()
+
+    FULL_REPORT_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+    if zip_path is None:
+        msg = ""
+        if report_title:
+            msg += f"# {report_title}\n\n"
+        msg += (
+            "TCK scripts output\n\n"
+            "Source zip: (not found)\n\n"
+            "Expected one of:\n"
+            + "\n".join(f"  - {p}" for p in TCK_ZIP_CANDIDATES)
+            + "\n"
+        )
+        FULL_REPORT_PATH.write_text(msg, encoding="utf-8")
+        if summary_path:
+            with open(summary_path, "a", encoding="utf-8") as out:
+                out.write("\n\n---\n\n")
+                out.write(msg)
+        return
+
+    scripts = load_scripts_from_zip(zip_path)
+    results = parse_ordered_results(SUREFIRE_XML_PATH)
+
+    chunks: list[str] = []
+    if report_title:
+        chunks.append(f"# {report_title}\n\n")
+    chunks.append("TCK scripts output\n")
+    chunks.append("")
+    chunks.append(f"Source zip: {zip_path_for_report(zip_path)}\n")
+    chunks.append("")
+    chunks.append(f"Total cases: {len(results)}\n")
+    chunks.append("")
+
+    for row in results:
+        i = row["index"]
+        display_path = row["display_path"]
+        script = lookup_script(scripts, display_path)
+        chunks.append(render_case_plain(i, display_path, script, row))
+
+    report = "".join(chunks).rstrip() + "\n"
+
+    FULL_REPORT_PATH.write_text(report, encoding="utf-8")
+
+    if summary_path:
+        with open(summary_path, "a", encoding="utf-8") as out:
+            out.write("\n\n---\n\n")
+            out.write(report)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/coverage/src/test/java/fr/insee/vtl/coverage/TCKTest.java b/coverage/src/test/java/fr/insee/vtl/coverage/TCKTest.java
index 118c86e3a..3fa0f1a63 100644
--- a/coverage/src/test/java/fr/insee/vtl/coverage/TCKTest.java
+++ b/coverage/src/test/java/fr/insee/vtl/coverage/TCKTest.java
@@ -5,6 +5,7 @@
 import fr.insee.vtl.coverage.tck.TckCaseExecutor;
 import fr.insee.vtl.coverage.tck.TckFolders;
 import fr.insee.vtl.coverage.tck.TckLeafCase;
+import fr.insee.vtl.coverage.tck.TckScriptText;
 import fr.insee.vtl.coverage.tck.TckSparkScriptEngines;
 import java.io.InputStream;
 import java.util.List;
@@ -13,7 +14,7 @@
 import org.apache.spark.sql.SparkSession;
 import org.junit.jupiter.api.Assumptions;
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.DisplayNameGeneration;
 import org.junit.jupiter.api.Named;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
@@ -23,7 +24,7 @@
  * Spark-backed conformance run against the packaged TCK ({@code v2.1.zip}). Orchestration only —
  * discovery, naming, and assertions live under {@code fr.insee.vtl.coverage.tck}.
  */
-@DisplayName("TCK v2.1 (Spark)")
+@DisplayNameGeneration(TckSuiteDisplayNameGenerator.class)
 class TCKTest {
 
   private TckCaseExecutor executor;
@@ -51,7 +52,12 @@ void tckCase(TckCase c) throws Exception {
   }
 
   private static void logCaseOutcome(TckCase c, boolean success) {
+    // Avoid duplicating hundreds of lines in CI logs; use generated markdown artifact instead.
+    if (Boolean.parseBoolean(System.getenv().getOrDefault("GITHUB_ACTIONS", "false"))) {
+      return;
+    }
     System.out.println((success ? "✅" : "❌") + " Test " + c.index());
+    System.out.println("\tVTL script: " + c.scriptSummary());
     System.out.println("\t" + c.displayPath());
   }
 
@@ -76,5 +82,9 @@ private record TckCase(int index, String displayPath, Test payload) {
     String label() {
       return "Test " + index + " — " + displayPath;
     }
+
+    String scriptSummary() {
+      return TckScriptText.summary(payload.getScript(), 120);
+    }
   }
 }
diff --git a/coverage/src/test/java/fr/insee/vtl/coverage/TckSuiteDisplayNameGenerator.java b/coverage/src/test/java/fr/insee/vtl/coverage/TckSuiteDisplayNameGenerator.java
new file mode 100644
index 000000000..48b0a392e
--- /dev/null
+++ b/coverage/src/test/java/fr/insee/vtl/coverage/TckSuiteDisplayNameGenerator.java
@@ -0,0 +1,37 @@
+package fr.insee.vtl.coverage;
+
+import java.lang.reflect.Method;
+import java.util.List;
+import org.junit.jupiter.api.DisplayNameGenerator;
+
+/**
+ * JUnit suite title from {@code -Dtck.suite.title=…} (set by Maven profile in CI for Spark 3 vs 4).
+ */
+public final class TckSuiteDisplayNameGenerator implements DisplayNameGenerator {
+
+  private static final DisplayNameGenerator DEFAULT = new DisplayNameGenerator.Standard();
+
+  @Override
+  public String generateDisplayNameForClass(Class<?> testClass) {
+    if (testClass == TCKTest.class) {
+      return System.getProperty("tck.suite.title", "TCK VTL v2.1 (Spark 3)");
+    }
+    return DEFAULT.generateDisplayNameForClass(testClass);
+  }
+
+  @Override
+  public String generateDisplayNameForNestedClass(Class<?> nestedClass) {
+    return DEFAULT.generateDisplayNameForNestedClass(nestedClass);
+  }
+
+  @Override
+  public String generateDisplayNameForMethod(Class<?> testClass, Method testMethod) {
+    return DEFAULT.generateDisplayNameForMethod(testClass, testMethod);
+  }
+
+  @Override
+  public String generateDisplayNameForMethod(
+      List<Class<?>> enclosingInstanceTypes, Class<?> testClass, Method testMethod) {
+    return DEFAULT.generateDisplayNameForMethod(enclosingInstanceTypes, testClass, testMethod);
+  }
+}
diff --git a/coverage/src/test/java/fr/insee/vtl/coverage/tck/TckFailureText.java b/coverage/src/test/java/fr/insee/vtl/coverage/tck/TckFailureText.java
index 9ee748ac7..bdadb5e74 100644
--- a/coverage/src/test/java/fr/insee/vtl/coverage/tck/TckFailureText.java
+++ b/coverage/src/test/java/fr/insee/vtl/coverage/tck/TckFailureText.java
@@ -45,16 +45,7 @@ public static String rowDataMismatch(
   }
 
   private static void appendScript(StringBuilder sb, String script) {
-    sb.append("--- transformation.vtl ---").append(System.lineSeparator());
-    if (script == null) {
-      sb.append("(null)");
-      return;
-    }
-    String s =
-        script.length() > MAX_SCRIPT_CHARS
-            ? script.substring(0, MAX_SCRIPT_CHARS) + "\n… (truncated)"
-            : script;
-    sb.append(s);
+    TckScriptText.appendFull(sb, script, MAX_SCRIPT_CHARS);
   }
 
   private static void appendInputs(StringBuilder sb, Map<String, Dataset> inputs) {
diff --git a/coverage/src/test/java/fr/insee/vtl/coverage/tck/TckScriptText.java b/coverage/src/test/java/fr/insee/vtl/coverage/tck/TckScriptText.java
new file mode 100644
index 000000000..d3b517396
--- /dev/null
+++ b/coverage/src/test/java/fr/insee/vtl/coverage/tck/TckScriptText.java
@@ -0,0 +1,64 @@
+package fr.insee.vtl.coverage.tck;
+
+/** Shared formatting for VTL script text in TCK outputs. */
+public final class TckScriptText {
+
+  private TckScriptText() {}
+
+  public static String summary(String script, int maxChars) {
+    String normalized = normalizeScript(script);
+    if (normalized == null || normalized.isBlank()) {
+      return "(empty)";
+    }
+    String oneLine =
+        normalized.replace('\n', ' ').replace('\r', ' ').trim().replaceAll("\\s+", " ");
+    return oneLine.length() > maxChars ? oneLine.substring(0, maxChars) + "…" : oneLine;
+  }
+
+  public static void appendFull(StringBuilder sb, String script, int maxChars) {
+    sb.append("VTL script: ").append(summary(script, 120)).append(System.lineSeparator());
+    sb.append("--- transformation.vtl ---").append(System.lineSeparator());
+    String full = full(script);
+    if (full == null) {
+      sb.append("(null)");
+      return;
+    }
+    String truncated =
+        full.length() > maxChars ? full.substring(0, maxChars) + "\n… (truncated)" : full;
+    sb.append(truncated);
+  }
+
+  public static String full(String script) {
+    return normalizeScript(script);
+  }
+
+  private static String normalizeScript(String script) {
+    if (script == null) {
+      return null;
+    }
+    // TCK payload may contain XML/HTML entities, sometimes double-escaped
+    // (e.g. &amp;quot;), so decode repeatedly until stable.
+    String decoded = script;
+    for (int i = 0; i < 4; i++) {
+      String next = decodeXmlEntities(decoded);
+      if (next.equals(decoded)) {
+        break;
+      }
+      decoded = next;
+    }
+    return decoded;
+  }
+
+  private static String decodeXmlEntities(String text) {
+    return text.replace("&quot;", "\"")
+        .replace("&#34;", "\"")
+        .replace("&apos;", "'")
+        .replace("&#39;", "'")
+        .replace("&lt;", "<")
+        .replace("&#60;", "<")
+        .replace("&gt;", ">")
+        .replace("&#62;", ">")
+        .replace("&amp;", "&")
+        .replace("&#38;", "&");
+  }
+}
diff --git a/pom.xml b/pom.xml
index b9e5d18dd..0b2fa10ef 100644
--- a/pom.xml
+++ b/pom.xml
@@ -12,6 +12,7 @@
         <module>vtl-engine</module>
         <module>vtl-jackson</module>
         <module>vtl-spark</module>
+        <module>vtl-spark4</module>
         <module>vtl-jdbc</module>
         <module>vtl-sdmx</module>
         <module>vtl-csv</module>
@@ -75,6 +76,11 @@
         <sonar.coverage.jacoco.xmlReportPaths>
             ${project.basedir}/coverage/target/site/jacoco-aggregate/jacoco.xml
         </sonar.coverage.jacoco.xmlReportPaths>
+        <!-- Published Spark integrations: bump here only (CI spark-matrix exercises both). -->
+        <spark3.version>3.5.8</spark3.version>
+        <spark3.scala.binary>2.12</spark3.scala.binary>
+        <spark4.version>4.0.0</spark4.version>
+        <spark4.scala.binary>2.13</spark4.scala.binary>
     </properties>
 
     <dependencies>
@@ -105,6 +111,16 @@
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
+            <dependency>
+                <groupId>org.apache.spark</groupId>
+                <artifactId>spark-sql_2.12</artifactId>
+                <version>${spark3.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.apache.spark</groupId>
+                <artifactId>spark-sql_2.13</artifactId>
+                <version>${spark4.version}</version>
+            </dependency>
         </dependencies>
     </dependencyManagement>
 
diff --git a/vtl-engine/pom.xml b/vtl-engine/pom.xml
index 1cca5ed31..504d77673 100644
--- a/vtl-engine/pom.xml
+++ b/vtl-engine/pom.xml
@@ -76,6 +76,17 @@
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <!-- fr.insee.vtl.parser.shaded exists only as Automatic-Module-Name on the packaged
+                         shaded vtl-parser.jar. Reactor resolution uses target/classes (no module name),
+                         which breaks Surefire's default Java 9+ module-path startup. Classpath mode matches
+                         compilation against workspace classes + antlr-runtime. -->
+                    <useModulePath>false</useModulePath>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
 
diff --git a/vtl-engine/src/main/java/fr/insee/vtl/engine/VtlScriptEngine.java b/vtl-engine/src/main/java/fr/insee/vtl/engine/VtlScriptEngine.java
index 051db6f39..034b92f7b 100644
--- a/vtl-engine/src/main/java/fr/insee/vtl/engine/VtlScriptEngine.java
+++ b/vtl-engine/src/main/java/fr/insee/vtl/engine/VtlScriptEngine.java
@@ -9,6 +9,10 @@
 import fr.insee.vtl.model.exceptions.VtlScriptException;
 import fr.insee.vtl.parser.VtlLexer;
 import fr.insee.vtl.parser.VtlParser;
+import fr.insee.vtl.parser.antlr4.runtime.*;
+import fr.insee.vtl.parser.antlr4.runtime.misc.Interval;
+import fr.insee.vtl.parser.antlr4.runtime.tree.ParseTree;
+import fr.insee.vtl.parser.antlr4.runtime.tree.TerminalNode;
 import java.io.IOException;
 import java.io.Reader;
 import java.lang.reflect.Method;
@@ -19,10 +23,6 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import javax.script.*;
-import org.antlr.v4.runtime.*;
-import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.tree.ParseTree;
-import org.antlr.v4.runtime.tree.TerminalNode;
 
 /**
  * The {@link ScriptEngine} implementation for VTL.
diff --git a/vtl-engine/src/main/java/fr/insee/vtl/engine/VtlSyntaxPreprocessor.java b/vtl-engine/src/main/java/fr/insee/vtl/engine/VtlSyntaxPreprocessor.java
index b24b6518b..d2e36eebf 100644
--- a/vtl-engine/src/main/java/fr/insee/vtl/engine/VtlSyntaxPreprocessor.java
+++ b/vtl-engine/src/main/java/fr/insee/vtl/engine/VtlSyntaxPreprocessor.java
@@ -6,10 +6,10 @@
 import fr.insee.vtl.model.exceptions.VtlMultiErrorScriptException;
 import fr.insee.vtl.model.exceptions.VtlScriptException;
 import fr.insee.vtl.parser.VtlParser;
+import fr.insee.vtl.parser.antlr4.runtime.ParserRuleContext;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
-import org.antlr.v4.runtime.ParserRuleContext;
 
 /**
  * Class for preprocessing the VTL script for resolving script errors and reordering statements
diff --git a/vtl-engine/src/main/java/fr/insee/vtl/engine/utils/TypeChecking.java b/vtl-engine/src/main/java/fr/insee/vtl/engine/utils/TypeChecking.java
index ad202a42b..3d2ea296e 100644
--- a/vtl-engine/src/main/java/fr/insee/vtl/engine/utils/TypeChecking.java
+++ b/vtl-engine/src/main/java/fr/insee/vtl/engine/utils/TypeChecking.java
@@ -7,12 +7,12 @@
 import fr.insee.vtl.model.ResolvableExpression;
 import fr.insee.vtl.model.TypedExpression;
 import fr.insee.vtl.model.exceptions.InvalidTypeException;
+import fr.insee.vtl.parser.antlr4.runtime.tree.ParseTree;
 import java.time.Instant;
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Stream;
-import org.antlr.v4.runtime.tree.ParseTree;
 import org.threeten.extra.Interval;
 import org.threeten.extra.PeriodDuration;
 
diff --git a/vtl-engine/src/main/java/fr/insee/vtl/engine/utils/dag/DAGStatement.java b/vtl-engine/src/main/java/fr/insee/vtl/engine/utils/dag/DAGStatement.java
index 55a2fab3d..e639690af 100644
--- a/vtl-engine/src/main/java/fr/insee/vtl/engine/utils/dag/DAGStatement.java
+++ b/vtl-engine/src/main/java/fr/insee/vtl/engine/utils/dag/DAGStatement.java
@@ -4,15 +4,15 @@
 import fr.insee.vtl.model.Positioned;
 import fr.insee.vtl.model.exceptions.VtlMultiStatementScriptException;
 import fr.insee.vtl.parser.VtlParser;
+import fr.insee.vtl.parser.antlr4.runtime.ParserRuleContext;
+import fr.insee.vtl.parser.antlr4.runtime.tree.ParseTree;
+import fr.insee.vtl.parser.antlr4.runtime.tree.RuleNode;
+import fr.insee.vtl.parser.antlr4.runtime.tree.TerminalNode;
 import java.util.Collection;
 import java.util.Comparator;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.stream.Collectors;
-import org.antlr.v4.runtime.ParserRuleContext;
-import org.antlr.v4.runtime.tree.ParseTree;
-import org.antlr.v4.runtime.tree.RuleNode;
-import org.antlr.v4.runtime.tree.TerminalNode;
 
 /**
  * Representation of a VTL Statement
diff --git a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/AnalyticsVisitor.java b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/AnalyticsVisitor.java
index 2062da040..e03db76cd 100644
--- a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/AnalyticsVisitor.java
+++ b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/AnalyticsVisitor.java
@@ -10,12 +10,12 @@
 import fr.insee.vtl.model.exceptions.VtlScriptException;
 import fr.insee.vtl.parser.VtlBaseVisitor;
 import fr.insee.vtl.parser.VtlParser;
+import fr.insee.vtl.parser.antlr4.runtime.Token;
+import fr.insee.vtl.parser.antlr4.runtime.tree.ParseTree;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
-import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.tree.ParseTree;
 
 public class AnalyticsVisitor extends VtlBaseVisitor<DatasetExpression> {
 
diff --git a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/AssignmentVisitor.java b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/AssignmentVisitor.java
index c55ca3bbb..41c1a7188 100644
--- a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/AssignmentVisitor.java
+++ b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/AssignmentVisitor.java
@@ -11,6 +11,7 @@
 import fr.insee.vtl.model.exceptions.VtlScriptException;
 import fr.insee.vtl.parser.VtlBaseVisitor;
 import fr.insee.vtl.parser.VtlParser;
+import fr.insee.vtl.parser.antlr4.runtime.tree.TerminalNode;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
@@ -18,7 +19,6 @@
 import javax.script.ScriptContext;
 import javax.script.ScriptException;
 import javax.script.SimpleBindings;
-import org.antlr.v4.runtime.tree.TerminalNode;
 
 /** <code>AssignmentVisitor</code> is the visitor for VTL assignment expressions. */
 public class AssignmentVisitor extends VtlBaseVisitor<Object> {
diff --git a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/ClauseVisitor.java b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/ClauseVisitor.java
index cdda2e14f..3fb9400e5 100644
--- a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/ClauseVisitor.java
+++ b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/ClauseVisitor.java
@@ -15,11 +15,11 @@
 import fr.insee.vtl.model.exceptions.VtlScriptException;
 import fr.insee.vtl.parser.VtlBaseVisitor;
 import fr.insee.vtl.parser.VtlParser;
+import fr.insee.vtl.parser.antlr4.runtime.ParserRuleContext;
+import fr.insee.vtl.parser.antlr4.runtime.misc.Interval;
 import java.util.*;
 import java.util.function.Function;
 import java.util.stream.Collectors;
-import org.antlr.v4.runtime.ParserRuleContext;
-import org.antlr.v4.runtime.misc.Interval;
 
 /**
  * <code>ClauseVisitor</code> is the visitor for VTL clause expressions (component filter, aggr,
diff --git a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/DAGBuildingVisitor.java b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/DAGBuildingVisitor.java
index 068153a95..b2f96e0b0 100644
--- a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/DAGBuildingVisitor.java
+++ b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/DAGBuildingVisitor.java
@@ -3,16 +3,16 @@
 import fr.insee.vtl.engine.utils.dag.DAGStatement;
 import fr.insee.vtl.parser.VtlBaseVisitor;
 import fr.insee.vtl.parser.VtlParser;
+import fr.insee.vtl.parser.antlr4.runtime.RuleContext;
+import fr.insee.vtl.parser.antlr4.runtime.Token;
+import fr.insee.vtl.parser.antlr4.runtime.tree.RuleNode;
+import fr.insee.vtl.parser.antlr4.runtime.tree.TerminalNode;
 import java.util.Collection;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
-import org.antlr.v4.runtime.RuleContext;
-import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.tree.RuleNode;
-import org.antlr.v4.runtime.tree.TerminalNode;
 
 /** <code>DagbuildingVisitor</code> is the visitor for creating a DAG from VTL statements. */
 public class DAGBuildingVisitor extends VtlBaseVisitor<List<DAGStatement>> {
diff --git a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/ComparisonVisitor.java b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/ComparisonVisitor.java
index d493fd301..f3e8a2e47 100644
--- a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/ComparisonVisitor.java
+++ b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/ComparisonVisitor.java
@@ -13,10 +13,10 @@
 import fr.insee.vtl.model.exceptions.VtlScriptException;
 import fr.insee.vtl.parser.VtlBaseVisitor;
 import fr.insee.vtl.parser.VtlParser;
+import fr.insee.vtl.parser.antlr4.runtime.Token;
+import fr.insee.vtl.parser.antlr4.runtime.tree.TerminalNode;
 import java.util.*;
 import java.util.stream.Collectors;
-import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.tree.TerminalNode;
 
 /**
  * <code>ComparisonVisitor</code> is the base visitor for comparison, 'element of' and list
diff --git a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/ConditionalVisitor.java b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/ConditionalVisitor.java
index 686508deb..b10c94acc 100644
--- a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/ConditionalVisitor.java
+++ b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/ConditionalVisitor.java
@@ -5,6 +5,7 @@
 
 import fr.insee.vtl.engine.exceptions.VtlRuntimeException;
 import fr.insee.vtl.engine.visitors.expression.functions.GenericFunctionsVisitor;
+import fr.insee.vtl.model.ConstantExpression;
 import fr.insee.vtl.model.Positioned;
 import fr.insee.vtl.model.ResolvableExpression;
 import fr.insee.vtl.model.exceptions.InvalidTypeException;
@@ -165,11 +166,14 @@ private ResolvableExpression caseToIfIt(
     }
 
     ResolvableExpression nextWhen = whenExpr.next();
+    ResolvableExpression caseCondition =
+        genericFunctionsVisitor.invokeFunction(
+            "nvl", List.of(nextWhen, new ConstantExpression(false, nextWhen)), nextWhen);
 
     return genericFunctionsVisitor.invokeFunction(
         "ifThenElse",
-        List.of(nextWhen, thenExpr.next(), caseToIfIt(whenExpr, thenExpr, elseExpression)),
-        nextWhen);
+        List.of(caseCondition, thenExpr.next(), caseToIfIt(whenExpr, thenExpr, elseExpression)),
+        caseCondition);
   }
 
   /**
diff --git a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/functions/GenericFunctionsVisitor.java b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/functions/GenericFunctionsVisitor.java
index 5d3d7cac8..e9a5dacaa 100644
--- a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/functions/GenericFunctionsVisitor.java
+++ b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/functions/GenericFunctionsVisitor.java
@@ -20,6 +20,8 @@
 import fr.insee.vtl.model.exceptions.VtlScriptException;
 import fr.insee.vtl.parser.VtlBaseVisitor;
 import fr.insee.vtl.parser.VtlParser;
+import fr.insee.vtl.parser.antlr4.runtime.Token;
+import fr.insee.vtl.parser.antlr4.runtime.tree.TerminalNode;
 import java.time.Instant;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -29,8 +31,6 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
-import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.tree.TerminalNode;
 import org.threeten.extra.Interval;
 import org.threeten.extra.PeriodDuration;
 
diff --git a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/functions/SetFunctionsVisitor.java b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/functions/SetFunctionsVisitor.java
index 3daa0e2e3..0c8523ffe 100644
--- a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/functions/SetFunctionsVisitor.java
+++ b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/functions/SetFunctionsVisitor.java
@@ -13,11 +13,11 @@
 import fr.insee.vtl.model.Structured;
 import fr.insee.vtl.parser.VtlBaseVisitor;
 import fr.insee.vtl.parser.VtlParser;
+import fr.insee.vtl.parser.antlr4.runtime.RuleContext;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import java.util.stream.Collectors;
-import org.antlr.v4.runtime.RuleContext;
 
 /**
  * <code>SetFunctionsVisitor</code> is the visitor for expressions involving set functions (i.e.
diff --git a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/functions/TimeFunctionsVisitor.java b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/functions/TimeFunctionsVisitor.java
index c56de1f66..f1e6e78d0 100644
--- a/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/functions/TimeFunctionsVisitor.java
+++ b/vtl-engine/src/main/java/fr/insee/vtl/engine/visitors/expression/functions/TimeFunctionsVisitor.java
@@ -10,6 +10,7 @@
 import fr.insee.vtl.model.exceptions.VtlScriptException;
 import fr.insee.vtl.parser.VtlBaseVisitor;
 import fr.insee.vtl.parser.VtlParser;
+import fr.insee.vtl.parser.antlr4.runtime.tree.ParseTree;
 import java.time.Instant;
 import java.time.OffsetDateTime;
 import java.time.ZonedDateTime;
@@ -18,7 +19,6 @@
 import java.util.Map;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
-import org.antlr.v4.runtime.tree.ParseTree;
 import org.threeten.extra.Interval;
 
 /**
diff --git a/vtl-engine/src/main/java/module-info.java b/vtl-engine/src/main/java/module-info.java
index 3032248ea..7c938e2a0 100644
--- a/vtl-engine/src/main/java/module-info.java
+++ b/vtl-engine/src/main/java/module-info.java
@@ -9,35 +9,29 @@
 /** This module contains the actual VTL engine. */
 module fr.insee.vtl.engine {
   exports fr.insee.vtl.engine.exceptions;
+  exports fr.insee.vtl.engine.processors;
 
   requires transitive java.scripting;
   requires transitive fr.insee.vtl.parser;
   requires transitive fr.insee.vtl.model;
 
+  // TODO: Consider removing these.
+  requires org.apache.commons.lang3;
+  requires org.apache.commons.text;
+  requires safety.mirror;
+  requires org.threeten.extra;
+  requires org.jgrapht.core;
+
   uses ProcessingEngine;
   uses ProcessingEngineFactory;
   uses FunctionProvider;
 
-  // exports fr.insee.vtl.engine.functions;
   provides FunctionProvider with
       LevenshteinProvider;
-
-  exports fr.insee.vtl.engine.processors;
-
   provides ProcessingEngineFactory with
       InMemoryProcessingEngine.Factory;
-
-  opens fr.insee.vtl.engine;
-
-  requires org.antlr.antlr4.runtime;
-
-  // TODO: Consider removing these.
-  requires org.apache.commons.lang3;
-  requires org.apache.commons.text;
-  requires safety.mirror;
-  requires org.threeten.extra;
-  requires org.jgrapht.core;
-
   provides ScriptEngineFactory with
       VtlScriptEngineFactory;
+
+  opens fr.insee.vtl.engine;
 }
diff --git a/vtl-engine/src/test/java/fr/insee/vtl/engine/utils/dag/DagDefineStatementsTest.java b/vtl-engine/src/test/java/fr/insee/vtl/engine/utils/dag/DagDefineStatementsTest.java
index 8881fa042..a572c79b6 100644
--- a/vtl-engine/src/test/java/fr/insee/vtl/engine/utils/dag/DagDefineStatementsTest.java
+++ b/vtl-engine/src/test/java/fr/insee/vtl/engine/utils/dag/DagDefineStatementsTest.java
@@ -6,15 +6,15 @@
 import fr.insee.vtl.model.exceptions.VtlScriptException;
 import fr.insee.vtl.parser.VtlLexer;
 import fr.insee.vtl.parser.VtlParser;
+import fr.insee.vtl.parser.antlr4.runtime.CharStreams;
+import fr.insee.vtl.parser.antlr4.runtime.CodePointCharStream;
+import fr.insee.vtl.parser.antlr4.runtime.CommonTokenStream;
+import fr.insee.vtl.parser.antlr4.runtime.tree.ParseTree;
+import fr.insee.vtl.parser.antlr4.runtime.tree.RuleNode;
+import fr.insee.vtl.parser.antlr4.runtime.tree.TerminalNode;
 import java.util.Set;
 import java.util.stream.Stream;
 import javax.script.ScriptException;
-import org.antlr.v4.runtime.CharStreams;
-import org.antlr.v4.runtime.CodePointCharStream;
-import org.antlr.v4.runtime.CommonTokenStream;
-import org.antlr.v4.runtime.tree.ParseTree;
-import org.antlr.v4.runtime.tree.RuleNode;
-import org.antlr.v4.runtime.tree.TerminalNode;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
diff --git a/vtl-engine/src/test/java/fr/insee/vtl/engine/visitors/expression/ConditionalExprTest.java b/vtl-engine/src/test/java/fr/insee/vtl/engine/visitors/expression/ConditionalExprTest.java
index 5ce05c628..37dd9efa0 100644
--- a/vtl-engine/src/test/java/fr/insee/vtl/engine/visitors/expression/ConditionalExprTest.java
+++ b/vtl-engine/src/test/java/fr/insee/vtl/engine/visitors/expression/ConditionalExprTest.java
@@ -69,6 +69,8 @@ public void testCaseExpr() throws ScriptException {
     assertThat(context.getAttribute("s2")).isEqualTo("yes");
     engine.eval("s3 := case when false then \"no\" when 1=2 then \"yes\" else \"else\";");
     assertThat(context.getAttribute("s3")).isEqualTo("else");
+    engine.eval("s4 := case when cast(null, boolean) then \"no\" else \"else\";");
+    assertThat(context.getAttribute("s4")).isEqualTo("else");
 
     engine.getContext().setAttribute("ds_1", DatasetSamples.ds1, ScriptContext.ENGINE_SCOPE);
     engine.getContext().setAttribute("ds_2", DatasetSamples.ds2, ScriptContext.ENGINE_SCOPE);
diff --git a/vtl-parser/pom.xml b/vtl-parser/pom.xml
index 4328b2160..cfe6b5699 100644
--- a/vtl-parser/pom.xml
+++ b/vtl-parser/pom.xml
@@ -28,6 +28,10 @@
             <groupId>org.antlr</groupId>
             <artifactId>antlr4-runtime</artifactId>
             <version>${antlr4.version}</version>
+            <scope>compile</scope>
+            <!-- Runtime is shaded/relocated into this module artifact;
+                 do not leak the original ANTLR runtime transitively. -->
+            <optional>true</optional>
         </dependency>
     </dependencies>
 
@@ -51,6 +55,98 @@
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <!-- Build the unshaded jar early (process-classes) so shade can transform it
+                     before tests run. Skip the default jar execution that would otherwise
+                     overwrite the shaded jar at the package phase. -->
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>3.4.2</version>
+                <executions>
+                    <execution>
+                        <id>default-jar</id>
+                        <phase>none</phase>
+                    </execution>
+                    <execution>
+                        <id>pre-shade-jar</id>
+                        <phase>process-classes</phase>
+                        <goals>
+                            <goal>jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.5.0</version>
+                <executions>
+                    <execution>
+                        <id>shade-antlr</id>
+                        <phase>process-classes</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <createDependencyReducedPom>false</createDependencyReducedPom>
+                            <artifactSet>
+                                <includes>
+                                    <include>org.antlr:antlr4-runtime</include>
+                                </includes>
+                            </artifactSet>
+
+                            <relocations>
+                                <relocation>
+                                    <pattern>org.antlr.v4</pattern>
+                                    <shadedPattern>fr.insee.vtl.parser.antlr4</shadedPattern>
+                                </relocation>
+                            </relocations>
+
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <!-- Inject a JPMS module-info into the shaded JAR. The source module-info.java
+                     only exports unshaded packages (so Surefire can read target/classes during test);
+                     this execution overwrites the JAR's module-info.class with one that also exports
+                     the relocated fr.insee.vtl.parser.antlr4.* packages produced by shade. -->
+                <groupId>org.moditect</groupId>
+                <artifactId>moditect-maven-plugin</artifactId>
+                <version>1.2.2.Final</version>
+                <executions>
+                    <execution>
+                        <id>add-shaded-module-info</id>
+                        <phase>process-classes</phase>
+                        <goals>
+                            <goal>add-module-info</goal>
+                        </goals>
+                        <configuration>
+                            <overwriteExistingFiles>true</overwriteExistingFiles>
+                            <outputDirectory>${project.build.directory}</outputDirectory>
+                            <modules>
+                                <module>
+                                    <file>${project.build.directory}/${project.build.finalName}.jar</file>
+                                    <moduleInfo>
+                                        <name>fr.insee.vtl.parser</name>
+                                        <exports>
+                                            fr.insee.vtl.parser;
+                                            fr.insee.vtl.parser.antlr4.runtime;
+                                            fr.insee.vtl.parser.antlr4.runtime.atn;
+                                            fr.insee.vtl.parser.antlr4.runtime.dfa;
+                                            fr.insee.vtl.parser.antlr4.runtime.misc;
+                                            fr.insee.vtl.parser.antlr4.runtime.tree;
+                                            fr.insee.vtl.parser.antlr4.runtime.tree.pattern;
+                                            fr.insee.vtl.parser.antlr4.runtime.tree.xpath;
+                                        </exports>
+                                        <opens>fr.insee.vtl.parser;</opens>
+                                    </moduleInfo>
+                                </module>
+                            </modules>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
 
         <!-- Needed so that the mvn test goal finds the ANTLR g4 files. -->
@@ -67,4 +163,4 @@
         </resources>
     </build>
 
-</project>
\ No newline at end of file
+</project>
diff --git a/vtl-parser/src/main/java/fr/insee/vtl/parser/package-info.java b/vtl-parser/src/main/java/fr/insee/vtl/parser/package-info.java
deleted file mode 100644
index 6d79e9fe0..000000000
--- a/vtl-parser/src/main/java/fr/insee/vtl/parser/package-info.java
+++ /dev/null
@@ -1,2 +0,0 @@
-/** This package exposes the constructs generated by Antlr from the VTL grammar files. */
-package fr.insee.vtl.parser;
diff --git a/vtl-prov/pom.xml b/vtl-prov/pom.xml
index 653070e44..1bb88721e 100644
--- a/vtl-prov/pom.xml
+++ b/vtl-prov/pom.xml
@@ -20,6 +20,10 @@
         <sonar.coverage.jacoco.xmlReportPaths>
             ${project.basedir}/../coverage/target/site/jacoco-aggregate/jacoco.xml
         </sonar.coverage.jacoco.xmlReportPaths>
+        <!-- Test-only Spark bridge: same public package fr.insee.vtl.spark.* in both artifacts. -->
+        <trevas.spark.integration.test.module>vtl-spark</trevas.spark.integration.test.module>
+        <trevas.spark.processing.engine>spark</trevas.spark.processing.engine>
+        <jackson.version>2.15.2</jackson.version>
     </properties>
 
     <dependencies>
@@ -39,11 +43,6 @@
             <artifactId>vtl-engine</artifactId>
             <version>2.4.0-SNAPSHOT</version>
         </dependency>
-        <dependency>
-            <groupId>fr.insee.trevas</groupId>
-            <artifactId>vtl-spark</artifactId>
-            <version>2.4.0-SNAPSHOT</version>
-        </dependency>
         <dependency>
             <groupId>fr.insee.trevas</groupId>
             <artifactId>vtl-model</artifactId>
@@ -63,9 +62,44 @@
             <version>3.17.0</version>
             <type>pom</type>
         </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-core</artifactId>
+            <version>${jackson.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-annotations</artifactId>
+            <version>${jackson.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>${jackson.version}</version>
+        </dependency>
+
+        <!-- Spark is not a compile dependency: applications add either vtl-spark or vtl-spark4.
+             Tests pick one module via trevas.spark.integration.test.module (profile spark4-tests). -->
+        <dependency>
+            <groupId>fr.insee.trevas</groupId>
+            <artifactId>${trevas.spark.integration.test.module}</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
 
     </dependencies>
 
+    <profiles>
+        <profile>
+            <id>spark4-tests</id>
+            <properties>
+                <trevas.spark.integration.test.module>vtl-spark4</trevas.spark.integration.test.module>
+                <trevas.spark.processing.engine>spark4</trevas.spark.processing.engine>
+                <jackson.version>2.18.2</jackson.version>
+            </properties>
+        </profile>
+    </profiles>
+
     <build>
         <plugins>
             <plugin>
@@ -74,6 +108,13 @@
                 <version>3.5.4</version>
                 <configuration>
                     <argLine>--add-exports java.base/sun.nio.ch=ALL-UNNAMED</argLine>
+                    <environmentVariables>
+                        <SPARK_USER>test</SPARK_USER>
+                        <HADOOP_USER_NAME>test</HADOOP_USER_NAME>
+                    </environmentVariables>
+                    <systemPropertyVariables>
+                        <trevas.spark.processing.engine>${trevas.spark.processing.engine}</trevas.spark.processing.engine>
+                    </systemPropertyVariables>
                 </configuration>
             </plugin>
         </plugins>
diff --git a/vtl-prov/src/main/java/fr/insee/vtl/prov/ProvenanceListener.java b/vtl-prov/src/main/java/fr/insee/vtl/prov/ProvenanceListener.java
index d80e37444..5cf7f08e9 100644
--- a/vtl-prov/src/main/java/fr/insee/vtl/prov/ProvenanceListener.java
+++ b/vtl-prov/src/main/java/fr/insee/vtl/prov/ProvenanceListener.java
@@ -4,6 +4,9 @@
 import fr.insee.vtl.parser.VtlBaseListener;
 import fr.insee.vtl.parser.VtlLexer;
 import fr.insee.vtl.parser.VtlParser;
+import fr.insee.vtl.parser.antlr4.runtime.*;
+import fr.insee.vtl.parser.antlr4.runtime.misc.Interval;
+import fr.insee.vtl.parser.antlr4.runtime.tree.ParseTreeWalker;
 import fr.insee.vtl.prov.prov.DataframeInstance;
 import fr.insee.vtl.prov.prov.Program;
 import fr.insee.vtl.prov.prov.ProgramStep;
@@ -15,9 +18,6 @@
 import java.util.Set;
 import javax.script.ScriptEngine;
 import javax.script.ScriptException;
-import org.antlr.v4.runtime.*;
-import org.antlr.v4.runtime.misc.Interval;
-import org.antlr.v4.runtime.tree.ParseTreeWalker;
 
 /** ANTLR Listener that create provenance objects. */
 public class ProvenanceListener extends VtlBaseListener {
diff --git a/vtl-prov/src/main/java/fr/insee/vtl/prov/Variable.java b/vtl-prov/src/main/java/fr/insee/vtl/prov/Variable.java
index 84d7343f2..9982d377b 100644
--- a/vtl-prov/src/main/java/fr/insee/vtl/prov/Variable.java
+++ b/vtl-prov/src/main/java/fr/insee/vtl/prov/Variable.java
@@ -1,9 +1,9 @@
 package fr.insee.vtl.prov;
 
+import fr.insee.vtl.parser.antlr4.runtime.ParserRuleContext;
+import fr.insee.vtl.parser.antlr4.runtime.Token;
+import fr.insee.vtl.parser.antlr4.runtime.misc.Interval;
 import java.util.Optional;
-import org.antlr.v4.runtime.ParserRuleContext;
-import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.misc.Interval;
 
 public class Variable {
 
diff --git a/vtl-prov/src/main/java/fr/insee/vtl/prov/VariableGraphListener.java b/vtl-prov/src/main/java/fr/insee/vtl/prov/VariableGraphListener.java
index 3e4748431..4ae148649 100644
--- a/vtl-prov/src/main/java/fr/insee/vtl/prov/VariableGraphListener.java
+++ b/vtl-prov/src/main/java/fr/insee/vtl/prov/VariableGraphListener.java
@@ -2,11 +2,11 @@
 
 import fr.insee.vtl.parser.VtlBaseListener;
 import fr.insee.vtl.parser.VtlParser;
+import fr.insee.vtl.parser.antlr4.runtime.ParserRuleContext;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
-import org.antlr.v4.runtime.ParserRuleContext;
 import org.jgrapht.graph.DefaultDirectedGraph;
 import org.jgrapht.graph.DefaultEdge;
 
diff --git a/vtl-prov/src/main/java/fr/insee/vtl/prov/utils/AntlrUtils.java b/vtl-prov/src/main/java/fr/insee/vtl/prov/utils/AntlrUtils.java
index d63257f5c..6a0199e3a 100644
--- a/vtl-prov/src/main/java/fr/insee/vtl/prov/utils/AntlrUtils.java
+++ b/vtl-prov/src/main/java/fr/insee/vtl/prov/utils/AntlrUtils.java
@@ -2,10 +2,10 @@
 
 import fr.insee.vtl.parser.VtlLexer;
 import fr.insee.vtl.parser.VtlParser;
+import fr.insee.vtl.parser.antlr4.runtime.*;
+import fr.insee.vtl.parser.antlr4.runtime.misc.Interval;
 import java.util.HashMap;
 import java.util.Map;
-import org.antlr.v4.runtime.*;
-import org.antlr.v4.runtime.misc.Interval;
 
 public class AntlrUtils {
 
diff --git a/vtl-prov/src/test/java/fr/insee/vtl/prov/ProvenanceListenerTest.java b/vtl-prov/src/test/java/fr/insee/vtl/prov/ProvenanceListenerTest.java
index fb2f07326..546615bd7 100644
--- a/vtl-prov/src/test/java/fr/insee/vtl/prov/ProvenanceListenerTest.java
+++ b/vtl-prov/src/test/java/fr/insee/vtl/prov/ProvenanceListenerTest.java
@@ -26,11 +26,11 @@ public class ProvenanceListenerTest {
 
   @BeforeEach
   public void setUp() {
-    SparkSession spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession spark = TestSparkSessionFactory.create();
 
     ScriptEngineManager mgr = new ScriptEngineManager();
     engine = mgr.getEngineByExtension("vtl");
-    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark");
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, TestSparkEngineConfig.getEngineName());
     engine.put("$vtl.spark.session", spark);
   }
 
diff --git a/vtl-prov/src/test/java/fr/insee/vtl/prov/RDFTest.java b/vtl-prov/src/test/java/fr/insee/vtl/prov/RDFTest.java
index 8d5870e1d..00a2fced8 100644
--- a/vtl-prov/src/test/java/fr/insee/vtl/prov/RDFTest.java
+++ b/vtl-prov/src/test/java/fr/insee/vtl/prov/RDFTest.java
@@ -61,11 +61,11 @@ void loadBlueprintConfig() {
     RDFUtils.loadModelWithCredentials(
         model, sparqlEndpoint, sparqlEndpointUser, sparlqEndpointPassword);
 
-    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    spark = TestSparkSessionFactory.create();
 
     ScriptEngineManager mgr = new ScriptEngineManager();
     engine = mgr.getEngineByExtension("vtl");
-    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark");
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, TestSparkEngineConfig.getEngineName());
     engine.put("$vtl.spark.session", spark);
   }
 
diff --git a/vtl-prov/src/test/java/fr/insee/vtl/prov/TestSparkEngineConfig.java b/vtl-prov/src/test/java/fr/insee/vtl/prov/TestSparkEngineConfig.java
new file mode 100644
index 000000000..192c6234d
--- /dev/null
+++ b/vtl-prov/src/test/java/fr/insee/vtl/prov/TestSparkEngineConfig.java
@@ -0,0 +1,13 @@
+package fr.insee.vtl.prov;
+
+final class TestSparkEngineConfig {
+
+  private static final String ENGINE_PROPERTY = "trevas.spark.processing.engine";
+  private static final String DEFAULT_ENGINE = "spark";
+
+  private TestSparkEngineConfig() {}
+
+  static String getEngineName() {
+    return System.getProperty(ENGINE_PROPERTY, DEFAULT_ENGINE);
+  }
+}
diff --git a/vtl-prov/src/test/java/fr/insee/vtl/prov/TestSparkSessionFactory.java b/vtl-prov/src/test/java/fr/insee/vtl/prov/TestSparkSessionFactory.java
new file mode 100644
index 000000000..d725b0581
--- /dev/null
+++ b/vtl-prov/src/test/java/fr/insee/vtl/prov/TestSparkSessionFactory.java
@@ -0,0 +1,18 @@
+package fr.insee.vtl.prov;
+
+import org.apache.spark.sql.SparkSession;
+
+final class TestSparkSessionFactory {
+
+  private TestSparkSessionFactory() {}
+
+  static SparkSession create() {
+    return SparkSession.builder()
+        .appName("test")
+        .master("local")
+        .config("spark.driver.bindAddress", "127.0.0.1")
+        .config("spark.driver.host", "127.0.0.1")
+        .config("spark.ui.enabled", "false")
+        .getOrCreate();
+  }
+}
diff --git a/vtl-prov/src/test/java/fr/insee/vtl/prov/VariableGraphListenerTest.java b/vtl-prov/src/test/java/fr/insee/vtl/prov/VariableGraphListenerTest.java
index 9ce99a699..c6aff3329 100644
--- a/vtl-prov/src/test/java/fr/insee/vtl/prov/VariableGraphListenerTest.java
+++ b/vtl-prov/src/test/java/fr/insee/vtl/prov/VariableGraphListenerTest.java
@@ -4,11 +4,11 @@
 
 import fr.insee.vtl.parser.VtlLexer;
 import fr.insee.vtl.parser.VtlParser;
+import fr.insee.vtl.parser.antlr4.runtime.CharStreams;
+import fr.insee.vtl.parser.antlr4.runtime.CodePointCharStream;
+import fr.insee.vtl.parser.antlr4.runtime.CommonTokenStream;
+import fr.insee.vtl.parser.antlr4.runtime.tree.ParseTreeWalker;
 import java.util.Set;
-import org.antlr.v4.runtime.CharStreams;
-import org.antlr.v4.runtime.CodePointCharStream;
-import org.antlr.v4.runtime.CommonTokenStream;
-import org.antlr.v4.runtime.tree.ParseTreeWalker;
 import org.jgrapht.Graph;
 import org.jgrapht.graph.DefaultDirectedGraph;
 import org.jgrapht.graph.DefaultEdge;
diff --git a/vtl-spark/pom.xml b/vtl-spark/pom.xml
index d80045813..fca333427 100644
--- a/vtl-spark/pom.xml
+++ b/vtl-spark/pom.xml
@@ -36,8 +36,7 @@
         </dependency>
         <dependency>
             <groupId>org.apache.spark</groupId>
-            <artifactId>spark-sql_2.12</artifactId>
-            <version>3.5.8</version>
+            <artifactId>spark-sql_${spark3.scala.binary}</artifactId>
         </dependency>
 
         <dependency>
diff --git a/vtl-spark/src/test/java/fr/insee/vtl/spark/SparkDatasetTest.java b/vtl-spark/src/test/java/fr/insee/vtl/spark/SparkDatasetTest.java
index d0e97f7dd..fdd105926 100644
--- a/vtl-spark/src/test/java/fr/insee/vtl/spark/SparkDatasetTest.java
+++ b/vtl-spark/src/test/java/fr/insee/vtl/spark/SparkDatasetTest.java
@@ -29,7 +29,14 @@ public class SparkDatasetTest {
 
   @BeforeEach
   public void setUp() {
-    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    spark =
+        SparkSession.builder()
+            .appName("test")
+            .master("local")
+            .config("spark.driver.bindAddress", "127.0.0.1")
+            .config("spark.driver.host", "127.0.0.1")
+            .config("spark.ui.enabled", "false")
+            .getOrCreate();
 
     ScriptEngineManager mgr = new ScriptEngineManager();
     engine = mgr.getEngineByExtension("vtl");
diff --git a/vtl-spark/src/test/java/fr/insee/vtl/spark/processing.engine/CalcTest.java b/vtl-spark/src/test/java/fr/insee/vtl/spark/processing.engine/CalcTest.java
index 0f5ce5d27..933d53ca3 100644
--- a/vtl-spark/src/test/java/fr/insee/vtl/spark/processing.engine/CalcTest.java
+++ b/vtl-spark/src/test/java/fr/insee/vtl/spark/processing.engine/CalcTest.java
@@ -6,6 +6,7 @@
 import fr.insee.vtl.model.Dataset;
 import fr.insee.vtl.model.InMemoryDataset;
 import fr.insee.vtl.model.Structured;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import javax.script.ScriptContext;
@@ -79,4 +80,40 @@ public void testCalcClause() throws ScriptException, InterruptedException {
             new Structured.Component("weight", Long.class, Dataset.Role.MEASURE),
             new Structured.Component("wisdom", Double.class, Dataset.Role.ATTRIBUTE));
   }
+
+  @Test
+  public void testCaseElseAppliesWhenWhenConditionIsNull() throws ScriptException {
+    ScriptContext context = engine.getContext();
+
+    Map<String, Object> r4 = new HashMap<>();
+    r4.put("name", "NullGuy");
+    r4.put("me_1", null);
+
+    InMemoryDataset dsWithNull =
+        new InMemoryDataset(
+            List.of(
+                Map.of("name", "A", "me_1", 0.12D),
+                Map.of("name", "B", "me_1", 3.5D),
+                Map.of("name", "C", "me_1", 10.7D),
+                r4),
+            Map.of("name", String.class, "me_1", Double.class),
+            Map.of("name", Dataset.Role.IDENTIFIER, "me_1", Dataset.Role.MEASURE));
+
+    context.setAttribute("ds_null", dsWithNull, ScriptContext.ENGINE_SCOPE);
+    engine.eval(
+        "res := ds_null[calc me_2 := case when me_1 <= 1 then 0 when me_1 > 1 and me_1 <= 10 then 1 when me_1 > 10 then 10 else 100];");
+
+    Dataset res = (Dataset) context.getAttribute("res");
+    assertThat(res.getDataAsMap())
+        .contains(
+            Map.of("name", "A", "me_1", 0.12D, "me_2", 0L),
+            Map.of("name", "B", "me_1", 3.5D, "me_2", 1L),
+            Map.of("name", "C", "me_1", 10.7D, "me_2", 10L));
+
+    Map<String, Object> expectedNullRow = new HashMap<>();
+    expectedNullRow.put("name", "NullGuy");
+    expectedNullRow.put("me_1", null);
+    expectedNullRow.put("me_2", 100L);
+    assertThat(res.getDataAsMap()).contains(expectedNullRow);
+  }
 }
diff --git a/vtl-spark4/README.md b/vtl-spark4/README.md
new file mode 100644
index 000000000..dbc8108ac
--- /dev/null
+++ b/vtl-spark4/README.md
@@ -0,0 +1,3 @@
+# VTL Spark
+
+[![Maven Central](https://maven-badges.herokuapp.com/maven-central/fr.insee.trevas/vtl-spark/badge.svg)](https://maven-badges.herokuapp.com/maven-central/fr.insee.trevas/vtl-spark)
diff --git a/vtl-spark4/docs/Analytic_invocation.md b/vtl-spark4/docs/Analytic_invocation.md
new file mode 100644
index 000000000..f82b6e464
--- /dev/null
+++ b/vtl-spark4/docs/Analytic_invocation.md
@@ -0,0 +1,118 @@
+# Analytic invocation 
+
+## General form:
+
+`analyticOperator`(firstOperand { , additionalOperand }* **over** ( `analyticClause` ) )
+- `analyticOperator` ::= **avg | count | max | median | min | stddev_pop| stddev_samp | sum | var_pop | var_samp | first_value | lag | last_value | lead | rank | ratio_to_report**
+- `analyticClause` ::= { `partitionClause` } { `orderClause` } { `windowClause` }
+    - `partitionClause` ::= **partition by** identifier { , identifier }*
+    - `orderClause` ::= **order by** component { **asc | desc** } {, component { **asc | desc** } }*
+    - `windowClause` ::= { **data points** | **range** } **between** limitClause **and** `limitClause`
+        - `limitClause` ::= { num **preceding** | num **following** | **current data point** | **unbounded preceding** | **unbounded following** }
+
+### expression specification
+- `analyticOperator`: is the keyword of the analytic operator to invoke (e.g., avg, count, max, etc.)
+- `firstOperand`: is the first operand of the invoked analytic operator (a Data Set for an invocation at Data Set level 
+                  or a Component of the input Data Set for an invocation at Component level within a calc operator 
+                  or a calc clause in a join operation)
+- `additionalOperand`: an additional operand (if any) of the invoked operator. The various operators can have 
+                     a different number of parameters. The number of parameters, their types and if they
+                     are mandatory or optional depend on the invoked operator
+- `analyticClause`: is the clause that specifies the dataset reorganization(partitions, orders and sliding windows).
+- `partitionClause`: is the clause that specifies how to partition Data Points in groups to be analysed separately.
+                    The input Data Set is partitioned according to the values of one or more columns (Identifier Components). 
+                    If the clause is omitted, **then the Data Set is partitioned by the Identifier Components that are not specified in the orderClause.**
+- `orderClause`: is the clause that specifies how to order the Data Points. The input Data Set is ordered
+                 according to the values of one or more Components, in ascending order if asc is
+                 specified, in descending order if desc is specified, by default in ascending order if the
+                 asc and desc keywords are omitted.
+- `windowClause`: is the clause that specifies how to apply a sliding window on the ordered Data Points. 
+      - The keyword **data points** means that the sliding window includes a certain number of Data Points 
+                  before and after the current Data Point in the order given by the
+                  orderClause. 
+      - The keyword **range** means that the sliding windows includes all the Data Points whose values are in a certain 
+                 range in respect to the value, for the current Data Point, of the Measure which the analytic is applied to.
+
+- `limitClause`: is the clause that can specify either the lower or the upper boundaries of the sliding window. 
+                 Each boundary is specified in relationship either to the whole partition or to the
+                 current data point under analysis by using the following keywords:
+                 - **unbounded preceding** means that the sliding window starts at the first Data Point 
+                   of the partition (it make sense only as the first limit of the window)
+                 - **unbounded following** indicates that the sliding window ends at the last Data Point
+                   of the partition (it makes sense only as the second limit of the window)
+                 - current data point specifies that the window starts or ends at the current Data Point.
+                 - num **preceding** specifies either the number of **data points** to consider preceding
+                   the current data point in the order given by the orderClause (when **data points** is
+                   specified in the window clause), or the maximum difference to consider, as for the
+                   Measure which the analytic is applied to, between the value of the current Data
+                   Point and the generic other Data Point (when **range** is specified in the windows clause).
+                 - num **following** specifies either the number of data points to consider following the
+                    current data point in the order given by the orderClause (when **data points** is
+                    specified in the window clause), or the maximum difference to consider, as for the
+                    Measure which the analytic is applied to, between the values of the generic other
+                   Data Point and the current Data Point (when **range** is specified in the windows clause).
+                If the whole windowClause is omitted then **the default is data points between unbounded preceding and current data point.**
+
+- `identifier`: is an Identifier Component of the input Data Set. (e.g. column_name)
+- `component`: a Component of the input Data Set (e.g. column name)
+- `num`: a scalar number
+
+### Examples of valid syntaxes
+```text
+sum ( DS_1 over ( partition by Id_1 order by Id_2 ) )
+sum ( DS_1 over ( order by Id_2 ) )
+avg ( DS_1 over ( order by Id_1 data points between 1 preceding and 1 following ) )
+DS_1 [ calc M1 := sum ( Me_1 over ( order by Id_1 ) ) ]
+```
+
+
+### parameter datatype:
+Input:
+- firstOperand :: dataset | component
+- additionalOperand :: type of the (possible) additional parameter of the invoked operator
+- identifier :: name<identifier>
+- component :: name<component>
+- num :: integer
+
+Output : 
+- result :: dataset | component
+
+
+### Additional constraints
+
+- The analytic invocation cannot be nested in other Aggregate or Analytic invocations.
+- The analytic operations at component level can be invoked within the calc clause, both as part of a Join operator
+and the calc operator (see the parameter calcExpr of those operators).
+- The basic scalar types of firstOperand and additionalOperand (if any) must be compliant with the specific basic
+scalar types required by the invoked operator (the required basic scalar types are described in the table at the
+beginning of this chapter and in the sections of the various operators below).
+
+### Behaviour
+
+The analytic Operator is applied as usual to all the Measures of the input Data Set (if invoked at Data Set level) or
+to the specified Component of the input Data Set (if invoked at Component level). In both cases, the operator
+calculates the desired output values for each Data Point of the input Data Set.
+The behaviour of the analytic operations can be procedurally described as follows:
+- The Data Points of the input Data Set are first partitioned (according to partitionBy) and then ordered
+(according to orderBy).
+- The operation is performed for each Data Point (named “current Data Point”) of the input Data Set. For each
+input Data Point, one output Data Point is returned, having the same values of the Identifiers. The analytic
+operator is applied to a “window” which includes a set of Data Points of the input Data Set and returns the
+values of the Measure(s) of the output Data Point.
+    - If windowClause is not specified, then the set of Data Points which contribute to the analytic operation is
+         the whole partition which the current Data Point belongs to
+    - If windowClause is specified, then the set of Data Points is the one specified by windowClause (see
+         windowsClause and LimitClause explained above).
+
+For the invocation at Data Set level, the resulting Data Set has the same Measures as the input Data Set
+`firstOperand`. For the invocation at Component level, the resulting Data Set has the Measures of the input Data
+Set plus the Measures explicitly calculated through the `calc` clause.
+
+For the invocation at Data Set level, the Attribute propagation rule is applied. For invocation at Component level,
+the Attributes calculated within the calc clause are maintained in the result; for all the other Attributes that are
+defined as viral, the Attribute propagation rule is applied (for the semantics, see the Attribute Propagation Rule
+section in the User Manual).
+
+As mentioned, the Analytic invocation at component level can be done within the `calc` clause, both as part of a
+Join operator and the `calc` operator (see the parameter aggrCalc of those operators), therefore, for a better
+comprehension fo the behaviour at Component level, see also those operators
diff --git a/vtl-spark4/docs/expression_visitor.md b/vtl-spark4/docs/expression_visitor.md
new file mode 100644
index 000000000..289c68eff
--- /dev/null
+++ b/vtl-spark4/docs/expression_visitor.md
@@ -0,0 +1,56 @@
+# How to parse an expression via Antlr
+
+## Step 1: Check if the expression is already in the grammar (Vtl.g4)
+## Step 2: Choose two possible way to parse the expression (visitor vs listeners)
+
+### When to use visitor or listeners
+
+If you plan to directly use the parser output for interpretation, the visitor is a good choice. You have full 
+control of the traversal, so in conditionals only one branch is visited, loops can be visited n times and so on.
+
+If you translate the input to a lower level, e.g. virtual machine instructions, both patterns may be useful.
+
+You might take a look at "Language Implementation Patterns", which covers the basic interpreter implementations.
+
+**Trevas uses the visitor pattern, as it's more flexible**.
+
+## Step 3 : Identify, Overwrite the visitor generate by Antlr
+
+When you overwrite the visitor, you need to parse the token and context to some types that you want to reuse in the 
+`ProcessingEngine`.
+
+After the parse of the token, then it calls the processingEngine to evaluate the parsed expression 
+
+Check the code of **fr/insee/vtl/engine/visitors/AnalyticsVisitor.java** which parses below grammar. 
+
+In the **fr/insee/vtl/model/Analytics.java**, we define all the types that we want to use to replace the Antlr generated
+token type.
+
+```antlrv4
+anFunction:
+    op = ( SUM
+        | AVG
+        | COUNT
+        | MEDIAN
+        | MIN
+        | MAX
+        | STDDEV_POP
+        | STDDEV_SAMP
+        | VAR_POP
+        | VAR_SAMP
+        | FIRST_VALUE
+        | LAST_VALUE)
+        LPAREN expr OVER LPAREN (partition=partitionByClause? orderBy=orderByClause? windowing=windowingClause?)RPAREN RPAREN       #anSimpleFunction
+    | op=(LAG |LEAD)  LPAREN expr (COMMA offet=signedInteger(defaultValue=constant)?)?  OVER  LPAREN (partition=partitionByClause? orderBy=orderByClause)   RPAREN RPAREN    # lagOrLeadAn
+    | op=RATIO_TO_REPORT LPAREN expr OVER  LPAREN (partition=partitionByClause) RPAREN RPAREN               
+```
+
+## Step 4. Implement the evaluation logic in ProcessingEngine
+
+
+### 4.1 Define method signature in the interface
+
+Note to make low level evaluation logic independent of the parser. The `ProcessingEngine` (fr/insee/vtl/model/ProcessingEngine.java) 
+is an interface. For now, trevas has two concrete implementations of this interface (e.g. spark, in-memory) 
+
+### 4.2 Implement the method in the concrete ProcessingEngine implementation. 
\ No newline at end of file
diff --git a/vtl-spark4/pom.xml b/vtl-spark4/pom.xml
new file mode 100644
index 000000000..b5eb9784b
--- /dev/null
+++ b/vtl-spark4/pom.xml
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>fr.insee.trevas</groupId>
+        <artifactId>trevas-parent</artifactId>
+        <version>2.4.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>vtl-spark4</artifactId>
+    <name>VTL Spark4</name>
+    <description>Trevas engine for Apache Spark 4</description>
+    <version>2.4.0-SNAPSHOT</version>
+
+    <properties>
+        <sonar.coverage.jacoco.xmlReportPaths>
+            ${project.basedir}/../coverage/target/site/jacoco-aggregate/jacoco.xml
+        </sonar.coverage.jacoco.xmlReportPaths>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>fr.insee.trevas</groupId>
+            <artifactId>vtl-model</artifactId>
+            <version>2.4.0-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>fr.insee.trevas</groupId>
+            <artifactId>vtl-engine</artifactId>
+            <version>2.4.0-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.spark</groupId>
+            <artifactId>spark-sql_${spark4.scala.binary}</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <version>2.4.240</version>
+            <scope>test</scope>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.5.3</version>
+                <configuration>
+                    <argLine>--add-exports java.base/sun.nio.ch=ALL-UNNAMED</argLine>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>3.4.2</version>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
diff --git a/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkDataset.java b/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkDataset.java
new file mode 100644
index 000000000..c8930e181
--- /dev/null
+++ b/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkDataset.java
@@ -0,0 +1,314 @@
+package fr.insee.vtl.spark;
+
+import static org.apache.spark.sql.types.DataTypes.*;
+
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.Structured;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.util.*;
+import java.util.stream.Collectors;
+import org.apache.spark.sql.Column;
+import org.apache.spark.sql.Row;
+import org.apache.spark.sql.RowFactory;
+import org.apache.spark.sql.SparkSession;
+import org.apache.spark.sql.types.*;
+
+/** The <code>SparkDataset</code> class is a wrapper around a Spark dataframe. */
+public class SparkDataset implements Dataset {
+
+  private final org.apache.spark.sql.Dataset<Row> sparkDataset;
+  private DataStructure dataStructure = null;
+  private Map<String, Role> roles = Collections.emptyMap();
+  private Map<String, String> valuedomains = Collections.emptyMap();
+
+  /**
+   * Constructor taking a Spark dataset.
+   *
+   * @param sparkDataset a Spark dataset.
+   */
+  public SparkDataset(org.apache.spark.sql.Dataset<Row> sparkDataset) {
+    org.apache.spark.sql.Dataset<Row> casted = castIfNeeded(sparkDataset);
+    this.sparkDataset = casted;
+    this.dataStructure = fromSparkSchema(casted.schema(), Map.of(), Map.of());
+  }
+
+  /**
+   * Constructor taking a Spark dataset and a structure.
+   *
+   * @param sparkDataset a Spark dataset.
+   * @param structure a Data Structure.
+   */
+  public SparkDataset(org.apache.spark.sql.Dataset<Row> sparkDataset, DataStructure structure) {
+    org.apache.spark.sql.Dataset<Row> castedSparkDataset =
+        castIfNeeded(Objects.requireNonNull(sparkDataset));
+    this.sparkDataset = addMetadata(castedSparkDataset, structure);
+    this.dataStructure = structure;
+    this.roles =
+        Objects.requireNonNull(
+            structure.entrySet().stream()
+                .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().getRole())));
+    this.valuedomains =
+        Objects.requireNonNull(
+            structure.entrySet().stream()
+                .filter(e -> null != e.getValue().getValuedomain())
+                .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().getValuedomain())));
+  }
+
+  /**
+   * Constructor taking a {@link Dataset}, a mapping of component names and roles, and a Spark
+   * session.
+   *
+   * @param vtlDataset a VTL dataset.
+   * @param roles a map between component names and their roles in the dataset.
+   * @param spark a Spark session to use for the creation of the Spark dataset.
+   */
+  public SparkDataset(Dataset vtlDataset, Map<String, Role> roles, SparkSession spark) {
+    List<Row> rows =
+        vtlDataset.getDataPoints().stream()
+            .map(
+                dataPoint -> {
+                  // Convert Instant to Date for Spark compatibility
+                  Object[] values =
+                      dataPoint.stream()
+                          .map(
+                              obj -> {
+                                if (obj instanceof java.time.Instant instant) {
+                                  return java.sql.Date.valueOf(
+                                      instant.atZone(java.time.ZoneOffset.UTC).toLocalDate());
+                                }
+                                return obj;
+                              })
+                          .toArray();
+                  return RowFactory.create(values);
+                })
+            .collect(Collectors.toList());
+    // TODO: Handle nullable with component
+    StructType schema = toSparkSchema(vtlDataset.getDataStructure());
+    this.sparkDataset = spark.createDataFrame(rows, schema);
+    this.roles = Objects.requireNonNull(roles);
+    this.dataStructure = vtlDataset.getDataStructure();
+  }
+
+  /**
+   * Constructor taking a Spark dataset and a mapping of component names and roles.
+   *
+   * @param sparkDataset a Spark dataset.
+   * @param roles a map between component names and their roles in the dataset.
+   */
+  public SparkDataset(org.apache.spark.sql.Dataset<Row> sparkDataset, Map<String, Role> roles) {
+    org.apache.spark.sql.Dataset<Row> castedSparkDataset =
+        castIfNeeded(Objects.requireNonNull(sparkDataset));
+    DataStructure dataStructure = fromSparkSchema(sparkDataset.schema(), roles, Map.of());
+    this.sparkDataset = addMetadata(castedSparkDataset, dataStructure);
+    this.dataStructure = dataStructure;
+    this.roles = Objects.requireNonNull(roles);
+  }
+
+  /** Cast integer and float types to long and double efficiently. */
+  private static org.apache.spark.sql.Dataset<Row> castIfNeeded(
+      org.apache.spark.sql.Dataset<Row> sparkDataset) {
+    StructType schema = sparkDataset.schema();
+
+    List<Column> castedColumns =
+        Arrays.stream(schema.fields())
+            .map(
+                field -> {
+                  DataType type = field.dataType();
+                  Column col = SparkUtils.safeCol(field.name());
+                  if (type instanceof IntegerType
+                      || type instanceof FloatType
+                      || type instanceof DecimalType) {
+                    return col.cast(
+                            type instanceof IntegerType ? DataTypes.LongType : DataTypes.DoubleType)
+                        .alias(field.name());
+                  }
+                  return col;
+                })
+            .toList();
+
+    return sparkDataset.select(castedColumns.toArray(new Column[0]));
+  }
+
+  /** Convert Spark schema to VTL DataStructure efficiently. */
+  public static DataStructure fromSparkSchema(
+      StructType schema, Map<String, Role> roles, Map<String, String> valuedomains) {
+    return new DataStructure(
+        Arrays.stream(schema.fields())
+            .map(
+                field ->
+                    new Component(
+                        field.name(),
+                        extractVtlType(field),
+                        handleRole(field, roles),
+                        null,
+                        handleValuedomain(field, valuedomains)))
+            .collect(Collectors.toList()));
+  }
+
+  /** Add metadata to dataset in a single transformation step. */
+  private static org.apache.spark.sql.Dataset<Row> addMetadata(
+      org.apache.spark.sql.Dataset<Row> sparkDataset, DataStructure structure) {
+    StructType updatedSchema = toSparkSchema(structure);
+
+    return sparkDataset.select(
+        Arrays.stream(updatedSchema.fields())
+            .map(field -> SparkUtils.safeCol(field.name()).as(field.name(), field.metadata()))
+            .toArray(Column[]::new));
+  }
+
+  /**
+   * Transforms a {@link DataStructure} into a Spark schema.
+   *
+   * @param structure the dataset structure to transform
+   * @return The resulting Spark schema (<code>StructType</code> object).
+   */
+  public static StructType toSparkSchema(DataStructure structure) {
+    List<StructField> schema = new ArrayList<>();
+    for (Component component : structure.values()) {
+      Object vd = null == component.getValuedomain() ? null : component.getValuedomain();
+      Map<String, Object> map = new HashMap<>();
+      map.put("vtlRole", component.getRole().name());
+      map.put("vtlValuedomain", vd);
+      map.put("vtlType", component.getType().getName());
+      scala.collection.immutable.Map<String, Object> md =
+          scala.collection.immutable.Map.from(scala.jdk.javaapi.CollectionConverters.asScala(map));
+      schema.add(
+          DataTypes.createStructField(
+              component.getName(), fromVtlType(component.getType()), true, new Metadata(md)));
+    }
+    return DataTypes.createStructType(schema);
+  }
+
+  private static Role handleRole(StructField field, Map<String, Role> roles) {
+    Role fieldRole;
+    if (roles.containsKey(field.name())) {
+      fieldRole = roles.get(field.name());
+    } else if (field.metadata().contains("vtlRole")) {
+      String roleName = field.metadata().getString("vtlRole");
+      fieldRole = Role.valueOf(roleName);
+    } else {
+      fieldRole = Role.MEASURE;
+    }
+    return fieldRole;
+  }
+
+  private static String handleValuedomain(StructField field, Map<String, String> valuedomains) {
+    String valuedomain;
+    if (valuedomains.containsKey(field.name())) {
+      valuedomain = valuedomains.get(field.name());
+    } else if (field.metadata().contains("vtlValuedomain")) {
+      valuedomain = field.metadata().getString("vtlValuedomain");
+    } else {
+      valuedomain = null;
+    }
+    return valuedomain;
+  }
+
+  /**
+   * Translates a Spark data type into a VTL data type.
+   *
+   * @param dataType the Spark {@link DataType} to translate.
+   * @return The corresponding VTL data type as a class.
+   */
+  public static Class<?> toVtlType(DataType dataType) {
+    if (StringType.sameType(dataType)) {
+      return String.class;
+    } else if (IntegerType.sameType(dataType)) {
+      return Long.class;
+    } else if (LongType.sameType(dataType)) {
+      return Long.class;
+    } else if (FloatType.sameType(dataType)) {
+      return Double.class;
+    } else if (DoubleType.sameType(dataType)) {
+      return Double.class;
+    } else if (BooleanType.sameType(dataType)) {
+      return Boolean.class;
+    } else if (DecimalType.class.equals(dataType.getClass())) {
+      return Double.class;
+    } else if (DateType.sameType(dataType) || TimestampType.sameType(dataType)) {
+      return Instant.class;
+    } else {
+      throw new UnsupportedOperationException("unsupported type " + dataType);
+    }
+  }
+
+  /**
+   * Translates a VTL data type into a Spark data type.
+   *
+   * @param type the VTL data type to translate (as a class).
+   * @return The corresponding Spark {@link DataType}.
+   */
+  public static DataType fromVtlType(Class<?> type) {
+    if (String.class.equals(type)) {
+      return StringType;
+    } else if (Long.class.equals(type)) {
+      return LongType;
+    } else if (Double.class.equals(type)) {
+      return DoubleType;
+    } else if (Boolean.class.equals(type)) {
+      return BooleanType;
+    } else if (Instant.class.equals(type) || LocalDate.class.equals(type)) {
+      return DateType;
+    } else {
+      throw new UnsupportedOperationException("unsupported type " + type);
+    }
+  }
+
+  private static Class<?> extractVtlType(StructField field) {
+    if (field.metadata().contains("vtlType")) {
+      try {
+        return Class.forName(field.metadata().getString("vtlType"));
+      } catch (ClassNotFoundException e) {
+        throw new IllegalStateException("Unknown VTL type in metadata", e);
+      }
+    }
+    return toVtlType(field.dataType());
+  }
+
+  /**
+   * Returns the Spark dataset.
+   *
+   * @return The Spark dataset.
+   */
+  public org.apache.spark.sql.Dataset<Row> getSparkDataset() {
+    return sparkDataset;
+  }
+
+  @Override
+  public List<DataPoint> getDataPoints() {
+    List<Row> rows = sparkDataset.collectAsList();
+    return rows.stream()
+        .map(
+            row -> {
+              List<Object> values = new ArrayList<>();
+              int i = 0;
+              for (Component component : getDataStructure().values()) {
+                Object v = row.get(i++);
+                if (component.getType().equals(Instant.class)) {
+                  if (v instanceof java.time.LocalDate ld) {
+                    values.add(ld.atStartOfDay().toInstant(java.time.ZoneOffset.UTC));
+                  } else if (v instanceof java.sql.Date d) {
+                    values.add(d.toLocalDate().atStartOfDay().toInstant(java.time.ZoneOffset.UTC));
+                  } else if (v instanceof java.sql.Timestamp ts) {
+                    values.add(ts.toInstant());
+                  } else {
+                    values.add(v);
+                  }
+                } else {
+                  values.add(v);
+                }
+              }
+              return new DataPoint(getDataStructure(), values);
+            })
+        .collect(Collectors.toList());
+  }
+
+  @Override
+  public Structured.DataStructure getDataStructure() {
+    if (dataStructure == null) {
+      dataStructure = fromSparkSchema(sparkDataset.schema(), roles, valuedomains);
+    }
+    return dataStructure;
+  }
+}
diff --git a/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkDatasetExpression.java b/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkDatasetExpression.java
new file mode 100644
index 000000000..3f0290a80
--- /dev/null
+++ b/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkDatasetExpression.java
@@ -0,0 +1,36 @@
+package fr.insee.vtl.spark;
+
+import fr.insee.vtl.model.DatasetExpression;
+import fr.insee.vtl.model.Positioned;
+import fr.insee.vtl.model.Structured;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * The <code>SparkDatasetExpression</code> class represents a VTL dataset expression involving a
+ * Spark dataset.
+ */
+public class SparkDatasetExpression extends DatasetExpression implements Positioned {
+
+  private final SparkDataset dataset;
+
+  /**
+   * Constructor taking a {@link SparkDataset}.
+   *
+   * @param dataset The Spark dataset used in the expression.
+   */
+  public SparkDatasetExpression(SparkDataset dataset, Positioned position) {
+    super(position);
+    this.dataset = Objects.requireNonNull(dataset);
+  }
+
+  @Override
+  public SparkDataset resolve(Map<String, Object> context) {
+    return dataset;
+  }
+
+  @Override
+  public Structured.DataStructure getDataStructure() {
+    return dataset.getDataStructure();
+  }
+}
diff --git a/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkFilterFunction.java b/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkFilterFunction.java
new file mode 100644
index 000000000..a44d32e6a
--- /dev/null
+++ b/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkFilterFunction.java
@@ -0,0 +1,30 @@
+package fr.insee.vtl.spark;
+
+import fr.insee.vtl.model.ResolvableExpression;
+import org.apache.spark.api.java.function.FilterFunction;
+import org.apache.spark.sql.Row;
+
+/**
+ * The <code>SparkFilterFunction</code> class is a wrapper around a filter expression operating on
+ * rows of a Spark dataset.
+ */
+public class SparkFilterFunction implements FilterFunction<Row> {
+
+  private final ResolvableExpression expression;
+
+  /**
+   * Constructor taking a VTL expression.
+   *
+   * @param expression the VTL expression.
+   */
+  public SparkFilterFunction(ResolvableExpression expression) {
+    this.expression = expression;
+  }
+
+  @Override
+  public boolean call(Row row) {
+    var res = expression.resolve(new SparkRowMap(row));
+    if (res == null) return false;
+    return (boolean) res;
+  }
+}
diff --git a/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkProcessingEngine.java b/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkProcessingEngine.java
new file mode 100644
index 000000000..dbbd70728
--- /dev/null
+++ b/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkProcessingEngine.java
@@ -0,0 +1,1177 @@
+package fr.insee.vtl.spark;
+
+import static fr.insee.vtl.model.AggregationExpression.*;
+import static fr.insee.vtl.model.Dataset.Component;
+import static fr.insee.vtl.model.Dataset.Role;
+import static fr.insee.vtl.model.Dataset.Role.IDENTIFIER;
+import static fr.insee.vtl.model.Dataset.Role.MEASURE;
+import static fr.insee.vtl.spark.SparkDataset.fromVtlType;
+import static org.apache.spark.sql.functions.*;
+import static org.apache.spark.sql.functions.avg;
+import static org.apache.spark.sql.functions.count;
+import static org.apache.spark.sql.functions.max;
+import static org.apache.spark.sql.functions.min;
+import static org.apache.spark.sql.functions.sum;
+import static scala.collection.JavaConverters.iterableAsScalaIterable;
+
+import fr.insee.vtl.engine.exceptions.VtlRuntimeException;
+import fr.insee.vtl.model.*;
+import java.util.*;
+import java.util.stream.Collectors;
+import javax.script.ScriptEngine;
+import org.apache.spark.sql.*;
+import org.apache.spark.sql.Dataset;
+import org.apache.spark.sql.expressions.UserDefinedFunction;
+import org.apache.spark.sql.expressions.Window;
+import org.apache.spark.sql.expressions.WindowSpec;
+import scala.collection.JavaConverters;
+import scala.collection.Seq;
+
+/**
+ * The <code>SparkProcessingEngine</code> class is an implementation of a VTL engine using Apache
+ * Spark.
+ */
+public class SparkProcessingEngine implements ProcessingEngine {
+
+  public static final Integer DEFAULT_MEDIAN_ACCURACY = 1000000;
+  public static final UnsupportedOperationException UNKNOWN_ANALYTIC_FUNCTION =
+      new UnsupportedOperationException("Unknown analytic function");
+  private static final String BOOLVAR = "bool_var";
+  private static final String ERRORCODE = "errorcode";
+  private static final String ERRORLEVEL = "errorlevel";
+  private static final String RULEID = "ruleid";
+  private static final String IMBALANCE = "imbalance";
+  private static final String NON_NULL = "non_null";
+  private static final String NON_ZERO = "non_zero";
+  private static final String PARTIAL_NULL = "partial_null";
+  private static final String PARTIAL_ZERO = "partial_zero";
+  private static final String ALWAYS_NULL = "always_null";
+  private static final String ALWAYS_ZERO = "always_zero";
+  private final SparkSession spark;
+
+  /**
+   * Constructor taking an existing Spark session.
+   *
+   * @param spark The Spark session to use for the engine.
+   */
+  public SparkProcessingEngine(SparkSession spark) {
+    spark.conf().set("spark.sql.datetime.java8API.enabled", true);
+    this.spark = Objects.requireNonNull(spark);
+  }
+
+  private static Map<String, Role> getRoleMap(Collection<Component> components) {
+    return components.stream().collect(Collectors.toMap(Component::getName, Component::getRole));
+  }
+
+  private static Map<String, Role> getRoleMap(fr.insee.vtl.model.Dataset dataset) {
+    return getRoleMap(dataset.getDataStructure().values());
+  }
+
+  // TODO (expression instanceof MinAggregationExpression)
+  // TODO column = stddev_pop(columnName);
+  private static Column convertAggregation(String columnName, AggregationExpression expression)
+      throws UnsupportedOperationException {
+    Column column;
+    if (expression instanceof MinAggregationExpression) {
+      column = min(SparkUtils.safeCol(columnName));
+    } else if (expression instanceof MaxAggregationExpression) {
+      column = max(SparkUtils.safeCol(columnName));
+    } else if (expression instanceof AverageAggregationExpression) {
+      column = avg(SparkUtils.safeCol(columnName));
+    } else if (expression instanceof SumAggregationExpression) {
+      column = sum(SparkUtils.safeCol(columnName));
+    } else if (expression instanceof CountAggregationExpression) {
+      column = count("*");
+    } else if (expression instanceof MedianAggregationExpression) {
+      column =
+          percentile_approx(SparkUtils.safeCol(columnName), lit(0.5), lit(DEFAULT_MEDIAN_ACCURACY));
+    } else if (expression instanceof StdDevSampAggregationExpression) {
+      column = stddev_samp(SparkUtils.safeCol(columnName));
+    } else if (expression instanceof VarPopAggregationExpression) {
+      column = var_pop(SparkUtils.safeCol(columnName));
+    } else if (expression instanceof VarSampAggregationExpression) {
+      column = var_samp(SparkUtils.safeCol(columnName));
+    } else {
+      throw new UnsupportedOperationException("unknown aggregation " + expression.getClass());
+    }
+    return column.alias(columnName);
+  }
+
+  //    todo need to add unit test
+  private static WindowSpec buildWindowSpec(List<String> partitionBy) {
+    return buildWindowSpec(partitionBy, null, null);
+  }
+
+  //    todo need to add unit test
+  private static WindowSpec buildWindowSpec(
+      List<String> partitionBy, Map<String, Analytics.Order> orderBy) {
+    return buildWindowSpec(partitionBy, orderBy, null);
+  }
+
+  //    todo need to add unit test
+  private static WindowSpec buildWindowSpec(
+      List<String> partitionBy, Map<String, Analytics.Order> orderBy, Analytics.WindowSpec window) {
+    if (partitionBy == null) {
+      partitionBy = List.of();
+    }
+
+    Column[] partitionCols =
+        scala.collection.JavaConverters.seqAsJavaList(colNameToCol(partitionBy))
+            .toArray(new Column[0]);
+
+    WindowSpec windowSpec = Window.partitionBy(partitionCols);
+
+    if (orderBy == null) {
+      orderBy = Map.of();
+    }
+
+    Column[] orderCols =
+        scala.collection.JavaConverters.seqAsJavaList(buildOrderCol(orderBy))
+            .toArray(new Column[0]);
+    windowSpec = windowSpec.orderBy(orderCols);
+
+    if (window instanceof Analytics.DataPointWindow) {
+      windowSpec = windowSpec.rowsBetween(-window.getLower(), window.getUpper());
+    } else if (window instanceof Analytics.RangeWindow) {
+      windowSpec = windowSpec.rangeBetween(-window.getLower(), window.getUpper());
+    }
+
+    return windowSpec;
+  }
+
+  public static Seq<Column> colNameToCol(List<String> inputColNames) {
+    List<Column> cols = new ArrayList<>();
+    for (String colName : inputColNames) {
+      cols.add(SparkUtils.safeCol(colName));
+    }
+    return JavaConverters.asScalaIteratorConverter(cols.iterator()).asScala().toSeq();
+  }
+
+  // helper function that builds order col expression with asc and desc spec
+  public static Seq<Column> buildOrderCol(Map<String, Analytics.Order> orderCols) {
+    List<Column> orders = new ArrayList<>();
+    for (Map.Entry<String, Analytics.Order> entry : orderCols.entrySet()) {
+      if (entry.getValue().equals(Analytics.Order.DESC)) {
+        orders.add(SparkUtils.safeCol(entry.getKey()).desc());
+      } else {
+        orders.add(SparkUtils.safeCol(entry.getKey()));
+      }
+    }
+    return JavaConverters.asScalaIteratorConverter(orders.iterator()).asScala().toSeq();
+  }
+
+  private static List<String> identifierNames(List<Component> components) {
+    return components.stream()
+        .filter(component -> IDENTIFIER.equals(component.getRole()))
+        .map(Component::getName)
+        .collect(Collectors.toList());
+  }
+
+  private SparkDataset asSparkDataset(DatasetExpression expression) {
+    if (expression instanceof SparkDatasetExpression datasetExpression) {
+      return datasetExpression.resolve(Map.of());
+    } else {
+      var dataset = expression.resolve(Map.of());
+      if (dataset instanceof PersistentDataset persistentDataset) {
+        dataset = persistentDataset.getDelegate();
+      }
+      if (dataset instanceof SparkDataset sparkDataset) {
+        return sparkDataset;
+      } else {
+        return new SparkDataset(dataset, getRoleMap(dataset), spark);
+      }
+    }
+  }
+
+  @Override
+  public DatasetExpression executeCalc(
+      DatasetExpression expression,
+      Map<String, ResolvableExpression> expressions,
+      Map<String, Role> roles,
+      Map<String, String> expressionStrings) {
+    SparkDataset dataset = asSparkDataset(expression);
+    Dataset<Row> ds = dataset.getSparkDataset();
+
+    // Rename all the columns to avoid conflicts (static single assignment).
+    Map<String, String> aliasesToName = new HashMap<>();
+    Map<String, ResolvableExpression> renamedExpressions = new LinkedHashMap<>();
+    Map<String, String> renamedExpressionString = new LinkedHashMap<>();
+    for (var name : expressions.keySet()) {
+      String alias = name + "_" + aliasesToName.size();
+      renamedExpressions.put(alias, expressions.get(name));
+      renamedExpressionString.put(alias, expressionStrings.get(name));
+      aliasesToName.put(alias, name);
+    }
+
+    // First pass with interpreted spark expressions
+    Dataset<Row> interpreted = executeCalcInterpreted(ds, renamedExpressionString);
+
+    // Execute the rest using the resolvable expressions
+    Dataset<Row> evaluated = executeCalcEvaluated(interpreted, renamedExpressions);
+
+    // Rename the columns back to their original names
+    Dataset<Row> renamed = rename(evaluated, aliasesToName);
+
+    // Create the new role map.
+    var roleMap = getRoleMap(dataset);
+    roleMap.putAll(roles);
+
+    return new SparkDatasetExpression(new SparkDataset(renamed, roleMap), expression);
+  }
+
+  private Dataset<Row> executeCalcEvaluated(
+      Dataset<Row> interpreted, Map<String, ResolvableExpression> expressions) {
+    var columnNames = Set.of(interpreted.columns());
+    Column structColumns =
+        struct(columnNames.stream().map(colName -> col(colName)).toArray(Column[]::new));
+    for (var name : expressions.keySet()) {
+      // Ignore the columns that already exist.
+      if (columnNames.contains(name)) {
+        continue;
+      }
+      // Execute the ResolvableExpression by wrapping it in a UserDefinedFunction.
+      ResolvableExpression expression = expressions.get(name);
+      UserDefinedFunction exprFunction =
+          udf(
+              (Row row) -> {
+                try {
+                  SparkRowMap context = new SparkRowMap(row);
+                  Object result = expression.resolve(context);
+                  // Convert java.time.Instant to java.sql.Date for Spark compatibility
+                  if (result instanceof java.time.Instant instant) {
+                    return java.sql.Date.valueOf(
+                        instant.atZone(java.time.ZoneOffset.UTC).toLocalDate());
+                  }
+                  return result;
+                } catch (VtlRuntimeException e) {
+                  // VtlRuntimeException already wraps the real VTL error, re-throw it
+                  throw e;
+                } catch (Exception e) {
+                  // Wrap any other exception to provide context
+                  throw new RuntimeException(
+                      "Error in UDF for column '" + name + "': " + e.getMessage(), e);
+                }
+              },
+              fromVtlType(expression.getType()));
+      interpreted = interpreted.withColumn(name, exprFunction.apply(structColumns));
+    }
+    return interpreted;
+  }
+
+  private Dataset<Row> executeCalcInterpreted(
+      Dataset<Row> result, Map<String, String> expressionStrings) {
+    for (String name : expressionStrings.keySet()) {
+      try {
+        String expression = expressionStrings.get(name);
+        if (expression == null) continue;
+        result = result.withColumn(name, expr(expression));
+      } catch (Exception e) {
+        // Silently ignore expressions that Spark SQL cannot interpret directly.
+        // These will be evaluated as ResolvableExpressions in executeCalcEvaluated instead.
+      }
+    }
+    return result;
+  }
+
+  @Override
+  public DatasetExpression executeFilter(
+      DatasetExpression expression, ResolvableExpression filter, String filterText) {
+    SparkDataset dataset = asSparkDataset(expression);
+
+    Dataset<Row> ds = dataset.getSparkDataset();
+    try {
+      Dataset<Row> result = ds.filter(filterText);
+      return new SparkDatasetExpression(new SparkDataset(result, getRoleMap(dataset)), expression);
+    } catch (Exception e) {
+      SparkFilterFunction filterFunction = new SparkFilterFunction(filter);
+      Dataset<Row> result = ds.filter(filterFunction);
+      return new SparkDatasetExpression(new SparkDataset(result, getRoleMap(dataset)), expression);
+    }
+  }
+
+  @Override
+  public DatasetExpression executeRename(DatasetExpression expression, Map<String, String> fromTo) {
+    SparkDataset dataset = asSparkDataset(expression);
+
+    var result = rename(dataset.getSparkDataset(), fromTo);
+
+    var originalRoles = getRoleMap(dataset);
+    var renamedRoles = new LinkedHashMap<>(originalRoles);
+    for (Map.Entry<String, String> fromToEntry : fromTo.entrySet()) {
+      renamedRoles.put(fromToEntry.getValue(), originalRoles.get(fromToEntry.getKey()));
+    }
+
+    return new SparkDatasetExpression(new SparkDataset(result, renamedRoles), expression);
+  }
+
+  public Dataset<Row> rename(Dataset<Row> dataset, Map<String, String> fromTo) {
+    List<Column> columns = new ArrayList<>();
+    for (String name : dataset.columns()) {
+      if (fromTo.containsKey(name)) {
+        columns.add(SparkUtils.safeCol(name).as(fromTo.get(name)));
+      } else if (!fromTo.containsValue(name)) {
+        columns.add(SparkUtils.safeCol(name));
+      }
+    }
+    return dataset.select(iterableAsScalaIterable(columns).toSeq());
+  }
+
+  @Override
+  public DatasetExpression executeProject(DatasetExpression expression, List<String> columnNames) {
+    SparkDataset dataset = asSparkDataset(expression);
+
+    List<Column> columns = columnNames.stream().map(Column::new).collect(Collectors.toList());
+    Column[] columnArray = columns.toArray(new Column[0]);
+
+    // Project in spark.
+    Dataset<Row> result = dataset.getSparkDataset().select(columnArray);
+
+    return new SparkDatasetExpression(new SparkDataset(result, getRoleMap(dataset)), expression);
+  }
+
+  private boolean checkColNameCompatibility(List<DatasetExpression> datasets) {
+    boolean result = true;
+    IndexedHashMap<String, Component> baseStructure = datasets.get(0).getDataStructure();
+    for (int i = 1; i <= datasets.size() - 1; i++) {
+      // check if current structure equals base structure
+      IndexedHashMap<String, Component> curretStructure = datasets.get(i).getDataStructure();
+      if (!baseStructure.equals(curretStructure)) {
+        result = false;
+        break;
+      }
+    }
+    return result;
+  }
+
+  @Override
+  public DatasetExpression executeUnion(List<DatasetExpression> datasets) {
+    DatasetExpression dataset = datasets.get(0);
+
+    if (!checkColNameCompatibility(datasets))
+      throw new UnsupportedOperationException("The schema of the dataset is not compatible");
+    // use the base data structure to build the result data roles
+    Structured.DataStructure baseDataStructure = datasets.get(0).getDataStructure();
+    Set<String> keys = baseDataStructure.keySet();
+    HashMap<String, Role> dataRoles = new HashMap<>();
+    for (String key : keys) {
+      Component item = baseDataStructure.get(key);
+      dataRoles.put(item.getName(), item.getRole());
+    }
+
+    // get Id column list
+    List<String> colNames = datasets.get(0).getColumnNames();
+    ArrayList<String> idColList = new ArrayList<>();
+    IndexedHashMap<String, Component> structure = dataset.getDataStructure();
+    // get column list with ID role, it will be used to drop duplicated rows
+    for (String colName : colNames) {
+      if (structure.get(colName).getRole().equals(IDENTIFIER)) idColList.add(colName);
+    }
+    int size = datasets.size();
+
+    if (size == 1) {
+      return datasets.get(0);
+    } else {
+      Dataset<Row> result = asSparkDataset(datasets.get(0)).getSparkDataset();
+      for (int i = 1; i <= size - 1; i++) {
+        Dataset<Row> current = asSparkDataset(datasets.get(i)).getSparkDataset();
+        result = result.union(current);
+      }
+      result = result.dropDuplicates(iterableAsScalaIterable(idColList).toSeq());
+      return new SparkDatasetExpression(new SparkDataset(result, dataRoles), datasets.get(0));
+    }
+  }
+
+  @Override
+  public DatasetExpression executeAggr(
+      DatasetExpression dataset,
+      List<String> groupBy,
+      Map<String, AggregationExpression> collectorMap) {
+    SparkDataset sparkDataset = asSparkDataset(dataset);
+    List<Column> columns =
+        collectorMap.entrySet().stream()
+            .map(e -> convertAggregation(e.getKey(), e.getValue()))
+            .collect(Collectors.toList());
+    List<Column> groupByColumns =
+        groupBy.stream().map(SparkUtils::safeCol).collect(Collectors.toList());
+    Dataset<Row> result =
+        sparkDataset
+            .getSparkDataset()
+            .groupBy(iterableAsScalaIterable(groupByColumns).toSeq())
+            .agg(
+                columns.get(0),
+                iterableAsScalaIterable(columns.subList(1, columns.size())).toSeq());
+    SparkDataset sparkDs = new SparkDataset(result, dataset.getRoles());
+    return new SparkDatasetExpression(sparkDs, dataset);
+  }
+
+  @Override
+  public DatasetExpression executeSimpleAnalytic(
+      DatasetExpression dataset,
+      String targetColName,
+      Analytics.Function function,
+      String sourceColName,
+      List<String> partitionBy,
+      Map<String, Analytics.Order> orderBy,
+      Analytics.WindowSpec window) {
+    SparkDataset sparkDataset = asSparkDataset(dataset);
+
+    // step1: build window spec
+    WindowSpec windowSpec = buildWindowSpec(partitionBy, orderBy, window);
+
+    // step 2: call analytic func on window spec
+    // 2.1 get all measurement column
+
+    Column safeCol = SparkUtils.safeCol(sourceColName);
+
+    Column column =
+        switch (function) {
+          case COUNT -> count(safeCol).over(windowSpec);
+          case SUM -> sum(safeCol).over(windowSpec);
+          case MIN -> min(safeCol).over(windowSpec);
+          case MAX -> max(safeCol).over(windowSpec);
+          case AVG -> avg(safeCol).over(windowSpec);
+          case MEDIAN ->
+              percentile_approx(safeCol, lit(0.5), lit(DEFAULT_MEDIAN_ACCURACY)).over(windowSpec);
+          case STDDEV_POP -> stddev_pop(safeCol).over(windowSpec);
+          case STDDEV_SAMP -> stddev_samp(safeCol).over(windowSpec);
+          case VAR_POP -> var_pop(safeCol).over(windowSpec);
+          case VAR_SAMP -> var_samp(safeCol).over(windowSpec);
+          case FIRST_VALUE -> first(safeCol).over(windowSpec);
+          case LAST_VALUE -> last(safeCol).over(windowSpec);
+          default -> throw UNKNOWN_ANALYTIC_FUNCTION;
+        };
+    var result = sparkDataset.getSparkDataset().withColumn(targetColName, column);
+    return new SparkDatasetExpression(new SparkDataset(result), dataset);
+  }
+
+  @Override
+  public DatasetExpression executeLeadOrLagAn(
+      DatasetExpression dataset,
+      String targetColName,
+      Analytics.Function function,
+      String sourceColName,
+      int offset,
+      List<String> partitionBy,
+      Map<String, Analytics.Order> orderBy) {
+    SparkDataset sparkDataset = asSparkDataset(dataset);
+
+    // step1: build window spec
+    WindowSpec windowSpec = buildWindowSpec(partitionBy, orderBy);
+
+    // step 2: call analytic func on window spec
+    Column column =
+        switch (function) {
+          case LEAD -> lead(sourceColName, offset).over(windowSpec);
+          case LAG -> lag(sourceColName, offset).over(windowSpec);
+          default -> throw UNKNOWN_ANALYTIC_FUNCTION;
+        };
+    var result = sparkDataset.getSparkDataset().withColumn(targetColName, column);
+    return new SparkDatasetExpression(new SparkDataset(result), dataset);
+  }
+
+  @Override
+  public DatasetExpression executeRatioToReportAn(
+      DatasetExpression dataset,
+      String targetColName,
+      Analytics.Function function,
+      String sourceColName,
+      List<String> partitionBy) {
+    if (!function.equals(Analytics.Function.RATIO_TO_REPORT)) throw UNKNOWN_ANALYTIC_FUNCTION;
+
+    SparkDataset sparkDataset = asSparkDataset(dataset);
+    // step1: build window spec
+    WindowSpec windowSpec = buildWindowSpec(partitionBy);
+
+    // step 2: call analytic func on window spec
+    String totalColName = "total_" + sourceColName;
+    // 2.2 add the result column for the calc clause
+    Dataset<Row> result =
+        sparkDataset
+            .getSparkDataset()
+            .withColumn(totalColName, sum(SparkUtils.safeCol(sourceColName)).over(windowSpec))
+            .withColumn(targetColName, SparkUtils.safeCol(sourceColName).divide(col(totalColName)))
+            .drop(totalColName);
+    // 2.3 without the calc clause, we need to overwrite the measure columns with the result column
+    return new SparkDatasetExpression(new SparkDataset(result), dataset);
+  }
+
+  @Override
+  public DatasetExpression executeRankAn(
+      DatasetExpression dataset,
+      String targetColName,
+      Analytics.Function function,
+      List<String> partitionBy,
+      Map<String, Analytics.Order> orderBy) {
+    if (!function.equals(Analytics.Function.RANK)) throw UNKNOWN_ANALYTIC_FUNCTION;
+
+    SparkDataset sparkDataset = asSparkDataset(dataset);
+    // step1: build window spec
+    WindowSpec windowSpec = buildWindowSpec(partitionBy, orderBy);
+
+    // step 2: call analytic func on window spec
+    Dataset<Row> result =
+        sparkDataset.getSparkDataset().withColumn(targetColName, rank().over(windowSpec));
+    // 2.3 without the calc clause, we need to overwrite the measure columns with the result column
+    return new SparkDatasetExpression(new SparkDataset(result), dataset);
+  }
+
+  @Override
+  public DatasetExpression executeInnerJoin(
+      Map<String, DatasetExpression> datasets, List<Component> components) {
+    List<Dataset<Row>> sparkDatasets = toAliasedDatasets(datasets);
+    List<String> identifiers = identifierNames(components);
+    var innerJoin = executeJoin(sparkDatasets, identifiers, "inner");
+    DatasetExpression datasetExpression = datasets.entrySet().iterator().next().getValue();
+    return new SparkDatasetExpression(
+        new SparkDataset(innerJoin, getRoleMap(components)), datasetExpression);
+  }
+
+  @Override
+  public DatasetExpression executeLeftJoin(
+      Map<String, DatasetExpression> datasets, List<Structured.Component> components) {
+    List<Dataset<Row>> sparkDatasets = toAliasedDatasets(datasets);
+    List<String> identifiers = identifierNames(components);
+    var innerJoin = executeJoin(sparkDatasets, identifiers, "left");
+    DatasetExpression datasetExpression = datasets.entrySet().iterator().next().getValue();
+    return new SparkDatasetExpression(
+        new SparkDataset(innerJoin, getRoleMap(components)), datasetExpression);
+  }
+
+  @Override
+  public DatasetExpression executeCrossJoin(
+      Map<String, DatasetExpression> datasets, List<Component> identifiers) {
+    List<Dataset<Row>> sparkDatasets = toAliasedDatasets(datasets);
+    var crossJoin = executeJoin(sparkDatasets, List.of(), "cross");
+    DatasetExpression datasetExpression = datasets.entrySet().iterator().next().getValue();
+    return new SparkDatasetExpression(
+        new SparkDataset(crossJoin, getRoleMap(identifiers)), datasetExpression);
+  }
+
+  @Override
+  public DatasetExpression executeFullJoin(
+      Map<String, DatasetExpression> datasets, List<Component> identifiers) {
+    List<Dataset<Row>> sparkDatasets = toAliasedDatasets(datasets);
+    List<String> identifierNames = identifierNames(identifiers);
+    var crossJoin = executeJoin(sparkDatasets, identifierNames, "outer");
+    DatasetExpression datasetExpression = datasets.entrySet().iterator().next().getValue();
+    return new SparkDatasetExpression(
+        new SparkDataset(crossJoin, getRoleMap(identifiers)), datasetExpression);
+  }
+
+  @Override
+  public DatasetExpression executeValidateDPruleset(
+      DataPointRuleset dpr,
+      DatasetExpression dataset,
+      String output,
+      Positioned pos,
+      List<String> toDrop) {
+    SparkDataset sparkDataset = asSparkDataset(dataset);
+    Dataset<Row> ds = sparkDataset.getSparkDataset();
+    Dataset<Row> renamedDs = rename(ds, dpr.getAlias());
+
+    SparkDataset sparkDs = new SparkDataset(renamedDs);
+    DatasetExpression sparkDsExpr = new SparkDatasetExpression(sparkDs, pos);
+    Structured.DataStructure dataStructure = sparkDs.getDataStructure();
+
+    var roleMap = getRoleMap(sparkDataset);
+    roleMap.put(RULEID, IDENTIFIER);
+    roleMap.put(BOOLVAR, MEASURE);
+    roleMap.put(ERRORLEVEL, MEASURE);
+    roleMap.put(ERRORCODE, MEASURE);
+
+    Class errorCodeType = dpr.getErrorCodeType();
+    Class errorLevelType = dpr.getErrorLevelType();
+
+    List<DatasetExpression> datasetsExpression =
+        dpr.getRules().stream()
+            .map(
+                rule -> {
+                  String ruleName = rule.getName();
+                  ResolvableExpression ruleIdExpression =
+                      ResolvableExpression.withType(String.class)
+                          .withPosition(pos)
+                          .using(context -> ruleName);
+
+                  ResolvableExpression antecedentExpression =
+                      rule.getBuildAntecedentExpression(dataStructure);
+                  ResolvableExpression consequentExpression =
+                      rule.getBuildConsequentExpression(dataStructure);
+
+                  ResolvableExpression errorCodeExpr = rule.getErrorCodeExpression();
+                  ResolvableExpression errorCodeExpression =
+                      ResolvableExpression.withType(errorCodeType)
+                          .withPosition(pos)
+                          .using(
+                              context -> {
+                                if (errorCodeExpr == null) return null;
+                                Map<String, Object> mapContext = (Map<String, Object>) context;
+                                Object erCode = errorCodeExpr.resolve(mapContext);
+                                if (erCode == null) return null;
+                                Boolean antecedentValue =
+                                    (Boolean) antecedentExpression.resolve(mapContext);
+                                Boolean consequentValue =
+                                    (Boolean) consequentExpression.resolve(mapContext);
+                                return Boolean.TRUE.equals(antecedentValue)
+                                        && Boolean.FALSE.equals(consequentValue)
+                                    ? errorCodeType.cast(erCode)
+                                    : null;
+                              });
+
+                  ResolvableExpression errorLevelExpr = rule.getErrorLevelExpression();
+                  ResolvableExpression errorLevelExpression =
+                      ResolvableExpression.withType(errorLevelType)
+                          .withPosition(pos)
+                          .using(
+                              context -> {
+                                if (errorLevelExpr == null) return null;
+                                Map<String, Object> mapContext = (Map<String, Object>) context;
+                                Object erLevel = errorLevelExpr.resolve(mapContext);
+                                if (erLevel == null) return null;
+                                Boolean antecedentValue =
+                                    (Boolean) antecedentExpression.resolve(mapContext);
+                                Boolean consequentValue =
+                                    (Boolean) consequentExpression.resolve(mapContext);
+                                return Boolean.TRUE.equals(antecedentValue)
+                                        && Boolean.FALSE.equals(consequentValue)
+                                    ? errorLevelType.cast(erLevel)
+                                    : null;
+                              });
+
+                  ResolvableExpression BOOLVARExpression =
+                      ResolvableExpression.withType(Boolean.class)
+                          .withPosition(pos)
+                          .using(
+                              context -> {
+                                Boolean antecedentValue =
+                                    (Boolean) antecedentExpression.resolve(context);
+                                Boolean consequentValue =
+                                    (Boolean) consequentExpression.resolve(context);
+                                if (antecedentValue == null) return consequentValue;
+                                if (consequentValue == null) return antecedentValue;
+                                return !antecedentValue || consequentValue;
+                              });
+
+                  Map<String, ResolvableExpression> resolvableExpressions = new HashMap<>();
+                  resolvableExpressions.put(RULEID, ruleIdExpression);
+                  resolvableExpressions.put(BOOLVAR, BOOLVARExpression);
+                  resolvableExpressions.put(ERRORLEVEL, errorLevelExpression);
+                  resolvableExpressions.put(ERRORCODE, errorCodeExpression);
+                  // do we need to use execute executeCalcInterpreted too?
+                  return executeCalc(sparkDsExpr, resolvableExpressions, roleMap, Map.of());
+                })
+            .collect(Collectors.toList());
+
+    Dataset<Row> invertRenamedSparkDs =
+        rename(
+            asSparkDataset(executeUnion(datasetsExpression)).getSparkDataset(),
+            invertMap(dpr.getAlias()));
+    SparkDatasetExpression sparkDatasetExpression =
+        new SparkDatasetExpression(new SparkDataset(invertRenamedSparkDs), pos);
+    List<String> toKeep =
+        sparkDatasetExpression.getColumnNames().stream()
+            .filter(v -> !toDrop.contains(v))
+            .collect(Collectors.toList());
+    DatasetExpression cleanedExpression = executeProject(sparkDatasetExpression, toKeep);
+    if (output == null || output.equals(ValidationOutput.INVALID.value)) {
+      ResolvableExpression defaultExpression =
+          ResolvableExpression.withType(Boolean.class).withPosition(pos).using(c -> null);
+      DatasetExpression filteredDataset =
+          executeFilter(cleanedExpression, defaultExpression, BOOLVAR + " = false");
+      Dataset<Row> result = asSparkDataset(filteredDataset).getSparkDataset().drop(BOOLVAR);
+      return new SparkDatasetExpression(new SparkDataset(result), pos);
+    }
+    return cleanedExpression;
+  }
+
+  @Override
+  public DatasetExpression executeValidationSimple(
+      DatasetExpression dsExpr,
+      ResolvableExpression errorCodeExpr,
+      ResolvableExpression errorLevelExpr,
+      DatasetExpression imbalanceExpr,
+      String output,
+      Positioned pos) {
+    // Rename imbalance single measure to imbalance
+    SparkDataset sparkImbalanceDataset = asSparkDataset(imbalanceExpr);
+    Dataset<Row> sparkImbalanceDatasetRow = sparkImbalanceDataset.getSparkDataset();
+    String imbalanceMonomeasureName =
+        imbalanceExpr.getDataStructure().values().stream()
+            .filter(Component::isMeasure)
+            .map(Component::getName)
+            .collect(Collectors.toList())
+            .get(0);
+    Map<String, String> varsToRename =
+        Map.ofEntries(Map.entry(imbalanceMonomeasureName, IMBALANCE));
+    Dataset<Row> renamed = rename(sparkImbalanceDatasetRow, varsToRename);
+    var imbalanceRoleMap = getRoleMap(sparkImbalanceDataset);
+    SparkDatasetExpression imbalanceRenamedExpr =
+        new SparkDatasetExpression(new SparkDataset(renamed, imbalanceRoleMap), pos);
+    // Join expr ds & imbalance ds
+    Map<String, DatasetExpression> datasetExpressions =
+        Map.ofEntries(
+            Map.entry("dsExpr", dsExpr), Map.entry("imbalanceExpr", imbalanceRenamedExpr));
+    List<Component> components =
+        dsExpr.getDataStructure().values().stream()
+            .filter(Component::isIdentifier)
+            .collect(Collectors.toList());
+    DatasetExpression datasetExpression = executeLeftJoin(datasetExpressions, components);
+    SparkDataset sparkDataset = asSparkDataset(datasetExpression);
+    Dataset<Row> ds = sparkDataset.getSparkDataset();
+
+    // TODO: Extract to a ValidationExpression(ResolvableExpression).
+    Class errorCodeType = errorCodeExpr == null ? String.class : errorCodeExpr.getType();
+    ResolvableExpression errorCodeExpression =
+        ResolvableExpression.withType(errorCodeType)
+            .withPosition(pos)
+            .using(
+                context -> {
+                  Map<String, Object> contextMap = (Map<String, Object>) context;
+                  if (errorCodeExpr == null) return null;
+                  Object erCode = errorCodeExpr.resolve(contextMap);
+                  Boolean boolVar = (Boolean) contextMap.get(BOOLVAR);
+                  return boolVar ? null : errorCodeType.cast(erCode);
+                });
+    // TODO: Extract to a ValidationExpression(ResolvableExpression).
+    Class errorLevelType = errorLevelExpr == null ? String.class : errorLevelExpr.getType();
+    ResolvableExpression errorLevelExpression =
+        ResolvableExpression.withType(errorLevelType)
+            .withPosition(pos)
+            .using(
+                context -> {
+                  Map<String, Object> contextMap = (Map<String, Object>) context;
+                  if (errorLevelExpr == null) return null;
+                  Object erLevel = errorLevelExpr.resolve(contextMap);
+                  Boolean boolVar = (Boolean) contextMap.get(BOOLVAR);
+                  return boolVar ? null : errorLevelType.cast(erLevel);
+                });
+
+    var roleMap = getRoleMap(sparkDataset);
+    roleMap.put(ERRORLEVEL, MEASURE);
+    roleMap.put(ERRORCODE, MEASURE);
+
+    Map<String, ResolvableExpression> resolvableExpressions =
+        Map.ofEntries(
+            Map.entry(ERRORLEVEL, errorLevelExpression), Map.entry(ERRORCODE, errorCodeExpression));
+
+    Dataset<Row> calculatedDataset = executeCalcEvaluated(ds, resolvableExpressions);
+    DatasetExpression sparkDatasetExpression =
+        new SparkDatasetExpression(new SparkDataset(calculatedDataset, roleMap), pos);
+
+    // handle output: if none or all, return, if invalid filter on bool_var and return
+    if (output == null || output.equals(ValidationOutput.ALL.value)) {
+      return sparkDatasetExpression;
+    }
+    DatasetExpression filteredDataset =
+        executeFilter(
+            sparkDatasetExpression,
+            ResolvableExpression.withType(Boolean.class).withPosition(pos).using(c -> null),
+            BOOLVAR + " = false");
+    // VTL issue: drop BOOLVAR in check_datapoint only specified but we apply also here for
+    // harmonization
+    Dataset<Row> result = asSparkDataset(filteredDataset).getSparkDataset().drop(BOOLVAR);
+    return new SparkDatasetExpression(new SparkDataset(result), pos);
+  }
+
+  @Override
+  public DatasetExpression executeHierarchicalValidation(
+      DatasetExpression dsE,
+      HierarchicalRuleset hr,
+      String componentID,
+      String validationMode,
+      String inputMode,
+      String validationOutput,
+      Positioned pos) {
+    // inputMode: dataset (default) | dataset_priority (not handled)
+    if (inputMode != null && inputMode.equals("dataset_priority")) {
+      throw new UnsupportedOperationException(
+          "dataset_priority input mode is not supported in check_hierarchy");
+    }
+
+    // Create "bindings" (componentID column values)
+    fr.insee.vtl.model.Dataset ds = dsE.resolve(Map.of());
+
+    Map<String, Object> bindings =
+        ds.getDataAsMap().stream()
+            .collect(
+                HashMap::new,
+                (acc, dp) -> acc.put(dp.get(componentID).toString(), dp.get(hr.getVariable())),
+                HashMap::putAll);
+    // Save monomeasure type
+    Component measure = dsE.getDataStructure().getMeasures().get(0);
+    Class measureType = measure.getType();
+
+    var roleMap = getRoleMap(ds);
+    roleMap.put(RULEID, IDENTIFIER);
+    roleMap.put(BOOLVAR, MEASURE);
+    roleMap.put(IMBALANCE, MEASURE);
+    roleMap.put(ERRORLEVEL, MEASURE);
+    roleMap.put(ERRORCODE, MEASURE);
+
+    Class errorCodeType = hr.getErrorCodeType();
+    Class errorLevelType = hr.getErrorLevelType();
+
+    List<DatasetExpression> datasetsExpression = new ArrayList<>();
+    hr.getRules()
+        .forEach(
+            rule -> {
+              DatasetExpression filteredDataset;
+              try {
+                filteredDataset =
+                    executeFilterForHR(
+                        dsE, componentID + " = \"" + rule.getValueDomainValue() + "\"");
+              } catch (Exception e) {
+                throw new RuntimeException(e);
+              }
+
+              String ruleName = rule.getName();
+              List<String> codeItems = rule.getCodeItems();
+
+              // handle validationMode
+              Map<String, Object> ruleBindings = extractHRRuleBindings(bindings, codeItems);
+              Boolean hasToProduceOutputLine = checkRule(codeItems, ruleBindings, validationMode);
+              if (Boolean.FALSE.equals(hasToProduceOutputLine)) {
+                // trick to break
+                return;
+              }
+              ruleBindings =
+                  buildBindingsWithDefault(ruleBindings, codeItems, validationMode, measureType);
+              // Iterate on rules to resolve expressions
+              Map<Object, Boolean> resolvedRuleExpressions = new HashMap<>();
+              Map<Object, Double> resolvedLeftRuleExpressions = new HashMap<>();
+              Map<Object, Double> resolvedRightRuleExpressions = new HashMap<>();
+              // use try / catch because of scalar expr function resolution issue with null (only
+              // handled in ds thanks to column type)
+              try {
+                resolvedRuleExpressions.put(
+                    ruleName, (Boolean) rule.getExpression().resolve(ruleBindings));
+              } catch (Exception e) {
+                resolvedRuleExpressions.put(ruleName, null);
+              }
+              try {
+                resolvedLeftRuleExpressions.put(
+                    ruleName, (Double) rule.getLeftExpression().resolve(ruleBindings));
+              } catch (Exception e) {
+                resolvedLeftRuleExpressions.put(ruleName, null);
+              }
+              try {
+                resolvedRightRuleExpressions.put(
+                    ruleName, (Double) rule.getRightExpression().resolve(ruleBindings));
+              } catch (Exception e) {
+                resolvedRightRuleExpressions.put(ruleName, null);
+              }
+              ResolvableExpression ruleIdExpression =
+                  ResolvableExpression.withType(String.class)
+                      .withPosition(pos)
+                      .using(context -> ruleName);
+
+              String vd = rule.getValueDomainValue();
+              ResolvableExpression valueDomainExpression =
+                  ResolvableExpression.withType(String.class)
+                      .withPosition(pos)
+                      .using(context -> vd);
+
+              Boolean expression = resolvedRuleExpressions.get(ruleName);
+
+              ResolvableExpression errorCodeExpr = rule.getErrorCodeExpression();
+              ResolvableExpression errorCodeExpression =
+                  ResolvableExpression.withType(errorCodeType)
+                      .withPosition(pos)
+                      .using(
+                          context -> {
+                            if (errorCodeExpr == null || expression == null) return null;
+                            Map<String, Object> mapContext = (Map<String, Object>) context;
+                            Object erCode = errorCodeExpr.resolve(mapContext);
+                            if (erCode == null) return null;
+                            return expression.equals(Boolean.FALSE)
+                                ? errorCodeType.cast(erCode)
+                                : null;
+                          });
+
+              ResolvableExpression errorLevelExpr = rule.getErrorLevelExpression();
+              ResolvableExpression errorLevelExpression =
+                  ResolvableExpression.withType(errorLevelType)
+                      .withPosition(pos)
+                      .using(
+                          context -> {
+                            if (errorLevelExpr == null || expression == null) return null;
+                            Map<String, Object> mapContext = (Map<String, Object>) context;
+                            Object erLevel = errorLevelExpr.resolve(mapContext);
+                            if (erLevel == null) return null;
+                            return expression.equals(Boolean.FALSE)
+                                ? errorLevelType.cast(erLevel)
+                                : null;
+                          });
+
+              ResolvableExpression BoolvarExpression =
+                  ResolvableExpression.withType(Boolean.class)
+                      .withPosition(pos)
+                      .using(context -> expression);
+
+              ResolvableExpression imbalanceExpression =
+                  ResolvableExpression.withType(measureType)
+                      .withPosition(pos)
+                      .using(
+                          context -> {
+                            Double leftExpression = resolvedLeftRuleExpressions.get(ruleName);
+                            Double rightExpression = resolvedRightRuleExpressions.get(ruleName);
+                            if (leftExpression == null || rightExpression == null) {
+                              return null;
+                            }
+                            if (measureType.isAssignableFrom(Long.class)) {
+                              return leftExpression.longValue() - rightExpression.longValue();
+                            }
+                            return leftExpression - rightExpression;
+                          });
+
+              Map<String, ResolvableExpression> resolvableExpressions = new HashMap<>();
+              resolvableExpressions.put(RULEID, ruleIdExpression);
+              resolvableExpressions.put(componentID, valueDomainExpression);
+              resolvableExpressions.put(BOOLVAR, BoolvarExpression);
+              resolvableExpressions.put(IMBALANCE, imbalanceExpression);
+              resolvableExpressions.put(ERRORLEVEL, errorLevelExpression);
+              resolvableExpressions.put(ERRORCODE, errorCodeExpression);
+
+              datasetsExpression.add(
+                  executeCalc(filteredDataset, resolvableExpressions, roleMap, Map.of()));
+            });
+    DatasetExpression datasetExpression;
+    if (datasetsExpression.size() == 0) {
+      InMemoryDataset emptyCHDataset =
+          new InMemoryDataset(
+              List.of(),
+              Map.of(
+                  measure.getName(),
+                  measureType,
+                  RULEID,
+                  String.class,
+                  componentID,
+                  String.class,
+                  BOOLVAR,
+                  Boolean.class,
+                  IMBALANCE,
+                  Double.class,
+                  ERRORLEVEL,
+                  errorLevelType,
+                  ERRORCODE,
+                  errorCodeType),
+              roleMap);
+      datasetExpression = DatasetExpression.of(emptyCHDataset, pos);
+    } else {
+      datasetExpression = executeUnion(datasetsExpression);
+    }
+    // validationOutput invalid (default) | all | all_measures
+    if (null == validationOutput || validationOutput.equals("invalid")) {
+      DatasetExpression filteredDataset =
+          executeFilter(
+              datasetExpression,
+              ResolvableExpression.withType(Boolean.class).withPosition(pos).using(c -> null),
+              BOOLVAR + " = false");
+      Dataset<Row> result = asSparkDataset(filteredDataset).getSparkDataset().drop(BOOLVAR);
+      return new SparkDatasetExpression(new SparkDataset(result), pos);
+    }
+    if (validationOutput.equals("all")) {
+      String measureName = measure.getName();
+      Dataset<Row> result = asSparkDataset(datasetExpression).getSparkDataset().drop(measureName);
+      return new SparkDatasetExpression(new SparkDataset(result), pos);
+    }
+    // all_measures
+    return datasetExpression;
+  }
+
+  private DatasetExpression executeFilterForHR(DatasetExpression expression, String filterText)
+      throws Exception {
+    SparkDataset dataset = asSparkDataset(expression);
+    Dataset<Row> ds = dataset.getSparkDataset();
+    try {
+      Dataset<Row> result = ds.filter(filterText);
+      if (result.isEmpty()) {
+        result = ds.limit(1);
+      }
+      return new SparkDatasetExpression(new SparkDataset(result, getRoleMap(dataset)), expression);
+    } catch (Exception e) {
+      throw new Exception(e);
+    }
+  }
+
+  private Map<String, Object> extractHRRuleBindings(
+      Map<String, Object> bindings, List<String> items) {
+    Map<String, Object> ruleBindings = new HashMap<>();
+    items.forEach(
+        k -> {
+          if (bindings.containsKey(k)) {
+            Object value = bindings.get(k);
+            ruleBindings.put(k, value);
+          }
+        });
+    return ruleBindings;
+  }
+
+  private Boolean checkRule(
+      List<String> codeItems, Map<String, Object> ruleBindings, String validationMode) {
+    if (validationMode == null || validationMode.equals(NON_NULL)) {
+      if (codeItems.size() != ruleBindings.size()) {
+        return Boolean.FALSE;
+      }
+      if (ruleBindings.values().stream().noneMatch(Objects::isNull)) {
+        return Boolean.TRUE;
+      }
+      return Boolean.FALSE;
+    }
+    if (validationMode.equals(NON_ZERO)) {
+      if (ruleBindings.values().stream()
+          .noneMatch(
+              r -> {
+                if (null == r) {
+                  return Boolean.TRUE;
+                }
+                Double d = null;
+                if (r.getClass().isAssignableFrom(Long.class)) {
+                  d = ((Long) r).doubleValue();
+                }
+                if (r.getClass().isAssignableFrom(Double.class)) {
+                  d = (Double) r;
+                }
+                if (d.equals(0D)) {
+                  return Boolean.FALSE;
+                }
+                return Boolean.TRUE;
+              })) {
+        return Boolean.FALSE;
+      }
+      return Boolean.TRUE;
+    }
+    if (validationMode.equals(PARTIAL_NULL) || validationMode.equals(PARTIAL_ZERO)) {
+      if (ruleBindings.values().stream().filter(Objects::nonNull).count() > 0) {
+        return Boolean.TRUE;
+      }
+      return Boolean.FALSE;
+    }
+    if (validationMode.equals(ALWAYS_NULL) || validationMode.equals(ALWAYS_ZERO)) {
+      return Boolean.TRUE;
+    }
+    return Boolean.FALSE;
+  }
+
+  private Map<String, Object> buildBindingsWithDefault(
+      Map<String, Object> bindings,
+      List<String> ruleItems,
+      String validationMode,
+      Class<?> measureType) {
+    Map<String, Object> bindingsWithDefault = new HashMap<>();
+    ruleItems.forEach(
+        i -> {
+          if (bindings.containsKey(i)) {
+            bindingsWithDefault.put(i, bindings.get(i));
+          } else {
+            // don't need to handle non_null, items are always in bindings
+            if (List.of(NON_ZERO, PARTIAL_ZERO, ALWAYS_ZERO).contains(validationMode)) {
+              if (measureType.isAssignableFrom(Long.class)) {
+                bindingsWithDefault.put(i, 0L);
+              } else bindingsWithDefault.put(i, 0D);
+            }
+            if (List.of(PARTIAL_NULL, ALWAYS_NULL).contains(validationMode)) {
+              bindingsWithDefault.put(i, null);
+            }
+          }
+        });
+    return bindingsWithDefault;
+  }
+
+  private <V, K> Map<V, K> invertMap(Map<K, V> map) {
+    return map.entrySet().stream()
+        .collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
+  }
+
+  private List<Dataset<Row>> toAliasedDatasets(Map<String, DatasetExpression> datasets) {
+    List<Dataset<Row>> sparkDatasets = new ArrayList<>();
+    for (Map.Entry<String, DatasetExpression> dataset : datasets.entrySet()) {
+      var sparkDataset = asSparkDataset(dataset.getValue()).getSparkDataset().as(dataset.getKey());
+      sparkDatasets.add(sparkDataset);
+    }
+    return sparkDatasets;
+  }
+
+  /**
+   * Utility method used for the implementation of the different types of join operations.
+   *
+   * @param sparkDatasets a list datasets.
+   * @param identifiers the list of identifiers to join on.
+   * @param type the type of join operation.
+   * @return The dataset resulting from the join operation.
+   */
+  public Dataset<Row> executeJoin(
+      List<Dataset<Row>> sparkDatasets, List<String> identifiers, String type) {
+    var iterator = sparkDatasets.iterator();
+    var result = iterator.next();
+    while (iterator.hasNext()) {
+      if (type.equals("cross")) result = result.crossJoin(iterator.next());
+      else
+        result = result.join(iterator.next(), iterableAsScalaIterable(identifiers).toSeq(), type);
+    }
+    return result;
+  }
+
+  /**
+   * Execute pivot on dataset expression.
+   *
+   * @param dsExpr dataset expression
+   * @param idName identifier name
+   * @param meName measure name
+   * @param pos script error position
+   * @return the result of the pivot
+   */
+  public DatasetExpression executePivot(
+      DatasetExpression dsExpr, String idName, String meName, Positioned pos) {
+
+    Dataset<Row> sparkDataset = asSparkDataset(dsExpr).getSparkDataset();
+
+    List<String> groupByIdentifiers = new ArrayList<>(dsExpr.getIdentifierNames());
+    groupByIdentifiers.remove(idName);
+
+    Column[] groupByCols =
+        groupByIdentifiers.stream().map(SparkUtils::safeCol).toArray(Column[]::new);
+
+    // TODO: fail if any values needs to be aggregated
+    Dataset<Row> result =
+        sparkDataset
+            .groupBy(groupByCols)
+            .pivot(SparkUtils.safeCol(idName))
+            .agg(functions.first(meName));
+
+    return new SparkDatasetExpression(new SparkDataset(result), pos);
+  }
+
+  /**
+   * The <code>Factory</code> class is an implementation of a VTL engine factory that returns Spark
+   * engines.
+   */
+  public static class Factory implements ProcessingEngineFactory {
+
+    private static final String SPARK_SESSION = "$vtl.spark.session";
+
+    @Override
+    public String getName() {
+      return "spark4";
+    }
+
+    @Override
+    public ProcessingEngine getProcessingEngine(ScriptEngine engine) {
+      // Try to find the session in the script engine.
+      var session = engine.get(SPARK_SESSION);
+      if (session != null) {
+        if (session instanceof SparkSession sparkSession) {
+          return new SparkProcessingEngine(sparkSession);
+        } else {
+          throw new IllegalArgumentException(SPARK_SESSION + " was not a spark session");
+        }
+      } else {
+        var activeSession = SparkSession.active();
+        if (activeSession != null) {
+          return new SparkProcessingEngine(activeSession);
+        } else {
+          throw new IllegalArgumentException("no active spark session");
+        }
+      }
+    }
+  }
+}
diff --git a/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkRowMap.java b/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkRowMap.java
new file mode 100644
index 000000000..64d01c316
--- /dev/null
+++ b/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkRowMap.java
@@ -0,0 +1,81 @@
+package fr.insee.vtl.spark;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+import org.apache.spark.sql.Row;
+
+/** The <code>SparkRowMap</code> class represents a row in a Spark dataset as a map. */
+class SparkRowMap implements Map<String, Object> {
+
+  private final Row row;
+
+  /**
+   * Constructor taking a Spark {@link Row}.
+   *
+   * @param row the row of the Spark dataset.
+   */
+  public SparkRowMap(Row row) {
+    this.row = row;
+  }
+
+  @Override
+  public int size() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public boolean isEmpty() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public boolean containsKey(Object key) {
+    return row.fieldIndex((String) key) > -1;
+  }
+
+  @Override
+  public boolean containsValue(Object value) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public Object get(Object key) {
+    return row.get(row.fieldIndex((String) key));
+  }
+
+  @Override
+  public Object put(String key, Object value) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public Object remove(Object key) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public void putAll(Map<? extends String, ?> m) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public void clear() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public Set<String> keySet() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public Collection<Object> values() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public Set<Entry<String, Object>> entrySet() {
+    throw new UnsupportedOperationException();
+  }
+}
diff --git a/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkUtils.java b/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkUtils.java
new file mode 100644
index 000000000..df7643ab2
--- /dev/null
+++ b/vtl-spark4/src/main/java/fr/insee/vtl/spark4/SparkUtils.java
@@ -0,0 +1,24 @@
+package fr.insee.vtl.spark;
+
+import static scala.collection.JavaConverters.iterableAsScalaIterable;
+
+import java.util.Collection;
+import org.apache.spark.sql.Column;
+import org.apache.spark.sql.functions;
+import scala.collection.Seq;
+
+public final class SparkUtils {
+
+  private SparkUtils() {}
+
+  public static Column safeCol(String name) {
+    if (name == null) {
+      throw new IllegalArgumentException("Column name cannot be null");
+    }
+    return functions.col("`" + name + "`");
+  }
+
+  public static Seq<Column> safeCols(Collection<String> names) {
+    return iterableAsScalaIterable(names.stream().map(SparkUtils::safeCol).toList()).toSeq();
+  }
+}
diff --git a/vtl-spark4/src/main/java/fr/insee/vtl/spark4/package-info.java b/vtl-spark4/src/main/java/fr/insee/vtl/spark4/package-info.java
new file mode 100644
index 000000000..ef61fb20b
--- /dev/null
+++ b/vtl-spark4/src/main/java/fr/insee/vtl/spark4/package-info.java
@@ -0,0 +1,2 @@
+/** This package contains the Spark VTL engine. */
+package fr.insee.vtl.spark4;
diff --git a/vtl-spark4/src/main/resources/META-INF/services/fr.insee.vtl.model.ProcessingEngineFactory b/vtl-spark4/src/main/resources/META-INF/services/fr.insee.vtl.model.ProcessingEngineFactory
new file mode 100644
index 000000000..5466b1492
--- /dev/null
+++ b/vtl-spark4/src/main/resources/META-INF/services/fr.insee.vtl.model.ProcessingEngineFactory
@@ -0,0 +1 @@
+fr.insee.vtl.spark.SparkProcessingEngine$Factory
\ No newline at end of file
diff --git a/vtl-spark4/src/main/resources/c_h.csv b/vtl-spark4/src/main/resources/c_h.csv
new file mode 100644
index 000000000..c1b2a0091
--- /dev/null
+++ b/vtl-spark4/src/main/resources/c_h.csv
@@ -0,0 +1,11 @@
+"id";"Me"
+"ABC";"12"
+"A";"1"
+"B";"10"
+"C";"1"
+"DEF";"100"
+"E";"99"
+"F";"1"
+"HIJ";"100"
+"H";"99"
+"I";"0"
diff --git a/vtl-spark4/src/main/resources/ds1.csv b/vtl-spark4/src/main/resources/ds1.csv
new file mode 100644
index 000000000..efaa125f5
--- /dev/null
+++ b/vtl-spark4/src/main/resources/ds1.csv
@@ -0,0 +1,11 @@
+id;long1;string1;bool1;double1
+1;100;aa;true;0.1
+2;250;bb;true;10.59786
+3;1;cc;true;0
+4;;dd;false;1.2
+5;50;ee;false;
+6;40;ff;true;56
+7;79;gg;true;5.3216004
+8;100;hh;false;0
+9;-2;ii;true;12
+10;0;jjjjjjjj;true;-5
diff --git a/vtl-spark4/src/main/resources/ds2.csv b/vtl-spark4/src/main/resources/ds2.csv
new file mode 100644
index 000000000..a7530f6bc
--- /dev/null
+++ b/vtl-spark4/src/main/resources/ds2.csv
@@ -0,0 +1,6 @@
+id;long1;string1;bool1;double1
+1;200;aaaaaa;false;0.11
+2;-250;bbbbbb;true;11.11999
+3;1;c;true;0
+4;10;ddd;false;-1.2
+5;56;eeeeeeee;false;
diff --git a/vtl-spark4/src/main/resources/input_sample/sample.parquet b/vtl-spark4/src/main/resources/input_sample/sample.parquet
new file mode 100644
index 000000000..d74f91c19
Binary files /dev/null and b/vtl-spark4/src/main/resources/input_sample/sample.parquet differ
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/SparkDatasetTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/SparkDatasetTest.java
new file mode 100644
index 000000000..ffe9f7f35
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/SparkDatasetTest.java
@@ -0,0 +1,147 @@
+package fr.insee.vtl.spark;
+
+import static fr.insee.vtl.model.Structured.Component;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.InMemoryDataset;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.api.java.function.FilterFunction;
+import org.apache.spark.sql.*;
+import org.apache.spark.sql.types.DataTypes;
+import org.apache.spark.sql.types.StructType;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+public class SparkDatasetTest {
+
+  private static SparkSession spark;
+  private ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+    spark =
+        SparkSession.builder()
+            .appName("test")
+            .master("local")
+            .config("spark.driver.bindAddress", "127.0.0.1")
+            .config("spark.driver.host", "127.0.0.1")
+            .config("spark.ui.enabled", "false")
+            .getOrCreate();
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterAll
+  public static void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testFilters() {
+    StructType schema =
+        DataTypes.createStructType(
+            List.of(
+                DataTypes.createStructField("string", DataTypes.StringType, false),
+                DataTypes.createStructField("integer", DataTypes.LongType, false),
+                DataTypes.createStructField("boolean", DataTypes.BooleanType, false),
+                DataTypes.createStructField("float", DataTypes.DoubleType, false)));
+
+    Dataset<Row> dataFrame =
+        spark.createDataFrame(List.of(RowFactory.create("string", 1L, true, 1.5D)), schema);
+
+    dataFrame.filter("integer > 0").collectAsList();
+    dataFrame.filter((FilterFunction<Row>) row -> false).collectAsList();
+    dataFrame.selectExpr("integer + 2 as newInteger").collectAsList();
+  }
+
+  @Test
+  void testVtlCanReadSpark() {
+
+    StructType schema =
+        DataTypes.createStructType(
+            List.of(
+                DataTypes.createStructField("string", DataTypes.StringType, false),
+                DataTypes.createStructField("integer", DataTypes.LongType, false),
+                DataTypes.createStructField("boolean", DataTypes.BooleanType, false),
+                DataTypes.createStructField("float", DataTypes.DoubleType, false)));
+
+    Dataset<Row> dataFrame =
+        spark.createDataFrame(List.of(RowFactory.create("string", 1L, true, 1.5D)), schema);
+
+    fr.insee.vtl.model.Dataset sparkDataset = new SparkDataset(dataFrame);
+
+    fr.insee.vtl.model.Dataset expectedDataset =
+        new InMemoryDataset(
+            List.of(List.of("string", 1L, true, 1.5D)),
+            List.of(
+                new Component("string", String.class, fr.insee.vtl.model.Dataset.Role.MEASURE),
+                new Component("integer", Long.class, fr.insee.vtl.model.Dataset.Role.MEASURE),
+                new Component("boolean", Boolean.class, fr.insee.vtl.model.Dataset.Role.MEASURE),
+                new Component("float", Double.class, fr.insee.vtl.model.Dataset.Role.MEASURE)));
+
+    assertThat(sparkDataset.getDataStructure()).isEqualTo(expectedDataset.getDataStructure());
+    assertThat(sparkDataset.getDataPoints()).isEqualTo(expectedDataset.getDataPoints());
+  }
+
+  @Test
+  public void testParquetMetadataReading(@TempDir Path tmpDirectory) {
+    SparkDataset sparkDataset =
+        new SparkDataset(
+            spark.read().parquet("src/main/resources/input_sample"),
+            Map.of(
+                "year", fr.insee.vtl.model.Dataset.Role.IDENTIFIER,
+                "student_number", fr.insee.vtl.model.Dataset.Role.ATTRIBUTE));
+    assertTrue(sparkDataset.getDataStructure().get("year").isIdentifier());
+    assertTrue(sparkDataset.getDataStructure().get("student_number").isAttribute());
+
+    // Write the file as parquet and read again.
+    sparkDataset
+        .getSparkDataset()
+        .write()
+        .mode(SaveMode.Overwrite)
+        .parquet(tmpDirectory.toString());
+    SparkDataset readSparkDataset = new SparkDataset(spark.read().parquet(tmpDirectory.toString()));
+
+    assertTrue(readSparkDataset.getDataStructure().get("year").isIdentifier());
+    assertTrue(readSparkDataset.getDataStructure().get("student_number").isAttribute());
+  }
+
+  @Test
+  public void testParquetMetadataWriting(@TempDir Path tmpDirectory) throws ScriptException {
+    SparkDataset datasetWithoutMetadata =
+        new SparkDataset(spark.read().parquet("src/main/resources/input_sample"));
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds", datasetWithoutMetadata, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("ds1 := ds[calc identifier school_id := school_id, attribute year := year];");
+
+    SparkDataset dsWithRoles = (SparkDataset) engine.getContext().getAttribute("ds1");
+    dsWithRoles.getSparkDataset().write().mode(SaveMode.Overwrite).parquet(tmpDirectory.toString());
+
+    SparkDataset dsWithMetadata = new SparkDataset(spark.read().parquet(tmpDirectory.toString()));
+
+    assertTrue(dsWithMetadata.getDataStructure().get("school_id").isIdentifier());
+    assertTrue(dsWithMetadata.getDataStructure().get("year").isAttribute());
+
+    context.setAttribute("ds2", dsWithMetadata, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("ds3 := ds2[calc identifier year := year];");
+
+    SparkDataset dsWithMetadataAndRoles = (SparkDataset) engine.getContext().getAttribute("ds3");
+
+    assertTrue(dsWithMetadataAndRoles.getDataStructure().get("year").isIdentifier());
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/SparkSQLTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/SparkSQLTest.java
new file mode 100644
index 000000000..1da61da52
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/SparkSQLTest.java
@@ -0,0 +1,181 @@
+package fr.insee.vtl.spark;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import java.io.File;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class SparkSQLTest {
+
+  private static SparkSession spark;
+  private ScriptEngine engine;
+  private File databaseFile;
+
+  @BeforeEach
+  public void setUp() throws SQLException, IOException {
+    databaseFile = File.createTempFile("vtl-test", "h2");
+    databaseFile.deleteOnExit();
+    var connection = DriverManager.getConnection("jdbc:h2:" + databaseFile);
+    var statement = connection.createStatement();
+    statement.executeUpdate(
+        "create table if not exists ds1 ("
+            + "  id integer,"
+            + "  colChar char(7), "
+            + "  colVarchar varchar, "
+            + "  colInteger int,"
+            + "  colInteger4 int4,"
+            + "  colFloat float,"
+            + "  colFloat8 float8,"
+            + "  colBoolean boolean,"
+            + "  colNumeric numeric(20,2),"
+            + "  colBigint int8,"
+            + "  colTimestamp timestamp,"
+            + "  colDate date,"
+            + "  primary key (id)"
+            + ")");
+
+    statement.executeUpdate("delete from ds1");
+    statement.executeUpdate(
+        "insert into ds1 values (1, 'string1', 'string1', 1, 1, 1.2, 1.2, 'true', 1.2, 100, '2001-01-01T00:00:00Z', '2001-01-01')");
+    statement.executeUpdate(
+        "insert into ds1 values (2, 'string2', 'string2', 2, 2, 5.2, 5.2, 'false', 5.2, 200, '2002-01-01T00:00:00Z', '2002-01-01')");
+    statement.executeUpdate(
+        "insert into ds1 values (3, 'string3', 'string3', 3, 3, 3.2, 3.2, 'true', 3.2, 300, '2003-01-01T00:00:00Z', '2003-01-01')");
+    statement.executeUpdate(
+        "insert into ds1 values (4, 'string4', 'string4', 4, 4, 4.2, 4.2, 'false', 4.2, 400, '2004-01-01T00:00:00Z', '2004-01-01')");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterAll
+  public static void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testReadSql() throws ScriptException {
+
+    // See https://spark.apache.org/docs/latest/sql-data-sources-jdbc.html
+    var ds1 =
+        spark
+            .read()
+            .format("jdbc")
+            .option("url", "jdbc:h2:" + databaseFile)
+            // .option("dbtable", "DS1")
+            .option("query", "select * from DS1")
+            .load();
+
+    var bindings = engine.getBindings(ScriptContext.ENGINE_SCOPE);
+    bindings.put("ds1", new SparkDataset(ds1, Map.of("id", Dataset.Role.IDENTIFIER)));
+
+    engine.eval(
+        "ds2 := ds1[calc "
+            + "col1 := COLCHAR || \" ok\", "
+            + "col2 := COLVARCHAR || \" ok\", "
+            + "col3 := COLINTEGER + 1, "
+            + "col4 := COLINTEGER4 * 100, "
+            + "col5 := round(COLFLOAT - 0.1, 1), "
+            + "col6 := round(COLFLOAT8 - 0.0009, 4), "
+            + "col7 := not(COLBOOLEAN), "
+            + "col8 := round(COLNUMERIC + 0.0001, 4), "
+            + "col9 := COLBIGINT + 9999, "
+            + "col10 := cast(COLTIMESTAMP, string, \"YYYY\"), "
+            + "col11 := cast(COLDATE, string, \"YYYY\") "
+            + "]"
+            + "[keep ID, col1, col2, col3, col4, col5, col6, col7, col8, col9, col10, col11];");
+
+    var ds2 = (Dataset) bindings.get("ds2");
+    List<List<Object>> roundedDs2 =
+        ds2.getDataAsList().stream()
+            .map(
+                line ->
+                    line.stream()
+                        .map(
+                            element -> {
+                              if (element instanceof Double double1) {
+                                BigDecimal bd = new BigDecimal(Double.toString(double1));
+                                bd = bd.setScale(10, RoundingMode.HALF_UP);
+                                return bd.doubleValue();
+                              }
+                              return element;
+                            })
+                        .collect(Collectors.toList()))
+            .collect(Collectors.toList());
+
+    assertThat(roundedDs2)
+        .containsExactlyInAnyOrder(
+            List.of(
+                1L,
+                "string1 ok",
+                "string1 ok",
+                2L,
+                100L,
+                1.1D,
+                1.1991D,
+                false,
+                1.2001D,
+                10099L,
+                "2001",
+                "2001"),
+            List.of(
+                2L,
+                "string2 ok",
+                "string2 ok",
+                3L,
+                200L,
+                5.1D,
+                5.1991D,
+                true,
+                5.2001D,
+                10199L,
+                "2002",
+                "2002"),
+            List.of(
+                3L,
+                "string3 ok",
+                "string3 ok",
+                4L,
+                300L,
+                3.1D,
+                3.1991D,
+                false,
+                3.2001D,
+                10299L,
+                "2003",
+                "2003"),
+            List.of(
+                4L,
+                "string4 ok",
+                "string4 ok",
+                5L,
+                400L,
+                4.1D,
+                4.1991D,
+                true,
+                4.2001D,
+                10399L,
+                "2004",
+                "2004"));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/TemporalTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/TemporalTest.java
new file mode 100644
index 000000000..9badbca8d
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/TemporalTest.java
@@ -0,0 +1,97 @@
+package fr.insee.vtl.spark;
+
+import static fr.insee.vtl.model.Structured.Component;
+import static fr.insee.vtl.spark.processing.engine.analytic.AnalyticTest.spark;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import java.io.IOException;
+import java.time.Instant;
+import java.util.List;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class TemporalTest {
+
+  private ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+    SparkSession spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterAll
+  public static void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testFlowToStock() throws ScriptException {
+    var ds =
+        new InMemoryDataset(
+            List.of(
+                new Component("id1", String.class, Dataset.Role.IDENTIFIER),
+                new Component("id2", Instant.class, Dataset.Role.IDENTIFIER),
+                new Component("me1", Long.class, Dataset.Role.MEASURE)),
+            List.of("A", Instant.parse("2009-01-01T00:00:00Z"), 2L),
+            List.of("A", Instant.parse("2011-01-01T00:00:00Z"), 5L),
+            List.of("A", Instant.parse("2012-01-01T00:00:00Z"), -3L),
+            List.of("B", Instant.parse("2010-01-01T00:00:00Z"), 9L),
+            List.of("B", Instant.parse("2011-01-01T00:00:00Z"), 4L),
+            List.of("B", Instant.parse("2013-01-01T00:00:00Z"), -6L));
+    engine.put("ds", ds);
+    engine.eval("r := flow_to_stock(ds);");
+    assertThat(engine.get("r")).isInstanceOf(Dataset.class);
+    assertThat(((Dataset) engine.get("r")).getDataAsList())
+        .containsExactlyInAnyOrder(
+            List.of("A", Instant.parse("2009-01-01T00:00:00Z"), 2L),
+            List.of("A", Instant.parse("2011-01-01T00:00:00Z"), 7L),
+            List.of("A", Instant.parse("2012-01-01T00:00:00Z"), 4L),
+            List.of("B", Instant.parse("2010-01-01T00:00:00Z"), 9L),
+            List.of("B", Instant.parse("2011-01-01T00:00:00Z"), 13L),
+            List.of("B", Instant.parse("2013-01-01T00:00:00Z"), 7L));
+  }
+
+  @Test
+  public void testStockToFlow() throws ScriptException {
+    var ds =
+        new InMemoryDataset(
+            List.of(
+                new Component("id1", String.class, Dataset.Role.IDENTIFIER),
+                new Component("id2", Instant.class, Dataset.Role.IDENTIFIER),
+                new Component("me1", Long.class, Dataset.Role.MEASURE),
+                new Component("me2", String.class, Dataset.Role.MEASURE)),
+            List.of("A", Instant.parse("2010-01-01T00:00:00Z"), 2L, "foo"),
+            List.of("A", Instant.parse("2011-01-01T00:00:00Z"), 7L, "foo"),
+            List.of("A", Instant.parse("2012-01-01T00:00:00Z"), 4L, "foo"),
+            List.of("A", Instant.parse("2013-01-01T00:00:00Z"), 13L, "foo"),
+            List.of("B", Instant.parse("2010-01-01T00:00:00Z"), 4L, "foo"),
+            List.of("B", Instant.parse("2011-01-01T00:00:00Z"), -4L, "foo"),
+            List.of("B", Instant.parse("2012-01-01T00:00:00Z"), -4L, "foo"),
+            List.of("B", Instant.parse("2013-01-01T00:00:00Z"), 2L, "foo"));
+    engine.put("ds", ds);
+    engine.eval("res := stock_to_flow(ds);");
+    assertThat(engine.get("res")).isInstanceOf(Dataset.class);
+    ((Dataset) engine.get("res")).getDataAsMap().forEach(System.out::println);
+    assertThat(((Dataset) engine.get("res")).getDataAsList())
+        .containsExactly(
+            List.of("A", Instant.parse("2010-01-01T00:00:00Z"), "foo", 2L),
+            List.of("A", Instant.parse("2011-01-01T00:00:00Z"), "foo", 5L),
+            List.of("A", Instant.parse("2012-01-01T00:00:00Z"), "foo", -3L),
+            List.of("A", Instant.parse("2013-01-01T00:00:00Z"), "foo", 9L),
+            List.of("B", Instant.parse("2010-01-01T00:00:00Z"), "foo", 4L),
+            List.of("B", Instant.parse("2011-01-01T00:00:00Z"), "foo", -8L),
+            List.of("B", Instant.parse("2012-01-01T00:00:00Z"), "foo", 0L),
+            List.of("B", Instant.parse("2013-01-01T00:00:00Z"), "foo", 6L));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/AggregateTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/AggregateTest.java
new file mode 100644
index 000000000..ac2101dd7
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/AggregateTest.java
@@ -0,0 +1,305 @@
+package fr.insee.vtl.spark.processing.engine;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import fr.insee.vtl.model.Structured;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class AggregateTest {
+
+  InMemoryDataset dataset =
+      new InMemoryDataset(
+          List.of(
+              Map.of("name", "Hadrien", "country", "norway", "age", 10L, "weight", 11D),
+              Map.of("name", "Nico", "country", "france", "age", 11L, "weight", 10D),
+              Map.of("name", "Franck", "country", "france", "age", 12L, "weight", 9D),
+              Map.of("name", "pengfei", "country", "france", "age", 13L, "weight", 11D)),
+          Map.of(
+              "name",
+              String.class,
+              "country",
+              String.class,
+              "age",
+              Long.class,
+              "weight",
+              Double.class),
+          Map.of(
+              "name",
+              Dataset.Role.IDENTIFIER,
+              "country",
+              Dataset.Role.IDENTIFIER,
+              "age",
+              Dataset.Role.MEASURE,
+              "weight",
+              Dataset.Role.MEASURE));
+  private SparkSession spark;
+  private ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterEach
+  public void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  void testAggregateGroupAll() throws ScriptException {
+    engine.put("ds1", dataset);
+    engine.eval("res := ds1[aggr test := sum(age) group all length(name)];");
+
+    var actual = ((Dataset) engine.get("res"));
+
+    assertThat(actual.getDataAsMap())
+        .containsExactly(
+            Map.of("test", 23L, "time", 7L),
+            Map.of("test", 12L, "time", 6L),
+            Map.of("test", 11L, "time", 4L));
+  }
+
+  @Test
+  public void testAggregateClause() throws ScriptException {
+
+    engine.put("ds1", dataset);
+    engine.eval(
+        "res := ds1[aggr "
+            + "sumAge := sum(age*2),"
+            + "avgWeight := avg(weight),"
+            + "countVal := count(),"
+            + "maxAge := max(age),"
+            + "maxWeight := max(weight),"
+            + "minAge := min(age),"
+            + "minWeight := min(weight),"
+            + "medianAge := median(age),"
+            + "medianWeight := median(weight)"
+            + " group by country];");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of(
+                "country",
+                "france",
+                "sumAge",
+                72L,
+                "avgWeight",
+                10.0D,
+                "countVal",
+                3L,
+                "maxAge",
+                13L,
+                "maxWeight",
+                11.0D,
+                "minAge",
+                11L,
+                "minWeight",
+                9D,
+                "medianAge",
+                12L,
+                "medianWeight",
+                10.0D),
+            Map.of(
+                "country",
+                "norway",
+                "sumAge",
+                20L,
+                "avgWeight",
+                11.0,
+                "countVal",
+                1L,
+                "maxAge",
+                10L,
+                "maxWeight",
+                11.0D,
+                "minAge",
+                10L,
+                "minWeight",
+                11D,
+                "medianAge",
+                10L,
+                "medianWeight",
+                11D));
+
+    //        InMemoryDataset dataset2 = new InMemoryDataset(
+    //                List.of(
+    //                        Map.of("name", "Hadrien", "country", "norway", "age", 10L, "weight",
+    // 11D),
+    //                        Map.of("name", "Nico", "country", "france", "age", 9L, "weight", 5D),
+    //                        Map.of("name", "Franck", "country", "france", "age", 10L, "weight",
+    // 15D),
+    //                        Map.of("name", "Nico1", "country", "france", "age", 11L, "weight",
+    // 10D),
+    //                        Map.of("name", "Franck1", "country", "france", "age", 12L, "weight",
+    // 8D)
+    //                ),
+    //                Map.of("name", String.class, "country", String.class, "age", Long.class,
+    // "weight", Double.class),
+    //                Map.of("name", Role.IDENTIFIER, "country", Role.IDENTIFIER, "age",
+    // Role.MEASURE, "weight", Role.MEASURE)
+    //        );
+    //
+    //        context.setAttribute("ds2", dataset2, ScriptContext.ENGINE_SCOPE);
+    //
+    //        engine.eval("res := ds2[aggr " +
+    //                "stddev_popAge := stddev_pop(age), " +
+    //                "stddev_popWeight := stddev_pop(weight), " +
+    //                "stddev_sampAge := stddev_samp(age), " +
+    //                "stddev_sampWeight := stddev_samp(weight), " +
+    //                "var_popAge := var_pop(age), " +
+    //                "var_popWeight := var_pop(weight), " +
+    //                "var_sampAge := var_samp(age), " +
+    //                "var_sampWeight := var_samp(weight)" +
+    //                " group by country];");
+    //
+    //        assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+    //
+    //        var fr = ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap().get(0);
+    //
+    //        assertThat((Double) fr.get("stddev_popAge")).isCloseTo(1.118,
+    // Percentage.withPercentage(2));
+    //        assertThat((Double) fr.get("stddev_popWeight")).isCloseTo(3.640,
+    // Percentage.withPercentage(2));
+    //        assertThat((Double) fr.get("stddev_sampAge")).isCloseTo(1.290,
+    // Percentage.withPercentage(2));
+    //        assertThat((Double) fr.get("stddev_sampWeight")).isCloseTo(4.2,
+    // Percentage.withPercentage(2));
+    //        assertThat((Double) fr.get("var_popAge")).isEqualTo(1.25);
+    //        assertThat((Double) fr.get("var_popWeight")).isEqualTo(13.25);
+    //        assertThat((Double) fr.get("var_sampAge")).isCloseTo(1.666,
+    // Percentage.withPercentage(2));
+    //        assertThat((Double) fr.get("var_sampWeight")).isCloseTo(17.666,
+    // Percentage.withPercentage(2));
+    //
+    //        var no = ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap().get(1);
+    //
+    //        assertThat((Double) no.get("stddev_popAge")).isEqualTo(0.0);
+    //        assertThat((Double) no.get("stddev_popWeight")).isEqualTo(0.0);
+    //        assertThat((Double) no.get("stddev_sampAge")).isEqualTo(0.0);
+    //        assertThat((Double) no.get("stddev_sampWeight")).isEqualTo(0.0);
+    //        assertThat((Double) no.get("var_popAge")).isEqualTo(0.0);
+    //        assertThat((Double) no.get("var_popWeight")).isEqualTo(0.0);
+    //        assertThat((Double) no.get("var_sampAge")).isEqualTo(0.0);
+    //        assertThat((Double) no.get("var_sampWeight")).isEqualTo(0.0);
+
+  }
+
+  @Test
+  public void testMinMax() throws ScriptException {
+
+    InMemoryDataset ds =
+        new InMemoryDataset(
+            List.of(
+                List.of(
+                    "Hadrien", "No", 10L, 11D, true, "01/01/1990"
+                    // ,
+                    // "2000-01-01/2000-12-31",
+                    // "2000M12"
+                    ),
+                List.of(
+                    "Nico", "Fr", 10L, 11D, false, "01/01/1991"
+                    // ,
+                    // "2000-01-01/2000-01-31",
+                    // "2000M11"
+                    ),
+                List.of(
+                    "Franck", "Fr", 12L, 9D, true, "01/01/1989"
+                    // ,
+                    // "2000-01-01/2000-03-31",
+                    // "2010M10"
+                    )),
+            List.of(
+                new Structured.Component("name", String.class, Dataset.Role.MEASURE),
+                new Structured.Component("country", String.class, Dataset.Role.IDENTIFIER),
+                new Structured.Component("l", Long.class, Dataset.Role.MEASURE),
+                new Structured.Component("dou", Double.class, Dataset.Role.MEASURE),
+                new Structured.Component("boo", Boolean.class, Dataset.Role.MEASURE),
+                new Structured.Component("d", String.class, Dataset.Role.MEASURE)
+                // ,
+                // new Structured.Component("dur", String.class, Dataset.Role.MEASURE),
+                // new Structured.Component("tp", String.class, Dataset.Role.MEASURE)
+                ));
+
+    engine.put("ds", ds);
+    engine.eval(
+        "res := ds[calc d := cast(d, date, \"dd/MM/yyyy\")"
+            +
+            // ", "
+            // + "             dur := cast(dur, string), "
+            // + "             tp := cast(tp, string)" +
+            "]"
+            + "[aggr "
+            + "minName := min(name),"
+            + "maxName := max(name),"
+            + "minL := min(l),"
+            + "maxL := max(l),"
+            + "minDou := min(dou),"
+            + "maxDou := max(dou),"
+            + "minBoo := min(boo),"
+            + "maxBoo := max(boo),"
+            + "minD := min(d),"
+            + "maxD := max(d)"
+            // + ","
+            // + "minDur := min(dur),"
+            // + "maxDur := max(dur),"
+            // + "minTp := min(tp),"
+            // + "maxTp := max(tp)"
+            + " group by country]"
+            + " [calc minD := cast(minD, string, \"dd/MM/yyyy\"),"
+            + "       maxD := cast(maxD, string, \"dd/MM/yyyy\")"
+            // + ","
+            // + "       minDur := cast(minDur, string),"
+            // + "       maxDur := cast(maxDur, string),"
+            // + "       minTp := cast(minTp, string),"
+            // + "       maxTp := cast(maxTp, string)"
+            + " ];");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsList())
+        .containsExactlyInAnyOrder(
+            List.of(
+                "No",
+                "Hadrien",
+                "Hadrien",
+                10L,
+                10L,
+                11D,
+                11D,
+                true,
+                true,
+                "01/01/1990",
+                "01/01/1990"
+                // ,
+                // "2000-01-01/2000-12-31",
+                // "2000-01-01/2000-12-31",
+                // "2000M12",
+                // "2000M12"
+                ),
+            List.of(
+                "Fr", "Franck", "Nico", 10L, 12L, 9D, 11D, false, true, "01/01/1989", "01/01/1991"
+                // ,
+                // "2000-01-01/2000-01-31",
+                // "2000-01-01/2000-03-31",
+                // "2000M11",
+                // "2010Q1"
+                ));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/CalcTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/CalcTest.java
new file mode 100644
index 000000000..b102e271b
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/CalcTest.java
@@ -0,0 +1,120 @@
+package fr.insee.vtl.spark.processing.engine;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import fr.insee.vtl.model.Structured;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class CalcTest {
+
+  private SparkSession spark;
+  private ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterEach
+  public void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  InMemoryDataset dataset =
+      new InMemoryDataset(
+          List.of(
+              Map.of("name", "Hadrien", "age", 10L, "weight", 11L),
+              Map.of("name", "Nico", "age", 11L, "weight", 10L),
+              Map.of("name", "Franck", "age", 12L, "weight", 9L)),
+          Map.of("name", String.class, "age", Long.class, "weight", Long.class),
+          Map.of(
+              "name",
+              Dataset.Role.IDENTIFIER,
+              "age",
+              Dataset.Role.MEASURE,
+              "weight",
+              Dataset.Role.MEASURE));
+
+  @Test
+  public void testCalcClause() throws ScriptException, InterruptedException {
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", dataset, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "ds := ds1[calc test := between(age, 10, 11), age := age * 2, attribute wisdom := (weight + age) / 2];");
+
+    var ds = (Dataset) engine.getContext().getAttribute("ds");
+    assertThat(ds).isInstanceOf(Dataset.class);
+    assertThat(ds.getDataAsMap())
+        .isEqualTo(
+            List.of(
+                Map.of("name", "Hadrien", "age", 20L, "test", true, "weight", 11L, "wisdom", 10.5D),
+                Map.of("name", "Nico", "age", 22L, "test", true, "weight", 10L, "wisdom", 10.5D),
+                Map.of(
+                    "name", "Franck", "age", 24L, "test", false, "weight", 9L, "wisdom", 10.5D)));
+    assertThat(ds.getDataStructure())
+        .containsValues(
+            new Structured.Component("name", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("age", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("test", Boolean.class, Dataset.Role.MEASURE),
+            new Structured.Component("weight", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("wisdom", Double.class, Dataset.Role.ATTRIBUTE));
+  }
+
+  @Test
+  public void testCaseElseAppliesWhenWhenConditionIsNull() throws ScriptException {
+    ScriptContext context = engine.getContext();
+
+    Map<String, Object> r4 = new HashMap<>();
+    r4.put("name", "NullGuy");
+    r4.put("me_1", null);
+
+    InMemoryDataset dsWithNull =
+        new InMemoryDataset(
+            List.of(
+                Map.of("name", "A", "me_1", 0.12D),
+                Map.of("name", "B", "me_1", 3.5D),
+                Map.of("name", "C", "me_1", 10.7D),
+                r4),
+            Map.of("name", String.class, "me_1", Double.class),
+            Map.of("name", Dataset.Role.IDENTIFIER, "me_1", Dataset.Role.MEASURE));
+
+    context.setAttribute("ds_null", dsWithNull, ScriptContext.ENGINE_SCOPE);
+    engine.eval(
+        "res := ds_null[calc me_2 := case when me_1 <= 1 then 0 when me_1 > 1 and me_1 <= 10 then 1 when me_1 > 10 then 10 else 100];");
+
+    Dataset res = (Dataset) context.getAttribute("res");
+    assertThat(res.getDataAsMap())
+        .contains(
+            Map.of("name", "A", "me_1", 0.12D, "me_2", 0L),
+            Map.of("name", "B", "me_1", 3.5D, "me_2", 1L),
+            Map.of("name", "C", "me_1", 10.7D, "me_2", 10L));
+
+    Map<String, Object> expectedNullRow = new HashMap<>();
+    expectedNullRow.put("name", "NullGuy");
+    expectedNullRow.put("me_1", null);
+    expectedNullRow.put("me_2", 100L);
+    assertThat(res.getDataAsMap()).contains(expectedNullRow);
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/FilterTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/FilterTest.java
new file mode 100644
index 000000000..1b0d36cd3
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/FilterTest.java
@@ -0,0 +1,94 @@
+package fr.insee.vtl.spark.processing.engine;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.engine.exceptions.ConflictingTypesException;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import fr.insee.vtl.model.Structured;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class FilterTest {
+
+  InMemoryDataset dataset =
+      new InMemoryDataset(
+          List.of(
+              Map.of("name", "Hadrien", "age", 10L, "weight", 11L),
+              Map.of("name", "Nico", "age", 11L, "weight", 10L),
+              Map.of("name", "Franck", "age", 12L, "weight", 9L)),
+          Map.of("name", String.class, "age", Long.class, "weight", Long.class),
+          Map.of(
+              "name",
+              Dataset.Role.IDENTIFIER,
+              "age",
+              Dataset.Role.MEASURE,
+              "weight",
+              Dataset.Role.MEASURE));
+  private SparkSession spark;
+  private ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterEach
+  public void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testLessThanBadTypes() {
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds", dataset, ScriptContext.ENGINE_SCOPE);
+    assertThatThrownBy(() -> engine.eval("ds_out := ds[filter name < 1];"))
+        .isInstanceOf(ConflictingTypesException.class)
+        .hasMessage("conflicting types: [String, Long]");
+  }
+
+  @Test
+  public void testLessThanGoodTypes() throws ScriptException {
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds", dataset, ScriptContext.ENGINE_SCOPE);
+    engine.eval("ds_out := ds[filter 18.1 < age];");
+  }
+
+  @Test
+  public void testFilterClause() throws ScriptException {
+
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", dataset, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("ds := ds1[filter age > 10 and age < 12];");
+
+    assertThat(engine.getContext().getAttribute("ds")).isInstanceOf(Dataset.class);
+    var ds = (Dataset) engine.getContext().getAttribute("ds");
+    assertThat(ds.getDataAsMap())
+        .isEqualTo(List.of(Map.of("name", "Nico", "age", 11L, "weight", 10L)));
+
+    assertThat(ds.getDataStructure())
+        .containsValues(
+            new Structured.Component("name", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("age", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("weight", Long.class, Dataset.Role.MEASURE));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/JoinTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/JoinTest.java
new file mode 100644
index 000000000..8374c1d6c
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/JoinTest.java
@@ -0,0 +1,278 @@
+package fr.insee.vtl.spark.processing.engine;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import fr.insee.vtl.model.Structured;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class JoinTest {
+
+  private final InMemoryDataset dataset1 =
+      new InMemoryDataset(
+          List.of(
+              List.of("a", 1L, 2L),
+              List.of("b", 3L, 4L),
+              List.of("c", 5L, 6L),
+              List.of("d", 7L, 8L)),
+          List.of(
+              new Structured.Component("name", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("age", Long.class, Dataset.Role.MEASURE),
+              new Structured.Component("weight", Long.class, Dataset.Role.MEASURE)));
+  private final InMemoryDataset dataset2 =
+      new InMemoryDataset(
+          List.of(
+              List.of(9L, "a", 10L),
+              List.of(11L, "b", 12L),
+              List.of(12L, "c", 13L),
+              List.of(14L, "c", 15L)),
+          List.of(
+              new Structured.Component("age2", Long.class, Dataset.Role.MEASURE),
+              new Structured.Component("name", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("weight2", Long.class, Dataset.Role.MEASURE)));
+  private final InMemoryDataset dataset3 =
+      new InMemoryDataset(
+          List.of(
+              List.of(16L, "a", 17L),
+              List.of(18L, "b", 19L),
+              List.of(20L, "c", 21L),
+              List.of(22L, "c", 23L)),
+          List.of(
+              new Structured.Component("age3", Long.class, Dataset.Role.MEASURE),
+              new Structured.Component("name", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("weight3", Long.class, Dataset.Role.MEASURE)));
+  private SparkSession spark;
+  private ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterEach
+  public void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testLeftJoin() throws ScriptException {
+
+    ScriptContext context = engine.getContext();
+    context.getBindings(ScriptContext.ENGINE_SCOPE).put("ds_1", dataset1);
+    context.getBindings(ScriptContext.ENGINE_SCOPE).put("ds_2", dataset2);
+    context.getBindings(ScriptContext.ENGINE_SCOPE).put("ds_3", dataset3);
+
+    engine.eval("result := left_join(ds_1 as ds1, ds_2 as ds2, ds_3 as ds3);");
+
+    var result = (Dataset) context.getAttribute("result");
+    assertThat(result.getDataAsList())
+        .containsExactlyInAnyOrder(
+            Arrays.asList("a", 2L, 16L, 17L, 10L, 1L, 9L),
+            Arrays.asList("b", 4L, 18L, 19L, 12L, 3L, 11L),
+            Arrays.asList("c", 6L, 22L, 23L, 15L, 5L, 14L),
+            Arrays.asList("c", 6L, 20L, 21L, 15L, 5L, 14L),
+            Arrays.asList("c", 6L, 22L, 23L, 13L, 5L, 12L),
+            Arrays.asList("c", 6L, 20L, 21L, 13L, 5L, 12L),
+            Arrays.asList("d", 8L, null, null, null, 7L, null));
+
+    assertThat(result.getDataStructure())
+        .containsValues(
+            new Structured.Component("name", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("age", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("weight", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("age2", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("weight2", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("age3", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("weight3", Long.class, Dataset.Role.MEASURE));
+  }
+
+  @Test
+  public void testInnerJoin() throws ScriptException {
+    ScriptContext context = engine.getContext();
+    context.getBindings(ScriptContext.ENGINE_SCOPE).put("ds1", dataset1);
+    context.getBindings(ScriptContext.ENGINE_SCOPE).put("ds2", dataset2);
+    context.getBindings(ScriptContext.ENGINE_SCOPE).put("ds3", dataset3);
+
+    engine.eval("result := inner_join(ds1 as dsOne, ds2, ds3);");
+
+    var resultInner = (Dataset) context.getAttribute("result");
+    assertThat(resultInner.getDataAsList())
+        .containsExactlyInAnyOrder(
+            Arrays.asList("a", 2L, 16L, 17L, 10L, 1L, 9L),
+            Arrays.asList("b", 4L, 18L, 19L, 12L, 3L, 11L),
+            Arrays.asList("c", 6L, 22L, 23L, 15L, 5L, 14L),
+            Arrays.asList("c", 6L, 20L, 21L, 15L, 5L, 14L),
+            Arrays.asList("c", 6L, 22L, 23L, 13L, 5L, 12L),
+            Arrays.asList("c", 6L, 20L, 21L, 13L, 5L, 12L));
+
+    assertThat(resultInner.getDataStructure())
+        .containsValues(
+            new Structured.Component("name", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("age", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("weight", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("age2", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("weight2", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("age3", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("weight3", Long.class, Dataset.Role.MEASURE));
+  }
+
+  @Test
+  public void testFullJoin() throws ScriptException {
+    ScriptContext context = engine.getContext();
+
+    var ds1 =
+        new InMemoryDataset(
+            List.of(
+                new Structured.Component("id", String.class, Dataset.Role.IDENTIFIER),
+                new Structured.Component("m1", Long.class, Dataset.Role.MEASURE)),
+            Arrays.asList("b", 1L),
+            Arrays.asList("c", 2L),
+            Arrays.asList("d", 3L));
+
+    var ds2 =
+        new InMemoryDataset(
+            List.of(
+                new Structured.Component("id", String.class, Dataset.Role.IDENTIFIER),
+                new Structured.Component("m1", Long.class, Dataset.Role.MEASURE)),
+            Arrays.asList("a", 4L),
+            Arrays.asList("b", 5L),
+            Arrays.asList("c", 6L));
+
+    var ds3 =
+        new InMemoryDataset(
+            List.of(
+                new Structured.Component("id", String.class, Dataset.Role.IDENTIFIER),
+                new Structured.Component("m1", Long.class, Dataset.Role.MEASURE)),
+            Arrays.asList("a", 7L),
+            Arrays.asList("d", 8L));
+
+    context.getBindings(ScriptContext.ENGINE_SCOPE).put("ds_1", ds1);
+    context.getBindings(ScriptContext.ENGINE_SCOPE).put("ds_2", ds2);
+    context.getBindings(ScriptContext.ENGINE_SCOPE).put("ds_3", ds3);
+
+    engine.eval("result := full_join(ds_1 as ds1, ds_2 as ds2, ds_3 as ds3);");
+
+    var result = (Dataset) context.getAttribute("result");
+
+    assertThat(result.getDataStructure().values())
+        .containsExactlyInAnyOrder(
+            new Structured.Component("id", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("m1", Long.class, Dataset.Role.MEASURE));
+
+    assertThat(result.getDataAsList())
+        .containsExactlyInAnyOrder(
+            Arrays.asList(8L, "d"),
+            Arrays.asList(null, "c"),
+            Arrays.asList(null, "b"),
+            Arrays.asList(7L, "a"));
+  }
+
+  @Test
+  public void testCrossJoin() throws ScriptException {
+    ScriptContext context = engine.getContext();
+    context.getBindings(ScriptContext.ENGINE_SCOPE).put("ds1", dataset1);
+    context.getBindings(ScriptContext.ENGINE_SCOPE).put("ds2", dataset2);
+    context.getBindings(ScriptContext.ENGINE_SCOPE).put("ds3", dataset3);
+
+    engine.eval("result := cross_join(ds1 as dsOne, ds2, ds3);");
+
+    var resultCross = (Dataset) context.getAttribute("result");
+    assertThat(resultCross.getDataAsList())
+        .containsExactlyInAnyOrder(
+            Arrays.asList("a", 1L, 2L, 9L, "a", 10L, 16L, "a", 17L),
+            Arrays.asList("a", 1L, 2L, 9L, "a", 10L, 18L, "b", 19L),
+            Arrays.asList("a", 1L, 2L, 9L, "a", 10L, 20L, "c", 21L),
+            Arrays.asList("a", 1L, 2L, 9L, "a", 10L, 22L, "c", 23L),
+            Arrays.asList("a", 1L, 2L, 11L, "b", 12L, 16L, "a", 17L),
+            Arrays.asList("a", 1L, 2L, 11L, "b", 12L, 18L, "b", 19L),
+            Arrays.asList("a", 1L, 2L, 11L, "b", 12L, 20L, "c", 21L),
+            Arrays.asList("a", 1L, 2L, 11L, "b", 12L, 22L, "c", 23L),
+            Arrays.asList("a", 1L, 2L, 12L, "c", 13L, 16L, "a", 17L),
+            Arrays.asList("a", 1L, 2L, 12L, "c", 13L, 18L, "b", 19L),
+            Arrays.asList("a", 1L, 2L, 12L, "c", 13L, 20L, "c", 21L),
+            Arrays.asList("a", 1L, 2L, 12L, "c", 13L, 22L, "c", 23L),
+            Arrays.asList("a", 1L, 2L, 14L, "c", 15L, 16L, "a", 17L),
+            Arrays.asList("a", 1L, 2L, 14L, "c", 15L, 18L, "b", 19L),
+            Arrays.asList("a", 1L, 2L, 14L, "c", 15L, 20L, "c", 21L),
+            Arrays.asList("a", 1L, 2L, 14L, "c", 15L, 22L, "c", 23L),
+            Arrays.asList("b", 3L, 4L, 9L, "a", 10L, 16L, "a", 17L),
+            Arrays.asList("b", 3L, 4L, 9L, "a", 10L, 18L, "b", 19L),
+            Arrays.asList("b", 3L, 4L, 9L, "a", 10L, 20L, "c", 21L),
+            Arrays.asList("b", 3L, 4L, 9L, "a", 10L, 22L, "c", 23L),
+            Arrays.asList("b", 3L, 4L, 11L, "b", 12L, 16L, "a", 17L),
+            Arrays.asList("b", 3L, 4L, 11L, "b", 12L, 18L, "b", 19L),
+            Arrays.asList("b", 3L, 4L, 11L, "b", 12L, 20L, "c", 21L),
+            Arrays.asList("b", 3L, 4L, 11L, "b", 12L, 22L, "c", 23L),
+            Arrays.asList("b", 3L, 4L, 12L, "c", 13L, 16L, "a", 17L),
+            Arrays.asList("b", 3L, 4L, 12L, "c", 13L, 18L, "b", 19L),
+            Arrays.asList("b", 3L, 4L, 12L, "c", 13L, 20L, "c", 21L),
+            Arrays.asList("b", 3L, 4L, 12L, "c", 13L, 22L, "c", 23L),
+            Arrays.asList("b", 3L, 4L, 14L, "c", 15L, 16L, "a", 17L),
+            Arrays.asList("b", 3L, 4L, 14L, "c", 15L, 18L, "b", 19L),
+            Arrays.asList("b", 3L, 4L, 14L, "c", 15L, 20L, "c", 21L),
+            Arrays.asList("b", 3L, 4L, 14L, "c", 15L, 22L, "c", 23L),
+            Arrays.asList("c", 5L, 6L, 9L, "a", 10L, 16L, "a", 17L),
+            Arrays.asList("c", 5L, 6L, 9L, "a", 10L, 18L, "b", 19L),
+            Arrays.asList("c", 5L, 6L, 9L, "a", 10L, 20L, "c", 21L),
+            Arrays.asList("c", 5L, 6L, 9L, "a", 10L, 22L, "c", 23L),
+            Arrays.asList("c", 5L, 6L, 11L, "b", 12L, 16L, "a", 17L),
+            Arrays.asList("c", 5L, 6L, 11L, "b", 12L, 18L, "b", 19L),
+            Arrays.asList("c", 5L, 6L, 11L, "b", 12L, 20L, "c", 21L),
+            Arrays.asList("c", 5L, 6L, 11L, "b", 12L, 22L, "c", 23L),
+            Arrays.asList("c", 5L, 6L, 12L, "c", 13L, 16L, "a", 17L),
+            Arrays.asList("c", 5L, 6L, 12L, "c", 13L, 18L, "b", 19L),
+            Arrays.asList("c", 5L, 6L, 12L, "c", 13L, 20L, "c", 21L),
+            Arrays.asList("c", 5L, 6L, 12L, "c", 13L, 22L, "c", 23L),
+            Arrays.asList("c", 5L, 6L, 14L, "c", 15L, 16L, "a", 17L),
+            Arrays.asList("c", 5L, 6L, 14L, "c", 15L, 18L, "b", 19L),
+            Arrays.asList("c", 5L, 6L, 14L, "c", 15L, 20L, "c", 21L),
+            Arrays.asList("c", 5L, 6L, 14L, "c", 15L, 22L, "c", 23L),
+            Arrays.asList("d", 7L, 8L, 9L, "a", 10L, 16L, "a", 17L),
+            Arrays.asList("d", 7L, 8L, 9L, "a", 10L, 18L, "b", 19L),
+            Arrays.asList("d", 7L, 8L, 9L, "a", 10L, 20L, "c", 21L),
+            Arrays.asList("d", 7L, 8L, 9L, "a", 10L, 22L, "c", 23L),
+            Arrays.asList("d", 7L, 8L, 11L, "b", 12L, 16L, "a", 17L),
+            Arrays.asList("d", 7L, 8L, 11L, "b", 12L, 18L, "b", 19L),
+            Arrays.asList("d", 7L, 8L, 11L, "b", 12L, 20L, "c", 21L),
+            Arrays.asList("d", 7L, 8L, 11L, "b", 12L, 22L, "c", 23L),
+            Arrays.asList("d", 7L, 8L, 12L, "c", 13L, 16L, "a", 17L),
+            Arrays.asList("d", 7L, 8L, 12L, "c", 13L, 18L, "b", 19L),
+            Arrays.asList("d", 7L, 8L, 12L, "c", 13L, 20L, "c", 21L),
+            Arrays.asList("d", 7L, 8L, 12L, "c", 13L, 22L, "c", 23L),
+            Arrays.asList("d", 7L, 8L, 14L, "c", 15L, 16L, "a", 17L),
+            Arrays.asList("d", 7L, 8L, 14L, "c", 15L, 18L, "b", 19L),
+            Arrays.asList("d", 7L, 8L, 14L, "c", 15L, 20L, "c", 21L),
+            Arrays.asList("d", 7L, 8L, 14L, "c", 15L, 22L, "c", 23L));
+
+    assertThat(resultCross.getDataStructure().values())
+        .containsExactly(
+            new Structured.Component("dsOne#name", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("age", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("weight", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("age2", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("ds2#name", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("weight2", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("age3", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("ds3#name", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("weight3", Long.class, Dataset.Role.MEASURE));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/OperatorsTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/OperatorsTest.java
new file mode 100644
index 000000000..bd19e6b6c
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/OperatorsTest.java
@@ -0,0 +1,94 @@
+package fr.insee.vtl.spark.processing.engine;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.spark.samples.DatasetSamples;
+import java.io.IOException;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class OperatorsTest {
+
+  private SparkSession spark;
+  private ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterEach
+  public void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testOperators() throws ScriptException {
+
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", DatasetSamples.ds1, ScriptContext.ENGINE_SCOPE);
+    context.setAttribute("ds2", DatasetSamples.ds2, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := ds1#long1; "
+            + "res1 := isnull(ds1); "
+            + "ds_1 := ds1[keep long1, double1]; ds_2 := ds2[keep long1, double1]; "
+            + "res2 := ds_1 + ds_2; "
+            + "res3 := ds_1 - ds_2; "
+            + "res4 := ds_1 * ds_2; "
+            + "res5 := ds_1 / ds_2; "
+            + "res6 := ds_1 = ds_2; "
+            + "res7 := ds_1 <> ds_2; "
+            + "res8 := ds_1 < ds_2; "
+            + "res9 := ds_1 <= ds_2; "
+            + "res10 := ds_1 > ds_2; "
+            + "res11 := ds_1 >= ds_2; "
+            + "res12 := + ds_1; "
+            + "res13 := - ds_1; "
+            + "res14 := ceil(floor(ln(exp(abs(ds_1))))); "
+            + "res15 := round(ds_1, 5); "
+            + "res16 := trunc(ds_1, 5); "
+            + "res17 := sqrt(abs(ds_1)); "
+            + "res18 := mod(ds_1, 5); "
+            + "res19 := power(ds_1, 5); "
+            + "res20 := log(abs(ds_1), 5); "
+            + "ds_11 := ds1[keep string1, string2]; "
+            + "ds_22 := ds2[keep string1][calc string2 := string1]; "
+            + "res21 := ds_11 || ds_22; ");
+    var res = engine.getContext().getAttribute("res21");
+    assertThat(((Dataset) res).getDataStructure().get("string1").getType()).isEqualTo(String.class);
+  }
+
+  @Test
+  public void testPlan() throws ScriptException {
+    engine.getContext().setAttribute("ds_1", DatasetSamples.ds1, ScriptContext.ENGINE_SCOPE);
+    engine.getContext().setAttribute("ds_2", DatasetSamples.ds2, ScriptContext.ENGINE_SCOPE);
+    engine.eval(
+        "ds1 := ds_1[keep long1][rename long1 to bool_var]; "
+            + "ds2 := ds_2[keep long1][rename long1 to bool_var]; "
+            + "res := if ds1 > ds2 then ds1 else ds2;");
+    var res = engine.getContext().getAttribute("res");
+    assertThat(((Dataset) res).getDataAsMap())
+        .containsExactlyInAnyOrder(
+            Map.of("id", "Hadrien", "bool_var", 150L),
+            Map.of("id", "Nico", "bool_var", 20L),
+            Map.of("id", "Franck", "bool_var", 100L));
+    assertThat(((Dataset) res).getDataStructure().get("bool_var").getType()).isEqualTo(Long.class);
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/PivotTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/PivotTest.java
new file mode 100644
index 000000000..e84d95d38
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/PivotTest.java
@@ -0,0 +1,108 @@
+package fr.insee.vtl.spark.processing.engine;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import fr.insee.vtl.model.Structured;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class PivotTest {
+
+  private SparkSession spark;
+  private ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterEach
+  public void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testPivot() throws ScriptException {
+
+    var dataset =
+        new InMemoryDataset(
+            List.of(
+                List.of(1L, "A", 5L, "E"),
+                List.of(1L, "B", 2L, "F"),
+                List.of(1L, "C", 7L, "F"),
+                List.of(2L, "A", 3L, "E"),
+                List.of(2L, "B", 4L, "E"),
+                List.of(2L, "C", 9L, "F")),
+            List.of(
+                new Structured.Component("Id_1", Long.class, Dataset.Role.IDENTIFIER),
+                new Structured.Component("Id_2", String.class, Dataset.Role.IDENTIFIER),
+                new Structured.Component("Me_1", Long.class, Dataset.Role.MEASURE),
+                new Structured.Component("At_1", String.class, Dataset.Role.ATTRIBUTE)));
+
+    var dataset2 =
+        new InMemoryDataset(
+            List.of(
+                List.of(1L, 1L, 5L, "E"),
+                List.of(1L, 2L, 2L, "F"),
+                List.of(1L, 3L, 7L, "F"),
+                List.of(2L, 1L, 3L, "E"),
+                List.of(2L, 2L, 4L, "E"),
+                List.of(2L, 3L, 9L, "F")),
+            List.of(
+                new Structured.Component("Id_1", Long.class, Dataset.Role.IDENTIFIER),
+                new Structured.Component("Id_2", Long.class, Dataset.Role.IDENTIFIER),
+                new Structured.Component("Me_1", Long.class, Dataset.Role.MEASURE),
+                new Structured.Component("At_1", String.class, Dataset.Role.ATTRIBUTE)));
+
+    ScriptContext context = engine.getContext();
+    context.getBindings(ScriptContext.ENGINE_SCOPE).put("Ds_1", dataset);
+    context.getBindings(ScriptContext.ENGINE_SCOPE).put("Ds_2", dataset2);
+
+    engine.eval("DS_r := Ds_1 [ pivot Id_2, Me_1 ];" + "DS_r2 := Ds_2 [ pivot Id_2, Me_1 ];");
+
+    var result = (Dataset) context.getAttribute("DS_r");
+    assertThat(result.getDataAsList())
+        .containsExactlyInAnyOrder(Arrays.asList(1L, 5L, 2L, 7L), Arrays.asList(2L, 3L, 4L, 9L));
+
+    var result2 = (Dataset) context.getAttribute("DS_r2");
+    assertThat(result2.getDataAsList())
+        .containsExactlyInAnyOrder(Arrays.asList(1L, 5L, 2L, 7L), Arrays.asList(2L, 3L, 4L, 9L));
+
+    Exception exception =
+        assertThrows(
+            fr.insee.vtl.engine.exceptions.InvalidArgumentException.class,
+            () -> engine.eval("DS_id_issue := Ds_1 [ pivot bad, Me_1 ];"));
+    String expectedMessage = "bad is not part of the dataset identifiers";
+    String actualMessage = exception.getMessage();
+    assertTrue(actualMessage.contains(expectedMessage));
+
+    Exception exceptionMe =
+        assertThrows(
+            fr.insee.vtl.engine.exceptions.InvalidArgumentException.class,
+            () -> engine.eval("DS_id_issue := Ds_1 [ pivot Id_2, bad ];"));
+    String expectedMessageMe = "bad is not part of the dataset measures";
+    String actualMessageMe = exceptionMe.getMessage();
+    assertTrue(actualMessageMe.contains(expectedMessageMe));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/ProjectTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/ProjectTest.java
new file mode 100644
index 000000000..29dcb9e10
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/ProjectTest.java
@@ -0,0 +1,89 @@
+package fr.insee.vtl.spark.processing.engine;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import fr.insee.vtl.model.Structured;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class ProjectTest {
+
+  private final InMemoryDataset dataset =
+      new InMemoryDataset(
+          List.of(
+              Map.of("name", "Hadrien", "age", 10L, "weight", 11L),
+              Map.of("name", "Nico", "age", 11L, "weight", 10L),
+              Map.of("name", "Franck", "age", 12L, "weight", 9L)),
+          Map.of("name", String.class, "age", Long.class, "weight", Long.class),
+          Map.of(
+              "name",
+              Dataset.Role.IDENTIFIER,
+              "age",
+              Dataset.Role.MEASURE,
+              "weight",
+              Dataset.Role.MEASURE));
+  private SparkSession spark;
+  private ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterEach
+  public void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testProjection() throws ScriptException {
+
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds", dataset, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("ds1 := ds[keep age];");
+
+    assertThat(engine.getContext().getAttribute("ds"))
+        .isInstanceOf(fr.insee.vtl.model.Dataset.class);
+    assertThat(
+            ((fr.insee.vtl.model.Dataset) engine.getContext().getAttribute("ds1")).getDataAsMap())
+        .containsExactly(
+            Map.of("name", "Hadrien", "age", 10L),
+            Map.of("name", "Nico", "age", 11L),
+            Map.of("name", "Franck", "age", 12L));
+
+    engine.eval("ds2 := ds[drop weight];");
+
+    assertThat(engine.getContext().getAttribute("ds2"))
+        .isInstanceOf(fr.insee.vtl.model.Dataset.class);
+    var ds = (Dataset) engine.getContext().getAttribute("ds2");
+    assertThat(ds.getDataAsMap())
+        .containsExactly(
+            Map.of("name", "Hadrien", "age", 10L),
+            Map.of("name", "Nico", "age", 11L),
+            Map.of("name", "Franck", "age", 12L));
+    assertThat(ds.getDataStructure())
+        .containsValues(
+            new Structured.Component("name", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("age", Long.class, Dataset.Role.MEASURE));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/RenameTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/RenameTest.java
new file mode 100644
index 000000000..531380a6f
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/RenameTest.java
@@ -0,0 +1,78 @@
+package fr.insee.vtl.spark.processing.engine;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import fr.insee.vtl.model.Structured;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class RenameTest {
+
+  private final InMemoryDataset dataset =
+      new InMemoryDataset(
+          List.of(
+              Map.of("name", "Hadrien", "age", 10L, "weight", 11L),
+              Map.of("name", "Nico", "age", 11L, "weight", 10L),
+              Map.of("name", "Franck", "age", 12L, "weight", 9L)),
+          Map.of("name", String.class, "age", Long.class, "weight", Long.class),
+          Map.of(
+              "name",
+              Dataset.Role.IDENTIFIER,
+              "age",
+              Dataset.Role.MEASURE,
+              "weight",
+              Dataset.Role.MEASURE));
+  private SparkSession spark;
+  private ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterEach
+  public void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testRename() throws ScriptException {
+
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", dataset, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("ds := ds1[rename age to weight, weight to age, name to pseudo];");
+
+    assertThat(engine.getContext().getAttribute("ds")).isInstanceOf(Dataset.class);
+    var ds = (Dataset) engine.getContext().getAttribute("ds");
+    assertThat(ds.getDataAsMap())
+        .containsExactlyInAnyOrder(
+            Map.of("pseudo", "Hadrien", "weight", 10L, "age", 11L),
+            Map.of("pseudo", "Nico", "weight", 11L, "age", 10L),
+            Map.of("pseudo", "Franck", "weight", 12L, "age", 9L));
+    assertThat(ds.getDataStructure())
+        .containsValues(
+            new Structured.Component("pseudo", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("age", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("weight", Long.class, Dataset.Role.MEASURE));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/ServiceLoaderTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/ServiceLoaderTest.java
new file mode 100644
index 000000000..05083e92e
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/ServiceLoaderTest.java
@@ -0,0 +1,22 @@
+package fr.insee.vtl.spark.processing.engine;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.model.ProcessingEngineFactory;
+import java.util.List;
+import java.util.ServiceLoader;
+import java.util.stream.Collectors;
+import org.junit.jupiter.api.Test;
+
+public class ServiceLoaderTest {
+
+  @Test
+  public void testServiceLoader() {
+    List<String> processingEngines =
+        ServiceLoader.load(ProcessingEngineFactory.class).stream()
+            .map(ServiceLoader.Provider::get)
+            .map(ProcessingEngineFactory::getName)
+            .collect(Collectors.toList());
+    assertThat(processingEngines).containsExactlyInAnyOrder("memory", "spark4");
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/UnionTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/UnionTest.java
new file mode 100644
index 000000000..5ea92a9c0
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/UnionTest.java
@@ -0,0 +1,477 @@
+package fr.insee.vtl.spark.processing.engine;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import fr.insee.vtl.model.Structured;
+import fr.insee.vtl.spark.SparkDataset;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class UnionTest {
+
+  private final InMemoryDataset unionDS1 =
+      new InMemoryDataset(
+          List.of(
+              Map.of("Id_1", "2012", "Id_2", "B", "Id_3", "Total", "Id_4", "Total", "Me_1", 5L),
+              Map.of("Id_1", "2012", "Id_2", "G", "Id_3", "Total", "Id_4", "Total", "Me_1", 2L),
+              Map.of("Id_1", "2012", "Id_2", "F", "Id_3", "Total", "Id_4", "Total", "Me_1", 3L)),
+          Map.of(
+              "Id_1",
+              String.class,
+              "Id_2",
+              String.class,
+              "Id_3",
+              String.class,
+              "Id_4",
+              String.class,
+              "Me_1",
+              Long.class),
+          Map.of(
+              "Id_1",
+              Dataset.Role.IDENTIFIER,
+              "Id_2",
+              Dataset.Role.IDENTIFIER,
+              "Id_3",
+              Dataset.Role.IDENTIFIER,
+              "Id_4",
+              Dataset.Role.IDENTIFIER,
+              "Me_1",
+              Dataset.Role.MEASURE));
+  private final InMemoryDataset unionDS2 =
+      new InMemoryDataset(
+          List.of(
+              Map.of("Id_1", "2012", "Id_2", "N", "Id_3", "Total", "Id_4", "Total", "Me_1", 23L),
+              Map.of("Id_1", "2012", "Id_2", "S", "Id_3", "Total", "Id_4", "Total", "Me_1", 5L)),
+          Map.of(
+              "Id_1",
+              String.class,
+              "Id_2",
+              String.class,
+              "Id_3",
+              String.class,
+              "Id_4",
+              String.class,
+              "Me_1",
+              Long.class),
+          Map.of(
+              "Id_1",
+              Dataset.Role.IDENTIFIER,
+              "Id_2",
+              Dataset.Role.IDENTIFIER,
+              "Id_3",
+              Dataset.Role.IDENTIFIER,
+              "Id_4",
+              Dataset.Role.IDENTIFIER,
+              "Me_1",
+              Dataset.Role.MEASURE));
+  private final InMemoryDataset unionDS3 =
+      new InMemoryDataset(
+          List.of(
+              Map.of("Id_1", "2012", "Id_2", "L", "Id_3", "Total", "Id_4", "Total", "Me_1", 5L),
+              Map.of("Id_1", "2012", "Id_2", "M", "Id_3", "Total", "Id_4", "Total", "Me_1", 2L),
+              Map.of("Id_1", "2012", "Id_2", "X", "Id_3", "Total", "Id_4", "Total", "Me_1", 3L)),
+          Map.of(
+              "Id_1",
+              String.class,
+              "Id_2",
+              String.class,
+              "Id_3",
+              String.class,
+              "Id_4",
+              String.class,
+              "Me_1",
+              Long.class),
+          Map.of(
+              "Id_1",
+              Dataset.Role.IDENTIFIER,
+              "Id_2",
+              Dataset.Role.IDENTIFIER,
+              "Id_3",
+              Dataset.Role.IDENTIFIER,
+              "Id_4",
+              Dataset.Role.IDENTIFIER,
+              "Me_1",
+              Dataset.Role.MEASURE));
+  private final InMemoryDataset unionDS4 =
+      new InMemoryDataset(
+          List.of(
+              Map.of("Id_1", "2012", "Id_2", "N", "Id_3", "Total", "Id_4", "Total", "Me_1", 5L),
+              Map.of("Id_1", "2012", "Id_2", "S", "Id_3", "Total", "Id_4", "Total", "Me_1", 2L),
+              Map.of("Id_1", "2012", "Id_2", "X", "Id_3", "Total", "Id_4", "Total", "Me_1", 3L)),
+          Map.of(
+              "Id_1",
+              String.class,
+              "Id_2",
+              String.class,
+              "Id_3",
+              String.class,
+              "Id_4",
+              String.class,
+              "Me_1",
+              Long.class),
+          Map.of(
+              "Id_1",
+              Dataset.Role.IDENTIFIER,
+              "Id_2",
+              Dataset.Role.IDENTIFIER,
+              "Id_3",
+              Dataset.Role.IDENTIFIER,
+              "Id_4",
+              Dataset.Role.IDENTIFIER,
+              "Me_1",
+              Dataset.Role.MEASURE));
+  private final InMemoryDataset unionDS5 =
+      new InMemoryDataset(
+          List.of(
+              Map.of("Id_1", "2012", "Id_2", "N", "Id_3", "Total", "Me_1", 5L),
+              Map.of("Id_1", "2012", "Id_2", "S", "Id_3", "Total", "Me_1", 2L),
+              Map.of("Id_1", "2012", "Id_2", "X", "Id_3", "Total", "Me_1", 3L)),
+          Map.of(
+              "Id_1", String.class, "Id_2", String.class, "Id_3", String.class, "Me_1", Long.class),
+          Map.of(
+              "Id_1",
+              Dataset.Role.IDENTIFIER,
+              "Id_2",
+              Dataset.Role.IDENTIFIER,
+              "Id_3",
+              Dataset.Role.IDENTIFIER,
+              "Me_1",
+              Dataset.Role.MEASURE));
+  private final String DEFAULT_NULL_STR = "null";
+  private SparkSession spark;
+  private ScriptEngine engine;
+
+  private static <T, K> Map<K, T> replaceNullValues(Map<K, T> map, T defaultValue) {
+
+    // Replace the null value
+    map =
+        map.entrySet().stream()
+            .map(
+                entry -> {
+                  if (entry.getValue() == null) entry.setValue(defaultValue);
+                  return entry;
+                })
+            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+    return map;
+  }
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterEach
+  public void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testDataStructureAfterUnion() throws ScriptException {
+    // Union Test case 1 : After union, the result should have the same data structure as the input
+    // dataframe
+    /* Input dataset ds1 and ds2 has below data structure
+    Component{Id_1, type=class java.lang.String, role=IDENTIFIER}
+    Component{Id_2, type=class java.lang.String, role=IDENTIFIER}
+    Component{Id_3, type=class java.lang.String, role=IDENTIFIER}
+    Component{Id_4, type=class java.lang.String, role=IDENTIFIER}
+    Component{Me_1, type=class java.lang.Long, role=MEASURE}
+     * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", unionDS1, ScriptContext.ENGINE_SCOPE);
+    context.setAttribute("ds2", unionDS2, ScriptContext.ENGINE_SCOPE);
+    engine.eval("res := union (ds1, ds2);");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+     * the result df should have the same data structure
+     * */
+
+    Collection<Structured.Component> actualStructure =
+        ((SparkDataset) engine.getContext().getAttribute("res")).getDataStructure().values();
+
+    assertThat(actualStructure)
+        .containsExactlyInAnyOrder(
+            new Structured.Component("Id_1", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("Id_2", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("Id_3", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("Id_4", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("Me_1", Long.class, Dataset.Role.MEASURE));
+  }
+
+  @Test
+  public void testUnionTwoWithoutDup() throws ScriptException {
+    // Union Test case 1 : union on two df without duplicate
+    /* Input dataset ds1
+    +----+----+-----+-----+----+
+    |Id_1|Id_2| Id_3| Id_4|Me_1|
+    +----+----+-----+-----+----+
+    |2012|   B|Total|Total|   5|
+    |2012|   G|Total|Total|   2|
+    |2012|   F|Total|Total|   3|
+    +----+----+-----+-----+----+
+
+    ****************************
+    * Input dataset ds2
+    +----+----+-----+-----+----+
+    |Id_1|Id_2| Id_3| Id_4|Me_1|
+    +----+----+-----+-----+----+
+    |2012|   N|Total|Total|  23|
+    |2012|   S|Total|Total|   5|
+    +----+----+-----+-----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", unionDS1, ScriptContext.ENGINE_SCOPE);
+    context.setAttribute("ds2", unionDS2, ScriptContext.ENGINE_SCOPE);
+    engine.eval("res := union (ds1, ds2);");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * result df
+    +----+----+-----+-----+----+
+    |Id_1|Id_2| Id_3| Id_4|Me_1|
+    +----+----+-----+-----+----+
+    |2012|   B|Total|Total|   5|
+    |2012|   G|Total|Total|   2|
+    |2012|   F|Total|Total|   3|
+    |2012|   N|Total|Total|  23|
+    |2012|   S|Total|Total|   5|
+    +----+----+-----+-----+----+
+    * */
+
+    List<Map<String, Object>> actualWithNull =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    List<Map<String, Object>> actual = new ArrayList<>();
+    for (Map<String, Object> map : actualWithNull) {
+      actual.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+    List<Map<String, Object>> expected =
+        List.of(
+            Map.of("Id_1", "2012", "Id_2", "B", "Id_3", "Total", "Id_4", "Total", "Me_1", 5L),
+            Map.of("Id_1", "2012", "Id_2", "G", "Id_3", "Total", "Id_4", "Total", "Me_1", 2L),
+            Map.of("Id_1", "2012", "Id_2", "F", "Id_3", "Total", "Id_4", "Total", "Me_1", 3L),
+            Map.of("Id_1", "2012", "Id_2", "N", "Id_3", "Total", "Id_4", "Total", "Me_1", 23L),
+            Map.of("Id_1", "2012", "Id_2", "S", "Id_3", "Total", "Id_4", "Total", "Me_1", 5L));
+    assertEquals(new HashSet<>(actual), new HashSet<>(expected));
+  }
+
+  @Test
+  public void testUnionThreeWithoutDup() throws ScriptException {
+    // Union Test case 2 : union on three df without duplicate
+    /* Input dataset ds1
+    +----+----+-----+-----+----+
+    |Id_1|Id_2| Id_3| Id_4|Me_1|
+    +----+----+-----+-----+----+
+    |2012|   B|Total|Total|   5|
+    |2012|   G|Total|Total|   2|
+    |2012|   F|Total|Total|   3|
+    +----+----+-----+-----+----+
+
+    ****************************
+    * Input dataset ds2
+    +----+----+-----+-----+----+
+    |Id_1|Id_2| Id_3| Id_4|Me_1|
+    +----+----+-----+-----+----+
+    |2012|   N|Total|Total|  23|
+    |2012|   S|Total|Total|   5|
+    +----+----+-----+-----+----+
+
+    **************************
+    * Input dataset ds3
+    +----+----+-----+-----+----+
+    |Id_1|Id_2| Id_3| Id_4|Me_1|
+    +----+----+-----+-----+----+
+    |2012|   L|Total|Total|   5|
+    |2012|   M|Total|Total|   2|
+    |2012|   X|Total|Total|   3|
+    +----+----+-----+-----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", unionDS1, ScriptContext.ENGINE_SCOPE);
+    context.setAttribute("ds2", unionDS2, ScriptContext.ENGINE_SCOPE);
+    context.setAttribute("ds3", unionDS3, ScriptContext.ENGINE_SCOPE);
+    engine.eval("res := union (ds1, ds2, ds3);");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * result df
+    +----+----+-----+-----+----+
+    |Id_1|Id_2| Id_3| Id_4|Me_1|
+    +----+----+-----+-----+----+
+    |2012|   B|Total|Total|   5|
+    |2012|   G|Total|Total|   2|
+    |2012|   F|Total|Total|   3|
+    |2012|   N|Total|Total|  23|
+    |2012|   S|Total|Total|   5|
+    +----+----+-----+-----+----+
+    * */
+
+    List<Map<String, Object>> actualWithNull =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    List<Map<String, Object>> actual = new ArrayList<>();
+    for (Map<String, Object> map : actualWithNull) {
+      actual.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+    List<Map<String, Object>> expected =
+        List.of(
+            Map.of("Id_1", "2012", "Id_2", "B", "Id_3", "Total", "Id_4", "Total", "Me_1", 5L),
+            Map.of("Id_1", "2012", "Id_2", "G", "Id_3", "Total", "Id_4", "Total", "Me_1", 2L),
+            Map.of("Id_1", "2012", "Id_2", "F", "Id_3", "Total", "Id_4", "Total", "Me_1", 3L),
+            Map.of("Id_1", "2012", "Id_2", "S", "Id_3", "Total", "Id_4", "Total", "Me_1", 5L),
+            Map.of("Id_1", "2012", "Id_2", "N", "Id_3", "Total", "Id_4", "Total", "Me_1", 23L),
+            Map.of("Id_1", "2012", "Id_2", "X", "Id_3", "Total", "Id_4", "Total", "Me_1", 3L),
+            Map.of("Id_1", "2012", "Id_2", "M", "Id_3", "Total", "Id_4", "Total", "Me_1", 2L),
+            Map.of("Id_1", "2012", "Id_2", "L", "Id_3", "Total", "Id_4", "Total", "Me_1", 5L));
+    assertEquals(new HashSet<>(actual), new HashSet<>(expected));
+  }
+
+  @Test
+  public void testUnionThreeWithDup() throws ScriptException {
+    // Union Test case 3 : union on three df with duplicate, note for the duplicated rows, the first
+    // appeared row
+    // are kept, the rest all dropped
+    /* Input dataset ds1
+    +----+----+-----+-----+----+
+    |Id_1|Id_2| Id_3| Id_4|Me_1|
+    +----+----+-----+-----+----+
+    |2012|   B|Total|Total|   5|
+    |2012|   G|Total|Total|   2|
+    |2012|   F|Total|Total|   3|
+    +----+----+-----+-----+----+
+
+    ****************************
+    * Input dataset ds2
+    +----+----+-----+-----+----+
+    |Id_1|Id_2| Id_3| Id_4|Me_1|
+    +----+----+-----+-----+----+
+    |2012|   N|Total|Total|  23|
+    |2012|   S|Total|Total|   5|
+    +----+----+-----+-----+----+
+
+    **************************
+    * Input dataset ds4
+    +----+----+-----+-----+----+
+    |Id_1|Id_2| Id_3| Id_4|Me_1|
+    +----+----+-----+-----+----+
+    |2012|   N|Total|Total|   5|
+    |2012|   S|Total|Total|   2|
+    |2012|   X|Total|Total|   3|
+    +----+----+-----+-----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", unionDS1, ScriptContext.ENGINE_SCOPE);
+    context.setAttribute("ds2", unionDS2, ScriptContext.ENGINE_SCOPE);
+    context.setAttribute("ds4", unionDS4, ScriptContext.ENGINE_SCOPE);
+    engine.eval("res := union (ds1, ds2, ds4);");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * result df
+    +----+----+-----+-----+----+
+    |Id_1|Id_2| Id_3| Id_4|Me_1|
+    +----+----+-----+-----+----+
+    |2012|   F|Total|Total|   3|
+    |2012|   B|Total|Total|   5|
+    |2012|   G|Total|Total|   2|
+    |2012|   N|Total|Total|  23|
+    |2012|   S|Total|Total|   5|
+    |2012|   X|Total|Total|   3|
+    +----+----+-----+-----+----+
+    * */
+
+    List<Map<String, Object>> actualWithNull =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    List<Map<String, Object>> actual = new ArrayList<>();
+    for (Map<String, Object> map : actualWithNull) {
+      actual.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+    List<Map<String, Object>> expected =
+        List.of(
+            Map.of("Id_1", "2012", "Id_2", "G", "Id_3", "Total", "Id_4", "Total", "Me_1", 2L),
+            Map.of("Id_1", "2012", "Id_2", "F", "Id_3", "Total", "Id_4", "Total", "Me_1", 3L),
+            Map.of("Id_1", "2012", "Id_2", "B", "Id_3", "Total", "Id_4", "Total", "Me_1", 5L),
+            Map.of("Id_1", "2012", "Id_2", "S", "Id_3", "Total", "Id_4", "Total", "Me_1", 5L),
+            Map.of("Id_1", "2012", "Id_2", "N", "Id_3", "Total", "Id_4", "Total", "Me_1", 23L),
+            Map.of("Id_1", "2012", "Id_2", "X", "Id_3", "Total", "Id_4", "Total", "Me_1", 3L));
+    assertEquals(new HashSet<>(actual), new HashSet<>(expected));
+  }
+
+  @Test
+  public void testUnionIncompatibleSchema() throws ScriptException {
+    // Union Test case 4 : union on three df with incompatible schema, should throw exception
+    // here we assert if the right exception is thrown.
+    /* Input dataset ds1
+    +----+----+-----+-----+----+
+    |Id_1|Id_2| Id_3| Id_4|Me_1|
+    +----+----+-----+-----+----+
+    |2012|   B|Total|Total|   5|
+    |2012|   G|Total|Total|   2|
+    |2012|   F|Total|Total|   3|
+    +----+----+-----+-----+----+
+
+    ****************************
+    * Input dataset ds2
+    +----+----+-----+-----+----+
+    |Id_1|Id_2| Id_3| Id_4|Me_1|
+    +----+----+-----+-----+----+
+    |2012|   N|Total|Total|  23|
+    |2012|   S|Total|Total|   5|
+    +----+----+-----+-----+----+
+
+    **************************
+    * Input dataset ds5
+    +----+----+-----+----+
+    |Id_1|Id_2| Id_3|Me_1|
+    +----+----+-----+----+
+    |2012|   N|Total|   5|
+    |2012|   S|Total|   2|
+    |2012|   X|Total|   3|
+    +----+----+-----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", unionDS1, ScriptContext.ENGINE_SCOPE);
+    context.setAttribute("ds2", unionDS2, ScriptContext.ENGINE_SCOPE);
+    context.setAttribute("ds5", unionDS5, ScriptContext.ENGINE_SCOPE);
+
+    // engine.getContext().getAttribute("res");
+    Exception exception =
+        assertThrows(
+            fr.insee.vtl.engine.exceptions.InvalidArgumentException.class,
+            () -> {
+              engine.eval("res := union ( ds1, ds2, ds5 ) ;");
+            });
+    String expectedMessage = "dataset structure of ds5 is incompatible";
+    String actualMessage = exception.getMessage();
+    System.out.println(actualMessage);
+    assertTrue(actualMessage.contains(expectedMessage));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/ValidationTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/ValidationTest.java
new file mode 100644
index 000000000..9f0ea2d5e
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/ValidationTest.java
@@ -0,0 +1,2042 @@
+package fr.insee.vtl.spark.processing.engine;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import fr.insee.vtl.model.Structured;
+import fr.insee.vtl.spark.SparkDataset;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import javax.script.*;
+import org.apache.spark.sql.Row;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class ValidationTest {
+
+  private final String DEFAULT_NULL_STR = "null";
+  private final InMemoryDataset dataset =
+      new InMemoryDataset(
+          List.of(
+              List.of("2011", "I", "CREDIT", 10L),
+              List.of("2011", "I", "DEBIT", -2L),
+              List.of("2012", "I", "CREDIT", 10L),
+              List.of("2012", "I", "DEBIT", 2L)),
+          List.of(
+              new Structured.Component("Id_1", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("Id_2", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component(
+                  "Id_3", String.class, Dataset.Role.IDENTIFIER, null, "vd_id_3"),
+              new Structured.Component("Me_1", Long.class, Dataset.Role.MEASURE, null, "vd_me_1")));
+  private final InMemoryDataset ds_1_check =
+      new InMemoryDataset(
+          List.of(
+              List.of("2010", "I", 1L),
+              List.of("2011", "I", 2L),
+              List.of("2012", "I", 10L),
+              List.of("2013", "I", 4L),
+              List.of("2014", "I", 5L),
+              List.of("2015", "I", 6L),
+              List.of("2010", "D", 25L),
+              List.of("2011", "D", 35L),
+              List.of("2012", "D", 45L),
+              List.of("2013", "D", 55L),
+              List.of("2014", "D", 50L),
+              List.of("2015", "D", 75L)),
+          List.of(
+              new Structured.Component("Id_1", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("Id_2", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("Me_1", Long.class, Dataset.Role.MEASURE)));
+  private final InMemoryDataset ds_2_check =
+      new InMemoryDataset(
+          List.of(
+              List.of("2010", "I", 9L),
+              List.of("2011", "I", 2L),
+              List.of("2012", "I", 10L),
+              List.of("2013", "I", 7L),
+              List.of("2014", "I", 5L),
+              List.of("2015", "I", 6L),
+              List.of("2010", "D", 50L),
+              List.of("2011", "D", 35L),
+              List.of("2012", "D", 40L),
+              List.of("2013", "D", 55L),
+              List.of("2014", "D", 65L),
+              List.of("2015", "D", 75L)),
+          List.of(
+              new Structured.Component("Id_1", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("Id_2", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("Me_1", Long.class, Dataset.Role.MEASURE)));
+  private final Dataset dsExpr =
+      new InMemoryDataset(
+          List.of(
+              List.of("2011", "I", "CREDIT", true),
+              List.of("2011", "I", "DEBIT", false),
+              List.of("2012", "I", "CREDIT", false),
+              List.of("2012", "I", "DEBIT", true)),
+          List.of(
+              new Structured.Component("Id_1", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("Id_2", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("Id_3", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("bool_var", Boolean.class, Dataset.Role.MEASURE)));
+  private final Dataset dsImbalance =
+      new InMemoryDataset(
+          List.of(
+              List.of("2011", "I", "CREDIT", 1L),
+              List.of("2011", "I", "DEBIT", 2L),
+              List.of("2012", "I", "CREDIT", 2L),
+              List.of("2012", "I", "DEBIT", 3L)),
+          List.of(
+              new Structured.Component("Id_1", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("Id_2", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("Id_3", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("imbalance", Long.class, Dataset.Role.MEASURE)));
+  private final Dataset dsImbalanceToRename =
+      new InMemoryDataset(
+          List.of(
+              List.of("2011", "I", "CREDIT", 1L),
+              List.of("2011", "I", "DEBIT", 2L),
+              List.of("2012", "I", "CREDIT", 2L),
+              List.of("2012", "I", "DEBIT", 3L)),
+          List.of(
+              new Structured.Component("Id_1", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("Id_2", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("Id_3", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("imbalance_1", Long.class, Dataset.Role.MEASURE)));
+  private final String hierarchicalRulesetDef =
+      """
+                    define hierarchical ruleset HR_1 (variable rule Me_1) is\s
+                    R010 : A = J + K + L errorlevel 5;
+                    R020 : B = M + N + O errorlevel 5;
+                    R030 : C = P + Q errorcode "XX" errorlevel 5;
+                    R040 : D = R + S errorlevel 1;
+                    R050 : E = T + U + V errorlevel 0;
+                    R060 : F = Y + W + Z errorlevel 7;
+                    R070 : G = B + C;
+                    R080 : H = D + E errorlevel 0;
+                    R090 : I = D + G errorcode "YY" errorlevel 0;
+                    R100 : M >= N errorlevel 5;
+                    R110 : M <= G errorlevel 5
+                    end hierarchical ruleset;\s
+                    """;
+  private final Dataset DS_1_HR =
+      new InMemoryDataset(
+          List.of(
+              List.of("2010", "A", 5L),
+              List.of("2010", "B", 11L),
+              List.of("2010", "C", 0L),
+              List.of("2010", "G", 19L),
+              Stream.of("2010", "H", null).collect(Collectors.toList()),
+              List.of("2010", "I", 14L),
+              List.of("2010", "M", 2L),
+              List.of("2010", "N", 5L),
+              List.of("2010", "O", 4L),
+              List.of("2010", "P", 7L),
+              List.of("2010", "Q", -7L),
+              List.of("2010", "S", 3L),
+              List.of("2010", "T", 9L),
+              Stream.of("2010", "U", null).collect(Collectors.toList()),
+              List.of("2010", "V", 6L)),
+          List.of(
+              new Structured.Component("Id_1", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("Id_2", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("Me_1", Long.class, Dataset.Role.MEASURE)));
+  private static SparkSession spark;
+  private ScriptEngine engine;
+
+  private static <T, K> Map<K, T> replaceNullValues(Map<K, T> map, T defaultValue) {
+
+    // Replace the null value
+    map =
+        map.entrySet().stream()
+            .map(
+                entry -> {
+                  if (entry.getValue() == null) entry.setValue(defaultValue);
+                  return entry;
+                })
+            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+    return map;
+  }
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterAll
+  public static void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testValidateDPruleset() throws ScriptException {
+
+    ScriptContext context = engine.getContext();
+    context.setAttribute("DS_1", dataset, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "define datapoint ruleset dpr1 (variable Id_3, Me_1) is "
+            + "ruleA : when Id_3 = \"CREDIT\" then Me_1 >= 0 errorcode \"Bad credit\"; "
+            + "when Id_3 = \"DEBIT\" then Me_1 >= 0 errorcode \"Bad debit\" errorlevel 1 "
+            + "end datapoint ruleset; "
+            + "DS_r := check_datapoint(DS_1, dpr1); "
+            + "DS_r_invalid := check_datapoint(DS_1, dpr1 invalid); "
+            + "DS_r_all := check_datapoint(DS_1, dpr1 all); "
+            + "DS_r_all_measures := check_datapoint(DS_1, dpr1 all_measures);");
+
+    Dataset DS_r = (Dataset) engine.getContext().getAttribute("DS_r");
+    assertThat(DS_r).isInstanceOf(Dataset.class);
+    Dataset DS_r_invalid = (Dataset) engine.getContext().getAttribute("DS_r_invalid");
+    assertThat(DS_r_invalid).isInstanceOf(Dataset.class);
+    Dataset DS_r_all = (Dataset) engine.getContext().getAttribute("DS_r_all");
+    assertThat(DS_r).isInstanceOf(Dataset.class);
+    Dataset DS_r_all_measures = (Dataset) engine.getContext().getAttribute("DS_r_all_measures");
+    assertThat(DS_r_all_measures).isInstanceOf(Dataset.class);
+
+    List<Map<String, Object>> DS_rWithNull = DS_r.getDataAsMap();
+    List<Map<String, Object>> DS_r_invalidWithNull = DS_r_invalid.getDataAsMap();
+    List<Map<String, Object>> DS_r_allWithNull = DS_r_all.getDataAsMap();
+    List<Map<String, Object>> DS_r_all_measuresWithNull = DS_r_all_measures.getDataAsMap();
+
+    List<Map<String, Object>> DS_rWithoutNull = new ArrayList<>();
+    for (Map<String, Object> map : DS_rWithNull) {
+      DS_rWithoutNull.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+    List<Map<String, Object>> DS_r_invalidWithoutNull = new ArrayList<>();
+    for (Map<String, Object> map : DS_r_invalidWithNull) {
+      DS_r_invalidWithoutNull.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+    List<Map<String, Object>> DS_r_allWithoutNull = new ArrayList<>();
+    for (Map<String, Object> map : DS_r_allWithNull) {
+      DS_r_allWithoutNull.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+    List<Map<String, Object>> DS_r_all_measuresWithoutNull = new ArrayList<>();
+    for (Map<String, Object> map : DS_r_all_measuresWithNull) {
+      DS_r_all_measuresWithoutNull.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+
+    assertThat(DS_rWithoutNull)
+        .containsExactlyInAnyOrder(
+            Map.of(
+                "Id_1",
+                "2011",
+                "Id_2",
+                "I",
+                "Id_3",
+                "DEBIT",
+                "Me_1",
+                -2L,
+                "ruleid",
+                "dpr1_2",
+                "errorcode",
+                "Bad debit",
+                "errorlevel",
+                1L))
+        .containsExactlyInAnyOrderElementsOf(DS_r_invalidWithoutNull);
+
+    assertThat(DS_r_allWithoutNull)
+        .containsExactlyInAnyOrder(
+            Map.of(
+                "Id_1",
+                "2011",
+                "Id_2",
+                "I",
+                "Id_3",
+                "CREDIT",
+                "Me_1",
+                10L,
+                "ruleid",
+                "ruleA",
+                "bool_var",
+                true,
+                "errorcode",
+                "null",
+                "errorlevel",
+                "null"),
+            Map.of(
+                "Id_1",
+                "2011",
+                "Id_2",
+                "I",
+                "Id_3",
+                "CREDIT",
+                "Me_1",
+                10L,
+                "ruleid",
+                "dpr1_2",
+                "bool_var",
+                true,
+                "errorcode",
+                "null",
+                "errorlevel",
+                "null"),
+            Map.of(
+                "Id_1",
+                "2011",
+                "Id_2",
+                "I",
+                "Id_3",
+                "DEBIT",
+                "Me_1",
+                -2L,
+                "ruleid",
+                "ruleA",
+                "bool_var",
+                true,
+                "errorcode",
+                "null",
+                "errorlevel",
+                "null"),
+            Map.of(
+                "Id_1",
+                "2011",
+                "Id_2",
+                "I",
+                "Id_3",
+                "DEBIT",
+                "Me_1",
+                -2L,
+                "ruleid",
+                "dpr1_2",
+                "bool_var",
+                false,
+                "errorcode",
+                "Bad debit",
+                "errorlevel",
+                1L),
+            Map.of(
+                "Id_1",
+                "2012",
+                "Id_2",
+                "I",
+                "Id_3",
+                "CREDIT",
+                "Me_1",
+                10L,
+                "ruleid",
+                "ruleA",
+                "bool_var",
+                true,
+                "errorcode",
+                "null",
+                "errorlevel",
+                "null"),
+            Map.of(
+                "Id_1",
+                "2012",
+                "Id_2",
+                "I",
+                "Id_3",
+                "CREDIT",
+                "Me_1",
+                10L,
+                "ruleid",
+                "dpr1_2",
+                "bool_var",
+                true,
+                "errorcode",
+                "null",
+                "errorlevel",
+                "null"),
+            Map.of(
+                "Id_1",
+                "2012",
+                "Id_2",
+                "I",
+                "Id_3",
+                "DEBIT",
+                "Me_1",
+                2L,
+                "ruleid",
+                "ruleA",
+                "bool_var",
+                true,
+                "errorcode",
+                "null",
+                "errorlevel",
+                "null"),
+            Map.of(
+                "Id_1",
+                "2012",
+                "Id_2",
+                "I",
+                "Id_3",
+                "DEBIT",
+                "Me_1",
+                2L,
+                "ruleid",
+                "dpr1_2",
+                "bool_var",
+                true,
+                "errorcode",
+                "null",
+                "errorlevel",
+                "null"))
+        .containsExactlyInAnyOrderElementsOf(DS_r_all_measuresWithoutNull);
+  }
+
+  @Test
+  public void testValidateDPrulesetWithValuedomain() throws ScriptException {
+
+    ScriptContext context = engine.getContext();
+    context.setAttribute("DS_1", dataset, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "define datapoint ruleset dpr1 (valuedomain vd_id_3, vd_me_1 as vd) is "
+            + "ruleA : vd_id_3 = \"AA\" and vd > 0 errorcode \"CREDIT or DEBIT\" "
+            + "end datapoint ruleset; "
+            + "DS_r := check_datapoint(DS_1, dpr1); ");
+
+    Dataset DS_r = (Dataset) engine.getContext().getAttribute("DS_r");
+    assertThat(DS_r).isInstanceOf(Dataset.class);
+    assertThat(DS_r.getDataPoints().size()).isEqualTo(4);
+  }
+
+  @Test
+  public void testValidateDPrulesetWithAlias() throws ScriptException {
+
+    ScriptContext context = engine.getContext();
+    context.setAttribute("DS_1", dataset, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "define datapoint ruleset dpr1 (variable Id_3 as AA, Me_1) is "
+            + "when AA = \"CREDIT\" then Me_1 >= 0 errorcode \"Bad credit\"; "
+            + "when AA = \"DEBIT\" then Me_1 >= 0 errorcode \"Bad debit\" "
+            + "end datapoint ruleset; "
+            + "DS_r := check_datapoint(DS_1, dpr1);");
+
+    Dataset DS_r = (Dataset) engine.getContext().getAttribute("DS_r");
+    assertThat(DS_r).isInstanceOf(Dataset.class);
+
+    List<Map<String, Object>> DS_rWithNull = DS_r.getDataAsMap();
+    List<Map<String, Object>> DS_rWithoutNull = new ArrayList<>();
+    for (Map<String, Object> map : DS_rWithNull) {
+      DS_rWithoutNull.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+
+    assertThat(DS_rWithoutNull)
+        .containsExactlyInAnyOrder(
+            Map.of(
+                "Id_1",
+                "2011",
+                "Id_2",
+                "I",
+                "Id_3",
+                "DEBIT",
+                "Me_1",
+                -2L,
+                "ruleid",
+                "dpr1_2",
+                "errorcode",
+                "Bad debit",
+                "errorlevel",
+                "null"));
+  }
+
+  @Test
+  public void testCheck() throws ScriptException {
+    ScriptContext context = engine.getContext();
+    context.setAttribute("DS1", ds_1_check, ScriptContext.ENGINE_SCOPE);
+    context.setAttribute("DS2", ds_2_check, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "ds := check(DS1 >= DS2 errorcode \"err\" errorlevel 1 imbalance DS1 - DS2);"
+            + "ds1 := check(DS1 >= DS2 errorcode \"err\" errorlevel 1 imbalance DS1 - DS2 invalid);");
+
+    var ds = (Dataset) engine.getContext().getAttribute("ds");
+    assertThat(ds).isInstanceOf(Dataset.class);
+
+    List<Map<String, Object>> dsWithNull = ds.getDataAsMap();
+    List<Map<String, Object>> dsWithoutNull = new ArrayList<>();
+    for (Map<String, Object> map : dsWithNull) {
+      dsWithoutNull.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+
+    assertThat(dsWithoutNull)
+        .isEqualTo(
+            List.of(
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "I",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -8L,
+                    "errorcode",
+                    "err",
+                    "errorlevel",
+                    1L),
+                Map.of(
+                    "Id_1",
+                    "2011",
+                    "Id_2",
+                    "I",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2012",
+                    "Id_2",
+                    "I",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2013",
+                    "Id_2",
+                    "I",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -3L,
+                    "errorcode",
+                    "err",
+                    "errorlevel",
+                    1L),
+                Map.of(
+                    "Id_1",
+                    "2014",
+                    "Id_2",
+                    "I",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2015",
+                    "Id_2",
+                    "I",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "D",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -25L,
+                    "errorcode",
+                    "err",
+                    "errorlevel",
+                    1L),
+                Map.of(
+                    "Id_1",
+                    "2011",
+                    "Id_2",
+                    "D",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2012",
+                    "Id_2",
+                    "D",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    5L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2013",
+                    "Id_2",
+                    "D",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2014",
+                    "Id_2",
+                    "D",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -15L,
+                    "errorcode",
+                    "err",
+                    "errorlevel",
+                    1L),
+                Map.of(
+                    "Id_1",
+                    "2015",
+                    "Id_2",
+                    "D",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null")));
+    assertThat(ds.getDataStructure())
+        .containsValues(
+            new Structured.Component("Id_1", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("Id_2", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("bool_var", Boolean.class, Dataset.Role.MEASURE),
+            new Structured.Component("imbalance", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("errorcode", String.class, Dataset.Role.MEASURE),
+            new Structured.Component("errorlevel", Long.class, Dataset.Role.MEASURE));
+
+    var ds1 = (Dataset) engine.getContext().getAttribute("ds1");
+    assertThat(ds1).isInstanceOf(Dataset.class);
+
+    List<Map<String, Object>> ds1WithNull = ds1.getDataAsMap();
+    List<Map<String, Object>> ds1WithoutNull = new ArrayList<>();
+    for (Map<String, Object> map : ds1WithNull) {
+      ds1WithoutNull.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+
+    assertThat(ds1WithoutNull)
+        .isEqualTo(
+            List.of(
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "I",
+                    "imbalance",
+                    -8L,
+                    "errorcode",
+                    "err",
+                    "errorlevel",
+                    1L),
+                Map.of(
+                    "Id_1",
+                    "2013",
+                    "Id_2",
+                    "I",
+                    "imbalance",
+                    -3L,
+                    "errorcode",
+                    "err",
+                    "errorlevel",
+                    1L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "D",
+                    "imbalance",
+                    -25L,
+                    "errorcode",
+                    "err",
+                    "errorlevel",
+                    1L),
+                Map.of(
+                    "Id_1",
+                    "2014",
+                    "Id_2",
+                    "D",
+                    "imbalance",
+                    -15L,
+                    "errorcode",
+                    "err",
+                    "errorlevel",
+                    1L)));
+  }
+
+  @Test
+  public void testValidationSimpleException() throws ScriptException {
+
+    ScriptContext context = engine.getContext();
+    context.setAttribute("dsExpr", dsExpr, ScriptContext.ENGINE_SCOPE);
+    context.setAttribute("dsImbalance", dsImbalance, ScriptContext.ENGINE_SCOPE);
+    context.setAttribute("dsImbalanceToRename", dsImbalanceToRename, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("DS_r := check(dsExpr errorcode \"error\" errorlevel 1 imbalance dsImbalance);");
+    engine.eval(
+        "DS_r_invalid := check(dsExpr errorcode \"error\" errorlevel 1 imbalance dsImbalance invalid);");
+    engine.eval(
+        "DS_r_to_rename := check(dsExpr errorcode \"error\" errorlevel 1 imbalance dsImbalanceToRename);");
+    Dataset DS_r = (Dataset) engine.getContext().getAttribute("DS_r");
+    assertThat(DS_r.getDataAsMap().size()).isEqualTo(4);
+    Dataset DS_r_invalid = (Dataset) engine.getContext().getAttribute("DS_r_invalid");
+    assertThat(DS_r_invalid.getDataAsMap().size()).isEqualTo(2);
+    Dataset DS_r_to_rename = (Dataset) engine.getContext().getAttribute("DS_r_to_rename");
+    List<String> DS_r_to_renameMeasure =
+        DS_r_to_rename.getDataStructure().values().stream()
+            .filter(Structured.Component::isMeasure)
+            .map(Structured.Component::getName)
+            .toList();
+    assertThat(DS_r_to_renameMeasure.size()).isEqualTo(4);
+    assertThat(DS_r_to_renameMeasure.contains("imbalance")).isTrue();
+  }
+
+  @Test
+  public void serializationCheckDatapointTest() throws ScriptException {
+    ScriptContext context = engine.getContext();
+    org.apache.spark.sql.Dataset<Row> ds1_csv =
+        spark
+            .read()
+            .option("delimiter", ";")
+            .option("header", "true")
+            .csv("src/main/resources/ds1.csv");
+    SparkDataset sparkDataset1 = new SparkDataset(ds1_csv);
+    context.setAttribute("ds1", sparkDataset1, ScriptContext.ENGINE_SCOPE);
+    org.apache.spark.sql.Dataset<Row> ds2_csv =
+        spark
+            .read()
+            .option("delimiter", ";")
+            .option("header", "true")
+            .csv("src/main/resources/ds2.csv");
+    SparkDataset sparkDataset2 = new SparkDataset(ds1_csv);
+    context.setAttribute("ds2", sparkDataset2, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "ds1_1 := ds1[calc identifier id := id, long1 := cast(long1, integer), double1 := cast(double1, number), bool1 := cast(bool1, boolean)]; "
+            + "ds2_1 := ds2[calc identifier id := id, long1 := cast(long1, integer), double1 := cast(double1, number), bool1 := cast(bool1, boolean)]; "
+            + "ds_concat := ds1_1#string1 || \" and \" || ds2_1#string1; "
+            + "ds1_num := ds1_1[keep long1, double1]; "
+            + "ds2_num := ds2_1[keep long1, double1]; "
+            + "ds_mod := mod(ds1_num, 2); "
+            + "ds_sum := ds1_num + ds2_num; "
+            + "ds_compare := ds1_num = ds2_num; "
+            + "define datapoint ruleset dpr1 ( variable double1, long1 ) is "
+            + "   my_rule_1 : double1 > 0 errorcode \"Double <= 0\" errorlevel 1; "
+            + "   my_rule_2 : long1 > 0 errorcode \"Long <= 0\" errorlevel 100 "
+            + "end datapoint ruleset; "
+            + "ds_check_datapoint := check_datapoint(ds1_num, dpr1 all); "
+            + "ds_check := check(ds1_1#long1 > ds2_1#long1 errorcode \"error\" errorlevel 1 imbalance ds1_1#long1 + ds2_1#long1 invalid);");
+    List<Structured.DataPoint> dsCheckDatapoint =
+        ((Dataset) engine.getContext().getAttribute("ds_check_datapoint")).getDataPoints();
+  }
+
+  @Test
+  public void checkHierarchyOutputMode() throws ScriptException {
+    ScriptContext context = engine.getContext();
+    context.setAttribute("DS_1", DS_1_HR, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        hierarchicalRulesetDef
+            + "DS_r := check_hierarchy(DS_1, HR_1 rule Id_2); "
+            + "DS_r_all := check_hierarchy(DS_1, HR_1 rule Id_2 all); "
+            + "DS_r_all_measures := check_hierarchy(DS_1, HR_1 rule Id_2 all_measures);");
+
+    Dataset dsR = (Dataset) engine.getContext().getAttribute("DS_r");
+    List<Map<String, Object>> dsRWithNull = dsR.getDataAsMap();
+    List<Map<String, Object>> dsRWithoutNull = new ArrayList<>();
+    for (Map<String, Object> map : dsRWithNull) {
+      dsRWithoutNull.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+    assertThat(dsRWithoutNull)
+        .isEqualTo(
+            List.of(
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "G",
+                    "ruleid",
+                    "R070",
+                    "Me_1",
+                    19L,
+                    "imbalance",
+                    8L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R100",
+                    "Me_1",
+                    2L,
+                    "imbalance",
+                    -3L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    5L)));
+    assertThat(dsR.getDataStructure())
+        .containsValues(
+            new Structured.Component("Id_1", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("Id_2", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("ruleid", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("Me_1", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("imbalance", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("errorcode", String.class, Dataset.Role.MEASURE),
+            new Structured.Component("errorlevel", Long.class, Dataset.Role.MEASURE));
+
+    Dataset dsRAll = (Dataset) engine.getContext().getAttribute("DS_r_all");
+    List<Map<String, Object>> dsRAllWithNull = dsRAll.getDataAsMap();
+    List<Map<String, Object>> dsRAllWithoutNull = new ArrayList<>();
+    for (Map<String, Object> map : dsRAllWithNull) {
+      dsRAllWithoutNull.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+    assertThat(dsRAllWithoutNull)
+        .isEqualTo(
+            List.of(
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "B",
+                    "ruleid",
+                    "R020",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "C",
+                    "ruleid",
+                    "R030",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "G",
+                    "ruleid",
+                    "R070",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    8L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R100",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -3L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    5L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R110",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    -17L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null")));
+    assertThat(dsRAll.getDataStructure())
+        .containsValues(
+            new Structured.Component("Id_1", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("Id_2", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("ruleid", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("bool_var", Boolean.class, Dataset.Role.MEASURE),
+            new Structured.Component("imbalance", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("errorcode", String.class, Dataset.Role.MEASURE),
+            new Structured.Component("errorlevel", Long.class, Dataset.Role.MEASURE));
+
+    Dataset dsRAllMeasures = (Dataset) engine.getContext().getAttribute("DS_r_all_measures");
+    List<Map<String, Object>> dsRAllMeasuresWithNull = dsRAllMeasures.getDataAsMap();
+    List<Map<String, Object>> dsRAllMeasuresWithoutNull = new ArrayList<>();
+    for (Map<String, Object> map : dsRAllMeasuresWithNull) {
+      dsRAllMeasuresWithoutNull.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+    assertThat(dsRAllMeasuresWithoutNull)
+        .isEqualTo(
+            List.of(
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "B",
+                    "ruleid",
+                    "R020",
+                    "bool_var",
+                    true,
+                    "Me_1",
+                    11L,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "C",
+                    "ruleid",
+                    "R030",
+                    "bool_var",
+                    true,
+                    "Me_1",
+                    0L,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "G",
+                    "ruleid",
+                    "R070",
+                    "bool_var",
+                    false,
+                    "Me_1",
+                    19L,
+                    "imbalance",
+                    8L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R100",
+                    "bool_var",
+                    false,
+                    "Me_1",
+                    2L,
+                    "imbalance",
+                    -3L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    5L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R110",
+                    "bool_var",
+                    true,
+                    "Me_1",
+                    2L,
+                    "imbalance",
+                    -17L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null")));
+    assertThat(dsRAllMeasures.getDataStructure())
+        .containsValues(
+            new Structured.Component("Id_1", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("Id_2", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("ruleid", String.class, Dataset.Role.IDENTIFIER),
+            new Structured.Component("Me_1", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("bool_var", Boolean.class, Dataset.Role.MEASURE),
+            new Structured.Component("imbalance", Long.class, Dataset.Role.MEASURE),
+            new Structured.Component("errorcode", String.class, Dataset.Role.MEASURE),
+            new Structured.Component("errorlevel", Long.class, Dataset.Role.MEASURE));
+  }
+
+  @Test
+  public void checkHierarchyValidationMode() throws ScriptException {
+    ScriptContext context = engine.getContext();
+    context.setAttribute("DS_1", DS_1_HR, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        hierarchicalRulesetDef
+            + "DS_r_non_null := check_hierarchy(DS_1, HR_1 rule Id_2 non_null all); "
+            + "DS_r_non_zero := check_hierarchy(DS_1, HR_1 rule Id_2 non_zero all); "
+            + "DS_r_partial_null := check_hierarchy(DS_1, HR_1 rule Id_2 partial_null all); "
+            + "DS_r_partial_zero := check_hierarchy(DS_1, HR_1 rule Id_2 partial_zero all); "
+            + "DS_r_always_null := check_hierarchy(DS_1, HR_1 rule Id_2 always_null all); "
+            + "DS_r_always_zero := check_hierarchy(DS_1, HR_1 rule Id_2 always_zero all);");
+
+    Dataset dsRNonNull = (Dataset) engine.getContext().getAttribute("DS_r_non_null");
+    List<Map<String, Object>> dsRNonNullWithNull = dsRNonNull.getDataAsMap();
+    List<Map<String, Object>> dsRNonNullWithoutNull = new ArrayList<>();
+    for (Map<String, Object> map : dsRNonNullWithNull) {
+      dsRNonNullWithoutNull.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+    assertThat(dsRNonNullWithoutNull)
+        .isEqualTo(
+            List.of(
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "B",
+                    "ruleid",
+                    "R020",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "C",
+                    "ruleid",
+                    "R030",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "G",
+                    "ruleid",
+                    "R070",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    8L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R100",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -3L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    5L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R110",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    -17L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null")));
+
+    Dataset dsRNonZero = (Dataset) engine.getContext().getAttribute("DS_r_non_zero");
+    List<Map<String, Object>> dsRNonZeroWithNull = dsRNonZero.getDataAsMap();
+    List<Map<String, Object>> dsRNonZeroWithoutNull = new ArrayList<>();
+    for (Map<String, Object> map : dsRNonZeroWithNull) {
+      dsRNonZeroWithoutNull.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+    assertThat(dsRNonZeroWithoutNull)
+        .isEqualTo(
+            List.of(
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "A",
+                    "ruleid",
+                    "R010",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    5L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    5L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "B",
+                    "ruleid",
+                    "R020",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "C",
+                    "ruleid",
+                    "R030",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "D",
+                    "ruleid",
+                    "R040",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -3L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    1L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "E",
+                    "ruleid",
+                    "R050",
+                    "bool_var",
+                    "null",
+                    "imbalance",
+                    "null",
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "G",
+                    "ruleid",
+                    "R070",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    8L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "H",
+                    "ruleid",
+                    "R080",
+                    "bool_var",
+                    "null",
+                    "imbalance",
+                    "null",
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "I",
+                    "ruleid",
+                    "R090",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -5L,
+                    "errorcode",
+                    "YY",
+                    "errorlevel",
+                    0L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R100",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -3L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    5L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R110",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    -17L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null")));
+
+    Dataset dsRPartialNull = (Dataset) engine.getContext().getAttribute("DS_r_partial_null");
+    List<Map<String, Object>> dsRPartialNullWithNull = dsRPartialNull.getDataAsMap();
+    List<Map<String, Object>> dsRPartialNullWithoutNull = new ArrayList<>();
+    for (Map<String, Object> map : dsRPartialNullWithNull) {
+      dsRPartialNullWithoutNull.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+
+    assertThat(dsRPartialNullWithoutNull)
+        .isEqualTo(
+            List.of(
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "A",
+                    "ruleid",
+                    "R010",
+                    "bool_var",
+                    "null",
+                    "imbalance",
+                    "null",
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "B",
+                    "ruleid",
+                    "R020",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "C",
+                    "ruleid",
+                    "R030",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "D",
+                    "ruleid",
+                    "R040",
+                    "bool_var",
+                    "null",
+                    "imbalance",
+                    "null",
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "E",
+                    "ruleid",
+                    "R050",
+                    "bool_var",
+                    "null",
+                    "imbalance",
+                    "null",
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "G",
+                    "ruleid",
+                    "R070",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    8L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "I",
+                    "ruleid",
+                    "R090",
+                    "bool_var",
+                    "null",
+                    "imbalance",
+                    "null",
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R100",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -3L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    5L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R110",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    -17L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null")));
+
+    Dataset dsRPartialZero = (Dataset) engine.getContext().getAttribute("DS_r_partial_zero");
+    List<Map<String, Object>> dsRPartialZeroWithNull = dsRPartialZero.getDataAsMap();
+    List<Map<String, Object>> dsRPartialZeroWithoutNull = new ArrayList<>();
+    for (Map<String, Object> map : dsRPartialZeroWithNull) {
+      dsRPartialZeroWithoutNull.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+
+    assertThat(dsRPartialZeroWithoutNull)
+        .isEqualTo(
+            List.of(
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "A",
+                    "ruleid",
+                    "R010",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    5L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    5L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "B",
+                    "ruleid",
+                    "R020",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "C",
+                    "ruleid",
+                    "R030",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "D",
+                    "ruleid",
+                    "R040",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -3L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    1L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "E",
+                    "ruleid",
+                    "R050",
+                    "bool_var",
+                    "null",
+                    "imbalance",
+                    "null",
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "G",
+                    "ruleid",
+                    "R070",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    8L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "I",
+                    "ruleid",
+                    "R090",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -5L,
+                    "errorcode",
+                    "YY",
+                    "errorlevel",
+                    0L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R100",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -3L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    5L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R110",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    -17L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null")));
+
+    Dataset dsRAlwaysNull = (Dataset) engine.getContext().getAttribute("DS_r_always_null");
+    List<Map<String, Object>> dsRAlwaysNullWithNull = dsRAlwaysNull.getDataAsMap();
+    List<Map<String, Object>> dsRAlwaysNullWithoutNull = new ArrayList<>();
+    for (Map<String, Object> map : dsRAlwaysNullWithNull) {
+      dsRAlwaysNullWithoutNull.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+
+    assertThat(dsRAlwaysNullWithoutNull)
+        .isEqualTo(
+            List.of(
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "A",
+                    "ruleid",
+                    "R010",
+                    "bool_var",
+                    "null",
+                    "imbalance",
+                    "null",
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "B",
+                    "ruleid",
+                    "R020",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "C",
+                    "ruleid",
+                    "R030",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "D",
+                    "ruleid",
+                    "R040",
+                    "bool_var",
+                    "null",
+                    "imbalance",
+                    "null",
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "E",
+                    "ruleid",
+                    "R050",
+                    "bool_var",
+                    "null",
+                    "imbalance",
+                    "null",
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "F",
+                    "ruleid",
+                    "R060",
+                    "bool_var",
+                    "null",
+                    "imbalance",
+                    "null",
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "G",
+                    "ruleid",
+                    "R070",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    8L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "H",
+                    "ruleid",
+                    "R080",
+                    "bool_var",
+                    "null",
+                    "imbalance",
+                    "null",
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "I",
+                    "ruleid",
+                    "R090",
+                    "bool_var",
+                    "null",
+                    "imbalance",
+                    "null",
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R100",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -3L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    5L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R110",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    -17L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null")));
+
+    Dataset dsRAlwaysZero = (Dataset) engine.getContext().getAttribute("DS_r_always_zero");
+    List<Map<String, Object>> dsRAlwaysZeroWithNull = dsRAlwaysZero.getDataAsMap();
+    List<Map<String, Object>> dsRAlwaysZeroWithoutNull = new ArrayList<>();
+    for (Map<String, Object> map : dsRAlwaysZeroWithNull) {
+      dsRAlwaysZeroWithoutNull.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+
+    assertThat(dsRAlwaysZeroWithoutNull)
+        .isEqualTo(
+            List.of(
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "A",
+                    "ruleid",
+                    "R010",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    5L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    5L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "B",
+                    "ruleid",
+                    "R020",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "C",
+                    "ruleid",
+                    "R030",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "D",
+                    "ruleid",
+                    "R040",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -3L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    1L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "E",
+                    "ruleid",
+                    "R050",
+                    "bool_var",
+                    "null",
+                    "imbalance",
+                    "null",
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "F",
+                    "ruleid",
+                    "R060",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    0L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "G",
+                    "ruleid",
+                    "R070",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    8L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "H",
+                    "ruleid",
+                    "R080",
+                    "bool_var",
+                    "null",
+                    "imbalance",
+                    "null",
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null"),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "I",
+                    "ruleid",
+                    "R090",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -5L,
+                    "errorcode",
+                    "YY",
+                    "errorlevel",
+                    0L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R100",
+                    "bool_var",
+                    false,
+                    "imbalance",
+                    -3L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    5L),
+                Map.of(
+                    "Id_1",
+                    "2010",
+                    "Id_2",
+                    "M",
+                    "ruleid",
+                    "R110",
+                    "bool_var",
+                    true,
+                    "imbalance",
+                    -17L,
+                    "errorcode",
+                    "null",
+                    "errorlevel",
+                    "null")));
+  }
+
+  @Test
+  public void checkHierarchyException() {
+    Dataset DS_2_HR =
+        new InMemoryDataset(
+            List.of(List.of("2010", "A", 5L, 5L)),
+            List.of(
+                new Structured.Component("Id_1", String.class, Dataset.Role.IDENTIFIER),
+                new Structured.Component("Id_2", String.class, Dataset.Role.IDENTIFIER),
+                new Structured.Component("Me_1", Long.class, Dataset.Role.MEASURE),
+                new Structured.Component("Me_2", Long.class, Dataset.Role.MEASURE)));
+
+    Dataset DS_3_HR =
+        new InMemoryDataset(
+            List.of(List.of("2010", "A", "5")),
+            List.of(
+                new Structured.Component("Id_1", String.class, Dataset.Role.IDENTIFIER),
+                new Structured.Component("Id_2", String.class, Dataset.Role.IDENTIFIER),
+                new Structured.Component("Me_1", String.class, Dataset.Role.MEASURE)));
+
+    Dataset DS_4_HR =
+        new InMemoryDataset(
+            List.of(List.of("2010", "A", 5L)),
+            List.of(
+                new Structured.Component("Id_1", String.class, Dataset.Role.IDENTIFIER),
+                new Structured.Component("Id_2", String.class, Dataset.Role.IDENTIFIER),
+                new Structured.Component("Me_1", Long.class, Dataset.Role.MEASURE)));
+
+    ScriptContext context = engine.getContext();
+    context.setAttribute("DS_1", DS_1_HR, ScriptContext.ENGINE_SCOPE);
+    context.setAttribute("DS_2", DS_2_HR, ScriptContext.ENGINE_SCOPE);
+    context.setAttribute("DS_3", DS_3_HR, ScriptContext.ENGINE_SCOPE);
+    context.setAttribute("DS_4", DS_4_HR, ScriptContext.ENGINE_SCOPE);
+
+    assertThatThrownBy(
+            () ->
+                engine.eval(
+                    hierarchicalRulesetDef
+                        + "DS_r := check_hierarchy(DS_1, HR_1 rule Id_2 dataset_priority all);"))
+        .hasMessageContaining("dataset_priority input mode is not supported in check_hierarchy");
+
+    assertThatThrownBy(
+            () ->
+                engine.eval(
+                    hierarchicalRulesetDef
+                        + "DS_r := check_hierarchy(DS_2, HR_1 rule Id_2 partial_null all);"))
+        .hasMessageContaining("Dataset DS_2 is not monomeasure");
+
+    assertThatThrownBy(
+            () ->
+                engine.eval(
+                    hierarchicalRulesetDef
+                        + "DS_r := check_hierarchy(DS_3, HR_1 rule Id_2 partial_null all);"))
+        .hasMessageContaining("Dataset DS_3 measure Me_1 has to have number type");
+
+    assertThatThrownBy(
+            () ->
+                engine.eval(
+                    hierarchicalRulesetDef
+                        + "DS_r := check_hierarchy(DS_4, HR_1 rule Id_3 partial_null all);"))
+        .hasMessageContaining("ComponentID Id_3 not contained in dataset DS_4");
+  }
+
+  @Test
+  void testCH() throws ScriptException {
+    SparkSession.Builder sparkBuilder = SparkSession.builder().appName("vtl-lab").master("local");
+    SparkSession spark = sparkBuilder.getOrCreate();
+
+    ScriptEngine engine = new ScriptEngineManager().getEngineByName("vtl");
+    ScriptContext context = engine.getContext();
+    Bindings bindings = new SimpleBindings();
+    org.apache.spark.sql.Dataset<Row> ds1 =
+        spark
+            .read()
+            .option("delimiter", ";")
+            .option("header", "true")
+            .csv("src/main/resources/c_h.csv");
+    bindings.put("ds1", new SparkDataset(ds1));
+    context.setBindings(bindings, ScriptContext.ENGINE_SCOPE);
+    engine.put("$vtl.engine.processing_engine_names", "spark4");
+    engine.put("$vtl.spark.session", spark);
+
+    engine.eval(
+        """
+                        // Ensure ds1 metadata definition is good
+                        ds1_1 := ds1[calc identifier id := id, Me := cast(Me, integer)];\
+                        ds2_1 := ds1_1[filter id = "A"];
+
+                        // Define hierarchical ruleset
+                        define hierarchical ruleset hr (variable rule Me) is
+                            My_Rule : ABC = A + B + C errorcode "ABC is not sum of A,B,C" errorlevel 1;
+                            DEF = D + E + F errorcode "DEF is not sum of D,E,F";
+                            HIJ : HIJ = H + I - J errorcode "HIJ is not H + I - J" errorlevel 10
+                        end hierarchical ruleset;
+                        ds_all := check_hierarchy(ds1_1, hr rule id all);
+                        ds_all_empty := check_hierarchy(ds2_1, hr rule id all);
+                        ds_invalid := check_hierarchy(ds1_1, hr rule id always_zero invalid);
+                        ds_all_measures := check_hierarchy(ds1_1, hr rule id always_null all_measures);\
+                        """);
+
+    fr.insee.vtl.model.Dataset ds_all =
+        (fr.insee.vtl.model.Dataset) engine.getContext().getAttribute("ds_all");
+    assertThat(ds_all.getDataPoints()).hasSize(1);
+
+    fr.insee.vtl.model.Dataset ds_all_empty =
+        (fr.insee.vtl.model.Dataset) engine.getContext().getAttribute("ds_all_empty");
+    assertThat(ds_all_empty.getDataPoints()).isEmpty();
+
+    fr.insee.vtl.model.Dataset ds_invalid =
+        (fr.insee.vtl.model.Dataset) engine.getContext().getAttribute("ds_invalid");
+    assertThat(ds_invalid.getDataPoints()).hasSize(1);
+
+    fr.insee.vtl.model.Dataset ds_all_measures =
+        (fr.insee.vtl.model.Dataset) engine.getContext().getAttribute("ds_all_measures");
+    assertThat(ds_all_measures.getDataPoints()).hasSize(3);
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticAvgTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticAvgTest.java
new file mode 100644
index 000000000..077de35b6
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticAvgTest.java
@@ -0,0 +1,445 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class AnalyticAvgTest {
+
+  private final InMemoryDataset anCountDS1 =
+      new InMemoryDataset(
+          List.of(
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 9D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 7L, "Me_2", 5D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 6L, "Me_2", 8D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 9L, "Me_2", 3D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 4D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 10L, "Me_2", 2D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5L, "Me_2", 7D)),
+          Map.of(
+              "Id_1",
+              String.class,
+              "Id_2",
+              String.class,
+              "Year",
+              Long.class,
+              "Me_1",
+              Long.class,
+              "Me_2",
+              Double.class),
+          Map.of(
+              "Id_1",
+              Dataset.Role.IDENTIFIER,
+              "Id_2",
+              Dataset.Role.IDENTIFIER,
+              "Year",
+              Dataset.Role.IDENTIFIER,
+              "Me_1",
+              Dataset.Role.MEASURE,
+              "Me_2",
+              Dataset.Role.MEASURE));
+
+  private static SparkSession spark;
+  private static ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterAll
+  public static void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testAnAvgWithCalcClause() throws ScriptException {
+
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := ds1 [ calc avg_Me_1:= avg ( Me_1 over ( partition by Id_1,Id_2 order by Year) )];");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+-----------------+
+    |Id_1|Id_2|Year|Me_1|Me_2|         avg_Me_1|
+    +----+----+----+----+----+-----------------+
+    |   A|  XX|2000|   3| 1.0|              3.0|
+    |   A|  XX|2001|   4| 9.0|              3.5|
+    |   A|  XX|2002|   7| 5.0|4.666666666666667|
+    |   A|  XX|2003|   6| 8.0|              5.0|
+    |   A|  YY|2000|   9| 3.0|              9.0|
+    |   A|  YY|2001|   5| 4.0|              7.0|
+    |   A|  YY|2002|  10| 2.0|              8.0|
+    |   A|  YY|2003|   5| 7.0|             7.25|
+    +----+----+----+----+----+-----------------+
+    * */
+    List<Map<String, Object>> actual =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    assertThat(actual)
+        .containsExactly(
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2000L,
+                "Me_1",
+                3L,
+                "Me_2",
+                1.0D,
+                "avg_Me_1",
+                3.0D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2001L,
+                "Me_1",
+                4L,
+                "Me_2",
+                9.0D,
+                "avg_Me_1",
+                3.5D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2002L,
+                "Me_1",
+                7L,
+                "Me_2",
+                5.0D,
+                "avg_Me_1",
+                4.666666666666667D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2003L,
+                "Me_1",
+                6L,
+                "Me_2",
+                8.0D,
+                "avg_Me_1",
+                5.0D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2000L,
+                "Me_1",
+                9L,
+                "Me_2",
+                3.0D,
+                "avg_Me_1",
+                9.0D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2001L,
+                "Me_1",
+                5L,
+                "Me_2",
+                4.0D,
+                "avg_Me_1",
+                7.0D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2002L,
+                "Me_1",
+                10L,
+                "Me_2",
+                2.0D,
+                "avg_Me_1",
+                8.0D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2003L,
+                "Me_1",
+                5L,
+                "Me_2",
+                7.0D,
+                "avg_Me_1",
+                7.25D));
+  }
+
+  @Test
+  public void testAnAvgWithPartitionClause() throws ScriptException {
+
+    // Analytical function Test case 1 : avg on window with partition
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := avg ( ds1 over ( partition by Id_1, Id_2 ) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|avg_Me_1|avg_Me_2|
+        +----+----+----+----+----+--------+--------+
+        |   A|  XX|2000|   3| 1.0|     5.0|    5.75|
+        |   A|  XX|2001|   4| 9.0|     5.0|    5.75|
+        |   A|  XX|2002|   7| 5.0|     5.0|    5.75|
+        |   A|  XX|2003|   6| 8.0|     5.0|    5.75|
+        |   A|  YY|2000|   9| 3.0|    7.25|     4.0|
+        |   A|  YY|2001|   5| 4.0|    7.25|     4.0|
+        |   A|  YY|2002|  10| 2.0|    7.25|     4.0|
+        |   A|  YY|2003|   5| 7.0|    7.25|     4.0|
+        +----+----+----+----+----+--------+--------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 5.0D, "Me_2", 5.75D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 5.0D, "Me_2", 5.75D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 5.0D, "Me_2", 5.75D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 5.0D, "Me_2", 5.75D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 7.25D, "Me_2", 4.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 7.25D, "Me_2", 4.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 7.25D, "Me_2", 4.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 7.25D, "Me_2", 4.0D));
+  }
+
+  @Test
+  public void testAnAvgWithPartitionOrderByClause() throws ScriptException {
+
+    // Analytical function Test case 2 : avg on window with partition and order by
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := avg ( ds1 over ( partition by Id_1, Id_2 order by Year) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|         avg_Me_1|avg_Me_2|
+        +----+----+----+----+----+-----------------+--------+
+        |   A|  XX|2000|   3| 1.0|              3.0|     1.0|
+        |   A|  XX|2001|   4| 9.0|              3.5|     5.0|
+        |   A|  XX|2002|   7| 5.0|4.666666666666667|     5.0|
+        |   A|  XX|2003|   6| 8.0|              5.0|    5.75|
+        |   A|  YY|2000|   9| 3.0|              9.0|     3.0|
+        |   A|  YY|2001|   5| 4.0|              7.0|     3.5|
+        |   A|  YY|2002|  10| 2.0|              8.0|     3.0|
+        |   A|  YY|2003|   5| 7.0|             7.25|     4.0|
+        +----+----+----+----+----+-----------------+--------+
+
+    * */
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+
+    assertThat(res)
+        .contains(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3.0D, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 3.5D, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 4.67D, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 5.0D, "Me_2", 5.75D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 9.0D, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 7.0D, "Me_2", 3.5D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 8.0D, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 7.25D, "Me_2", 4.0D));
+  }
+
+  @Test
+  public void testAnAvgWithPartitionOrderByDPClause() throws ScriptException {
+
+    // Analytical function count test case 3 : avg on window with partition, orderBy and data points
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := avg ( ds1 over ( partition by Id_1 order by Id_2 data points between 2 preceding and 2 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|         avg_Me_1|         avg_Me_2|
+        +----+----+----+----+----+-----------------+-----------------+
+        |   A|  XX|2000|   3| 1.0|4.666666666666667|              5.0|
+        |   A|  XX|2001|   4| 9.0|              5.0|             5.75|
+        |   A|  XX|2002|   7| 5.0|              5.8|              5.2|
+        |   A|  XX|2003|   6| 8.0|              6.2|              5.8|
+        |   A|  YY|2000|   9| 3.0|              7.4|              4.4|
+        |   A|  YY|2001|   5| 4.0|              7.0|              4.8|
+        |   A|  YY|2002|  10| 2.0|             7.25|              4.0|
+        |   A|  YY|2003|   5| 7.0|6.666666666666667|4.333333333333333|
+        +----+----+----+----+----+-----------------+-----------------+
+
+    * */
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+    assertThat(res)
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 4.67D, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 5.0D, "Me_2", 5.75D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 5.8D, "Me_2", 5.2D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 6.2D, "Me_2", 5.8D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 7.4D, "Me_2", 4.4D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 7.0D, "Me_2", 4.8D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 7.25D, "Me_2", 4.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 6.67D, "Me_2", 4.33D));
+  }
+
+  @Test
+  public void testAnAvgWithPartitionOrderByRangeClause() throws ScriptException {
+
+    // Analytical function count test case 5 : avg on window with partition, orderBy and range
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := avg ( ds1 over ( partition by Id_1 order by Year range between 1 preceding and 1 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|         avg_Me_1|         avg_Me_2|
+        +----+----+----+----+----+-----------------+-----------------+
+        |   A|  XX|2000|   3| 1.0|             5.25|             4.25|
+        |   A|  YY|2000|   9| 3.0|             5.25|             4.25|
+        |   A|  XX|2001|   4| 9.0|6.333333333333333|              4.0|
+        |   A|  YY|2001|   5| 4.0|6.333333333333333|              4.0|
+        |   A|  XX|2002|   7| 5.0|6.166666666666667|5.833333333333333|
+        |   A|  YY|2002|  10| 2.0|6.166666666666667|5.833333333333333|
+        |   A|  XX|2003|   6| 8.0|              7.0|              5.5|
+        |   A|  YY|2003|   5| 7.0|              7.0|              5.5|
+        +----+----+----+----+----+-----------------+-----------------+
+
+    * */
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+    assertThat(res)
+        .containsExactlyInAnyOrder(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 5.25D, "Me_2", 4.25D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 6.33D, "Me_2", 4D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 6.17D, "Me_2", 5.83D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 7D, "Me_2", 5.5D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 5.25D, "Me_2", 4.25D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 6.33D, "Me_2", 4D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 6.17D, "Me_2", 5.83D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 7.0D, "Me_2", 5.5D));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticCountTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticCountTest.java
new file mode 100644
index 000000000..952a9eab1
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticCountTest.java
@@ -0,0 +1,746 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class AnalyticCountTest {
+
+  private final InMemoryDataset anCountDS1 =
+      new InMemoryDataset(
+          List.of(
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 9D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 7L, "Me_2", 5D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 6L, "Me_2", 8D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 9L, "Me_2", 3D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 4D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 10L, "Me_2", 2D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5L, "Me_2", 7D)),
+          Map.of(
+              "Id_1",
+              String.class,
+              "Id_2",
+              String.class,
+              "Year",
+              Long.class,
+              "Me_1",
+              Long.class,
+              "Me_2",
+              Double.class),
+          Map.of(
+              "Id_1",
+              Dataset.Role.IDENTIFIER,
+              "Id_2",
+              Dataset.Role.IDENTIFIER,
+              "Year",
+              Dataset.Role.IDENTIFIER,
+              "Me_1",
+              Dataset.Role.MEASURE,
+              "Me_2",
+              Dataset.Role.MEASURE));
+
+  private static SparkSession spark;
+  private static ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterAll
+  public static void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  /*
+   * Test with calc statement */
+  @Test
+  public void testAnCountWithCalcClause() throws ScriptException {
+
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := ds1 [ calc count_Me_1:= count ( Me_1 over ( partition by Id_1,Id_2 order by Year ) )];");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    *   +----+----+----+----+----+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|count_Me_1|
+        +----+----+----+----+----+----------+
+        |   A|  XX|2000|   3| 1.0|         1|
+        |   A|  XX|2001|   4| 9.0|         2|
+        |   A|  XX|2002|   7| 5.0|         3|
+        |   A|  XX|2003|   6| 8.0|         4|
+        |   A|  YY|2000|   9| 3.0|         1|
+        |   A|  YY|2001|   5| 4.0|         2|
+        |   A|  YY|2002|  10| 2.0|         3|
+        |   A|  YY|2003|   5| 7.0|         4|
+        +----+----+----+----+----+----------+
+    * */
+    List<Map<String, Object>> actual =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    assertThat(actual)
+        .containsExactly(
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2000L,
+                "Me_1",
+                3L,
+                "Me_2",
+                1.0D,
+                "count_Me_1",
+                1L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2001L,
+                "Me_1",
+                4L,
+                "Me_2",
+                9.0D,
+                "count_Me_1",
+                2L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2002L,
+                "Me_1",
+                7L,
+                "Me_2",
+                5.0D,
+                "count_Me_1",
+                3L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2003L,
+                "Me_1",
+                6L,
+                "Me_2",
+                8.0D,
+                "count_Me_1",
+                4L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2000L,
+                "Me_1",
+                9L,
+                "Me_2",
+                3.0D,
+                "count_Me_1",
+                1L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2001L,
+                "Me_1",
+                5L,
+                "Me_2",
+                4.0D,
+                "count_Me_1",
+                2L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2002L,
+                "Me_1",
+                10L,
+                "Me_2",
+                2.0D,
+                "count_Me_1",
+                3L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2003L,
+                "Me_1",
+                5L,
+                "Me_2",
+                7.0D,
+                "count_Me_1",
+                4L));
+  }
+
+  @Test
+  public void testAnCountDPWithCalcClause() throws ScriptException {
+
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := ds1 [ calc count_Me_1:= count ( Me_1 over ( partition by Id_1,Id_2 order by Year data points between 2 preceding and 2 following) )];");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+----------+
+    |Id_1|Id_2|Year|Me_1|Me_2|count_Me_1|
+    +----+----+----+----+----+----------+
+    |   A|  XX|2000|   3| 1.0|         3|
+    |   A|  XX|2001|   4| 9.0|         4|
+    |   A|  XX|2002|   7| 5.0|         4|
+    |   A|  XX|2003|   6| 8.0|         3|
+    |   A|  YY|2000|   9| 3.0|         3|
+    |   A|  YY|2001|   5| 4.0|         4|
+    |   A|  YY|2002|  10| 2.0|         4|
+    |   A|  YY|2003|   5| 7.0|         3|
+    +----+----+----+----+----+----------+
+    * */
+    List<Map<String, Object>> actual =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    assertThat(actual)
+        .containsExactly(
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2000L,
+                "Me_1",
+                3L,
+                "Me_2",
+                1.0D,
+                "count_Me_1",
+                3L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2001L,
+                "Me_1",
+                4L,
+                "Me_2",
+                9.0D,
+                "count_Me_1",
+                4L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2002L,
+                "Me_1",
+                7L,
+                "Me_2",
+                5.0D,
+                "count_Me_1",
+                4L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2003L,
+                "Me_1",
+                6L,
+                "Me_2",
+                8.0D,
+                "count_Me_1",
+                3L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2000L,
+                "Me_1",
+                9L,
+                "Me_2",
+                3.0D,
+                "count_Me_1",
+                3L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2001L,
+                "Me_1",
+                5L,
+                "Me_2",
+                4.0D,
+                "count_Me_1",
+                4L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2002L,
+                "Me_1",
+                10L,
+                "Me_2",
+                2.0D,
+                "count_Me_1",
+                4L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2003L,
+                "Me_1",
+                5L,
+                "Me_2",
+                7.0D,
+                "count_Me_1",
+                3L));
+  }
+
+  @Test
+  public void testAnCountRangeWithCalcClause() throws ScriptException {
+
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := ds1 [ calc count_Me_1:= count ( Me_1 over ( partition by Id_1,Id_2 order by Year range between 1 preceding and 1 following) )];");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+----------+
+    |Id_1|Id_2|Year|Me_1|Me_2|count_Me_1|
+    +----+----+----+----+----+----------+
+    |   A|  XX|2000|   3| 1.0|         2|
+    |   A|  XX|2001|   4| 9.0|         3|
+    |   A|  XX|2002|   7| 5.0|         3|
+    |   A|  XX|2003|   6| 8.0|         2|
+    |   A|  YY|2000|   9| 3.0|         2|
+    |   A|  YY|2001|   5| 4.0|         3|
+    |   A|  YY|2002|  10| 2.0|         3|
+    |   A|  YY|2003|   5| 7.0|         2|
+    +----+----+----+----+----+----------+
+    * */
+    List<Map<String, Object>> actual =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    assertThat(actual)
+        .containsExactly(
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2000L,
+                "Me_1",
+                3L,
+                "Me_2",
+                1.0D,
+                "count_Me_1",
+                2L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2001L,
+                "Me_1",
+                4L,
+                "Me_2",
+                9.0D,
+                "count_Me_1",
+                3L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2002L,
+                "Me_1",
+                7L,
+                "Me_2",
+                5.0D,
+                "count_Me_1",
+                3L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2003L,
+                "Me_1",
+                6L,
+                "Me_2",
+                8.0D,
+                "count_Me_1",
+                2L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2000L,
+                "Me_1",
+                9L,
+                "Me_2",
+                3.0D,
+                "count_Me_1",
+                2L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2001L,
+                "Me_1",
+                5L,
+                "Me_2",
+                4.0D,
+                "count_Me_1",
+                3L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2002L,
+                "Me_1",
+                10L,
+                "Me_2",
+                2.0D,
+                "count_Me_1",
+                3L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2003L,
+                "Me_1",
+                5L,
+                "Me_2",
+                7.0D,
+                "count_Me_1",
+                2L));
+  }
+
+  @Test
+  public void testAnCountWithPartitionClause() throws ScriptException {
+
+    // Analytical function Test case 1 : count on window with partition
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    // Transform to res := ds1[ calc count_Me_1 := count ( Me_1 over ( partition by Id_1))];"
+    engine.eval("res := count ( ds1 over ( partition by Id_1) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame need to check mutable or not mutable on Mesaument column
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|count_Me_1|count_Me_2|
+        +----+----+----+----+----+----------+----------+
+        |   A|  XX|2000|   3| 1.0|         8|         8|
+        |   A|  XX|2001|   4| 9.0|         8|         8|
+        |   A|  XX|2002|   7| 5.0|         8|         8|
+        |   A|  XX|2003|   6| 8.0|         8|         8|
+        |   A|  YY|2000|   9| 3.0|         8|         8|
+        |   A|  YY|2001|   5| 4.0|         8|         8|
+        |   A|  YY|2002|  10| 2.0|         8|         8|
+        |   A|  YY|2003|   5| 7.0|         8|         8|
+        +----+----+----+----+----+----------+----------+
+    * */
+    List<Map<String, Object>> actual =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    assertThat(actual)
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 8L, "Me_2", 8L),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 8L, "Me_2", 8L),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 8L, "Me_2", 8L),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 8L, "Me_2", 8L),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 8L, "Me_2", 8L),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 8L, "Me_2", 8L),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 8L, "Me_2", 8L),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 8L, "Me_2", 8L));
+  }
+
+  @Test
+  public void testAnCountWithPartitionOrderByClause() throws ScriptException {
+
+    // Analytical function Test case 2 : count on window with partition and orderBy
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := count ( ds1 over ( partition by Id_1 order by Id_2) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|count_Me_1|count_Me_2|
+        +----+----+----+----+----+----------+----------+
+        |   A|  XX|2000|   3| 1.0|         4|         4|
+        |   A|  XX|2001|   4| 9.0|         4|         4|
+        |   A|  XX|2002|   7| 5.0|         4|         4|
+        |   A|  XX|2003|   6| 8.0|         4|         4|
+        |   A|  YY|2000|   9| 3.0|         8|         8|
+        |   A|  YY|2001|   5| 4.0|         8|         8|
+        |   A|  YY|2002|  10| 2.0|         8|         8|
+        |   A|  YY|2003|   5| 7.0|         8|         8|
+        +----+----+----+----+----+----------+----------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 4L, "Me_2", 4L),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 4L),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 4L, "Me_2", 4L),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 4L, "Me_2", 4L),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 8L, "Me_2", 8L),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 8L, "Me_2", 8L),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 8L, "Me_2", 8L),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 8L, "Me_2", 8L));
+  }
+
+  @Test
+  public void testAnCountWithPartitionOrderByDPClause() throws ScriptException {
+
+    // Analytical function count test case 3 : count on window with partition, orderBy and data
+    // points
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := count ( ds1 over ( partition by Id_1 order by Id_2 data points between 2 preceding and 2 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|count_Me_1|count_Me_2|
+        +----+----+----+----+----+----------+----------+
+        |   A|  XX|2000|   3| 1.0|         3|         3|
+        |   A|  XX|2001|   4| 9.0|         4|         4|
+        |   A|  XX|2002|   7| 5.0|         5|         5|
+        |   A|  XX|2003|   6| 8.0|         5|         5|
+        |   A|  YY|2000|   9| 3.0|         5|         5|
+        |   A|  YY|2001|   5| 4.0|         5|         5|
+        |   A|  YY|2002|  10| 2.0|         4|         4|
+        |   A|  YY|2003|   5| 7.0|         3|         3|
+        +----+----+----+----+----+----------+----------+
+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 3L),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 4L),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 5L, "Me_2", 5L),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 5L, "Me_2", 5L),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 5L, "Me_2", 5L),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 5L),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 4L, "Me_2", 4L),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 3L, "Me_2", 3L));
+  }
+
+  @Test
+  public void testAnCountWithPartitionOrderByRange() throws ScriptException {
+    // Analytical function count test case 4 : count on window with partition, orderBy and range
+    // Because range build window based on the ordered column value, and Id_2 is string, so we
+    // change
+    // the order by column to year.
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := count ( ds1 over ( partition by Id_1 order by Year range between 1 preceding and 1 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|count_Me_1|count_Me_2|
+        +----+----+----+----+----+----------+----------+
+        |   A|  XX|2000|   3| 1.0|         4|         4|
+        |   A|  YY|2000|   9| 3.0|         4|         4|
+        |   A|  XX|2001|   4| 9.0|         6|         6|
+        |   A|  YY|2001|   5| 4.0|         6|         6|
+        |   A|  XX|2002|   7| 5.0|         6|         6|
+        |   A|  YY|2002|  10| 2.0|         6|         6|
+        |   A|  XX|2003|   6| 8.0|         4|         4|
+        |   A|  YY|2003|   5| 7.0|         4|         4|
+        +----+----+----+----+----+----------+----------+
+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 4L, "Me_2", 4L),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 4L, "Me_2", 4L),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 6L, "Me_2", 6L),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 6L, "Me_2", 6L),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 6L, "Me_2", 6L),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 6L, "Me_2", 6L),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 4L, "Me_2", 4L),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 4L, "Me_2", 4L));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticFirstTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticFirstTest.java
new file mode 100644
index 000000000..80096f49b
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticFirstTest.java
@@ -0,0 +1,222 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.model.Dataset;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptException;
+import org.junit.jupiter.api.Test;
+
+public class AnalyticFirstTest extends AnalyticTest {
+
+  @Test
+  public void testAnFirstWithPartitionClause() throws ScriptException {
+
+    // Analytical function Test case 1 : first on window with partition
+    /* Input dataset
+    +----+----+----+----+----+
+    |Id_1|Id_2|Year|Me_1|Me_2|
+    +----+----+----+----+----+
+    |   A|  XX|1993|   3| 1.0|
+    |   A|  XX|1994|   4| 9.0|
+    |   A|  XX|1995|   7| 5.0|
+    |   A|  XX|1996|   6| 8.0|
+    |   A|  YY|1993|   9| 3.0|
+    |   A|  YY|1994|   5| 4.0|
+    |   A|  YY|1995|  10| 2.0|
+    |   A|  YY|1996|   2| 7.0|
+    +----+----+----+----+----+
+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds2", ds2, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res :=  first_value ( ds2 over ( partition by Id_1, Id_2) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+----------+----------+
+    |Id_1|Id_2|Year|Me_1|Me_2|first_Me_1|first_Me_2|
+    +----+----+----+----+----+----------+----------+
+    |   A|  XX|1993|   3| 1.0|         3|       1.0|
+    |   A|  XX|1994|   4| 9.0|         3|       1.0|
+    |   A|  XX|1995|   7| 5.0|         3|       1.0|
+    |   A|  XX|1996|   6| 8.0|         3|       1.0|
+    |   A|  YY|1993|   9| 3.0|         9|       3.0|
+    |   A|  YY|1994|   5| 4.0|         9|       3.0|
+    |   A|  YY|1995|  10| 2.0|         9|       3.0|
+    |   A|  YY|1996|   2| 7.0|         9|       3.0|
+    +----+----+----+----+----+----------+----------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1993L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1994L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1995L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1996L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1993L, "Me_1", 9L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1994L, "Me_1", 9L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1995L, "Me_1", 9L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1996L, "Me_1", 9L, "Me_2", 3.0D));
+  }
+
+  @Test
+  public void testAnFirstPartitionOrderByDesc() throws ScriptException {
+
+    // Analytical function Test case 2 : first on window with partition and desc order
+    /* Input dataset
+    +----+----+----+----+----+
+    |Id_1|Id_2|Year|Me_1|Me_2|
+    +----+----+----+----+----+
+    |   A|  XX|1993|   3| 1.0|
+    |   A|  XX|1994|   4| 9.0|
+    |   A|  XX|1995|   7| 5.0|
+    |   A|  XX|1996|   6| 8.0|
+    |   A|  YY|1993|   9| 3.0|
+    |   A|  YY|1994|   5| 4.0|
+    |   A|  YY|1995|  10| 2.0|
+    |   A|  YY|1996|   2| 7.0|
+    +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    // will also test dot espacing
+    context.setAttribute("ds.ds2", ds2, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res :=  first_value ( ds.ds2 over ( partition by Id_1, Id_2 order by Year desc) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+----------+----------+
+    |Id_1|Id_2|Year|Me_1|Me_2|first_Me_1|first_Me_2|
+    +----+----+----+----+----+----------+----------+
+    |   A|  XX|1996|   6| 8.0|         6|       8.0|
+    |   A|  XX|1995|   7| 5.0|         6|       8.0|
+    |   A|  XX|1994|   4| 9.0|         6|       8.0|
+    |   A|  XX|1993|   3| 1.0|         6|       8.0|
+    |   A|  YY|1996|   2| 7.0|         2|       7.0|
+    |   A|  YY|1995|  10| 2.0|         2|       7.0|
+    |   A|  YY|1994|   5| 4.0|         2|       7.0|
+    |   A|  YY|1993|   9| 3.0|         2|       7.0|
+    +----+----+----+----+----+----------+----------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1996L, "Me_1", 6L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1995L, "Me_1", 6L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1994L, "Me_1", 6L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1993L, "Me_1", 6L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1996L, "Me_1", 2L, "Me_2", 7.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1995L, "Me_1", 2L, "Me_2", 7.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1994L, "Me_1", 2L, "Me_2", 7.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1993L, "Me_1", 2L, "Me_2", 7.0D));
+  }
+
+  @Test
+  public void testAnFirstWithPartitionOrderByDPClause() throws ScriptException {
+
+    // Analytical function Test case 3 : first on window with partition, order by and data points
+    /* Input dataset
+    +----+----+----+----+----+
+    |Id_1|Id_2|Year|Me_1|Me_2|
+    +----+----+----+----+----+
+    |   A|  XX|1993|   3| 1.0|
+    |   A|  XX|1994|   4| 9.0|
+    |   A|  XX|1995|   7| 5.0|
+    |   A|  XX|1996|   6| 8.0|
+    |   A|  YY|1993|   9| 3.0|
+    |   A|  YY|1994|   5| 4.0|
+    |   A|  YY|1995|  10| 2.0|
+    |   A|  YY|1996|   2| 7.0|
+    +----+----+----+----+----+
+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds2", ds2, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := first_value ( ds2 over ( partition by Id_1 order by Id_2 data points between 2 preceding and 2 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+----------+----------+
+    |Id_1|Id_2|Year|Me_1|Me_2|first_Me_1|first_Me_2|
+    +----+----+----+----+----+----------+----------+
+    |   A|  XX|1993|   3| 1.0|         3|       1.0|
+    |   A|  XX|1994|   4| 9.0|         3|       1.0|
+    |   A|  XX|1995|   7| 5.0|         3|       1.0|
+    |   A|  XX|1996|   6| 8.0|         4|       9.0|
+    |   A|  YY|1993|   9| 3.0|         7|       5.0|
+    |   A|  YY|1994|   5| 4.0|         6|       8.0|
+    |   A|  YY|1995|  10| 2.0|         9|       3.0|
+    |   A|  YY|1996|   2| 7.0|         5|       4.0|
+    +----+----+----+----+----+----------+----------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1993L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1994L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1995L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1996L, "Me_1", 4L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1993L, "Me_1", 7L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1994L, "Me_1", 6L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1995L, "Me_1", 9L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1996L, "Me_1", 5L, "Me_2", 4.0D));
+  }
+
+  @Test
+  public void testAnFirstPartitionOrderByRangeClause() throws ScriptException {
+
+    // Analytical function Test case 4 : first on window with partition, order by and range
+    /* Input dataset
+    +----+----+----+----+----+
+    |Id_1|Id_2|Year|Me_1|Me_2|
+    +----+----+----+----+----+
+    |   A|  XX|1993|   3| 1.0|
+    |   A|  XX|1994|   4| 9.0|
+    |   A|  XX|1995|   7| 5.0|
+    |   A|  XX|1996|   6| 8.0|
+    |   A|  YY|1993|   9| 3.0|
+    |   A|  YY|1994|   5| 4.0|
+    |   A|  YY|1995|  10| 2.0|
+    |   A|  YY|1996|   2| 7.0|
+    +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds2", ds2, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := first_value ( ds2 over ( partition by Id_1 order by Year range between 1 preceding and 1 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+----------+----------+
+    |Id_1|Id_2|Year|Me_1|Me_2|first_Me_1|first_Me_2|
+    +----+----+----+----+----+----------+----------+
+    |   A|  XX|1993|   3| 1.0|         3|       1.0|
+    |   A|  YY|1993|   9| 3.0|         3|       1.0|
+    |   A|  XX|1994|   4| 9.0|         3|       1.0|
+    |   A|  YY|1994|   5| 4.0|         3|       1.0|
+    |   A|  XX|1995|   7| 5.0|         4|       9.0|
+    |   A|  YY|1995|  10| 2.0|         4|       9.0|
+    |   A|  XX|1996|   6| 8.0|         7|       5.0|
+    |   A|  YY|1996|   2| 7.0|         7|       5.0|
+    +----+----+----+----+----+----------+----------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactlyInAnyOrder(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1993L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1993L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1994L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1994L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1995L, "Me_1", 4L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1995L, "Me_1", 4L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1996L, "Me_1", 7L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1996L, "Me_1", 7L, "Me_2", 5.0D));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticLagTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticLagTest.java
new file mode 100644
index 000000000..20f9eda52
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticLagTest.java
@@ -0,0 +1,193 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.model.Dataset;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.script.ScriptContext;
+import javax.script.ScriptException;
+import org.junit.jupiter.api.Test;
+
+public class AnalyticLagTest extends AnalyticTest {
+
+  @Test
+  public void testAnLagWithCalcClause() throws ScriptException {
+
+    // Analytical function Test case 1 : lead on window with partition, order by and range
+    /* Input dataset
+    +----+----+----+----+----+
+    |Id_1|Id_2|Year|Me_1|Me_2|
+    +----+----+----+----+----+
+    |   A|  XX|1993|   3| 1.0|
+    |   A|  XX|1994|   4| 9.0|
+    |   A|  XX|1995|   7| 5.0|
+    |   A|  XX|1996|   6| 8.0|
+    |   A|  YY|1993|   9| 3.0|
+    |   A|  YY|1994|   5| 4.0|
+    |   A|  YY|1995|  10| 2.0|
+    |   A|  YY|1996|   2| 7.0|
+    +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds2", ds2, ScriptContext.ENGINE_SCOPE);
+    engine.eval(
+        "res := ds2 [ calc lag_Me_1 := lag ( Me_1 , 1 over ( partition by Id_1 , Id_2 order by Year ) )] ;");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+--------+
+    |Id_1|Id_2|Year|Me_1|Me_2|lag_Me_1|
+    +----+----+----+----+----+--------+
+    |   A|  XX|1993|   3| 1.0|    null|
+    |   A|  XX|1994|   4| 9.0|       3|
+    |   A|  XX|1995|   7| 5.0|       4|
+    |   A|  XX|1996|   6| 8.0|       7|
+    |   A|  YY|1993|   9| 3.0|    null|
+    |   A|  YY|1994|   5| 4.0|       9|
+    |   A|  YY|1995|  10| 2.0|       5|
+    |   A|  YY|1996|   2| 7.0|      10|
+    +----+----+----+----+----+--------+
+    * */
+
+    List<Map<String, Object>> actualWithNull =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    List<Map<String, Object>> actual = new ArrayList<>();
+    for (Map<String, Object> map : actualWithNull) {
+      actual.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+    assertThat(actual)
+        .containsExactly(
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                1993L,
+                "Me_1",
+                3L,
+                "Me_2",
+                1.0D,
+                "lag_Me_1",
+                "null"),
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 1994L, "Me_1", 4L, "Me_2", 9.0D, "lag_Me_1", 3L),
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 1995L, "Me_1", 7L, "Me_2", 5.0D, "lag_Me_1", 4L),
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 1996L, "Me_1", 6L, "Me_2", 8.0D, "lag_Me_1", 7L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                1993L,
+                "Me_1",
+                9L,
+                "Me_2",
+                3.0D,
+                "lag_Me_1",
+                "null"),
+            Map.of(
+                "Id_1", "A", "Id_2", "YY", "Year", 1994L, "Me_1", 5L, "Me_2", 4.0D, "lag_Me_1", 9L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                1995L,
+                "Me_1",
+                10L,
+                "Me_2",
+                2.0D,
+                "lag_Me_1",
+                5L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                1996L,
+                "Me_1",
+                2L,
+                "Me_2",
+                7.0D,
+                "lag_Me_1",
+                10L));
+  }
+
+  /*
+   * Test case for analytic function lag
+   * The lag function take two argument:
+   * - input dataframe
+   * - step
+   * Analytic clause restriction:
+   * - Must have orderClause
+   * - The windowClause such as data points and range are not allowed
+   * */
+  @Test
+  public void testAnLag() throws ScriptException {
+
+    // Analytical function Test case 1 : lag on window with partition, order by and range
+    /* Input dataset
+    +----+----+----+----+----+
+    |Id_1|Id_2|Year|Me_1|Me_2|
+    +----+----+----+----+----+
+    |   A|  XX|1993|   3| 1.0|
+    |   A|  XX|1994|   4| 9.0|
+    |   A|  XX|1995|   7| 5.0|
+    |   A|  XX|1996|   6| 8.0|
+    |   A|  YY|1993|   9| 3.0|
+    |   A|  YY|1994|   5| 4.0|
+    |   A|  YY|1995|  10| 2.0|
+    |   A|  YY|1996|   2| 7.0|
+    +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds2", ds2, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := lag ( ds2 , 1 over ( partition by Id_1 , Id_2 order by Year ) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+---------+---------+
+    |Id_1|Id_2|Year|Me_1|Me_2|lead_Me_1|lead_Me_2|
+    +----+----+----+----+----+---------+---------+
+    |   A|  XX|1993|   3| 1.0|     null|     null|
+    |   A|  XX|1994|   4| 9.0|        3|      1.0|
+    |   A|  XX|1995|   7| 5.0|        4|      9.0|
+    |   A|  XX|1996|   6| 8.0|        7|      5.0|
+    |   A|  YY|1993|   9| 3.0|     null|     null|
+    |   A|  YY|1994|   5| 4.0|        9|      3.0|
+    |   A|  YY|1995|  10| 2.0|        5|      4.0|
+    |   A|  YY|1996|   2| 7.0|       10|      2.0|
+    +----+----+----+----+----+---------+---------+
+    * */
+    List<Map<String, Object>> actualWithNull =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+    var actual =
+        actualWithNull.stream()
+            .map(map -> replaceNullValues(map, DEFAULT_NULL_STR))
+            .collect(Collectors.toList());
+
+    assertThat(actual)
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1993L, "Me_1", "null", "Me_2", "null"),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1994L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1995L, "Me_1", 4L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1996L, "Me_1", 7L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1993L, "Me_1", "null", "Me_2", "null"),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1994L, "Me_1", 9L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1995L, "Me_1", 5L, "Me_2", 4.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1996L, "Me_1", 10L, "Me_2", 2.0D));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticLastTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticLastTest.java
new file mode 100644
index 000000000..1e16a4874
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticLastTest.java
@@ -0,0 +1,224 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.model.Dataset;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptException;
+import org.junit.jupiter.api.Test;
+
+public class AnalyticLastTest extends AnalyticTest {
+
+  /*
+   * Test case for analytic function last
+   *
+   * */
+  @Test
+  public void testAnLastWithPartitionClause() throws ScriptException {
+
+    // Analytical function Test case 1 : last on window with partition
+    /* Input dataset
+    +----+----+----+----+----+
+    |Id_1|Id_2|Year|Me_1|Me_2|
+    +----+----+----+----+----+
+    |   A|  XX|1993|   3| 1.0|
+    |   A|  XX|1994|   4| 9.0|
+    |   A|  XX|1995|   7| 5.0|
+    |   A|  XX|1996|   6| 8.0|
+    |   A|  YY|1993|   9| 3.0|
+    |   A|  YY|1994|   5| 4.0|
+    |   A|  YY|1995|  10| 2.0|
+    |   A|  YY|1996|   2| 7.0|
+    +----+----+----+----+----+
+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds2", ds2, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res :=  last_value ( ds2 over ( partition by Id_1, Id_2) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+---------+---------+
+    |Id_1|Id_2|Year|Me_1|Me_2|last_Me_1|last_Me_2|
+    +----+----+----+----+----+---------+---------+
+    |   A|  XX|1993|   3| 1.0|        6|      8.0|
+    |   A|  XX|1994|   4| 9.0|        6|      8.0|
+    |   A|  XX|1995|   7| 5.0|        6|      8.0|
+    |   A|  XX|1996|   6| 8.0|        6|      8.0|
+    |   A|  YY|1993|   9| 3.0|        2|      7.0|
+    |   A|  YY|1994|   5| 4.0|        2|      7.0|
+    |   A|  YY|1995|  10| 2.0|        2|      7.0|
+    |   A|  YY|1996|   2| 7.0|        2|      7.0|
+    +----+----+----+----+----+---------+---------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1993L, "Me_1", 6L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1994L, "Me_1", 6L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1995L, "Me_1", 6L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1996L, "Me_1", 6L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1993L, "Me_1", 2L, "Me_2", 7.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1994L, "Me_1", 2L, "Me_2", 7.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1995L, "Me_1", 2L, "Me_2", 7.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1996L, "Me_1", 2L, "Me_2", 7.0D));
+  }
+
+  @Test
+  public void testAnLastPartitionOrderByDesc() throws ScriptException {
+
+    // Analytical function Test case 2 : last on window with partition and desc order
+    /* Input dataset
+    +----+----+----+----+----+
+    |Id_1|Id_2|Year|Me_1|Me_2|
+    +----+----+----+----+----+
+    |   A|  XX|1993|   3| 1.0|
+    |   A|  XX|1994|   4| 9.0|
+    |   A|  XX|1995|   7| 5.0|
+    |   A|  XX|1996|   6| 8.0|
+    |   A|  YY|1993|   9| 3.0|
+    |   A|  YY|1994|   5| 4.0|
+    |   A|  YY|1995|  10| 2.0|
+    |   A|  YY|1996|   2| 7.0|
+    +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds2", ds2, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res :=  last_value ( ds2 over ( partition by Id_1, Id_2 order by Year desc) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+---------+---------+
+    |Id_1|Id_2|Year|Me_1|Me_2|last_Me_1|last_Me_2|
+    +----+----+----+----+----+---------+---------+
+    |   A|  XX|1996|   6| 8.0|        6|      8.0|
+    |   A|  XX|1995|   7| 5.0|        7|      5.0|
+    |   A|  XX|1994|   4| 9.0|        4|      9.0|
+    |   A|  XX|1993|   3| 1.0|        3|      1.0|
+    |   A|  YY|1996|   2| 7.0|        2|      7.0|
+    |   A|  YY|1995|  10| 2.0|       10|      2.0|
+    |   A|  YY|1994|   5| 4.0|        5|      4.0|
+    |   A|  YY|1993|   9| 3.0|        9|      3.0|
+    +----+----+----+----+----+---------+---------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1996L, "Me_1", 6L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1995L, "Me_1", 7L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1994L, "Me_1", 4L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1993L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1996L, "Me_1", 2L, "Me_2", 7.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1995L, "Me_1", 10L, "Me_2", 2.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1994L, "Me_1", 5L, "Me_2", 4.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1993L, "Me_1", 9L, "Me_2", 3.0D));
+  }
+
+  @Test
+  public void testAnLastWithPartitionOrderByDPClause() throws ScriptException {
+
+    // Analytical function Test case 3 : last on window with partition, order by and data points
+    /* Input dataset
+    +----+----+----+----+----+
+    |Id_1|Id_2|Year|Me_1|Me_2|
+    +----+----+----+----+----+
+    |   A|  XX|1993|   3| 1.0|
+    |   A|  XX|1994|   4| 9.0|
+    |   A|  XX|1995|   7| 5.0|
+    |   A|  XX|1996|   6| 8.0|
+    |   A|  YY|1993|   9| 3.0|
+    |   A|  YY|1994|   5| 4.0|
+    |   A|  YY|1995|  10| 2.0|
+    |   A|  YY|1996|   2| 7.0|
+    +----+----+----+----+----+
+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds2", ds2, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := last_value ( ds2 over ( partition by Id_1 order by Id_2 data points between 2 preceding and 2 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+---------+---------+
+    |Id_1|Id_2|Year|Me_1|Me_2|last_Me_1|last_Me_2|
+    +----+----+----+----+----+---------+---------+
+    |   A|  XX|1993|   3| 1.0|        7|      5.0|
+    |   A|  XX|1994|   4| 9.0|        6|      8.0|
+    |   A|  XX|1995|   7| 5.0|        9|      3.0|
+    |   A|  XX|1996|   6| 8.0|        5|      4.0|
+    |   A|  YY|1993|   9| 3.0|       10|      2.0|
+    |   A|  YY|1994|   5| 4.0|        2|      7.0|
+    |   A|  YY|1995|  10| 2.0|        2|      7.0|
+    |   A|  YY|1996|   2| 7.0|        2|      7.0|
+    +----+----+----+----+----+---------+---------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1993L, "Me_1", 7L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1994L, "Me_1", 6L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1995L, "Me_1", 9L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1996L, "Me_1", 5L, "Me_2", 4.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1993L, "Me_1", 10L, "Me_2", 2.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1994L, "Me_1", 2L, "Me_2", 7.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1995L, "Me_1", 2L, "Me_2", 7.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1996L, "Me_1", 2L, "Me_2", 7.0D));
+  }
+
+  @Test
+  public void testAnLastPartitionOrderByRangeClause() throws ScriptException {
+
+    // Analytical function Test case 4 : last on window with partition, order by and range
+    /* Input dataset
+    +----+----+----+----+----+
+    |Id_1|Id_2|Year|Me_1|Me_2|
+    +----+----+----+----+----+
+    |   A|  XX|1993|   3| 1.0|
+    |   A|  XX|1994|   4| 9.0|
+    |   A|  XX|1995|   7| 5.0|
+    |   A|  XX|1996|   6| 8.0|
+    |   A|  YY|1993|   9| 3.0|
+    |   A|  YY|1994|   5| 4.0|
+    |   A|  YY|1995|  10| 2.0|
+    |   A|  YY|1996|   2| 7.0|
+    +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds2", ds2, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := last_value ( ds2 over ( partition by Id_1, Id_2 order by Year range between 1 preceding and 1 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+---------+---------+
+    |Id_1|Id_2|Year|Me_1|Me_2|last_Me_1|last_Me_2|
+    +----+----+----+----+----+---------+---------+
+    |   A|  XX|1993|   3| 1.0|        4|      9.0|
+    |   A|  XX|1994|   4| 9.0|        7|      5.0|
+    |   A|  XX|1995|   7| 5.0|        6|      8.0|
+    |   A|  XX|1996|   6| 8.0|        6|      8.0|
+    |   A|  YY|1993|   9| 3.0|        5|      4.0|
+    |   A|  YY|1994|   5| 4.0|       10|      2.0|
+    |   A|  YY|1995|  10| 2.0|        2|      7.0|
+    |   A|  YY|1996|   2| 7.0|        2|      7.0|
+    +----+----+----+----+----+---------+---------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactlyInAnyOrder(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1993L, "Me_1", 4L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1994L, "Me_1", 7L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1995L, "Me_1", 6L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1996L, "Me_1", 6L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1993L, "Me_1", 5L, "Me_2", 4.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1994L, "Me_1", 10L, "Me_2", 2.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1995L, "Me_1", 2L, "Me_2", 7.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1996L, "Me_1", 2L, "Me_2", 7.0D));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticLeadTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticLeadTest.java
new file mode 100644
index 000000000..5a71e462b
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticLeadTest.java
@@ -0,0 +1,237 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.model.Dataset;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.script.ScriptContext;
+import javax.script.ScriptException;
+import org.junit.jupiter.api.Test;
+
+public class AnalyticLeadTest extends AnalyticTest {
+
+  @Test
+  public void testAnLeadWithCalcClause() throws ScriptException {
+
+    // Analytical function Test case 1 : lead on window with partition, order by and range
+    /* Input dataset
+    +----+----+----+----+----+
+    |Id_1|Id_2|Year|Me_1|Me_2|
+    +----+----+----+----+----+
+    |   A|  XX|1993|   3| 1.0|
+    |   A|  XX|1994|   4| 9.0|
+    |   A|  XX|1995|   7| 5.0|
+    |   A|  XX|1996|   6| 8.0|
+    |   A|  YY|1993|   9| 3.0|
+    |   A|  YY|1994|   5| 4.0|
+    |   A|  YY|1995|  10| 2.0|
+    |   A|  YY|1996|   2| 7.0|
+    +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds2", ds2, ScriptContext.ENGINE_SCOPE);
+    engine.eval(
+        "res := ds2 [ calc lead_Me_1 := lead ( Me_1 , 1 over ( partition by Id_1 , Id_2 order by Year ) )] ;");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+---------+
+    |Id_1|Id_2|Year|Me_1|Me_2|lead_Me_1|
+    +----+----+----+----+----+---------+
+    |   A|  XX|1993|   3| 1.0|        4|
+    |   A|  XX|1994|   4| 9.0|        7|
+    |   A|  XX|1995|   7| 5.0|        6|
+    |   A|  XX|1996|   6| 8.0|     null|
+    |   A|  YY|1993|   9| 3.0|        5|
+    |   A|  YY|1994|   5| 4.0|       10|
+    |   A|  YY|1995|  10| 2.0|        2|
+    |   A|  YY|1996|   2| 7.0|     null|
+    +----+----+----+----+----+---------+
+    * */
+
+    List<Map<String, Object>> actualWithNull =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    List<Map<String, Object>> actual = new ArrayList<>();
+    for (Map<String, Object> map : actualWithNull) {
+      actual.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+
+    assertThat(actual)
+        .containsExactly(
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                1993L,
+                "Me_1",
+                3L,
+                "Me_2",
+                1.0D,
+                "lead_Me_1",
+                4L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                1994L,
+                "Me_1",
+                4L,
+                "Me_2",
+                9.0D,
+                "lead_Me_1",
+                7L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                1995L,
+                "Me_1",
+                7L,
+                "Me_2",
+                5.0D,
+                "lead_Me_1",
+                6L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                1996L,
+                "Me_1",
+                6L,
+                "Me_2",
+                8.0D,
+                "lead_Me_1",
+                "null"),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                1993L,
+                "Me_1",
+                9L,
+                "Me_2",
+                3.0D,
+                "lead_Me_1",
+                5L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                1994L,
+                "Me_1",
+                5L,
+                "Me_2",
+                4.0D,
+                "lead_Me_1",
+                10L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                1995L,
+                "Me_1",
+                10L,
+                "Me_2",
+                2.0D,
+                "lead_Me_1",
+                2L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                1996L,
+                "Me_1",
+                2L,
+                "Me_2",
+                7.0D,
+                "lead_Me_1",
+                "null"));
+  }
+
+  /*
+   * Test case for analytic function lead
+   * The lead function take two argument:
+   * - input dataframe
+   * - step
+   * Analytic clause restriction:
+   * - Must have orderClause
+   * - The windowClause such as data points and range are not allowed
+   * */
+
+  @Test
+  public void testAnLead() throws ScriptException {
+
+    // Analytical function Test case 1 : lead on window with partition, order by and range
+    /* Input dataset
+    +----+----+----+----+----+
+    |Id_1|Id_2|Year|Me_1|Me_2|
+    +----+----+----+----+----+
+    |   A|  XX|1993|   3| 1.0|
+    |   A|  XX|1994|   4| 9.0|
+    |   A|  XX|1995|   7| 5.0|
+    |   A|  XX|1996|   6| 8.0|
+    |   A|  YY|1993|   9| 3.0|
+    |   A|  YY|1994|   5| 4.0|
+    |   A|  YY|1995|  10| 2.0|
+    |   A|  YY|1996|   2| 7.0|
+    +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds2", ds2, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := lead ( ds2 , 1 over ( partition by Id_1 , Id_2 order by Year ) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+---------+---------+
+    |Id_1|Id_2|Year|Me_1|Me_2|lead_Me_1|lead_Me_2|
+    +----+----+----+----+----+---------+---------+
+    |   A|  XX|1993|   3| 1.0|        4|      9.0|
+    |   A|  XX|1994|   4| 9.0|        7|      5.0|
+    |   A|  XX|1995|   7| 5.0|        6|      8.0|
+    |   A|  XX|1996|   6| 8.0|     null|     null|
+    |   A|  YY|1993|   9| 3.0|        5|      4.0|
+    |   A|  YY|1994|   5| 4.0|       10|      2.0|
+    |   A|  YY|1995|  10| 2.0|        2|      7.0|
+    |   A|  YY|1996|   2| 7.0|     null|     null|
+    +----+----+----+----+----+---------+---------+
+    * */
+    var actual =
+        ((Dataset) engine.getContext().getAttribute("res"))
+            .getDataAsMap().stream()
+                .map(map -> replaceNullValues(map, DEFAULT_NULL_STR))
+                .collect(Collectors.toList());
+    assertThat(actual)
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1993L, "Me_1", 4L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1994L, "Me_1", 7L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1995L, "Me_1", 6L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 1996L, "Me_1", "null", "Me_2", "null"),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1993L, "Me_1", 5L, "Me_2", 4.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1994L, "Me_1", 10L, "Me_2", 2.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1995L, "Me_1", 2L, "Me_2", 7.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 1996L, "Me_1", "null", "Me_2", "null"));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticMaxTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticMaxTest.java
new file mode 100644
index 000000000..e776ca0ca
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticMaxTest.java
@@ -0,0 +1,369 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class AnalyticMaxTest {
+
+  private final InMemoryDataset anCountDS1 =
+      new InMemoryDataset(
+          List.of(
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 9D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 7L, "Me_2", 5D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 6L, "Me_2", 8D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 9L, "Me_2", 3D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 4D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 10L, "Me_2", 2D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5L, "Me_2", 7D)),
+          Map.of(
+              "Id_1",
+              String.class,
+              "Id_2",
+              String.class,
+              "Year",
+              Long.class,
+              "Me_1",
+              Long.class,
+              "Me_2",
+              Double.class),
+          Map.of(
+              "Id_1",
+              Dataset.Role.IDENTIFIER,
+              "Id_2",
+              Dataset.Role.IDENTIFIER,
+              "Year",
+              Dataset.Role.IDENTIFIER,
+              "Me_1",
+              Dataset.Role.MEASURE,
+              "Me_2",
+              Dataset.Role.MEASURE));
+
+  private static SparkSession spark;
+  private static ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterAll
+  public static void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testAnMaxWithCalcClause() throws ScriptException {
+
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := ds1 [ calc max_Me_1:= max ( Me_1 over ( partition by Id_1,Id_2 order by Year) )];");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+--------+
+    |Id_1|Id_2|Year|Me_1|Me_2|max_Me_1|
+    +----+----+----+----+----+--------+
+    |   A|  XX|2000|   3| 1.0|       3|
+    |   A|  XX|2001|   4| 9.0|       4|
+    |   A|  XX|2002|   7| 5.0|       7|
+    |   A|  XX|2003|   6| 8.0|       7|
+    |   A|  YY|2000|   9| 3.0|       9|
+    |   A|  YY|2001|   5| 4.0|       9|
+    |   A|  YY|2002|  10| 2.0|      10|
+    |   A|  YY|2003|   5| 7.0|      10|
+    +----+----+----+----+----+--------+
+    * */
+    List<Map<String, Object>> actual =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    assertThat(actual)
+        .containsExactly(
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1.0D, "max_Me_1", 3L),
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 9.0D, "max_Me_1", 4L),
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 7L, "Me_2", 5.0D, "max_Me_1", 7L),
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 6L, "Me_2", 8.0D, "max_Me_1", 7L),
+            Map.of(
+                "Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 9L, "Me_2", 3.0D, "max_Me_1", 9L),
+            Map.of(
+                "Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 4.0D, "max_Me_1", 9L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2002L,
+                "Me_1",
+                10L,
+                "Me_2",
+                2.0D,
+                "max_Me_1",
+                10L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2003L,
+                "Me_1",
+                5L,
+                "Me_2",
+                7.0D,
+                "max_Me_1",
+                10L));
+  }
+
+  @Test
+  public void testAnMaxWithPartitionClause() throws ScriptException {
+
+    // Analytical function Test case 1 : max on window with partition
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := max ( ds1 over ( partition by Id_1, Id_2 ) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|max_Me_1|max_Me_2|
+        +----+----+----+----+----+--------+--------+
+        |   A|  XX|2000|   3| 1.0|       7|     9.0|
+        |   A|  XX|2001|   4| 9.0|       7|     9.0|
+        |   A|  XX|2002|   7| 5.0|       7|     9.0|
+        |   A|  XX|2003|   6| 8.0|       7|     9.0|
+        |   A|  YY|2000|   9| 3.0|      10|     7.0|
+        |   A|  YY|2001|   5| 4.0|      10|     7.0|
+        |   A|  YY|2002|  10| 2.0|      10|     7.0|
+        |   A|  YY|2003|   5| 7.0|      10|     7.0|
+        +----+----+----+----+----+--------+--------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 7L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 7L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 7L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 7L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 10L, "Me_2", 7.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 10L, "Me_2", 7.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 10L, "Me_2", 7.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 10L, "Me_2", 7.0D));
+  }
+
+  @Test
+  public void testAnMaxWithPartitionOrderByClause() throws ScriptException {
+
+    // Analytical function Test case 2 : max on window with partition and order by
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := max ( ds1 over ( partition by Id_1, Id_2 order by Year) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|max_Me_1|max_Me_2|
+        +----+----+----+----+----+--------+--------+
+        |   A|  XX|2000|   3| 1.0|       3|     1.0|
+        |   A|  XX|2001|   4| 9.0|       4|     9.0|
+        |   A|  XX|2002|   7| 5.0|       7|     9.0|
+        |   A|  XX|2003|   6| 8.0|       7|     9.0|
+        |   A|  YY|2000|   9| 3.0|       9|     3.0|
+        |   A|  YY|2001|   5| 4.0|       9|     4.0|
+        |   A|  YY|2002|  10| 2.0|      10|     4.0|
+        |   A|  YY|2003|   5| 7.0|      10|     7.0|
+        +----+----+----+----+----+--------+--------+
+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 7L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 7L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 9L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 9L, "Me_2", 4.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 10L, "Me_2", 4.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 10L, "Me_2", 7.0D));
+  }
+
+  @Test
+  public void testAnMaxWithPartitionOrderByDPClause() throws ScriptException {
+
+    // Analytical function count test case 3 : max on window with partition, orderBy and data points
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := max ( ds1 over ( partition by Id_1 order by Id_2 data points between 2 preceding and 2 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|max_Me_1|max_Me_2|
+        +----+----+----+----+----+--------+--------+
+        |   A|  XX|2000|   3| 1.0|       7|     9.0|
+        |   A|  XX|2001|   4| 9.0|       7|     9.0|
+        |   A|  XX|2002|   7| 5.0|       9|     9.0|
+        |   A|  XX|2003|   6| 8.0|       9|     9.0|
+        |   A|  YY|2000|   9| 3.0|      10|     8.0|
+        |   A|  YY|2001|   5| 4.0|      10|     8.0|
+        |   A|  YY|2002|  10| 2.0|      10|     7.0|
+        |   A|  YY|2003|   5| 7.0|      10|     7.0|
+        +----+----+----+----+----+--------+--------+
+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 7L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 7L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 9L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 9L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 10L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 10L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 10L, "Me_2", 7.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 10L, "Me_2", 7.0D));
+  }
+
+  @Test
+  public void testAnMaxWithPartitionOrderByRangeClause() throws ScriptException {
+
+    // Analytical function count test case 5 : max on window with partition, orderBy and range
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := max ( ds1 over ( partition by Id_1 order by Year range between 1 preceding and 1 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|max_Me_1|max_Me_2|
+        +----+----+----+----+----+--------+--------+
+        |   A|  XX|2000|   3| 1.0|       9|     9.0|
+        |   A|  YY|2000|   9| 3.0|       9|     9.0|
+        |   A|  XX|2001|   4| 9.0|      10|     9.0|
+        |   A|  YY|2001|   5| 4.0|      10|     9.0|
+        |   A|  XX|2002|   7| 5.0|      10|     9.0|
+        |   A|  YY|2002|  10| 2.0|      10|     9.0|
+        |   A|  XX|2003|   6| 8.0|      10|     8.0|
+        |   A|  YY|2003|   5| 7.0|      10|     8.0|
+        +----+----+----+----+----+--------+--------+
+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactlyInAnyOrder(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 9L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 9L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 10L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 10L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 10L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 10L, "Me_2", 9.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 10L, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 10L, "Me_2", 8.0D));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticMedianTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticMedianTest.java
new file mode 100644
index 000000000..3762d5987
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticMedianTest.java
@@ -0,0 +1,435 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class AnalyticMedianTest {
+
+  private final InMemoryDataset anCountDS1 =
+      new InMemoryDataset(
+          List.of(
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 9D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 7L, "Me_2", 5D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 6L, "Me_2", 8D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 9L, "Me_2", 3D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 4D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 10L, "Me_2", 2D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5L, "Me_2", 7D)),
+          Map.of(
+              "Id_1",
+              String.class,
+              "Id_2",
+              String.class,
+              "Year",
+              Long.class,
+              "Me_1",
+              Long.class,
+              "Me_2",
+              Double.class),
+          Map.of(
+              "Id_1",
+              Dataset.Role.IDENTIFIER,
+              "Id_2",
+              Dataset.Role.IDENTIFIER,
+              "Year",
+              Dataset.Role.IDENTIFIER,
+              "Me_1",
+              Dataset.Role.MEASURE,
+              "Me_2",
+              Dataset.Role.MEASURE));
+
+  private static SparkSession spark;
+  private static ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterAll
+  public static void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testAnMedianWithCalcClause() throws ScriptException {
+
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := ds1 [ calc median_Me_1:= median ( Me_1 over ( partition by Id_1,Id_2 order by Year) )];");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    +----+----+----+----+----+-----------+
+    |Id_1|Id_2|Year|Me_1|Me_2|median_Me_1|
+    +----+----+----+----+----+-----------+
+    |   A|  XX|2000|   3| 1.0|          3|
+    |   A|  XX|2001|   4| 9.0|          3|
+    |   A|  XX|2002|   7| 5.0|          4|
+    |   A|  XX|2003|   6| 8.0|          4|
+    |   A|  YY|2000|   9| 3.0|          9|
+    |   A|  YY|2001|   5| 4.0|          5|
+    |   A|  YY|2002|  10| 2.0|          9|
+    |   A|  YY|2003|   5| 7.0|          5|
+    +----+----+----+----+----+-----------+
+    * */
+    List<Map<String, Object>> actual =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    assertThat(actual)
+        .containsExactly(
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2000L,
+                "Me_1",
+                3L,
+                "Me_2",
+                1.0D,
+                "median_Me_1",
+                3L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2001L,
+                "Me_1",
+                4L,
+                "Me_2",
+                9.0D,
+                "median_Me_1",
+                3L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2002L,
+                "Me_1",
+                7L,
+                "Me_2",
+                5.0D,
+                "median_Me_1",
+                4L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2003L,
+                "Me_1",
+                6L,
+                "Me_2",
+                8.0D,
+                "median_Me_1",
+                4L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2000L,
+                "Me_1",
+                9L,
+                "Me_2",
+                3.0D,
+                "median_Me_1",
+                9L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2001L,
+                "Me_1",
+                5L,
+                "Me_2",
+                4.0D,
+                "median_Me_1",
+                5L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2002L,
+                "Me_1",
+                10L,
+                "Me_2",
+                2.0D,
+                "median_Me_1",
+                9L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2003L,
+                "Me_1",
+                5L,
+                "Me_2",
+                7.0D,
+                "median_Me_1",
+                5L));
+  }
+
+  @Test
+  public void testAnMedianWithPartitionClause() throws ScriptException {
+
+    // Analytical function Test case 1 : median on window with partition
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := median ( ds1 over ( partition by Id_1, Id_2 ) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|median_Me_1|median_Me_2|
+        +----+----+----+----+----+-----------+-----------+
+        |   A|  XX|2000|   3| 1.0|          4|        5.0|
+        |   A|  XX|2001|   4| 9.0|          4|        5.0|
+        |   A|  XX|2002|   7| 5.0|          4|        5.0|
+        |   A|  XX|2003|   6| 8.0|          4|        5.0|
+        |   A|  YY|2000|   9| 3.0|          5|        3.0|
+        |   A|  YY|2001|   5| 4.0|          5|        3.0|
+        |   A|  YY|2002|  10| 2.0|          5|        3.0|
+        |   A|  YY|2003|   5| 7.0|          5|        3.0|
+        +----+----+----+----+----+-----------+-----------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 4L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 4L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 4L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 5L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 5L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5L, "Me_2", 3.0D));
+  }
+
+  @Test
+  public void testAnMedianWithPartitionOrderByClause() throws ScriptException {
+
+    // Analytical function Test case 2 : median on window with partition and order by
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := median ( ds1 over ( partition by Id_1, Id_2 order by Year) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|median_Me_1|median_Me_2|
+        +----+----+----+----+----+-----------+-----------+
+        |   A|  XX|2000|   3| 1.0|          3|        1.0|
+        |   A|  XX|2001|   4| 9.0|          3|        1.0|
+        |   A|  XX|2002|   7| 5.0|          4|        5.0|
+        |   A|  XX|2003|   6| 8.0|          4|        5.0|
+        |   A|  YY|2000|   9| 3.0|          9|        3.0|
+        |   A|  YY|2001|   5| 4.0|          5|        3.0|
+        |   A|  YY|2002|  10| 2.0|          9|        3.0|
+        |   A|  YY|2003|   5| 7.0|          5|        3.0|
+        +----+----+----+----+----+-----------+-----------+
+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 4L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 4L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 9L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 9L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5L, "Me_2", 3.0D));
+  }
+
+  @Test
+  public void testAnMedianWithPartitionOrderByDPClause() throws ScriptException {
+
+    // Analytical function count test case 3 : median on window with partition, orderBy and data
+    // points
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := median ( ds1 over ( partition by Id_1 order by Id_2 data points between 2 preceding and 2 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|median_Me_1|median_Me_2|
+        +----+----+----+----+----+-----------+-----------+
+        |   A|  XX|2000|   3| 1.0|          4|        5.0|
+        |   A|  XX|2001|   4| 9.0|          4|        5.0|
+        |   A|  XX|2002|   7| 5.0|          6|        5.0|
+        |   A|  XX|2003|   6| 8.0|          6|        5.0|
+        |   A|  YY|2000|   9| 3.0|          7|        4.0|
+        |   A|  YY|2001|   5| 4.0|          6|        4.0|
+        |   A|  YY|2002|  10| 2.0|          5|        3.0|
+        |   A|  YY|2003|   5| 7.0|          5|        4.0|
+        +----+----+----+----+----+-----------+-----------+
+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 4L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 6L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 6L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 7L, "Me_2", 4.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 6L, "Me_2", 4.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 5L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5L, "Me_2", 4.0D));
+  }
+
+  @Test
+  public void testAnMedianWithPartitionOrderByRangeClause() throws ScriptException {
+
+    // Analytical function count test case 4 : median on window with partition, orderBy and range
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := median ( ds1 over ( partition by Id_1 order by Year range between 1 preceding and 1 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|median_Me_1|median_Me_2|
+        +----+----+----+----+----+-----------+-----------+
+        |   A|  XX|2000|   3| 1.0|          4|        3.0|
+        |   A|  YY|2000|   9| 3.0|          4|        3.0|
+        |   A|  XX|2001|   4| 9.0|          5|        3.0|
+        |   A|  YY|2001|   5| 4.0|          5|        3.0|
+        |   A|  XX|2002|   7| 5.0|          5|        5.0|
+        |   A|  YY|2002|  10| 2.0|          5|        5.0|
+        |   A|  XX|2003|   6| 8.0|          6|        5.0|
+        |   A|  YY|2003|   5| 7.0|          6|        5.0|
+        +----+----+----+----+----+-----------+-----------+
+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactlyInAnyOrder(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 4L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 4L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 5L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 5L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 5L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 6L, "Me_2", 5.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 6L, "Me_2", 5.0D));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticMinTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticMinTest.java
new file mode 100644
index 000000000..ab98b50bd
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticMinTest.java
@@ -0,0 +1,421 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class AnalyticMinTest {
+
+  private final InMemoryDataset anCountDS1 =
+      new InMemoryDataset(
+          List.of(
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 9D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 7L, "Me_2", 5D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 6L, "Me_2", 8D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 9L, "Me_2", 3D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 4D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 10L, "Me_2", 2D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5L, "Me_2", 7D)),
+          Map.of(
+              "Id_1",
+              String.class,
+              "Id_2",
+              String.class,
+              "Year",
+              Long.class,
+              "Me_1",
+              Long.class,
+              "Me_2",
+              Double.class),
+          Map.of(
+              "Id_1",
+              Dataset.Role.IDENTIFIER,
+              "Id_2",
+              Dataset.Role.IDENTIFIER,
+              "Year",
+              Dataset.Role.IDENTIFIER,
+              "Me_1",
+              Dataset.Role.MEASURE,
+              "Me_2",
+              Dataset.Role.MEASURE));
+
+  private static SparkSession spark;
+  private static ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterAll
+  public static void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testAnMinWithCalcClause() throws ScriptException {
+
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := ds1 [ calc min_Me_1:= min ( Me_1 over ( partition by Id_1,Id_2 order by Year) )];");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+--------+
+    |Id_1|Id_2|Year|Me_1|Me_2|min_Me_1|
+    +----+----+----+----+----+--------+
+    |   A|  XX|2000|   3| 1.0|       3|
+    |   A|  XX|2001|   4| 9.0|       3|
+    |   A|  XX|2002|   7| 5.0|       3|
+    |   A|  XX|2003|   6| 8.0|       3|
+    |   A|  YY|2000|   9| 3.0|       9|
+    |   A|  YY|2001|   5| 4.0|       5|
+    |   A|  YY|2002|  10| 2.0|       5|
+    |   A|  YY|2003|   5| 7.0|       5|
+    +----+----+----+----+----+--------+
+    * */
+    List<Map<String, Object>> actual =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    assertThat(actual)
+        .containsExactly(
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1.0D, "min_Me_1", 3L),
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 9.0D, "min_Me_1", 3L),
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 7L, "Me_2", 5.0D, "min_Me_1", 3L),
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 6L, "Me_2", 8.0D, "min_Me_1", 3L),
+            Map.of(
+                "Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 9L, "Me_2", 3.0D, "min_Me_1", 9L),
+            Map.of(
+                "Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 4.0D, "min_Me_1", 5L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2002L,
+                "Me_1",
+                10L,
+                "Me_2",
+                2.0D,
+                "min_Me_1",
+                5L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2003L,
+                "Me_1",
+                5L,
+                "Me_2",
+                7.0D,
+                "min_Me_1",
+                5L));
+  }
+
+  @Test
+  public void testAnMinWithPartitionClause() throws ScriptException {
+
+    // Analytical function Test case 1 : min on window with partition
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := min ( ds1 over ( partition by Id_1, Id_2 ) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|min_Me_1|min_Me_2|
+        +----+----+----+----+----+--------+--------+
+        |   A|  XX|2000|   3| 1.0|       3|     1.0|
+        |   A|  XX|2001|   4| 9.0|       3|     1.0|
+        |   A|  XX|2002|   7| 5.0|       3|     1.0|
+        |   A|  XX|2003|   6| 8.0|       3|     1.0|
+        |   A|  YY|2000|   9| 3.0|       5|     2.0|
+        |   A|  YY|2001|   5| 4.0|       5|     2.0|
+        |   A|  YY|2002|  10| 2.0|       5|     2.0|
+        |   A|  YY|2003|   5| 7.0|       5|     2.0|
+        +----+----+----+----+----+--------+--------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 5L, "Me_2", 2.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 2.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 5L, "Me_2", 2.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5L, "Me_2", 2.0D));
+  }
+
+  @Test
+  public void testAnMinWithPartitionOrderByClause() throws ScriptException {
+
+    // Analytical function Test case 2 : min on window with partition and order by
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := min ( ds1 over ( partition by Id_1, Id_2 order by Year) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|min_Me_1|min_Me_2|
+        +----+----+----+----+----+--------+--------+
+        |   A|  XX|2000|   3| 1.0|       3|     1.0|
+        |   A|  XX|2001|   4| 9.0|       3|     1.0|
+        |   A|  XX|2002|   7| 5.0|       3|     1.0|
+        |   A|  XX|2003|   6| 8.0|       3|     1.0|
+        |   A|  YY|2000|   9| 3.0|       9|     3.0|
+        |   A|  YY|2001|   5| 4.0|       5|     3.0|
+        |   A|  YY|2002|  10| 2.0|       5|     2.0|
+        |   A|  YY|2003|   5| 7.0|       5|     2.0|
+        +----+----+----+----+----+--------+--------+
+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 9L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 5L, "Me_2", 2.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5L, "Me_2", 2.0D));
+  }
+
+  @Test
+  public void testAnMinWithOrderByClause() throws ScriptException {
+
+    // Analytical function Test case 3 : min on window with only order by without partition
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := min ( ds1 over ( order by Id_1, Id_2, Year ) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|min_Me_1|min_Me_2|
+        +----+----+----+----+----+--------+--------+
+        |   A|  XX|2000|   3| 1.0|       3|     1.0|
+        |   A|  XX|2001|   4| 9.0|       3|     1.0|
+        |   A|  XX|2002|   7| 5.0|       3|     1.0|
+        |   A|  XX|2003|   6| 8.0|       3|     1.0|
+        |   A|  YY|2000|   9| 3.0|       3|     1.0|
+        |   A|  YY|2001|   5| 4.0|       3|     1.0|
+        |   A|  YY|2002|  10| 2.0|       3|     1.0|
+        |   A|  YY|2003|   5| 7.0|       3|     1.0|
+        +----+----+----+----+----+--------+--------+
+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 3L, "Me_2", 1.0D));
+  }
+
+  @Test
+  public void testAnMinWithPartitionOrderByDPClause() throws ScriptException {
+
+    // Analytical function count test case 4 : min on window with partition, orderBy and data points
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := min ( ds1 over ( partition by Id_1 order by Id_2 data points between 2 preceding and 2 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|min_Me_1|min_Me_2|
+        +----+----+----+----+----+--------+--------+
+        |   A|  XX|2000|   3| 1.0|       3|     1.0|
+        |   A|  XX|2001|   4| 9.0|       3|     1.0|
+        |   A|  XX|2002|   7| 5.0|       3|     1.0|
+        |   A|  XX|2003|   6| 8.0|       4|     3.0|
+        |   A|  YY|2000|   9| 3.0|       5|     2.0|
+        |   A|  YY|2001|   5| 4.0|       5|     2.0|
+        |   A|  YY|2002|  10| 2.0|       5|     2.0|
+        |   A|  YY|2003|   5| 7.0|       5|     2.0|
+        +----+----+----+----+----+--------+--------+
+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 4L, "Me_2", 3.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 5L, "Me_2", 2.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 2.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 5L, "Me_2", 2.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5L, "Me_2", 2.0D));
+  }
+
+  @Test
+  public void testAnMinWithPartitionOrderByRangeClause() throws ScriptException {
+
+    // Analytical function count test case 5 : min on window with partition, orderBy and range
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := min ( ds1 over ( partition by Id_1 order by Year range between 1 preceding and 1 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|min_Me_1|min_Me_2|
+        +----+----+----+----+----+--------+--------+
+        |   A|  XX|2000|   3| 1.0|       3|     1.0|
+        |   A|  YY|2000|   9| 3.0|       3|     1.0|
+        |   A|  XX|2001|   4| 9.0|       3|     1.0|
+        |   A|  YY|2001|   5| 4.0|       3|     1.0|
+        |   A|  XX|2002|   7| 5.0|       4|     2.0|
+        |   A|  YY|2002|  10| 2.0|       4|     2.0|
+        |   A|  XX|2003|   6| 8.0|       5|     2.0|
+        |   A|  YY|2003|   5| 7.0|       5|     2.0|
+        +----+----+----+----+----+--------+--------+
+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactlyInAnyOrder(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 4L, "Me_2", 2.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 4L, "Me_2", 2.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 5L, "Me_2", 2.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5L, "Me_2", 2.0D));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticRankTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticRankTest.java
new file mode 100644
index 000000000..d0bddfd70
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticRankTest.java
@@ -0,0 +1,184 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.model.Dataset;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptException;
+import org.junit.jupiter.api.Test;
+
+public class AnalyticRankTest extends AnalyticTest {
+
+  /*
+   * Test case for analytic function rank
+   *  ** rank analytic clause restriction**
+   *  - Must have `orderClause`
+   * - The `windowClause` such as `data points` and `range` are not allowed
+   * */
+  @Test
+  public void testAnRankAscClause() throws ScriptException {
+
+    // Analytical function Test case 1 : rank on window with partition and asc order
+    /* Input dataset
+    +----+----+----+----+----+
+    |Id_1|Id_2|Year|Me_1|Me_2|
+    +----+----+----+----+----+
+    |   A|  XX|1993|   3| 1.0|
+    |   A|  XX|1994|   4| 9.0|
+    |   A|  XX|1995|   7| 5.0|
+    |   A|  XX|1996|   6| 8.0|
+    |   A|  YY|1993|   9| 3.0|
+    |   A|  YY|1994|   5| 4.0|
+    |   A|  YY|1995|  10| 2.0|
+    |   A|  YY|1996|   2| 7.0|
+    +----+----+----+----+----+
+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds2", ds2, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := ds2 [calc rank_col := rank ( over ( partition by Id_1, Id_2 order by Year) )];");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+--------+
+    |Id_1|Id_2|Year|Me_1|Me_2|rank_col|
+    +----+----+----+----+----+--------+
+    |   A|  XX|1993|   3| 1.0|       1|
+    |   A|  XX|1994|   4| 9.0|       2|
+    |   A|  XX|1995|   7| 5.0|       3|
+    |   A|  XX|1996|   6| 8.0|       4|
+    |   A|  YY|1993|   9| 3.0|       1|
+    |   A|  YY|1994|   5| 4.0|       2|
+    |   A|  YY|1995|  10| 2.0|       3|
+    |   A|  YY|1996|   2| 7.0|       4|
+    +----+----+----+----+----+--------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 1993L, "Me_1", 3L, "Me_2", 1.0D, "rank_col", 1L),
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 1994L, "Me_1", 4L, "Me_2", 9.0D, "rank_col", 2L),
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 1995L, "Me_1", 7L, "Me_2", 5.0D, "rank_col", 3L),
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 1996L, "Me_1", 6L, "Me_2", 8.0D, "rank_col", 4L),
+            Map.of(
+                "Id_1", "A", "Id_2", "YY", "Year", 1993L, "Me_1", 9L, "Me_2", 3.0D, "rank_col", 1L),
+            Map.of(
+                "Id_1", "A", "Id_2", "YY", "Year", 1994L, "Me_1", 5L, "Me_2", 4.0D, "rank_col", 2L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                1995L,
+                "Me_1",
+                10L,
+                "Me_2",
+                2.0D,
+                "rank_col",
+                3L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                1996L,
+                "Me_1",
+                2L,
+                "Me_2",
+                7.0D,
+                "rank_col",
+                4L));
+  }
+
+  @Test
+  public void testAnRankDesc() throws ScriptException {
+
+    // Analytical function Test case 2 : rank on window with partition and desc order
+    /* Input dataset
+    +----+----+----+----+----+
+    |Id_1|Id_2|Year|Me_1|Me_2|
+    +----+----+----+----+----+
+    |   A|  XX|1993|   3| 1.0|
+    |   A|  XX|1994|   4| 9.0|
+    |   A|  XX|1995|   7| 5.0|
+    |   A|  XX|1996|   6| 8.0|
+    |   A|  YY|1993|   9| 3.0|
+    |   A|  YY|1994|   5| 4.0|
+    |   A|  YY|1995|  10| 2.0|
+    |   A|  YY|1996|   2| 7.0|
+    +----+----+----+----+----+
+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds2", ds2, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := ds2 [calc rank_col:= rank ( over ( partition by Id_1, Id_2 order by Year desc) )];");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+--------+
+    |Id_1|Id_2|Year|Me_1|Me_2|rank_col|
+    +----+----+----+----+----+--------+
+    |   A|  XX|1996|   6| 8.0|       1|
+    |   A|  XX|1995|   7| 5.0|       2|
+    |   A|  XX|1994|   4| 9.0|       3|
+    |   A|  XX|1993|   3| 1.0|       4|
+    |   A|  YY|1996|   2| 7.0|       1|
+    |   A|  YY|1995|  10| 2.0|       2|
+    |   A|  YY|1994|   5| 4.0|       3|
+    |   A|  YY|1993|   9| 3.0|       4|
+    +----+----+----+----+----+--------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 1996L, "Me_1", 6L, "Me_2", 8.0D, "rank_col", 1L),
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 1995L, "Me_1", 7L, "Me_2", 5.0D, "rank_col", 2L),
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 1994L, "Me_1", 4L, "Me_2", 9.0D, "rank_col", 3L),
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 1993L, "Me_1", 3L, "Me_2", 1.0D, "rank_col", 4L),
+            Map.of(
+                "Id_1", "A", "Id_2", "YY", "Year", 1996L, "Me_1", 2L, "Me_2", 7.0D, "rank_col", 1L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                1995L,
+                "Me_1",
+                10L,
+                "Me_2",
+                2.0D,
+                "rank_col",
+                2L),
+            Map.of(
+                "Id_1", "A", "Id_2", "YY", "Year", 1994L, "Me_1", 5L, "Me_2", 4.0D, "rank_col", 3L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                1993L,
+                "Me_1",
+                9L,
+                "Me_2",
+                3.0D,
+                "rank_col",
+                4L));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticRatioToReportTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticRatioToReportTest.java
new file mode 100644
index 000000000..0adf4260f
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticRatioToReportTest.java
@@ -0,0 +1,283 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import java.util.List;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptException;
+import org.junit.jupiter.api.Test;
+
+public class AnalyticRatioToReportTest extends AnalyticTest {
+
+  @Test
+  public void testAnRatioToReportWithCalcClause() throws ScriptException {
+
+    InMemoryDataset anDS =
+        new InMemoryDataset(
+            List.of(
+                Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1D),
+                Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 3D),
+                Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 7L, "Me_2", 5D),
+                Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 6L, "Me_2", 1D),
+                Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 12L, "Me_2", 0D),
+                Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 8L, "Me_2", 8D),
+                Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 6L, "Me_2", 5D),
+                Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 14L, "Me_2", -3D)),
+            Map.of(
+                "Id_1",
+                String.class,
+                "Id_2",
+                String.class,
+                "Year",
+                Long.class,
+                "Me_1",
+                Long.class,
+                "Me_2",
+                Double.class),
+            Map.of(
+                "Id_1",
+                Dataset.Role.IDENTIFIER,
+                "Id_2",
+                Dataset.Role.IDENTIFIER,
+                "Year",
+                Dataset.Role.IDENTIFIER,
+                "Me_1",
+                Dataset.Role.MEASURE,
+                "Me_2",
+                Dataset.Role.MEASURE));
+    /* Input dataset
+    +----+----+----+----+----+
+    |Id_1|Id_2|Id_3|Me_1|Me_2|
+    +----+----+----+----+----+
+    |   A|  XX|2000|   3|   1|
+    |   A|  XX|2001|   4|   3|
+    |   A|  XX|2002|   7|   5|
+    |   A|  XX|2003|   6|   1|
+    |   A|  YY|2000|  12|   0|
+    |   A|  YY|2001|   8|   8|
+    |   A|  YY|2002|   6|   5|
+    |   A|  YY|2003|  14|  -3|
+    +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds", anDS, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res :=  ds  [ calc ratio_Me_1 := ratio_to_report ( Me_1 over ( partition by Id_1, Id_2 ) )];");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+----------+
+    |Id_1|Id_2|Id_3|Me_1|Me_2|ratio_Me_1|
+    +----+----+----+----+----+----------+
+    |   A|  XX|2000|   3|   1|      0.15|
+    |   A|  XX|2001|   4|   3|       0.2|
+    |   A|  XX|2002|   7|   5|      0.35|
+    |   A|  XX|2003|   6|   1|       0.3|
+    |   A|  YY|2000|  12|   0|       0.3|
+    |   A|  YY|2001|   8|   8|       0.2|
+    |   A|  YY|2002|   6|   5|      0.15|
+    |   A|  YY|2003|  14|  -3|      0.35|
+    +----+----+----+----+----+----------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2000L,
+                "Me_1",
+                3L,
+                "Me_2",
+                1.0D,
+                "ratio_Me_1",
+                0.15D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2001L,
+                "Me_1",
+                4L,
+                "Me_2",
+                3.0D,
+                "ratio_Me_1",
+                0.2D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2002L,
+                "Me_1",
+                7L,
+                "Me_2",
+                5.0D,
+                "ratio_Me_1",
+                0.35D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2003L,
+                "Me_1",
+                6L,
+                "Me_2",
+                1.0D,
+                "ratio_Me_1",
+                0.3D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2000L,
+                "Me_1",
+                12L,
+                "Me_2",
+                0.0D,
+                "ratio_Me_1",
+                0.3D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2001L,
+                "Me_1",
+                8L,
+                "Me_2",
+                8.0D,
+                "ratio_Me_1",
+                0.2D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2002L,
+                "Me_1",
+                6L,
+                "Me_2",
+                5.0D,
+                "ratio_Me_1",
+                0.15D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2003L,
+                "Me_1",
+                14L,
+                "Me_2",
+                -3.0D,
+                "ratio_Me_1",
+                0.35D));
+  }
+
+  /*
+   * Test case for analytic function ratio_to_report
+   * Analytic clause restriction:
+   * - The orderClause and windowClause of the Analytic invocation syntax are not allowed.
+   * */
+
+  @Test
+  public void testAnRatioToReport() throws ScriptException {
+
+    InMemoryDataset anDS =
+        new InMemoryDataset(
+            List.of(
+                Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1D),
+                Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 3D),
+                Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 7L, "Me_2", 5D),
+                Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 6L, "Me_2", 1D),
+                Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 12L, "Me_2", 0D),
+                Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 8L, "Me_2", 8D),
+                Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 6L, "Me_2", 5D),
+                Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 14L, "Me_2", -3D)),
+            Map.of(
+                "Id_1",
+                String.class,
+                "Id_2",
+                String.class,
+                "Year",
+                Long.class,
+                "Me_1",
+                Long.class,
+                "Me_2",
+                Double.class),
+            Map.of(
+                "Id_1",
+                Dataset.Role.IDENTIFIER,
+                "Id_2",
+                Dataset.Role.IDENTIFIER,
+                "Year",
+                Dataset.Role.IDENTIFIER,
+                "Me_1",
+                Dataset.Role.MEASURE,
+                "Me_2",
+                Dataset.Role.MEASURE));
+    /* Input dataset
+    +----+----+----+----+----+
+    |Id_1|Id_2|Id_3|Me_1|Me_2|
+    +----+----+----+----+----+
+    |   A|  XX|2000|   3|   1|
+    |   A|  XX|2001|   4|   3|
+    |   A|  XX|2002|   7|   5|
+    |   A|  XX|2003|   6|   1|
+    |   A|  YY|2000|  12|   0|
+    |   A|  YY|2001|   8|   8|
+    |   A|  YY|2002|   6|   5|
+    |   A|  YY|2003|  14|  -3|
+    +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds", anDS, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := ratio_to_report ( ds over ( partition by Id_1, Id_2 ) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+----------+----------+----------+----------+
+    |Id_1|Id_2|Id_3|Me_1|Me_2|total_Me_1|ratio_Me_1|total_Me_2|ratio_Me_2|
+    +----+----+----+----+----+----------+----------+----------+----------+
+    |   A|  XX|2000|   3|   1|        20|      0.15|        10|       0.1|
+    |   A|  XX|2001|   4|   3|        20|       0.2|        10|       0.3|
+    |   A|  XX|2002|   7|   5|        20|      0.35|        10|       0.5|
+    |   A|  XX|2003|   6|   1|        20|       0.3|        10|       0.1|
+    |   A|  YY|2000|  12|   0|        40|       0.3|        10|       0.0|
+    |   A|  YY|2001|   8|   8|        40|       0.2|        10|       0.8|
+    |   A|  YY|2002|   6|   5|        40|      0.15|        10|       0.5|
+    |   A|  YY|2003|  14|  -3|        40|      0.35|        10|      -0.3|
+    +----+----+----+----+----+----------+----------+----------+----------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 0.15D, "Me_2", 0.1D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 0.2D, "Me_2", 0.3D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 0.35D, "Me_2", 0.5D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 0.3D, "Me_2", 0.1D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 0.3D, "Me_2", 0.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 0.2D, "Me_2", 0.8D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 0.15D, "Me_2", 0.5D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 0.35D, "Me_2", -0.3D));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticStdPopTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticStdPopTest.java
new file mode 100644
index 000000000..67ee09d41
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticStdPopTest.java
@@ -0,0 +1,388 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.model.Dataset;
+import java.util.List;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptException;
+import org.junit.jupiter.api.Test;
+
+public class AnalyticStdPopTest extends AnalyticTest {
+
+  @Test
+  public void testAnStdPopWithCalcClause() throws ScriptException {
+
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", ds1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := ds1 [ calc stddev_pop_Me_1:= stddev_pop ( Me_1 over ( partition by Id_1,Id_2 order by Year) )];");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+------------------+
+    |Id_1|Id_2|Year|Me_1|Me_2|   stddev_pop_Me_1|
+    +----+----+----+----+----+------------------+
+    |   A|  XX|2000|   3| 1.0|               0.0|
+    |   A|  XX|2001|   4| 9.0|               0.5|
+    |   A|  XX|2002|   7| 5.0| 1.699673171197595|
+    |   A|  XX|2003|   6| 8.0|1.5811388300841895|
+    |   A|  YY|2000|   9| 3.0|               0.0|
+    |   A|  YY|2001|   5| 4.0|               2.0|
+    |   A|  YY|2002|  10| 2.0| 2.160246899469287|
+    |   A|  YY|2003|   5| 7.0| 2.277608394786075|
+    +----+----+----+----+----+------------------+
+    * */
+    List<Map<String, Object>> actual =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    assertThat(actual)
+        .containsExactly(
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2000L,
+                "Me_1",
+                3L,
+                "Me_2",
+                1.0D,
+                "stddev_pop_Me_1",
+                0.0D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2001L,
+                "Me_1",
+                4L,
+                "Me_2",
+                9.0D,
+                "stddev_pop_Me_1",
+                0.5D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2002L,
+                "Me_1",
+                7L,
+                "Me_2",
+                5.0D,
+                "stddev_pop_Me_1",
+                1.699673171197595D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2003L,
+                "Me_1",
+                6L,
+                "Me_2",
+                8.0D,
+                "stddev_pop_Me_1",
+                1.5811388300841895D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2000L,
+                "Me_1",
+                9L,
+                "Me_2",
+                3.0D,
+                "stddev_pop_Me_1",
+                0.0D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2001L,
+                "Me_1",
+                5L,
+                "Me_2",
+                4.0D,
+                "stddev_pop_Me_1",
+                2.0D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2002L,
+                "Me_1",
+                10L,
+                "Me_2",
+                2.0D,
+                "stddev_pop_Me_1",
+                2.160246899469287D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2003L,
+                "Me_1",
+                5L,
+                "Me_2",
+                7.0D,
+                "stddev_pop_Me_1",
+                2.277608394786075D));
+  }
+
+  @Test
+  public void testAnStdPopWithPartitionClause() throws ScriptException {
+
+    // Analytical function Test case 1 : stddev_pop on window with partition
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", ds1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := stddev_pop ( ds1 over ( partition by Id_1, Id_2 ) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+
+        +----+----+----+----+----+------------------+------------------+
+        |Id_1|Id_2|Year|Me_1|Me_2|      std_pop_Me_1|      std_pop_Me_2|
+        +----+----+----+----+----+------------------+------------------+
+        |   A|  XX|2000|   3| 1.0|1.5811388300841895| 3.112474899497183|
+        |   A|  XX|2001|   4| 9.0|1.5811388300841895| 3.112474899497183|
+        |   A|  XX|2002|   7| 5.0|1.5811388300841895| 3.112474899497183|
+        |   A|  XX|2003|   6| 8.0|1.5811388300841895| 3.112474899497183|
+        |   A|  YY|2000|   9| 3.0| 2.277608394786075|1.8708286933869707|
+        |   A|  YY|2001|   5| 4.0| 2.277608394786075|1.8708286933869707|
+        |   A|  YY|2002|  10| 2.0| 2.277608394786075|1.8708286933869707|
+        |   A|  YY|2003|   5| 7.0| 2.277608394786075|1.8708286933869707|
+        +----+----+----+----+----+------------------+------------------+
+    * */
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+    assertThat(res)
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 1.58D, "Me_2", 3.11D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 1.58D, "Me_2", 3.11D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 1.58D, "Me_2", 3.11D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 1.58D, "Me_2", 3.11D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 2.28D, "Me_2", 1.87D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 2.28D, "Me_2", 1.87D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 2.28D, "Me_2", 1.87D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 2.28D, "Me_2", 1.87D));
+  }
+
+  @Test
+  public void testAnStdPopWithPartitionOrderByClause() throws ScriptException {
+
+    // Analytical function Test case 2 : stddev_pop on window with partition and order by
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", ds1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := stddev_pop ( ds1 over ( partition by Id_1, Id_2 order by Year) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    +----+----+----+----+----+------------------+------------------+
+    |Id_1|Id_2|Year|Me_1|Me_2|      std_pop_Me_1|      std_pop_Me_2|
+    +----+----+----+----+----+------------------+------------------+
+    |   A|  XX|2000|   3| 1.0|               0.0|               0.0|
+    |   A|  XX|2001|   4| 9.0|               0.5|               4.0|
+    |   A|  XX|2002|   7| 5.0| 1.699673171197595| 3.265986323710904|
+    |   A|  XX|2003|   6| 8.0|1.5811388300841895| 3.112474899497183|
+    |   A|  YY|2000|   9| 3.0|               0.0|               0.0|
+    |   A|  YY|2001|   5| 4.0|               2.0|               0.5|
+    |   A|  YY|2002|  10| 2.0| 2.160246899469287| 0.816496580927726|
+    |   A|  YY|2003|   5| 7.0| 2.277608394786075|1.8708286933869707|
+    +----+----+----+----+----+------------------+------------------+
+
+    * */
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+    assertThat(res)
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 0.0D, "Me_2", 0.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 0.5D, "Me_2", 4.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 1.70D, "Me_2", 3.27D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 1.58D, "Me_2", 3.11D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 0.0D, "Me_2", 0.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 2.0D, "Me_2", 0.5D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 2.16D, "Me_2", 0.82D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 2.28D, "Me_2", 1.87D));
+  }
+
+  @Test
+  public void testAnStdPopWithPartitionOrderByDPClause() throws ScriptException {
+
+    // Analytical function count test case 3 : stddev_pop on window with partition, orderBy and data
+    // points
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", ds1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := stddev_pop ( ds1 over ( partition by Id_1 order by Id_2 data points between 2 preceding and 2 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    +----+----+----+----+----+------------------+------------------+
+    |Id_1|Id_2|Year|Me_1|Me_2|      std_pop_Me_1|      std_pop_Me_2|
+    +----+----+----+----+----+------------------+------------------+
+    |   A|  XX|2000|   3| 1.0| 1.699673171197595| 3.265986323710904|
+    |   A|  XX|2001|   4| 9.0|1.5811388300841895| 3.112474899497183|
+    |   A|  XX|2002|   7| 5.0|2.1354156504062622| 2.993325909419153|
+    |   A|  XX|2003|   6| 8.0|1.7204650534085253|2.3151673805580453|
+    |   A|  YY|2000|   9| 3.0|1.8547236990991407|   2.0591260281974|
+    |   A|  YY|2001|   5| 4.0|2.0976176963403033|2.3151673805580453|
+    |   A|  YY|2002|  10| 2.0| 2.277608394786075|1.8708286933869707|
+    |   A|  YY|2003|   5| 7.0| 2.357022603955158|2.0548046676563256|
+    +----+----+----+----+----+------------------+------------------+
+
+    * */
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+    assertThat(res)
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 1.70D, "Me_2", 3.27D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 1.58D, "Me_2", 3.11D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 2.14D, "Me_2", 2.99D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 1.72D, "Me_2", 2.32D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 1.85D, "Me_2", 2.06D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 2.1D, "Me_2", 2.32D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 2.28D, "Me_2", 1.87D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 2.36D, "Me_2", 2.05D));
+  }
+
+  @Test
+  public void testAnStdPopWithPartitionOrderByRangeClause() throws ScriptException {
+
+    // Analytical function count test case 4 : stddev_pop on window with partition, orderBy and
+    // range
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", ds1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := stddev_pop ( ds1 over ( partition by Id_1 order by Year range between 1 preceding and 1 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    +----+----+----+----+----+------------------+------------------+
+    |Id_1|Id_2|Year|Me_1|Me_2|      std_pop_Me_1|      std_pop_Me_2|
+    +----+----+----+----+----+------------------+------------------+
+    |   A|  XX|2000|   3| 1.0| 2.277608394786075| 2.947456530637899|
+    |   A|  YY|2000|   9| 3.0| 2.277608394786075| 2.947456530637899|
+    |   A|  XX|2001|   4| 9.0| 2.560381915956203|2.5819888974716116|
+    |   A|  YY|2001|   5| 4.0| 2.560381915956203|2.5819888974716116|
+    |   A|  XX|2002|   7| 5.0|1.9507833184532708|2.4094720491334933|
+    |   A|  YY|2002|  10| 2.0|1.9507833184532708|2.4094720491334933|
+    |   A|  XX|2003|   6| 8.0|1.8708286933869707|  2.29128784747792|
+    |   A|  YY|2003|   5| 7.0|1.8708286933869707|  2.29128784747792|
+    +----+----+----+----+----+------------------+------------------+
+
+    * */
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+    assertThat(res)
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 2.28D, "Me_2", 2.95D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 2.28D, "Me_2", 2.95D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 2.56D, "Me_2", 2.58D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 2.56D, "Me_2", 2.58D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 1.95D, "Me_2", 2.41D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 1.95D, "Me_2", 2.41D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 1.87D, "Me_2", 2.29D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 1.87D, "Me_2", 2.29D));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticStdSampTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticStdSampTest.java
new file mode 100644
index 000000000..0e6bda56f
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticStdSampTest.java
@@ -0,0 +1,403 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.model.Dataset;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.script.ScriptContext;
+import javax.script.ScriptException;
+import org.junit.jupiter.api.Test;
+
+public class AnalyticStdSampTest extends AnalyticTest {
+
+  @Test
+  public void testAnStdSampWithCalcClause() throws ScriptException {
+
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", ds1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := ds1 [ calc stddev_samp_Me_1:= stddev_samp ( Me_1 over ( partition by Id_1,Id_2 order by Year) )];");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+------------------+
+    |Id_1|Id_2|Year|Me_1|Me_2|  stddev_samp_Me_1|
+    +----+----+----+----+----+------------------+
+    |   A|  XX|2000|   3| 1.0|              null|
+    |   A|  XX|2001|   4| 9.0|0.7071067811865476|
+    |   A|  XX|2002|   7| 5.0|2.0816659994661326|
+    |   A|  XX|2003|   6| 8.0|1.8257418583505536|
+    |   A|  YY|2000|   9| 3.0|              null|
+    |   A|  YY|2001|   5| 4.0|2.8284271247461903|
+    |   A|  YY|2002|  10| 2.0|2.6457513110645907|
+    |   A|  YY|2003|   5| 7.0|2.6299556396765835|
+    +----+----+----+----+----+------------------+
+    * */
+    List<Map<String, Object>> actualWithNull =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    List<Map<String, Object>> actual = new ArrayList<>();
+    for (Map<String, Object> map : actualWithNull) {
+      actual.add(replaceNullValues(map, DEFAULT_NULL_STR));
+    }
+
+    assertThat(actual)
+        .containsExactly(
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2000L,
+                "Me_1",
+                3L,
+                "Me_2",
+                1.0D,
+                "stddev_samp_Me_1",
+                "null"),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2001L,
+                "Me_1",
+                4L,
+                "Me_2",
+                9.0D,
+                "stddev_samp_Me_1",
+                0.7071067811865476D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2002L,
+                "Me_1",
+                7L,
+                "Me_2",
+                5.0D,
+                "stddev_samp_Me_1",
+                2.0816659994661326D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2003L,
+                "Me_1",
+                6L,
+                "Me_2",
+                8.0D,
+                "stddev_samp_Me_1",
+                1.8257418583505536D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2000L,
+                "Me_1",
+                9L,
+                "Me_2",
+                3.0D,
+                "stddev_samp_Me_1",
+                "null"),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2001L,
+                "Me_1",
+                5L,
+                "Me_2",
+                4.0D,
+                "stddev_samp_Me_1",
+                2.8284271247461903D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2002L,
+                "Me_1",
+                10L,
+                "Me_2",
+                2.0D,
+                "stddev_samp_Me_1",
+                2.6457513110645907D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2003L,
+                "Me_1",
+                5L,
+                "Me_2",
+                7.0D,
+                "stddev_samp_Me_1",
+                2.6299556396765835D));
+  }
+
+  @Test
+  public void testAnStdSampWithPartitionClause() throws ScriptException {
+
+    // Analytical function Test case 1 : stddev_samp on window with partition
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", ds1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := stddev_samp ( ds1 over ( partition by Id_1, Id_2 ) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+
+       +----+----+----+----+----+------------------+-----------------+
+        |Id_1|Id_2|Year|Me_1|Me_2|     std_samp_Me_1|    std_samp_Me_2|
+        +----+----+----+----+----+------------------+-----------------+
+        |   A|  XX|2000|   3| 1.0|1.8257418583505536|3.593976442141304|
+        |   A|  XX|2001|   4| 9.0|1.8257418583505536|3.593976442141304|
+        |   A|  XX|2002|   7| 5.0|1.8257418583505536|3.593976442141304|
+        |   A|  XX|2003|   6| 8.0|1.8257418583505536|3.593976442141304|
+        |   A|  YY|2000|   9| 3.0|2.6299556396765835|2.160246899469287|
+        |   A|  YY|2001|   5| 4.0|2.6299556396765835|2.160246899469287|
+        |   A|  YY|2002|  10| 2.0|2.6299556396765835|2.160246899469287|
+        |   A|  YY|2003|   5| 7.0|2.6299556396765835|2.160246899469287|
+        +----+----+----+----+----+------------------+-----------------+
+    * */
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+    assertThat(res)
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 1.83D, "Me_2", 3.59D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 1.83D, "Me_2", 3.59D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 1.83D, "Me_2", 3.59D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 1.83D, "Me_2", 3.59D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 2.63D, "Me_2", 2.16D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 2.63D, "Me_2", 2.16D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 2.63D, "Me_2", 2.16D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 2.63D, "Me_2", 2.16D));
+  }
+
+  @Test
+  public void testAnStdSampWithPartitionOrderByClause() throws ScriptException {
+
+    // Analytical function Test case 2 : stddev_samp on window with partition and order by
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", ds1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := stddev_samp ( ds1 over ( partition by Id_1, Id_2 order by Year) );"
+            + "res1 := res[calc Me_1 := round(Me_1, 2), Me_2 := round(Me_2, 2)];");
+    assertThat(engine.getContext().getAttribute("res1")).isInstanceOf(Dataset.class);
+
+    /*
+    +----+----+----+----+----+------------------+------------------+
+    |Id_1|Id_2|Year|Me_1|Me_2|     std_samp_Me_1|     std_samp_Me_2|
+    +----+----+----+----+----+------------------+------------------+
+    |   A|  XX|2000|   3| 1.0|              null|              null|
+    |   A|  XX|2001|   4| 9.0|0.7071067811865476| 5.656854249492381|
+    |   A|  XX|2002|   7| 5.0|2.0816659994661326|               4.0|
+    |   A|  XX|2003|   6| 8.0|1.8257418583505536| 3.593976442141304|
+    |   A|  YY|2000|   9| 3.0|              null|              null|
+    |   A|  YY|2001|   5| 4.0|2.8284271247461903|0.7071067811865476|
+    |   A|  YY|2002|  10| 2.0|2.6457513110645907|               1.0|
+    |   A|  YY|2003|   5| 7.0|2.6299556396765835| 2.160246899469287|
+    +----+----+----+----+----+------------------+------------------+
+
+    * */
+
+    var actual =
+        ((Dataset) engine.getContext().getAttribute("res1"))
+            .getDataAsMap().stream()
+                .map(map -> replaceNullValues(map, DEFAULT_NULL_STR))
+                .collect(Collectors.toList());
+    assertThat(actual)
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", "null", "Me_2", "null"),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 0.71D, "Me_2", 5.66D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 2.08D, "Me_2", 4.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 1.83D, "Me_2", 3.59D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", "null", "Me_2", "null"),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 2.83D, "Me_2", 0.71D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 2.65D, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 2.63D, "Me_2", 2.16D));
+  }
+
+  @Test
+  public void testAnStdSampWithPartitionOrderByDPClause() throws ScriptException {
+
+    // Analytical function count test case 3 : stddev_samp on window with partition, orderBy and
+    // data points
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", ds1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := stddev_samp ( ds1 over ( partition by Id_1 order by Id_2 data points between 2 preceding and 2 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    +----+----+----+----+----+------------------+------------------+
+    |Id_1|Id_2|Year|Me_1|Me_2|     std_samp_Me_1|     std_samp_Me_2|
+    +----+----+----+----+----+------------------+------------------+
+    |   A|  XX|2000|   3| 1.0|2.0816659994661326|               4.0|
+    |   A|  XX|2001|   4| 9.0|1.8257418583505536| 3.593976442141304|
+    |   A|  XX|2002|   7| 5.0|2.3874672772626644|3.3466401061363023|
+    |   A|  XX|2003|   6| 8.0|1.9235384061671346| 2.588435821108957|
+    |   A|  YY|2000|   9| 3.0| 2.073644135332772|2.3021728866442674|
+    |   A|  YY|2001|   5| 4.0| 2.345207879911715| 2.588435821108957|
+    |   A|  YY|2002|  10| 2.0|2.6299556396765835| 2.160246899469287|
+    |   A|  YY|2003|   5| 7.0|2.8867513459481287|2.5166114784235836|
+    +----+----+----+----+----+------------------+------------------+
+
+
+    * */
+
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+
+    assertThat(res)
+        .contains(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 2.08D, "Me_2", 4.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 1.83D, "Me_2", 3.59D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 2.39D, "Me_2", 3.35D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 1.92D, "Me_2", 2.59D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 2.07D, "Me_2", 2.30D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 2.35D, "Me_2", 2.59D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 2.63D, "Me_2", 2.16D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 2.89D, "Me_2", 2.52D));
+  }
+
+  @Test
+  public void testAnStdSampWithPartitionOrderByRangeClause() throws ScriptException {
+
+    // Analytical function count test case 4 : stddev_samp on window with partition, orderBy and
+    // range
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", ds1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := stddev_samp ( ds1 over ( partition by Id_1 order by Year range between 1 preceding and 1 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    +----+----+----+----+----+------------------+------------------+
+    |Id_1|Id_2|Year|Me_1|Me_2|     std_samp_Me_1|     std_samp_Me_2|
+    +----+----+----+----+----+------------------+------------------+
+    |   A|  XX|2000|   3| 1.0|2.6299556396765835|3.4034296427770228|
+    |   A|  YY|2000|   9| 3.0|2.6299556396765835|3.4034296427770228|
+    |   A|  XX|2001|   4| 9.0|2.8047578623950176|2.8284271247461903|
+    |   A|  YY|2001|   5| 4.0|2.8047578623950176|2.8284271247461903|
+    |   A|  XX|2002|   7| 5.0| 2.136976056643281|2.6394443859772205|
+    |   A|  YY|2002|  10| 2.0| 2.136976056643281|2.6394443859772205|
+    |   A|  XX|2003|   6| 8.0| 2.160246899469287|2.6457513110645907|
+    |   A|  YY|2003|   5| 7.0| 2.160246899469287|2.6457513110645907|
+    +----+----+----+----+----+------------------+------------------+
+
+    * */
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+    assertThat(res)
+        .contains(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 2.63D, "Me_2", 3.40D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 2.63D, "Me_2", 3.40D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 2.80D, "Me_2", 2.83D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 2.80D, "Me_2", 2.83D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 2.14D, "Me_2", 2.64D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 2.14D, "Me_2", 2.64D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 2.16D, "Me_2", 2.65D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 2.16D, "Me_2", 2.65D));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticSumTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticSumTest.java
new file mode 100644
index 000000000..b45a5c190
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticSumTest.java
@@ -0,0 +1,458 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class AnalyticSumTest {
+
+  private final InMemoryDataset anCountDS1 =
+      new InMemoryDataset(
+          List.of(
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 9D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 7L, "Me_2", 5D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 6L, "Me_2", 8D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 9L, "Me_2", 3D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 4D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 10L, "Me_2", 2D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5L, "Me_2", 7D)),
+          Map.of(
+              "Id_1",
+              String.class,
+              "Id_2",
+              String.class,
+              "Year",
+              Long.class,
+              "Me_1",
+              Long.class,
+              "Me_2",
+              Double.class),
+          Map.of(
+              "Id_1",
+              Dataset.Role.IDENTIFIER,
+              "Id_2",
+              Dataset.Role.IDENTIFIER,
+              "Year",
+              Dataset.Role.IDENTIFIER,
+              "Me_1",
+              Dataset.Role.MEASURE,
+              "Me_2",
+              Dataset.Role.MEASURE));
+
+  private static SparkSession spark;
+  private static ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterAll
+  public static void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testAnSumWithCalcClause() throws ScriptException {
+
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := ds1 [ calc sum_Me_1:= sum ( Me_1 over ( partition by Id_1,Id_2 order by Year) )];");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+--------+
+    |Id_1|Id_2|Year|Me_1|Me_2|sum_Me_1|
+    +----+----+----+----+----+--------+
+    |   A|  XX|2000|   3| 1.0|       3|
+    |   A|  XX|2001|   4| 9.0|       7|
+    |   A|  XX|2002|   7| 5.0|      14|
+    |   A|  XX|2003|   6| 8.0|      20|
+    |   A|  YY|2000|   9| 3.0|       9|
+    |   A|  YY|2001|   5| 4.0|      14|
+    |   A|  YY|2002|  10| 2.0|      24|
+    |   A|  YY|2003|   5| 7.0|      29|
+    +----+----+----+----+----+--------+
+    * */
+    List<Map<String, Object>> actual =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    assertThat(actual)
+        .containsExactly(
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1.0D, "sum_Me_1", 3L),
+            Map.of(
+                "Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 9.0D, "sum_Me_1", 7L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2002L,
+                "Me_1",
+                7L,
+                "Me_2",
+                5.0D,
+                "sum_Me_1",
+                14L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2003L,
+                "Me_1",
+                6L,
+                "Me_2",
+                8.0D,
+                "sum_Me_1",
+                20L),
+            Map.of(
+                "Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 9L, "Me_2", 3.0D, "sum_Me_1", 9L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2001L,
+                "Me_1",
+                5L,
+                "Me_2",
+                4.0D,
+                "sum_Me_1",
+                14L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2002L,
+                "Me_1",
+                10L,
+                "Me_2",
+                2.0D,
+                "sum_Me_1",
+                24L),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2003L,
+                "Me_1",
+                5L,
+                "Me_2",
+                7.0D,
+                "sum_Me_1",
+                29L));
+  }
+
+  @Test
+  public void testAnSumWithPartitionClause() throws ScriptException {
+
+    // Analytical function Test case 1 : sum on window with partition
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := sum ( ds1 over ( partition by Id_1, Id_2 ) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame need to check mutable or not mutable on Mesaument column
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|sum_Me_1|sum_Me_2|
+        +----+----+----+----+----+--------+--------+
+        |   A|  XX|2000|   3| 1.0|      20|    23.0|
+        |   A|  XX|2001|   4| 9.0|      20|    23.0|
+        |   A|  XX|2002|   7| 5.0|      20|    23.0|
+        |   A|  XX|2003|   6| 8.0|      20|    23.0|
+        |   A|  YY|2000|   9| 3.0|      29|    16.0|
+        |   A|  YY|2001|   5| 4.0|      29|    16.0|
+        |   A|  YY|2002|  10| 2.0|      29|    16.0|
+        |   A|  YY|2003|   5| 7.0|      29|    16.0|
+        +----+----+----+----+----+--------+--------+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 20L, "Me_2", 23.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 20L, "Me_2", 23.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 20L, "Me_2", 23.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 20L, "Me_2", 23.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 29L, "Me_2", 16.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 29L, "Me_2", 16.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 29L, "Me_2", 16.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 29L, "Me_2", 16.0D));
+  }
+
+  @Test
+  public void testAnSumWithPartitionOrderByClause() throws ScriptException {
+
+    // Analytical function Test case 2 : sum on window with partition and order by
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := sum ( ds1 over ( partition by Id_1 order by Id_2) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame need to check mutable or not mutable on Mesaument column
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|sum_Me_1|sum_Me_2|
+        +----+----+----+----+----+--------+--------+
+        |   A|  XX|2000|   3| 1.0|      20|    23.0|
+        |   A|  XX|2001|   4| 9.0|      20|    23.0|
+        |   A|  XX|2002|   7| 5.0|      20|    23.0|
+        |   A|  XX|2003|   6| 8.0|      20|    23.0|
+        |   A|  YY|2000|   9| 3.0|      49|    39.0|
+        |   A|  YY|2001|   5| 4.0|      49|    39.0|
+        |   A|  YY|2002|  10| 2.0|      49|    39.0|
+        |   A|  YY|2003|   5| 7.0|      49|    39.0|
+        +----+----+----+----+----+--------+--------+
+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 20L, "Me_2", 23.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 20L, "Me_2", 23.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 20L, "Me_2", 23.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 20L, "Me_2", 23.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 49L, "Me_2", 39.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 49L, "Me_2", 39.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 49L, "Me_2", 39.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 49L, "Me_2", 39.0D));
+  }
+
+  @Test
+  public void testAnSumWithOrderByClause() throws ScriptException {
+
+    // Analytical function Test case 3 : sum on window with only order by without partition
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := sum ( ds1 over ( order by Id_1, Id_2, Year ) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame need to check mutable or not mutable on Mesaument column
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|sum_Me_1|sum_Me_2|
+        +----+----+----+----+----+--------+--------+
+        |   A|  XX|2000|   3| 1.0|       3|     1.0|
+        |   A|  XX|2001|   4| 9.0|       7|    10.0|
+        |   A|  XX|2002|   7| 5.0|      14|    15.0|
+        |   A|  XX|2003|   6| 8.0|      20|    23.0|
+        |   A|  YY|2000|   9| 3.0|      29|    26.0|
+        |   A|  YY|2001|   5| 4.0|      34|    30.0|
+        |   A|  YY|2002|  10| 2.0|      44|    32.0|
+        |   A|  YY|2003|   5| 7.0|      49|    39.0|
+        +----+----+----+----+----+--------+--------+
+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 7L, "Me_2", 10.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 14L, "Me_2", 15.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 20L, "Me_2", 23.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 29L, "Me_2", 26.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 34L, "Me_2", 30.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 44L, "Me_2", 32.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 49L, "Me_2", 39.0D));
+  }
+
+  @Test
+  public void testAnSumWithPartitionOrderByDPClause() throws ScriptException {
+
+    // Analytical function count test case 4 : sum on window with partition, orderBy and data points
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := sum ( ds1 over ( partition by Id_1 order by Id_2 data points between 2 preceding and 2 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|sum_Me_1|sum_Me_2|
+        +----+----+----+----+----+--------+--------+
+        |   A|  XX|2000|   3| 1.0|      14|    15.0|
+        |   A|  XX|2001|   4| 9.0|      20|    23.0|
+        |   A|  XX|2002|   7| 5.0|      29|    26.0|
+        |   A|  XX|2003|   6| 8.0|      31|    29.0|
+        |   A|  YY|2000|   9| 3.0|      37|    22.0|
+        |   A|  YY|2001|   5| 4.0|      35|    24.0|
+        |   A|  YY|2002|  10| 2.0|      29|    16.0|
+        |   A|  YY|2003|   5| 7.0|      20|    13.0|
+        +----+----+----+----+----+--------+--------+
+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 14L, "Me_2", 15.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 20L, "Me_2", 23.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 29L, "Me_2", 26.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 31L, "Me_2", 29.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 37L, "Me_2", 22.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 35L, "Me_2", 24.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 29L, "Me_2", 16.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 20L, "Me_2", 13.0D));
+  }
+
+  @Test
+  public void testAnSumWithPartitionOrderByRangeClause() throws ScriptException {
+
+    // Analytical function count test case 5 : sum on window with partition, orderBy and range
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := sum ( ds1 over ( partition by Id_1 order by Year range between 1 preceding and 1 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    *   +----+----+----+----+----+----------+----------+
+        |Id_1|Id_2|Year|Me_1|Me_2|sum_Me_1|sum_Me_2|
+        +----+----+----+----+----+--------+--------+
+        |   A|  XX|2000|   3| 1.0|      21|    17.0|
+        |   A|  YY|2000|   9| 3.0|      21|    17.0|
+        |   A|  XX|2001|   4| 9.0|      38|    24.0|
+        |   A|  YY|2001|   5| 4.0|      38|    24.0|
+        |   A|  XX|2002|   7| 5.0|      37|    35.0|
+        |   A|  YY|2002|  10| 2.0|      37|    35.0|
+        |   A|  XX|2003|   6| 8.0|      28|    22.0|
+        |   A|  YY|2003|   5| 7.0|      28|    22.0|
+        +----+----+----+----+----+--------+--------+
+
+    * */
+    assertThat(((Dataset) engine.getContext().getAttribute("res")).getDataAsMap())
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 21L, "Me_2", 17.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 21L, "Me_2", 17.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 38L, "Me_2", 24.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 38L, "Me_2", 24.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 37L, "Me_2", 35.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 37L, "Me_2", 35.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 28L, "Me_2", 22.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 28L, "Me_2", 22.0D));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticTest.java
new file mode 100644
index 000000000..927079111
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticTest.java
@@ -0,0 +1,207 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.Dataset.Role;
+import fr.insee.vtl.model.InMemoryDataset;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeEach;
+
+public abstract class AnalyticTest {
+
+  public final InMemoryDataset ds1 =
+      new InMemoryDataset(
+          List.of(
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 9D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 7L, "Me_2", 5D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 6L, "Me_2", 8D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 9L, "Me_2", 3D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 4D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 10L, "Me_2", 2D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5L, "Me_2", 7D)),
+          Map.of(
+              "Id_1",
+              String.class,
+              "Id_2",
+              String.class,
+              "Year",
+              Long.class,
+              "Me_1",
+              Long.class,
+              "Me_2",
+              Double.class),
+          Map.of(
+              "Id_1",
+              Role.IDENTIFIER,
+              "Id_2",
+              Role.IDENTIFIER,
+              "Year",
+              Role.IDENTIFIER,
+              "Me_1",
+              Role.MEASURE,
+              "Me_2",
+              Role.MEASURE));
+
+  public final InMemoryDataset ds2 =
+      new InMemoryDataset(
+          List.of(
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 1993L, "Me_1", 3L, "Me_2", 1D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 1994L, "Me_1", 4L, "Me_2", 9D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 1995L, "Me_1", 7L, "Me_2", 5D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 1996L, "Me_1", 6L, "Me_2", 8D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 1993L, "Me_1", 9L, "Me_2", 3D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 1994L, "Me_1", 5L, "Me_2", 4D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 1995L, "Me_1", 10L, "Me_2", 2D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 1996L, "Me_1", 2L, "Me_2", 7D)),
+          Map.of(
+              "Id_1",
+              String.class,
+              "Id_2",
+              String.class,
+              "Year",
+              Long.class,
+              "Me_1",
+              Long.class,
+              "Me_2",
+              Double.class),
+          Map.of(
+              "Id_1",
+              Dataset.Role.IDENTIFIER,
+              "Id_2",
+              Dataset.Role.IDENTIFIER,
+              "Year",
+              Dataset.Role.IDENTIFIER,
+              "Me_1",
+              Dataset.Role.MEASURE,
+              "Me_2",
+              Dataset.Role.MEASURE));
+
+  public static final int DEFAULT_PRECISION = 2;
+
+  public static <T, K> Map<K, T> replaceNullValues(Map<K, T> map, T defaultValue) {
+
+    // Replace the null value
+    map =
+        map.entrySet().stream()
+            .map(
+                entry -> {
+                  if (entry.getValue() == null) entry.setValue(defaultValue);
+                  return entry;
+                })
+            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+    return map;
+  }
+
+  /**
+   * This method round the double or float column of the given dataset with the given precision.
+   * This method should be used only for unit test, do not apply it on large dataset, it will have
+   * performance issues.
+   *
+   * @param dataset The given dataset which need to be transformed
+   * @param precision The given precision of the decimal value after ,
+   * @return The result dataset in a list of map.
+   */
+  public static List<Map<String, Object>> roundDecimalInDataset(Dataset dataset, int precision) {
+    List<Map<String, Object>> res = dataset.getDataAsMap();
+    for (Map<String, Object> map : res) {
+      for (Map.Entry<String, Object> entry : map.entrySet()) {
+        if (entry.getValue() instanceof Double || entry.getValue() instanceof Float) {
+          double value = ((Number) entry.getValue()).doubleValue();
+          BigDecimal roundedValue =
+              BigDecimal.valueOf(value).setScale(precision, RoundingMode.HALF_UP);
+          map.put(entry.getKey(), roundedValue.doubleValue());
+        }
+      }
+    }
+    return res;
+  }
+
+  public final String DEFAULT_NULL_STR = "null";
+
+  public static SparkSession spark;
+  public static ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterAll
+  public static void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  /*
+   * End test with calc statement*/
+
+  /***********************************Unit test for implicit analytic function *************************************/
+
+  /*
+   * Test case for analytic function Avg
+   *
+   * */
+
+  /*
+   * End of Avg test case */
+
+  /*
+   * Test case for analytic function Median
+   *
+   * */
+
+  /*
+   * End of Median test case */
+
+  /*
+   * Test case for analytic function stddev_pop
+   *
+   * */
+
+  /*
+   * End of stddev_samp test case */
+
+  /*
+   * End of var_pop test case */
+
+  /*
+   * End of rank test case */
+
+  /*
+   * Test case for analytic function first
+   *
+   * */
+
+  /*
+   * End of first test case */
+
+  /*
+   * End of last test case */
+
+  /*
+   * End of lead test case */
+
+  /*
+   * End of lag test case */
+
+  /*
+   * End of ratio_to_report test case */
+
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticVarPopTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticVarPopTest.java
new file mode 100644
index 000000000..6df54c09d
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticVarPopTest.java
@@ -0,0 +1,456 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class AnalyticVarPopTest {
+
+  private final InMemoryDataset anCountDS1 =
+      new InMemoryDataset(
+          List.of(
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3L, "Me_2", 1D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 4L, "Me_2", 9D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 7L, "Me_2", 5D),
+              Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 6L, "Me_2", 8D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 9L, "Me_2", 3D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5L, "Me_2", 4D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 10L, "Me_2", 2D),
+              Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5L, "Me_2", 7D)),
+          Map.of(
+              "Id_1",
+              String.class,
+              "Id_2",
+              String.class,
+              "Year",
+              Long.class,
+              "Me_1",
+              Long.class,
+              "Me_2",
+              Double.class),
+          Map.of(
+              "Id_1",
+              Dataset.Role.IDENTIFIER,
+              "Id_2",
+              Dataset.Role.IDENTIFIER,
+              "Year",
+              Dataset.Role.IDENTIFIER,
+              "Me_1",
+              Dataset.Role.MEASURE,
+              "Me_2",
+              Dataset.Role.MEASURE));
+
+  private static SparkSession spark;
+  private static ScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = mgr.getEngineByExtension("vtl");
+
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+    SparkSession.setActiveSession(spark);
+
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterAll
+  public static void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void testAnVarPopWithCalcClause() throws ScriptException {
+
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := ds1 [ calc var_pop_Me_1:= var_pop ( Me_1 over ( partition by Id_1,Id_2 order by Year) )];");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+    +----+----+----+----+----+------------------+
+    |Id_1|Id_2|Year|Me_1|Me_2|      var_pop_Me_1|
+    +----+----+----+----+----+------------------+
+    |   A|  XX|2000|   3| 1.0|               0.0|
+    |   A|  XX|2001|   4| 9.0|              0.25|
+    |   A|  XX|2002|   7| 5.0| 2.888888888888889|
+    |   A|  XX|2003|   6| 8.0|2.4999999999999996|
+    |   A|  YY|2000|   9| 3.0|               0.0|
+    |   A|  YY|2001|   5| 4.0|               4.0|
+    |   A|  YY|2002|  10| 2.0| 4.666666666666667|
+    |   A|  YY|2003|   5| 7.0|            5.1875|
+    +----+----+----+----+----+------------------+
+    * */
+    List<Map<String, Object>> actual =
+        ((Dataset) engine.getContext().getAttribute("res")).getDataAsMap();
+
+    assertThat(actual)
+        .containsExactly(
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2000L,
+                "Me_1",
+                3L,
+                "Me_2",
+                1.0D,
+                "var_pop_Me_1",
+                0.0D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2001L,
+                "Me_1",
+                4L,
+                "Me_2",
+                9.0D,
+                "var_pop_Me_1",
+                0.25D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2002L,
+                "Me_1",
+                7L,
+                "Me_2",
+                5.0D,
+                "var_pop_Me_1",
+                2.888888888888889D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "XX",
+                "Year",
+                2003L,
+                "Me_1",
+                6L,
+                "Me_2",
+                8.0D,
+                "var_pop_Me_1",
+                2.4999999999999996D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2000L,
+                "Me_1",
+                9L,
+                "Me_2",
+                3.0D,
+                "var_pop_Me_1",
+                0.0D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2001L,
+                "Me_1",
+                5L,
+                "Me_2",
+                4.0D,
+                "var_pop_Me_1",
+                4.0D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2002L,
+                "Me_1",
+                10L,
+                "Me_2",
+                2.0D,
+                "var_pop_Me_1",
+                4.666666666666667D),
+            Map.of(
+                "Id_1",
+                "A",
+                "Id_2",
+                "YY",
+                "Year",
+                2003L,
+                "Me_1",
+                5L,
+                "Me_2",
+                7.0D,
+                "var_pop_Me_1",
+                5.1875D));
+  }
+
+  /*
+   * Test case for analytic function var_pop
+   *
+   * */
+  @Test
+  public void testAnVarPopWithPartitionClause() throws ScriptException {
+
+    // Analytical function Test case 1 : var_pop on window with partition
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := var_pop ( ds1 over ( partition by Id_1, Id_2 ) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+
+        +----+----+----+----+----+------------------+------------+
+        |Id_1|Id_2|Year|Me_1|Me_2|      var_pop_Me_1|var_pop_Me_2|
+        +----+----+----+----+----+------------------+------------+
+        |   A|  XX|2000|   3| 1.0|2.4999999999999996|      9.6875|
+        |   A|  XX|2001|   4| 9.0|2.4999999999999996|      9.6875|
+        |   A|  XX|2002|   7| 5.0|2.4999999999999996|      9.6875|
+        |   A|  XX|2003|   6| 8.0|2.4999999999999996|      9.6875|
+        |   A|  YY|2000|   9| 3.0|            5.1875|         3.5|
+        |   A|  YY|2001|   5| 4.0|            5.1875|         3.5|
+        |   A|  YY|2002|  10| 2.0|            5.1875|         3.5|
+        |   A|  YY|2003|   5| 7.0|            5.1875|         3.5|
+        +----+----+----+----+----+------------------+------------+
+    * */
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+    assertThat(res)
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 2.50D, "Me_2", 9.69D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 2.50D, "Me_2", 9.69D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 2.50D, "Me_2", 9.69D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 2.50D, "Me_2", 9.69D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 5.19D, "Me_2", 3.5D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5.19D, "Me_2", 3.5D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 5.19D, "Me_2", 3.5D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5.19D, "Me_2", 3.5D));
+  }
+
+  @Test
+  public void testAnVarPopWithPartitionOrderByClause() throws ScriptException {
+
+    // Analytical function Test case 2 : var_pop on window with partition and order by
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := var_pop ( ds1 over ( partition by Id_1, Id_2 order by Year) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    +----+----+----+----+----+------------------+------------------+
+    |Id_1|Id_2|Year|Me_1|Me_2|      var_pop_Me_1|      var_pop_Me_2|
+    +----+----+----+----+----+------------------+------------------+
+    |   A|  XX|2000|   3| 1.0|               0.0|               0.0|
+    |   A|  XX|2001|   4| 9.0|              0.25|              16.0|
+    |   A|  XX|2002|   7| 5.0| 2.888888888888889|10.666666666666666|
+    |   A|  XX|2003|   6| 8.0|2.4999999999999996|            9.6875|
+    |   A|  YY|2000|   9| 3.0|               0.0|               0.0|
+    |   A|  YY|2001|   5| 4.0|               4.0|              0.25|
+    |   A|  YY|2002|  10| 2.0| 4.666666666666667|0.6666666666666666|
+    |   A|  YY|2003|   5| 7.0|            5.1875|               3.5|
+    +----+----+----+----+----+------------------+------------------+
+
+    * */
+
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+
+    assertThat(res)
+        .contains(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 0.0D, "Me_2", 0.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 0.25D, "Me_2", 16.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 2.89D, "Me_2", 10.67D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 2.50D, "Me_2", 9.69D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 0.0D, "Me_2", 0.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 4.0D, "Me_2", 0.25D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 4.67D, "Me_2", 0.67D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5.19D, "Me_2", 3.5D));
+  }
+
+  @Test
+  public void testAnVarPopWithPartitionOrderByDPClause() throws ScriptException {
+
+    // Analytical function count test case 3 : var_pop on window with partition, orderBy and data
+    // points
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := var_pop ( ds1 over ( partition by Id_1 order by Id_2 data points between 2 preceding and 2 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    +----+----+----+----+----+------------------+------------------+
+    |Id_1|Id_2|Year|Me_1|Me_2|      var_pop_Me_1|      var_pop_Me_2|
+    +----+----+----+----+----+------------------+------------------+
+    |   A|  XX|2000|   3| 1.0| 2.888888888888889|10.666666666666666|
+    |   A|  XX|2001|   4| 9.0|2.4999999999999996|            9.6875|
+    |   A|  XX|2002|   7| 5.0|              4.56| 8.959999999999999|
+    |   A|  XX|2003|   6| 8.0|              2.96|              5.36|
+    |   A|  YY|2000|   9| 3.0|              3.44| 4.239999999999999|
+    |   A|  YY|2001|   5| 4.0|               4.4|              5.36|
+    |   A|  YY|2002|  10| 2.0|            5.1875|               3.5|
+    |   A|  YY|2003|   5| 7.0|5.5555555555555545| 4.222222222222222|
+    +----+----+----+----+----+------------------+------------------+
+
+
+    * */
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+    assertThat(res)
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 2.89D, "Me_2", 10.67D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 2.5D, "Me_2", 9.69D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 4.56D, "Me_2", 8.96D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 2.96D, "Me_2", 5.36D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 3.44D, "Me_2", 4.24D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 4.4D, "Me_2", 5.36D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 5.19D, "Me_2", 3.5D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 5.56D, "Me_2", 4.22D));
+  }
+
+  @Test
+  public void testAnVarPopWithPartitionOrderByRangeClause() throws ScriptException {
+
+    // Analytical function count test case 4 : var_pop on window with partition, orderBy and range
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", anCountDS1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := var_pop ( ds1 over ( partition by Id_1 order by Year range between 1 preceding and 1 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    +----+----+----+----+----+------------------+-----------------+
+    |Id_1|Id_2|Year|Me_1|Me_2|      var_pop_Me_1|     var_pop_Me_2|
+    +----+----+----+----+----+------------------+-----------------+
+    |   A|  XX|2000|   3| 1.0|            5.1875|           8.6875|
+    |   A|  YY|2000|   9| 3.0|            5.1875|           8.6875|
+    |   A|  XX|2001|   4| 9.0| 6.555555555555556|6.666666666666668|
+    |   A|  YY|2001|   5| 4.0| 6.555555555555556|6.666666666666668|
+    |   A|  XX|2002|   7| 5.0|3.8055555555555554|5.805555555555556|
+    |   A|  YY|2002|  10| 2.0|3.8055555555555554|5.805555555555556|
+    |   A|  XX|2003|   6| 8.0|               3.5|             5.25|
+    |   A|  YY|2003|   5| 7.0|               3.5|             5.25|
+    +----+----+----+----+----+------------------+-----------------+
+
+    * */
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+    assertThat(res)
+        .containsExactlyInAnyOrder(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 5.19D, "Me_2", 8.69D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 5.19D, "Me_2", 8.69D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 6.56D, "Me_2", 6.67D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 6.56D, "Me_2", 6.67D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 3.81D, "Me_2", 5.81D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 3.81D, "Me_2", 5.81D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 3.5D, "Me_2", 5.25D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 3.5D, "Me_2", 5.25D));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticVarSampTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticVarSampTest.java
new file mode 100644
index 000000000..1d2d4ae02
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/processing.engine/analytic/AnalyticVarSampTest.java
@@ -0,0 +1,244 @@
+package fr.insee.vtl.spark.processing.engine.analytic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import fr.insee.vtl.model.Dataset;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.script.ScriptContext;
+import javax.script.ScriptException;
+import org.junit.jupiter.api.Test;
+
+public class AnalyticVarSampTest extends AnalyticTest {
+
+  @Test
+  public void testAnVarSampWithPartitionClause() throws ScriptException {
+
+    // Analytical function Test case 1 : var_samp on window with partition
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", ds1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval("res := var_samp ( ds1 over ( partition by Id_1, Id_2 ) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    *
+
+        +----+----+----+----+----+------------------+------------------+
+        |Id_1|Id_2|Year|Me_1|Me_2|     var_samp_Me_1|     var_samp_Me_2|
+        +----+----+----+----+----+------------------+------------------+
+        |   A|  XX|2000|   3| 1.0|3.3333333333333326|12.916666666666666|
+        |   A|  XX|2001|   4| 9.0|3.3333333333333326|12.916666666666666|
+        |   A|  XX|2002|   7| 5.0|3.3333333333333326|12.916666666666666|
+        |   A|  XX|2003|   6| 8.0|3.3333333333333326|12.916666666666666|
+        |   A|  YY|2000|   9| 3.0| 6.916666666666667| 4.666666666666667|
+        |   A|  YY|2001|   5| 4.0| 6.916666666666667| 4.666666666666667|
+        |   A|  YY|2002|  10| 2.0| 6.916666666666667| 4.666666666666667|
+        |   A|  YY|2003|   5| 7.0| 6.916666666666667| 4.666666666666667|
+        +----+----+----+----+----+------------------+------------------+
+    * */
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+    assertThat(res)
+        .contains(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 3.33D, "Me_2", 12.92D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 3.33D, "Me_2", 12.92D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 3.33D, "Me_2", 12.92D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 3.33D, "Me_2", 12.92D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 6.92D, "Me_2", 4.67D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 6.92D, "Me_2", 4.67D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 6.92D, "Me_2", 4.67D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 6.92D, "Me_2", 4.67D));
+  }
+
+  @Test
+  public void testAnVarSampWithPartitionOrderByClause() throws ScriptException {
+
+    // Analytical function Test case 2 : var_samp on window with partition and order by
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", ds1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := var_samp ( ds1 over ( partition by Id_1, Id_2 order by Year) );"
+            + "res1 := res [calc Me_1 := round(Me_1, 2), Me_2 := round(Me_2, 2)];");
+    assertThat(engine.getContext().getAttribute("res1")).isInstanceOf(Dataset.class);
+
+    /*
+    +----+----+----+----+----+------------------+------------------+
+    |Id_1|Id_2|Year|Me_1|Me_2|     var_samp_Me_1|     var_samp_Me_2|
+    +----+----+----+----+----+------------------+------------------+
+    |   A|  XX|2000|   3| 1.0|              null|              null|
+    |   A|  XX|2001|   4| 9.0|               0.5|              32.0|
+    |   A|  XX|2002|   7| 5.0| 4.333333333333333|              16.0|
+    |   A|  XX|2003|   6| 8.0|3.3333333333333326|12.916666666666666|
+    |   A|  YY|2000|   9| 3.0|              null|              null|
+    |   A|  YY|2001|   5| 4.0|               8.0|               0.5|
+    |   A|  YY|2002|  10| 2.0|               7.0|               1.0|
+    |   A|  YY|2003|   5| 7.0| 6.916666666666667| 4.666666666666667|
+    +----+----+----+----+----+------------------+------------------+
+    * */
+
+    var actual =
+        ((Dataset) engine.getContext().getAttribute("res1"))
+            .getDataAsMap().stream()
+                .map(map -> replaceNullValues(map, DEFAULT_NULL_STR))
+                .collect(Collectors.toList());
+    assertThat(actual)
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", "null", "Me_2", "null"),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 0.5D, "Me_2", 32.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 4.33D, "Me_2", 16.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 3.33D, "Me_2", 12.92D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", "null", "Me_2", "null"),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 8.0D, "Me_2", 0.5D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 7.0D, "Me_2", 1.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 6.92D, "Me_2", 4.67D));
+  }
+
+  @Test
+  public void testAnVarSampWithPartitionOrderByDPClause() throws ScriptException {
+
+    // Analytical function count test case 3 : var_samp on window with partition, orderBy and data
+    // points
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", ds1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := var_samp ( ds1 over ( partition by Id_1 order by Id_2 data points between 2 preceding and 2 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    +----+----+----+----+----+------------------+------------------+
+    |Id_1|Id_2|Year|Me_1|Me_2|     var_samp_Me_1|     var_samp_Me_2|
+    +----+----+----+----+----+------------------+------------------+
+    |   A|  XX|2000|   3| 1.0| 4.333333333333333|              16.0|
+    |   A|  XX|2001|   4| 9.0|3.3333333333333326|12.916666666666666|
+    |   A|  XX|2002|   7| 5.0| 5.699999999999999|              11.2|
+    |   A|  XX|2003|   6| 8.0|               3.7|               6.7|
+    |   A|  YY|2000|   9| 3.0|               4.3| 5.299999999999999|
+    |   A|  YY|2001|   5| 4.0|               5.5|               6.7|
+    |   A|  YY|2002|  10| 2.0| 6.916666666666667| 4.666666666666667|
+    |   A|  YY|2003|   5| 7.0| 8.333333333333332| 6.333333333333334|
+    +----+----+----+----+----+------------------+------------------+
+
+
+
+    * */
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+    assertThat(res)
+        .containsExactly(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 4.33D, "Me_2", 16.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 3.33D, "Me_2", 12.92D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 5.70D, "Me_2", 11.2D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 3.7D, "Me_2", 6.7D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 4.3D, "Me_2", 5.3D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 5.5D, "Me_2", 6.7D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 6.92D, "Me_2", 4.67D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 8.33D, "Me_2", 6.33D));
+  }
+
+  @Test
+  public void testAnVarSampWithPartitionOrderByRangeClause() throws ScriptException {
+
+    // Analytical function count test case 4 : var_samp on window with partition, orderBy and range
+    /* Input dataset
+    *   +----+----+----+----+----+
+        |Id_1|Id_2|Year|Me_1|Me_2|
+        +----+----+----+----+----+
+        |   A|  XX|2000|   3| 1.0|
+        |   A|  XX|2001|   4| 9.0|
+        |   A|  XX|2002|   7| 5.0|
+        |   A|  XX|2003|   6| 8.0|
+        |   A|  YY|2000|   9| 3.0|
+        |   A|  YY|2001|   5| 4.0|
+        |   A|  YY|2002|  10| 2.0|
+        |   A|  YY|2003|   5| 7.0|
+        +----+----+----+----+----+
+    * */
+    ScriptContext context = engine.getContext();
+    context.setAttribute("ds1", ds1, ScriptContext.ENGINE_SCOPE);
+
+    engine.eval(
+        "res := var_samp ( ds1 over ( partition by Id_1 order by Year range between 1 preceding and 1 following) );");
+    assertThat(engine.getContext().getAttribute("res")).isInstanceOf(Dataset.class);
+
+    /*
+    * The result data frame
+    *
+    +----+----+----+----+----+-----------------+------------------+
+    |Id_1|Id_2|Year|Me_1|Me_2|    var_samp_Me_1|     var_samp_Me_2|
+    +----+----+----+----+----+-----------------+------------------+
+    |   A|  XX|2000|   3| 1.0|6.916666666666667|11.583333333333334|
+    |   A|  YY|2000|   9| 3.0|6.916666666666667|11.583333333333334|
+    |   A|  XX|2001|   4| 9.0|7.866666666666667| 8.000000000000002|
+    |   A|  YY|2001|   5| 4.0|7.866666666666667| 8.000000000000002|
+    |   A|  XX|2002|   7| 5.0|4.566666666666666| 6.966666666666667|
+    |   A|  YY|2002|  10| 2.0|4.566666666666666| 6.966666666666667|
+    |   A|  XX|2003|   6| 8.0|4.666666666666667|               7.0|
+    |   A|  YY|2003|   5| 7.0|4.666666666666667|               7.0|
+    +----+----+----+----+----+-----------------+------------------+
+
+    * */
+    List<Map<String, Object>> res =
+        AnalyticTest.roundDecimalInDataset(
+            (Dataset) engine.getContext().getAttribute("res"), AnalyticTest.DEFAULT_PRECISION);
+    assertThat(res)
+        .containsExactlyInAnyOrder(
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2000L, "Me_1", 6.92D, "Me_2", 11.58D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2000L, "Me_1", 6.92D, "Me_2", 11.58D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2001L, "Me_1", 7.87D, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2001L, "Me_1", 7.87D, "Me_2", 8.0D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2002L, "Me_1", 4.57D, "Me_2", 6.97D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2002L, "Me_1", 4.57D, "Me_2", 6.97D),
+            Map.of("Id_1", "A", "Id_2", "XX", "Year", 2003L, "Me_1", 4.67D, "Me_2", 7.0D),
+            Map.of("Id_1", "A", "Id_2", "YY", "Year", 2003L, "Me_1", 4.67D, "Me_2", 7.0D));
+  }
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/samples/DatasetSamples.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/samples/DatasetSamples.java
new file mode 100644
index 000000000..9a88a8ab6
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/samples/DatasetSamples.java
@@ -0,0 +1,39 @@
+package fr.insee.vtl.spark.samples;
+
+import fr.insee.vtl.model.Dataset;
+import fr.insee.vtl.model.InMemoryDataset;
+import fr.insee.vtl.model.Structured;
+import java.util.Arrays;
+import java.util.List;
+
+public class DatasetSamples {
+
+  public static InMemoryDataset ds1 =
+      new InMemoryDataset(
+          List.of(
+              new Structured.Component("id", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("long1", Long.class, Dataset.Role.MEASURE),
+              new Structured.Component("long2", Long.class, Dataset.Role.MEASURE),
+              new Structured.Component("double1", Double.class, Dataset.Role.MEASURE),
+              new Structured.Component("double2", Double.class, Dataset.Role.MEASURE),
+              new Structured.Component("bool1", Boolean.class, Dataset.Role.MEASURE),
+              new Structured.Component("bool2", Boolean.class, Dataset.Role.MEASURE),
+              new Structured.Component("string1", String.class, Dataset.Role.MEASURE),
+              new Structured.Component("string2", String.class, Dataset.Role.MEASURE)),
+          Arrays.asList("Toto", 30L, 300L, 12.2D, 1.22D, true, false, "toto", "t"),
+          Arrays.asList("Hadrien", 10L, 1L, 1.1D, 10.11D, true, true, "hadrien", "k"),
+          Arrays.asList("Nico", 20L, 250L, 12.2D, 21.1D, false, true, "nico", "l"),
+          Arrays.asList("Franck", 100L, 2L, 1.21D, 100.9D, false, false, "franck", "c"));
+
+  public static InMemoryDataset ds2 =
+      new InMemoryDataset(
+          List.of(
+              new Structured.Component("id", String.class, Dataset.Role.IDENTIFIER),
+              new Structured.Component("long1", Long.class, Dataset.Role.MEASURE),
+              new Structured.Component("double1", Double.class, Dataset.Role.MEASURE),
+              new Structured.Component("bool1", Boolean.class, Dataset.Role.MEASURE),
+              new Structured.Component("string1", String.class, Dataset.Role.MEASURE)),
+          Arrays.asList("Hadrien", 150L, 1.1D, true, "hadrien"),
+          Arrays.asList("Nico", 20L, 2.2D, true, "nico"),
+          Arrays.asList("Franck", 100L, -1.21D, false, "franck"));
+}
diff --git a/vtl-spark4/src/test/java/fr/insee/vtl/spark4/samples/RegisterMethodTest.java b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/samples/RegisterMethodTest.java
new file mode 100644
index 000000000..7654f9ebc
--- /dev/null
+++ b/vtl-spark4/src/test/java/fr/insee/vtl/spark4/samples/RegisterMethodTest.java
@@ -0,0 +1,99 @@
+package fr.insee.vtl.spark.samples;
+
+import fr.insee.vtl.engine.VtlScriptEngine;
+import fr.insee.vtl.model.Structured;
+import fr.insee.vtl.spark.SparkDataset;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import org.apache.spark.sql.Dataset;
+import org.apache.spark.sql.Row;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class RegisterMethodTest {
+
+  private static SparkSession spark;
+  private VtlScriptEngine engine;
+
+  @BeforeEach
+  public void setUp() {
+    spark = SparkSession.builder().appName("test").master("local").getOrCreate();
+
+    SparkSession.setActiveSession(spark);
+
+    ScriptEngineManager mgr = new ScriptEngineManager();
+    engine = (VtlScriptEngine) mgr.getEngineByExtension("vtl");
+    engine.put(VtlScriptEngine.PROCESSING_ENGINE_NAMES, "spark4");
+  }
+
+  @AfterEach
+  public void tearDown() throws IOException {
+    if (spark != null) spark.close();
+  }
+
+  @Test
+  public void registerTest() throws ScriptException, NoSuchMethodException {
+    engine.registerGlobalMethod("loadCSV", HandleDs.class.getMethod("loadCSV", String.class));
+    engine.registerGlobalMethod(
+        "writeCSV",
+        HandleDs.class.getMethod("writeCSV", String.class, fr.insee.vtl.model.Dataset.class));
+    engine.registerGlobalMethod(
+        "getSize", HandleDs.class.getMethod("getSize", fr.insee.vtl.model.Dataset.class));
+    engine.eval(
+        "a := loadCSV(\"src/main/resources/ds1.csv\"); "
+            + "b := a[calc toto := \"test\"]; "
+            + "c := writeCSV(\"src/main/resources/ds1_out.csv\", b);"
+            + "d := getSize(b);");
+    fr.insee.vtl.model.Dataset a =
+        (fr.insee.vtl.model.Dataset) engine.getContext().getAttribute("a");
+    Structured.DataStructure dataStructure = a.getDataStructure();
+    String d = (String) engine.getContext().getAttribute("d");
+  }
+
+  public static class HandleDs {
+    public static SparkDataset loadCSV(String path) throws Exception {
+      Dataset<Row> ds;
+      try {
+        ds = spark.read().option("sep", ";").option("header", "true").csv(path);
+      } catch (Exception e) {
+        throw new Exception(e);
+      }
+      return new SparkDataset(ds);
+    }
+
+    public static void writeCSV(String location, fr.insee.vtl.model.Dataset dataset) {
+      org.apache.spark.sql.Dataset<Row> sparkDataset = asSparkDataset(dataset).getSparkDataset();
+      // Commented to avoid git issues, but function is found at high level
+      // sparkDataset.write().mode(SaveMode.Overwrite).csv(location);
+    }
+
+    public static String getSize(fr.insee.vtl.model.Dataset dataset) {
+      return "Dataset size: " + dataset.getDataPoints().size();
+    }
+
+    private static SparkDataset asSparkDataset(fr.insee.vtl.model.Dataset dataset) {
+      if (dataset instanceof SparkDataset sparkDataset) {
+        return sparkDataset;
+      } else {
+        return new SparkDataset(dataset, getRoleMap(dataset), spark);
+      }
+    }
+
+    private static Map<String, fr.insee.vtl.model.Dataset.Role> getRoleMap(
+        Collection<Structured.Component> components) {
+      return components.stream()
+          .collect(Collectors.toMap(Structured.Component::getName, Structured.Component::getRole));
+    }
+
+    private static Map<String, fr.insee.vtl.model.Dataset.Role> getRoleMap(
+        fr.insee.vtl.model.Dataset dataset) {
+      return getRoleMap(dataset.getDataStructure().values());
+    }
+  }
+}