merge from upstream

Author: junphine

.github/workflows/publish-website-on-branch-update.yml

@@ -59,6 +59,26 @@ jobs:
             exit 1
           fi
 
+      - name: Validate ignite-website token
+        env:
+          GH_TOKEN: ${{ secrets.IGNITE_WEBSITE_BUILD }}
+        run: |
+          if [ -z "$GH_TOKEN" ]; then
+            echo "::error::Secret IGNITE_WEBSITE_BUILD is empty or missing."
+            echo "::error::Please contact Apache INFRA to create or update the token."
+            echo "::error::Example INFRA ticket:"
+            echo "::error::https://issues.apache.org/jira/browse/INFRA-27835"
+            exit 1
+          fi
+
+          if ! git ls-remote https://x-access-token:${GH_TOKEN}@github.com/apache/ignite-website.git &>/dev/null; then
+            echo "::error::Invalid or expired IGNITE_WEBSITE_BUILD token."
+            echo "::error::Please contact Apache INFRA to renew or recreate the token."
+            echo "::error::Example INFRA ticket:"
+            echo "::error::https://issues.apache.org/jira/browse/INFRA-27835"
+            exit 1
+          fi
+
       - name: Check out 'ignite-website' repository code
         uses: actions/checkout@v3
         with:

docs/_data/toc.yaml

@@ -232,8 +232,8 @@
       url: sql-reference/ddl
     - title: Data Manipulation Language (DML)
       url: sql-reference/dml
-    - title: Transactions
-      url: key-value-api/transactions
+    - title: Transaction-aware Queries
+      url: SQL/sql-calcite#transaction-aware-queries
     - title: Operational Commands
       url: sql-reference/operational-commands
     - title: Aggregate functions

docs/_docs/SQL/JDBC/jdbc-driver.adoc

@@ -564,9 +564,9 @@ JDBC Thin Driver supports the standard JDBC savepoint API for explicit transacti
 * `Connection.rollback(Savepoint savepoint)`
 * `Connection.releaseSavepoint(Savepoint savepoint)`
 
-Savepoints are available for JDBC connections that use the Calcite-based SQL engine and explicit `PESSIMISTIC` transactions.
+Savepoints are available for JDBC connections that use the Calcite-based SQL engine and explicit transactions.
 Disable auto-commit before creating a savepoint.
-If auto-commit is left enabled, JDBC savepoint API calls requiring an explicit transaction will fail with 'SQLException'.
+If auto-commit is left enabled, JDBC savepoint API calls requiring a transaction will fail with 'SQLException'.
 
 [source,java]
 ----

docs/_docs/SQL/sql-calcite.adoc

@@ -485,7 +485,7 @@ Disables certain optimizer rules. This is an optimizer level hint.
 SELECT /*+ DISABLE_RULE('MergeJoinConverter') */ T1.* FROM TBL1 T1 JOIN TBL2 T2 ON T1.V1=T2.V1 WHERE T2.V2=?
 ----
 
-== Transactions [[transactions]]
+== Transaction-aware Queries [[transaction-aware-queries]]
 
 The Calcite-based query engine supports SQL transactions with READ_COMMITTED isolation.
 To ensure backward compatibility, transaction support is disabled by default. To enable it, use the following configuration:

docs/_docs/code-snippets/java/pom.xml

@@ -101,15 +101,15 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.7.0</version>
+                <version>3.14.1</version>
                 <configuration>
                     <source>1.8</source>
                     <target>1.8</target>
                 </configuration>
             </plugin>
             <plugin>
                 <artifactId>maven-surefire-plugin</artifactId>
