diff --git a/src/ccontrol/CMakeLists.txt b/src/ccontrol/CMakeLists.txt
index 8b8cb78211..0f5695a47d 100644
--- a/src/ccontrol/CMakeLists.txt
+++ b/src/ccontrol/CMakeLists.txt
@@ -15,6 +15,7 @@ target_sources(ccontrol PRIVATE
     ParseRunner.cc
     QueryState.cc
     UserQueryAsyncResult.cc
+    UserQueryExplain.cc
     UserQueryFactory.cc
     UserQueryProcessList.cc
     UserQueryQueries.cc
diff --git a/src/ccontrol/UserQueryExplain.cc b/src/ccontrol/UserQueryExplain.cc
new file mode 100644
index 0000000000..d45694b8f7
--- /dev/null
+++ b/src/ccontrol/UserQueryExplain.cc
@@ -0,0 +1,213 @@
+// -*- LSST-C++ -*-
+/*
+ * LSST Data Management System
+ * Copyright 2026 LSST.
+ *
+ * This product includes software developed by the
+ * LSST Project (http://www.lsst.org/).
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the LSST License Statement and
+ * the GNU General Public License along with this program.  If not,
+ * see <http://www.lsstcorp.org/LegalNotices/>.
+ */
+
+// Class header
+#include "ccontrol/UserQueryExplain.h"
+
+// System headers
+#include <sstream>
+
+// Third-party headers
+#include "nlohmann/json.hpp"
+
+// LSST headers
+#include "lsst/log/Log.h"
+
+// Qserv headers
+#include "cconfig/CzarConfig.h"
+#include "qdisp/MessageStore.h"
+#include "qproc/QuerySession.h"
+#include "query/AreaRestrictor.h"
+#include "query/QueryTemplate.h"
+#include "query/ScanTableInfo.h"
+#include "query/SecIdxRestrictor.h"
+#include "query/SelectStmt.h"
+#include "query/typedefs.h"
+#include "sql/SqlBulkInsert.h"
+#include "sql/SqlConnection.h"
+#include "sql/SqlConnectionFactory.h"
+#include "sql/SqlErrorObject.h"
+#include "util/IterableFormatter.h"
+
+using namespace lsst::qserv;
+using json = nlohmann::json;
+
+namespace {
+LOG_LOGGER _log = LOG_GET("lsst.qserv.ccontrol.UserQueryExplain");
+
+/// Concatenate restrictors for display
+template <typename VecPtr>
+std::string restrictorsToString(VecPtr const& restrictors) {
+    if (restrictors == nullptr || restrictors->empty()) return "none";
+    std::ostringstream os;
+    os << util::ptrPrintable(restrictors, "", "");
+    return os.str();
+}
+
+/// Convert JSON values for use in MariaDB-style EXPLAIN table
+std::string jsonValueToString(json const& value) {
+    if (value.is_string()) return value.get<std::string>();
+    if (value.is_boolean()) return value.get<bool>() ? "yes" : "no";
+    if (value.is_number()) return value.dump();
+    return value.dump(2);
+}
+
+}  // namespace
+
+namespace lsst::qserv::ccontrol {
+
+UserQueryExplain::UserQueryExplain(std::shared_ptr<qproc::QuerySession> const& qSession,
+                                   std::string const& userQueryId, std::string const& resultDb,
+                                   bool jsonFormat)
+        : _qSession(qSession),
+          _jsonFormat(jsonFormat),
+          _messageStore(std::make_shared<qdisp::MessageStore>()),
+          _resultTableName("qserv_result_explain_" + userQueryId),
+          _resultDb(resultDb) {}
+
+std::string UserQueryExplain::getError() const { return _qSession->getError(); }
+
+json UserQueryExplain::_getQueryInfo() const {
+    auto const& qs = *_qSession;
+    json qInfo = json::object();
+
+    qInfo["parsed_sql"] = qs.getStmt().getQueryTemplate().sqlFragment();
+
+    std::ostringstream irStream;
+    irStream << qs.getStmt();
+    qInfo["parsed_ir"] = irStream.str();
+
+    qInfo["needs_merge"] = qs.needsMerge();
+    auto const mergeStmt = qs.getMergeStmt();
+    qInfo["merge_sql"] = mergeStmt != nullptr ? mergeStmt->getQueryTemplate().sqlFragment() : "none";
+
+    qInfo["is_chunked"] = qs.hasChunks();
+    qInfo["chunks_matched"] = qs.isDummy() ? 0 : qs.getChunksSize();
+
+    qInfo["area_restrictors"] = restrictorsToString(qs.getAreaRestrictors());
+    qInfo["secidx_restrictors"] = restrictorsToString(qs.getSecIdxRestrictors());
+
+    qInfo["scan_interactive"] = qs.getScanInteractive();
+    auto const scanInfo = qs.getScanInfo();
+    qInfo["scan_rating"] = scanInfo.scanRating;
+    json scanTables = json::array();
+    for (auto const& tbl : scanInfo.infoTables) {
+        scanTables.push_back(json::object({{"db", tbl.db},
+                                           {"table", tbl.table},
+                                           {"rating", tbl.scanRating},
+                                           {"lock_in_memory", tbl.lockInMemory}}));
+    }
+    qInfo["scan_tables"] = scanTables;
+
+    std::ostringstream workerStream;
+    bool first = true;
+    for (auto const& stmt : qs.getStmtParallel()) {
+        if (stmt == nullptr) continue;
+        if (!first) workerStream << " /*QSEPARATOR*/; ";
+        workerStream << stmt->getQueryTemplate().sqlFragment();
+        first = false;
+    }
+    qInfo["worker_sql"] = first ? "none" : workerStream.str();
+
+    return qInfo;
+}
+
+std::string UserQueryExplain::getResultQuery() const {
+    return "SELECT * FROM " + _resultDb + "." + _resultTableName + " ORDER BY 1";
+}
+
+void UserQueryExplain::submit() {
+    try {
+        _populateResultTable();
+    } catch (std::exception const& exc) {
+        std::string const message = std::string("Internal failure, EXPLAIN failed: ") + exc.what();
+        LOGS(_log, LOG_LVL_ERROR, message);
+        _messageStore->addMessage(-1, "EXPLAIN", 1051, message, MessageSeverity::MSG_ERROR);
+        _qState = ERROR;
+    }
+}
+
+void UserQueryExplain::_populateResultTable() {
+    auto qInfo = _getQueryInfo();
+
+    auto const czarConfig = cconfig::CzarConfig::instance();
+    auto const resultDbConn = sql::SqlConnectionFactory::make(czarConfig->getMySqlResultConfig());
+    sql::SqlErrorObject errObj;
+
+    auto fail = [this](int code, std::string const& message) {
+        LOGS(_log, LOG_LVL_ERROR, message);
+        _messageStore->addMessage(-1, "EXPLAIN", code, message, MessageSeverity::MSG_ERROR);
+        _qState = ERROR;
+    };
+
+    std::string createTable;
+    std::vector<std::string> columns;
+    std::vector<std::vector<std::string>> rows;
+
+    if (_jsonFormat) {
+        // Single-column, single-row JSON document (like MariaDB EXPLAIN FORMAT=JSON).
+        createTable = "CREATE TABLE " + _resultTableName + " (`EXPLAIN` MEDIUMTEXT)";
+        columns = {"EXPLAIN"};
+        rows.push_back({qInfo.dump(2)});
+    } else {
+        // Attribute/value table, one row per entry
+        createTable = "CREATE TABLE " + _resultTableName + " (`attribute` VARCHAR(255), `value` MEDIUMTEXT)";
+        columns = {"attribute", "value"};
+        for (auto const& [key, value] : qInfo.items()) {
+            rows.push_back({key, jsonValueToString(value)});
+        }
+    }
+
+    LOGS(_log, LOG_LVL_DEBUG, "creating result table: " << createTable);
+    if (!resultDbConn->runQuery(createTable, errObj)) {
+        fail(1051, "Internal failure, failed to create result table: " + errObj.errMsg());
+        return;
+    }
+
+    sql::SqlBulkInsert bulkInsert(resultDbConn.get(), _resultTableName, columns);
+    for (auto const& row : rows) {
+        std::vector<std::string> values;
+        values.reserve(row.size());
+        for (auto const& value : row) {
+            values.push_back("'" + resultDbConn->escapeString(value) + "'");
+        }
+        if (!bulkInsert.addRow(values, errObj)) {
+            fail(1051, "Internal failure, error updating result table: " + errObj.errMsg());
+            return;
+        }
+    }
+    if (!bulkInsert.flush(errObj)) {
+        fail(1051, "Internal failure, error updating result table: " + errObj.errMsg());
+        return;
+    }
+
+    _qState = SUCCESS;
+}
+
+QueryState UserQueryExplain::join() { return _qState; }
+
+void UserQueryExplain::kill() {}
+
+void UserQueryExplain::discard() {}
+
+}  // namespace lsst::qserv::ccontrol
diff --git a/src/ccontrol/UserQueryExplain.h b/src/ccontrol/UserQueryExplain.h
new file mode 100644
index 0000000000..f39a501458
--- /dev/null
+++ b/src/ccontrol/UserQueryExplain.h
@@ -0,0 +1,106 @@
+// -*- LSST-C++ -*-
+/*
+ * LSST Data Management System
+ * Copyright 2026 LSST.
+ *
+ * This product includes software developed by the
+ * LSST Project (http://www.lsst.org/).
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the LSST License Statement and
+ * the GNU General Public License along with this program.  If not,
+ * see <http://www.lsstcorp.org/LegalNotices/>.
+ */
+
+#ifndef LSST_QSERV_CCONTROL_USERQUERYEXPLAIN_H
+#define LSST_QSERV_CCONTROL_USERQUERYEXPLAIN_H
+
+// System headers
+#include <memory>
+#include <string>
+
+// Third-party headers
+#include "nlohmann/json_fwd.hpp"
+
+// Qserv headers
+#include "ccontrol/UserQuery.h"
+#include "global/intTypes.h"
+
+// Forward decl
+namespace lsst::qserv::qproc {
+class QuerySession;
+}  // namespace lsst::qserv::qproc
+
+namespace lsst::qserv::ccontrol {
+
+/// UserQueryExplain : implementation of UserQuery for `EXPLAIN [FORMAT=JSON] <select>`.
+///
+/// The supplied QuerySession should have already had analysis run previously. This query type places analysis
+/// info into a result table (either tabular or JSON format).
+class UserQueryExplain : public UserQuery {
+public:
+    /**
+     *  @param qSession   Already-analyzed QuerySession for the inner SELECT query.
+     *  @param userQueryId Unique string identifying query
+     *  @param resultDb   Name of the database that will contain results.
+     *  @param jsonFormat If true, output a single-column JSON document
+     */
+    UserQueryExplain(std::shared_ptr<qproc::QuerySession> const& qSession, std::string const& userQueryId,
+                     std::string const& resultDb, bool jsonFormat);
+
+    UserQueryExplain(UserQueryExplain const&) = delete;
+    UserQueryExplain& operator=(UserQueryExplain const&) = delete;
+
+    /// @return a non-empty string describing the current error state
+    std::string getError() const override;
+
+    /// Populate the EXPLAIN result table.
+    void submit() override;
+
+    /// Wait until the query has completed execution (everything happens in submit()).
+    QueryState join() override;
+
+    /// No-op, does not run async
+    void kill() override;
+
+    /// No-op, no resources to release
+    void discard() override;
+
+    // Delegate objects
+    std::shared_ptr<qdisp::MessageStore> getMessageStore() override { return _messageStore; }
+
+    /// @return Name of the result table for this query.
+    std::string getResultTableName() const override { return _resultTableName; }
+
+    /// @return Result location for this query.
+    std::string getResultLocation() const override { return "table:" + getResultTableName(); }
+
+    std::string getResultQuery() const override;
+
+private:
+    /// Gather query analysis info as JSON, one attribute per key.
+    nlohmann::json _getQueryInfo() const;
+
+    /// Create and populate the result table. May throw; callers must not let that escape submit().
+    void _populateResultTable();
+
+    std::shared_ptr<qproc::QuerySession> _qSession;
+    bool const _jsonFormat;
+    QueryState _qState = UNKNOWN;
+    std::shared_ptr<qdisp::MessageStore> _messageStore;
+    std::string _resultTableName;
+    std::string _resultDb;
+};
+
+}  // namespace lsst::qserv::ccontrol
+
+#endif  // LSST_QSERV_CCONTROL_USERQUERYEXPLAIN_H
diff --git a/src/ccontrol/UserQueryFactory.cc b/src/ccontrol/UserQueryFactory.cc
index b17066d2f3..3ea2f03d69 100644
--- a/src/ccontrol/UserQueryFactory.cc
+++ b/src/ccontrol/UserQueryFactory.cc
@@ -41,6 +41,7 @@
 #include "ccontrol/ConfigMap.h"
 #include "ccontrol/ParseRunner.h"
 #include "ccontrol/UserQueryAsyncResult.h"
+#include "ccontrol/UserQueryExplain.h"
 #include "ccontrol/UserQueryInvalid.h"
 #include "ccontrol/UserQueryProcessList.h"
 #include "ccontrol/UserQueryQueries.h"
@@ -181,6 +182,63 @@ std::shared_ptr<UserQuery> _makeUserQueryQueries(query::SelectStmt::Ptr& stmt,
     }
 }
 
+/**
+ * @brief Make a UserQueryExplain (or UserQueryInvalid) from given parameters.
+ *
+ * Runs czar-side analysis (parse, plugins, restrictor and chunk coverage) on the provided SELECT without
+ * actually dispatching any work.
+ *
+ * @param innerQuery The SELECT statement to analyze
+ * @param jsonFormat True if JSON format was requested.
+ * @param sharedResources Resources used by UserQueryFactory to create UserQueries.
+ * @param defaultDb Default database name, may be empty.
+ * @param userQueryId Unique string identifying the query.
+ * @param resultDb Name of the database that will contain results.
+ * @return std::shared_ptr<UserQuery>, will be a UserQueryExplain or UserQueryInvalid.
+ */
+std::shared_ptr<UserQuery> _makeUserQueryExplain(std::string const& innerQuery, bool jsonFormat,
+                                                 userQuerySharedResourcesPtr& sharedResources,
+                                                 std::string const& defaultDb, std::string const& userQueryId,
+                                                 std::string const& resultDb) {
+    LOGS(_log, LOG_LVL_DEBUG,
+         "make UserQueryExplain: jsonFormat=" << (jsonFormat ? 'y' : 'n') << " query=" << innerQuery);
+
+    if (!UserQueryType::isSelect(innerQuery)) {
+        return std::make_shared<UserQueryInvalid>("EXPLAIN not supported for: " + innerQuery);
+    }
+    query::SelectStmt::Ptr stmt;
+    try {
+        stmt = ParseRunner::makeSelectStmt(innerQuery);
+    } catch (parser::ParseException& e) {
+        return std::make_shared<UserQueryInvalid>(std::string("ParseException:") + e.what());
+    }
+
+    auto qs = std::make_shared<qproc::QuerySession>(sharedResources->css, sharedResources->databaseModels,
+                                                    defaultDb, sharedResources->interactiveChunkLimit);
+    try {
+        qs->analyzeQuery(innerQuery, stmt);
+    } catch (...) {
+        return std::make_shared<UserQueryInvalid>(
+                "Unknown failure occurred setting up QuerySession for EXPLAIN (query is invalid).");
+    }
+
+    if (!qs->getError().empty()) {
+        return std::make_shared<UserQueryInvalid>("Invalid query: " + qs->getError());
+    }
+
+    try {
+        // Compute chunk coverage
+        qs->setupChunking(sharedResources->secondaryIndex);
+
+        // Analysis before submission
+        qs->finalize();
+    } catch (std::exception const& exc) {
+        return std::make_shared<UserQueryInvalid>(std::string("EXPLAIN analysis failed: ") + exc.what());
+    }
+
+    return std::make_shared<UserQueryExplain>(qs, userQueryId, resultDb, jsonFormat);
+}
+
 /**
  * @brief Determine if the qmeta database has a metadata table with chunks & row
  *        counts that represents the table in the FROM statement for a SELECT
@@ -298,6 +356,13 @@ UserQuery::Ptr UserQueryFactory::newUserQuery(std::string const& aQuery, std::st
     bool full = false;
     QueryId userJobId = 0;
 
+    std::string explainStripped;
+    bool explainInJson = false;
+    if (UserQueryType::isExplain(query, explainStripped, explainInJson)) {
+        return _makeUserQueryExplain(explainStripped, explainInJson, _userQuerySharedResources, defaultDb,
+                                     userQueryId, resultDb);
+    }
+
     if (UserQueryType::isSelect(query)) {
         // Processing regular select query
         bool sessionValid = true;
diff --git a/src/ccontrol/UserQuerySelect.cc b/src/ccontrol/UserQuerySelect.cc
index 9d8b42cf93..481131f216 100644
--- a/src/ccontrol/UserQuerySelect.cc
+++ b/src/ccontrol/UserQuerySelect.cc
@@ -422,37 +422,7 @@ void UserQuerySelect::_expandSelectStarInMergeStatment(std::shared_ptr<query::Se
 
 void UserQuerySelect::saveResultQuery() { _queryMetadata->saveResultQuery(_queryId, getResultQuery()); }
 
-void UserQuerySelect::_setupChunking() {
-    LOGS(_log, LOG_LVL_TRACE, "Setup chunking  _qSession: " << _qSession);
-    if (_qSession->hasChunks()) {
-        auto areaRestrictors = _qSession->getAreaRestrictors();
-        auto secIdxRestrictors = _qSession->getSecIdxRestrictors();
-        css::StripingParams partStriping = _qSession->getDbStriping();
-        auto const im = std::make_shared<qproc::IndexMap>(partStriping, _secondaryIndex);
-        qproc::ChunkSpecVector csv;
-        if (areaRestrictors != nullptr || secIdxRestrictors != nullptr) {
-            csv = im->getChunks(areaRestrictors, secIdxRestrictors);
-        } else {  // Unrestricted: full-sky
-            csv = im->getAllChunks();
-        }
-        LOGS(_log, LOG_LVL_TRACE, "Chunk specs: " << util::printable(csv));
-
-        // Filter out empty chunks
-        std::shared_ptr<IntSet const> eSet = _qSession->getEmptyChunks();
-        if (!eSet) {
-            eSet = std::make_shared<IntSet const>();
-            LOGS(_log, LOG_LVL_WARN, "Missing empty chunks info for dominantDbs");
-        }
-        for (qproc::ChunkSpecVector::const_iterator i = csv.begin(), e = csv.end(); i != e; ++i) {
-            if (eSet->count(i->chunkId) == 0) {  // chunk not in empty?
-                _qSession->addChunk(*i);
-            }
-        }
-    } else {
-        LOGS(_log, LOG_LVL_TRACE, "No chunks added, QuerySession will add dummy chunk");
-    }
-    _qSession->setScanInteractive();
-}
+void UserQuerySelect::_setupChunking() { _qSession->setupChunking(_secondaryIndex); }
 
 void UserQuerySelect::qMetaRegister(std::string const& resultLocation, std::string const& msgTableName) {
     qmeta::QInfo::QType qType = _async ? qmeta::QInfo::ASYNC : qmeta::QInfo::SYNC;
diff --git a/src/ccontrol/UserQueryType.cc b/src/ccontrol/UserQueryType.cc
index a73f86a24c..b7551baaf5 100644
--- a/src/ccontrol/UserQueryType.cc
+++ b/src/ccontrol/UserQueryType.cc
@@ -30,7 +30,6 @@
 #include "boost/algorithm/string/case_conv.hpp"
 
 // LSST headers
-#include "lsst/log/Log.h"
 #include "query/FromList.h"
 #include "query/SelectStmt.h"
 #include "query/SelectList.h"
@@ -39,8 +38,6 @@
 
 namespace {
 
-LOG_LOGGER _log = LOG_GET("lsst.qserv.ccontrol.UserQueryType");
-
 // regex for SELECT *
 // Note that parens around whole string are not part of the regex but raw string literal
 boost::regex _selectRe(R"(^select\s+.+$)",
@@ -58,6 +55,11 @@ boost::regex _showProcessListRe(R"(^show\s+(full\s+)?processlist$)",
 boost::regex _submitRe(R"(^submit\s+(.+)$)",
                        boost::regex::ECMAScript | boost::regex::icase | boost::regex::optimize);
 
+// regex for EXPLAIN [FORMAT=JSON|TRADITIONAL] ...
+// group 1 (optional) is the requested output format, group 2 is the stripped query
+boost::regex _explainRe(R"(^explain\s+(?:format\s*=\s*(json|traditional)\s+)?(.+)$)",
+                        boost::regex::ECMAScript | boost::regex::icase | boost::regex::optimize);
+
 // regex for SELECT * FROM QSERV_RESULT(12345)
 // group 1 is the query ID number
 // Note that parens around whole string are not part of the regex but raw string literal
@@ -100,13 +102,10 @@ namespace lsst::qserv::ccontrol {
 
 /// Returns true if query is regular SELECT (not isSelectResult())
 bool UserQueryType::isSelect(std::string const& query) {
-    LOGS(_log, LOG_LVL_TRACE, "isSelect: " << query);
     boost::smatch sm;
     bool match = boost::regex_match(query, sm, _selectRe);
     if (match) {
-        LOGS(_log, LOG_LVL_TRACE, "isSelect: match");
         if (boost::regex_match(query, sm, _selectResultRe)) {
-            LOGS(_log, LOG_LVL_TRACE, "isSelect: match select result");
             match = false;
         }
     }
@@ -115,12 +114,10 @@ bool UserQueryType::isSelect(std::string const& query) {
 
 /// Returns true if query is SHOW [FULL] PROCESSLIST
 bool UserQueryType::isShowProcessList(std::string const& query, bool& full) {
-    LOGS(_log, LOG_LVL_TRACE, "isShowProcessList: " << query);
     boost::smatch sm;
     bool match = boost::regex_match(query, sm, _showProcessListRe);
     if (match) {
         full = sm.length(1) != 0;
-        LOGS(_log, LOG_LVL_TRACE, "isShowProcessList: full: " << (full ? 'y' : 'n'));
     }
     return match;
 }
@@ -138,64 +135,62 @@ bool UserQueryType::isQueriesTable(std::string const& dbName, std::string const&
 
 /// Returns true if query is SUBMIT ...
 bool UserQueryType::isSubmit(std::string const& query, std::string& stripped) {
-    LOGS(_log, LOG_LVL_TRACE, "isSubmit: " << query);
     boost::smatch sm;
     bool match = boost::regex_match(query, sm, _submitRe);
     if (match) {
         stripped = sm.str(1);
-        LOGS(_log, LOG_LVL_TRACE, "isSubmit: match: " << stripped);
+    }
+    return match;
+}
+
+/// Returns true if query is EXPLAIN [FORMAT=JSON|TRADITIONAL] ...
+bool UserQueryType::isExplain(std::string const& query, std::string& stripped, bool& jsonFormat) {
+    boost::smatch sm;
+    bool match = boost::regex_match(query, sm, _explainRe);
+    if (match) {
+        jsonFormat = boost::to_lower_copy(sm.str(1)) == "json";
+        stripped = sm.str(2);
     }
     return match;
 }
 
 /// Returns true if query is SELECT * FROM QSERV_RESULT(...)
 bool UserQueryType::isSelectResult(std::string const& query, QueryId& queryId) {
-    LOGS(_log, LOG_LVL_TRACE, "isSelectResult: " << query);
     boost::smatch sm;
     bool match = boost::regex_match(query, sm, _selectResultRe);
     if (match) {
         queryId = std::stoull(sm.str(1));
-        LOGS(_log, LOG_LVL_TRACE, "isSelectResult: queryId: " << queryId);
     }
     return match;
 }
 
 // Returns true if query is KILL [QUERY|CONNECTION] NNN
 bool UserQueryType::isKill(std::string const& query, int& threadId) {
-    LOGS(_log, LOG_LVL_TRACE, "isKill: " << query);
     boost::smatch sm;
     bool match = boost::regex_match(query, sm, _killRe);
     if (match) {
         threadId = std::stoi(sm.str(1));
-        LOGS(_log, LOG_LVL_TRACE, "isKill: threadId: " << threadId);
     }
     return match;
 }
 
 // Returns true if query is CANCEL NNN
 bool UserQueryType::isCancel(std::string const& query, QueryId& queryId) {
-    LOGS(_log, LOG_LVL_TRACE, "isCancel: " << query);
     boost::smatch sm;
     bool match = boost::regex_match(query, sm, _cancelRe);
     if (match) {
         queryId = std::stoull(sm.str(1));
-        LOGS(_log, LOG_LVL_TRACE, "isCancel: queryId: " << queryId);
     }
     return match;
 }
 
-bool UserQueryType::isCall(std::string const& query) {
-    LOGS(_log, LOG_LVL_TRACE, "isCall: " << query);
-    return boost::regex_match(query, _callRe);
-}
+bool UserQueryType::isCall(std::string const& query) { return boost::regex_match(query, _callRe); }
 
 bool UserQueryType::isResultDelete(std::string const& query, std::string& queryId) {
-    LOGS(_log, LOG_LVL_TRACE, "isResultDelete: " << query);
     boost::smatch sm;
     bool match = boost::regex_match(query, sm, _resultDeleteRe);
     if (match) {
         queryId = sm.str(1);
-        LOGS(_log, LOG_LVL_TRACE, "isResultDelete: queryId: " << queryId);
     }
     return match;
 }
@@ -220,23 +215,16 @@ bool UserQueryType::isSimpleCountStar(std::shared_ptr<query::SelectStmt> const&
 
 /// Returns true if query is SET
 bool UserQueryType::isSet(std::string const& query) {
-    LOGS(_log, LOG_LVL_TRACE, "isSet: " << query);
     boost::smatch sm;
-    bool match = boost::regex_match(query, sm, _setRe);
-    if (match) {
-        LOGS(_log, LOG_LVL_TRACE, "isSet: match");
-    }
-    return match;
+    return boost::regex_match(query, sm, _setRe);
 }
 
 bool UserQueryType::isSetGlobal(std::string const& query, std::string& varName, std::string& varValue) {
-    LOGS(_log, LOG_LVL_TRACE, "isSetGlobal (extract): " << query);
     boost::smatch sm;
     bool match = boost::regex_match(query, sm, _setGlobalRe);
     if (match) {
         varName = sm.str(1);
         varValue = sm.str(2);
-        LOGS(_log, LOG_LVL_TRACE, "isSetGlobal: " << varName << "=" << varValue);
     }
     return match;
 }
diff --git a/src/ccontrol/UserQueryType.h b/src/ccontrol/UserQueryType.h
index 88c7406137..308bf9ba85 100644
--- a/src/ccontrol/UserQueryType.h
+++ b/src/ccontrol/UserQueryType.h
@@ -78,6 +78,12 @@ class UserQueryType {
      */
     static bool isSubmit(std::string const& query, std::string& stripped);
 
+    /**
+     *  Returns true if query is EXPLAIN [FORMAT=JSON|TRADITIONAL] <query>, returns query without "EXPLAIN" in
+     * `stripped` string and whether or not JSON format was requested in `jsonFormat`.
+     */
+    static bool isExplain(std::string const& query, std::string& stripped, bool& jsonFormat);
+
     /**
      *  Returns true if query is SELECT * FROM QSERV_RESULT(...), returns
      *  query ID in `queryId` argument.
diff --git a/src/ccontrol/testUserQueryType.cc b/src/ccontrol/testUserQueryType.cc
index 9d04da996b..edf0f0455b 100644
--- a/src/ccontrol/testUserQueryType.cc
+++ b/src/ccontrol/testUserQueryType.cc
@@ -83,4 +83,28 @@ BOOST_AUTO_TEST_CASE(testSetQueryType) {
             false);
 }
 
+BOOST_AUTO_TEST_CASE(testExplainQueryType) {
+    std::string stripped;
+    bool jsonFormat = true;  // start non-default to confirm it is written
+
+    // EXPLAIN <select>.
+    BOOST_CHECK_EQUAL(
+            ccontrol::UserQueryType::isExplain("EXPLAIN SELECT * FROM LSST.Object", stripped, jsonFormat),
+            true);
+    BOOST_CHECK_EQUAL(stripped, "SELECT * FROM LSST.Object");
+    BOOST_CHECK_EQUAL(jsonFormat, false);
+
+    // EXPLAIN FORMAT=JSON <select>.
+    BOOST_CHECK_EQUAL(
+            ccontrol::UserQueryType::isExplain("EXPLAIN FORMAT=JSON SELECT a FROM b", stripped, jsonFormat),
+            true);
+    BOOST_CHECK_EQUAL(stripped, "SELECT a FROM b");
+    BOOST_CHECK_EQUAL(jsonFormat, true);
+
+    // Non-matches
+    BOOST_CHECK_EQUAL(ccontrol::UserQueryType::isExplain("SELECT * FROM Obj", stripped, jsonFormat), false);
+    BOOST_CHECK_EQUAL(ccontrol::UserQueryType::isExplain("EXPLAINX SELECT 1", stripped, jsonFormat), false);
+    BOOST_CHECK_EQUAL(ccontrol::UserQueryType::isExplain("EXPLAIN", stripped, jsonFormat), false);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/css/ScanTableParams.h b/src/css/ScanTableParams.h
index ad25336152..9b7e72cc63 100644
--- a/src/css/ScanTableParams.h
+++ b/src/css/ScanTableParams.h
@@ -34,7 +34,7 @@ struct ScanTableParams {
     ScanTableParams(bool lockInMem_, int scanRating_) : lockInMem(lockInMem_), scanRating(scanRating_) {}
 
     bool lockInMem{false};  ///< True if table should be locked in memory for shared scan
-    int scanRating{0};      ///< Speed of shared scan. 1-fast, 2-medium, 3-slow
+    int scanRating{0};      ///< Speed of shared scan. @see proto::ScanInfo::Rating
 };
 
 }  // namespace lsst::qserv::css
diff --git a/src/proto/ScanTableInfo.h b/src/proto/ScanTableInfo.h
index 634953e656..d97adf8e2f 100644
--- a/src/proto/ScanTableInfo.h
+++ b/src/proto/ScanTableInfo.h
@@ -30,6 +30,7 @@
 
 // Qserv headers
 #include "proto/worker.pb.h"
+#include "query/ScanTableInfo.h"
 
 namespace lsst::qserv::proto {
 
@@ -67,6 +68,15 @@ struct ScanInfo {
     /// Threshold priority values. Scan priorities are not limited to these values.
     enum Rating { FASTEST = 0, FAST = 10, MEDIUM = 20, SLOW = 30, SLOWEST = 100 };
 
+    ScanInfo() = default;
+    /// Convert query analysis ScanInfo to the dispatch representation.
+    explicit ScanInfo(query::ScanInfo const& qScanInfo) : scanRating(qScanInfo.scanRating) {
+        infoTables.reserve(qScanInfo.infoTables.size());
+        for (auto const& qTbl : qScanInfo.infoTables) {
+            infoTables.emplace_back(qTbl.db, qTbl.table, qTbl.lockInMemory, qTbl.scanRating);
+        }
+    }
+
     void sortTablesSlowestFirst();
     int compareTables(ScanInfo const& rhs);
 
diff --git a/src/proxy/mysqlProxy.lua b/src/proxy/mysqlProxy.lua
index 6cf2276b30..3d935d9e65 100755
--- a/src/proxy/mysqlProxy.lua
+++ b/src/proxy/mysqlProxy.lua
@@ -204,8 +204,7 @@ function queryType()
     end
 
     local isNotSupported = function(qU)
-        if string.find(qU, "^EXPLAIN ") or
-           string.find(qU, "^GRANT ") or
+        if string.find(qU, "^GRANT ") or
            (string.find(qU, "^FLUSH ") and not string.find(qU, "^FLUSH QSERV")) then
             err.set(ERR_NOT_SUPPORTED,
                     "Sorry, this type of queries is not supported in DC3b.")
diff --git a/src/proxy/test.sh b/src/proxy/test.sh
index 76f31c6876..0fb8361e15 100644
--- a/src/proxy/test.sh
+++ b/src/proxy/test.sh
@@ -33,11 +33,14 @@ mysql --port=4040 --protocol=TCP proxyTest -e "desc Obj"
 mysql --port=4040 --protocol=TCP proxyTest -e "rollback"
 mysql --port=4040 --protocol=TCP proxyTest -e "commit"
 
+# EXPLAIN
+mysql --port=4040 --protocol=TCP proxyTest -e "explain select * from Obj"
+mysql --port=4040 --protocol=TCP proxyTest -e "explain format=json select * from Obj"
+
 # these all should fail
 mysql --port=4040 --protocol=TCP proxyTest -e "insert into Obj values(1, 2)"
 mysql --port=4040 --protocol=TCP -e "create database xyz"
 mysql --port=4040 --protocol=TCP proxyTest -e "create table tt (i int)"
-mysql --port=4040 --protocol=TCP proxyTest -e "explain select * from Obj"
 
 
 mysql -e "DROP DATABASE proxyTest"
diff --git a/src/qana/ScanTablePlugin.cc b/src/qana/ScanTablePlugin.cc
index 6e5f046617..25e64f396b 100644
--- a/src/qana/ScanTablePlugin.cc
+++ b/src/qana/ScanTablePlugin.cc
@@ -41,7 +41,6 @@
 
 // Qserv headers
 #include "global/stringTypes.h"
-#include "proto/ScanTableInfo.h"
 #include "query/ColumnRef.h"
 #include "query/FromList.h"
 #include "query/QueryContext.h"
@@ -93,7 +92,7 @@ StringPairVector filterPartitioned(query::TableRefList const& tList) {
     return vector;
 }
 
-proto::ScanInfo ScanTablePlugin::_findScanTables(query::SelectStmt& stmt, query::QueryContext& context) {
+query::ScanInfo ScanTablePlugin::_findScanTables(query::SelectStmt& stmt, query::QueryContext& context) {
     // Might be better as a separate plugin
 
     // All tables of a query are scan tables if the statement both:
@@ -187,15 +186,14 @@ proto::ScanInfo ScanTablePlugin::_findScanTables(query::SelectStmt& stmt, query:
 
     // Ask css if any of the tables should be locked in memory and their scan rating.
     // Use this information to determine scanPriority.
-    proto::ScanInfo scanInfo;
+    query::ScanInfo scanInfo;
     for (auto& pair : scanTables) {
-        proto::ScanTableInfo info(pair.first, pair.second);
+        query::ScanTableInfo info(pair.first, pair.second);
         css::ScanTableParams const params = context.css->getScanTableParams(info.db, info.table);
         info.lockInMemory = params.lockInMem;
         info.scanRating = params.scanRating;
         scanInfo.infoTables.push_back(info);
         scanInfo.scanRating = std::max(scanInfo.scanRating, info.scanRating);
-        scanInfo.scanRating = std::min(scanInfo.scanRating, static_cast<int>(proto::ScanInfo::SLOWEST));
         LOGS(_log, LOG_LVL_INFO,
              "ScanInfo " << info.db << "." << info.table << " lockInMemory=" << info.lockInMemory
                          << " rating=" << info.scanRating);
diff --git a/src/qana/ScanTablePlugin.h b/src/qana/ScanTablePlugin.h
index 145424852f..cd1efb8c88 100644
--- a/src/qana/ScanTablePlugin.h
+++ b/src/qana/ScanTablePlugin.h
@@ -27,7 +27,7 @@
 #include "qana/QueryPlugin.h"
 
 // Qserv headers
-#include "proto/ScanTableInfo.h"
+#include "query/ScanTableInfo.h"
 
 namespace lsst::qserv::qana {
 
@@ -55,8 +55,8 @@ class ScanTablePlugin : public QueryPlugin {
     std::string name() const override { return "ScanTablePlugin"; }
 
 private:
-    proto::ScanInfo _findScanTables(query::SelectStmt& stmt, query::QueryContext& context);
-    proto::ScanInfo _scanInfo;
+    query::ScanInfo _findScanTables(query::SelectStmt& stmt, query::QueryContext& context);
+    query::ScanInfo _scanInfo;
     int _interactiveChunkLimit;
 };
 
diff --git a/src/qproc/QuerySession.cc b/src/qproc/QuerySession.cc
index 4b864caa30..b04a3640d4 100644
--- a/src/qproc/QuerySession.cc
+++ b/src/qproc/QuerySession.cc
@@ -48,11 +48,14 @@
 // Qserv headers
 #include "ccontrol/ParseRunner.h"
 #include "css/CssAccess.h"
+#include "qproc/IndexMap.h"
+#include "qproc/SecondaryIndex.h"
 #include "css/CssError.h"
 #include "css/EmptyChunks.h"
 #include "global/constants.h"
 #include "global/stringTypes.h"
 #include "parser/ParseException.h"
+#include "proto/ScanTableInfo.h"
 #include "qana/AggregatePlugin.h"
 #include "qana/AnalysisError.h"
 #include "qana/DuplSelectExprPlugin.h"
@@ -195,6 +198,8 @@ void QuerySession::addChunk(ChunkSpec const& cs) {
     _chunks.push_back(cs);
 }
 
+query::ScanInfo QuerySession::getScanInfo() const { return _context->scanInfo; }
+
 void QuerySession::setScanInteractive() {
     // Default is for interactive scan.
     if (_context->chunkCount > _interactiveChunkLimit) {
@@ -202,6 +207,40 @@ void QuerySession::setScanInteractive() {
     }
 }
 
+void QuerySession::setupChunking(std::shared_ptr<SecondaryIndex> const& secondaryIndex) {
+    if (hasChunks()) {
+        auto areaRestrictors = getAreaRestrictors();
+        auto secIdxRestrictors = getSecIdxRestrictors();
+        css::StripingParams partStriping = getDbStriping();
+        auto const im = std::make_shared<IndexMap>(partStriping, secondaryIndex);
+        ChunkSpecVector csv;
+        if (areaRestrictors != nullptr || secIdxRestrictors != nullptr) {
+            csv = im->getChunks(areaRestrictors, secIdxRestrictors);
+        } else {  // Unrestricted: full-sky
+            csv = im->getAllChunks();
+        }
+        LOGS(_log, LOG_LVL_TRACE, "Chunk specs: " << util::printable(csv));
+
+        // Filter out empty chunks
+        std::shared_ptr<IntSet const> eSet = getEmptyChunks();
+        if (!eSet) {
+            eSet = std::make_shared<IntSet const>();
+            LOGS(_log, LOG_LVL_WARN, "Missing empty chunks info for dominantDbs");
+        }
+        for (ChunkSpecVector::const_iterator i = csv.begin(), e = csv.end(); i != e; ++i) {
+            if (eSet->count(i->chunkId) == 0) {  // chunk not in empty?
+                addChunk(*i);
+            }
+        }
+    } else {
+        LOGS(_log, LOG_LVL_TRACE, "No chunks added, QuerySession will add dummy chunk");
+    }
+
+    // Must run after the chunks above have been added: it compares the resulting chunk count against
+    // _interactiveChunkLimit, so running it any earlier always sees a count of zero.
+    setScanInteractive();
+}
+
 void QuerySession::setDummy() {
     _isDummy = true;
     // Clear out chunk counts and _chunks, and replace with dummy chunk.
@@ -445,7 +484,7 @@ ChunkQuerySpec::Ptr QuerySession::buildChunkQuerySpec(query::QueryTemplate::Vect
     // name in the ChunkQuerySpec is to build the CSS resource path. See details in the implementation
     // of the class.
     auto cQSpec = std::make_shared<ChunkQuerySpec>(*(_context->dominantDbs.begin()), chunkSpec.chunkId,
-                                                   _context->scanInfo, _scanInteractive);
+                                                   proto::ScanInfo(_context->scanInfo), _scanInteractive);
     // Reset subChunkTables
     qana::QueryMapping const& queryMapping = *(_context->queryMapping);
     DbTableSet const& sTables = queryMapping.getSubChunkTables();
diff --git a/src/qproc/QuerySession.h b/src/qproc/QuerySession.h
index 32951002b2..a72ad53f1e 100644
--- a/src/qproc/QuerySession.h
+++ b/src/qproc/QuerySession.h
@@ -47,6 +47,7 @@
 #include "qproc/ChunkSpec.h"
 #include "qproc/DatabaseModels.h"
 #include "query/QueryTemplate.h"
+#include "query/ScanTableInfo.h"
 #include "query/typedefs.h"
 #include "sql/SqlConfig.h"
 
@@ -63,6 +64,8 @@ class QueryContext;
 
 namespace lsst::qserv::qproc {
 
+class SecondaryIndex;
+
 ///  QuerySession contains state and behavior for operating on user queries. It
 ///  contains much of the query analysis-side responsibility, including the text
 ///  of the original query, a parsed query  tree, and other user state/context.
@@ -108,6 +111,17 @@ class QuerySession {
     void addChunk(ChunkSpec const& cs);
     void setDummy();
 
+    /// @return true if this query runs against the dummy chunk rather than real chunk coverage.
+    bool isDummy() const { return _isDummy; }
+
+    /**
+     * @brief Compute this query's chunk coverage.
+     *
+     * Uses the secondary index + restrictors to determine the set of chunks the query touches (empty chunks
+     * are filtered out). analyzeQuery() must be called first.
+     */
+    void setupChunking(std::shared_ptr<SecondaryIndex> const& secondaryIndex);
+
     query::SelectStmt const& getStmt() const { return *_stmt; }
 
     query::SelectStmtPtrVector const& getStmtParallel() const { return _stmtParallel; }
