core/src/main/java/io/questdb/cairo/wal/seq/TableSequencerImpl.java (1)

215-217: Guard against long→int overflow for WAL IDs.

IDGenerator.getNextId() returns long, casting to int risks overflow if IDs ever exceed Integer.MAX_VALUE. If the interface must return int, add a defensive check to fail fast.

-    public int getNextWalId() {
-        return (int) walIdGenerator.getNextId();
-    }
+    public int getNextWalId() {
+        final long id = walIdGenerator.getNextId();
+        if (id > Integer.MAX_VALUE) {
+            throw CairoException.critical(0).put("wal id overflow: ").put(id);
+        }
+        return (int) id;
+    }

core/src/main/java/io/questdb/cutlass/line/tcp/LineTcpMeasurementScheduler.java (2)

110-118: Nit: variable name consistency

Consider renaming networkSharedPoolSize → sharedNetworkPoolSize for consistency with the new terminology.

---

125-131: Guard against zero writer threads

If sharedPoolWrite.getWorkerCount() can ever be 0 (misconfiguration), downstream arrays will be zero-sized and later indexing will throw. Add a fail-fast check.

-            int nWriterThreads = sharedPoolWrite.getWorkerCount();
+            int nWriterThreads = sharedPoolWrite.getWorkerCount();
+            if (nWriterThreads <= 0) {
+                throw new IllegalArgumentException("sharedPoolWrite must have at least one worker");
+            }

core/src/test/java/io/questdb/test/TestServerConfiguration.java (1)

256-259: Optional: expose shared query/write configs for symmetry

If tests need them, also override getSharedWorkerPoolQueryConfiguration/getSharedWorkerPoolWriteConfiguration to return confSharedPool for consistency.

core/src/main/java/io/questdb/cutlass/line/tcp/LineTcpReceiver.java (1)

58-60: Initialize scheduler before registering dispatcher (minor ordering hardening)

Currently safe because pools aren’t started yet, but initializing scheduler first avoids future race potential if ordering changes.

-            this.dispatcher = IODispatchers.create(configuration, contextFactory);
-            sharedPoolNetwork.assign(dispatcher);
-            this.scheduler = new LineTcpMeasurementScheduler(configuration, engine, sharedPoolNetwork, dispatcher, sharedPoolWrite);
+            this.dispatcher = IODispatchers.create(configuration, contextFactory);
+            this.scheduler = new LineTcpMeasurementScheduler(configuration, engine, sharedPoolNetwork, dispatcher, sharedPoolWrite);
+            sharedPoolNetwork.assign(dispatcher);

Also applies to: 61-65

core/src/test/java/io/questdb/test/WorkerPoolManagerTest.java (1)

81-95: Nit: local variable naming

Consider renaming variables like networkSharedPool → sharedPoolNetwork to mirror the API and reduce cognitive load.

core/src/main/java/io/questdb/WorkerPoolManager.java (3)

54-56: Minor: avoid duplicate getter and clarify intent.

Cache the query configuration locally to avoid the double call and improve readability.

-        sharedPoolNetwork = new WorkerPool(config.getSharedWorkerPoolNetworkConfiguration());
-        sharedPoolQuery = config.getSharedWorkerPoolQueryConfiguration().getWorkerCount() > 0 ? new WorkerPool(config.getSharedWorkerPoolQueryConfiguration()) : null;
+        sharedPoolNetwork = new WorkerPool(config.getSharedWorkerPoolNetworkConfiguration());
+        final WorkerPoolConfiguration queryConf = config.getSharedWorkerPoolQueryConfiguration();
+        sharedPoolQuery = queryConf.getWorkerCount() > 0 ? new WorkerPool(queryConf) : null;
         sharedPoolWrite = new WorkerPool(config.getSharedWorkerPoolWriteConfiguration());

---

71-73: Add no-arg write accessor for symmetry and clarity.

Like network’s no-arg getter, provide an explicit shared write accessor to avoid accidental dedicated-pool selection when a config is passed.

     public WorkerPool getSharedPoolWrite(@NotNull WorkerPoolConfiguration config, @NotNull Requester requester) {
         return getWorkerPool(config, requester, sharedPoolWrite);
     }
+
+    public WorkerPool getSharedPoolWrite() {
+        return sharedPoolWrite;
+    }

---

178-181: Annotate sharedPoolQuery as nullable in the hook.

This parameter can be null when parallel querying is disabled; make it explicit.

-    protected abstract void configureWorkerPools(
-            final WorkerPool sharedPoolQuery,
-            final WorkerPool sharedPoolWrite
-    );
+    protected abstract void configureWorkerPools(
+            @Nullable final WorkerPool sharedPoolQuery,
+            final WorkerPool sharedPoolWrite
+    );

core/src/main/java/io/questdb/ServerConfiguration.java (1)

87-92: Bridge old pool getters to preserve binary compatibility.

Add deprecated default methods mapping old names to the new “shared” accessors to ease downstream upgrades.

     WorkerPoolConfiguration getSharedWorkerPoolWriteConfiguration();
 
+    /** @deprecated use {@link #getSharedWorkerPoolNetworkConfiguration()} */
+    @Deprecated
+    default WorkerPoolConfiguration getNetworkWorkerPoolConfiguration() {
+        return getSharedWorkerPoolNetworkConfiguration();
+    }
+    /** @deprecated use {@link #getSharedWorkerPoolQueryConfiguration()} */
+    @Deprecated
+    default WorkerPoolConfiguration getQueryWorkerPoolConfiguration() {
+        return getSharedWorkerPoolQueryConfiguration();
+    }
+    /** @deprecated use {@link #getSharedWorkerPoolWriteConfiguration()} */
+    @Deprecated
+    default WorkerPoolConfiguration getWriteWorkerPoolConfiguration() {
+        return getSharedWorkerPoolWriteConfiguration();
+    }