-                <version>2.22.2</version>
+                <version>3.5.4</version>
                 <configuration>
                     <includes>
                         <include>**/*.java</include>
@@ -118,7 +118,7 @@
             </plugin>
             <plugin>
                 <artifactId>maven-failsafe-plugin</artifactId>
-                <version>2.22.2</version>
+                <version>3.5.4</version>
             </plugin>
         </plugins>
     </build>

docs/_docs/code-snippets/java/src/main/java/org/apache/ignite/snippets/DistributedComputing.java

@@ -22,11 +22,17 @@
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.atomic.AtomicLong;
 
+import javax.cache.Cache;
+
 import org.apache.ignite.Ignite;
 import org.apache.ignite.IgniteCache;
 import org.apache.ignite.IgniteCluster;
 import org.apache.ignite.IgniteCompute;
 import org.apache.ignite.Ignition;
+import org.apache.ignite.cache.affinity.Affinity;
+import org.apache.ignite.cache.query.QueryCursor;
+import org.apache.ignite.cache.query.ScanQuery;
+import org.apache.ignite.cluster.ClusterNode;
 import org.apache.ignite.lang.IgniteCallable;
 import org.apache.ignite.lang.IgniteFuture;
 import org.apache.ignite.resources.IgniteInstanceResource;
@@ -194,4 +200,50 @@ public Integer call() throws Exception {
 
     // end::access-data[]
 
+    // tag::local-scan-query[]
+    public static class AverageAgeTask implements IgniteCallable<long[]> {
+        @IgniteInstanceResource
+        private Ignite ignite;
+
+        @Override
+        public long[] call() throws Exception {
+            IgniteCache<Long, Person> cache = ignite.cache("person");
+            Affinity<Long> affinity = ignite.affinity("person");
+            ClusterNode localNode = ignite.cluster().localNode();
+
+            long[] sumAndCount = new long[2];
+
+            try (QueryCursor<Cache.Entry<Long, Person>> cursor = cache
+                    .query(new ScanQuery<Long, Person>().setLocal(true))) {
+                for (Cache.Entry<Long, Person> entry : cursor) {
+                    if (affinity.isPrimary(localNode, entry.getKey())) {
+                        sumAndCount[0] += entry.getValue().getAge();
+                        sumAndCount[1]++;
+                    }
+                }
+            }
+
+            return sumAndCount;
+        }
+    }
+
+    void calculateAverageAge(Ignite ignite) {
+        Collection<long[]> results = ignite.compute(ignite.cluster().forDataNodes("person"))
+                .broadcast(new AverageAgeTask());
+
+        long totalAge = 0;
+        long totalCount = 0;
+
+        for (long[] result : results) {
+            totalAge += result[0];
+            totalCount += result[1];
+        }
+
+        double averageAge = totalCount == 0 ? 0 : (double) totalAge / totalCount;
+
+        System.out.println("Average age: " + averageAge);
+    }
+
+    // end::local-scan-query[]
+
 }

docs/_docs/data-streaming.adoc

@@ -68,7 +68,7 @@ DataStreamer doesn't guarantee:
 If <<overwriting, 'allowOverwrite'>> property is 'false' (default), consider:
 []
 - You should not have the same keys repeating in the data being streamed;
-- Streamer cancelation or streamer node failure can cause data inconsistency;
+- Streamer cancelation or topology change can cause data inconsistency;
 - If loading into a persistent cache, concurrently created snapshot may contain inconsistent data and might not be restored entirely.
 
 Most important behavior of Ignite Data Streamer is defined by <<receivers, stream receiver>> and

docs/_docs/distributed-computing/distributed-computing.adoc

@@ -305,60 +305,27 @@ If you want to use the key and value objects inside `IgniteCallable` and `Ignite
 ====
 
 
-////////////////////////////////////////////////////////////////////////////////
-
-
-
-In the cases where you do not need to colocate computations with data but simply want to process all data remotely, you can run local cache queries inside the `call()` method. Consider the following example.
-
-Let's say we have a cache that stores information about persons and we want to calculate the average age of all persons. One way to accomplish this is to run a link:key-value-api/using-cache-queries[scan query] that will fetch the ages of all persons to the local node, where you can calculate the average age.
-
-A more efficient way, however, is to avoid network calls to other nodes by running the query locally on each remote node and aggregating the result on the local node.
-
-This task can be easily split
-
-[source, java]
--------------------------------------------------------------------------------
-private class AverageAgeJob implements IgniteCallable<Double> {
-
-    @IgniteInstanceResource
-    private Ignite ignite;
-
-    @Override
-    public Double call() throws Exception {
-
-        IgniteCache<Long, Person> cache = ignite.cache("person");
-
-        int localAvg = 0;
-        try (QueryCursor<Cache.Entry<Long, Person>> cursor = cache
-                .query(new ScanQuery<Long, Person>().setLocal(true))) {
-            for (Cache.Entry<Long, Person> entry : cursor) {
-                localAvg += (int) entry.getValue().getAge();
-            }
-        }
-
-        return (localAvg / (double) cache.size());
-    }
-}
-
--------------------------------------------------------------------------------
-Note that the scan query is executed in the local mode. It means that it will only fetch objects from the Person cache that are stored localy and will not request data from other nodes.
+=== Processing Cache Data Locally
 
-If you broadcast this task to all nodes, all person objecs will be processed (each locally), and the results are sent to the node that initiated the task.
-
-[source, java]
--------------------------------------------------------------------------------
-Ignite ignite = Ignition.ignite();
-
-double average = ignite.compute().broadcast(new AverageAgeTask()).stream().reduce(0D, (a, b) -> a + b);
--------------------------------------------------------------------------------
-
-
-The task is executed on every node, where it will query all persons stored locally and calculate the local average. Then the result are sent to the node that initiated the task and summed up. In this implementation, objects are not transferred via network.
+If you need to process all cache data remotely, you can broadcast a task to the data nodes and run a local cache query inside the task.
+In this mode, each node scans only the cache entries stored locally, processes them there, and returns only the aggregated result to the caller.
 
+For example, assume that a cache stores `Person` objects and it is necessary to calculate the average age of all persons.
+A regular link:key-value-api/using-cache-queries[scan query] transfers matching entries to the query initiator page by page.
+The following example avoids transferring the full dataset over the network: the task is broadcast to the nodes that store data for the `person` cache, and each node runs `ScanQuery.setLocal(true)`.
+The task checks primary ownership so backup copies are not counted twice.
 
+[tabs]
+--
+tab:Java[]
+[source,java]
+----
+include::{javaFile}[tag=local-scan-query,indent=0]
+----
+tab:C#/.NET[unsupported]
 
-////////////////////////////////////////////////////////////////////////////////
+tab:C++[unsupported]
+--
 
 
 ////////////////////////////////////////////////////////////////////////////////

docs/_docs/key-value-api/transactions.adoc

@@ -92,10 +92,10 @@ It is critical that an Ignite Transaction should be `closed` regardless of its c
 
 == Transaction Savepoints
 
-Savepoints allow you to mark an intermediate state inside an explicit transaction and later roll back only the changes made after that point.
+Savepoints allow you to mark an intermediate state inside a transaction and later roll back only the changes made after that point.
 They are useful when a transaction contains several logical steps and one of the later steps can be discarded without rolling back the whole transaction.
 
-Ignite supports savepoints only for explicit `PESSIMISTIC` transactions.
+Ignite supports savepoints only for explicit transactions.
 Savepoints are local to the transaction that created them and are removed when the transaction is committed or rolled back.
 
 Use `Transaction.savepoint(name)` to create a savepoint.

docs/_docs/monitoring-metrics/system-views.adoc

@@ -497,6 +497,7 @@ This view exposes information about currently running SQL queries.
 |START_TIME | date | Query start time
 |DURATION | long | Query execution duration
 |INITIATOR_ID | string | User defined query initiator ID
+|MAP_QUERY | boolean | True if query is H2 map query
 |LOCAL | boolean | True if local only
 |SCHEMA_NAME | string | Schema name
 |SUBJECT_ID | UUID | The subject ID of the entity that initiated the query