@@ -187,6 +201,8 @@ class QuerySession {
     void setScanInteractive();
     bool getScanInteractive() const { return _scanInteractive; }
 
+    query::ScanInfo getScanInfo() const;
+
     /**
      *  Print query session to stream.
      *
diff --git a/src/query/QueryContext.h b/src/query/QueryContext.h
index 77ad177234..4b17cd0b18 100644
--- a/src/query/QueryContext.h
+++ b/src/query/QueryContext.h
@@ -39,9 +39,9 @@
 // Local headers
 #include "css/CssAccess.h"
 #include "global/stringTypes.h"
-#include "proto/ScanTableInfo.h"
 #include "qana/QueryMapping.h"
 #include "query/FromList.h"
+#include "query/ScanTableInfo.h"
 #include "query/typedefs.h"
 #include "query/ValueExpr.h"
 #include "util/CIUtils.h"
@@ -84,7 +84,7 @@ class QueryContext {
 
     std::shared_ptr<qproc::DatabaseModels> databaseModels;  ///< contains database schema information.
 
-    proto::ScanInfo scanInfo;  // Tables scanned (for shared scans)
+    ScanInfo scanInfo;  // Tables scanned (for shared scans)
 
     /**
      * @brief Add a TableRef to the list of tables used by this query.
diff --git a/src/query/ScanTableInfo.h b/src/query/ScanTableInfo.h
new file mode 100644
index 0000000000..030606f390
--- /dev/null
+++ b/src/query/ScanTableInfo.h
@@ -0,0 +1,53 @@
+// -*- LSST-C++ -*-
+/*
+ * LSST Data Management System
+ * Copyright 2016-2026 LSST Corporation.
+ *
+ * This product includes software developed by the
+ * LSST Project (http://www.lsst.org/).
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the LSST License Statement and
+ * the GNU General Public License along with this program.  If not,
+ * see <http://www.lsstcorp.org/LegalNotices/>.
+ */
+
+#ifndef LSST_QSERV_QUERY_SCANTABLEINFO_H
+#define LSST_QSERV_QUERY_SCANTABLEINFO_H
+
+// System headers
+#include <string>
+#include <vector>
+
+namespace lsst::qserv::query {
+
+/// Shared scan information for a single table, produced by query analysis
+struct ScanTableInfo {
+    ScanTableInfo(std::string const& db_, std::string const& table_) : db(db_), table(table_) {}
+    ScanTableInfo(std::string const& db_, std::string const& table_, bool lockInMemory_, int scanRating_)
+            : db{db_}, table{table_}, lockInMemory{lockInMemory_}, scanRating{scanRating_} {}
+
+    std::string db;
+    std::string table;
+    bool lockInMemory{false};
+    int scanRating{0};
+};
+
+/// This class stores information about database table ratings for a user query.
+struct ScanInfo {
+    std::vector<ScanTableInfo> infoTables;
+    int scanRating{0};
+};
+
+}  // namespace lsst::qserv::query
+
+#endif  // LSST_QSERV_QUERY_SCANTABLEINFO_H