Merge branch 'tickets/DM-50657'

Author: iagaponenko

src/ccontrol/UserQueryFactory.cc

@@ -325,6 +325,7 @@ UserQuery::Ptr UserQueryFactory::newUserQuery(std::string const& aQuery, std::st
                     userQueryId, rowsTable, resultDb, countSpelling, _userQuerySharedResources->qMetaCzarId,
                     async);
             uq->qMetaRegister(resultLocation, msgTableName);
+            uq->saveResultQuery();
             return uq;
         }
 

src/ccontrol/UserQuerySelectCountStar.cc

@@ -21,6 +21,8 @@
 
 #include "UserQuerySelectCountStar.h"
 
+// Third-party headers
+#include "boost/algorithm/string/replace.hpp"
 #include "boost/lexical_cast.hpp"
 
 // LSST headers
@@ -30,6 +32,7 @@
 #include "cconfig/CzarConfig.h"
 #include "ccontrol/UserQueryError.h"
 #include "ccontrol/UserQueryType.h"
+#include "global/LogContext.h"
 #include "qdisp/MessageStore.h"
 #include "qmeta/QInfo.h"
 #include "qmeta/QMetaSelect.h"
@@ -40,10 +43,6 @@
 
 namespace {
 
-std::string g_nextResultTableId(std::string const& userQueryId) {
-    return "qserv_result_countstar_" + userQueryId;
-}
-
 LOG_LOGGER _log = LOG_GET("lsst.qserv.ccontrol.UserQuerySelectCountStar");
 
 }  // end namespace
@@ -63,7 +62,6 @@ UserQuerySelectCountStar::UserQuerySelectCountStar(std::string query,
         : _qMetaSelect(qMetaSelect),
           _queryMetadata(queryMetadata),
           _messageStore(std::make_shared<qdisp::MessageStore>()),
-          _resultTableName(::g_nextResultTableId(userQueryId)),
           _userQueryId(userQueryId),
           _rowsTable(rowsTable),
           _resultDb(resultDb),
@@ -124,7 +122,7 @@ void UserQuerySelectCountStar::submit() {
     }
 
     // Create a result table, with one column (row_count) and one row (the total number of rows):
-    std::string createTable = "CREATE TABLE " + _resultTableName + "(row_count BIGINT UNSIGNED)";
+    std::string createTable = "CREATE TABLE " + _resultTable + "(row_count BIGINT UNSIGNED)";
     LOGS(_log, LOG_LVL_DEBUG, "creating result table: " << createTable);
     auto const czarConfig = cconfig::CzarConfig::instance();
     auto const resultDbConn = sql::SqlConnectionFactory::make(czarConfig->getMySqlResultConfig());
@@ -137,7 +135,7 @@ void UserQuerySelectCountStar::submit() {
     }
 
     // Insert the total row count into the result table:
-    std::string insertRow = "INSERT INTO " + _resultTableName + " VALUES (";
+    std::string insertRow = "INSERT INTO " + _resultTable + " VALUES (";
     try {
         insertRow += lexical_cast<std::string>(row_count);
     } catch (bad_lexical_cast const& exc) {
@@ -171,13 +169,38 @@ void UserQuerySelectCountStar::qMetaRegister(std::string const& resultLocation,
                                              std::string const& msgTableName) {
     qmeta::QInfo::QType qType = _async ? qmeta::QInfo::ASYNC : qmeta::QInfo::SYNC;
     std::string user = "anonymous";  // we do not have access to that info yet
-    std::string qTemplate = "template";
-    std::string qMerge = "merge";
+    std::string qTemplate;
+    std::string qMerge;
+    if (_resultLoc.empty()) {
+        // Special token #QID# is replaced with query ID later.
+        _resultLoc = "table:result_#QID#";
+    }
     int chunkCount = 0;
-    qmeta::QInfo qInfo(qType, _qMetaCzarId, user, _query, qTemplate, qMerge, getResultLocation(),
-                       msgTableName, getResultQuery(), chunkCount);
+    qmeta::QInfo qInfo(qType, _qMetaCzarId, user, _query, qTemplate, qMerge, _resultLoc, msgTableName,
+                       getResultQuery(), chunkCount);
+    // register query, save its ID
     qmeta::QMeta::TableNames tableNames;
     _qMetaQueryId = _queryMetadata->registerQuery(qInfo, tableNames);
+    _queryIdStr = QueryIdHelper::makeIdStr(_qMetaQueryId);
+    // Add logging context with query ID
+    QSERV_LOGCONTEXT_QUERY(_qMetaQueryId);
+
+    // update #QID# with actual query ID
+    boost::replace_all(_resultLoc, "#QID#", std::to_string(_qMetaQueryId));
+
+    // guess query result location
+    if (_resultLoc.compare(0, 6, "table:") == 0) {
+        _resultTable = _resultLoc.substr(6);
+    } else {
+        // we only support results going to tables for now, abort for anything else
+        std::string const msg = "Unexpected result location '" + _resultLoc + "'";
+        _messageStore->addMessage(-1, "SYSTEM", 1146, msg, MessageSeverity::MSG_ERROR);
+        throw UserQueryError(getQueryIdString());
+    }
+}
+
+void UserQuerySelectCountStar::saveResultQuery() {
+    _queryMetadata->saveResultQuery(_qMetaQueryId, getResultQuery());
 }
 
 QueryState UserQuerySelectCountStar::join() {

src/ccontrol/UserQuerySelectCountStar.h

@@ -84,19 +84,21 @@ class UserQuerySelectCountStar : public UserQuery {
     /// in locations other than MySQL tables. We'll switch to getResultLocation()
     /// at that point.
     /// @return Name of the result table for this query, can be empty
-    std::string getResultTableName() const { return _resultTableName; }
+    std::string getResultTableName() const { return _resultTable; }
 
     /// Result location could be something like "table:table_name" or
     /// "file:/path/to/file.csv".
     /// @return Result location for this query, can be empty
-    std::string getResultLocation() const override { return "table:" + _resultTableName; }
+    std::string getResultLocation() const override { return _resultLoc; }
 
     /// @return True if query is async query
     bool isAsync() const override { return _async; }
 
     /// @return get the SELECT statement to be executed by proxy
     std::string getResultQuery() const override;
 
+    std::string getQueryIdString() const override { return _queryIdStr; }
+
     /// @return this query's QueryId.
     QueryId getQueryId() const override { return _qMetaQueryId; }
 
@@ -107,20 +109,26 @@ class UserQuerySelectCountStar : public UserQuery {
      */
     void qMetaRegister(std::string const& resultLocation, std::string const& msgTableName);
 
+    /// save the result query in the query metadata
+    void saveResultQuery();
+
 private:
     void _qMetaUpdateStatus(qmeta::QInfo::QStatus qStatus);
 
     std::shared_ptr<qmeta::QMetaSelect> _qMetaSelect;
     std::shared_ptr<qmeta::QMeta> const& _queryMetadata;
     std::shared_ptr<qdisp::MessageStore> _messageStore;
-    std::string _resultTableName;
+    std::string _resultTable;
+    std::string _resultLoc;  ///< Result location
     std::string _userQueryId;
     std::string _rowsTable;
     std::string _resultDb;
     std::string _countSpelling;  // keeps track of how "COUNT" is spelled, for the result query.
     std::string _query;          // The original query text (without SUBMIT if async)
     qmeta::CzarId _qMetaCzarId;
     QueryId _qMetaQueryId;
+    /// QueryId in a standard string form, initially set to unknown.
+    std::string _queryIdStr{QueryIdHelper::makeIdStr(0, true)};
     bool _async;
     QueryState _qState{UNKNOWN};
 };