IGNITE-24669 Set H2 default SQL plan history to zero - Fixes #11903.

Signed-off-by: Aleksey Plekhanov <plehanov.alex@gmail.com>

Author: oleg-vlsk

modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/SqlPlanHistoryIntegrationTest.java

@@ -57,6 +57,7 @@
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
+import static org.apache.ignite.configuration.SqlConfiguration.DFLT_SQL_PLAN_HISTORY_SIZE;
 import static org.apache.ignite.internal.processors.query.running.RunningQueryManager.SQL_PLAN_HIST_VIEW;
 import static org.apache.ignite.testframework.GridTestUtils.waitForCondition;
 import static org.junit.Assert.assertNotEquals;
@@ -101,6 +102,18 @@ public class SqlPlanHistoryIntegrationTest extends GridCommonAbstractTest {
         ), false
     );
 
+    /** Flag indicating whether SQL is configured by using {@link IgniteConfiguration#setSqlConfiguration(SqlConfiguration)}. */
+    private boolean isSqlConfigured = true;
+
+    /** Flag indicating whether the SQL engine is configured within {@link SqlConfiguration}. */
+    private boolean isSqlEngineConfigured = true;
+
+    /**
+     * Flag indicating whether a custom SQL plan history size is explicitly set within {@link SqlConfiguration}.
+     * If {@code false}, the default SQL plan history size will be used.
+     */
+    private boolean isPlanHistorySizeSet = true;
+
     /** SQL plan history size. */
     private int planHistorySize = 10;
 
@@ -140,10 +153,18 @@ public static Collection<Object[]> params() {
     @Override protected IgniteConfiguration getConfiguration(String igniteInstanceName) throws Exception {
         IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName);
 
-        cfg.setSqlConfiguration(new SqlConfiguration()
-            .setSqlPlanHistorySize(planHistorySize)
-            .setQueryEnginesConfiguration(configureSqlEngine())
-        );
+        if (isSqlConfigured) {
+            SqlConfiguration sqlCfg = new SqlConfiguration();
+
+            if (isSqlEngineConfigured) {
+                sqlCfg.setQueryEnginesConfiguration(configureSqlEngine());
+
+                if (isPlanHistorySizeSet)
+                    sqlCfg.setSqlPlanHistorySize(planHistorySize);
+            }
+
+            cfg.setSqlConfiguration(sqlCfg);
+        }
 
         return cfg.setCacheConfiguration(
             configureCache("A", Integer.class, String.class),
@@ -425,6 +446,45 @@ public void testResetPlanHistoryMetrics() throws Exception {
         checkReset(() -> queryNode().context().query().runningQueryManager().resetPlanHistoryMetrics());
     }
 
+    /**
+     * Checks that the actual SQL plan history remains empty and its size in {@link SqlConfiguration} equals {@code -1}
+     * when SQL is not explicitly configured. In such cases, H2 is used as the default engine.
+     */
+    @Test
+    public void testNoSqlConfiguration() throws Exception {
+        isSqlConfigured = false;
+
+        checkDefaultHistorySize(true, -1, 0, 1);
+    }
+
+    /**
+     * Checks that the actual SQL plan history remains empty and its size in {@link SqlConfiguration} equals {@code -1}
+     * when the SQL engine is not configured. In such cases, H2 is used as the default engine.
+     */
+    @Test
+    public void testNoSqlEngineConfiguration() throws Exception {
+        isSqlEngineConfigured = false;
+
+        checkDefaultHistorySize(true, -1, 0, 1);
+    }
+
+    /**
+     * Checks that the actual SQL plan history size and its value in {@link SqlConfiguration} are correct for both
+     * Calcite and H2 engines when the history size is not explicitly set.
+     */
+    @Test
+    public void testDefaultHistorySize() throws Exception {
+        isPlanHistorySizeSet = false;
+
+        boolean isCalcite = sqlEngine.equals(CalciteQueryEngineConfiguration.ENGINE_NAME);
+
+        int expConfHistSize = isCalcite ? DFLT_SQL_PLAN_HISTORY_SIZE : -1;
+        int expHistSize = isCalcite ? DFLT_SQL_PLAN_HISTORY_SIZE : 0;
+        int qrys = isCalcite ? DFLT_SQL_PLAN_HISTORY_SIZE : 1;
+
+        checkDefaultHistorySize(false, expConfHistSize, expHistSize, qrys);
+    }
+
     /**
      * Checks that there is no 'scanCount' suffix in H2 local query plans even if identical queries are not
      * executed one after another (when there are other queries executed between them).
@@ -709,6 +769,38 @@ public void checkEmptyHistory(Runnable setup, boolean startGridFirst) throws Exc
         assertTrue(getSqlPlanHistory().isEmpty());
     }
 
+    /**
+     * @param isSingleEngineCheck Flag indicating whether the test should be run for one SQL engine or for both of them.
+     * @param expConfHistSize Expected SQL plan history size in {@link SqlConfiguration}.
+     * @param expHistSize Expected actual SQL plan history size.
+     * @param qrys Nubmer of queries to be run in the test.
+     */
+    public void checkDefaultHistorySize(
+        boolean isSingleEngineCheck,
+        int expConfHistSize,
+        int expHistSize,
+        int qrys
+    ) throws Exception {
+        if (isSingleEngineCheck)
+            assumeFalse(sqlEngine == CalciteQueryEngineConfiguration.ENGINE_NAME);
+
+        assumeFalse(isClient || loc || isFullyFetched);
+
+        startTestGrid();
+
+        int confHistSize = queryNode().configuration().getSqlConfiguration().getSqlPlanHistorySize();
+
+        assertEquals(expConfHistSize, confHistSize);
+
+        for (int i = 0; i < qrys; i++) {
+            String sql = "select * from A.String where _key <= " + i;
+
+            cacheQuery(new SqlFieldsQuery(sql), "A");
+        }
+
+        assertEquals(expHistSize, getSqlPlanHistory().size());
+    }
+
     /** */
     private static class Person {
         /** */

modules/core/src/main/java/org/apache/ignite/configuration/SqlConfiguration.java

@@ -49,7 +49,7 @@ public class SqlConfiguration {
     private int sqlQryHistSize = DFLT_SQL_QUERY_HISTORY_SIZE;
 
     /** SQL plan history size. */
-    private int sqlPlanHistSize = DFLT_SQL_PLAN_HISTORY_SIZE;
+    private int sqlPlanHistSize = -1;
 
     /** Enable validation of key & values against sql schema. */
     private boolean validationEnabled;
@@ -114,9 +114,9 @@ public SqlConfiguration setSqlQueryHistorySize(int size) {
     }
 
     /**
-     * Number of SQL plan history elements to keep in memory. If not provided, then default value {@link
-     * #DFLT_SQL_PLAN_HISTORY_SIZE} is used. If provided value is less or equals 0, then gathering SQL plan history
-     * will be switched off.
+     * Number of SQL plan history elements to keep in memory. If not provided, then default value {@code -1} applies when
+     * the indexing module is in use and {@link #DFLT_SQL_PLAN_HISTORY_SIZE} is used for other engines. If provided value
+     * is less or equals 0, then gathering SQL plan history will be switched off.
      *
      * @return SQL plan history size.
      */
@@ -125,8 +125,8 @@ public int getSqlPlanHistorySize() {
     }
 
     /**
-     * Sets number of SQL plan history elements kept in memory. If not explicitly set, then default value is {@link
-     * #DFLT_SQL_PLAN_HISTORY_SIZE}.
+     * Sets number of SQL plan history elements kept in memory. If not explicitly set, then default value {@code -1}
+     * applies when the indexing module is in use and {@link #DFLT_SQL_PLAN_HISTORY_SIZE} is used for other engines.
      *
      * @param size Number of SQL plan history elements kept in memory.
      * @return {@code this} for chaining.

modules/core/src/main/java/org/apache/ignite/internal/processors/query/GridQueryProcessor.java

@@ -4441,4 +4441,9 @@ public SchemaSqlViewManager sqlViewManager() {
     public IgniteStatisticsManager statsManager() {
         return statsMgr;
     }
+
+    /** @return Default query engine. */
+    public QueryEngine defaultQueryEngine() {
+        return dfltQryEngine;
+    }
 }

modules/core/src/main/java/org/apache/ignite/internal/processors/query/running/RunningQueryManager.java

@@ -72,6 +72,7 @@
 import org.apache.ignite.spi.systemview.view.SqlQueryView;
 import org.jetbrains.annotations.Nullable;
 
+import static org.apache.ignite.configuration.SqlConfiguration.DFLT_SQL_PLAN_HISTORY_SIZE;
 import static org.apache.ignite.internal.processors.cache.query.GridCacheQueryType.SQL;
 import static org.apache.ignite.internal.processors.cache.query.GridCacheQueryType.SQL_FIELDS;
 import static org.apache.ignite.internal.processors.metric.impl.MetricUtils.metricName;
@@ -192,14 +193,19 @@ public RunningQueryManager(GridKernalContext ctx) {
 
         localNodeId = ctx.localNodeId();
 
-        histSz = ctx.config().getSqlConfiguration().getSqlQueryHistorySize();
+        final SqlConfiguration sqlCfg = ctx.config().getSqlConfiguration();
+
+        histSz = sqlCfg.getSqlQueryHistorySize();
         closure = ctx.closure();
 
         qryHistTracker = new QueryHistoryTracker(histSz);
 
         heavyQrysTracker = ctx.query().moduleEnabled() ? new HeavyQueriesTracker(ctx) : null;
 
-        planHistSz = ctx.config().getSqlConfiguration().getSqlPlanHistorySize();
+        if (sqlCfg.getSqlPlanHistorySize() < 0 && ctx.query().defaultQueryEngine() != null)
+            sqlCfg.setSqlPlanHistorySize(DFLT_SQL_PLAN_HISTORY_SIZE);
+
+        planHistSz = sqlCfg.getSqlPlanHistorySize();
 
         planHistTracker = new SqlPlanHistoryTracker(planHistSz);