Also consider a brief Javadoc note that “dedicated vs shared” is selected by WorkerPoolConfiguration.getWorkerCount() (0 → shared).

core/src/main/java/io/questdb/DynamicPropServerConfiguration.java (2)

359-361: Consistency: add non-reloadable comment like network.

Keep comments uniform across the three shared pool getters.

     @Override
     public WorkerPoolConfiguration getSharedWorkerPoolQueryConfiguration() {
+        // nested object is kept non-reloadable
         return serverConfig.get().getSharedWorkerPoolQueryConfiguration();
     }

---

364-366: Consistency: add non-reloadable comment like network.

     @Override
     public WorkerPoolConfiguration getSharedWorkerPoolWriteConfiguration() {
+        // nested object is kept non-reloadable
         return serverConfig.get().getSharedWorkerPoolWriteConfiguration();
     }

core/src/main/java/io/questdb/ServerMain.java (2)

399-404: Clarify the comment vs API name

The comment says “dedicated pool”, but the API used is getSharedPoolWrite. If this method conditionally creates a dedicated pool, please reword the comment to reflect that to avoid confusion during maintenance.

-                // This starts mat view refresh jobs only when there is a dedicated pool for mat view refresh
-                // this will not use shared pool write because getWorkerCount() > 0
+                // Starts MV refresh jobs using a dedicated write pool (via manager), since workerCount > 0

---

405-409: Include env var hint in advisory

Surface both the property path and its env var to make the message actionable in containerized setups.

-                log.advisory().$("mat view refresh is disabled; set ")
-                        .$(MAT_VIEW_REFRESH_WORKER_COUNT.getPropertyPath())
-                        .$(" to a positive value or keep default to enable mat view refresh.")
-                        .$();
+                log.advisory().$("mat view refresh is disabled; set ")
+                        .$(MAT_VIEW_REFRESH_WORKER_COUNT.getPropertyPath())
+                        .$(" (env: ")
+                        .$(propertyPathToEnvVarName(MAT_VIEW_REFRESH_WORKER_COUNT.getPropertyPath()))
+                        .$(") to a positive value or keep default to enable mat view refresh.")
+                        .$();

core/src/test/java/io/questdb/test/PropServerConfigurationTest.java (1)

1082-1090: Use hyphenated pool names in DefaultServerConfiguration
Replace underscore-separated names with hyphens to match PropServerConfiguration:
• In DefaultServerConfiguration (core/src/main/java/io/questdb/DefaultServerConfiguration.java), change
– "shared_network" → "shared-network"
– "shared_query" → "shared-query"
– "shared_write" → "shared-write"

core/src/main/java/io/questdb/DefaultServerConfiguration.java (1)

61-66: Use hyphenated pool names for consistency

Elsewhere (tests, logs) pools use “shared-network/query/write”, “mat-view-refresh”, “wal-apply”. Recommend aligning defaults here.

-        this.sharedPoolNetworkConfiguration = new DefaultWorkerPoolConfiguration("shared_network");
-        this.sharedPoolQueryConfiguration = new DefaultWorkerPoolConfiguration("shared_query");
-        this.sharedPoolWriteConfiguration = new DefaultWorkerPoolConfiguration("shared_write");
-        this.matViewRefreshPoolConfiguration = new DefaultWorkerPoolConfiguration("mat_view_refresh");
-        this.walApplyPoolConfiguration = new DefaultWorkerPoolConfiguration("wal_apply");
+        this.sharedPoolNetworkConfiguration = new DefaultWorkerPoolConfiguration("shared-network");
+        this.sharedPoolQueryConfiguration = new DefaultWorkerPoolConfiguration("shared-query");
+        this.sharedPoolWriteConfiguration = new DefaultWorkerPoolConfiguration("shared-write");
+        this.matViewRefreshPoolConfiguration = new DefaultWorkerPoolConfiguration("mat-view-refresh");
+        this.walApplyPoolConfiguration = new DefaultWorkerPoolConfiguration("wal-apply");

core/src/main/java/io/questdb/PropServerConfiguration.java (2)

1738-1742: Keep query pool affinity consistent when disabling the pool

Directly mutating sharedWorkerCount to 0 can leave a stale non-empty affinity array. Also clear affinity.

-                sharedWorkerPoolQueryConfiguration.sharedWorkerCount = 0;
+                sharedWorkerPoolQueryConfiguration.sharedWorkerCount = 0;
+                sharedWorkerPoolQueryConfiguration.sharedWorkerAffinity = new int[0];

---

5183-5228: Optional: make mat-view pool priority and enablement explicit

For parity with other pools and easier ops tuning, consider setting an explicit priority and an isEnabled() guard.

         @Override
         public boolean haltOnError() {
             return matViewRefreshWorkerHaltOnError;
         }
+
+        @Override
+        public int workerPoolPriority() {
+            // Keep below network to avoid starving IO; align with write pool bias.
+            return Thread.NORM_PRIORITY - 1;
+        }
+
+        @Override
+        public boolean isEnabled() {
+            return matViewRefreshWorkerCount > 0;
+        }

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro