Update CODEOWNERS to remove redundant entries

Removing myself as I have no maintainer's permissions to review the code

.github/CODEOWNERS

@@ -1,5 +1,5 @@
 # AUTH
-auth/* @nuivall @ptrsmrn
+auth/* @nuivall
 
 # CACHE
 row_cache* @tgrabiec
@@ -25,11 +25,11 @@ compaction/* @raphaelsc
 transport/*
 
 # CQL QUERY LANGUAGE
-cql3/* @tgrabiec @nuivall @ptrsmrn
+cql3/* @tgrabiec @nuivall
 
 # COUNTERS
-counters* @nuivall @ptrsmrn
-tests/counter_test* @nuivall @ptrsmrn
+counters* @nuivall
+tests/counter_test* @nuivall
 
 # DOCS
 docs/* @annastuchlik @tzach

auth/service.cc

@@ -884,6 +884,15 @@ future<> migrate_to_auth_v2(db::system_keyspace& sys_ks, ::service::raft_group0_
             ::service::client_state cs(::service::client_state::internal_tag{}, tc);
             ::service::query_state qs(cs, empty_service_permit());
 
+            auto rows = co_await qp.execute_internal(
+                    seastar::format("SELECT * FROM {}.{}", meta::legacy::AUTH_KS, cf_name),
+                    db::consistency_level::ALL,
+                    qs,
+                    {},
+                    cql3::query_processor::cache_internal::no);
+            if (rows->empty()) {
+                continue;
+            }
             std::vector<sstring> col_names;
             for (const auto& col : schema->all_columns()) {
                 col_names.push_back(col.name_as_cql_string());
@@ -892,14 +901,7 @@ future<> migrate_to_auth_v2(db::system_keyspace& sys_ks, ::service::raft_group0_
             for (size_t i = 1; i < col_names.size(); ++i) {
                 val_binders_str += ", ?";
             }
-
-            co_await qp.query_internal(
-                    seastar::format("SELECT * FROM {}.{}", meta::legacy::AUTH_KS, cf_name),
-                    db::consistency_level::ALL,
-                    qs,
-                    {},
-                    1000,
-                    [&](const cql3::untyped_result_set_row& row) -> future<stop_iteration> {
+            for (const auto& row : *rows) {
                 std::vector<data_value_or_unset> values;
                 for (const auto& col : schema->all_columns()) {
                     if (row.has(col.name_as_text())) {
@@ -923,8 +925,7 @@ future<> migrate_to_auth_v2(db::system_keyspace& sys_ks, ::service::raft_group0_
                             format("expecting single insert mutation, got {}", muts.size()));
                 }
                 co_yield std::move(muts[0]);
-                co_return stop_iteration::no;
-            });
+            }
         }
         co_yield co_await sys_ks.make_auth_version_mutation(ts,
                 db::system_keyspace::auth_version_t::v2);
@@ -933,7 +934,7 @@ future<> migrate_to_auth_v2(db::system_keyspace& sys_ks, ::service::raft_group0_
             start_operation_func,
             std::move(gen),
             as,
-            get_raft_timeout());
+            std::nullopt);
 }
 
 }

cql3/query_processor.cc

@@ -886,10 +886,9 @@ future<> query_processor::for_each_cql_result(
 }
 
 future<::shared_ptr<untyped_result_set>>
-query_processor::execute_paged_internal(internal_query_state& state, service::query_state* query_state) {
+query_processor::execute_paged_internal(internal_query_state& state) {
     state.p->statement->validate(*this, service::client_state::for_internal_calls());
-    auto default_qs = query_state ? std::nullopt : std::make_optional(query_state_for_internal_call());
-    auto& qs = query_state ? *query_state : *default_qs;
+    auto qs = query_state_for_internal_call();
     ::shared_ptr<cql_transport::messages::result_message> msg =
       co_await state.p->statement->execute(*this, qs, *state.opts, std::nullopt);
 
@@ -926,20 +925,6 @@ query_processor::execute_paged_internal(internal_query_state& state, service::qu
     co_return ::make_shared<untyped_result_set>(msg);
 }
 
-future<> query_processor::for_each_cql_result(
-        cql3::internal_query_state& state,
-        service::query_state& query_state,
-        noncopyable_function<future<stop_iteration>(const cql3::untyped_result_set::row&)> f) {
-    do {
-        auto msg = co_await execute_paged_internal(state, &query_state);
-        for (auto& row : *msg) {
-            if ((co_await f(row)) == stop_iteration::yes) {
-                co_return;
-            }
-        }
-    } while (has_more_results(state));
-}
-
 future<::shared_ptr<untyped_result_set>>
 query_processor::execute_internal(
         const sstring& query_string,
@@ -1217,17 +1202,6 @@ future<> query_processor::query_internal(
     co_return co_await for_each_cql_result(query_state, std::move(f));
 }
 
-future<> query_processor::query_internal(
-        const sstring& query_string,
-        db::consistency_level cl,
-        service::query_state& query_state,
-        const data_value_list& values,
-        int32_t page_size,
-        noncopyable_function<future<stop_iteration>(const cql3::untyped_result_set_row&)> f) {
-    auto paged_state = create_paged_state(query_string, cl, values, page_size);
-    co_return co_await for_each_cql_result(paged_state, query_state, std::move(f));
-}
-
 future<> query_processor::query_internal(
         const sstring& query_string,
         noncopyable_function<future<stop_iteration>(const cql3::untyped_result_set_row&)> f) {

cql3/query_processor.hh

@@ -332,29 +332,6 @@ public:
             int32_t page_size,
             noncopyable_function<future<stop_iteration>(const cql3::untyped_result_set_row&)> f);
 
-    /*!
-     * \brief iterate over all cql results using paging with a custom query_state (for timeout control)
-     *
-     * You can use placeholders in the query, the statement will only be prepared once.
-     *
-     * query_string - the cql string, can contain placeholders
-     * cl - consistency level of the query
-     * query_state - query state with custom timeout configuration
-     * values - values to be substituted for the placeholders in the query
-     * page_size - maximum page size
-     * f - a function to be run on each row of the query result,
-     *     if the function returns stop_iteration::yes the iteration will stop
-     *
-     * \note This function is optimized for convenience, not performance.
-     */
-    future<> query_internal(
-            const sstring& query_string,
-            db::consistency_level cl,
-            service::query_state& query_state,
-            const data_value_list& values,
-            int32_t page_size,
-            noncopyable_function<future<stop_iteration>(const cql3::untyped_result_set_row&)> f);
-
     /*
      * \brief iterate over all cql results using paging
      * An overload of query_internal without query parameters
@@ -524,14 +501,11 @@ private:
             int32_t page_size);
 
     /*!
-     * \brief run a query using paging with an optional custom query_state (for timeout control)
-     *
-     * state - internal query state containing prepared statement and options
-     * query_state - optional query state with custom timeout configuration (defaults to internal query state)
+     * \brief run a query using paging
      *
      * \note Optimized for convenience, not performance.
      */
-    future<::shared_ptr<untyped_result_set>> execute_paged_internal(internal_query_state& state, service::query_state* query_state = nullptr);
+    future<::shared_ptr<untyped_result_set>> execute_paged_internal(internal_query_state& state);
 
     /*!
      * \brief iterate over all results using paging, accept a function that returns a future
@@ -542,21 +516,6 @@ private:
             cql3::internal_query_state& state,
             noncopyable_function<future<stop_iteration>(const cql3::untyped_result_set_row&)> f);
 
-    /*!
-     * \brief iterate over all results using paging with a custom query_state (for timeout control)
-     *
-     * state - internal query state containing prepared statement and options
-     * query_state - query state with custom timeout configuration
-     * f - a function to be run on each row of the query result,
-     *     if the function returns stop_iteration::yes the iteration will stop
-     *
-     * \note Optimized for convenience, not performance.
-     */
-    future<> for_each_cql_result(
-            cql3::internal_query_state& state,
-            service::query_state& query_state,
-            noncopyable_function<future<stop_iteration>(const cql3::untyped_result_set_row&)> f);
-
     /*!
      * \brief check, based on the state if there are additional results
      * Users of the paging, should not use the internal_query_state directly