release: prepare for 4.1.11

sstable_writer may depend on the sstable throughout its whole lifecycle.
If the sstable is freed before the sstable_writer we might hit use-after-free
as in the follwing case:
```
std::_Deque_iterator<sstables::compression::segmented_offsets::bucket, sstables::compression::segmented_offsets::bucket&, sstables::compression::segmented_offsets::bucket*>::operator+=(long) at /usr/include/c++/10/bits/stl_deque.h:240
 (inlined by) std::operator+(std::_Deque_iterator<sstables::compression::segmented_offsets::bucket, sstables::compression::segmented_offsets::bucket&, sstables::compression::segmented_offsets::bucket*> const&, long) at /usr/include/c++/10/bits/stl_deque.h:378
 (inlined by) std::_Deque_iterator<sstables::compression::segmented_offsets::bucket, sstables::compression::segmented_offsets::bucket&, sstables::compression::segmented_offsets::bucket*>::operator[](long) const at /usr/include/c++/10/bits/stl_deque.h:252
 (inlined by) std::deque<sstables::compression::segmented_offsets::bucket, std::allocator<sstables::compression::segmented_offsets::bucket> >::operator[](unsigned long) at /usr/include/c++/10/bits/stl_deque.h:1327
 (inlined by) sstables::compression::segmented_offsets::push_back(unsigned long, sstables::compression::segmented_offsets::state&) at ./sstables/compress.cc:214
sstables::compression::segmented_offsets::writer::push_back(unsigned long) at ./sstables/compress.hh:123
 (inlined by) compressed_file_data_sink_impl<crc32_utils, (compressed_checksum_mode)1>::put(seastar::temporary_buffer<char>) at ./sstables/compress.cc:519
seastar::output_stream<char>::put(seastar::temporary_buffer<char>) at table.cc:?
 (inlined by) seastar::output_stream<char>::put(seastar::temporary_buffer<char>) at ././seastar/include/seastar/core/iostream-impl.hh:432
seastar::output_stream<char>::flush() at table.cc:?
seastar::output_stream<char>::close() at table.cc:?
sstables::file_writer::close() at sstables.cc:?
sstables::mc::writer::~writer() at writer.cc:?
 (inlined by) sstables::mc::writer::~writer() at ./sstables/mx/writer.cc:790
sstables::mc::writer::~writer() at writer.cc:?
flat_mutation_reader::impl::consumer_adapter<stable_flattened_mutations_consumer<compact_for_compaction<sstables::compacting_sstable_writer, noop_compacted_fragments_consumer> > >::~consumer_adapter() at compaction.cc:?
 (inlined by) std::_Optional_payload_base<sstables::compaction_writer>::_M_destroy() at /usr/include/c++/10/optional:260
 (inlined by) std::_Optional_payload_base<sstables::compaction_writer>::_M_reset() at /usr/include/c++/10/optional:280
 (inlined by) std::_Optional_payload<sstables::compaction_writer, false, false, false>::~_Optional_payload() at /usr/include/c++/10/optional:401
 (inlined by) std::_Optional_base<sstables::compaction_writer, false, false>::~_Optional_base() at /usr/include/c++/10/optional:474
 (inlined by) std::optional<sstables::compaction_writer>::~optional() at /usr/include/c++/10/optional:659
 (inlined by) sstables::compacting_sstable_writer::~compacting_sstable_writer() at ./sstables/compaction.cc:229
 (inlined by) compact_mutation<(emit_only_live_rows)0, (compact_for_sstables)1, sstables::compacting_sstable_writer, noop_compacted_fragments_consumer>::~compact_mutation() at ././mutation_compactor.hh:468
 (inlined by) compact_for_compaction<sstables::compacting_sstable_writer, noop_compacted_fragments_consumer>::~compact_for_compaction() at ././mutation_compactor.hh:538
 (inlined by) std::default_delete<compact_for_compaction<sstables::compacting_sstable_writer, noop_compacted_fragments_consumer> >::operator()(compact_for_compaction<sstables::compacting_sstable_writer, noop_compacted_fragments_consumer>*) const at /usr/include/c++/10/bits/unique_ptr.h:85
 (inlined by) std::unique_ptr<compact_for_compaction<sstables::compacting_sstable_writer, noop_compacted_fragments_consumer>, std::default_delete<compact_for_compaction<sstables::compacting_sstable_writer, noop_compacted_fragments_consumer> > >::~unique_ptr() at /usr/include/c++/10/bits/unique_ptr.h:361
 (inlined by) stable_flattened_mutations_consumer<compact_for_compaction<sstables::compacting_sstable_writer, noop_compacted_fragments_consumer> >::~stable_flattened_mutations_consumer() at ././mutation_reader.hh:342
 (inlined by) flat_mutation_reader::impl::consumer_adapter<stable_flattened_mutations_consumer<compact_for_compaction<sstables::compacting_sstable_writer, noop_compacted_fragments_consumer> > >::~consumer_adapter() at ././flat_mutation_reader.hh:201
auto flat_mutation_reader::impl::consume_in_thread<stable_flattened_mutations_consumer<compact_for_compaction<sstables::compacting_sstable_writer, noop_compacted_fragments_consumer> >, flat_mutation_reader::no_filter>(stable_flattened_mutations_consumer<compact_for_compaction<sstables::compacting_sstable_writer, noop_compacted_fragments_consumer> >, flat_mutation_reader::no_filter, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000l> > >) at ././flat_mutation_reader.hh:272
 (inlined by) auto flat_mutation_reader::consume_in_thread<stable_flattened_mutations_consumer<compact_for_compaction<sstables::compacting_sstable_writer, noop_compacted_fragments_consumer> >, flat_mutation_reader::no_filter>(stable_flattened_mutations_consumer<compact_for_compaction<sstables::compacting_sstable_writer, noop_compacted_fragments_consumer> >, flat_mutation_reader::no_filter, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000l> > >) at ././flat_mutation_reader.hh:383
 (inlined by) auto flat_mutation_reader::consume_in_thread<stable_flattened_mutations_consumer<compact_for_compaction<sstables::compacting_sstable_writer, noop_compacted_fragments_consumer> > >(stable_flattened_mutations_consumer<compact_for_compaction<sstables::compacting_sstable_writer, noop_compacted_fragments_consumer> >, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000l> > >) at ././flat_mutation_reader.hh:389
 (inlined by) seastar::future<void> sstables::compaction::setup<noop_compacted_fragments_consumer>(noop_compacted_fragments_consumer)::{lambda(flat_mutation_reader)#1}::operator()(flat_mutation_reader)::{lambda()#1}::operator()() at ./sstables/compaction.cc:612
```

What happens here is that:

    compressed_file_data_sink_impl(output_stream<char> out, sstables::compression* cm, sstables::local_compression lc)
            : _out(std::move(out))
            , _compression_metadata(cm)
            , _offsets(_compression_metadata->offsets.get_writer())
            , _compression(lc)
            , _full_checksum(ChecksumType::init_checksum())

_compression_metadata points to a buffer held by the sstable object.
and _compression_metadata->offsets.get_writer returns a writer that keeps
a reference to the segmented_offsets in the sstables::compression
that is used in the ~writer -> close path.

Fixes #7821

Signed-off-by: Benny Halevy <bhalevy@scylladb.com>
Message-Id: <20201227145726.33319-1-bhalevy@scylladb.com>
(cherry picked from commit 8a745a0ee0)

.github/CODEOWNERS

@@ -1,81 +0,0 @@
-# AUTH
-auth/* @elcallio @vladzcloudius
-
-# CACHE
-row_cache* @tgrabiec @haaawk
-*mutation* @tgrabiec @haaawk
-tests/mvcc* @tgrabiec @haaawk
-
-# CDC
-cdc/* @haaawk @kbr- @elcallio @piodul @jul-stas
-test/cql/cdc_* @haaawk @kbr- @elcallio @piodul @jul-stas
-test/boost/cdc_* @haaawk @kbr- @elcallio @piodul @jul-stas
-
-# COMMITLOG / BATCHLOG
-db/commitlog/* @elcallio
-db/batch* @elcallio
-
-# COORDINATOR
-service/storage_proxy* @gleb-cloudius
-
-# COMPACTION
-sstables/compaction* @raphaelsc @nyh
-
-# CQL TRANSPORT LAYER
-transport/* @penberg
-
-# CQL QUERY LANGUAGE
-cql3/* @tgrabiec @penberg @psarna
-
-# COUNTERS
-counters* @haaawk @jul-stas
-tests/counter_test* @haaawk @jul-stas
-
-# GOSSIP
-gms/* @tgrabiec @asias
-
-# DOCKER
-dist/docker/* @penberg
-
-# LSA
-utils/logalloc* @tgrabiec
-
-# MATERIALIZED VIEWS
-db/view/* @nyh @psarna
-cql3/statements/*view* @nyh @psarna
-test/boost/view_* @nyh @psarna
-
-# PACKAGING
-dist/* @syuu1228
-
-# REPAIR
-repair/* @tgrabiec @asias @nyh
-
-# SCHEMA MANAGEMENT
-db/schema_tables* @tgrabiec @nyh
-db/legacy_schema_migrator* @tgrabiec @nyh
-service/migration* @tgrabiec @nyh
-schema* @tgrabiec @nyh
-
-# SECONDARY INDEXES
-db/index/* @nyh @penberg @psarna
-cql3/statements/*index* @nyh @penberg @psarna
-test/boost/*index* @nyh @penberg @psarna
-
-# SSTABLES
-sstables/* @tgrabiec @raphaelsc @nyh
-
-# STREAMING
-streaming/* @tgrabiec @asias
-service/storage_service.* @tgrabiec @asias
-
-# ALTERNATOR
-alternator/* @nyh @psarna
-test/alternator/* @nyh @psarna
-
-# HINTED HANDOFF
-db/hints/* @haaawk @piodul @vladzcloudius
-
-# REDIS
-redis/* @nyh @syuu1228
-redis-test/* @nyh @syuu1228

.gitignore

@@ -22,6 +22,5 @@ resources
 .pytest_cache
 /expressions.tokens
 tags
-testlog
+testlog/*
 test/*/*.reject
-.vscode

.gitmodules

@@ -9,15 +9,9 @@
 [submodule "libdeflate"]
 	path = libdeflate
 	url = ../libdeflate
+[submodule "zstd"]
+	path = zstd
+	url = ../zstd
 [submodule "abseil"]
 	path = abseil
 	url = ../abseil-cpp
-[submodule "scylla-jmx"]
-	path = tools/jmx
-	url = ../scylla-jmx
-[submodule "scylla-tools"]
-	path = tools/java
-	url = ../scylla-tools-java
-[submodule "scylla-python3"]
-	path = tools/python3
-	url = ../scylla-python3

CMakeLists.txt

@@ -110,7 +110,6 @@ scan_scylla_source_directories(
           io
           locator
           message
-          raft
           repair
           service
           sstables
@@ -135,11 +134,15 @@ add_executable(scylla
         ${SEASTAR_SOURCE_FILES}
         ${SCYLLA_SOURCE_FILES})
 
+# Note that since CLion does not undestand GCC6 concepts, we always disable them (even if users configure otherwise).
+# CLion seems to have trouble with `-U` (macro undefinition), so we do it this way instead.
+list(REMOVE_ITEM SEASTAR_CFLAGS "-DHAVE_GCC6_CONCEPTS")
+
 # If the Seastar pkg-config information is available, append to the default flags.
 #
 # For ease of browsing the source code, we always pretend that DPDK is enabled.
 target_compile_options(scylla PUBLIC
-        -std=gnu++20
+        -std=gnu++1z
         -DHAVE_DPDK
         -DHAVE_HWLOC
         "${SEASTAR_CFLAGS}")
@@ -153,5 +156,4 @@ target_include_directories(scylla PUBLIC
         ${Boost_INCLUDE_DIRS}
         xxhash
         libdeflate
-        abseil
         build/${BUILD_TYPE}/gen)

CONTRIBUTING.md

@@ -8,4 +8,4 @@ Please use the [Issue Tracker](https://github.com/scylladb/scylla/issues/) to re
 
 # Contributing Code to Scylla
 
-To contribute code to Scylla, you need to sign the [Contributor License Agreement](https://www.scylladb.com/open-source/contributor-agreement/) and send your changes as [patches](https://github.com/scylladb/scylla/wiki/Formatting-and-sending-patches) to the [mailing list](https://groups.google.com/forum/#!forum/scylladb-dev). We don't accept pull requests on GitHub.
+To contribute code to Scylla, you need to sign the [Contributor License Agreement](http://www.scylladb.com/opensource/cla/) and send your changes as [patches](https://github.com/scylladb/scylla/wiki/Formatting-and-sending-patches) to the [mailing list](https://groups.google.com/forum/#!forum/scylladb-dev). We don't accept pull requests on GitHub.

HACKING.md

@@ -18,35 +18,23 @@ $ git submodule update --init --recursive
 
 ### Dependencies
 
-Scylla is fairly fussy about its build environment, requiring a very recent
-version of the C++20 compiler and numerous tools and libraries to build.
+Scylla depends on the system package manager for its development dependencies.
 
-Run `./install-dependencies.sh` (as root) to use your Linux distributions's
-package manager to install the appropriate packages on your build machine.
-However, this will only work on very recent distributions. For example,
-currently Fedora users must upgrade to Fedora 32 otherwise the C++ compiler
-will be too old, and not support the new C++20 standard that Scylla uses.
+Running `./install-dependencies.sh` (as root) installs the appropriate packages based on your Linux distribution.
 
-Alternatively, to avoid having to upgrade your build machine or install
-various packages on it, we provide another option - the **frozen toolchain**.
-This is a script, `./tools/toolchain/dbuild`, that can execute build or run
-commands inside a Docker image that contains exactly the right build tools and
-libraries. The `dbuild` technique is useful for beginners, but is also the way
-in which ScyllaDB produces official releases, so it is highly recommended.
+On Ubuntu and Debian based Linux distributions, some packages
+required to build Scylla are missing in the official upstream:
 
-To use `dbuild`, you simply prefix any build or run command with it. Building
-and running Scylla becomes as easy as:
+- libthrift-dev and libthrift
+- antlr3-c++-dev
 
-```bash
-$ ./tools/toolchain/dbuild ./configure.py
-$ ./tools/toolchain/dbuild ninja build/release/scylla
-$ ./tools/toolchain/dbuild ./build/release/scylla --developer-mode 1
-```
+Try running ```sudo ./scripts/scylla_current_repo``` to add Scylla upstream,
+and get the missing packages from it.
 
 ### Build system
 
 **Note**: Compiling Scylla requires, conservatively, 2 GB of memory per native
-thread, and up to 3 GB per native thread while linking. GCC >= 10 is
+thread, and up to 3 GB per native thread while linking. GCC >= 8.1.1. is
 required.
 
 Scylla is built with [Ninja](https://ninja-build.org/), a low-level rule-based system. A Python script, `configure.py`, generates a Ninja file (`build.ninja`) based on configuration options.

MAINTAINERS

@@ -0,0 +1,114 @@
+M: Maintainer with commit access
+R: Reviewer with subsystem expertise
+F: Filename, directory, or pattern for the subsystem
+
+---
+
+AUTH
+R: Calle Wilund <calle@scylladb.com>
+R: Vlad Zolotarov <vladz@scylladb.com>
+R: Jesse Haber-Kucharsky <jhaberku@scylladb.com>
+F: auth/*
+
+CACHE
+M: Tomasz Grabiec <tgrabiec@scylladb.com>
+R: Piotr Jastrzebski <piotr@scylladb.com>
+F: row_cache*
+F: *mutation*
+F: tests/mvcc*
+
+COMMITLOG / BATCHLOGa
+R: Calle Wilund <calle@scylladb.com>
+F: db/commitlog/*
+F: db/batch*
+
+COORDINATOR
+R: Gleb Natapov <gleb@scylladb.com>
+F: service/storage_proxy*
+
+COMPACTION
+R: Raphael S. Carvalho <raphaelsc@scylladb.com>
+R: Glauber Costa <glauber@scylladb.com>
+R: Nadav Har'El <nyh@scylladb.com>
+F: sstables/compaction*
+
+CQL TRANSPORT LAYER
+M: Pekka Enberg <penberg@scylladb.com>
+F: transport/*
+
+CQL QUERY LANGUAGE
+M: Tomasz Grabiec <tgrabiec@scylladb.com>
+M: Pekka Enberg <penberg@scylladb.com>
+F: cql3/*
+
+COUNTERS
+F: counters*
+F: tests/counter_test*
+
+GOSSIP
+M: Tomasz Grabiec <tgrabiec@scylladb.com>
+R: Asias He <asias@scylladb.com>
+F: gms/*
+
+DOCKER
+M: Pekka Enberg <penberg@scylladb.com>
+F: dist/docker/*
+
+LSA
+M: Tomasz Grabiec <tgrabiec@scylladb.com>
+F: utils/logalloc*
+
+MATERIALIZED VIEWS
+M: Pekka Enberg <penberg@scylladb.com>
+M: Nadav Har'El <nyh@scylladb.com>
+F: db/view/*
+F: cql3/statements/*view*
+
+PACKAGING
+R: Takuya ASADA <syuu@scylladb.com>
+F: dist/*
+
+REPAIR
+M: Tomasz Grabiec <tgrabiec@scylladb.com>
+R: Asias He <asias@scylladb.com>
+R: Nadav Har'El <nyh@scylladb.com>
+F: repair/*
+
+SCHEMA MANAGEMENT
+M: Tomasz Grabiec <tgrabiec@scylladb.com>
+M: Pekka Enberg <penberg@scylladb.com>
+F: db/schema_tables*
+F: db/legacy_schema_migrator*
+F: service/migration*
+F: schema*
+
+SECONDARY INDEXES
+M: Pekka Enberg <penberg@scylladb.com>
+M: Nadav Har'El <nyh@scylladb.com>
+R: Pekka Enberg <penberg@scylladb.com>
+F: db/index/*
+F: cql3/statements/*index*
+
+SSTABLES
+M: Tomasz Grabiec <tgrabiec@scylladb.com>
+R: Raphael S. Carvalho <raphaelsc@scylladb.com>
+R: Glauber Costa <glauber@scylladb.com>
+R: Nadav Har'El <nyh@scylladb.com>
+F: sstables/*
+
+STREAMING
+M: Tomasz Grabiec <tgrabiec@scylladb.com>
+R: Asias He <asias@scylladb.com>
+F: streaming/*
+F: service/storage_service.*
+
+ALTERNATOR
+M: Nadav Har'El <nyh@scylladb.com>
+F: alternator/*
+F: alternator-test/*
+
+THE REST
+M: Avi Kivity <avi@scylladb.com>
+M: Tomasz Grabiec <tgrabiec@scylladb.com>
+M: Nadav Har'El <nyh@scylladb.com>
+F: *

README.md

@@ -1,66 +1,41 @@
 # Scylla
 
-[![Slack](https://img.shields.io/badge/slack-scylla-brightgreen.svg?logo=slack)](http://slack.scylladb.com)
-[![Twitter](https://img.shields.io/twitter/follow/ScyllaDB.svg?style=social&label=Follow)](https://twitter.com/intent/follow?screen_name=ScyllaDB)
+## Quick-start
 
-## What is Scylla?
-
-Scylla is the real-time big data database that is API-compatible with Apache Cassandra and Amazon DynamoDB.
-Scylla embraces a shared-nothing approach that increases throughput and storage capacity to realize order-of-magnitude performance improvements and reduce hardware costs.
-
-For more information, please see the [ScyllaDB web site].
-
-[ScyllaDB web site]: https://www.scylladb.com
-
-## Build Prerequisites
-
-Scylla is fairly fussy about its build environment, requiring very recent
-versions of the C++20 compiler and of many libraries to build. The document
-[HACKING.md](HACKING.md) includes detailed information on building and
-developing Scylla, but to get Scylla building quickly on (almost) any build
-machine, Scylla offers a [frozen toolchain](tools/toolchain/README.md),
-This is a pre-configured Docker image which includes recent versions of all
-the required compilers, libraries and build tools. Using the frozen toolchain
-allows you to avoid changing anything in your build machine to meet Scylla's
-requirements - you just need to meet the frozen toolchain's prerequisites
-(mostly, Docker or Podman being available).
-
-## Building Scylla
-
-Building Scylla with the frozen toolchain `dbuild` is as easy as:
+To get the build going quickly, Scylla offers a [frozen toolchain](tools/toolchain/README.md)
+which would build and run Scylla using a pre-configured Docker image.
+Using the frozen toolchain will also isolate all of the installed
+dependencies in a Docker container.
+Assuming you have met the toolchain prerequisites, which is running
+Docker in user mode, building and running is as easy as:
 
 ```bash
-$ git submodule update --init --force --recursive
-$ ./tools/toolchain/dbuild ./configure.py
-$ ./tools/toolchain/dbuild ninja build/release/scylla
-```
+$ ./tools/toolchain/dbuild ./configure.py
+$ ./tools/toolchain/dbuild ninja build/release/scylla
+$ ./tools/toolchain/dbuild ./build/release/scylla --developer-mode 1
+ ```
 
-For further information, please see:
+Please see [HACKING.md](HACKING.md) for detailed information on building and developing Scylla.
 
-* [Developer documentation] for more information on building Scylla.
-* [Build documentation] on how to build Scylla binaries, tests, and packages.
-* [Docker image build documentation] for information on how to build Docker images.
-
-[developer documentation]: HACKING.md
-[build documentation]: docs/building.md
-[docker image build documentation]: dist/docker/redhat/README.md
+**Note**: GCC >= 8.1.1 is required to compile Scylla.
 
 ## Running Scylla
 
-To start Scylla server, run:
+* Run Scylla
+```
+./build/release/scylla
 
-```bash
-$ ./tools/toolchain/dbuild ./build/release/scylla --workdir tmp --smp 1 --developer-mode 1
 ```
 
-This will start a Scylla node with one CPU core allocated to it and data files stored in the `tmp` directory.
-The `--developer-mode` is needed to disable the various checks Scylla performs at startup to ensure the machine is configured for maximum performance (not relevant on development workstations).
-Please note that you need to run Scylla with `dbuild` if you built it with the frozen toolchain.
+* run Scylla with one CPU and ./tmp as work directory
 
-For more run options, run:
+```
+./build/release/scylla --workdir tmp --smp 1
+```
 
-```bash
-$ ./tools/toolchain/dbuild ./build/release/scylla --help
+* For more run options:
+```
+./build/release/scylla --help
 ```
 
 ## Testing
@@ -69,10 +44,10 @@ See [test.py manual](docs/testing.md).
 
 ## Scylla APIs and compatibility
 By default, Scylla is compatible with Apache Cassandra and its APIs - CQL and
-Thrift. There is also support for the API of Amazon DynamoDB™,
-which needs to be enabled and configured in order to be used. For more
-information on how to enable the DynamoDB™ API in Scylla,
-and the current compatibility of this feature as well as Scylla-specific extensions, see
+Thrift. There is also experimental support for the API of Amazon DynamoDB,
+but being experimental it needs to be explicitly enabled to be used. For more
+information on how to enable the experimental DynamoDB compatibility in Scylla,
+and the current limitations of this feature, see
 [Alternator](docs/alternator/alternator.md) and
 [Getting started with Alternator](docs/alternator/getting-started.md).
 
@@ -92,22 +67,22 @@ The courses are free, self-paced and include hands-on examples. They cover a var
 administration, architecture, basic NoSQL concepts, using drivers for application development, Scylla setup, failover, compactions, 
 multi-datacenters and how Scylla integrates with third-party applications.
 
+## Building Fedora-based Docker image
+
+Build a Docker image with:
+
+```
+cd dist/docker
+docker build -t <image-name> .
+```
+
+Run the image with:
+
+```
+docker run -p $(hostname -i):9042:9042 -i -t <image name>
+```
+
 ## Contributing to Scylla
 
-If you want to report a bug or submit a pull request or a patch, please read the [contribution guidelines].
-
-If you are a developer working on Scylla, please read the [developer guidelines].
-
-[contribution guidelines]: CONTRIBUTING.md
-[developer guidelines]: HACKING.md
-
-## Contact
-
-* The [users mailing list] and [Slack channel] are for users to discuss configuration, management, and operations of the ScyllaDB open source.
-* The [developers mailing list] is for developers and people interested in following the development of ScyllaDB to discuss technical topics.
-
-[Users mailing list]: https://groups.google.com/forum/#!forum/scylladb-users
-
-[Slack channel]: http://slack.scylladb.com/
-
-[Developers mailing list]: https://groups.google.com/forum/#!forum/scylladb-dev
+[Hacking howto](HACKING.md)
+[Guidelines for contributing](CONTRIBUTING.md)

SCYLLA-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 PRODUCT=scylla
-VERSION=4.3.7
+VERSION=4.1.11
 
 if test -f version
 then

absl-flat_hash_map.cc

@@ -1,26 +0,0 @@
-/*
- * Copyright (C) 2020 ScyllaDB
- */
-
-/*
- * This file is part of Scylla.
- *
- * Scylla is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Scylla 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 GNU General Public License
- * along with Scylla.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "absl-flat_hash_map.hh"
-
-size_t sstring_hash::operator()(std::string_view v) const noexcept {
-    return absl::Hash<std::string_view>{}(v);
-}

absl-flat_hash_map.hh

@@ -1,47 +0,0 @@
-/*
- * Copyright (C) 2020 ScyllaDB
- */
-
-/*
- * This file is part of Scylla.
- *
- * Scylla is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Scylla 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 GNU General Public License
- * along with Scylla.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include <absl/container/flat_hash_map.h>
-#include <seastar/core/sstring.hh>
-
-using namespace seastar;
-
-struct sstring_hash {
-    using is_transparent = void;
-    size_t operator()(std::string_view v) const noexcept;
-};
-
-struct sstring_eq {
-    using is_transparent = void;
-    bool operator()(std::string_view a, std::string_view b) const noexcept {
-        return a == b;
-    }
-};
-
-template <typename K, typename V, typename... Ts>
-struct flat_hash_map : public absl::flat_hash_map<K, V, Ts...> {
-};
-
-template <typename V>
-struct flat_hash_map<sstring, V>
-    : public absl::flat_hash_map<sstring, V, sstring_hash, sstring_eq> {};

alternator/auth.cc

@@ -78,12 +78,12 @@ void check_expiry(std::string_view signature_date) {
     std::string expiration_str = format_time_point(db_clock::now() - 15min);
     std::string validity_str = format_time_point(db_clock::now() + 15min);
     if (signature_date < expiration_str) {
-        throw api_error::invalid_signature(
+        throw api_error("InvalidSignatureException",
                 fmt::format("Signature expired: {} is now earlier than {} (current time - 15 min.)",
                 signature_date, expiration_str));
     }
     if (signature_date > validity_str) {
-        throw api_error::invalid_signature(
+        throw api_error("InvalidSignatureException",
                 fmt::format("Signature not yet current: {} is still later than {} (current time + 15 min.)",
                 signature_date, validity_str));
     }
@@ -94,13 +94,13 @@ std::string get_signature(std::string_view access_key_id, std::string_view secre
         std::string_view body_content, std::string_view region, std::string_view service, std::string_view query_string) {
     auto amz_date_it = signed_headers_map.find("x-amz-date");
     if (amz_date_it == signed_headers_map.end()) {
-        throw api_error::invalid_signature("X-Amz-Date header is mandatory for signature verification");
+        throw api_error("InvalidSignatureException", "X-Amz-Date header is mandatory for signature verification");
     }
     std::string_view amz_date = amz_date_it->second;
     check_expiry(amz_date);
     std::string_view datestamp = amz_date.substr(0, 8);
     if (datestamp != orig_datestamp) {
-        throw api_error::invalid_signature(
+        throw api_error("InvalidSignatureException",
                 format("X-Amz-Date date does not match the provided datestamp. Expected {}, got {}",
                         orig_datestamp, datestamp));
     }
@@ -126,7 +126,7 @@ std::string get_signature(std::string_view access_key_id, std::string_view secre
 
 future<std::string> get_key_from_roles(cql3::query_processor& qp, std::string username) {
     static const sstring query = format("SELECT salted_hash FROM {} WHERE {} = ?",
-            auth::meta::roles_table::qualified_name, auth::meta::roles_table::role_col_name);
+            auth::meta::roles_table::qualified_name(), auth::meta::roles_table::role_col_name);
 
     auto cl = auth::password_authenticator::consistency_for_user(username);
     auto& timeout = auth::internal_distributed_timeout_config();
@@ -134,11 +134,11 @@ future<std::string> get_key_from_roles(cql3::query_processor& qp, std::string us
         auto res = f.get0();
         auto salted_hash = std::optional<sstring>();
         if (res->empty()) {
-            throw api_error::unrecognized_client(fmt::format("User not found: {}", username));
+            throw api_error("UnrecognizedClientException", fmt::format("User not found: {}", username));
         }
         salted_hash = res->one().get_opt<sstring>("salted_hash");
         if (!salted_hash) {
-            throw api_error::unrecognized_client(fmt::format("No password found for user: {}", username));
+            throw api_error("UnrecognizedClientException", fmt::format("No password found for user: {}", username));
         }
         return make_ready_future<std::string>(*salted_hash);
     });

alternator/base64.cc

@@ -32,13 +32,13 @@
 // and the character used in base64 encoding to represent it.
 static class base64_chars {
 public:
-    static constexpr const char to[] =
+    static constexpr const char* to =
             "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
     int8_t from[255];
     base64_chars() {
-        static_assert(sizeof(to) == 64 + 1);
+        static_assert(strlen(to) == 64);
         for (int i = 0; i < 255; i++) {
-            from[i] = -1; // signal invalid character
+            from[i] = 255; // signal invalid character
         }
         for (int i = 0; i < 64; i++) {
             from[(unsigned) to[i]] = i;
@@ -77,7 +77,7 @@ std::string base64_encode(bytes_view in) {
     return ret;
 }
 
-static std::string base64_decode_string(std::string_view in) {
+bytes base64_decode(std::string_view in) {
     int i = 0;
     int8_t chunk4[4]; // chunk of input, each byte converted to 0..63;
     std::string ret;
@@ -104,42 +104,8 @@ static std::string base64_decode_string(std::string_view in) {
         if (i==3)
             ret += ((chunk4[1] & 0xf) << 4) + ((chunk4[2] & 0x3c) >> 2);
     }
-    return ret;
-}
-
-bytes base64_decode(std::string_view in) {
     // FIXME: This copy is sad. The problem is we need back "bytes"
     // but "bytes" doesn't have efficient append and std::string.
     // To fix this we need to use bytes' "uninitialized" feature.
-    std::string ret = base64_decode_string(in);
     return bytes(ret.begin(), ret.end());
 }
-
-static size_t base64_padding_len(std::string_view str) {
-    size_t padding = 0;
-    padding += (!str.empty() && str.back() == '=');
-    padding += (str.size() > 1 && *(str.end() - 2) == '=');
-    return padding;
-}
-
-size_t base64_decoded_len(std::string_view str) {
-    return str.size() / 4 * 3 - base64_padding_len(str);
-}
-
-bool base64_begins_with(std::string_view base, std::string_view operand) {
-    if (base.size() < operand.size() || base.size() % 4 != 0 || operand.size() % 4 != 0) {
-        return false;
-    }
-    if (base64_padding_len(operand) == 0) {
-        return base.starts_with(operand);
-    }
-    const std::string_view unpadded_base_prefix = base.substr(0, operand.size() - 4);
-    const std::string_view unpadded_operand = operand.substr(0, operand.size() - 4);
-    if (unpadded_base_prefix != unpadded_operand) {
-        return false;
-    }
-    // Decode and compare last 4 bytes of base64-encoded strings
-    const std::string base_remainder = base64_decode_string(base.substr(operand.size() - 4, operand.size()));
-    const std::string operand_remainder = base64_decode_string(operand.substr(operand.size() - 4));
-    return base_remainder.starts_with(operand_remainder);
-}

alternator/base64.hh

@@ -23,7 +23,7 @@
 
 #include <string_view>
 #include "bytes.hh"
-#include "utils/rjson.hh"
+#include "rjson.hh"
 
 std::string base64_encode(bytes_view);
 
@@ -32,7 +32,3 @@ bytes base64_decode(std::string_view);
 inline bytes base64_decode(const rjson::value& v) {
   return base64_decode(std::string_view(v.GetString(), v.GetStringLength()));
 }
-
-size_t base64_decoded_len(std::string_view str);
-
-bool base64_begins_with(std::string_view base, std::string_view operand);

alternator/conditions.cc

@@ -26,7 +26,7 @@
 #include "alternator/error.hh"
 #include "cql3/constants.hh"
 #include <unordered_map>
-#include "utils/rjson.hh"
+#include "rjson.hh"
 #include "serialization.hh"
 #include "base64.hh"
 #include <stdexcept>
@@ -34,7 +34,7 @@
 #include <boost/algorithm/cxx11/any_of.hpp>
 #include "utils/overloaded_functor.hh"
 
-#include "expressions.hh"
+#include "expressions_eval.hh"
 
 namespace alternator {
 
@@ -57,16 +57,59 @@ comparison_operator_type get_comparison_operator(const rjson::value& comparison_
             {"NOT_CONTAINS", comparison_operator_type::NOT_CONTAINS},
     };
     if (!comparison_operator.IsString()) {
-        throw api_error::validation(format("Invalid comparison operator definition {}", rjson::print(comparison_operator)));
+        throw api_error("ValidationException", format("Invalid comparison operator definition {}", rjson::print(comparison_operator)));
     }
     std::string op = comparison_operator.GetString();
     auto it = ops.find(op);
     if (it == ops.end()) {
-        throw api_error::validation(format("Unsupported comparison operator {}", op));
+        throw api_error("ValidationException", format("Unsupported comparison operator {}", op));
     }
     return it->second;
 }
 
+static ::shared_ptr<cql3::restrictions::single_column_restriction::contains> make_map_element_restriction(const column_definition& cdef, std::string_view key, const rjson::value& value) {
+    bytes raw_key = utf8_type->from_string(sstring_view(key.data(), key.size()));
+    auto key_value = ::make_shared<cql3::constants::value>(cql3::raw_value::make_value(std::move(raw_key)));
+    bytes raw_value = serialize_item(value);
+    auto entry_value = ::make_shared<cql3::constants::value>(cql3::raw_value::make_value(std::move(raw_value)));
+    return make_shared<cql3::restrictions::single_column_restriction::contains>(cdef, std::move(key_value), std::move(entry_value));
+}
+
+static ::shared_ptr<cql3::restrictions::single_column_restriction::EQ> make_key_eq_restriction(const column_definition& cdef, const rjson::value& value) {
+    bytes raw_value = get_key_from_typed_value(value, cdef);
+    auto restriction_value = ::make_shared<cql3::constants::value>(cql3::raw_value::make_value(std::move(raw_value)));
+    return make_shared<cql3::restrictions::single_column_restriction::EQ>(cdef, std::move(restriction_value));
+}
+
+::shared_ptr<cql3::restrictions::statement_restrictions> get_filtering_restrictions(schema_ptr schema, const column_definition& attrs_col, const rjson::value& query_filter) {
+    clogger.trace("Getting filtering restrictions for: {}", rjson::print(query_filter));
+    auto filtering_restrictions = ::make_shared<cql3::restrictions::statement_restrictions>(schema, true);
+    for (auto it = query_filter.MemberBegin(); it != query_filter.MemberEnd(); ++it) {
+        std::string_view column_name(it->name.GetString(), it->name.GetStringLength());
+        const rjson::value& condition = it->value;
+
+        const rjson::value& comp_definition = rjson::get(condition, "ComparisonOperator");
+        const rjson::value& attr_list = rjson::get(condition, "AttributeValueList");
+        comparison_operator_type op = get_comparison_operator(comp_definition);
+
+        if (op != comparison_operator_type::EQ) {
+            throw api_error("ValidationException", "Filtering is currently implemented for EQ operator only");
+        }
+        if (attr_list.Size() != 1) {
+            throw api_error("ValidationException", format("EQ restriction needs exactly 1 attribute value: {}", rjson::print(attr_list)));
+        }
+        if (const column_definition* cdef = schema->get_column_definition(to_bytes(column_name.data()))) {
+            // Primary key restriction
+            filtering_restrictions->add_restriction(make_key_eq_restriction(*cdef, attr_list[0]), false, true);
+        } else {
+            // Regular column restriction
+            filtering_restrictions->add_restriction(make_map_element_restriction(attrs_col, column_name, attr_list[0]), false, true);
+        }
+
+    }
+    return filtering_restrictions;
+}
+
 namespace {
 
 struct size_check {
@@ -104,10 +147,10 @@ static void verify_operand_count(const rjson::value* array, const size_check& ex
         return;
     }
     if (!array || !array->IsArray()) {
-        throw api_error::validation("With ComparisonOperator, AttributeValueList must be given and an array");
+        throw api_error("ValidationException", "With ComparisonOperator, AttributeValueList must be given and an array");
     }
     if (!expected(array->Size())) {
-        throw api_error::validation(
+        throw api_error("ValidationException",
                         format("{} operator requires AttributeValueList {}, instead found list size {}",
                                op, expected.what(), array->Size()));
     }
@@ -123,7 +166,7 @@ struct rjson_engaged_ptr_comp {
 // as internally they're stored in an array, and the order of elements is
 // not important in set equality. See issue #5021
 static bool check_EQ_for_sets(const rjson::value& set1, const rjson::value& set2) {
-    if (!set1.IsArray() || !set2.IsArray() || set1.Size() != set2.Size()) {
+    if (set1.Size() != set2.Size()) {
         return false;
     }
     std::set<const rjson::value*, rjson_engaged_ptr_comp> set1_raw;
@@ -131,40 +174,7 @@ static bool check_EQ_for_sets(const rjson::value& set1, const rjson::value& set2
         set1_raw.insert(&*it);
     }
     for (const auto& a : set2.GetArray()) {
-        if (!set1_raw.contains(&a)) {
-            return false;
-        }
-    }
-    return true;
-}
-// Moreover, the JSON being compared can be a nested document with outer
-// layers of lists and maps and some inner set - and we need to get to that
-// inner set to compare it correctly with check_EQ_for_sets() (issue #8514).
-static bool check_EQ(const rjson::value* v1, const rjson::value& v2);
-static bool check_EQ_for_lists(const rjson::value& list1, const rjson::value& list2) {
-    if (!list1.IsArray() || !list2.IsArray() || list1.Size() != list2.Size()) {
-        return false;
-    }
-    auto it1 = list1.Begin();
-    auto it2 = list2.Begin();
-    while (it1 != list1.End()) {
-        // Note: Alternator limits an item's depth (rjson::parse() limits
-        // it to around 37 levels), so this recursion is safe.
-        if (!check_EQ(&*it1, *it2)) {
-            return false;
-        }
-        ++it1;
-        ++it2;
-    }
-    return true;
-}
-static bool check_EQ_for_maps(const rjson::value& list1, const rjson::value& list2) {
-    if (!list1.IsObject() || !list2.IsObject() || list1.MemberCount() != list2.MemberCount()) {
-        return false;
-    }
-    for (auto it1 = list1.MemberBegin(); it1 != list1.MemberEnd(); ++it1) {
-        auto it2 = list2.FindMember(it1->name);
-        if (it2 == list2.MemberEnd() || !check_EQ(&it1->value, it2->value)) {
+        if (set1_raw.count(&a) == 0) {
             return false;
         }
     }
@@ -173,78 +183,55 @@ static bool check_EQ_for_maps(const rjson::value& list1, const rjson::value& lis
 
 // Check if two JSON-encoded values match with the EQ relation
 static bool check_EQ(const rjson::value* v1, const rjson::value& v2) {
-    if (v1 && v1->IsObject() && v1->MemberCount() == 1 && v2.IsObject() && v2.MemberCount() == 1) {
-        auto it1 = v1->MemberBegin();
-        auto it2 = v2.MemberBegin();
-        if (it1->name != it2->name) {
-            return false;
-        }
-        if (it1->name == "SS" || it1->name == "NS" || it1->name == "BS") {
-            return check_EQ_for_sets(it1->value, it2->value);
-        } else if(it1->name == "L") {
-            return check_EQ_for_lists(it1->value, it2->value);
-        } else if(it1->name == "M") {
-            return check_EQ_for_maps(it1->value, it2->value);
-        } else {
-            // Other, non-nested types (number, string, etc.) can be compared
-            // literally, comparing their JSON representation.
-            return it1->value == it2->value;
-        }
-    } else {
-        // If v1 and/or v2 are missing (IsNull()) the result should be false.
-        // In the unlikely case that the object is malformed (issue #8070),
-        // let's also return false.
+    if (!v1) {
         return false;
     }
+    if (v1->IsObject() && v1->MemberCount() == 1 && v2.IsObject() && v2.MemberCount() == 1) {
+        auto it1 = v1->MemberBegin();
+        auto it2 = v2.MemberBegin();
+        if ((it1->name == "SS" && it2->name == "SS") || (it1->name == "NS" && it2->name == "NS") || (it1->name == "BS" && it2->name == "BS")) {
+            return check_EQ_for_sets(it1->value, it2->value);
+        }
+    }
+    return *v1 == v2;
 }
 
 // Check if two JSON-encoded values match with the NE relation
 static bool check_NE(const rjson::value* v1, const rjson::value& v2) {
-    return !check_EQ(v1, v2);
+    return !v1 || *v1 != v2; // null is unequal to anything.
 }
 
 // Check if two JSON-encoded values match with the BEGINS_WITH relation
-bool check_BEGINS_WITH(const rjson::value* v1, const rjson::value& v2,
-                       bool v1_from_query, bool v2_from_query) {
-    bool bad = false;
-    if (!v1 || !v1->IsObject() || v1->MemberCount() != 1) {
-        if (v1_from_query) {
-            throw api_error::validation("begins_with() encountered malformed argument");
-        } else {
-            bad = true;
-        }
-    } else if (v1->MemberBegin()->name != "S" && v1->MemberBegin()->name != "B") {
-        if (v1_from_query) {
-            throw api_error::validation(format("begins_with supports only string or binary type, got: {}", *v1));
-        } else {
-            bad = true;
-        }
-    }
+static bool check_BEGINS_WITH(const rjson::value* v1, const rjson::value& v2) {
+    // BEGINS_WITH requires that its single operand (v2) be a string or
+    // binary - otherwise it's a validation error. However, problems with
+    // the stored attribute (v1) will just return false (no match).
     if (!v2.IsObject() || v2.MemberCount() != 1) {
-        if (v2_from_query) {
-            throw api_error::validation("begins_with() encountered malformed argument");
-        } else {
-            bad = true;
-        }
-    } else if (v2.MemberBegin()->name != "S" && v2.MemberBegin()->name != "B") {
-        if (v2_from_query) {
-            throw api_error::validation(format("begins_with() supports only string or binary type, got: {}", v2));
-        } else {
-            bad = true;
-        }
+        throw api_error("ValidationException", format("BEGINS_WITH operator encountered malformed AttributeValue: {}", v2));
     }
-    if (bad) {
+    auto it2 = v2.MemberBegin();
+    if (it2->name != "S" && it2->name != "B") {
+        throw api_error("ValidationException", format("BEGINS_WITH operator requires String or Binary in AttributeValue, got {}", it2->name));
+    }
+
+
+    if (!v1 || !v1->IsObject() || v1->MemberCount() != 1) {
         return false;
     }
     auto it1 = v1->MemberBegin();
-    auto it2 = v2.MemberBegin();
     if (it1->name != it2->name) {
         return false;
     }
     if (it2->name == "S") {
-        return rjson::to_string_view(it1->value).starts_with(rjson::to_string_view(it2->value));
+        std::string_view val1(it1->value.GetString(), it1->value.GetStringLength());
+        std::string_view val2(it2->value.GetString(), it2->value.GetStringLength());
+        return val1.substr(0, val2.size()) == val2;
     } else /* it2->name == "B" */ {
-        return base64_begins_with(rjson::to_string_view(it1->value), rjson::to_string_view(it2->value));
+        // TODO (optimization): Check the begins_with condition directly on
+        // the base64-encoded string, without making a decoded copy.
+        bytes val1 = base64_decode(it1->value);
+        bytes val2 = base64_decode(it2->value);
+        return val1.substr(0, val2.size()) == val2;
     }
 }
 
@@ -259,6 +246,11 @@ bool check_CONTAINS(const rjson::value* v1, const rjson::value& v2) {
     }
     const auto& kv1 = *v1->MemberBegin();
     const auto& kv2 = *v2.MemberBegin();
+    if (kv2.name != "S" && kv2.name != "N" &&  kv2.name != "B") {
+        throw api_error("ValidationException",
+                        format("CONTAINS operator requires a single AttributeValue of type String, Number, or Binary, "
+                               "got {} instead", kv2.name));
+    }
     if (kv1.name == "S" && kv2.name == "S") {
         return rjson::to_string_view(kv1.value).find(rjson::to_string_view(kv2.value)) != std::string_view::npos;
     } else if (kv1.name == "B" && kv2.name == "B") {
@@ -295,12 +287,12 @@ static bool check_NOT_CONTAINS(const rjson::value* v1, const rjson::value& v2) {
 // Check if a JSON-encoded value equals any element of an array, which must have at least one element.
 static bool check_IN(const rjson::value* val, const rjson::value& array) {
     if (!array[0].IsObject() || array[0].MemberCount() != 1) {
-        throw api_error::validation(
+        throw api_error("ValidationException",
                         format("IN operator encountered malformed AttributeValue: {}", array[0]));
     }
     const auto& type = array[0].MemberBegin()->name;
     if (type != "S" && type != "N" && type != "B") {
-        throw api_error::validation(
+        throw api_error("ValidationException",
                         "IN operator requires AttributeValueList elements to be of type String, Number, or Binary ");
     }
     if (!val) {
@@ -309,7 +301,7 @@ static bool check_IN(const rjson::value* val, const rjson::value& array) {
     bool have_match = false;
     for (const auto& elem : array.GetArray()) {
         if (!elem.IsObject() || elem.MemberCount() != 1 || elem.MemberBegin()->name != type) {
-            throw api_error::validation(
+            throw api_error("ValidationException",
                             "IN operator requires all AttributeValueList elements to have the same type ");
         }
         if (!have_match && *val == elem) {
@@ -341,40 +333,24 @@ static bool check_NOT_NULL(const rjson::value* val) {
     return val != nullptr;
 }
 
-// Only types S, N or B (string, number or bytes) may be compared by the
-// various comparion operators - lt, le, gt, ge, and between.
-// Note that in particular, if the value is missing (v->IsNull()), this
-// check returns false.
-static bool check_comparable_type(const rjson::value& v) {
-    if (!v.IsObject() || v.MemberCount() != 1) {
-        return false;
-    }
-    const rjson::value& type = v.MemberBegin()->name;
-    return type == "S" || type == "N" || type == "B";
-}
-
 // Check if two JSON-encoded values match with cmp.
 template <typename Comparator>
-bool check_compare(const rjson::value* v1, const rjson::value& v2, const Comparator& cmp,
-                   bool v1_from_query, bool v2_from_query) {
-    bool bad = false;
-    if (!v1 || !check_comparable_type(*v1)) {
-        if (v1_from_query) {
-            throw api_error::validation(format("{} allow only the types String, Number, or Binary", cmp.diagnostic));
-        }
-        bad = true;
+bool check_compare(const rjson::value* v1, const rjson::value& v2, const Comparator& cmp) {
+    if (!v2.IsObject() || v2.MemberCount() != 1) {
+        throw api_error("ValidationException",
+                        format("{} requires a single AttributeValue of type String, Number, or Binary",
+                               cmp.diagnostic));
     }
-    if (!check_comparable_type(v2)) {
-        if (v2_from_query) {
-            throw api_error::validation(format("{} allow only the types String, Number, or Binary", cmp.diagnostic));
-        }
-        bad = true;
+    const auto& kv2 = *v2.MemberBegin();
+    if (kv2.name != "S" && kv2.name != "N" && kv2.name != "B") {
+        throw api_error("ValidationException",
+                        format("{} requires a single AttributeValue of type String, Number, or Binary",
+                               cmp.diagnostic));
     }
-    if (bad) {
+    if (!v1 || !v1->IsObject() || v1->MemberCount() != 1) {
         return false;
     }
     const auto& kv1 = *v1->MemberBegin();
-    const auto& kv2 = *v2.MemberBegin();
     if (kv1.name != kv2.name) {
         return false;
     }
@@ -388,8 +364,7 @@ bool check_compare(const rjson::value* v1, const rjson::value& v2, const Compara
     if (kv1.name == "B") {
         return cmp(base64_decode(kv1.value), base64_decode(kv2.value));
     }
-    // cannot reach here, as check_comparable_type() verifies the type is one
-    // of the above options.
+    clogger.error("check_compare panic: LHS type equals RHS type, but one is in {N,S,B} while the other isn't");
     return false;
 }
 
@@ -420,71 +395,57 @@ struct cmp_gt {
     static constexpr const char* diagnostic = "GT operator";
 };
 
-// True if v is between lb and ub, inclusive.  Throws or returns false
-// (depending on bounds_from_query parameter) if lb > ub.
+// True if v is between lb and ub, inclusive.  Throws if lb > ub.
 template <typename T>
-static bool check_BETWEEN(const T& v, const T& lb, const T& ub, bool bounds_from_query) {
+bool check_BETWEEN(const T& v, const T& lb, const T& ub) {
     if (cmp_lt()(ub, lb)) {
-        if (bounds_from_query) {
-            throw api_error::validation(
-                format("BETWEEN operator requires lower_bound <= upper_bound, but {} > {}", lb, ub));
-        } else {
-            return false;
-        }
+        throw api_error("ValidationException",
+                        format("BETWEEN operator requires lower_bound <= upper_bound, but {} > {}", lb, ub));
     }
     return cmp_ge()(v, lb) && cmp_le()(v, ub);
 }
 
-static bool check_BETWEEN(const rjson::value* v, const rjson::value& lb, const rjson::value& ub,
-                          bool v_from_query, bool lb_from_query, bool ub_from_query) {
-    if ((v && v_from_query && !check_comparable_type(*v)) ||
-        (lb_from_query && !check_comparable_type(lb)) ||
-        (ub_from_query && !check_comparable_type(ub))) {
-        throw api_error::validation("between allow only the types String, Number, or Binary");
-
-    }
-    if (!v || !v->IsObject() || v->MemberCount() != 1 ||
-        !lb.IsObject() || lb.MemberCount() != 1 ||
-        !ub.IsObject() || ub.MemberCount() != 1) {
+static bool check_BETWEEN(const rjson::value* v, const rjson::value& lb, const rjson::value& ub) {
+    if (!v) {
         return false;
     }
+    if (!v->IsObject() || v->MemberCount() != 1) {
+        throw api_error("ValidationException", format("BETWEEN operator encountered malformed AttributeValue: {}", *v));
+    }
+    if (!lb.IsObject() || lb.MemberCount() != 1) {
+        throw api_error("ValidationException", format("BETWEEN operator encountered malformed AttributeValue: {}", lb));
+    }
+    if (!ub.IsObject() || ub.MemberCount() != 1) {
+        throw api_error("ValidationException", format("BETWEEN operator encountered malformed AttributeValue: {}", ub));
+    }
 
     const auto& kv_v = *v->MemberBegin();
     const auto& kv_lb = *lb.MemberBegin();
     const auto& kv_ub = *ub.MemberBegin();
-    bool bounds_from_query = lb_from_query && ub_from_query;
     if (kv_lb.name != kv_ub.name) {
-        if (bounds_from_query) {
-           throw api_error::validation(
+        throw api_error(
+                "ValidationException",
                 format("BETWEEN operator requires the same type for lower and upper bound; instead got {} and {}",
                        kv_lb.name, kv_ub.name));
-        } else {
-            return false;
-        }
     }
     if (kv_v.name != kv_lb.name) { // Cannot compare different types, so v is NOT between lb and ub.
         return false;
     }
     if (kv_v.name == "N") {
         const char* diag = "BETWEEN operator";
-        return check_BETWEEN(unwrap_number(*v, diag), unwrap_number(lb, diag), unwrap_number(ub, diag), bounds_from_query);
+        return check_BETWEEN(unwrap_number(*v, diag), unwrap_number(lb, diag), unwrap_number(ub, diag));
     }
     if (kv_v.name == "S") {
         return check_BETWEEN(std::string_view(kv_v.value.GetString(), kv_v.value.GetStringLength()),
                              std::string_view(kv_lb.value.GetString(), kv_lb.value.GetStringLength()),
-                             std::string_view(kv_ub.value.GetString(), kv_ub.value.GetStringLength()),
-                             bounds_from_query);
+                             std::string_view(kv_ub.value.GetString(), kv_ub.value.GetStringLength()));
     }
     if (kv_v.name == "B") {
-        return check_BETWEEN(base64_decode(kv_v.value), base64_decode(kv_lb.value), base64_decode(kv_ub.value), bounds_from_query);
+        return check_BETWEEN(base64_decode(kv_v.value), base64_decode(kv_lb.value), base64_decode(kv_ub.value));
     }
-    if (v_from_query) {
-        throw api_error::validation(
-            format("BETWEEN operator requires AttributeValueList elements to be of type String, Number, or Binary; instead got {}",
+    throw api_error("ValidationException",
+        format("BETWEEN operator requires AttributeValueList elements to be of type String, Number, or Binary; instead got {}",
                kv_lb.name));
-    } else {
-        return false;
-    }
 }
 
 // Verify one Expect condition on one attribute (whose content is "got")
@@ -502,24 +463,24 @@ static bool verify_expected_one(const rjson::value& condition, const rjson::valu
     // and requires a different combinations of parameters in the request
     if (value) {
         if (exists && (!exists->IsBool() || exists->GetBool() != true)) {
-            throw api_error::validation("Cannot combine Value with Exists!=true");
+            throw api_error("ValidationException", "Cannot combine Value with Exists!=true");
         }
         if (comparison_operator) {
-            throw api_error::validation("Cannot combine Value with ComparisonOperator");
+            throw api_error("ValidationException", "Cannot combine Value with ComparisonOperator");
         }
         return check_EQ(got, *value);
     } else if (exists) {
         if (comparison_operator) {
-            throw api_error::validation("Cannot combine Exists with ComparisonOperator");
+            throw api_error("ValidationException", "Cannot combine Exists with ComparisonOperator");
         }
         if (!exists->IsBool() || exists->GetBool() != false) {
-            throw api_error::validation("Exists!=false requires Value");
+            throw api_error("ValidationException", "Exists!=false requires Value");
         }
         // Remember Exists=false, so we're checking that the attribute does *not* exist:
         return !got;
     } else {
         if (!comparison_operator) {
-            throw api_error::validation("Missing ComparisonOperator, Value or Exists");
+            throw api_error("ValidationException", "Missing ComparisonOperator, Value or Exists");
         }
         comparison_operator_type op = get_comparison_operator(*comparison_operator);
         switch (op) {
@@ -531,19 +492,19 @@ static bool verify_expected_one(const rjson::value& condition, const rjson::valu
             return check_NE(got, (*attribute_value_list)[0]);
         case comparison_operator_type::LT:
             verify_operand_count(attribute_value_list, exact_size(1), *comparison_operator);
-            return check_compare(got, (*attribute_value_list)[0], cmp_lt{}, false, true);
+            return check_compare(got, (*attribute_value_list)[0], cmp_lt{});
         case comparison_operator_type::LE:
             verify_operand_count(attribute_value_list, exact_size(1), *comparison_operator);
-            return check_compare(got, (*attribute_value_list)[0], cmp_le{}, false, true);
+            return check_compare(got, (*attribute_value_list)[0], cmp_le{});
         case comparison_operator_type::GT:
             verify_operand_count(attribute_value_list, exact_size(1), *comparison_operator);
-            return check_compare(got, (*attribute_value_list)[0], cmp_gt{}, false, true);
+            return check_compare(got, (*attribute_value_list)[0], cmp_gt{});
         case comparison_operator_type::GE:
             verify_operand_count(attribute_value_list, exact_size(1), *comparison_operator);
-            return check_compare(got, (*attribute_value_list)[0], cmp_ge{}, false, true);
+            return check_compare(got, (*attribute_value_list)[0], cmp_ge{});
         case comparison_operator_type::BEGINS_WITH:
             verify_operand_count(attribute_value_list, exact_size(1), *comparison_operator);
-            return check_BEGINS_WITH(got, (*attribute_value_list)[0], false, true);
+            return check_BEGINS_WITH(got, (*attribute_value_list)[0]);
         case comparison_operator_type::IN:
             verify_operand_count(attribute_value_list, nonempty(), *comparison_operator);
             return check_IN(got, *attribute_value_list);
@@ -555,87 +516,56 @@ static bool verify_expected_one(const rjson::value& condition, const rjson::valu
             return check_NOT_NULL(got);
         case comparison_operator_type::BETWEEN:
             verify_operand_count(attribute_value_list, exact_size(2), *comparison_operator);
-            return check_BETWEEN(got, (*attribute_value_list)[0], (*attribute_value_list)[1],
-                                 false, true, true);
+            return check_BETWEEN(got, (*attribute_value_list)[0], (*attribute_value_list)[1]);
         case comparison_operator_type::CONTAINS:
-            {
-                verify_operand_count(attribute_value_list, exact_size(1), *comparison_operator);
-                // Expected's "CONTAINS" has this artificial limitation.
-                // ConditionExpression's "contains()" does not...
-                const rjson::value& arg = (*attribute_value_list)[0];
-                const auto& argtype = (*arg.MemberBegin()).name;
-                if (argtype != "S" && argtype != "N" && argtype != "B") {
-                    throw api_error::validation(
-                            format("CONTAINS operator requires a single AttributeValue of type String, Number, or Binary, "
-                                    "got {} instead", argtype));
-                }
-                return check_CONTAINS(got, arg);
-            }
+            verify_operand_count(attribute_value_list, exact_size(1), *comparison_operator);
+            return check_CONTAINS(got, (*attribute_value_list)[0]);
         case comparison_operator_type::NOT_CONTAINS:
-            {
-                verify_operand_count(attribute_value_list, exact_size(1), *comparison_operator);
-                // Expected's "NOT_CONTAINS" has this artificial limitation.
-                // ConditionExpression's "contains()" does not...
-                const rjson::value& arg = (*attribute_value_list)[0];
-                const auto& argtype = (*arg.MemberBegin()).name;
-                if (argtype != "S" && argtype != "N" && argtype != "B") {
-                    throw api_error::validation(
-                            format("CONTAINS operator requires a single AttributeValue of type String, Number, or Binary, "
-                                    "got {} instead", argtype));
-                }
-                return check_NOT_CONTAINS(got, arg);
-            }
+            verify_operand_count(attribute_value_list, exact_size(1), *comparison_operator);
+            return check_NOT_CONTAINS(got, (*attribute_value_list)[0]);
         }
         throw std::logic_error(format("Internal error: corrupted operator enum: {}", int(op)));
     }
 }
 
-conditional_operator_type get_conditional_operator(const rjson::value& req) {
-    const rjson::value* conditional_operator = rjson::find(req, "ConditionalOperator");
-    if (!conditional_operator) {
-        return conditional_operator_type::MISSING;
-    }
-    if (!conditional_operator->IsString()) {
-        throw api_error::validation("'ConditionalOperator' parameter, if given, must be a string");
-    }
-    auto s = rjson::to_string_view(*conditional_operator);
-    if (s == "AND") {
-        return conditional_operator_type::AND;
-    } else if (s == "OR") {
-        return conditional_operator_type::OR;
-    } else {
-        throw api_error::validation(
-                format("'ConditionalOperator' parameter must be AND, OR or missing. Found {}.", s));
-    }
-}
-
 // Check if the existing values of the item (previous_item) match the
 // conditions given by the Expected and ConditionalOperator parameters
 // (if they exist) in the request (an UpdateItem, PutItem or DeleteItem).
 // This function can throw an ValidationException API error if there
 // are errors in the format of the condition itself.
-bool verify_expected(const rjson::value& req, const rjson::value* previous_item) {
+bool verify_expected(const rjson::value& req, const std::unique_ptr<rjson::value>& previous_item) {
     const rjson::value* expected = rjson::find(req, "Expected");
-    auto conditional_operator = get_conditional_operator(req);
-    if (conditional_operator != conditional_operator_type::MISSING &&
-        (!expected || (expected->IsObject() && expected->GetObject().ObjectEmpty()))) {
-            throw api_error::validation("'ConditionalOperator' parameter cannot be specified for missing or empty Expression");
-    }
     if (!expected) {
         return true;
     }
     if (!expected->IsObject()) {
-        throw api_error::validation("'Expected' parameter, if given, must be an object");
+        throw api_error("ValidationException", "'Expected' parameter, if given, must be an object");
+    }
+    // ConditionalOperator can be "AND" for requiring all conditions, or
+    // "OR" for requiring one condition, and defaults to "AND" if missing.
+    const rjson::value* conditional_operator = rjson::find(req, "ConditionalOperator");
+    bool require_all = true;
+    if (conditional_operator) {
+        if (!conditional_operator->IsString()) {
+            throw api_error("ValidationException", "'ConditionalOperator' parameter, if given, must be a string");
+        }
+        std::string_view s(conditional_operator->GetString(), conditional_operator->GetStringLength());
+        if (s == "AND") {
+            // require_all is already true
+        } else if (s == "OR") {
+            require_all = false;
+        } else {
+            throw api_error("ValidationException", "'ConditionalOperator' parameter must be AND, OR or missing");
+        }
+        if (expected->GetObject().ObjectEmpty()) {
+            throw api_error("ValidationException", "'ConditionalOperator' parameter cannot be specified for empty Expression");
+        }
     }
-    bool require_all = conditional_operator != conditional_operator_type::OR;
-    return verify_condition(*expected, require_all, previous_item);
-}
 
-bool verify_condition(const rjson::value& condition, bool require_all, const rjson::value* previous_item) {
-    for (auto it = condition.MemberBegin(); it != condition.MemberEnd(); ++it) {
+    for (auto it = expected->MemberBegin(); it != expected->MemberEnd(); ++it) {
         const rjson::value* got = nullptr;
-        if (previous_item) {
-            got = rjson::find(*previous_item, rjson::to_string_view(it->name));
+        if (previous_item && previous_item->IsObject() && previous_item->HasMember("Item")) {
+            got = rjson::find((*previous_item)["Item"], rjson::to_string_view(it->name));
         }
         bool success = verify_expected_one(it->value, got);
         if (success && !require_all) {
@@ -651,8 +581,12 @@ bool verify_condition(const rjson::value& condition, bool require_all, const rjs
     return require_all;
 }
 
-static bool calculate_primitive_condition(const parsed::primitive_condition& cond,
-        const rjson::value* previous_item) {
+bool calculate_primitive_condition(const parsed::primitive_condition& cond,
+        std::unordered_set<std::string>& used_attribute_values,
+        std::unordered_set<std::string>& used_attribute_names,
+        const rjson::value& req,
+        schema_ptr schema,
+        const std::unique_ptr<rjson::value>& previous_item) {
     std::vector<rjson::value> calculated_values;
     calculated_values.reserve(cond._values.size());
     for (const parsed::value& v : cond._values) {
@@ -660,7 +594,9 @@ static bool calculate_primitive_condition(const parsed::primitive_condition& con
                 cond._op == parsed::primitive_condition::type::VALUE ?
                         calculate_value_caller::ConditionExpressionAlone :
                         calculate_value_caller::ConditionExpression,
-                previous_item));
+                rjson::find(req, "ExpressionAttributeValues"),
+                used_attribute_names, used_attribute_values,
+                req, schema, previous_item));
     }
     switch (cond._op) {
     case parsed::primitive_condition::type::BETWEEN:
@@ -668,8 +604,7 @@ static bool calculate_primitive_condition(const parsed::primitive_condition& con
             // Shouldn't happen unless we have a bug in the parser
             throw std::logic_error(format("Wrong number of values {} in BETWEEN primitive_condition", cond._values.size()));
         }
-        return check_BETWEEN(&calculated_values[0], calculated_values[1], calculated_values[2],
-                             cond._values[0].is_constant(), cond._values[1].is_constant(), cond._values[2].is_constant());
+        return check_BETWEEN(&calculated_values[0], calculated_values[1], calculated_values[2]);
     case parsed::primitive_condition::type::IN:
         return check_IN(calculated_values);
     case parsed::primitive_condition::type::VALUE:
@@ -684,7 +619,7 @@ static bool calculate_primitive_condition(const parsed::primitive_condition& con
                 return it->value.GetBool();
             }
         }
-        throw api_error::validation(
+        throw api_error("ValidationException",
                 format("ConditionExpression: condition results in a non-boolean value: {}",
                         calculated_values[0]));
     default:
@@ -700,17 +635,13 @@ static bool calculate_primitive_condition(const parsed::primitive_condition& con
     case parsed::primitive_condition::type::NE:
         return check_NE(&calculated_values[0], calculated_values[1]);
     case parsed::primitive_condition::type::GT:
-        return check_compare(&calculated_values[0], calculated_values[1], cmp_gt{},
-            cond._values[0].is_constant(), cond._values[1].is_constant());
+        return check_compare(&calculated_values[0], calculated_values[1], cmp_gt{});
     case parsed::primitive_condition::type::GE:
-        return check_compare(&calculated_values[0], calculated_values[1], cmp_ge{},
-            cond._values[0].is_constant(), cond._values[1].is_constant());
+        return check_compare(&calculated_values[0], calculated_values[1], cmp_ge{});
     case parsed::primitive_condition::type::LT:
-        return check_compare(&calculated_values[0], calculated_values[1], cmp_lt{},
-            cond._values[0].is_constant(), cond._values[1].is_constant());
+        return check_compare(&calculated_values[0], calculated_values[1], cmp_lt{});
     case parsed::primitive_condition::type::LE:
-        return check_compare(&calculated_values[0], calculated_values[1], cmp_le{},
-            cond._values[0].is_constant(), cond._values[1].is_constant());
+        return check_compare(&calculated_values[0], calculated_values[1], cmp_le{});
     default:
         // Shouldn't happen unless we have a bug in the parser
         throw std::logic_error(format("Unknown type {} in primitive_condition object", (int)(cond._op)));
@@ -721,17 +652,23 @@ static bool calculate_primitive_condition(const parsed::primitive_condition& con
 // conditions given by the given parsed ConditionExpression.
 bool verify_condition_expression(
         const parsed::condition_expression& condition_expression,
-        const rjson::value* previous_item) {
+        std::unordered_set<std::string>& used_attribute_values,
+        std::unordered_set<std::string>& used_attribute_names,
+        const rjson::value& req,
+        schema_ptr schema,
+        const std::unique_ptr<rjson::value>& previous_item) {
     if (condition_expression.empty()) {
         return true;
     }
     bool ret = std::visit(overloaded_functor {
         [&] (const parsed::primitive_condition& cond) -> bool {
-            return calculate_primitive_condition(cond, previous_item);
+            return calculate_primitive_condition(cond, used_attribute_values,
+                    used_attribute_names, req, schema, previous_item);
         },
         [&] (const parsed::condition_expression::condition_list& list) -> bool {
             auto verify_condition = [&] (const parsed::condition_expression& e) {
-                return verify_condition_expression(e, previous_item);
+                return verify_condition_expression(e, used_attribute_values,
+                        used_attribute_names, req, schema, previous_item);
             };
             switch (list.op) {
             case '&':

alternator/conditions.hh

@@ -33,7 +33,6 @@
 
 #include "cql3/restrictions/statement_restrictions.hh"
 #include "serialization.hh"
-#include "expressions_types.hh"
 
 namespace alternator {
 
@@ -43,19 +42,8 @@ enum class comparison_operator_type {
 
 comparison_operator_type get_comparison_operator(const rjson::value& comparison_operator);
 
-enum class conditional_operator_type {
-    AND, OR, MISSING
-};
-conditional_operator_type get_conditional_operator(const rjson::value& req);
+::shared_ptr<cql3::restrictions::statement_restrictions> get_filtering_restrictions(schema_ptr schema, const column_definition& attrs_col, const rjson::value& query_filter);
 
-bool verify_expected(const rjson::value& req, const rjson::value* previous_item);
-bool verify_condition(const rjson::value& condition, bool require_all, const rjson::value* previous_item);
-
-bool check_CONTAINS(const rjson::value* v1, const rjson::value& v2);
-bool check_BEGINS_WITH(const rjson::value* v1, const rjson::value& v2, bool v1_from_query, bool v2_from_query);
-
-bool verify_condition_expression(
-        const parsed::condition_expression& condition_expression,
-        const rjson::value* previous_item);
+bool verify_expected(const rjson::value& req, const std::unique_ptr<rjson::value>& previous_item);
 
 }

alternator/error.hh

@@ -26,15 +26,12 @@
 
 namespace alternator {
 
-// api_error contains a DynamoDB error message to be returned to the user.
-// It can be returned by value (see executor::request_return_type) or thrown.
-// The DynamoDB's error messages are described in detail in
+// DynamoDB's error messages are described in detail in
 // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.Errors.html
-// An error message has an HTTP code (almost always 400), a type, e.g.,
-// "ResourceNotFoundException", and a human readable message.
-// Eventually alternator::api_handler will convert a returned or thrown
-// api_error into a JSON object, and that is returned to the user.
-class api_error final {
+// Ah An error message has a "type", e.g., "ResourceNotFoundException", a coarser
+// HTTP code (almost always, 400), and a human readable message. Eventually these
+// will be wrapped into a JSON object returned to the client.
+class api_error : public std::exception {
 public:
     using status_type = httpd::reply::status_type;
     status_type _http_code;
@@ -45,41 +42,8 @@ public:
         , _type(std::move(type))
         , _msg(std::move(msg))
     { }
-
-    // Factory functions for some common types of DynamoDB API errors
-    static api_error validation(std::string msg) {
-        return api_error("ValidationException", std::move(msg));
-    }
-    static api_error resource_not_found(std::string msg) {
-        return api_error("ResourceNotFoundException", std::move(msg));
-    }
-    static api_error resource_in_use(std::string msg) {
-        return api_error("ResourceInUseException", std::move(msg));
-    }
-    static api_error invalid_signature(std::string msg) {
-        return api_error("InvalidSignatureException", std::move(msg));
-    }
-    static api_error unrecognized_client(std::string msg) {
-        return api_error("UnrecognizedClientException", std::move(msg));
-    }
-    static api_error unknown_operation(std::string msg) {
-        return api_error("UnknownOperationException", std::move(msg));
-    }
-    static api_error access_denied(std::string msg) {
-        return api_error("AccessDeniedException", std::move(msg));
-    }
-    static api_error conditional_check_failed(std::string msg) {
-        return api_error("ConditionalCheckFailedException", std::move(msg));
-    }
-    static api_error expired_iterator(std::string msg) {
-        return api_error("ExpiredIteratorException", std::move(msg));
-    }
-    static api_error trimmed_data_access_exception(std::string msg) {
-        return api_error("TrimmedDataAccessException", std::move(msg));
-    }
-    static api_error internal(std::string msg) {
-        return api_error("InternalServerError", std::move(msg), reply::status_type::internal_server_error);
-    }
+    api_error() = default;
+    virtual const char* what() const noexcept override { return _msg.c_str(); }
 };
 
 }

alternator/executor.hh

@@ -30,51 +30,16 @@
 #include "service/storage_proxy.hh"
 #include "service/migration_manager.hh"
 #include "service/client_state.hh"
-#include "db/timeout_clock.hh"
 
 #include "alternator/error.hh"
 #include "stats.hh"
-#include "utils/rjson.hh"
-
-namespace db {
-    class system_distributed_keyspace;
-}
-
-namespace query {
-class partition_slice;
-class result;
-}
-
-namespace cql3::selection {
-    class selection;
-}
-
-namespace service {
-    class storage_service;
-}
+#include "rjson.hh"
 
 namespace alternator {
 
-class rmw_operation;
-
-struct make_jsonable : public json::jsonable {
-    rjson::value _value;
-public:
-    explicit make_jsonable(rjson::value&& value);
-    std::string to_json() const override;
-};
-struct json_string : public json::jsonable {
-    std::string _value;
-public:
-    explicit json_string(std::string&& value);
-    std::string to_json() const override;
-};
-
 class executor : public peering_sharded_service<executor> {
     service::storage_proxy& _proxy;
     service::migration_manager& _mm;
-    db::system_distributed_keyspace& _sdks;
-    service::storage_service& _ss;
     // An smp_service_group to be used for limiting the concurrency when
     // forwarding Alternator request between shards - if necessary for LWT.
     smp_service_group _ssg;
@@ -87,13 +52,12 @@ public:
     static constexpr auto KEYSPACE_NAME_PREFIX = "alternator_";
     static constexpr std::string_view INTERNAL_TABLE_PREFIX = ".scylla.alternator.";
 
-    executor(service::storage_proxy& proxy, service::migration_manager& mm, db::system_distributed_keyspace& sdks, service::storage_service& ss, smp_service_group ssg)
-        : _proxy(proxy), _mm(mm), _sdks(sdks), _ss(ss), _ssg(ssg) {}
+    executor(service::storage_proxy& proxy, service::migration_manager& mm, smp_service_group ssg)
+        : _proxy(proxy), _mm(mm), _ssg(ssg) {}
 
     future<request_return_type> create_table(client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value request);
     future<request_return_type> describe_table(client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value request);
     future<request_return_type> delete_table(client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value request);
-    future<request_return_type> update_table(client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value request);
     future<request_return_type> put_item(client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value request);
     future<request_return_type> get_item(client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value request);
     future<request_return_type> delete_item(client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value request);
@@ -107,10 +71,6 @@ public:
     future<request_return_type> tag_resource(client_state& client_state, service_permit permit, rjson::value request);
     future<request_return_type> untag_resource(client_state& client_state, service_permit permit, rjson::value request);
     future<request_return_type> list_tags_of_resource(client_state& client_state, service_permit permit, rjson::value request);
-    future<request_return_type> list_streams(client_state& client_state, service_permit permit, rjson::value request);
-    future<request_return_type> describe_stream(client_state& client_state, service_permit permit, rjson::value request);
-    future<request_return_type> get_shard_iterator(client_state& client_state, service_permit permit, rjson::value request);
-    future<request_return_type> get_records(client_state& client_state, tracing::trace_state_ptr, service_permit permit, rjson::value request);
 
     future<> start();
     future<> stop() { return make_ready_future<>(); }
@@ -118,37 +78,6 @@ public:
     future<> create_keyspace(std::string_view keyspace_name);
 
     static tracing::trace_state_ptr maybe_trace_query(client_state& client_state, sstring_view op, sstring_view query);
-
-    static sstring table_name(const schema&);
-    static db::timeout_clock::time_point default_timeout();
-    static schema_ptr find_table(service::storage_proxy&, const rjson::value& request);
-
-private:
-    friend class rmw_operation;
-
-    static bool is_alternator_keyspace(const sstring& ks_name);
-    static sstring make_keyspace_name(const sstring& table_name);
-    static void describe_key_schema(rjson::value& parent, const schema&, std::unordered_map<std::string,std::string> * = nullptr);
-    static void describe_key_schema(rjson::value& parent, const schema& schema, std::unordered_map<std::string,std::string>&);
-    
-public:    
-    static std::optional<rjson::value> describe_single_item(schema_ptr,
-        const query::partition_slice&,
-        const cql3::selection::selection&,
-        const query::result&,
-        const std::unordered_set<std::string>&);
-
-    static void describe_single_item(const cql3::selection::selection&,
-        const std::vector<bytes_opt>&,
-        const std::unordered_set<std::string>&,
-        rjson::value&,
-        bool = false);
-
-
-
-    void add_stream_options(const rjson::value& stream_spec, schema_builder&) const;
-    void supplement_table_info(rjson::value& descr, const schema& schema) const;
-    void supplement_table_stream_info(rjson::value& descr, const schema& schema) const;
 };
 
 }

alternator/expressions.cc

@@ -20,24 +20,16 @@
  */
 
 #include "expressions.hh"
-#include "serialization.hh"
-#include "base64.hh"
-#include "conditions.hh"
 #include "alternator/expressionsLexer.hpp"
 #include "alternator/expressionsParser.hpp"
 #include "utils/overloaded_functor.hh"
-#include "error.hh"
 
-#include "seastarx.hh"
+#include <seastarx.hh>
 
 #include <seastar/core/print.hh>
 #include <seastar/util/log.hh>
 
-#include <boost/algorithm/cxx11/any_of.hpp>
-#include <boost/algorithm/cxx11/all_of.hpp>
-
 #include <functional>
-#include <unordered_map>
 
 namespace alternator {
 
@@ -130,555 +122,6 @@ void condition_expression::append(condition_expression&& a, char op) {
     }, _expression);
 }
 
+
 } // namespace parsed
-
-// The following resolve_*() functions resolve references in parsed
-// expressions of different types. Resolving a parsed expression means
-// replacing:
-//  1. In parsed::path objects, replace references like "#name" with the
-//     attribute name from ExpressionAttributeNames,
-//  2. In parsed::constant objects, replace references like ":value" with
-//     the value from ExpressionAttributeValues.
-// These function also track which name and value references were used, to
-// allow complaining if some remain unused.
-// Note that the resolve_*() functions modify the expressions in-place,
-// so if we ever intend to cache parsed expression, we need to pass a copy
-// into this function.
-//
-// Doing the "resolving" stage before the evaluation stage has two benefits.
-// First, it allows us to be compatible with DynamoDB in catching unused
-// names and values (see issue #6572). Second, in the FilterExpression case,
-// we need to resolve the expression just once but then use it many times
-// (once for each item to be filtered).
-
-static void resolve_path(parsed::path& p,
-        const rjson::value* expression_attribute_names,
-        std::unordered_set<std::string>& used_attribute_names) {
-    const std::string& column_name = p.root();
-    if (column_name.size() > 0 && column_name.front() == '#') {
-        if (!expression_attribute_names) {
-            throw api_error::validation(
-                    format("ExpressionAttributeNames missing, entry '{}' required by expression", column_name));
-        }
-        const rjson::value* value = rjson::find(*expression_attribute_names, column_name);
-        if (!value || !value->IsString()) {
-            throw api_error::validation(
-                    format("ExpressionAttributeNames missing entry '{}' required by expression", column_name));
-        }
-        used_attribute_names.emplace(column_name);
-        p.set_root(std::string(rjson::to_string_view(*value)));
-    }
-}
-
-static void resolve_constant(parsed::constant& c,
-        const rjson::value* expression_attribute_values,
-        std::unordered_set<std::string>& used_attribute_values) {
-    std::visit(overloaded_functor {
-        [&] (const std::string& valref) {
-            if (!expression_attribute_values) {
-                throw api_error::validation(
-                        format("ExpressionAttributeValues missing, entry '{}' required by expression", valref));
-            }
-            const rjson::value* value = rjson::find(*expression_attribute_values, valref);
-            if (!value) {
-                throw api_error::validation(
-                        format("ExpressionAttributeValues missing entry '{}' required by expression", valref));
-            }
-            if (value->IsNull()) {
-                throw api_error::validation(
-                        format("ExpressionAttributeValues null value for entry '{}' required by expression", valref));
-            }
-            validate_value(*value, "ExpressionAttributeValues");
-            used_attribute_values.emplace(valref);
-            c.set(*value);
-        },
-        [&] (const parsed::constant::literal& lit) {
-            // Nothing to do, already resolved
-        }
-    }, c._value);
-
-}
-
-void resolve_value(parsed::value& rhs,
-        const rjson::value* expression_attribute_names,
-        const rjson::value* expression_attribute_values,
-        std::unordered_set<std::string>& used_attribute_names,
-        std::unordered_set<std::string>& used_attribute_values) {
-    std::visit(overloaded_functor {
-        [&] (parsed::constant& c) {
-            resolve_constant(c, expression_attribute_values, used_attribute_values);
-        },
-        [&] (parsed::value::function_call& f) {
-            for (parsed::value& value : f._parameters) {
-                resolve_value(value, expression_attribute_names, expression_attribute_values,
-                        used_attribute_names, used_attribute_values);
-            }
-        },
-        [&] (parsed::path& p) {
-            resolve_path(p, expression_attribute_names, used_attribute_names);
-        }
-    }, rhs._value);
-}
-
-void resolve_set_rhs(parsed::set_rhs& rhs,
-        const rjson::value* expression_attribute_names,
-        const rjson::value* expression_attribute_values,
-        std::unordered_set<std::string>& used_attribute_names,
-        std::unordered_set<std::string>& used_attribute_values) {
-    resolve_value(rhs._v1, expression_attribute_names, expression_attribute_values,
-            used_attribute_names, used_attribute_values);
-    if (rhs._op != 'v') {
-        resolve_value(rhs._v2, expression_attribute_names, expression_attribute_values,
-                used_attribute_names, used_attribute_values);
-    }
-}
-
-void resolve_update_expression(parsed::update_expression& ue,
-        const rjson::value* expression_attribute_names,
-        const rjson::value* expression_attribute_values,
-        std::unordered_set<std::string>& used_attribute_names,
-        std::unordered_set<std::string>& used_attribute_values) {
-    for (parsed::update_expression::action& action : ue.actions()) {
-        resolve_path(action._path, expression_attribute_names, used_attribute_names);
-        std::visit(overloaded_functor {
-            [&] (parsed::update_expression::action::set& a) {
-                resolve_set_rhs(a._rhs, expression_attribute_names, expression_attribute_values,
-                        used_attribute_names, used_attribute_values);
-            },
-            [&] (parsed::update_expression::action::remove& a) {
-                // nothing to do
-            },
-            [&] (parsed::update_expression::action::add& a) {
-                resolve_constant(a._valref, expression_attribute_values, used_attribute_values);
-            },
-            [&] (parsed::update_expression::action::del& a) {
-                resolve_constant(a._valref, expression_attribute_values, used_attribute_values);
-            }
-        }, action._action);
-    }
-}
-
-static void resolve_primitive_condition(parsed::primitive_condition& pc,
-        const rjson::value* expression_attribute_names,
-        const rjson::value* expression_attribute_values,
-        std::unordered_set<std::string>& used_attribute_names,
-        std::unordered_set<std::string>& used_attribute_values) {
-    for (parsed::value& value : pc._values) {
-        resolve_value(value,
-                expression_attribute_names, expression_attribute_values,
-                used_attribute_names, used_attribute_values);
-    }
-}
-
-void resolve_condition_expression(parsed::condition_expression& ce,
-        const rjson::value* expression_attribute_names,
-        const rjson::value* expression_attribute_values,
-        std::unordered_set<std::string>& used_attribute_names,
-        std::unordered_set<std::string>& used_attribute_values) {
-    std::visit(overloaded_functor {
-        [&] (parsed::primitive_condition& cond) {
-            resolve_primitive_condition(cond,
-                    expression_attribute_names, expression_attribute_values,
-                    used_attribute_names, used_attribute_values);
-        },
-        [&] (parsed::condition_expression::condition_list& list) {
-            for (parsed::condition_expression& cond : list.conditions) {
-                resolve_condition_expression(cond,
-                        expression_attribute_names, expression_attribute_values,
-                            used_attribute_names, used_attribute_values);
-
-            }
-        }
-    }, ce._expression);
-}
-
-void resolve_projection_expression(std::vector<parsed::path>& pe,
-        const rjson::value* expression_attribute_names,
-        std::unordered_set<std::string>& used_attribute_names) {
-    for (parsed::path& p : pe) {
-        resolve_path(p, expression_attribute_names, used_attribute_names);
-    }
-}
-
-// condition_expression_on() checks whether a condition_expression places any
-// condition on the given attribute. It can be useful, for example, for
-// checking whether the condition tries to restrict a key column.
-
-static bool value_on(const parsed::value& v, std::string_view attribute) {
-    return std::visit(overloaded_functor {
-        [&] (const parsed::constant& c) {
-            return false;
-        },
-        [&] (const parsed::value::function_call& f) {
-            for (const parsed::value& value : f._parameters) {
-                if (value_on(value, attribute)) {
-                    return true;
-                }
-            }
-            return false;
-        },
-        [&] (const parsed::path& p) {
-            return p.root() == attribute;
-        }
-    }, v._value);
-}
-
-static bool primitive_condition_on(const parsed::primitive_condition& pc, std::string_view attribute) {
-    for (const parsed::value& value : pc._values) {
-        if (value_on(value, attribute)) {
-            return true;
-        }
-    }
-    return false;
-}
-
-bool condition_expression_on(const parsed::condition_expression& ce, std::string_view attribute) {
-    return std::visit(overloaded_functor {
-        [&] (const parsed::primitive_condition& cond) {
-            return primitive_condition_on(cond, attribute);
-        },
-        [&] (const parsed::condition_expression::condition_list& list) {
-            for (const parsed::condition_expression& cond : list.conditions) {
-                if (condition_expression_on(cond, attribute)) {
-                    return true;
-                }
-            }
-            return false;
-        }
-    }, ce._expression);
-}
-
-// for_condition_expression_on() runs a given function over all the attributes
-// mentioned in the expression. If the same attribute is mentioned more than
-// once, the function will be called more than once for the same attribute.
-
-static void for_value_on(const parsed::value& v, const noncopyable_function<void(std::string_view)>& func) {
-    std::visit(overloaded_functor {
-        [&] (const parsed::constant& c) { },
-        [&] (const parsed::value::function_call& f) {
-            for (const parsed::value& value : f._parameters) {
-                for_value_on(value, func);
-            }
-        },
-        [&] (const parsed::path& p) {
-            func(p.root());
-        }
-    }, v._value);
-}
-
-void for_condition_expression_on(const parsed::condition_expression& ce, const noncopyable_function<void(std::string_view)>& func) {
-    std::visit(overloaded_functor {
-        [&] (const parsed::primitive_condition& cond) {
-            for (const parsed::value& value : cond._values) {
-                for_value_on(value, func);
-            }
-        },
-        [&] (const parsed::condition_expression::condition_list& list) {
-            for (const parsed::condition_expression& cond : list.conditions) {
-                for_condition_expression_on(cond, func);
-            }
-        }
-    }, ce._expression);
-}
-
-// The following calculate_value() functions calculate, or evaluate, a parsed
-// expression. The parsed expression is assumed to have been "resolved", with
-// the matching resolve_* function.
-
-// Take two JSON-encoded list values (remember that a list value is
-// {"L": [...the actual list]}) and return the concatenation, again as
-// a list value.
-static rjson::value list_concatenate(const rjson::value& v1, const rjson::value& v2) {
-    const rjson::value* list1 = unwrap_list(v1);
-    const rjson::value* list2 = unwrap_list(v2);
-    if (!list1 || !list2) {
-        throw api_error::validation("UpdateExpression: list_append() given a non-list");
-    }
-    rjson::value cat = rjson::copy(*list1);
-    for (const auto& a : list2->GetArray()) {
-        rjson::push_back(cat, rjson::copy(a));
-    }
-    rjson::value ret = rjson::empty_object();
-    rjson::set(ret, "L", std::move(cat));
-    return ret;
-}
-
-// calculate_size() is ConditionExpression's size() function, i.e., it takes
-// a JSON-encoded value and returns its "size" as defined differently for the
-// different types - also as a JSON-encoded number.
-// It return a JSON-encoded "null" value if this value's type has no size
-// defined. Comparisons against this non-numeric value will later fail.
-static rjson::value calculate_size(const rjson::value& v) {
-    // NOTE: If v is improperly formatted for our JSON value encoding, it
-    // must come from the request itself, not from the database, so it makes
-    // sense to throw a ValidationException if we see such a problem.
-    if (!v.IsObject() || v.MemberCount() != 1) {
-        throw api_error::validation(format("invalid object: {}", v));
-    }
-    auto it = v.MemberBegin();
-    int ret;
-    if (it->name == "S") {
-        if (!it->value.IsString()) {
-            throw api_error::validation(format("invalid string: {}", v));
-        }
-        ret = it->value.GetStringLength();
-    } else if (it->name == "NS" || it->name == "SS" || it->name == "BS" || it->name == "L") {
-        if (!it->value.IsArray()) {
-            throw api_error::validation(format("invalid set: {}", v));
-        }
-        ret = it->value.Size();
-    } else if (it->name == "M") {
-        if (!it->value.IsObject()) {
-            throw api_error::validation(format("invalid map: {}", v));
-        }
-        ret = it->value.MemberCount();
-    } else if (it->name == "B") {
-        if (!it->value.IsString()) {
-            throw api_error::validation(format("invalid byte string: {}", v));
-        }
-        ret = base64_decoded_len(rjson::to_string_view(it->value));
-    } else {
-        rjson::value json_ret = rjson::empty_object();
-        rjson::set(json_ret, "null", rjson::value(true));
-        return json_ret;
-    }
-    rjson::value json_ret = rjson::empty_object();
-    rjson::set(json_ret, "N", rjson::from_string(std::to_string(ret)));
-    return json_ret;
-}
-
-static const rjson::value& calculate_value(const parsed::constant& c) {
-    return std::visit(overloaded_functor {
-        [&] (const parsed::constant::literal& v) -> const rjson::value& {
-            return *v;
-        },
-        [&] (const std::string& valref) -> const rjson::value& {
-            // Shouldn't happen, we should have called resolve_value() earlier
-            // and replaced the value reference by the literal constant.
-            throw std::logic_error("calculate_value() called before resolve_value()");
-        }
-    }, c._value);
-}
-
-static rjson::value to_bool_json(bool b) {
-    rjson::value json_ret = rjson::empty_object();
-    rjson::set(json_ret, "BOOL", rjson::value(b));
-    return json_ret;
-}
-
-static bool known_type(std::string_view type) {
-    static thread_local const std::unordered_set<std::string_view> types = {
-            "N", "S", "B", "NS", "SS", "BS", "L", "M", "NULL", "BOOL"
-    };
-    return types.contains(type);
-}
-
-using function_handler_type = rjson::value(calculate_value_caller, const rjson::value*, const parsed::value::function_call&);
-static const
-std::unordered_map<std::string_view, function_handler_type*> function_handlers {
-    {"list_append", [] (calculate_value_caller caller, const rjson::value* previous_item, const parsed::value::function_call& f) {
-            if (caller != calculate_value_caller::UpdateExpression) {
-                throw api_error::validation(
-                        format("{}: list_append() not allowed here", caller));
-            }
-            if (f._parameters.size() != 2) {
-                throw api_error::validation(
-                        format("{}: list_append() accepts 2 parameters, got {}", caller, f._parameters.size()));
-            }
-            rjson::value v1 = calculate_value(f._parameters[0], caller, previous_item);
-            rjson::value v2 = calculate_value(f._parameters[1], caller, previous_item);
-            return list_concatenate(v1, v2);
-        }
-    },
-    {"if_not_exists", [] (calculate_value_caller caller, const rjson::value* previous_item, const parsed::value::function_call& f) {
-            if (caller != calculate_value_caller::UpdateExpression) {
-                throw api_error::validation(
-                        format("{}: if_not_exists() not allowed here", caller));
-            }
-            if (f._parameters.size() != 2) {
-                throw api_error::validation(
-                        format("{}: if_not_exists() accepts 2 parameters, got {}", caller, f._parameters.size()));
-            }
-            if (!std::holds_alternative<parsed::path>(f._parameters[0]._value)) {
-                throw api_error::validation(
-                        format("{}: if_not_exists() must include path as its first argument", caller));
-            }
-            rjson::value v1 = calculate_value(f._parameters[0], caller, previous_item);
-            rjson::value v2 = calculate_value(f._parameters[1], caller, previous_item);
-            return v1.IsNull() ? std::move(v2) : std::move(v1);
-        }
-    },
-    {"size", [] (calculate_value_caller caller, const rjson::value* previous_item, const parsed::value::function_call& f) {
-            if (caller != calculate_value_caller::ConditionExpression) {
-                throw api_error::validation(
-                        format("{}: size() not allowed here", caller));
-            }
-            if (f._parameters.size() != 1) {
-                throw api_error::validation(
-                        format("{}: size() accepts 1 parameter, got {}", caller, f._parameters.size()));
-            }
-            rjson::value v = calculate_value(f._parameters[0], caller, previous_item);
-            return calculate_size(v);
-        }
-    },
-    {"attribute_exists", [] (calculate_value_caller caller, const rjson::value* previous_item, const parsed::value::function_call& f) {
-            if (caller != calculate_value_caller::ConditionExpressionAlone) {
-                throw api_error::validation(
-                        format("{}: attribute_exists() not allowed here", caller));
-            }
-            if (f._parameters.size() != 1) {
-                throw api_error::validation(
-                        format("{}: attribute_exists() accepts 1 parameter, got {}", caller, f._parameters.size()));
-            }
-            if (!std::holds_alternative<parsed::path>(f._parameters[0]._value)) {
-                throw api_error::validation(
-                        format("{}: attribute_exists()'s parameter must be a path", caller));
-            }
-            rjson::value v = calculate_value(f._parameters[0], caller, previous_item);
-            return to_bool_json(!v.IsNull());
-        }
-    },
-    {"attribute_not_exists", [] (calculate_value_caller caller, const rjson::value* previous_item, const parsed::value::function_call& f) {
-            if (caller != calculate_value_caller::ConditionExpressionAlone) {
-                throw api_error::validation(
-                        format("{}: attribute_not_exists() not allowed here", caller));
-            }
-            if (f._parameters.size() != 1) {
-                throw api_error::validation(
-                        format("{}: attribute_not_exists() accepts 1 parameter, got {}", caller, f._parameters.size()));
-            }
-            if (!std::holds_alternative<parsed::path>(f._parameters[0]._value)) {
-                throw api_error::validation(
-                        format("{}: attribute_not_exists()'s parameter must be a path", caller));
-            }
-            rjson::value v = calculate_value(f._parameters[0], caller, previous_item);
-            return to_bool_json(v.IsNull());
-        }
-    },
-    {"attribute_type", [] (calculate_value_caller caller, const rjson::value* previous_item, const parsed::value::function_call& f) {
-            if (caller != calculate_value_caller::ConditionExpressionAlone) {
-                throw api_error::validation(
-                        format("{}: attribute_type() not allowed here", caller));
-            }
-            if (f._parameters.size() != 2) {
-                throw api_error::validation(
-                        format("{}: attribute_type() accepts 2 parameters, got {}", caller, f._parameters.size()));
-            }
-            // There is no real reason for the following check (not
-            // allowing the type to come from a document attribute), but
-            // DynamoDB does this check, so we do too...
-            if (!f._parameters[1].is_constant()) {
-                throw api_error::validation(
-                        format("{}: attribute_types()'s first parameter must be an expression attribute", caller));
-            }
-            rjson::value v0 = calculate_value(f._parameters[0], caller, previous_item);
-            rjson::value v1 = calculate_value(f._parameters[1], caller, previous_item);
-            if (v1.IsObject() && v1.MemberCount() == 1 && v1.MemberBegin()->name == "S") {
-                // If the type parameter is not one of the legal types
-                // we should generate an error, not a failed condition:
-                if (!known_type(rjson::to_string_view(v1.MemberBegin()->value))) {
-                    throw api_error::validation(
-                            format("{}: attribute_types()'s second parameter, {}, is not a known type",
-                                    caller, v1.MemberBegin()->value));
-                }
-                if (v0.IsObject() && v0.MemberCount() == 1) {
-                    return to_bool_json(v1.MemberBegin()->value == v0.MemberBegin()->name);
-                } else {
-                    return to_bool_json(false);
-                }
-            } else {
-                throw api_error::validation(
-                        format("{}: attribute_type() second parameter must refer to a string, got {}", caller, v1));
-            }
-        }
-    },
-    {"begins_with", [] (calculate_value_caller caller, const rjson::value* previous_item, const parsed::value::function_call& f) {
-            if (caller != calculate_value_caller::ConditionExpressionAlone) {
-                throw api_error::validation(
-                        format("{}: begins_with() not allowed here", caller));
-            }
-            if (f._parameters.size() != 2) {
-                throw api_error::validation(
-                        format("{}: begins_with() accepts 2 parameters, got {}", caller, f._parameters.size()));
-            }
-            rjson::value v1 = calculate_value(f._parameters[0], caller, previous_item);
-            rjson::value v2 = calculate_value(f._parameters[1], caller, previous_item);
-            return to_bool_json(check_BEGINS_WITH(v1.IsNull() ? nullptr : &v1,  v2,
-                                    f._parameters[0].is_constant(), f._parameters[1].is_constant()));
-        }
-    },
-    {"contains", [] (calculate_value_caller caller, const rjson::value* previous_item, const parsed::value::function_call& f) {
-            if (caller != calculate_value_caller::ConditionExpressionAlone) {
-                throw api_error::validation(
-                        format("{}: contains() not allowed here", caller));
-            }
-            if (f._parameters.size() != 2) {
-                throw api_error::validation(
-                        format("{}: contains() accepts 2 parameters, got {}", caller, f._parameters.size()));
-            }
-            rjson::value v1 = calculate_value(f._parameters[0], caller, previous_item);
-            rjson::value v2 = calculate_value(f._parameters[1], caller, previous_item);
-            return to_bool_json(check_CONTAINS(v1.IsNull() ? nullptr : &v1,  v2));
-        }
-    },
-};
-
-// Given a parsed::value, which can refer either to a constant value from
-// ExpressionAttributeValues, to the value of some attribute, or to a function
-// of other values, this function calculates the resulting value.
-// "caller" determines which expression - ConditionExpression or
-// UpdateExpression - is asking for this value. We need to know this because
-// DynamoDB allows a different choice of functions for different expressions.
-rjson::value calculate_value(const parsed::value& v,
-        calculate_value_caller caller,
-        const rjson::value* previous_item) {
-    return std::visit(overloaded_functor {
-        [&] (const parsed::constant& c) -> rjson::value {
-            return rjson::copy(calculate_value(c));
-        },
-        [&] (const parsed::value::function_call& f) -> rjson::value {
-            auto function_it = function_handlers.find(std::string_view(f._function_name));
-            if (function_it == function_handlers.end()) {
-                throw api_error::validation(
-                        format("UpdateExpression: unknown function '{}' called.", f._function_name));
-            }
-            return function_it->second(caller, previous_item, f);
-        },
-        [&] (const parsed::path& p) -> rjson::value {
-            if (!previous_item) {
-                return rjson::null_value();
-            }
-            std::string update_path = p.root();
-            if (p.has_operators()) {
-                // FIXME: support this
-                throw api_error::validation("Reading attribute paths not yet implemented");
-            }
-            const rjson::value* previous_value = rjson::find(*previous_item, update_path);
-            return previous_value ? rjson::copy(*previous_value) : rjson::null_value();
-        }
-    }, v._value);
-}
-
-// Same as calculate_value() above, except takes a set_rhs, which may be
-// either a single value, or v1+v2 or v1-v2.
-rjson::value calculate_value(const parsed::set_rhs& rhs,
-        const rjson::value* previous_item) {
-    switch (rhs._op) {
-    case 'v':
-        return calculate_value(rhs._v1, calculate_value_caller::UpdateExpression, previous_item);
-    case '+': {
-        rjson::value v1 = calculate_value(rhs._v1, calculate_value_caller::UpdateExpression, previous_item);
-        rjson::value v2 = calculate_value(rhs._v2, calculate_value_caller::UpdateExpression, previous_item);
-        return number_add(v1, v2);
-    }
-    case '-': {
-        rjson::value v1 = calculate_value(rhs._v1, calculate_value_caller::UpdateExpression, previous_item);
-        rjson::value v2 = calculate_value(rhs._v2, calculate_value_caller::UpdateExpression, previous_item);
-        return number_subtract(v1, v2);
-    }
-    }
-    // Can't happen
-    return rjson::null_value();
-}
-
 } // namespace alternator

alternator/expressions.hh

@@ -24,13 +24,8 @@
 #include <string>
 #include <stdexcept>
 #include <vector>
-#include <unordered_set>
-#include <string_view>
-
-#include <seastar/util/noncopyable_function.hh>
 
 #include "expressions_types.hh"
-#include "utils/rjson.hh"
 
 namespace alternator {
 
@@ -43,60 +38,4 @@ parsed::update_expression parse_update_expression(std::string query);
 std::vector<parsed::path> parse_projection_expression(std::string query);
 parsed::condition_expression parse_condition_expression(std::string query);
 
-void resolve_update_expression(parsed::update_expression& ue,
-        const rjson::value* expression_attribute_names,
-        const rjson::value* expression_attribute_values,
-        std::unordered_set<std::string>& used_attribute_names,
-        std::unordered_set<std::string>& used_attribute_values);
-void resolve_projection_expression(std::vector<parsed::path>& pe,
-        const rjson::value* expression_attribute_names,
-        std::unordered_set<std::string>& used_attribute_names);
-void resolve_condition_expression(parsed::condition_expression& ce,
-        const rjson::value* expression_attribute_names,
-        const rjson::value* expression_attribute_values,
-        std::unordered_set<std::string>& used_attribute_names,
-        std::unordered_set<std::string>& used_attribute_values);
-
-void validate_value(const rjson::value& v, const char* caller);
-
-bool condition_expression_on(const parsed::condition_expression& ce, std::string_view attribute);
-
-// for_condition_expression_on() runs the given function on the attributes
-// that the expression uses. It may run for the same attribute more than once
-// if the same attribute is used more than once in the expression.
-void for_condition_expression_on(const parsed::condition_expression& ce, const noncopyable_function<void(std::string_view)>& func);
-
-// calculate_value() behaves slightly different (especially, different
-// functions supported) when used in different types of expressions, as
-// enumerated in this enum:
-enum class calculate_value_caller {
-    UpdateExpression, ConditionExpression, ConditionExpressionAlone
-};
-
-inline std::ostream& operator<<(std::ostream& out, calculate_value_caller caller) {
-    switch (caller) {
-        case calculate_value_caller::UpdateExpression:
-            out << "UpdateExpression";
-            break;
-        case calculate_value_caller::ConditionExpression:
-            out << "ConditionExpression";
-            break;
-        case calculate_value_caller::ConditionExpressionAlone:
-            out << "ConditionExpression";
-            break;
-        default:
-            out << "unknown type of expression";
-            break;
-    }
-    return out;
-}
-
-rjson::value calculate_value(const parsed::value& v,
-        calculate_value_caller caller,
-        const rjson::value* previous_item);
-
-rjson::value calculate_value(const parsed::set_rhs& rhs,
-        const rjson::value* previous_item);
-
-
 } /* namespace alternator */

alternator/expressions_eval.hh

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2020 ScyllaDB
+ */
+
+/*
+ * This file is part of Scylla.
+ *
+ * Scylla is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Scylla 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 GNU Affero General Public License
+ * along with Scylla.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <string>
+#include <unordered_set>
+
+#include "rjson.hh"
+#include "schema_fwd.hh"
+
+#include "expressions_types.hh"
+
+namespace alternator {
+
+// calculate_value() behaves slightly different (especially, different
+// functions supported) when used in different types of expressions, as
+// enumerated in this enum:
+enum class calculate_value_caller {
+    UpdateExpression, ConditionExpression, ConditionExpressionAlone
+};
+
+inline std::ostream& operator<<(std::ostream& out, calculate_value_caller caller) {
+    switch (caller) {
+        case calculate_value_caller::UpdateExpression:
+            out << "UpdateExpression";
+            break;
+        case calculate_value_caller::ConditionExpression:
+            out << "ConditionExpression";
+            break;
+        case calculate_value_caller::ConditionExpressionAlone:
+            out << "ConditionExpression";
+            break;
+        default:
+            out << "unknown type of expression";
+            break;
+    }
+    return out;
+}
+
+bool check_CONTAINS(const rjson::value* v1, const rjson::value& v2);
+
+rjson::value calculate_value(const parsed::value& v,
+        calculate_value_caller caller,
+        const rjson::value* expression_attribute_values,
+        std::unordered_set<std::string>& used_attribute_names,
+        std::unordered_set<std::string>& used_attribute_values,
+        const rjson::value& update_info,
+        schema_ptr schema,
+        const std::unique_ptr<rjson::value>& previous_item);
+
+bool verify_condition_expression(
+        const parsed::condition_expression& condition_expression,
+        std::unordered_set<std::string>& used_attribute_values,
+        std::unordered_set<std::string>& used_attribute_names,
+        const rjson::value& req,
+        schema_ptr schema,
+        const std::unique_ptr<rjson::value>& previous_item);
+
+} /* namespace alternator */

alternator/expressions_types.hh

@@ -25,10 +25,6 @@
 #include <string>
 #include <variant>
 
-#include <seastar/core/shared_ptr.hh>
-
-#include "utils/rjson.hh"
-
 /*
  * Parsed representation of expressions and their components.
  *
@@ -67,27 +63,10 @@ public:
     }
 };
 
-// When an expression is first parsed, all constants are references, like
-// ":val1", into ExpressionAttributeValues. This uses std::string() variant.
-// The resolve_value() function replaces these constants by the JSON item
-// extracted from the ExpressionAttributeValues.
-struct constant {
-    // We use lw_shared_ptr<rjson::value> just to make rjson::value copyable,
-    // to make this entire object copyable as ANTLR needs.
-    using literal = lw_shared_ptr<rjson::value>;
-    std::variant<std::string, literal> _value;
-    void set(const rjson::value& v) {
-        _value = make_lw_shared<rjson::value>(rjson::copy(v));
-    }
-    void set(std::string& s) {
-        _value = s;
-    }
-};
-
 // "value" is is a value used in the right hand side of an assignment
-// expression, "SET a = ...". It can be a constant (a reference to a value
-// included in the request, e.g., ":val"), a path to an attribute from the
-// existing item (e.g., "a.b[3].c"), or a function of other such values.
+// expression, "SET a = ...". It can be a reference to a value included in
+// the request (":val"), a path to an attribute from the existing item
+// (e.g., "a.b[3].c"), or a function of other such values.
 // Note that the real right-hand-side of an assignment is actually a bit
 // more general - it allows either a value, or a value+value or value-value -
 // see class set_rhs below.
@@ -96,12 +75,9 @@ struct value {
         std::string _function_name;
         std::vector<value> _parameters;
     };
-    std::variant<constant, path, function_call> _value;
-    void set_constant(constant c) {
-        _value = std::move(c);
-    }
+    std::variant<std::string, path, function_call> _value;
     void set_valref(std::string s) {
-        _value = constant { std::move(s) };
+        _value = std::move(s);
     }
     void set_path(path p) {
         _value = std::move(p);
@@ -112,8 +88,8 @@ struct value {
     void add_func_parameter(value v) {
         std::get<function_call>(_value)._parameters.emplace_back(std::move(v));
     }
-    bool is_constant() const {
-        return std::holds_alternative<constant>(_value);
+    bool is_valref() const {
+        return std::holds_alternative<std::string>(_value);
     }
     bool is_path() const {
         return std::holds_alternative<path>(_value);
@@ -154,10 +130,10 @@ public:
         struct remove {
         };
         struct add {
-            constant _valref;
+            std::string _valref;
         };
         struct del {
-            constant _valref;
+            std::string _valref;
         };
         std::variant<set, remove, add, del> _action;
 
@@ -171,11 +147,11 @@ public:
         }
         void assign_add(path p, std::string v) {
             _path = std::move(p);
-            _action = add { constant { std::move(v) } };
+            _action = add { std::move(v) };
         }
         void assign_del(path p, std::string v) {
             _path = std::move(p);
-            _action = del { constant { std::move(v) } };
+            _action = del { std::move(v) };
         }
     };
 private:
@@ -193,9 +169,6 @@ public:
     const std::vector<action>& actions() const {
         return _actions;
     }
-    std::vector<action>& actions() {
-        return _actions;
-    }
 };
 
 // A primitive_condition is a condition expression involving one condition,

alternator/rjson.cc

@@ -20,12 +20,13 @@
  */
 
 #include "rjson.hh"
+#include "error.hh"
 #include <seastar/core/print.hh>
 #include <seastar/core/thread.hh>
 
 namespace rjson {
 
-allocator the_allocator;
+static allocator the_allocator;
 
 /*
  * This wrapper class adds nested level checks to rapidjson's handlers.
@@ -127,21 +128,6 @@ std::string print(const rjson::value& value) {
     return std::string(buffer.GetString());
 }
 
-rjson::malformed_value::malformed_value(std::string_view name, const rjson::value& value)
-    : malformed_value(name, print(value))
-{}
-
-rjson::malformed_value::malformed_value(std::string_view name, std::string_view value)
-    : error(format("Malformed value {} : {}", name, value))
-{}
-
-rjson::missing_value::missing_value(std::string_view name) 
-    // TODO: using old message here, but as pointed out. 
-    // "parameter" is not really a JSON concept. It is a value
-    // missing according to (implicit) schema. 
-    : error(format("JSON parameter {} not found", name))
-{}
-
 rjson::value copy(const rjson::value& value) {
     return rjson::value(value, the_allocator);
 }
@@ -156,20 +142,6 @@ rjson::value parse(std::string_view str) {
     return std::move(v);
 }
 
-std::optional<rjson::value> try_parse(std::string_view str) {
-    guarded_yieldable_json_handler<document, false> d(78);
-    try {
-        d.Parse(str.data(), str.size());
-    } catch (const rjson::error&) {
-        return std::nullopt;
-    }
-    if (d.HasParseError()) {
-        return std::nullopt;    
-    }
-    rjson::value& v = d;
-    return std::move(v);
-}
-
 rjson::value parse_yieldable(std::string_view str) {
     guarded_yieldable_json_handler<document, true> d(78);
     d.Parse(str.data(), str.size());
@@ -186,18 +158,20 @@ rjson::value& get(rjson::value& value, std::string_view name) {
     // Luckily, the variant taking a GenericValue doesn't share this bug,
     // and we can create a string GenericValue without copying the string.
     auto member_it = value.FindMember(rjson::value(name.data(), name.size()));
-    if (member_it != value.MemberEnd()) {
+    if (member_it != value.MemberEnd())
         return member_it->value;
+    else {
+        throw rjson::error(format("JSON parameter {} not found", name));
     }
-    throw missing_value(name);
 }
 
 const rjson::value& get(const rjson::value& value, std::string_view name) {
     auto member_it = value.FindMember(rjson::value(name.data(), name.size()));
-    if (member_it != value.MemberEnd()) {
+    if (member_it != value.MemberEnd())
         return member_it->value;
+    else {
+        throw rjson::error(format("JSON parameter {} not found", name));
     }
-    throw missing_value(name);
 }
 
 rjson::value from_string(const std::string& str) {
@@ -319,66 +293,6 @@ bool single_value_comp::operator()(const rjson::value& r1, const rjson::value& r
    }
 }
 
-rjson::value from_string_map(const std::map<sstring, sstring>& map) {
-    rjson::value v = rjson::empty_object();
-    for (auto& entry : map) {
-        rjson::set_with_string_name(v, std::string_view(entry.first), rjson::from_string(entry.second));
-    }
-    return v;
-}
-
-static inline bool is_control_char(char c) {
-    return c >= 0 && c <= 0x1F;
-}
-
-static inline bool needs_escaping(const sstring& s) {
-    return std::any_of(s.begin(), s.end(), [](char c) {return is_control_char(c) || c == '"' || c == '\\';});
-}
-
-
-sstring quote_json_string(const sstring& value) {
-    if (!needs_escaping(value)) {
-        return format("\"{}\"", value);
-    }
-    std::ostringstream oss;
-    oss << std::hex << std::uppercase << std::setfill('0');
-    oss.put('"');
-    for (char c : value) {
-        switch (c) {
-        case '"':
-            oss.put('\\').put('"');
-            break;
-        case '\\':
-            oss.put('\\').put('\\');
-            break;
-        case '\b':
-            oss.put('\\').put('b');
-            break;
-        case '\f':
-            oss.put('\\').put('f');
-            break;
-        case '\n':
-            oss.put('\\').put('n');
-            break;
-        case '\r':
-            oss.put('\\').put('r');
-            break;
-        case '\t':
-            oss.put('\\').put('t');
-            break;
-        default:
-            if (is_control_char(c)) {
-                oss.put('\\').put('u') << std::setw(4) << static_cast<int>(c);
-            } else {
-                oss.put(c);
-            }
-            break;
-        }
-    }
-    oss.put('"');
-    return oss.str();
-}
-
 } // end namespace rjson
 
 std::ostream& std::operator<<(std::ostream& os, const rjson::value& v) {

alternator/rjson.hh

@@ -0,0 +1,177 @@
+/*
+ * Copyright 2019 ScyllaDB
+ */
+
+/*
+ * This file is part of Scylla.
+ *
+ * Scylla is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Scylla 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 GNU Affero General Public License
+ * along with Scylla.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+/*
+ * rjson is a wrapper over rapidjson library, providing fast JSON parsing and generation.
+ *
+ * rapidjson has strict copy elision policies, which, among other things, involves
+ * using provided char arrays without copying them and allows copying objects only explicitly.
+ * As such, one should be careful when passing strings with limited liveness
+ * (e.g. data underneath local std::strings) to rjson functions, because created JSON objects
+ * may end up relying on dangling char pointers. All rjson functions that create JSONs from strings
+ * by rjson have both APIs for string_ref_type (more optimal, used when the string is known to live
+ * at least as long as the object, e.g. a static char array) and for std::strings. The more optimal
+ * variants should be used *only* if the liveness of the string is guaranteed, otherwise it will
+ * result in undefined behaviour.
+ * Also, bear in mind that methods exposed by rjson::value are generic, but some of them
+ * work fine only for specific types. In case the type does not match, an rjson::error will be thrown.
+ * Examples of such mismatched usages is calling MemberCount() on a JSON value not of object type
+ * or calling Size() on a non-array value.
+ */
+
+#include <string>
+#include <stdexcept>
+
+namespace rjson {
+class error : public std::exception {
+    std::string _msg;
+public:
+    error() = default;
+    error(const std::string& msg) : _msg(msg) {}
+
+    virtual const char* what() const noexcept override { return _msg.c_str(); }
+};
+}
+
+// rapidjson configuration macros
+#define RAPIDJSON_HAS_STDSTRING 1
+// Default rjson policy is to use assert() - which is dangerous for two reasons:
+// 1. assert() can be turned off with -DNDEBUG
+// 2. assert() crashes a program
+// Fortunately, the default policy can be overridden, and so rapidjson errors will
+// throw an rjson::error exception instead.
+#define RAPIDJSON_ASSERT(x) do { if (!(x)) throw rjson::error(std::string("JSON error: condition not met: ") + #x); } while (0)
+
+#include <rapidjson/document.h>
+#include <rapidjson/writer.h>
+#include <rapidjson/stringbuffer.h>
+#include <rapidjson/error/en.h>
+#include <seastar/core/sstring.hh>
+#include "seastarx.hh"
+
+namespace rjson {
+
+using allocator = rapidjson::CrtAllocator;
+using encoding = rapidjson::UTF8<>;
+using document = rapidjson::GenericDocument<encoding, allocator>;
+using value = rapidjson::GenericValue<encoding, allocator>;
+using string_ref_type = value::StringRefType;
+using string_buffer = rapidjson::GenericStringBuffer<encoding>;
+using writer = rapidjson::Writer<string_buffer, encoding>;
+using type = rapidjson::Type;
+
+// Returns an object representing JSON's null
+inline rjson::value null_value() {
+    return rjson::value(rapidjson::kNullType);
+}
+
+// Returns an empty JSON object - {}
+inline rjson::value empty_object() {
+    return rjson::value(rapidjson::kObjectType);
+}
+
+// Returns an empty JSON array - []
+inline rjson::value empty_array() {
+    return rjson::value(rapidjson::kArrayType);
+}
+
+// Returns an empty JSON string - ""
+inline rjson::value empty_string() {
+    return rjson::value(rapidjson::kStringType);
+}
+
+// Convert the JSON value to a string with JSON syntax, the opposite of parse().
+// The representation is dense - without any redundant indentation.
+std::string print(const rjson::value& value);
+
+// Returns a string_view to the string held in a JSON value (which is
+// assumed to hold a string, i.e., v.IsString() == true). This is a view
+// to the existing data - no copying is done.
+inline std::string_view to_string_view(const rjson::value& v) {
+    return std::string_view(v.GetString(), v.GetStringLength());
+}
+
+// Copies given JSON value - involves allocation
+rjson::value copy(const rjson::value& value);
+
+// Parses a JSON value from given string or raw character array.
+// The string/char array liveness does not need to be persisted,
+// as parse() will allocate member names and values.
+// Throws rjson::error if parsing failed.
+rjson::value parse(std::string_view str);
+// Needs to be run in thread context
+rjson::value parse_yieldable(std::string_view str);
+
+// Creates a JSON value (of JSON string type) out of internal string representations.
+// The string value is copied, so str's liveness does not need to be persisted.
+rjson::value from_string(const std::string& str);
+rjson::value from_string(const sstring& str);
+rjson::value from_string(const char* str, size_t size);
+rjson::value from_string(std::string_view view);
+
+// Returns a pointer to JSON member if it exists, nullptr otherwise
+rjson::value* find(rjson::value& value, std::string_view name);
+const rjson::value* find(const rjson::value& value, std::string_view name);
+
+// Returns a reference to JSON member if it exists, throws otherwise
+rjson::value& get(rjson::value& value, std::string_view name);
+const rjson::value& get(const rjson::value& value, std::string_view name);
+
+// Sets a member in given JSON object by moving the member - allocates the name.
+// Throws if base is not a JSON object.
+void set_with_string_name(rjson::value& base, const std::string& name, rjson::value&& member);
+void set_with_string_name(rjson::value& base, std::string_view name, rjson::value&& member);
+
+// Sets a string member in given JSON object by assigning its reference - allocates the name.
+// NOTICE: member string liveness must be ensured to be at least as long as base's.
+// Throws if base is not a JSON object.
+void set_with_string_name(rjson::value& base, const std::string& name, rjson::string_ref_type member);
+void set_with_string_name(rjson::value& base, std::string_view name, rjson::string_ref_type member);
+
+// Sets a member in given JSON object by moving the member.
+// NOTICE: name liveness must be ensured to be at least as long as base's.
+// Throws if base is not a JSON object.
+void set(rjson::value& base, rjson::string_ref_type name, rjson::value&& member);
+
+// Sets a string member in given JSON object by assigning its reference.
+// NOTICE: name liveness must be ensured to be at least as long as base's.
+// NOTICE: member liveness must be ensured to be at least as long as base's.
+// Throws if base is not a JSON object.
+void set(rjson::value& base, rjson::string_ref_type name, rjson::string_ref_type member);
+
+// Adds a value to a JSON list by moving the item to its end.
+// Throws if base_array is not a JSON array.
+void push_back(rjson::value& base_array, rjson::value&& item);
+
+// Remove a member from a JSON object. Throws if value isn't an object.
+bool remove_member(rjson::value& value, std::string_view name);
+
+struct single_value_comp {
+    bool operator()(const rjson::value& r1, const rjson::value& r2) const;
+};
+
+} // end namespace rjson
+
+namespace std {
+std::ostream& operator<<(std::ostream& os, const rjson::value& v);
+}

alternator/rmw_operation.hh

@@ -21,10 +21,10 @@
 
 #pragma once
 
-#include "seastarx.hh"
-#include "service/storage_proxy.hh"
-#include "service/storage_proxy.hh"
-#include "utils/rjson.hh"
+#include <seastarx.hh>
+#include <service/storage_proxy.hh>
+#include <service/storage_proxy.hh>
+#include "rjson.hh"
 #include "executor.hh"
 
 namespace alternator {

alternator/serialization.cc

@@ -31,8 +31,8 @@ static logging::logger slogger("alternator-serialization");
 
 namespace alternator {
 
-type_info type_info_from_string(std::string_view type) {
-    static thread_local const std::unordered_map<std::string_view, type_info> type_infos = {
+type_info type_info_from_string(std::string type) {
+    static thread_local const std::unordered_map<std::string, type_info> type_infos = {
         {"S", {alternator_type::S, utf8_type}},
         {"B", {alternator_type::B, bytes_type}},
         {"BOOL", {alternator_type::BOOL, boolean_type}},
@@ -65,7 +65,7 @@ struct from_json_visitor {
 
     void operator()(const reversed_type_impl& t) const { visit(*t.underlying_type(), from_json_visitor{v, bo}); };
     void operator()(const string_type_impl& t) {
-        bo.write(t.from_string(rjson::to_string_view(v)));
+        bo.write(t.from_string(sstring_view(v.GetString(), v.GetStringLength())));
     }
     void operator()(const bytes_type_impl& t) const {
         bo.write(base64_decode(v));
@@ -74,27 +74,23 @@ struct from_json_visitor {
         bo.write(boolean_type->decompose(v.GetBool()));
     }
     void operator()(const decimal_type_impl& t) const {
-        try {
-            bo.write(t.from_string(rjson::to_string_view(v)));
-        } catch (const marshal_exception& e) {
-            throw api_error::validation(format("The parameter cannot be converted to a numeric value: {}", v));
-        }
+        bo.write(t.from_string(sstring_view(v.GetString(), v.GetStringLength())));
     }
     // default
     void operator()(const abstract_type& t) const {
-        bo.write(from_json_object(t, v, cql_serialization_format::internal()));
+        bo.write(from_json_object(t, Json::Value(rjson::print(v)), cql_serialization_format::internal()));
     }
 };
 
 bytes serialize_item(const rjson::value& item) {
     if (item.IsNull() || item.MemberCount() != 1) {
-        throw api_error::validation(format("An item can contain only one attribute definition: {}", item));
+        throw api_error("ValidationException", format("An item can contain only one attribute definition: {}", item));
     }
     auto it = item.MemberBegin();
-    type_info type_info = type_info_from_string(rjson::to_string_view(it->name)); // JSON keys are guaranteed to be strings
+    type_info type_info = type_info_from_string(it->name.GetString()); // JSON keys are guaranteed to be strings
 
     if (type_info.atype == alternator_type::NOT_SUPPORTED_YET) {
-        slogger.trace("Non-optimal serialization of type {}", it->name);
+        slogger.trace("Non-optimal serialization of type {}", it->name.GetString());
         return bytes{int8_t(type_info.atype)} + to_bytes(rjson::print(item));
     }
 
@@ -132,7 +128,7 @@ struct to_json_visitor {
 rjson::value deserialize_item(bytes_view bv) {
     rjson::value deserialized(rapidjson::kObjectType);
     if (bv.empty()) {
-        throw api_error::validation("Serialized value empty");
+        throw api_error("ValidationException", "Serialized value empty");
     }
 
     alternator_type atype = alternator_type(bv[0]);
@@ -168,7 +164,7 @@ bytes get_key_column_value(const rjson::value& item, const column_definition& co
     std::string column_name = column.name_as_text();
     const rjson::value* key_typed_value = rjson::find(item, column_name);
     if (!key_typed_value) {
-        throw api_error::validation(format("Key column {} not found", column_name));
+        throw api_error("ValidationException", format("Key column {} not found", column_name));
     }
     return get_key_from_typed_value(*key_typed_value, column);
 }
@@ -179,21 +175,16 @@ bytes get_key_column_value(const rjson::value& item, const column_definition& co
 bytes get_key_from_typed_value(const rjson::value& key_typed_value, const column_definition& column) {
     if (!key_typed_value.IsObject() || key_typed_value.MemberCount() != 1 ||
             !key_typed_value.MemberBegin()->value.IsString()) {
-        throw api_error::validation(
+        throw api_error("ValidationException",
                 format("Malformed value object for key column {}: {}",
                         column.name_as_text(), key_typed_value));
     }
 
     auto it = key_typed_value.MemberBegin();
     if (it->name != type_to_string(column.type)) {
-        throw api_error::validation(
+        throw api_error("ValidationException",
                 format("Type mismatch: expected type {} for key column {}, got type {}",
-                        type_to_string(column.type), column.name_as_text(), it->name));
-    }
-    std::string_view value_view = rjson::to_string_view(it->value);
-    if (value_view.empty()) {
-        throw api_error::validation(
-                format("The AttributeValue for a key attribute cannot contain an empty string value. Key: {}", column.name_as_text()));
+                        type_to_string(column.type), column.name_as_text(), it->name.GetString()));
     }
     if (column.type == bytes_type) {
         return base64_decode(it->value);
@@ -251,24 +242,20 @@ clustering_key ck_from_json(const rjson::value& item, schema_ptr schema) {
 
 big_decimal unwrap_number(const rjson::value& v, std::string_view diagnostic) {
     if (!v.IsObject() || v.MemberCount() != 1) {
-        throw api_error::validation(format("{}: invalid number object", diagnostic));
+        throw api_error("ValidationException", format("{}: invalid number object", diagnostic));
     }
     auto it = v.MemberBegin();
     if (it->name != "N") {
-        throw api_error::validation(format("{}: expected number, found type '{}'", diagnostic, it->name));
+        throw api_error("ValidationException", format("{}: expected number, found type '{}'", diagnostic, it->name));
     }
-    try {
-        if (it->value.IsNumber()) {
-             // FIXME(sarna): should use big_decimal constructor with numeric values directly:
-            return big_decimal(rjson::print(it->value));
-        }
-        if (!it->value.IsString()) {
-            throw api_error::validation(format("{}: improperly formatted number constant", diagnostic));
-        }
-        return big_decimal(rjson::to_string_view(it->value));
-    } catch (const marshal_exception& e) {
-        throw api_error::validation(format("The parameter cannot be converted to a numeric value: {}", it->value));
+    if (it->value.IsNumber()) {
+         // FIXME(sarna): should use big_decimal constructor with numeric values directly:
+        return big_decimal(rjson::print(it->value));
     }
+    if (!it->value.IsString()) {
+        throw api_error("ValidationException", format("{}: improperly formatted number constant", diagnostic));
+    }
+    return big_decimal(it->value.GetString());
 }
 
 const std::pair<std::string, const rjson::value*> unwrap_set(const rjson::value& v) {
@@ -283,93 +270,4 @@ const std::pair<std::string, const rjson::value*> unwrap_set(const rjson::value&
     return std::make_pair(it_key, &(it->value));
 }
 
-const rjson::value* unwrap_list(const rjson::value& v) {
-    if (!v.IsObject() || v.MemberCount() != 1) {
-        return nullptr;
-    }
-    auto it = v.MemberBegin();
-    if (it->name != std::string("L")) {
-        return nullptr;
-    }
-    return &(it->value);
-}
-
-// Take two JSON-encoded numeric values ({"N": "thenumber"}) and return the
-// sum, again as a JSON-encoded number.
-rjson::value number_add(const rjson::value& v1, const rjson::value& v2) {
-    auto n1 = unwrap_number(v1, "UpdateExpression");
-    auto n2 = unwrap_number(v2, "UpdateExpression");
-    rjson::value ret = rjson::empty_object();
-    std::string str_ret = std::string((n1 + n2).to_string());
-    rjson::set(ret, "N", rjson::from_string(str_ret));
-    return ret;
-}
-
-rjson::value number_subtract(const rjson::value& v1, const rjson::value& v2) {
-    auto n1 = unwrap_number(v1, "UpdateExpression");
-    auto n2 = unwrap_number(v2, "UpdateExpression");
-    rjson::value ret = rjson::empty_object();
-    std::string str_ret = std::string((n1 - n2).to_string());
-    rjson::set(ret, "N", rjson::from_string(str_ret));
-    return ret;
-}
-
-// Take two JSON-encoded set values (e.g. {"SS": [...the actual set]}) and
-// return the sum of both sets, again as a set value.
-rjson::value set_sum(const rjson::value& v1, const rjson::value& v2) {
-    auto [set1_type, set1] = unwrap_set(v1);
-    auto [set2_type, set2] = unwrap_set(v2);
-    if (set1_type != set2_type) {
-        throw api_error::validation(format("Mismatched set types: {} and {}", set1_type, set2_type));
-    }
-    if (!set1 || !set2) {
-        throw api_error::validation("UpdateExpression: ADD operation for sets must be given sets as arguments");
-    }
-    rjson::value sum = rjson::copy(*set1);
-    std::set<rjson::value, rjson::single_value_comp> set1_raw;
-    for (auto it = sum.Begin(); it != sum.End(); ++it) {
-        set1_raw.insert(rjson::copy(*it));
-    }
-    for (const auto& a : set2->GetArray()) {
-        if (!set1_raw.contains(a)) {
-            rjson::push_back(sum, rjson::copy(a));
-        }
-    }
-    rjson::value ret = rjson::empty_object();
-    rjson::set_with_string_name(ret, set1_type, std::move(sum));
-    return ret;
-}
-
-// Take two JSON-encoded set values (e.g. {"SS": [...the actual list]}) and
-// return the difference of s1 - s2, again as a set value.
-// DynamoDB does not allow empty sets, so if resulting set is empty, return
-// an unset optional instead.
-std::optional<rjson::value> set_diff(const rjson::value& v1, const rjson::value& v2) {
-    auto [set1_type, set1] = unwrap_set(v1);
-    auto [set2_type, set2] = unwrap_set(v2);
-    if (set1_type != set2_type) {
-        throw api_error::validation(format("Mismatched set types: {} and {}", set1_type, set2_type));
-    }
-    if (!set1 || !set2) {
-        throw api_error::validation("UpdateExpression: DELETE operation can only be performed on a set");
-    }
-    std::set<rjson::value, rjson::single_value_comp> set1_raw;
-    for (auto it = set1->Begin(); it != set1->End(); ++it) {
-        set1_raw.insert(rjson::copy(*it));
-    }
-    for (const auto& a : set2->GetArray()) {
-        set1_raw.erase(a);
-    }
-    if (set1_raw.empty()) {
-        return std::nullopt;
-    }
-    rjson::value ret = rjson::empty_object();
-    rjson::set_with_string_name(ret, set1_type, rjson::empty_array());
-    rjson::value& result_set = ret[set1_type];
-    for (const auto& a : set1_raw) {
-        rjson::push_back(result_set, rjson::copy(a));
-    }
-    return ret;
-}
-
 }

alternator/serialization.hh

@@ -26,7 +26,7 @@
 #include "types.hh"
 #include "schema_fwd.hh"
 #include "keys.hh"
-#include "utils/rjson.hh"
+#include "rjson.hh"
 #include "utils/big_decimal.hh"
 
 namespace alternator {
@@ -45,7 +45,7 @@ struct type_representation {
     data_type dtype;
 };
 
-type_info type_info_from_string(std::string_view type);
+type_info type_info_from_string(std::string type);
 type_representation represent_type(alternator_type atype);
 
 bytes serialize_item(const rjson::value& item);
@@ -69,21 +69,4 @@ big_decimal unwrap_number(const rjson::value& v, std::string_view diagnostic);
 // returned value is {"", nullptr}
 const std::pair<std::string, const rjson::value*> unwrap_set(const rjson::value& v);
 
-// Check if a given JSON object encodes a list (i.e., it is a {"L": [...]}
-// and returns a pointer to that list.
-const rjson::value* unwrap_list(const rjson::value& v);
-
-// Take two JSON-encoded numeric values ({"N": "thenumber"}) and return the
-// sum, again as a JSON-encoded number.
-rjson::value number_add(const rjson::value& v1, const rjson::value& v2);
-rjson::value number_subtract(const rjson::value& v1, const rjson::value& v2);
-// Take two JSON-encoded set values (e.g. {"SS": [...the actual set]}) and
-// return the sum of both sets, again as a set value.
-rjson::value set_sum(const rjson::value& v1, const rjson::value& v2);
-// Take two JSON-encoded set values (e.g. {"SS": [...the actual list]}) and
-// return the difference of s1 - s2, again as a set value.
-// DynamoDB does not allow empty sets, so if resulting set is empty, return
-// an unset optional instead.
-std::optional<rjson::value> set_diff(const rjson::value& v1, const rjson::value& v2);
-
 }

alternator/server.cc

@@ -23,9 +23,9 @@
 #include "log.hh"
 #include <seastar/http/function_handlers.hh>
 #include <seastar/json/json_elements.hh>
-#include "seastarx.hh"
+#include <seastarx.hh>
 #include "error.hh"
-#include "utils/rjson.hh"
+#include "rjson.hh"
 #include "auth.hh"
 #include <cctype>
 #include "cql3/query_processor.hh"
@@ -75,17 +75,20 @@ public:
                  // returned to the client as expected. Other types of
                  // exceptions are unexpected, and returned to the user
                  // as an internal server error:
+                 api_error ret;
                  try {
                      resf.get();
                  } catch (api_error &ae) {
-                     generate_error_reply(*rep, ae);
+                     ret = ae;
                  } catch (rjson::error & re) {
-                     generate_error_reply(*rep,
-                             api_error::validation(re.what()));
+                     ret = api_error("ValidationException", re.what());
                  } catch (...) {
-                     generate_error_reply(*rep,
-                             api_error::internal(format("Internal server error: {}", std::current_exception())));
+                     ret = api_error(
+                             "Internal Server Error",
+                             format("Internal server error: {}", std::current_exception()),
+                             reply::status_type::internal_server_error);
                  }
+                 generate_error_reply(*rep, ret);
                  return make_ready_future<std::unique_ptr<reply>>(std::move(rep));
              }
              auto res = resf.get0();
@@ -185,11 +188,11 @@ future<> server::verify_signature(const request& req) {
     }
     auto host_it = req._headers.find("Host");
     if (host_it == req._headers.end()) {
-        throw api_error::invalid_signature("Host header is mandatory for signature verification");
+        throw api_error("InvalidSignatureException", "Host header is mandatory for signature verification");
     }
     auto authorization_it = req._headers.find("Authorization");
     if (authorization_it == req._headers.end()) {
-        throw api_error::invalid_signature("Authorization header is mandatory for signature verification");
+        throw api_error("InvalidSignatureException", "Authorization header is mandatory for signature verification");
     }
     std::string host = host_it->second;
     std::vector<std::string_view> credentials_raw = split(authorization_it->second, ' ');
@@ -201,7 +204,7 @@ future<> server::verify_signature(const request& req) {
         std::vector<std::string_view> entry_split = split(entry, '=');
         if (entry_split.size() != 2) {
             if (entry != "AWS4-HMAC-SHA256") {
-                throw api_error::invalid_signature(format("Only AWS4-HMAC-SHA256 algorithm is supported. Found: {}", entry));
+                throw api_error("InvalidSignatureException", format("Only AWS4-HMAC-SHA256 algorithm is supported. Found: {}", entry));
             }
             continue;
         }
@@ -222,7 +225,7 @@ future<> server::verify_signature(const request& req) {
     }
     std::vector<std::string_view> credential_split = split(credential, '/');
     if (credential_split.size() != 5) {
-        throw api_error::validation(format("Incorrect credential information format: {}", credential));
+        throw api_error("ValidationException", format("Incorrect credential information format: {}", credential));
     }
     std::string user(credential_split[0]);
     std::string datestamp(credential_split[1]);
@@ -260,7 +263,7 @@ future<> server::verify_signature(const request& req) {
 
         if (signature != std::string_view(user_signature)) {
             _key_cache.remove(user);
-            throw api_error::unrecognized_client("The security token included in the request is invalid.");
+            throw api_error("UnrecognizedClientException", "The security token included in the request is invalid.");
         }
     });
 }
@@ -271,12 +274,13 @@ future<executor::request_return_type> server::handle_api_request(std::unique_ptr
     std::vector<std::string_view> split_target = split(target, '.');
     //NOTICE(sarna): Target consists of Dynamo API version followed by a dot '.' and operation type (e.g. CreateTable)
     std::string op = split_target.empty() ? std::string() : std::string(split_target.back());
-    slogger.trace("Request: {} {} {}", op, req->content, req->_headers);
+    slogger.trace("Request: {} {}", op, req->content);
     return verify_signature(*req).then([this, op, req = std::move(req)] () mutable {
         auto callback_it = _callbacks.find(op);
         if (callback_it == _callbacks.end()) {
             _executor._stats.unsupported_operations++;
-            throw api_error::unknown_operation(format("Unsupported operation {}", op));
+            throw api_error("UnknownOperationException",
+                    format("Unsupported operation {}", op));
         }
         return with_gate(_pending_requests, [this, callback_it = std::move(callback_it), op = std::move(op), req = std::move(req)] () mutable {
             //FIXME: Client state can provide more context, e.g. client's endpoint address
@@ -346,9 +350,6 @@ server::server(executor& exec)
         {"DeleteTable", [] (executor& e, executor::client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value json_request, std::unique_ptr<request> req) {
             return e.delete_table(client_state, std::move(trace_state), std::move(permit), std::move(json_request));
         }},
-        {"UpdateTable", [] (executor& e, executor::client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value json_request, std::unique_ptr<request> req) {
-            return e.update_table(client_state, std::move(trace_state), std::move(permit), std::move(json_request));
-        }},
         {"PutItem", [] (executor& e, executor::client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value json_request, std::unique_ptr<request> req) {
             return e.put_item(client_state, std::move(trace_state), std::move(permit), std::move(json_request));
         }},
@@ -388,18 +389,6 @@ server::server(executor& exec)
         {"ListTagsOfResource", [] (executor& e, executor::client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value json_request, std::unique_ptr<request> req) {
             return e.list_tags_of_resource(client_state, std::move(permit), std::move(json_request));
         }},
-        {"ListStreams", [] (executor& e, executor::client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value json_request, std::unique_ptr<request> req) {
-            return e.list_streams(client_state, std::move(permit), std::move(json_request));
-        }},
-        {"DescribeStream", [] (executor& e, executor::client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value json_request, std::unique_ptr<request> req) {
-            return e.describe_stream(client_state, std::move(permit), std::move(json_request));
-        }},
-        {"GetShardIterator", [] (executor& e, executor::client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value json_request, std::unique_ptr<request> req) {
-            return e.get_shard_iterator(client_state, std::move(permit), std::move(json_request));
-        }},
-        {"GetRecords", [] (executor& e, executor::client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value json_request, std::unique_ptr<request> req) {
-            return e.get_records(client_state, std::move(trace_state), std::move(permit), std::move(json_request));
-        }},
     } {
 }
 

alternator/server.hh

@@ -26,8 +26,8 @@
 #include <seastar/http/httpd.hh>
 #include <seastar/net/tls.hh>
 #include <optional>
-#include "alternator/auth.hh"
-#include "utils/small_vector.hh"
+#include <alternator/auth.hh>
+#include <utils/small_vector.hh>
 #include <seastar/core/units.hh>
 
 namespace alternator {

alternator/stats.cc

@@ -20,7 +20,7 @@
  */
 
 #include "stats.hh"
-#include "utils/histogram_metrics_helper.hh"
+
 #include <seastar/core/metrics.hh>
 
 namespace alternator {
@@ -37,7 +37,7 @@ stats::stats() : api_operations{} {
                         seastar::metrics::description("number of operations via Alternator API"), {op(CamelCaseName)}),
 #define OPERATION_LATENCY(name, CamelCaseName) \
                 seastar::metrics::make_histogram("op_latency", \
-                        seastar::metrics::description("Latency histogram of an operation via Alternator API"), {op(CamelCaseName)}, [this]{return to_metrics_histogram(api_operations.name);}),
+                        seastar::metrics::description("Latency histogram of an operation via Alternator API"), {op(CamelCaseName)}, [this]{return api_operations.name.get_histogram(1,20);}),
             OPERATION(batch_write_item, "BatchWriteItem")
             OPERATION(create_backup, "CreateBackup")
             OPERATION(create_global_table, "CreateGlobalTable")
@@ -77,11 +77,6 @@ stats::stats() : api_operations{} {
             OPERATION_LATENCY(get_item_latency, "GetItem")
             OPERATION_LATENCY(delete_item_latency, "DeleteItem")
             OPERATION_LATENCY(update_item_latency, "UpdateItem")
-            OPERATION(list_streams, "ListStreams")
-            OPERATION(describe_stream, "DescribeStream")
-            OPERATION(get_shard_iterator, "GetShardIterator")
-            OPERATION(get_records, "GetRecords")
-            OPERATION_LATENCY(get_records_latency, "GetRecords")
     });
     _metrics.add_group("alternator", {
             seastar::metrics::make_total_operations("unsupported_operations", unsupported_operations,

alternator/stats.hh

@@ -74,16 +74,11 @@ public:
         uint64_t update_item = 0;
         uint64_t update_table = 0;
         uint64_t update_time_to_live = 0;
-        uint64_t list_streams = 0;
-        uint64_t describe_stream = 0;
-        uint64_t get_shard_iterator = 0;
-        uint64_t get_records = 0;
 
-        utils::time_estimated_histogram put_item_latency;
-        utils::time_estimated_histogram get_item_latency;
-        utils::time_estimated_histogram delete_item_latency;
-        utils::time_estimated_histogram update_item_latency;
-        utils::time_estimated_histogram get_records_latency;
+        utils::estimated_histogram put_item_latency;
+        utils::estimated_histogram get_item_latency;
+        utils::estimated_histogram delete_item_latency;
+        utils::estimated_histogram update_item_latency;
     } api_operations;
     // Miscellaneous event counters
     uint64_t total_operations = 0;

api/api-doc/messaging_service.json

@@ -249,7 +249,7 @@
                  "MIGRATION_REQUEST",
                  "PREPARE_MESSAGE",
                  "PREPARE_DONE_MESSAGE",
-                 "UNUSED__STREAM_MUTATION",
+                 "STREAM_MUTATION",
                  "STREAM_MUTATION_DONE",
                  "COMPLETE_MESSAGE",
                  "REPAIR_CHECKSUM_RANGE",

api/api-doc/storage_service.json

@@ -511,21 +511,6 @@
             }
          ]
       },
-      {
-         "path":"/storage_service/cdc_streams_check_and_repair",
-         "operations":[
-            {
-               "method":"POST",
-               "summary":"Checks that CDC streams reflect current cluster topology and regenerates them if not.",
-               "type":"void",
-               "nickname":"cdc_streams_check_and_repair",
-               "produces":[
-                  "application/json"
-               ],
-               "parameters":[]
-            }
-         ]
-      },
       {
          "path":"/storage_service/snapshots",
          "operations":[
@@ -833,43 +818,6 @@
             }
          ]
       },
-      {
-         "path":"/storage_service/repair_status/",
-         "operations":[
-            {
-               "method":"GET",
-               "summary":"Query the repair status and return when the repair is finished or timeout",
-               "type":"string",
-               "enum":[
-                  "RUNNING",
-                  "SUCCESSFUL",
-                  "FAILED"
-               ],
-               "nickname":"repair_await_completion",
-               "produces":[
-                  "application/json"
-               ],
-               "parameters":[
-                  {
-                     "name":"id",
-                     "description":"The repair ID to check for status",
-                     "required":true,
-                     "allowMultiple":false,
-                     "type": "long",
-                     "paramType":"query"
-                  },
-                  {
-                     "name":"timeout",
-                     "description":"Seconds to wait before the query returns even if the repair is not finished. The value -1 or not providing this parameter means no timeout",
-                     "required":false,
-                     "allowMultiple":false,
-                     "type": "long",
-                     "paramType":"query"
-                  }
-               ]
-            }
-         ]
-      },
       {
          "path":"/storage_service/repair_async/{keyspace}",
          "operations":[
@@ -2468,7 +2416,7 @@
             "version":{
                "type":"string",
                "enum":[
-                  "ka", "la", "mc", "md"
+                  "ka", "la", "mc"
                ],
                "description":"SSTable version"
             },

api/api.cc

@@ -93,40 +93,12 @@ static future<> register_api(http_context& ctx, const sstring& api_name,
     });
 }
 
-future<> set_transport_controller(http_context& ctx, cql_transport::controller& ctl) {
-    return ctx.http_server.set_routes([&ctx, &ctl] (routes& r) { set_transport_controller(ctx, r, ctl); });
-}
-
-future<> unset_transport_controller(http_context& ctx) {
-    return ctx.http_server.set_routes([&ctx] (routes& r) { unset_transport_controller(ctx, r); });
-}
-
-future<> set_rpc_controller(http_context& ctx, thrift_controller& ctl) {
-    return ctx.http_server.set_routes([&ctx, &ctl] (routes& r) { set_rpc_controller(ctx, r, ctl); });
-}
-
-future<> unset_rpc_controller(http_context& ctx) {
-    return ctx.http_server.set_routes([&ctx] (routes& r) { unset_rpc_controller(ctx, r); });
-}
-
 future<> set_server_storage_service(http_context& ctx) {
     return register_api(ctx, "storage_service", "The storage service API", set_storage_service);
 }
 
-future<> set_server_repair(http_context& ctx, sharded<netw::messaging_service>& ms) {
-    return ctx.http_server.set_routes([&ctx, &ms] (routes& r) { set_repair(ctx, r, ms); });
-}
-
-future<> unset_server_repair(http_context& ctx) {
-    return ctx.http_server.set_routes([&ctx] (routes& r) { unset_repair(ctx, r); });
-}
-
-future<> set_server_snapshot(http_context& ctx, sharded<db::snapshot_ctl>& snap_ctl) {
-    return ctx.http_server.set_routes([&ctx, &snap_ctl] (routes& r) { set_snapshot(ctx, r, snap_ctl); });
-}
-
-future<> unset_server_snapshot(http_context& ctx) {
-    return ctx.http_server.set_routes([&ctx] (routes& r) { unset_snapshot(ctx, r); });
+future<> set_server_snapshot(http_context& ctx) {
+    return ctx.http_server.set_routes([&ctx] (routes& r) { set_snapshot(ctx, r); });
 }
 
 future<> set_server_snitch(http_context& ctx) {
@@ -143,14 +115,9 @@ future<> set_server_load_sstable(http_context& ctx) {
                 "The column family API", set_column_family);
 }
 
-future<> set_server_messaging_service(http_context& ctx, sharded<netw::messaging_service>& ms) {
+future<> set_server_messaging_service(http_context& ctx) {
     return register_api(ctx, "messaging_service",
-                "The messaging service API", [&ms] (http_context& ctx, routes& r) {
-                    set_messaging_service(ctx, r, ms);
-                });
-}
-future<> unset_server_messaging_service(http_context& ctx) {
-    return ctx.http_server.set_routes([&ctx] (routes& r) { unset_messaging_service(ctx, r); });
+                "The messaging service API", set_messaging_service);
 }
 
 future<> set_server_storage_proxy(http_context& ctx) {

api/api.hh

@@ -256,6 +256,4 @@ public:
     operator T() const { return value; }
 };
 
-utils_json::estimated_histogram time_to_json_histogram(const utils::time_estimated_histogram& val);
-
 }

api/api_init.hh

@@ -25,10 +25,6 @@
 
 namespace service { class load_meter; }
 namespace locator { class token_metadata; }
-namespace cql_transport { class controller; }
-class thrift_controller;
-namespace db { class snapshot_ctl; }
-namespace netw { class messaging_service; }
 
 namespace api {
 
@@ -39,11 +35,11 @@ struct http_context {
     distributed<database>& db;
     distributed<service::storage_proxy>& sp;
     service::load_meter& lmeter;
-    const sharded<locator::token_metadata>& token_metadata;
+    sharded<locator::token_metadata>& token_metadata;
 
     http_context(distributed<database>& _db,
             distributed<service::storage_proxy>& _sp,
-            service::load_meter& _lm, const sharded<locator::token_metadata>& _tm)
+            service::load_meter& _lm, sharded<locator::token_metadata>& _tm)
             : db(_db), sp(_sp), lmeter(_lm), token_metadata(_tm) {
     }
 };
@@ -52,18 +48,10 @@ future<> set_server_init(http_context& ctx);
 future<> set_server_config(http_context& ctx);
 future<> set_server_snitch(http_context& ctx);
 future<> set_server_storage_service(http_context& ctx);
-future<> set_server_repair(http_context& ctx, sharded<netw::messaging_service>& ms);
-future<> unset_server_repair(http_context& ctx);
-future<> set_transport_controller(http_context& ctx, cql_transport::controller& ctl);
-future<> unset_transport_controller(http_context& ctx);
-future<> set_rpc_controller(http_context& ctx, thrift_controller& ctl);
-future<> unset_rpc_controller(http_context& ctx);
-future<> set_server_snapshot(http_context& ctx, sharded<db::snapshot_ctl>& snap_ctl);
-future<> unset_server_snapshot(http_context& ctx);
+future<> set_server_snapshot(http_context& ctx);
 future<> set_server_gossip(http_context& ctx);
 future<> set_server_load_sstable(http_context& ctx);
-future<> set_server_messaging_service(http_context& ctx, sharded<netw::messaging_service>& ms);
-future<> unset_server_messaging_service(http_context& ctx);
+future<> set_server_messaging_service(http_context& ctx);
 future<> set_server_storage_proxy(http_context& ctx);
 future<> set_server_stream_manager(http_context& ctx);
 future<> set_server_gossip_settle(http_context& ctx);

api/column_family.cc

@@ -249,12 +249,6 @@ static future<json::json_return_type> sum_sstable(http_context& ctx, bool total)
     });
 }
 
-future<json::json_return_type> map_reduce_cf_time_histogram(http_context& ctx, const sstring& name, std::function<utils::time_estimated_histogram(const column_family&)> f) {
-    return map_reduce_cf_raw(ctx, name, utils::time_estimated_histogram(), f, utils::time_estimated_histogram_merge).then([](const utils::time_estimated_histogram& res) {
-        return make_ready_future<json::json_return_type>(time_to_json_histogram(res));
-    });
-}
-
 template <typename T>
 class sum_ratio {
     uint64_t _n = 0;
@@ -331,15 +325,15 @@ void set_column_family(http_context& ctx, routes& r) {
     });
 
     cf::get_memtable_columns_count.set(r, [&ctx] (std::unique_ptr<request> req) {
-        return map_reduce_cf(ctx, req->param["name"], uint64_t{0}, [](column_family& cf) {
+        return map_reduce_cf(ctx, req->param["name"], 0, [](column_family& cf) {
             return cf.active_memtable().partition_count();
-        }, std::plus<>());
+        }, std::plus<int>());
     });
 
     cf::get_all_memtable_columns_count.set(r, [&ctx] (std::unique_ptr<request> req) {
-        return map_reduce_cf(ctx, uint64_t{0}, [](column_family& cf) {
+        return map_reduce_cf(ctx, 0, [](column_family& cf) {
             return cf.active_memtable().partition_count();
-        }, std::plus<>());
+        }, std::plus<int>());
     });
 
     cf::get_memtable_on_heap_size.set(r, [] (const_req req) {
@@ -656,7 +650,7 @@ void set_column_family(http_context& ctx, routes& r) {
     cf::get_bloom_filter_disk_space_used.set(r, [&ctx] (std::unique_ptr<request> req) {
         return map_reduce_cf(ctx, req->param["name"], uint64_t(0), [] (column_family& cf) {
             return std::accumulate(cf.get_sstables()->begin(), cf.get_sstables()->end(), uint64_t(0), [](uint64_t s, auto& sst) {
-                return s + sst->filter_size();
+                return sst->filter_size();
             });
         }, std::plus<uint64_t>());
     });
@@ -664,7 +658,7 @@ void set_column_family(http_context& ctx, routes& r) {
     cf::get_all_bloom_filter_disk_space_used.set(r, [&ctx] (std::unique_ptr<request> req) {
         return map_reduce_cf(ctx, uint64_t(0), [] (column_family& cf) {
             return std::accumulate(cf.get_sstables()->begin(), cf.get_sstables()->end(), uint64_t(0), [](uint64_t s, auto& sst) {
-                return s + sst->filter_size();
+                return sst->filter_size();
             });
         }, std::plus<uint64_t>());
     });
@@ -672,7 +666,7 @@ void set_column_family(http_context& ctx, routes& r) {
     cf::get_bloom_filter_off_heap_memory_used.set(r, [&ctx] (std::unique_ptr<request> req) {
         return map_reduce_cf(ctx, req->param["name"], uint64_t(0), [] (column_family& cf) {
             return std::accumulate(cf.get_sstables()->begin(), cf.get_sstables()->end(), uint64_t(0), [](uint64_t s, auto& sst) {
-                return s + sst->filter_memory_size();
+                return sst->filter_memory_size();
             });
         }, std::plus<uint64_t>());
     });
@@ -680,7 +674,7 @@ void set_column_family(http_context& ctx, routes& r) {
     cf::get_all_bloom_filter_off_heap_memory_used.set(r, [&ctx] (std::unique_ptr<request> req) {
         return map_reduce_cf(ctx, uint64_t(0), [] (column_family& cf) {
             return std::accumulate(cf.get_sstables()->begin(), cf.get_sstables()->end(), uint64_t(0), [](uint64_t s, auto& sst) {
-                return s + sst->filter_memory_size();
+                return sst->filter_memory_size();
             });
         }, std::plus<uint64_t>());
     });
@@ -688,7 +682,7 @@ void set_column_family(http_context& ctx, routes& r) {
     cf::get_index_summary_off_heap_memory_used.set(r, [&ctx] (std::unique_ptr<request> req) {
         return map_reduce_cf(ctx, req->param["name"], uint64_t(0), [] (column_family& cf) {
             return std::accumulate(cf.get_sstables()->begin(), cf.get_sstables()->end(), uint64_t(0), [](uint64_t s, auto& sst) {
-                return s + sst->get_summary().memory_footprint();
+                return sst->get_summary().memory_footprint();
             });
         }, std::plus<uint64_t>());
     });
@@ -696,7 +690,7 @@ void set_column_family(http_context& ctx, routes& r) {
     cf::get_all_index_summary_off_heap_memory_used.set(r, [&ctx] (std::unique_ptr<request> req) {
         return map_reduce_cf(ctx, uint64_t(0), [] (column_family& cf) {
             return std::accumulate(cf.get_sstables()->begin(), cf.get_sstables()->end(), uint64_t(0), [](uint64_t s, auto& sst) {
-                return s + sst->get_summary().memory_footprint();
+                return sst->get_summary().memory_footprint();
             });
         }, std::plus<uint64_t>());
     });
@@ -802,21 +796,24 @@ void set_column_family(http_context& ctx, routes& r) {
     });
 
     cf::get_cas_prepare.set(r, [&ctx] (std::unique_ptr<request> req) {
-        return map_reduce_cf_time_histogram(ctx, req->param["name"], [](const column_family& cf) {
+        return map_reduce_cf(ctx, req->param["name"], utils::estimated_histogram(0), [](column_family& cf) {
             return cf.get_stats().estimated_cas_prepare;
-        });
+        },
+        utils::estimated_histogram_merge, utils_json::estimated_histogram());
     });
 
     cf::get_cas_propose.set(r, [&ctx] (std::unique_ptr<request> req) {
-        return map_reduce_cf_time_histogram(ctx, req->param["name"], [](const column_family& cf) {
+        return map_reduce_cf(ctx, req->param["name"], utils::estimated_histogram(0), [](column_family& cf) {
             return cf.get_stats().estimated_cas_accept;
-        });
+        },
+        utils::estimated_histogram_merge, utils_json::estimated_histogram());
     });
 
     cf::get_cas_commit.set(r, [&ctx] (std::unique_ptr<request> req) {
-        return map_reduce_cf_time_histogram(ctx, req->param["name"], [](const column_family& cf) {
+        return map_reduce_cf(ctx, req->param["name"], utils::estimated_histogram(0), [](column_family& cf) {
             return cf.get_stats().estimated_cas_learn;
-        });
+        },
+        utils::estimated_histogram_merge, utils_json::estimated_histogram());
     });
 
     cf::get_sstables_per_read_histogram.set(r, [&ctx] (std::unique_ptr<request> req) {
@@ -865,9 +862,7 @@ void set_column_family(http_context& ctx, routes& r) {
     });
 
     cf::get_built_indexes.set(r, [&ctx](std::unique_ptr<request> req) {
-        auto ks_cf = parse_fully_qualified_cf_name(req->param["name"]);
-        auto&& ks = std::get<0>(ks_cf);
-        auto&& cf_name = std::get<1>(ks_cf);
+        auto [ks, cf_name] = parse_fully_qualified_cf_name(req->param["name"]);
         return db::system_keyspace::load_view_build_progress().then([ks, cf_name, &ctx](const std::vector<db::system_keyspace::view_build_progress>& vb) mutable {
             std::set<sstring> vp;
             for (auto b : vb) {
@@ -880,7 +875,7 @@ void set_column_family(http_context& ctx, routes& r) {
             column_family& cf = ctx.db.local().find_column_family(uuid);
             res.reserve(cf.get_index_manager().list_indexes().size());
             for (auto&& i : cf.get_index_manager().list_indexes()) {
-                if (!vp.contains(secondary_index::index_table_name(i.metadata().name()))) {
+                if (vp.find(secondary_index::index_table_name(i.metadata().name())) == vp.end()) {
                     res.emplace_back(i.metadata().name());
                 }
             }
@@ -914,15 +909,17 @@ void set_column_family(http_context& ctx, routes& r) {
     });
 
     cf::get_read_latency_estimated_histogram.set(r, [&ctx](std::unique_ptr<request> req) {
-        return map_reduce_cf_time_histogram(ctx, req->param["name"], [](const column_family& cf) {
+        return map_reduce_cf(ctx, req->param["name"], utils::estimated_histogram(0), [](column_family& cf) {
             return cf.get_stats().estimated_read;
-        });
+        },
+        utils::estimated_histogram_merge, utils_json::estimated_histogram());
     });
 
     cf::get_write_latency_estimated_histogram.set(r, [&ctx](std::unique_ptr<request> req) {
-        return map_reduce_cf_time_histogram(ctx, req->param["name"], [](const column_family& cf) {
+        return map_reduce_cf(ctx, req->param["name"], utils::estimated_histogram(0), [](column_family& cf) {
             return cf.get_stats().estimated_write;
-        });
+        },
+        utils::estimated_histogram_merge, utils_json::estimated_histogram());
     });
 
     cf::set_compaction_strategy_class.set(r, [&ctx](std::unique_ptr<request> req) {

api/column_family.hh

@@ -68,8 +68,6 @@ future<json::json_return_type> map_reduce_cf(http_context& ctx, const sstring& n
     });
 }
 
-future<json::json_return_type> map_reduce_cf_time_histogram(http_context& ctx, const sstring& name, std::function<utils::time_estimated_histogram(const column_family&)> f);
-
 struct map_reduce_column_families_locally {
     std::any init;
     std::function<std::unique_ptr<std::any>(column_family&)> mapper;

api/commitlog.cc

@@ -20,7 +20,7 @@
  */
 
 #include "commitlog.hh"
-#include "db/commitlog/commitlog.hh"
+#include <db/commitlog/commitlog.hh>
 #include "api/api-doc/commitlog.json.hh"
 #include "database.hh"
 #include <vector>

api/gossiper.cc

@@ -21,7 +21,7 @@
 
 #include "gossiper.hh"
 #include "api/api-doc/gossiper.json.hh"
-#include "gms/gossiper.hh"
+#include <gms/gossiper.hh>
 
 namespace api {
 using namespace json;

api/messaging_service.cc

@@ -53,8 +53,8 @@ std::vector<message_counter> map_to_message_counters(
  * according to a function that it gets as a parameter.
  *
  */
-future_json_function get_client_getter(sharded<netw::messaging_service>& ms, std::function<uint64_t(const shard_info&)> f) {
-    return [&ms, f](std::unique_ptr<request> req) {
+future_json_function get_client_getter(std::function<uint64_t(const shard_info&)> f) {
+    return [f](std::unique_ptr<request> req) {
         using map_type = std::unordered_map<gms::inet_address, uint64_t>;
         auto get_shard_map = [f](messaging_service& ms) {
             std::unordered_map<gms::inet_address, unsigned long> map;
@@ -63,15 +63,15 @@ future_json_function get_client_getter(sharded<netw::messaging_service>& ms, std
             });
             return map;
         };
-        return ms.map_reduce0(get_shard_map, map_type(), map_sum<map_type>).
+        return  get_messaging_service().map_reduce0(get_shard_map, map_type(), map_sum<map_type>).
                 then([](map_type&& map) {
             return make_ready_future<json::json_return_type>(map_to_message_counters(map));
         });
     };
 }
 
-future_json_function get_server_getter(sharded<netw::messaging_service>& ms, std::function<uint64_t(const rpc::stats&)> f) {
-    return [&ms, f](std::unique_ptr<request> req) {
+future_json_function get_server_getter(std::function<uint64_t(const rpc::stats&)> f) {
+    return [f](std::unique_ptr<request> req) {
         using map_type = std::unordered_map<gms::inet_address, uint64_t>;
         auto get_shard_map = [f](messaging_service& ms) {
             std::unordered_map<gms::inet_address, unsigned long> map;
@@ -80,53 +80,53 @@ future_json_function get_server_getter(sharded<netw::messaging_service>& ms, std
             });
             return map;
         };
-        return ms.map_reduce0(get_shard_map, map_type(), map_sum<map_type>).
+        return  get_messaging_service().map_reduce0(get_shard_map, map_type(), map_sum<map_type>).
                 then([](map_type&& map) {
             return make_ready_future<json::json_return_type>(map_to_message_counters(map));
         });
     };
 }
 
-void set_messaging_service(http_context& ctx, routes& r, sharded<netw::messaging_service>& ms) {
-    get_timeout_messages.set(r, get_client_getter(ms, [](const shard_info& c) {
+void set_messaging_service(http_context& ctx, routes& r) {
+    get_timeout_messages.set(r, get_client_getter([](const shard_info& c) {
         return c.get_stats().timeout;
     }));
 
-    get_sent_messages.set(r, get_client_getter(ms, [](const shard_info& c) {
+    get_sent_messages.set(r, get_client_getter([](const shard_info& c) {
         return c.get_stats().sent_messages;
     }));
 
-    get_dropped_messages.set(r, get_client_getter(ms, [](const shard_info& c) {
+    get_dropped_messages.set(r, get_client_getter([](const shard_info& c) {
         // We don't have the same drop message mechanism
         // as origin has.
         // hence we can always return 0
         return 0;
     }));
 
-    get_exception_messages.set(r, get_client_getter(ms, [](const shard_info& c) {
+    get_exception_messages.set(r, get_client_getter([](const shard_info& c) {
         return c.get_stats().exception_received;
     }));
 
-    get_pending_messages.set(r, get_client_getter(ms, [](const shard_info& c) {
+    get_pending_messages.set(r, get_client_getter([](const shard_info& c) {
         return c.get_stats().pending;
     }));
 
-    get_respond_pending_messages.set(r, get_server_getter(ms, [](const rpc::stats& c) {
+    get_respond_pending_messages.set(r, get_server_getter([](const rpc::stats& c) {
         return c.pending;
     }));
 
-    get_respond_completed_messages.set(r, get_server_getter(ms, [](const rpc::stats& c) {
+    get_respond_completed_messages.set(r, get_server_getter([](const rpc::stats& c) {
         return c.sent_messages;
     }));
 
-    get_version.set(r, [&ms](const_req req) {
-        return ms.local().get_raw_version(req.get_query_param("addr"));
+    get_version.set(r, [](const_req req) {
+        return netw::get_local_messaging_service().get_raw_version(req.get_query_param("addr"));
     });
 
-    get_dropped_messages_by_ver.set(r, [&ms](std::unique_ptr<request> req) {
+    get_dropped_messages_by_ver.set(r, [](std::unique_ptr<request> req) {
         shared_ptr<std::vector<uint64_t>> map = make_shared<std::vector<uint64_t>>(num_verb);
 
-        return ms.map_reduce([map](const uint64_t* local_map) mutable {
+        return netw::get_messaging_service().map_reduce([map](const uint64_t* local_map) mutable {
             for (auto i = 0; i < num_verb; i++) {
                 (*map)[i]+= local_map[i];
             }
@@ -151,18 +151,5 @@ void set_messaging_service(http_context& ctx, routes& r, sharded<netw::messaging
         });
     });
 }
-
-void unset_messaging_service(http_context& ctx, routes& r) {
-    get_timeout_messages.unset(r);
-    get_sent_messages.unset(r);
-    get_dropped_messages.unset(r);
-    get_exception_messages.unset(r);
-    get_pending_messages.unset(r);
-    get_respond_pending_messages.unset(r);
-    get_respond_completed_messages.unset(r);
-    get_version.unset(r);
-    get_dropped_messages_by_ver.unset(r);
-}
-
 }
 

api/messaging_service.hh

@@ -23,11 +23,8 @@
 
 #include "api.hh"
 
-namespace netw { class messaging_service; }
-
 namespace api {
 
-void set_messaging_service(http_context& ctx, routes& r, sharded<netw::messaging_service>& ms);
-void unset_messaging_service(http_context& ctx, routes& r);
+void set_messaging_service(http_context& ctx, routes& r);
 
 }

api/storage_proxy.cc

@@ -116,23 +116,6 @@ static future<json::json_return_type>  sum_timed_rate_as_long(distributed<proxy>
     });
 }
 
-utils_json::estimated_histogram time_to_json_histogram(const utils::time_estimated_histogram& val) {
-    utils_json::estimated_histogram res;
-    for (size_t i = 0; i < val.size(); i++) {
-        res.buckets.push(val.get(i));
-        res.bucket_offsets.push(val.get_bucket_lower_limit(i));
-    }
-    return res;
-}
-
-static future<json::json_return_type>  sum_estimated_histogram(http_context& ctx, utils::time_estimated_histogram service::storage_proxy_stats::stats::*f) {
-
-    return two_dimensional_map_reduce(ctx.sp, f, utils::time_estimated_histogram_merge,
-            utils::time_estimated_histogram()).then([](const utils::time_estimated_histogram& val) {
-        return make_ready_future<json::json_return_type>(time_to_json_histogram(val));
-    });
-}
-
 static future<json::json_return_type>  sum_estimated_histogram(http_context& ctx, utils::estimated_histogram service::storage_proxy_stats::stats::*f) {
 
     return two_dimensional_map_reduce(ctx.sp, f, utils::estimated_histogram_merge,

api/storage_service.cc

@@ -41,9 +41,6 @@
 #include "sstables/sstables.hh"
 #include "database.hh"
 #include "db/extensions.hh"
-#include "db/snapshot-ctl.hh"
-#include "transport/controller.hh"
-#include "thrift/controller.hh"
 
 namespace api {
 
@@ -88,164 +85,21 @@ static auto wrap_ks_cf(http_context &ctx, ks_cf_func f) {
     };
 }
 
-future<json::json_return_type> set_tables_autocompaction(http_context& ctx, const sstring &keyspace, std::vector<sstring> tables, bool enabled) {
+future<> set_tables_autocompaction(http_context& ctx, const sstring &keyspace, std::vector<sstring> tables, bool enabled) {
     if (tables.empty()) {
         tables = map_keys(ctx.db.local().find_keyspace(keyspace).metadata().get()->cf_meta_data());
     }
-
-    return service::get_local_storage_service().set_tables_autocompaction(keyspace, tables, enabled).then([]{
-        return make_ready_future<json::json_return_type>(json_void());
-    });
-}
-
-void set_transport_controller(http_context& ctx, routes& r, cql_transport::controller& ctl) {
-    ss::start_native_transport.set(r, [&ctl](std::unique_ptr<request> req) {
-        return ctl.start_server().then([] {
-            return make_ready_future<json::json_return_type>(json_void());
-        });
-    });
-
-    ss::stop_native_transport.set(r, [&ctl](std::unique_ptr<request> req) {
-        return ctl.stop_server().then([] {
-            return make_ready_future<json::json_return_type>(json_void());
-        });
-    });
-
-    ss::is_native_transport_running.set(r, [&ctl] (std::unique_ptr<request> req) {
-        return ctl.is_server_running().then([] (bool running) {
-            return make_ready_future<json::json_return_type>(running);
-        });
-    });
-}
-
-void unset_transport_controller(http_context& ctx, routes& r) {
-    ss::start_native_transport.unset(r);
-    ss::stop_native_transport.unset(r);
-    ss::is_native_transport_running.unset(r);
-}
-
-void set_rpc_controller(http_context& ctx, routes& r, thrift_controller& ctl) {
-    ss::stop_rpc_server.set(r, [&ctl](std::unique_ptr<request> req) {
-        return ctl.stop_server().then([] {
-            return make_ready_future<json::json_return_type>(json_void());
-        });
-    });
-
-    ss::start_rpc_server.set(r, [&ctl](std::unique_ptr<request> req) {
-        return ctl.start_server().then([] {
-            return make_ready_future<json::json_return_type>(json_void());
-        });
-    });
-
-    ss::is_rpc_server_running.set(r, [&ctl] (std::unique_ptr<request> req) {
-        return ctl.is_server_running().then([] (bool running) {
-            return make_ready_future<json::json_return_type>(running);
-        });
-    });
-}
-
-void unset_rpc_controller(http_context& ctx, routes& r) {
-    ss::stop_rpc_server.unset(r);
-    ss::start_rpc_server.unset(r);
-    ss::is_rpc_server_running.unset(r);
-}
-
-void set_repair(http_context& ctx, routes& r, sharded<netw::messaging_service>& ms) {
-    ss::repair_async.set(r, [&ctx, &ms](std::unique_ptr<request> req) {
-        static std::vector<sstring> options = {"primaryRange", "parallelism", "incremental",
-                "jobThreads", "ranges", "columnFamilies", "dataCenters", "hosts", "trace",
-                "startToken", "endToken" };
-        std::unordered_map<sstring, sstring> options_map;
-        for (auto o : options) {
-            auto s = req->get_query_param(o);
-            if (s != "") {
-                options_map[o] = s;
-            }
-        }
-
-        // The repair process is asynchronous: repair_start only starts it and
-        // returns immediately, not waiting for the repair to finish. The user
-        // then has other mechanisms to track the ongoing repair's progress,
-        // or stop it.
-        return repair_start(ctx.db, ms, validate_keyspace(ctx, req->param),
-                options_map).then([] (int i) {
-                    return make_ready_future<json::json_return_type>(i);
-                });
-    });
-
-    ss::get_active_repair_async.set(r, [&ctx](std::unique_ptr<request> req) {
-        return get_active_repairs(ctx.db).then([] (std::vector<int> res){
-            return make_ready_future<json::json_return_type>(res);
-        });
-    });
-
-    ss::repair_async_status.set(r, [&ctx](std::unique_ptr<request> req) {
-        return repair_get_status(ctx.db, boost::lexical_cast<int>( req->get_query_param("id")))
-                .then_wrapped([] (future<repair_status>&& fut) {
-            ss::ns_repair_async_status::return_type_wrapper res;
-            try {
-                res = fut.get0();
-            } catch(std::runtime_error& e) {
-                throw httpd::bad_param_exception(e.what());
-            }
-            return make_ready_future<json::json_return_type>(json::json_return_type(res));
-        });
-    });
-
-    ss::repair_await_completion.set(r, [&ctx](std::unique_ptr<request> req) {
-        int id;
-        using clock = std::chrono::steady_clock;
-        clock::time_point expire;
-        try {
-            id = boost::lexical_cast<int>(req->get_query_param("id"));
-            // If timeout is not provided, it means no timeout.
-            sstring s = req->get_query_param("timeout");
-            int64_t timeout = s.empty() ? int64_t(-1) : boost::lexical_cast<int64_t>(s);
-            if (timeout < 0 && timeout != -1) {
-                return make_exception_future<json::json_return_type>(
-                        httpd::bad_param_exception("timeout can only be -1 (means no timeout) or non negative integer"));
-            }
-            if (timeout < 0) {
-                expire = clock::time_point::max();
+    return ctx.db.invoke_on_all([keyspace, tables, enabled] (database& db) {
+        return parallel_for_each(tables, [&db, keyspace, enabled](const sstring& table) mutable {
+            column_family& cf = db.find_column_family(keyspace, table);
+            if (enabled) {
+                cf.enable_auto_compaction();
             } else {
-                expire = clock::now() + std::chrono::seconds(timeout);
+                cf.disable_auto_compaction();
             }
-        } catch (std::exception& e) {
-            return make_exception_future<json::json_return_type>(httpd::bad_param_exception(e.what()));
-        }
-        return repair_await_completion(ctx.db, id, expire)
-                .then_wrapped([] (future<repair_status>&& fut) {
-            ss::ns_repair_async_status::return_type_wrapper res;
-            try {
-                res = fut.get0();
-            } catch (std::exception& e) {
-                return make_exception_future<json::json_return_type>(httpd::server_error_exception(e.what()));
-            }
-            return make_ready_future<json::json_return_type>(json::json_return_type(res));
+            return make_ready_future<>();
         });
     });
-
-    ss::force_terminate_all_repair_sessions.set(r, [](std::unique_ptr<request> req) {
-        return repair_abort_all(service::get_local_storage_service().db()).then([] {
-            return make_ready_future<json::json_return_type>(json_void());
-        });
-    });
-
-    ss::force_terminate_all_repair_sessions_new.set(r, [](std::unique_ptr<request> req) {
-        return repair_abort_all(service::get_local_storage_service().db()).then([] {
-            return make_ready_future<json::json_return_type>(json_void());
-        });
-    });
-
-}
-
-void unset_repair(http_context& ctx, routes& r) {
-    ss::repair_async.unset(r);
-    ss::get_active_repair_async.unset(r);
-    ss::repair_async_status.unset(r);
-    ss::repair_await_completion.unset(r);
-    ss::force_terminate_all_repair_sessions.unset(r);
-    ss::force_terminate_all_repair_sessions_new.unset(r);
 }
 
 void set_storage_service(http_context& ctx, routes& r) {
@@ -319,26 +173,11 @@ void set_storage_service(http_context& ctx, routes& r) {
     });
 
     ss::get_range_to_endpoint_map.set(r, [&ctx](std::unique_ptr<request> req) {
+        //TBD
+        unimplemented();
         auto keyspace = validate_keyspace(ctx, req->param);
         std::vector<ss::maplist_mapper> res;
-        return make_ready_future<json::json_return_type>(stream_range_as_array(service::get_local_storage_service().get_range_to_address_map(keyspace),
-                [](const std::pair<dht::token_range, std::vector<gms::inet_address>>& entry){
-            ss::maplist_mapper m;
-            if (entry.first.start()) {
-                m.key.push(entry.first.start().value().value().to_sstring());
-            } else {
-                m.key.push("");
-            }
-            if (entry.first.end()) {
-                m.key.push(entry.first.end().value().value().to_sstring());
-            } else {
-                m.key.push("");
-            }
-            for (const gms::inet_address& address : entry.second) {
-                m.value.push(address.to_sstring());
-            }
-            return m;
-        }));
+        return make_ready_future<json::json_return_type>(res);
     });
 
     ss::get_pending_range_to_endpoint_map.set(r, [&ctx](std::unique_ptr<request> req) {
@@ -393,12 +232,6 @@ void set_storage_service(http_context& ctx, routes& r) {
                 req.get_query_param("key")));
     });
 
-    ss::cdc_streams_check_and_repair.set(r, [&ctx] (std::unique_ptr<request> req) {
-        return service::get_local_storage_service().check_and_repair_cdc_streams().then([] {
-            return make_ready_future<json::json_return_type>(json_void());
-        });
-    });
-
     ss::force_keyspace_compaction.set(r, [&ctx](std::unique_ptr<request> req) {
         auto keyspace = validate_keyspace(ctx, req->param);
         auto column_families = split_cf(req->get_query_param("cf"));
@@ -452,7 +285,7 @@ void set_storage_service(http_context& ctx, routes& r) {
             return do_for_each(column_families, [=, &db](sstring cfname) {
                 auto& cm = db.get_compaction_manager();
                 auto& cf = db.find_column_family(keyspace, cfname);
-                return cm.perform_sstable_upgrade(db, &cf, exclude_current_version);
+                return cm.perform_sstable_upgrade(&cf, exclude_current_version);
             });
         }).then([]{
             return make_ready_future<json::json_return_type>(0);
@@ -475,6 +308,59 @@ void set_storage_service(http_context& ctx, routes& r) {
     });
 
 
+    ss::repair_async.set(r, [&ctx](std::unique_ptr<request> req) {
+        static std::vector<sstring> options = {"primaryRange", "parallelism", "incremental",
+                "jobThreads", "ranges", "columnFamilies", "dataCenters", "hosts", "trace",
+                "startToken", "endToken" };
+        std::unordered_map<sstring, sstring> options_map;
+        for (auto o : options) {
+            auto s = req->get_query_param(o);
+            if (s != "") {
+                options_map[o] = s;
+            }
+        }
+
+        // The repair process is asynchronous: repair_start only starts it and
+        // returns immediately, not waiting for the repair to finish. The user
+        // then has other mechanisms to track the ongoing repair's progress,
+        // or stop it.
+        return repair_start(ctx.db, validate_keyspace(ctx, req->param),
+                options_map).then([] (int i) {
+                    return make_ready_future<json::json_return_type>(i);
+                });
+    });
+
+    ss::get_active_repair_async.set(r, [&ctx](std::unique_ptr<request> req) {
+        return get_active_repairs(ctx.db).then([] (std::vector<int> res){
+            return make_ready_future<json::json_return_type>(res);
+        });
+    });
+
+    ss::repair_async_status.set(r, [&ctx](std::unique_ptr<request> req) {
+        return repair_get_status(ctx.db, boost::lexical_cast<int>( req->get_query_param("id")))
+                .then_wrapped([] (future<repair_status>&& fut) {
+            ss::ns_repair_async_status::return_type_wrapper res;
+            try {
+                res = fut.get0();
+            } catch(std::runtime_error& e) {
+                throw httpd::bad_param_exception(e.what());
+            }
+            return make_ready_future<json::json_return_type>(json::json_return_type(res));
+        });
+    });
+
+    ss::force_terminate_all_repair_sessions.set(r, [](std::unique_ptr<request> req) {
+        return repair_abort_all(service::get_local_storage_service().db()).then([] {
+            return make_ready_future<json::json_return_type>(json_void());
+        });
+    });
+
+    ss::force_terminate_all_repair_sessions_new.set(r, [](std::unique_ptr<request> req) {
+        return repair_abort_all(service::get_local_storage_service().db()).then([] {
+            return make_ready_future<json::json_return_type>(json_void());
+        });
+    });
+
     ss::decommission.set(r, [](std::unique_ptr<request> req) {
         return service::get_local_storage_service().decommission().then([] {
             return make_ready_future<json::json_return_type>(json_void());
@@ -610,6 +496,42 @@ void set_storage_service(http_context& ctx, routes& r) {
         });
     });
 
+    ss::stop_rpc_server.set(r, [](std::unique_ptr<request> req) {
+        return service::get_local_storage_service().stop_rpc_server().then([] {
+            return make_ready_future<json::json_return_type>(json_void());
+        });
+    });
+
+    ss::start_rpc_server.set(r, [](std::unique_ptr<request> req) {
+        return service::get_local_storage_service().start_rpc_server().then([] {
+            return make_ready_future<json::json_return_type>(json_void());
+        });
+    });
+
+    ss::is_rpc_server_running.set(r, [] (std::unique_ptr<request> req) {
+        return service::get_local_storage_service().is_rpc_server_running().then([] (bool running) {
+            return make_ready_future<json::json_return_type>(running);
+        });
+    });
+
+    ss::start_native_transport.set(r, [](std::unique_ptr<request> req) {
+        return service::get_local_storage_service().start_native_transport().then([] {
+            return make_ready_future<json::json_return_type>(json_void());
+        });
+    });
+
+    ss::stop_native_transport.set(r, [](std::unique_ptr<request> req) {
+        return service::get_local_storage_service().stop_native_transport().then([] {
+            return make_ready_future<json::json_return_type>(json_void());
+        });
+    });
+
+    ss::is_native_transport_running.set(r, [] (std::unique_ptr<request> req) {
+        return service::get_local_storage_service().is_native_transport_running().then([] (bool running) {
+            return make_ready_future<json::json_return_type>(running);
+        });
+    });
+
     ss::join_ring.set(r, [](std::unique_ptr<request> req) {
         return make_ready_future<json::json_return_type>(json_void());
     });
@@ -796,15 +718,17 @@ void set_storage_service(http_context& ctx, routes& r) {
     ss::enable_auto_compaction.set(r, [&ctx](std::unique_ptr<request> req) {
         auto keyspace = validate_keyspace(ctx, req->param);
         auto tables = split_cf(req->get_query_param("cf"));
-
-        return set_tables_autocompaction(ctx, keyspace, tables, true);
+        return set_tables_autocompaction(ctx, keyspace, tables, true).then([]{
+            return make_ready_future<json::json_return_type>(json_void());
+        });
     });
 
     ss::disable_auto_compaction.set(r, [&ctx](std::unique_ptr<request> req) {
         auto keyspace = validate_keyspace(ctx, req->param);
         auto tables = split_cf(req->get_query_param("cf"));
-
-        return set_tables_autocompaction(ctx, keyspace, tables, false);
+        return set_tables_autocompaction(ctx, keyspace, tables, false).then([]{
+            return make_ready_future<json::json_return_type>(json_void());
+        });
     });
 
     ss::deliver_hints.set(r, [](std::unique_ptr<request> req) {
@@ -982,7 +906,7 @@ void set_storage_service(http_context& ctx, routes& r) {
                                     e.value = p.second;
                                     nm.attributes.push(std::move(e));
                                 }
-                                if (!cp->options().contains(compression_parameters::SSTABLE_COMPRESSION)) {
+                                if (!cp->options().count(compression_parameters::SSTABLE_COMPRESSION)) {
                                     ss::mapper e;
                                     e.key = compression_parameters::SSTABLE_COMPRESSION;
                                     e.value = cp->name();
@@ -1040,29 +964,31 @@ void set_storage_service(http_context& ctx, routes& r) {
 
 }
 
-void set_snapshot(http_context& ctx, routes& r, sharded<db::snapshot_ctl>& snap_ctl) {
-    ss::get_snapshot_details.set(r, [&snap_ctl](std::unique_ptr<request> req) {
-        return snap_ctl.local().get_snapshot_details().then([] (std::unordered_map<sstring, std::vector<db::snapshot_ctl::snapshot_details>>&& result) {
-            std::function<future<>(output_stream<char>&&)> f = [result = std::move(result)](output_stream<char>&& s) {
-                return do_with(output_stream<char>(std::move(s)), true, [&result] (output_stream<char>& s, bool& first){
-                    return s.write("[").then([&s, &first, &result] {
-                        return do_for_each(result, [&s, &first](std::tuple<sstring, std::vector<db::snapshot_ctl::snapshot_details>>&& map){
-                            return do_with(ss::snapshots(), [&s, &first, &map](ss::snapshots& all_snapshots) {
-                                all_snapshots.key = std::get<0>(map);
-                                future<> f = first ? make_ready_future<>() : s.write(", ");
-                                first = false;
-                                std::vector<ss::snapshot> snapshot;
-                                for (auto& cf: std::get<1>(map)) {
-                                    ss::snapshot snp;
-                                    snp.ks = cf.ks;
-                                    snp.cf = cf.cf;
-                                    snp.live = cf.live;
-                                    snp.total = cf.total;
-                                    snapshot.push_back(std::move(snp));
-                                }
-                                all_snapshots.value = std::move(snapshot);
-                                return f.then([&s, &all_snapshots] {
-                                    return all_snapshots.write(s);
+void set_snapshot(http_context& ctx, routes& r) {
+    ss::get_snapshot_details.set(r, [](std::unique_ptr<request> req) {
+        std::function<future<>(output_stream<char>&&)> f = [](output_stream<char>&& s) {
+            return do_with(output_stream<char>(std::move(s)), true, [] (output_stream<char>& s, bool& first){
+                return s.write("[").then([&s, &first] {
+                    return service::get_local_storage_service().get_snapshot_details().then([&s, &first] (std::unordered_map<sstring, std::vector<service::storage_service::snapshot_details>>&& result) {
+                        return do_with(std::move(result), [&s, &first](const std::unordered_map<sstring, std::vector<service::storage_service::snapshot_details>>& result) {
+                            return do_for_each(result, [&s, &result,&first](std::tuple<sstring, std::vector<service::storage_service::snapshot_details>>&& map){
+                                return do_with(ss::snapshots(), [&s, &first, &result, &map](ss::snapshots& all_snapshots) {
+                                    all_snapshots.key = std::get<0>(map);
+                                    future<> f = first ? make_ready_future<>() : s.write(", ");
+                                    first = false;
+                                    std::vector<ss::snapshot> snapshot;
+                                    for (auto& cf: std::get<1>(map)) {
+                                        ss::snapshot snp;
+                                        snp.ks = cf.ks;
+                                        snp.cf = cf.cf;
+                                        snp.live = cf.live;
+                                        snp.total = cf.total;
+                                        snapshot.push_back(std::move(snp));
+                                    }
+                                    all_snapshots.value = std::move(snapshot);
+                                    return f.then([&s, &all_snapshots] {
+                                        return all_snapshots.write(s);
+                                    });
                                 });
                             });
                         });
@@ -1072,21 +998,20 @@ void set_snapshot(http_context& ctx, routes& r, sharded<db::snapshot_ctl>& snap_
                         });
                     });
                 });
-            };
-
-            return make_ready_future<json::json_return_type>(std::move(f));
-        });
+            });
+        };
+        return make_ready_future<json::json_return_type>(std::move(f));
     });
 
-    ss::take_snapshot.set(r, [&snap_ctl](std::unique_ptr<request> req) {
+    ss::take_snapshot.set(r, [](std::unique_ptr<request> req) {
         auto tag = req->get_query_param("tag");
-        auto column_families = split(req->get_query_param("cf"), ",");
+        auto column_family = req->get_query_param("cf");
 
         std::vector<sstring> keynames = split(req->get_query_param("kn"), ",");
 
         auto resp = make_ready_future<>();
-        if (column_families.empty()) {
-            resp = snap_ctl.local().take_snapshot(tag, keynames);
+        if (column_family.empty()) {
+            resp = service::get_local_storage_service().take_snapshot(tag, keynames);
         } else {
             if (keynames.empty()) {
                 throw httpd::bad_param_exception("The keyspace of column families must be specified");
@@ -1094,37 +1019,37 @@ void set_snapshot(http_context& ctx, routes& r, sharded<db::snapshot_ctl>& snap_
             if (keynames.size() > 1) {
                 throw httpd::bad_param_exception("Only one keyspace allowed when specifying a column family");
             }
-            resp = snap_ctl.local().take_column_family_snapshot(keynames[0], column_families, tag);
+            resp = service::get_local_storage_service().take_column_family_snapshot(keynames[0], column_family, tag);
         }
         return resp.then([] {
             return make_ready_future<json::json_return_type>(json_void());
         });
     });
 
-    ss::del_snapshot.set(r, [&snap_ctl](std::unique_ptr<request> req) {
+    ss::del_snapshot.set(r, [](std::unique_ptr<request> req) {
         auto tag = req->get_query_param("tag");
         auto column_family = req->get_query_param("cf");
 
         std::vector<sstring> keynames = split(req->get_query_param("kn"), ",");
-        return snap_ctl.local().clear_snapshot(tag, keynames, column_family).then([] {
+        return service::get_local_storage_service().clear_snapshot(tag, keynames, column_family).then([] {
             return make_ready_future<json::json_return_type>(json_void());
         });
     });
 
-    ss::true_snapshots_size.set(r, [&snap_ctl](std::unique_ptr<request> req) {
-        return snap_ctl.local().true_snapshots_size().then([] (int64_t size) {
+    ss::true_snapshots_size.set(r, [](std::unique_ptr<request> req) {
+        return service::get_local_storage_service().true_snapshots_size().then([] (int64_t size) {
             return make_ready_future<json::json_return_type>(size);
         });
     });
 
-    ss::scrub.set(r, wrap_ks_cf(ctx, [&snap_ctl] (http_context& ctx, std::unique_ptr<request> req, sstring keyspace, std::vector<sstring> column_families) {
+    ss::scrub.set(r, wrap_ks_cf(ctx, [] (http_context& ctx, std::unique_ptr<request> req, sstring keyspace, std::vector<sstring> column_families) {
         const auto skip_corrupted = req_param<bool>(*req, "skip_corrupted", false);
 
         auto f = make_ready_future<>();
         if (!req_param<bool>(*req, "disable_snapshot", false)) {
             auto tag = format("pre-scrub-{:d}", db_clock::now().time_since_epoch().count());
-            f = parallel_for_each(column_families, [&snap_ctl, keyspace, tag](sstring cf) {
-                return snap_ctl.local().take_column_family_snapshot(keyspace, cf, tag);
+            f = parallel_for_each(column_families, [keyspace, tag](sstring cf) {
+                return service::get_local_storage_service().take_column_family_snapshot(keyspace, cf, tag);
             });
         }
 
@@ -1142,12 +1067,4 @@ void set_snapshot(http_context& ctx, routes& r, sharded<db::snapshot_ctl>& snap_
     }));
 }
 
-void unset_snapshot(http_context& ctx, routes& r) {
-    ss::get_snapshot_details.unset(r);
-    ss::take_snapshot.unset(r);
-    ss::del_snapshot.unset(r);
-    ss::true_snapshots_size.unset(r);
-    ss::scrub.unset(r);
-}
-
 }

api/storage_service.hh

@@ -21,24 +21,11 @@
 
 #pragma once
 
-#include <seastar/core/sharded.hh>
 #include "api.hh"
 
-namespace cql_transport { class controller; }
-class thrift_controller;
-namespace db { class snapshot_ctl; }
-namespace netw { class messaging_service; }
-
 namespace api {
 
 void set_storage_service(http_context& ctx, routes& r);
-void set_repair(http_context& ctx, routes& r, sharded<netw::messaging_service>& ms);
-void unset_repair(http_context& ctx, routes& r);
-void set_transport_controller(http_context& ctx, routes& r, cql_transport::controller& ctl);
-void unset_transport_controller(http_context& ctx, routes& r);
-void set_rpc_controller(http_context& ctx, routes& r, thrift_controller& ctl);
-void unset_rpc_controller(http_context& ctx, routes& r);
-void set_snapshot(http_context& ctx, routes& r, sharded<db::snapshot_ctl>& snap_ctl);
-void unset_snapshot(http_context& ctx, routes& r);
+void set_snapshot(http_context& ctx, routes& r);
 
 }

atomic_cell.cc

@@ -208,7 +208,7 @@ size_t atomic_cell_or_collection::external_memory_usage(const abstract_type& t)
             external_value_size = cell_view.value_size();
         }
         // Add overhead of chunk headers. The last one is a special case.
-        external_value_size += (external_value_size - 1) / data::cell::effective_external_chunk_length * data::cell::external_chunk_overhead;
+        external_value_size += (external_value_size - 1) / data::cell::maximum_external_chunk_length * data::cell::external_chunk_overhead;
         external_value_size += data::cell::external_last_chunk_overhead;
     }
     return data::cell::structure::serialized_object_size(_data.get(), ctx)

atomic_cell.hh

@@ -29,6 +29,7 @@
 #include <seastar/net//byteorder.hh>
 #include <cstdint>
 #include <iosfwd>
+#include <seastar/util/gcc6-concepts.hh>
 #include "data/cell.hh"
 #include "data/schema_info.hh"
 #include "imr/utils.hh"
@@ -38,7 +39,6 @@
 
 class abstract_type;
 class collection_type_impl;
-class atomic_cell_or_collection;
 
 using atomic_cell_value_view = data::value_view;
 using atomic_cell_value_mutable_view = data::value_mutable_view;

auth/allow_all_authenticator.cc

@@ -26,7 +26,10 @@
 
 namespace auth {
 
-constexpr std::string_view allow_all_authenticator_name("org.apache.cassandra.auth.AllowAllAuthenticator");
+const sstring& allow_all_authenticator_name() {
+    static const sstring name = meta::AUTH_PACKAGE_NAME + "AllowAllAuthenticator";
+    return name;
+}
 
 // To ensure correct initialization order, we unfortunately need to use a string literal.
 static const class_registrator<

auth/allow_all_authenticator.hh

@@ -37,7 +37,7 @@ class migration_manager;
 
 namespace auth {
 
-extern const std::string_view allow_all_authenticator_name;
+const sstring& allow_all_authenticator_name();
 
 class allow_all_authenticator final : public authenticator {
 public:
@@ -53,7 +53,7 @@ public:
     }
 
     virtual std::string_view qualified_java_name() const override {
-        return allow_all_authenticator_name;
+        return allow_all_authenticator_name();
     }
 
     virtual bool require_authentication() const override {

auth/allow_all_authorizer.cc

@@ -26,7 +26,10 @@
 
 namespace auth {
 
-constexpr std::string_view allow_all_authorizer_name("org.apache.cassandra.auth.AllowAllAuthorizer");
+const sstring& allow_all_authorizer_name() {
+    static const sstring name = meta::AUTH_PACKAGE_NAME + "AllowAllAuthorizer";
+    return name;
+}
 
 // To ensure correct initialization order, we unfortunately need to use a string literal.
 static const class_registrator<

auth/allow_all_authorizer.hh

@@ -34,7 +34,7 @@ class migration_manager;
 
 namespace auth {
 
-extern const std::string_view allow_all_authorizer_name;
+const sstring& allow_all_authorizer_name();
 
 class allow_all_authorizer final  : public authorizer {
 public:
@@ -50,7 +50,7 @@ public:
     }
 
     virtual std::string_view qualified_java_name() const override {
-        return allow_all_authorizer_name;
+        return allow_all_authorizer_name();
     }
 
     virtual future<permission_set> authorize(const role_or_anonymous&, const resource&) const override {

auth/common.cc

@@ -34,9 +34,10 @@ namespace auth {
 
 namespace meta {
 
-constexpr std::string_view AUTH_KS("system_auth");
-constexpr std::string_view USERS_CF("users");
-constexpr std::string_view AUTH_PACKAGE_NAME("org.apache.cassandra.auth.");
+const sstring DEFAULT_SUPERUSER_NAME("cassandra");
+const sstring AUTH_KS("system_auth");
+const sstring USERS_CF("users");
+const sstring AUTH_PACKAGE_NAME("org.apache.cassandra.auth.");
 
 }
 
@@ -109,12 +110,7 @@ future<> wait_for_schema_agreement(::service::migration_manager& mm, const datab
 }
 
 const timeout_config& internal_distributed_timeout_config() noexcept {
-#ifdef DEBUG
-    // Give the much slower debug tests more headroom for completing auth queries.
-    static const auto t = 30s;
-#else
     static const auto t = 5s;
-#endif
     static const timeout_config tc{t, t, t, t, t, t, t};
     return tc;
 }

auth/common.hh

@@ -53,10 +53,10 @@ namespace auth {
 
 namespace meta {
 
-constexpr std::string_view DEFAULT_SUPERUSER_NAME("cassandra");
-extern const std::string_view AUTH_KS;
-extern const std::string_view USERS_CF;
-extern const std::string_view AUTH_PACKAGE_NAME;
+extern const sstring DEFAULT_SUPERUSER_NAME;
+extern const sstring AUTH_KS;
+extern const sstring USERS_CF;
+extern const sstring AUTH_PACKAGE_NAME;
 
 }
 

auth/default_authorizer.cc

@@ -65,14 +65,15 @@ extern "C" {
 
 namespace auth {
 
-std::string_view default_authorizer::qualified_java_name() const {
-    return "org.apache.cassandra.auth.CassandraAuthorizer";
+const sstring& default_authorizer_name() {
+    static const sstring name = meta::AUTH_PACKAGE_NAME + "CassandraAuthorizer";
+    return name;
 }
 
-static constexpr std::string_view ROLE_NAME = "role";
-static constexpr std::string_view RESOURCE_NAME = "resource";
-static constexpr std::string_view PERMISSIONS_NAME = "permissions";
-static constexpr std::string_view PERMISSIONS_CF = "role_permissions";
+static const sstring ROLE_NAME = "role";
+static const sstring RESOURCE_NAME = "resource";
+static const sstring PERMISSIONS_NAME = "permissions";
+static const sstring PERMISSIONS_CF = "role_permissions";
 
 static logging::logger alogger("default_authorizer");
 

auth/default_authorizer.hh

@@ -51,6 +51,8 @@
 
 namespace auth {
 
+const sstring& default_authorizer_name();
+
 class default_authorizer : public authorizer {
     cql3::query_processor& _qp;
 
@@ -69,7 +71,9 @@ public:
 
     virtual future<> stop() override;
 
-    virtual std::string_view qualified_java_name() const override;
+    virtual std::string_view qualified_java_name() const override {
+        return default_authorizer_name();
+    }
 
     virtual future<permission_set> authorize(const role_or_anonymous&, const resource&) const override;
 

auth/password_authenticator.cc

@@ -62,12 +62,15 @@
 
 namespace auth {
 
-constexpr std::string_view password_authenticator_name("org.apache.cassandra.auth.PasswordAuthenticator");
+const sstring& password_authenticator_name() {
+    static const sstring name = meta::AUTH_PACKAGE_NAME + "PasswordAuthenticator";
+    return name;
+}
 
 // name of the hash column.
-static constexpr std::string_view SALTED_HASH = "salted_hash";
-static constexpr std::string_view DEFAULT_USER_NAME = meta::DEFAULT_SUPERUSER_NAME;
-static const sstring DEFAULT_USER_PASSWORD = sstring(meta::DEFAULT_SUPERUSER_NAME);
+static const sstring SALTED_HASH = "salted_hash";
+static const sstring DEFAULT_USER_NAME = meta::DEFAULT_SUPERUSER_NAME;
+static const sstring DEFAULT_USER_PASSWORD = meta::DEFAULT_SUPERUSER_NAME;
 
 static logging::logger plogger("password_authenticator");
 
@@ -95,7 +98,7 @@ static bool has_salted_hash(const cql3::untyped_result_set_row& row) {
 
 static const sstring& update_row_query() {
     static const sstring update_row_query = format("UPDATE {} SET {} = ? WHERE {} = ?",
-            meta::roles_table::qualified_name,
+            meta::roles_table::qualified_name(),
             SALTED_HASH,
             meta::roles_table::role_col_name);
     return update_row_query;
@@ -195,7 +198,7 @@ db::consistency_level password_authenticator::consistency_for_user(std::string_v
 }
 
 std::string_view password_authenticator::qualified_java_name() const {
-    return password_authenticator_name;
+    return password_authenticator_name();
 }
 
 bool password_authenticator::require_authentication() const {
@@ -212,10 +215,10 @@ authentication_option_set password_authenticator::alterable_options() const {
 
 future<authenticated_user> password_authenticator::authenticate(
                 const credentials_map& credentials) const {
-    if (!credentials.contains(USERNAME_KEY)) {
+    if (!credentials.count(USERNAME_KEY)) {
         throw exceptions::authentication_exception(format("Required key '{}' is missing", USERNAME_KEY));
     }
-    if (!credentials.contains(PASSWORD_KEY)) {
+    if (!credentials.count(PASSWORD_KEY)) {
         throw exceptions::authentication_exception(format("Required key '{}' is missing", PASSWORD_KEY));
     }
 
@@ -230,7 +233,7 @@ future<authenticated_user> password_authenticator::authenticate(
     return futurize_invoke([this, username, password] {
         static const sstring query = format("SELECT {} FROM {} WHERE {} = ?",
                 SALTED_HASH,
-                meta::roles_table::qualified_name,
+                meta::roles_table::qualified_name(),
                 meta::roles_table::role_col_name);
 
         return _qp.execute_internal(
@@ -280,7 +283,7 @@ future<> password_authenticator::alter(std::string_view role_name, const authent
     }
 
     static const sstring query = format("UPDATE {} SET {} = ? WHERE {} = ?",
-            meta::roles_table::qualified_name,
+            meta::roles_table::qualified_name(),
             SALTED_HASH,
             meta::roles_table::role_col_name);
 
@@ -294,7 +297,7 @@ future<> password_authenticator::alter(std::string_view role_name, const authent
 future<> password_authenticator::drop(std::string_view name) const {
     static const sstring query = format("DELETE {} FROM {} WHERE {} = ?",
             SALTED_HASH,
-            meta::roles_table::qualified_name,
+            meta::roles_table::qualified_name(),
             meta::roles_table::role_col_name);
 
     return _qp.execute_internal(

auth/password_authenticator.hh

@@ -52,7 +52,7 @@ class migration_manager;
 
 namespace auth {
 
-extern const std::string_view password_authenticator_name;
+const sstring& password_authenticator_name();
 
 class password_authenticator : public authenticator {
     cql3::query_processor& _qp;

auth/roles-metadata.cc

@@ -45,13 +45,16 @@ std::string_view creation_query() {
             "  member_of set<text>,"
             "  salted_hash text"
             ")",
-            qualified_name,
+            qualified_name(),
             role_col_name);
 
     return instance;
 }
 
-constexpr std::string_view qualified_name("system_auth.roles");
+std::string_view qualified_name() noexcept {
+    static const sstring instance = AUTH_KS + "." + sstring(name);
+    return instance;
+}
 
 }
 
@@ -61,7 +64,7 @@ future<bool> default_role_row_satisfies(
         cql3::query_processor& qp,
         std::function<bool(const cql3::untyped_result_set_row&)> p) {
     static const sstring query = format("SELECT * FROM {} WHERE {} = ?",
-            meta::roles_table::qualified_name,
+            meta::roles_table::qualified_name(),
             meta::roles_table::role_col_name);
 
     return do_with(std::move(p), [&qp](const auto& p) {
@@ -94,7 +97,7 @@ future<bool> default_role_row_satisfies(
 future<bool> any_nondefault_role_row_satisfies(
         cql3::query_processor& qp,
         std::function<bool(const cql3::untyped_result_set_row&)> p) {
-    static const sstring query = format("SELECT * FROM {}", meta::roles_table::qualified_name);
+    static const sstring query = format("SELECT * FROM {}", meta::roles_table::qualified_name());
 
     return do_with(std::move(p), [&qp](const auto& p) {
         return qp.execute_internal(

auth/roles-metadata.hh

@@ -43,7 +43,7 @@ std::string_view creation_query();
 
 constexpr std::string_view name{"roles", 5};
 
-extern const std::string_view qualified_name;
+std::string_view qualified_name() noexcept;
 
 constexpr std::string_view role_col_name{"role", 4};
 

auth/service.cc

@@ -31,7 +31,9 @@
 #include "auth/allow_all_authenticator.hh"
 #include "auth/allow_all_authorizer.hh"
 #include "auth/common.hh"
+#include "auth/password_authenticator.hh"
 #include "auth/role_or_anonymous.hh"
+#include "auth/standard_role_manager.hh"
 #include "cql3/query_processor.hh"
 #include "cql3/untyped_result_set.hh"
 #include "db/consistency_level_type.hh"
@@ -123,7 +125,18 @@ service::service(
             , _authorizer(std::move(z))
             , _authenticator(std::move(a))
             , _role_manager(std::move(r))
-            , _migration_listener(std::make_unique<auth_migration_listener>(*_authorizer)) {}
+            , _migration_listener(std::make_unique<auth_migration_listener>(*_authorizer)) {
+    // The password authenticator requires that the `standard_role_manager` is running so that the roles metadata table
+    // it manages is created and updated. This cross-module dependency is rather gross, but we have to maintain it for
+    // the sake of compatibility with Apache Cassandra and its choice of auth. schema.
+    if ((_authenticator->qualified_java_name() == password_authenticator_name())
+            && (_role_manager->qualified_java_name() != standard_role_manager_name())) {
+        throw incompatible_module_combination(
+                format("The {} authenticator must be loaded alongside the {} role-manager.",
+                        password_authenticator_name(),
+                        standard_role_manager_name()));
+    }
+}
 
 service::service(
         permissions_cache_config c,
@@ -165,7 +178,7 @@ future<> service::start(::service::migration_manager& mm) {
         return create_keyspace_if_missing(mm);
     }).then([this] {
         return _role_manager->start().then([this] {
-            return when_all_succeed(_authorizer->start(), _authenticator->start()).discard_result();
+            return when_all_succeed(_authorizer->start(), _authenticator->start());
         });
     }).then([this] {
         _permissions_cache = std::make_unique<permissions_cache>(_permissions_cache_config, *this, log);
@@ -186,7 +199,7 @@ future<> service::stop() {
         }
         return make_ready_future<>();
     }).then([this] {
-        return when_all_succeed(_role_manager->stop(), _authorizer->stop(), _authenticator->stop()).discard_result();
+        return when_all_succeed(_role_manager->stop(), _authorizer->stop(), _authenticator->stop());
     });
 }
 
@@ -363,25 +376,25 @@ future<permission_set> get_permissions(const service& ser, const authenticated_u
 }
 
 bool is_enforcing(const service& ser)  {
-    const bool enforcing_authorizer = ser.underlying_authorizer().qualified_java_name() != allow_all_authorizer_name;
+    const bool enforcing_authorizer = ser.underlying_authorizer().qualified_java_name() != allow_all_authorizer_name();
 
     const bool enforcing_authenticator = ser.underlying_authenticator().qualified_java_name()
-            != allow_all_authenticator_name;
+            != allow_all_authenticator_name();
 
     return enforcing_authorizer || enforcing_authenticator;
 }
 
 bool is_protected(const service& ser, const resource& r) noexcept {
-    return ser.underlying_role_manager().protected_resources().contains(r)
-            || ser.underlying_authenticator().protected_resources().contains(r)
-            || ser.underlying_authorizer().protected_resources().contains(r);
+    return ser.underlying_role_manager().protected_resources().count(r)
+            || ser.underlying_authenticator().protected_resources().count(r)
+            || ser.underlying_authorizer().protected_resources().count(r);
 }
 
 static void validate_authentication_options_are_supported(
         const authentication_options& options,
         const authentication_option_set& supported) {
     const auto check = [&supported](authentication_option k) {
-        if (!supported.contains(k)) {
+        if (supported.count(k) == 0) {
             throw unsupported_authentication_option(k);
         }
     };
@@ -445,9 +458,7 @@ future<> drop_role(const service& ser, std::string_view name) {
 
         return when_all_succeed(
                 a.revoke_all(name),
-                a.revoke_all(r))
-                    .discard_result()
-                    .handle_exception_type([](const unsupported_authorization_operation&) {
+                a.revoke_all(r)).handle_exception_type([](const unsupported_authorization_operation&) {
             // Nothing.
         });
     }).then([&ser, name] {
@@ -460,8 +471,8 @@ future<> drop_role(const service& ser, std::string_view name) {
 future<bool> has_role(const service& ser, std::string_view grantee, std::string_view name) {
     return when_all_succeed(
             validate_role_exists(ser, name),
-            ser.get_roles(grantee)).then_unpack([name](role_set all_roles) {
-        return make_ready_future<bool>(all_roles.contains(sstring(name)));
+            ser.get_roles(grantee)).then([name](role_set all_roles) {
+        return make_ready_future<bool>(all_roles.count(sstring(name)) != 0);
     });
 }
 future<bool> has_role(const service& ser, const authenticated_user& u, std::string_view name) {
@@ -518,9 +529,14 @@ future<std::vector<permission_details>> list_filtered_permissions(
                     ? auth::expand_resource_family(r)
                     : auth::resource_set{r};
 
-            std::erase_if(all_details, [&resources](const permission_details& pd) {
-                return !resources.contains(pd.resource);
-            });
+            all_details.erase(
+                    std::remove_if(
+                            all_details.begin(),
+                            all_details.end(),
+                            [&resources](const permission_details& pd) {
+                        return resources.count(pd.resource) == 0;
+                    }),
+                    all_details.end());
         }
 
         std::transform(
@@ -533,9 +549,11 @@ future<std::vector<permission_details>> list_filtered_permissions(
                 });
 
         // Eliminate rows with an empty permission set.
-        std::erase_if(all_details, [](const permission_details& pd) {
-            return pd.permissions.mask() == 0;
-        });
+        all_details.erase(
+                std::remove_if(all_details.begin(), all_details.end(), [](const permission_details& pd) {
+                    return pd.permissions.mask() == 0;
+                }),
+                all_details.end());
 
         if (!role_name) {
             return make_ready_future<std::vector<permission_details>>(std::move(all_details));
@@ -547,9 +565,14 @@ future<std::vector<permission_details>> list_filtered_permissions(
 
         return do_with(std::move(all_details), [&ser, role_name](auto& all_details) {
             return ser.get_roles(*role_name).then([&all_details](role_set all_roles) {
-                std::erase_if(all_details, [&all_roles](const permission_details& pd) {
-                    return !all_roles.contains(pd.role_name);
-                });
+                all_details.erase(
+                        std::remove_if(
+                                all_details.begin(),
+                                all_details.end(),
+                                [&all_roles](const permission_details& pd) {
+                            return all_roles.count(pd.role_name) == 0;
+                        }),
+                        all_details.end());
 
                 return make_ready_future<std::vector<permission_details>>(std::move(all_details));
             });

auth/standard_role_manager.cc

@@ -49,7 +49,11 @@ namespace meta {
 namespace role_members_table {
 
 constexpr std::string_view name{"role_members" , 12};
-constexpr std::string_view qualified_name("system_auth.role_members");
+
+static std::string_view qualified_name() noexcept {
+    static const sstring instance = AUTH_KS + "." + sstring(name);
+    return instance;
+}
 
 }
 
@@ -80,7 +84,7 @@ static db::consistency_level consistency_for_role(std::string_view role_name) no
 
 static future<std::optional<record>> find_record(cql3::query_processor& qp, std::string_view role_name) {
     static const sstring query = format("SELECT * FROM {} WHERE {} = ?",
-            meta::roles_table::qualified_name,
+            meta::roles_table::qualified_name(),
             meta::roles_table::role_col_name);
 
     return qp.execute_internal(
@@ -120,8 +124,13 @@ static bool has_can_login(const cql3::untyped_result_set_row& row) {
     return row.has("can_login") && !(boolean_type->deserialize(row.get_blob("can_login")).is_null());
 }
 
+std::string_view standard_role_manager_name() noexcept {
+    static const sstring instance = meta::AUTH_PACKAGE_NAME + "CassandraRoleManager";
+    return instance;
+}
+
 std::string_view standard_role_manager::qualified_java_name() const noexcept {
-    return "org.apache.cassandra.auth.CassandraRoleManager";
+    return standard_role_manager_name();
 }
 
 const resource_set& standard_role_manager::protected_resources() const {
@@ -139,7 +148,7 @@ future<> standard_role_manager::create_metadata_tables_if_missing() const {
             "  member text,"
             "  PRIMARY KEY (role, member)"
             ")",
-            meta::role_members_table::qualified_name);
+            meta::role_members_table::qualified_name());
 
 
     return when_all_succeed(
@@ -152,14 +161,14 @@ future<> standard_role_manager::create_metadata_tables_if_missing() const {
                     meta::role_members_table::name,
                     _qp,
                     create_role_members_query,
-                    _migration_manager)).discard_result();
+                    _migration_manager));
 }
 
 future<> standard_role_manager::create_default_role_if_missing() const {
     return default_role_row_satisfies(_qp, &has_can_login).then([this](bool exists) {
         if (!exists) {
             static const sstring query = format("INSERT INTO {} ({}, is_superuser, can_login) VALUES (?, true, true)",
-                    meta::roles_table::qualified_name,
+                    meta::roles_table::qualified_name(),
                     meta::roles_table::role_col_name);
 
             return _qp.execute_internal(
@@ -247,7 +256,7 @@ future<> standard_role_manager::stop() {
 
 future<> standard_role_manager::create_or_replace(std::string_view role_name, const role_config& c) const {
     static const sstring query = format("INSERT INTO {} ({}, is_superuser, can_login) VALUES (?, ?, ?)",
-            meta::roles_table::qualified_name,
+            meta::roles_table::qualified_name(),
             meta::roles_table::role_col_name);
 
     return _qp.execute_internal(
@@ -292,7 +301,7 @@ standard_role_manager::alter(std::string_view role_name, const role_config_updat
 
         return _qp.execute_internal(
                 format("UPDATE {} SET {} WHERE {} = ?",
-                        meta::roles_table::qualified_name,
+                        meta::roles_table::qualified_name(),
                         build_column_assignments(u),
                         meta::roles_table::role_col_name),
                 consistency_for_role(role_name),
@@ -310,7 +319,7 @@ future<> standard_role_manager::drop(std::string_view role_name) const {
         // First, revoke this role from all roles that are members of it.
         const auto revoke_from_members = [this, role_name] {
             static const sstring query = format("SELECT member FROM {} WHERE role = ?",
-                    meta::role_members_table::qualified_name);
+                    meta::role_members_table::qualified_name());
 
             return _qp.execute_internal(
                     query,
@@ -348,7 +357,7 @@ future<> standard_role_manager::drop(std::string_view role_name) const {
         // Finally, delete the role itself.
         auto delete_role = [this, role_name] {
             static const sstring query = format("DELETE FROM {} WHERE {} = ?",
-                    meta::roles_table::qualified_name,
+                    meta::roles_table::qualified_name(),
                     meta::roles_table::role_col_name);
 
             return _qp.execute_internal(
@@ -358,7 +367,7 @@ future<> standard_role_manager::drop(std::string_view role_name) const {
                     {sstring(role_name)}).discard_result();
         };
 
-        return when_all_succeed(revoke_from_members(), revoke_members_of()).then_unpack([delete_role = std::move(delete_role)] {
+        return when_all_succeed(revoke_from_members(), revoke_members_of()).then([delete_role = std::move(delete_role)] {
             return delete_role();
         });
     });
@@ -374,7 +383,7 @@ standard_role_manager::modify_membership(
     const auto modify_roles = [this, role_name, grantee_name, ch] {
         const auto query = format(
                 "UPDATE {} SET member_of = member_of {} ? WHERE {} = ?",
-                meta::roles_table::qualified_name,
+                meta::roles_table::qualified_name(),
                 (ch == membership_change::add ? '+' : '-'),
                 meta::roles_table::role_col_name);
 
@@ -390,7 +399,7 @@ standard_role_manager::modify_membership(
             case membership_change::add:
                 return _qp.execute_internal(
                         format("INSERT INTO {} (role, member) VALUES (?, ?)",
-                                meta::role_members_table::qualified_name),
+                                meta::role_members_table::qualified_name()),
                         consistency_for_role(role_name),
                         internal_distributed_timeout_config(),
                         {sstring(role_name), sstring(grantee_name)}).discard_result();
@@ -398,7 +407,7 @@ standard_role_manager::modify_membership(
             case membership_change::remove:
                 return _qp.execute_internal(
                         format("DELETE FROM {} WHERE role = ? AND member = ?",
-                                meta::role_members_table::qualified_name),
+                                meta::role_members_table::qualified_name()),
                         consistency_for_role(role_name),
                         internal_distributed_timeout_config(),
                         {sstring(role_name), sstring(grantee_name)}).discard_result();
@@ -407,7 +416,7 @@ standard_role_manager::modify_membership(
         return make_ready_future<>();
     };
 
-    return when_all_succeed(modify_roles(), modify_role_members).discard_result();
+    return when_all_succeed(modify_roles(), modify_role_members());
 }
 
 future<>
@@ -416,7 +425,7 @@ standard_role_manager::grant(std::string_view grantee_name, std::string_view rol
         return this->query_granted(
                 grantee_name,
                 recursive_role_query::yes).then([role_name, grantee_name](role_set roles) {
-            if (roles.contains(sstring(role_name))) {
+            if (roles.count(sstring(role_name)) != 0) {
                 throw role_already_included(grantee_name, role_name);
             }
 
@@ -428,7 +437,7 @@ standard_role_manager::grant(std::string_view grantee_name, std::string_view rol
         return this->query_granted(
                 role_name,
                 recursive_role_query::yes).then([role_name, grantee_name](role_set roles) {
-            if (roles.contains(sstring(grantee_name))) {
+            if (roles.count(sstring(grantee_name)) != 0) {
                 throw role_already_included(role_name, grantee_name);
             }
 
@@ -436,7 +445,7 @@ standard_role_manager::grant(std::string_view grantee_name, std::string_view rol
         });
     };
 
-   return when_all_succeed(check_redundant(), check_cycle()).then_unpack([this, role_name, grantee_name] {
+   return when_all_succeed(check_redundant(), check_cycle()).then([this, role_name, grantee_name] {
        return this->modify_membership(grantee_name, role_name, membership_change::add);
    });
 }
@@ -451,7 +460,7 @@ standard_role_manager::revoke(std::string_view revokee_name, std::string_view ro
         return this->query_granted(
                 revokee_name,
                 recursive_role_query::no).then([revokee_name, role_name](role_set roles) {
-            if (!roles.contains(sstring(role_name))) {
+            if (roles.count(sstring(role_name)) == 0) {
                 throw revoke_ungranted_role(revokee_name, role_name);
             }
 
@@ -495,7 +504,7 @@ future<role_set> standard_role_manager::query_granted(std::string_view grantee_n
 future<role_set> standard_role_manager::query_all() const {
     static const sstring query = format("SELECT {} FROM {}",
             meta::roles_table::role_col_name,
-            meta::roles_table::qualified_name);
+            meta::roles_table::qualified_name());
 
     // To avoid many copies of a view.
     static const auto role_col_name_string = sstring(meta::roles_table::role_col_name);

auth/standard_role_manager.hh

@@ -42,6 +42,8 @@ class migration_manager;
 
 namespace auth {
 
+std::string_view standard_role_manager_name() noexcept;
+
 class standard_role_manager final : public role_manager {
     cql3::query_processor& _qp;
     ::service::migration_manager& _migration_manager;

auth/transitional.cc

@@ -101,7 +101,7 @@ public:
     virtual future<authenticated_user> authenticate(const credentials_map& credentials) const override {
         auto i = credentials.find(authenticator::USERNAME_KEY);
         if ((i == credentials.end() || i->second.empty())
-                && (!credentials.contains(PASSWORD_KEY) || credentials.at(PASSWORD_KEY).empty())) {
+                && (!credentials.count(PASSWORD_KEY) || credentials.at(PASSWORD_KEY).empty())) {
             // return anon user
             return make_ready_future<authenticated_user>(anonymous_user());
         }

build_id.cc

@@ -20,7 +20,7 @@ static const Elf64_Nhdr* get_nt_build_id(dl_phdr_info* info) {
             continue;
         }
 
-        auto* p = reinterpret_cast<const char*>(base + h->p_vaddr);
+        auto* p = reinterpret_cast<const char*>(base) + h->p_vaddr;
         auto* e = p + h->p_memsz;
         while (p != e) {
             const auto* n = reinterpret_cast<const Elf64_Nhdr*>(p);
@@ -49,17 +49,16 @@ static int callback(dl_phdr_info* info, size_t size, void* data) {
     assert(strlen(info->dlpi_name) == 0);
 
     auto* n = get_nt_build_id(info);
-    auto* p = reinterpret_cast<const unsigned char*>(n);
+    auto* p = reinterpret_cast<const char*>(n);
 
     p += sizeof(Elf64_Nhdr);
 
     p += n->n_namesz;
     p = align_up(p, 4);
 
-    auto* desc = p;
-    auto* desc_end = p + n->n_descsz;
-    while (desc < desc_end) {
-        fmt::fprintf(os, "%02x", *desc++);
+    const char* desc = p;
+    for (unsigned i = 0; i < n->n_descsz; ++i) {
+        fmt::fprintf(os, "%02x", (unsigned char)*(desc + i));
     }
     ret = os.str();
     return 1;

bytes.cc

@@ -100,7 +100,3 @@ std::ostream& operator<<(std::ostream& os, const bytes_view& b) {
 }
 
 }
-
-std::ostream& operator<<(std::ostream& os, const fmt_hex& b) {
-    return os << to_hex(b.v);
-}

bytes.hh

@@ -39,10 +39,6 @@ inline sstring_view to_sstring_view(bytes_view view) {
     return {reinterpret_cast<const char*>(view.data()), view.size()};
 }
 
-inline bytes_view to_bytes_view(sstring_view view) {
-    return {reinterpret_cast<const int8_t*>(view.data()), view.size()};
-}
-
 namespace std {
 
 template <>
@@ -54,13 +50,6 @@ struct hash<bytes_view> {
 
 }
 
-struct fmt_hex {
-    bytes_view& v;
-    fmt_hex(bytes_view& v) noexcept : v(v) {}
-};
-
-std::ostream& operator<<(std::ostream& os, const fmt_hex& hex);
-
 bytes from_hex(sstring_view s);
 sstring to_hex(bytes_view b);
 sstring to_hex(const bytes& b);
@@ -95,12 +84,9 @@ struct appending_hash<bytes_view> {
 };
 
 inline int32_t compare_unsigned(bytes_view v1, bytes_view v2) {
-  auto size = std::min(v1.size(), v2.size());
-  if (size) {
-    auto n = memcmp(v1.begin(), v2.begin(), size);
+    auto n = memcmp(v1.begin(), v2.begin(), std::min(v1.size(), v2.size()));
     if (n) {
         return n;
     }
-  }
     return (int32_t) (v1.size() - v2.size());
 }

cache_flat_mutation_reader.hh

@@ -28,6 +28,7 @@
 #include "partition_version.hh"
 #include "utils/logalloc.hh"
 #include "query-request.hh"
+#include "partition_snapshot_reader.hh"
 #include "partition_snapshot_row_cursor.hh"
 #include "read_context.hh"
 #include "flat_mutation_reader.hh"
@@ -133,7 +134,7 @@ class cache_flat_mutation_reader final : public flat_mutation_reader::impl {
     void maybe_add_to_cache(const static_row& sr);
     void maybe_set_static_row_continuous();
     void finish_reader() {
-        push_mutation_fragment(*_schema, _permit, partition_end());
+        push_mutation_fragment(partition_end());
         _end_of_stream = true;
         _state = state::end_of_stream;
     }
@@ -145,7 +146,7 @@ public:
                                lw_shared_ptr<read_context> ctx,
                                partition_snapshot_ptr snp,
                                row_cache& cache)
-        : flat_mutation_reader::impl(std::move(s), ctx->permit())
+        : flat_mutation_reader::impl(std::move(s))
         , _snp(std::move(snp))
         , _position_cmp(*_schema)
         , _ck_ranges(std::move(crr))
@@ -157,8 +158,8 @@ public:
         , _read_context(std::move(ctx))
         , _next_row(*_schema, *_snp)
     {
-        clogger.trace("csm {}: table={}.{}", fmt::ptr(this), _schema->ks_name(), _schema->cf_name());
-        push_mutation_fragment(*_schema, _permit, partition_start(std::move(dk), _snp->partition_tombstone()));
+        clogger.trace("csm {}: table={}.{}", this, _schema->ks_name(), _schema->cf_name());
+        push_mutation_fragment(partition_start(std::move(dk), _snp->partition_tombstone()));
     }
     cache_flat_mutation_reader(const cache_flat_mutation_reader&) = delete;
     cache_flat_mutation_reader(cache_flat_mutation_reader&&) = delete;
@@ -187,7 +188,7 @@ future<> cache_flat_mutation_reader::process_static_row(db::timeout_clock::time_
             return _snp->static_row(_read_context->digest_requested());
         });
         if (!sr.empty()) {
-            push_mutation_fragment(mutation_fragment(*_schema, _permit, std::move(sr)));
+            push_mutation_fragment(mutation_fragment(std::move(sr)));
         }
         return make_ready_future<>();
     } else {
@@ -231,7 +232,7 @@ future<> cache_flat_mutation_reader::fill_buffer(db::timeout_clock::time_point t
             return after_static_row();
         }
     }
-    clogger.trace("csm {}: fill_buffer(), range={}, lb={}", fmt::ptr(this), *_ck_ranges_curr, _lower_bound);
+    clogger.trace("csm {}: fill_buffer(), range={}, lb={}", this, *_ck_ranges_curr, _lower_bound);
     return do_until([this] { return _end_of_stream || is_buffer_full(); }, [this, timeout] {
         return do_fill_buffer(timeout);
     });
@@ -276,7 +277,7 @@ future<> cache_flat_mutation_reader::do_fill_buffer(db::timeout_clock::time_poin
     // assert(_state == state::reading_from_cache)
     return _lsa_manager.run_in_read_section([this] {
         auto next_valid = _next_row.iterators_valid();
-        clogger.trace("csm {}: reading_from_cache, range=[{}, {}), next={}, valid={}", fmt::ptr(this), _lower_bound,
+        clogger.trace("csm {}: reading_from_cache, range=[{}, {}), next={}, valid={}", this, _lower_bound,
             _upper_bound, _next_row.position(), next_valid);
         // We assume that if there was eviction, and thus the range may
         // no longer be continuous, the cursor was invalidated.
@@ -290,7 +291,7 @@ future<> cache_flat_mutation_reader::do_fill_buffer(db::timeout_clock::time_poin
             }
         }
         _next_row.maybe_refresh();
-        clogger.trace("csm {}: next={}, cont={}", fmt::ptr(this), _next_row.position(), _next_row.continuous());
+        clogger.trace("csm {}: next={}, cont={}", this, _next_row.position(), _next_row.continuous());
         _lower_bound_changed = false;
         while (_state == state::reading_from_cache) {
             copy_from_cache_to_buffer();
@@ -356,7 +357,7 @@ future<> cache_flat_mutation_reader::read_from_underlying(db::timeout_clock::tim
                                     e.release();
                                     auto next = std::next(it);
                                     it->set_continuous(next->continuous());
-                                    clogger.trace("csm {}: inserted dummy at {}, cont={}", fmt::ptr(this), it->position(), it->continuous());
+                                    clogger.trace("csm {}: inserted dummy at {}, cont={}", this, it->position(), it->continuous());
                                 }
                             });
                         } else if (ensure_population_lower_bound()) {
@@ -367,11 +368,11 @@ future<> cache_flat_mutation_reader::read_from_underlying(db::timeout_clock::tim
                                 auto insert_result = rows.insert_check(_next_row.get_iterator_in_latest_version(), *e, less);
                                 auto inserted = insert_result.second;
                                 if (inserted) {
-                                    clogger.trace("csm {}: inserted dummy at {}", fmt::ptr(this), _upper_bound);
+                                    clogger.trace("csm {}: inserted dummy at {}", this, _upper_bound);
                                     _snp->tracker()->insert(*e);
                                     e.release();
                                 } else {
-                                    clogger.trace("csm {}: mark {} as continuous", fmt::ptr(this), insert_result.first->position());
+                                    clogger.trace("csm {}: mark {} as continuous", this, insert_result.first->position());
                                     insert_result.first->set_continuous(true);
                                 }
                             });
@@ -412,7 +413,7 @@ bool cache_flat_mutation_reader::ensure_population_lower_bound() {
             auto insert_result = rows.insert_check(rows.end(), *e, less);
             auto inserted = insert_result.second;
             if (inserted) {
-                clogger.trace("csm {}: inserted lower bound dummy at {}", fmt::ptr(this), e->position());
+                clogger.trace("csm {}: inserted lower bound dummy at {}", this, e->position());
                 _snp->tracker()->insert(*e);
                 e.release();
             }
@@ -452,7 +453,7 @@ void cache_flat_mutation_reader::maybe_add_to_cache(const clustering_row& cr) {
         _read_context->cache().on_mispopulate();
         return;
     }
-    clogger.trace("csm {}: populate({})", fmt::ptr(this), clustering_row::printer(*_schema, cr));
+    clogger.trace("csm {}: populate({})", this, clustering_row::printer(*_schema, cr));
     _lsa_manager.run_in_update_section_with_allocator([this, &cr] {
         mutation_partition& mp = _snp->version()->partition();
         rows_entry::compare less(*_schema);
@@ -474,7 +475,7 @@ void cache_flat_mutation_reader::maybe_add_to_cache(const clustering_row& cr) {
 
         rows_entry& e = *it;
         if (ensure_population_lower_bound()) {
-            clogger.trace("csm {}: set_continuous({})", fmt::ptr(this), e.position());
+            clogger.trace("csm {}: set_continuous({})", this, e.position());
             e.set_continuous(true);
         } else {
             _read_context->cache().on_mispopulate();
@@ -493,14 +494,14 @@ bool cache_flat_mutation_reader::after_current_range(position_in_partition_view
 
 inline
 void cache_flat_mutation_reader::start_reading_from_underlying() {
-    clogger.trace("csm {}: start_reading_from_underlying(), range=[{}, {})", fmt::ptr(this), _lower_bound, _next_row_in_range ? _next_row.position() : _upper_bound);
+    clogger.trace("csm {}: start_reading_from_underlying(), range=[{}, {})", this, _lower_bound, _next_row_in_range ? _next_row.position() : _upper_bound);
     _state = state::move_to_underlying;
     _next_row.touch();
 }
 
 inline
 void cache_flat_mutation_reader::copy_from_cache_to_buffer() {
-    clogger.trace("csm {}: copy_from_cache, next={}, next_row_in_range={}", fmt::ptr(this), _next_row.position(), _next_row_in_range);
+    clogger.trace("csm {}: copy_from_cache, next={}, next_row_in_range={}", this, _next_row.position(), _next_row_in_range);
     _next_row.touch();
     position_in_partition_view next_lower_bound = _next_row.dummy() ? _next_row.position() : position_in_partition_view::after_key(_next_row.key());
     for (auto &&rts : _snp->range_tombstones(_lower_bound, _next_row_in_range ? next_lower_bound : _upper_bound)) {
@@ -516,7 +517,7 @@ void cache_flat_mutation_reader::copy_from_cache_to_buffer() {
                 return;
             }
         }
-        push_mutation_fragment(*_schema, _permit, std::move(rts));
+        push_mutation_fragment(std::move(rts));
     }
     // We add the row to the buffer even when it's full.
     // This simplifies the code. For more info see #3139.
@@ -532,7 +533,7 @@ void cache_flat_mutation_reader::copy_from_cache_to_buffer() {
 inline
 void cache_flat_mutation_reader::move_to_end() {
     finish_reader();
-    clogger.trace("csm {}: eos", fmt::ptr(this));
+    clogger.trace("csm {}: eos", this);
 }
 
 inline
@@ -557,7 +558,7 @@ void cache_flat_mutation_reader::move_to_range(query::clustering_row_ranges::con
     _ck_ranges_curr = next_it;
     auto adjacent = _next_row.advance_to(_lower_bound);
     _next_row_in_range = !after_current_range(_next_row.position());
-    clogger.trace("csm {}: move_to_range(), range={}, lb={}, ub={}, next={}", fmt::ptr(this), *_ck_ranges_curr, _lower_bound, _upper_bound, _next_row.position());
+    clogger.trace("csm {}: move_to_range(), range={}, lb={}, ub={}, next={}", this, *_ck_ranges_curr, _lower_bound, _upper_bound, _next_row.position());
     if (!adjacent && !_next_row.continuous()) {
         // FIXME: We don't insert a dummy for singular range to avoid allocating 3 entries
         // for a hit (before, at and after). If we supported the concept of an incomplete row,
@@ -567,7 +568,7 @@ void cache_flat_mutation_reader::move_to_range(query::clustering_row_ranges::con
             // Insert dummy for lower bound
             if (can_populate()) {
                 // FIXME: _lower_bound could be adjacent to the previous row, in which case we could skip this
-                clogger.trace("csm {}: insert dummy at {}", fmt::ptr(this), _lower_bound);
+                clogger.trace("csm {}: insert dummy at {}", this, _lower_bound);
                 auto it = with_allocator(_lsa_manager.region().allocator(), [&] {
                     auto& rows = _snp->version()->partition().clustered_rows();
                     auto new_entry = current_allocator().construct<rows_entry>(*_schema, _lower_bound, is_dummy::yes, is_continuous::no);
@@ -586,7 +587,7 @@ void cache_flat_mutation_reader::move_to_range(query::clustering_row_ranges::con
 // _next_row must be inside the range.
 inline
 void cache_flat_mutation_reader::move_to_next_entry() {
-    clogger.trace("csm {}: move_to_next_entry(), curr={}", fmt::ptr(this), _next_row.position());
+    clogger.trace("csm {}: move_to_next_entry(), curr={}", this, _next_row.position());
     if (no_clustering_row_between(*_schema, _next_row.position(), _upper_bound)) {
         move_to_next_range();
     } else {
@@ -595,7 +596,7 @@ void cache_flat_mutation_reader::move_to_next_entry() {
             return;
         }
         _next_row_in_range = !after_current_range(_next_row.position());
-        clogger.trace("csm {}: next={}, cont={}, in_range={}", fmt::ptr(this), _next_row.position(), _next_row.continuous(), _next_row_in_range);
+        clogger.trace("csm {}: next={}, cont={}, in_range={}", this, _next_row.position(), _next_row.continuous(), _next_row_in_range);
         if (!_next_row.continuous()) {
             start_reading_from_underlying();
         }
@@ -604,7 +605,7 @@ void cache_flat_mutation_reader::move_to_next_entry() {
 
 inline
 void cache_flat_mutation_reader::add_to_buffer(mutation_fragment&& mf) {
-    clogger.trace("csm {}: add_to_buffer({})", fmt::ptr(this), mutation_fragment::printer(*_schema, mf));
+    clogger.trace("csm {}: add_to_buffer({})", this, mutation_fragment::printer(*_schema, mf));
     if (mf.is_clustering_row()) {
         add_clustering_row_to_buffer(std::move(mf));
     } else {
@@ -617,7 +618,7 @@ inline
 void cache_flat_mutation_reader::add_to_buffer(const partition_snapshot_row_cursor& row) {
     if (!row.dummy()) {
         _read_context->cache().on_row_hit();
-        add_clustering_row_to_buffer(mutation_fragment(*_schema, _permit, row.row(_read_context->digest_requested())));
+        add_clustering_row_to_buffer(row.row(_read_context->digest_requested()));
     }
 }
 
@@ -626,7 +627,7 @@ void cache_flat_mutation_reader::add_to_buffer(const partition_snapshot_row_curs
 //   (2) If _lower_bound > mf.position(), mf was emitted
 inline
 void cache_flat_mutation_reader::add_clustering_row_to_buffer(mutation_fragment&& mf) {
-    clogger.trace("csm {}: add_clustering_row_to_buffer({})", fmt::ptr(this), mutation_fragment::printer(*_schema, mf));
+    clogger.trace("csm {}: add_clustering_row_to_buffer({})", this, mutation_fragment::printer(*_schema, mf));
     auto& row = mf.as_clustering_row();
     auto new_lower_bound = position_in_partition::after_key(row.key());
     push_mutation_fragment(std::move(mf));
@@ -636,7 +637,7 @@ void cache_flat_mutation_reader::add_clustering_row_to_buffer(mutation_fragment&
 
 inline
 void cache_flat_mutation_reader::add_to_buffer(range_tombstone&& rt) {
-    clogger.trace("csm {}: add_to_buffer({})", fmt::ptr(this), rt);
+    clogger.trace("csm {}: add_to_buffer({})", this, rt);
     // This guarantees that rt starts after any emitted clustering_row
     // and not before any emitted range tombstone.
     position_in_partition::less_compare less(*_schema);
@@ -649,13 +650,13 @@ void cache_flat_mutation_reader::add_to_buffer(range_tombstone&& rt) {
         _lower_bound = position_in_partition(rt.position());
         _lower_bound_changed = true;
     }
-    push_mutation_fragment(*_schema, _permit, std::move(rt));
+    push_mutation_fragment(std::move(rt));
 }
 
 inline
 void cache_flat_mutation_reader::maybe_add_to_cache(const range_tombstone& rt) {
     if (can_populate()) {
-        clogger.trace("csm {}: maybe_add_to_cache({})", fmt::ptr(this), rt);
+        clogger.trace("csm {}: maybe_add_to_cache({})", this, rt);
         _lsa_manager.run_in_update_section_with_allocator([&] {
             _snp->version()->partition().row_tombstones().apply_monotonically(*_schema, rt);
         });
@@ -667,7 +668,7 @@ void cache_flat_mutation_reader::maybe_add_to_cache(const range_tombstone& rt) {
 inline
 void cache_flat_mutation_reader::maybe_add_to_cache(const static_row& sr) {
     if (can_populate()) {
-        clogger.trace("csm {}: populate({})", fmt::ptr(this), static_row::printer(*_schema, sr));
+        clogger.trace("csm {}: populate({})", this, static_row::printer(*_schema, sr));
         _read_context->cache().on_static_row_insert();
         _lsa_manager.run_in_update_section_with_allocator([&] {
             if (_read_context->digest_requested()) {
@@ -683,7 +684,7 @@ void cache_flat_mutation_reader::maybe_add_to_cache(const static_row& sr) {
 inline
 void cache_flat_mutation_reader::maybe_set_static_row_continuous() {
     if (can_populate()) {
-        clogger.trace("csm {}: set static row continuous", fmt::ptr(this));
+        clogger.trace("csm {}: set static row continuous", this);
         _snp->version()->partition().set_static_row_continuous(true);
     } else {
         _read_context->cache().on_mispopulate();

caching_options.hh

@@ -23,7 +23,7 @@
 #include <seastar/core/sstring.hh>
 #include <boost/lexical_cast.hpp>
 #include "exceptions/exceptions.hh"
-#include "utils/rjson.hh"
+#include "json.hh"
 #include "seastarx.hh"
 
 class schema;
@@ -39,10 +39,7 @@ class caching_options {
 
     sstring _key_cache;
     sstring _row_cache;
-    bool _enabled = true;
-    caching_options(sstring k, sstring r, bool enabled)
-        : _key_cache(k), _row_cache(r), _enabled(enabled)
-    {
+    caching_options(sstring k, sstring r) : _key_cache(k), _row_cache(r) {
         if ((k != "ALL") && (k != "NONE")) {
             throw exceptions::configuration_exception("Invalid key value: " + k); 
         }
@@ -62,54 +59,36 @@ class caching_options {
     caching_options() : _key_cache(default_key), _row_cache(default_row) {}
 public:
 
-    bool enabled() const {
-        return _enabled;
-    }
-
     std::map<sstring, sstring> to_map() const {
-        std::map<sstring, sstring> res = {{ "keys", _key_cache },
-                { "rows_per_partition", _row_cache }};
-        if (!_enabled) {
-            res.insert({"enabled", "false"});
-        }
-        return res;
+        return {{ "keys", _key_cache }, { "rows_per_partition", _row_cache }};
     }
 
     sstring to_sstring() const {
-        return rjson::print(rjson::from_string_map(to_map()));
-    }
-
-    static caching_options get_disabled_caching_options() {
-        return caching_options("NONE", "NONE", false);
+        return json::to_json(to_map());
     }
 
     template<typename Map>
     static caching_options from_map(const Map & map) {
         sstring k = default_key;
         sstring r = default_row;
-        bool e = true;
 
         for (auto& p : map) {
             if (p.first == "keys") {
                 k = p.second;
             } else if (p.first == "rows_per_partition") {
                 r = p.second;
-            } else if (p.first == "enabled") {
-                e = p.second == "true";
             } else {
-                throw exceptions::configuration_exception(format("Invalid caching option: {}", p.first));
+                throw exceptions::configuration_exception("Invalid caching option: " + p.first);
             }
         }
-        return caching_options(k, r, e);
+        return caching_options(k, r);
     }
-
     static caching_options from_sstring(const sstring& str) {
-        return from_map(rjson::parse_to_map<std::map<sstring, sstring>>(str));
+        return from_map(json::to_map(str));
     }
 
     bool operator==(const caching_options& other) const {
-        return _key_cache == other._key_cache && _row_cache == other._row_cache
-            && _enabled == other._enabled;
+        return _key_cache == other._key_cache && _row_cache == other._row_cache;
     }
     bool operator!=(const caching_options& other) const {
         return !(*this == other);

cdc/cdc_extension.hh

@@ -20,16 +20,10 @@
 
 #pragma once
 
-#include <map>
-
-#include <seastar/core/sstring.hh>
-
-#include "bytes.hh"
 #include "serializer.hh"
 #include "db/extensions.hh"
 #include "cdc/cdc_options.hh"
 #include "schema.hh"
-#include "serializer_impl.hh"
 
 namespace cdc {
 
@@ -39,7 +33,6 @@ public:
     static constexpr auto NAME = "cdc";
 
     cdc_extension() = default;
-    cdc_extension(const options& opts) : _cdc_options(opts) {}
     explicit cdc_extension(std::map<sstring, sstring> tags) : _cdc_options(std::move(tags)) {}
     explicit cdc_extension(const bytes& b) : _cdc_options(cdc_extension::deserialize(b)) {}
     explicit cdc_extension(const sstring& s) {

cdc/cdc_options.hh

@@ -27,32 +27,10 @@
 
 namespace cdc {
 
-enum class delta_mode : uint8_t {
-    keys,
-    full,
-};
-
-/**
- * (for now only pre-) image collection mode.
- * Stating how much info to record.
- * off == none
- * on == changed columns
- * full == all (changed and unmodified columns)
- */
-enum class image_mode : uint8_t {
-    off, 
-    on,
-    full,
-};
-
-std::ostream& operator<<(std::ostream& os, delta_mode);
-std::ostream& operator<<(std::ostream& os, image_mode);
-
 class options final {
     bool _enabled = false;
-    image_mode _preimage = image_mode::off;
+    bool _preimage = false;
     bool _postimage = false;
-    delta_mode _delta_mode = delta_mode::full;
     int _ttl = 86400; // 24h in seconds
 public:
     options() = default;
@@ -62,19 +40,10 @@ public:
     sstring to_sstring() const;
 
     bool enabled() const { return _enabled; }
-    bool preimage() const { return _preimage != image_mode::off; }
-    bool full_preimage() const { return _preimage == image_mode::full; }
+    bool preimage() const { return _preimage; }
     bool postimage() const { return _postimage; }
-    delta_mode get_delta_mode() const { return _delta_mode; }
-    void set_delta_mode(delta_mode m) { _delta_mode = m; }
     int ttl() const { return _ttl; }
 
-    void enabled(bool b) { _enabled = b; }
-    void preimage(bool b) { preimage(b ? image_mode::on : image_mode::off); }
-    void preimage(image_mode m) { _preimage = m; }
-    void postimage(bool b) { _postimage = b; }
-    void ttl(int v) { _ttl = v; }
-
     bool operator==(const options& o) const;
     bool operator!=(const options& o) const;
 };

cdc/change_visitor.hh

@@ -1,283 +0,0 @@
-/*
- * Copyright (C) 2020 ScyllaDB
- */
-
-/*
- * This file is part of Scylla.
- *
- * Scylla is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Scylla 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 GNU General Public License
- * along with Scylla.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include "mutation.hh"
-
-/*
- * This file contains a general abstraction for walking over mutations,
- * deconstructing them into ``atomic'' pieces, and consuming these pieces.
- *
- * The pieces considered atomic are:
- * - atomic_cells, either in collections or in atomic columns
- *   (see `live_collection_cell`, `dead_collection_cell`, `live_atomic_cell`, `dead_atomic_cell`),
- * - collection tombstones (see `collection_tombstone`)
- * - row markers (see `marker`)
- * - row tombstones (see `clustered_row_delete`),
- * - range tombstones (see `range_delete`),
- * - partition tombstones (see `partition_delete`).
- * We use the term ``changes'' to refer to these atomic pieces, hence the name ``ChangeVisitor''.
- *
- * IMPORTANT: this doesn't understand all possible states that a mutation can have, e.g. it doesn't understand
- * the concept of ``continuity''. However, it is sufficient for analyzing mutations created by a write coordinator,
- * e.g. obtained by parsing a CQL statement.
- *
- * To analyze a mutation, create a visitor (described by the `ChangeVisitor` concept below) and pass it
- * together with the mutation to `inspect_mutation`.
- *
- * To analyze certain fragments of the mutation, the inspecting code requires further visitors to be passed.
- * For example, when it encounters a clustered row update, it calls `clustered_row_cells` on the visitor,
- * passing it the row's key and the callback. The visitor can then decide:
- * - if it's not interested in the row's cells, it can simply not call the callback,
- * - otherwise, it can call the callback with a value of type that satisfies the ``RowCellsVisitor'' concept.
- * If the callback is called, the inspector walks over the row and passes the changes into the ``row cells visitor''.
- * In either case, it will then proceed to analyze further parts of the mutation, if any.
- *
- * Note that the type passed to the callbacks provided by the inspector (such as in the example above)
- * can be decided at runtime. This can be especially useful with the callback passed to `collection_column`
- * in RowCellsVisitor, if different collection types require different logic to handle.
- *
- * The dummy visitors below are there only to define the concepts.
- * For example, in the RowCellsVisitor concept I wanted to express that `visit_collection` in RowCellsVisitor
- * is a function that handles *any* type which satisfies CollectionVisitor. I didn't find a way to do that
- * other than providing a ``most generic'' concrete type which satisfies the interface (`dummy_collection_visitor`).
- * Unfortunately C++ is still not Haskell.
- *
- * The inspector calls `finished()` after visiting each change, and sometimes before (e.g. when it starts
- * visiting a static row, but before it visits any of its cells). If it returns true, the inspector
- * will stop the visitation. Thus, if at any point during the walk the visitor decides it's not interested
- * in any more changes, it can inform the inspector by returning `true` from `finished()`.
- *
- * IMPORTANT: if the visitor returns `true` from `finished()`, it should keep returning `true`. This is because
- * the inspector may call `finished()` multiple times when exiting some nested loops.
- *
- * The order of visitation is as follows:
- * - First the static row is visited, if it has any cells.
- *   Within the row, its columns are visited in order of increasing column IDs.
- *
- * - Then, for each clustering key, if a change (row marker, cell, or tombstone) exists for this key:
- *   - The row marker is visited, if there is one.
- *   - Columns are visited in order of increasing column IDs.
- *   - The row tombstone is visited, if there is one.
- *
- * For both the static row and a clustering row, for each column:
- * - If the column is atomic, a corresponding atomic_cell is visited (if there is one).
- * - Otherwise (the column is non-atomic):
- *   - The collection tombstone is visited first.
- *   - Cells are visited in order of increasing keys
- *     (assuming that the mutation was correctly constructed, i.e. it stores cells in key order).
- *
- * WARNING: visited collection tombstone and cells
- * are guaranteed to live only for the duration of `collection_column` call.
- *
- * - Then range tombstones are visited. The order is unspecified
- *   (more accurately: if it's specified, I don't know what it is)
- *
- * - Finally, the partition tombstone is visited, if it exists.
- */
-
-namespace cdc {
-
-template <typename V>
-concept CollectionVisitor = requires(V v,
-        const tombstone& t,
-        bytes_view key,
-        const atomic_cell_view& cell) {
-
-    { v.collection_tombstone(t) }         -> std::same_as<void>;
-    { v.live_collection_cell(key, cell) } -> std::same_as<void>;
-    { v.dead_collection_cell(key, cell) } -> std::same_as<void>;
-    { v.finished() } -> std::same_as<bool>;
-};
-
-struct dummy_collection_visitor {
-    void collection_tombstone(const tombstone&) {}
-    void live_collection_cell(bytes_view, const atomic_cell_view&) {}
-    void dead_collection_cell(bytes_view, const atomic_cell_view&) {}
-    bool finished() { return false; }
-};
-
-template <typename V>
-concept RowCellsVisitor = requires(V v,
-        const column_definition& cdef,
-        const atomic_cell_view& cell,
-        noncopyable_function<void(dummy_collection_visitor&)> visit_collection) {
-
-    { v.live_atomic_cell(cdef, cell) }                         -> std::same_as<void>;
-    { v.dead_atomic_cell(cdef, cell) }                         -> std::same_as<void>;
-    { v.collection_column(cdef, std::move(visit_collection)) } -> std::same_as<void>;
-    { v.finished() }                                           -> std::same_as<bool>;
-};
-
-struct dummy_row_cells_visitor {
-    void live_atomic_cell(const column_definition&, const atomic_cell_view&) {}
-    void dead_atomic_cell(const column_definition&, const atomic_cell_view&) {}
-    void collection_column(const column_definition&, auto&& visit_collection) {
-        dummy_collection_visitor v;
-        visit_collection(v);
-    }
-    bool finished() { return false; }
-};
-
-template <typename V>
-concept ClusteredRowCellsVisitor = requires(V v,
-        const row_marker& rm) {
-    requires RowCellsVisitor<V>;
-    { v.marker(rm) } -> std::same_as<void>;
-};
-
-struct dummy_clustered_row_cells_visitor : public dummy_row_cells_visitor {
-    void marker(const row_marker&) {}
-};
-
-template <typename V>
-concept ChangeVisitor = requires(V v,
-        api::timestamp_type ts,
-        const clustering_key& ckey,
-        const range_tombstone& rt,
-        const tombstone& t,
-        noncopyable_function<void(dummy_clustered_row_cells_visitor&)> visit_clustered_row_cells,
-        noncopyable_function<void(dummy_row_cells_visitor&)> visit_row_cells) {
-
-    { v.static_row_cells(std::move(visit_row_cells)) }                    -> std::same_as<void>;
-    { v.clustered_row_cells(ckey, std::move(visit_clustered_row_cells)) } -> std::same_as<void>;
-    { v.clustered_row_delete(ckey, t) }                                   -> std::same_as<void>;
-    { v.range_delete(rt) }                                                -> std::same_as<void>;
-    { v.partition_delete(t) }                                             -> std::same_as<void>;
-    { v.finished() }                                                      -> std::same_as<bool>;
-};
-
-template <RowCellsVisitor V>
-void inspect_row_cells(const schema& s, column_kind ckind, const row& r, V& v) {
-    r.for_each_cell_until([&s, ckind, &v] (column_id id, const atomic_cell_or_collection& acoc) {
-        auto& cdef = s.column_at(ckind, id);
-
-        if (cdef.is_atomic()) {
-            auto cell = acoc.as_atomic_cell(cdef);
-            if (cell.is_live()) {
-                v.live_atomic_cell(cdef, cell);
-            } else {
-                v.dead_atomic_cell(cdef, cell);
-            }
-
-            return stop_iteration(v.finished());
-        }
-
-        acoc.as_collection_mutation().with_deserialized(*cdef.type, [&v, &cdef] (collection_mutation_view_description view) {
-            v.collection_column(cdef, [&view] (CollectionVisitor auto& cv) {
-                if (cv.finished()) {
-                    return;
-                }
-
-                if (view.tomb) {
-                    cv.collection_tombstone(view.tomb);
-                    if (cv.finished()) {
-                        return;
-                    }
-                }
-
-                for (auto& [key, cell]: view.cells) {
-                    if (cell.is_live()) {
-                        cv.live_collection_cell(key, cell);
-                    } else {
-                        cv.dead_collection_cell(key, cell);
-                    }
-
-                    if (cv.finished()) {
-                        return;
-                    }
-                }
-            });
-        });
-
-        return stop_iteration(v.finished());
-    });
-}
-
-template <ChangeVisitor V>
-void inspect_mutation(const mutation& m, V& v) {
-    auto& p = m.partition();
-    auto& s = *m.schema();
-
-    if (!p.static_row().empty()) {
-        v.static_row_cells([&s, &p] (RowCellsVisitor auto& srv) {
-            if (srv.finished()) {
-                return;
-            }
-            inspect_row_cells(s, column_kind::static_column, p.static_row().get(), srv);
-        });
-
-        if (v.finished()) {
-            return;
-        }
-    }
-
-    for (auto& cr: p.clustered_rows()) {
-        auto& r = cr.row();
-
-        if (r.marker().is_live() || !r.cells().empty()) {
-            v.clustered_row_cells(cr.key(), [&s, &r] (ClusteredRowCellsVisitor auto& crv) {
-                if (crv.finished()) {
-                    return;
-                }
-
-                auto& rm = r.marker();
-                if (rm.is_live()) {
-                    crv.marker(rm);
-
-                    if (crv.finished()) {
-                        return;
-                    }
-                }
-
-                inspect_row_cells(s, column_kind::regular_column, r.cells(), crv);
-            });
-
-            if (v.finished()) {
-                return;
-            }
-        }
-
-        if (r.deleted_at()) {
-            auto t = r.deleted_at().tomb();
-            assert(t.timestamp != api::missing_timestamp);
-            v.clustered_row_delete(cr.key(), t);
-            if (v.finished()) {
-                return;
-            }
-        }
-    }
-
-    for (auto& rt: p.row_tombstones()) {
-        assert(rt.tomb.timestamp != api::missing_timestamp);
-        v.range_delete(rt);
-        if (v.finished()) {
-            return;
-        }
-    }
-
-    if (p.partition_tombstone()) {
-        v.partition_delete(p.partition_tombstone());
-    }
-}
-
-} // namespace cdc

cdc/generation.cc

@@ -23,7 +23,6 @@
 #include <random>
 #include <unordered_set>
 #include <seastar/core/sleep.hh>
-#include <algorithm>
 
 #include "keys.hh"
 #include "schema_builder.hh"
@@ -60,57 +59,14 @@ static void copy_int_to_bytes(int64_t i, size_t offset, bytes& b) {
     std::copy_n(reinterpret_cast<int8_t*>(&i), sizeof(int64_t), b.begin() + offset);
 }
 
-static constexpr auto stream_id_version_bits = 4;
-static constexpr auto stream_id_random_bits = 38;
-static constexpr auto stream_id_index_bits = sizeof(uint64_t)*8 - stream_id_version_bits - stream_id_random_bits;
-
-static constexpr auto stream_id_version_shift = 0;
-static constexpr auto stream_id_index_shift = stream_id_version_shift + stream_id_version_bits;
-static constexpr auto stream_id_random_shift = stream_id_index_shift + stream_id_index_bits;
-
-/**
- * Responsibilty for encoding stream_id moved from factory method to
- * this constructor, to keep knowledge of composition in a single place.
- * Note this is private and friended to topology_description_generator,
- * because he is the one who defined the "order" we view vnodes etc.
- */
-stream_id::stream_id(dht::token token, size_t vnode_index)
+stream_id::stream_id(int64_t first, int64_t second)
     : _value(bytes::initialized_later(), 2 * sizeof(int64_t))
 {
-    static thread_local std::mt19937_64 rand_gen(std::random_device{}());
-    static thread_local std::uniform_int_distribution<uint64_t> rand_dist;
-
-    auto rand = rand_dist(rand_gen);
-    auto mask_shift = [](uint64_t val, size_t bits, size_t shift) {
-        return (val & ((1ull << bits) - 1u)) << shift;
-    };
-    /**
-     *  Low qword:
-     * 0-4: version
-     * 5-26: vnode index as when created (see generation below). This excludes shards
-     * 27-64: random value (maybe to be replaced with timestamp)
-     */
-    auto low_qword = mask_shift(version_1, stream_id_version_bits, stream_id_version_shift)
-        | mask_shift(vnode_index, stream_id_index_bits, stream_id_index_shift)
-        | mask_shift(rand, stream_id_random_bits, stream_id_random_shift)
-        ;
-
-    copy_int_to_bytes(dht::token::to_int64(token), 0, _value);
-    copy_int_to_bytes(low_qword, sizeof(int64_t), _value);
-    // not a hot code path. make sure we did not mess up the shifts and masks.
-    assert(version() == version_1);
-    assert(index() == vnode_index);
+    copy_int_to_bytes(first, 0, _value);
+    copy_int_to_bytes(second, sizeof(int64_t), _value);
 }
 
-stream_id::stream_id(bytes b)
-    : _value(std::move(b))
-{
-    // this is not a very solid check. Id:s previous to GA/versioned id:s
-    // have fully random bits in low qword, so this could go either way...
-    if (version() > version_1) {
-        throw std::invalid_argument("Unknown CDC stream id version");
-    }
-}
+stream_id::stream_id(bytes b) : _value(std::move(b)) { }
 
 bool stream_id::is_set() const {
     return !_value.empty();
@@ -120,10 +76,6 @@ bool stream_id::operator==(const stream_id& o) const {
     return _value == o._value;
 }
 
-bool stream_id::operator!=(const stream_id& o) const {
-    return !(*this == o);
-}
-
 bool stream_id::operator<(const stream_id& o) const {
     return _value < o._value;
 }
@@ -135,26 +87,18 @@ static int64_t bytes_to_int64(bytes_view b, size_t offset) {
     return net::ntoh(res);
 }
 
-dht::token stream_id::token() const {
-    return dht::token::from_int64(token_from_bytes(_value));
+int64_t stream_id::first() const {
+    return token_from_bytes(_value);
+}
+
+int64_t stream_id::second() const {
+    return bytes_to_int64(_value, sizeof(int64_t));
 }
 
 int64_t stream_id::token_from_bytes(bytes_view b) {
     return bytes_to_int64(b, 0);
 }
 
-static uint64_t unpack_value(bytes_view b, size_t off, size_t shift, size_t bits) {
-    return (uint64_t(bytes_to_int64(b, off)) >> shift) & ((1ull << bits) - 1u);
-}
-
-uint8_t stream_id::version() const {
-    return unpack_value(_value, sizeof(int64_t), stream_id_version_shift, stream_id_version_bits);
-}
-
-size_t stream_id::index() const {
-    return unpack_value(_value, sizeof(int64_t), stream_id_index_shift, stream_id_index_bits);
-}
-
 const bytes& stream_id::to_bytes() const {
     return _value;
 }
@@ -175,27 +119,15 @@ bool topology_description::operator==(const topology_description& o) const {
     return _entries == o._entries;
 }
 
-const std::vector<token_range_description>& topology_description::entries() const& {
+const std::vector<token_range_description>& topology_description::entries() const {
     return _entries;
 }
 
-std::vector<token_range_description>&& topology_description::entries() && {
-    return std::move(_entries);
-}
+static stream_id create_stream_id(dht::token t) {
+    static thread_local std::mt19937_64 rand_gen(std::random_device().operator()());
+    static thread_local std::uniform_int_distribution<int64_t> rand_dist(std::numeric_limits<int64_t>::min());
 
-static std::vector<stream_id> create_stream_ids(
-        size_t index, dht::token start, dht::token end, size_t shard_count, uint8_t ignore_msb) {
-    std::vector<stream_id> result;
-    result.reserve(shard_count);
-    dht::sharder sharder(shard_count, ignore_msb);
-    for (size_t shard_idx = 0; shard_idx < shard_count; ++shard_idx) {
-        auto t = dht::find_first_token_for_shard(sharder, start, end, shard_idx);
-        // compose the id from token and the "index" of the range end owning vnode
-        // as defined by token sort order. Basically grouping within this
-        // shard set.
-        result.emplace_back(stream_id(t, index));
-    }
-    return result;
+    return {dht::token::to_int64(t), rand_dist(rand_gen)};
 }
 
 class topology_description_generator final {
@@ -218,7 +150,7 @@ class topology_description_generator final {
     // Fetch sharding parameters for a node that owns vnode ending with this.end
     // Returns <shard_count, ignore_msb> pair.
     std::pair<size_t, uint8_t> get_sharding_info(dht::token end) const {
-        if (_bootstrap_tokens.contains(end)) {
+        if (_bootstrap_tokens.count(end) > 0) {
             return {smp::count, _cfg.murmur3_partitioner_ignore_msb_bits()};
         } else {
             auto endpoint = _token_metadata.get_endpoint(end);
@@ -231,15 +163,21 @@ class topology_description_generator final {
         }
     }
 
-    token_range_description create_description(size_t index, dht::token start, dht::token end) const {
+    token_range_description create_description(dht::token start, dht::token end) const {
         token_range_description desc;
 
         desc.token_range_end = end;
 
         auto [shard_count, ignore_msb] = get_sharding_info(end);
-        desc.streams = create_stream_ids(index, start, end, shard_count, ignore_msb);
+        desc.streams.reserve(shard_count);
         desc.sharding_ignore_msb = ignore_msb;
 
+        dht::sharder sharder(shard_count, ignore_msb);
+        for (size_t shard_idx = 0; shard_idx < shard_count; ++shard_idx) {
+            auto t = dht::find_first_token_for_shard(sharder, start, end, shard_idx);
+            desc.streams.push_back(create_stream_id(t));
+        }
+
         return desc;
     }
 public:
@@ -252,7 +190,12 @@ public:
         , _bootstrap_tokens(bootstrap_tokens)
         , _token_metadata(token_metadata)
         , _gossiper(gossiper)
-    {}
+    {
+        if (_bootstrap_tokens.empty()) {
+            throw std::runtime_error(
+                    "cdc: bootstrap tokens is empty in generate_topology_description");
+        }
+    }
 
     /*
      * Generate a set of CDC stream identifiers such that for each shard
@@ -275,10 +218,10 @@ public:
         vnode_descriptions.reserve(tokens.size());
 
         vnode_descriptions.push_back(
-                create_description(0, tokens.back(), tokens.front()));
+                create_description(tokens.back(), tokens.front()));
         for (size_t idx = 1; idx < tokens.size(); ++idx) {
             vnode_descriptions.push_back(
-                    create_description(idx, tokens[idx - 1], tokens[idx]));
+                    create_description(tokens[idx - 1], tokens[idx]));
         }
 
         return {std::move(vnode_descriptions)};
@@ -305,38 +248,6 @@ future<db_clock::time_point> get_local_streams_timestamp() {
     });
 }
 
-// non-static for testing
-size_t limit_of_streams_in_topology_description() {
-    // Each stream takes 16B and we don't want to exceed 4MB so we can have
-    // at most 262144 streams but not less than 1 per vnode.
-    return 4 * 1024 * 1024 / 16;
-}
-
-// non-static for testing
-topology_description limit_number_of_streams_if_needed(topology_description&& desc) {
-    int64_t streams_count = 0;
-    for (auto& tr_desc : desc.entries()) {
-        streams_count += tr_desc.streams.size();
-    }
-
-    size_t limit = std::max(limit_of_streams_in_topology_description(), desc.entries().size());
-    if (limit >= size_t(streams_count)) {
-        return std::move(desc);
-    }
-    size_t streams_per_vnode_limit = limit / desc.entries().size();
-    auto entries = std::move(desc).entries();
-    auto start = entries.back().token_range_end;
-    for (size_t idx = 0; idx < entries.size(); ++idx) {
-        auto end = entries[idx].token_range_end;
-        if (entries[idx].streams.size() > streams_per_vnode_limit) {
-            entries[idx].streams =
-                create_stream_ids(idx, start, end, streams_per_vnode_limit, entries[idx].sharding_ignore_msb);
-        }
-        start = end;
-    }
-    return topology_description(std::move(entries));
-}
-
 // Run inside seastar::async context.
 db_clock::time_point make_new_cdc_generation(
         const db::config& cfg,
@@ -346,25 +257,14 @@ db_clock::time_point make_new_cdc_generation(
         db::system_distributed_keyspace& sys_dist_ks,
         std::chrono::milliseconds ring_delay,
         bool for_testing) {
-    using namespace std::chrono;
-    auto gen = topology_description_generator(cfg, bootstrap_tokens, tm, g).generate();
+    assert(!bootstrap_tokens.empty());
 
-    // If the cluster is large we may end up with a generation that contains
-    // large number of streams. This is problematic because we store the
-    // generation in a single row. For a generation with large number of rows
-    // this will lead to a row that can be as big as 32MB. This is much more
-    // than the limit imposed by commitlog_segment_size_in_mb. If the size of
-    // the row that describes a new generation grows above
-    // commitlog_segment_size_in_mb, the write will fail and the new node won't
-    // be able to join. To avoid such problem we make sure that such row is
-    // always smaller than 4MB. We do that by removing some CDC streams from
-    // each vnode if the total number of streams is too large.
-    gen = limit_number_of_streams_if_needed(std::move(gen));
+    auto gen = topology_description_generator(cfg, bootstrap_tokens, tm, g).generate();
 
     // Begin the race.
     auto ts = db_clock::now() + (
-            (for_testing || ring_delay == milliseconds(0)) ? milliseconds(0) : (
-                2 * ring_delay + duration_cast<milliseconds>(generation_leeway)));
+            for_testing ? std::chrono::milliseconds(0) : (
+                2 * ring_delay + std::chrono::duration_cast<std::chrono::milliseconds>(generation_leeway)));
     sys_dist_ks.insert_cdc_topology_description(ts, std::move(gen), { tm.count_normal_token_owners() }).get();
 
     return ts;

cdc/generation.hh

@@ -64,21 +64,17 @@ namespace cdc {
 class stream_id final {
     bytes _value;
 public:
-    static constexpr uint8_t version_1 = 1;
-
     stream_id() = default;
+    stream_id(int64_t, int64_t);
     stream_id(bytes);
-    stream_id(dht::token, size_t);
-
     bool is_set() const;
     bool operator==(const stream_id&) const;
-    bool operator!=(const stream_id&) const;
     bool operator<(const stream_id&) const;
 
-    uint8_t version() const;
-    size_t index() const;
+    int64_t first() const;
+    int64_t second() const;
+
     const bytes& to_bytes() const;
-    dht::token token() const;
 
     partition_key to_partition_key(const schema& log_schema) const;
     static int64_t token_from_bytes(bytes_view);
@@ -114,25 +110,7 @@ public:
     topology_description(std::vector<token_range_description> entries);
     bool operator==(const topology_description&) const;
 
-    const std::vector<token_range_description>& entries() const&;
-    std::vector<token_range_description>&& entries() &&;
-};
-
-/**
- * The set of streams for a single topology version/generation
- * I.e. the stream ids at a given time. 
- */ 
-class streams_version {
-public:
-    std::vector<stream_id> streams;
-    db_clock::time_point timestamp;
-    std::optional<db_clock::time_point> expired;
-
-    streams_version(std::vector<stream_id> s, db_clock::time_point ts, std::optional<db_clock::time_point> exp)
-        : streams(std::move(s))
-        , timestamp(ts)
-        , expired(std::move(exp))
-    {}
+    const std::vector<token_range_description>& entries() const;
 };
 
 /* Should be called when we're restarting and we noticed that we didn't save any streams timestamp in our local tables,
@@ -152,8 +130,8 @@ bool should_propose_first_generation(const gms::inet_address& me, const gms::gos
  */
 future<db_clock::time_point> get_local_streams_timestamp();
 
-/* Generate a new set of CDC streams and insert it into the distributed cdc_generation_descriptions table.
- * Returns the timestamp of this new generation
+/* Generate a new set of CDC streams and insert it into the distributed cdc_generations table.
+ * Returns the timestamp of this new generation.
  *
  * Should be called when starting the node for the first time (i.e., joining the ring).
  *
@@ -183,7 +161,7 @@ std::optional<db_clock::time_point> get_streams_timestamp_for(const gms::inet_ad
 /* Inform CDC users about a generation of streams (identified by the given timestamp)
  * by inserting it into the cdc_streams table.
  *
- * Assumes that the cdc_generation_descriptions table contains this generation.
+ * Assumes that the cdc_generations table contains this generation.
  *
  * Returning from this function does not mean that the table update was successful: the function
  * might run an asynchronous task in the background.

cdc/log.hh

@@ -41,6 +41,7 @@
 #include "exceptions/exceptions.hh"
 #include "timestamp.hh"
 #include "tracing/trace_state.hh"
+#include "cdc_options.hh"
 #include "utils/UUID.hh"
 
 class schema;
@@ -62,7 +63,6 @@ class query_state;
 
 class mutation;
 class partition_key;
-class database;
 
 namespace cdc {
 
@@ -75,7 +75,7 @@ class metadata;
 /// CDC service will listen for schema changes and iff CDC is enabled/changed
 /// create/modify/delete corresponding log tables etc as part of the schema change. 
 ///
-class cdc_service final : public async_sharded_service<cdc::cdc_service> {
+class cdc_service {
     class impl;
     std::unique_ptr<impl> _impl;
 public:
@@ -100,19 +100,19 @@ public:
 struct db_context final {
     service::storage_proxy& _proxy;
     service::migration_notifier& _migration_notifier;
-    const locator::token_metadata& _token_metadata;
+    locator::token_metadata& _token_metadata;
     cdc::metadata& _cdc_metadata;
 
     class builder final {
         service::storage_proxy& _proxy;
         std::optional<std::reference_wrapper<service::migration_notifier>> _migration_notifier;
-        std::optional<std::reference_wrapper<const locator::token_metadata>> _token_metadata;
+        std::optional<std::reference_wrapper<locator::token_metadata>> _token_metadata;
         std::optional<std::reference_wrapper<cdc::metadata>> _cdc_metadata;
     public:
         builder(service::storage_proxy& proxy);
 
         builder& with_migration_notifier(service::migration_notifier& migration_notifier);
-        builder& with_token_metadata(const locator::token_metadata& token_metadata);
+        builder& with_token_metadata(locator::token_metadata& token_metadata);
         builder& with_cdc_metadata(cdc::metadata&);
 
         db_context build();
@@ -129,12 +129,7 @@ enum class operation : int8_t {
 };
 
 bool is_log_for_some_table(const sstring& ks_name, const std::string_view& table_name);
-
-schema_ptr get_base_table(const database&, const schema&);
-schema_ptr get_base_table(const database&, sstring_view, std::string_view);
-
-seastar::sstring base_name(std::string_view log_name);
-seastar::sstring log_name(std::string_view table_name);
+seastar::sstring log_name(const seastar::sstring& table_name);
 seastar::sstring log_data_column_name(std::string_view column_name);
 seastar::sstring log_meta_column_name(std::string_view column_name);
 bytes log_data_column_name_bytes(const bytes& column_name);
@@ -146,8 +141,6 @@ bytes log_data_column_deleted_name_bytes(const bytes& column_name);
 seastar::sstring log_data_column_deleted_elements_name(std::string_view column_name);
 bytes log_data_column_deleted_elements_name_bytes(const bytes& column_name);
 
-bool is_cdc_metacolumn_name(const sstring& name);
-
 utils::UUID generate_timeuuid(api::timestamp_type t);
 
 } // namespace cdc

cdc/metadata.cc

@@ -51,8 +51,7 @@ static cdc::stream_id get_stream(
     return entry.streams[shard_id];
 }
 
-// non-static for testing
-cdc::stream_id get_stream(
+static cdc::stream_id get_stream(
         const std::vector<cdc::token_range_description>& entries,
         dht::token tok) {
     if (entries.empty()) {
@@ -78,12 +77,6 @@ cdc::metadata::container_t::const_iterator cdc::metadata::gen_used_at(api::times
     return std::prev(it);
 }
 
-bool cdc::metadata::streams_available() const {
-    auto now = api::new_timestamp();
-    auto it = gen_used_at(now);
-    return  it != _gens.end();
-}
-
 cdc::stream_id cdc::metadata::get_stream(api::timestamp_type ts, dht::token tok) {
     auto now = api::new_timestamp();
     if (ts > now + generation_leeway.count()) {

cdc/metadata.hh

@@ -57,10 +57,6 @@ public:
     /* Is a generation with the given timestamp already known or superseded by a newer generation? */
     bool known_or_obsolete(db_clock::time_point) const;
 
-    /* Are there streams available. I.e. valid for time == now. If this is false, any writes to 
-     * CDC logs will fail fast.
-     */
-    bool streams_available() const;
     /* Return the stream for the base partition whose token is `tok` to which a corresponding log write should go
      * according to the generation used at time `ts` (i.e, the latest generation whose timestamp is less or equal to `ts`).
      *

cdc/split.cc

@@ -22,30 +22,31 @@
 #include "mutation.hh"
 #include "schema.hh"
 
-#include "concrete_types.hh"
-#include "types/user.hh"
-
 #include "split.hh"
 #include "log.hh"
-#include "change_visitor.hh"
-
-#include <type_traits>
 
 struct atomic_column_update {
     column_id id;
     atomic_cell cell;
 };
 
+// see the comment inside `clustered_row_insert` for motivation for separating
+// nonatomic deletions from nonatomic updates
+struct nonatomic_column_deletion {
+    column_id id;
+    tombstone t;
+};
+
 struct nonatomic_column_update {
     column_id id;
-    tombstone t; // optional
     utils::chunked_vector<std::pair<bytes, atomic_cell>> cells;
 };
 
 struct static_row_update {
     gc_clock::duration ttl;
     std::vector<atomic_column_update> atomic_entries;
-    std::vector<nonatomic_column_update> nonatomic_entries;
+    std::vector<nonatomic_column_deletion> nonatomic_deletions;
+    std::vector<nonatomic_column_update> nonatomic_updates;
 };
 
 struct clustered_row_insert {
@@ -53,14 +54,19 @@ struct clustered_row_insert {
     clustering_key key;
     row_marker marker;
     std::vector<atomic_column_update> atomic_entries;
-    std::vector<nonatomic_column_update> nonatomic_entries;
+    std::vector<nonatomic_column_deletion> nonatomic_deletions;
+    // INSERTs can't express updates of individual cells inside a non-atomic
+    // (without deleting the entire field first), so no `nonatomic_updates` field
+    // overwriting a nonatomic column inside an INSERT will be split into two changes:
+    // one with a nonatomic deletion, and one with a nonatomic update
 };
 
 struct clustered_row_update {
     gc_clock::duration ttl;
     clustering_key key;
     std::vector<atomic_column_update> atomic_entries;
-    std::vector<nonatomic_column_update> nonatomic_entries;
+    std::vector<nonatomic_column_deletion> nonatomic_deletions;
+    std::vector<nonatomic_column_update> nonatomic_updates;
 };
 
 struct clustered_row_deletion {
@@ -76,37 +82,6 @@ struct partition_deletion {
     tombstone t;
 };
 
-using clustered_column_set = std::map<clustering_key, cdc::one_kind_column_set, clustering_key::less_compare>;
-
-template<typename Container>
-concept EntryContainer = requires(Container& container) {
-    // Parenthesized due to https://bugs.llvm.org/show_bug.cgi?id=45088
-    { (container.atomic_entries) } -> std::same_as<std::vector<atomic_column_update>&>;
-    { (container.nonatomic_entries) } -> std::same_as<std::vector<nonatomic_column_update>&>;
-};
-
-template<EntryContainer Container>
-static void add_columns_affected_by_entries(cdc::one_kind_column_set& cset, const Container& cont) {
-    for (const auto& entry : cont.atomic_entries) {
-        cset.set(entry.id);
-    }
-    for (const auto& entry : cont.nonatomic_entries) {
-        cset.set(entry.id);
-    }
-}
-
-/* Given a mutation with multiple timestamps/ttl/types of changes, we split it into multiple mutations
- * before passing it into `process_change` (see comment above `should_split_visitor` for more details).
- *
- * The first step of the splitting is to walk over the mutation and put each change into an appropriate bucket
- * (see `batch`). The buckets are sorted by timestamps (see `set_of_changes`), and within each bucket,
- * the changes are split according to their types (`static_updates`, `clustered_inserts`, and so on).
- * Within each type, the changes are sorted w.r.t TTLs. Changes without a TTL are treated as if they had TTL = 0.
- *
- * The function that puts changes into bucket is called `extract_changes`. Underneath, it uses
- * `extract_changes_visitor`, `extract_collection_visitor` and `extract_row_visitor`.
- */
-
 struct batch {
     std::vector<static_row_update> static_updates;
     std::vector<clustered_row_insert> clustered_inserts;
@@ -114,503 +89,302 @@ struct batch {
     std::vector<clustered_row_deletion> clustered_row_deletions;
     std::vector<clustered_range_deletion> clustered_range_deletions;
     std::optional<partition_deletion> partition_deletions;
-
-    clustered_column_set get_affected_clustered_columns_per_row(const schema& s) const {
-        clustered_column_set ret{clustering_key::less_compare(s)};
-
-        if (!clustered_row_deletions.empty()) {
-            // When deleting a row, all columns are affected
-            cdc::one_kind_column_set all_columns{s.regular_columns_count()};
-            all_columns.set(0, s.regular_columns_count(), true);
-            for (const auto& change : clustered_row_deletions) {
-                ret.insert(std::make_pair(change.key, all_columns));
-            }
-        }
-
-        auto process_change_type = [&] (const auto& changes) {
-            for (const auto& change : changes) {
-                auto& cset = ret[change.key];
-                cset.resize(s.regular_columns_count());
-                add_columns_affected_by_entries(cset, change);
-            }
-        };
-
-        process_change_type(clustered_inserts);
-        process_change_type(clustered_updates);
-
-        return ret;
-    }
-
-    cdc::one_kind_column_set get_affected_static_columns(const schema& s) const {
-        cdc::one_kind_column_set ret{s.static_columns_count()};
-        for (const auto& change : static_updates) {
-            add_columns_affected_by_entries(ret, change);
-        }
-        return ret;
-    }
 };
 
 using set_of_changes = std::map<api::timestamp_type, batch>;
 
 struct row_update {
     std::vector<atomic_column_update> atomic_entries;
-    std::vector<nonatomic_column_update> nonatomic_entries;
+    std::vector<nonatomic_column_deletion> nonatomic_deletions;
+    std::vector<nonatomic_column_update> nonatomic_updates;
 };
 
-static gc_clock::duration get_ttl(const atomic_cell_view& acv) {
-    return acv.is_live_and_has_ttl() ? acv.ttl() : gc_clock::duration(0);
-}
-
-static gc_clock::duration get_ttl(const row_marker& rm) {
-    return rm.is_expiring() ? rm.ttl() : gc_clock::duration(0);
-}
-
-using change_key_t = std::pair<api::timestamp_type, gc_clock::duration>;
-
-/* Visits the cells and tombstone of a collection, putting the encountered changes into buckets
- * sorted by timestamp first and ttl second (see `_updates`).
- */
-template <typename V>
-struct extract_collection_visitor {
-private:
-    const column_id _id;
-    std::map<change_key_t, row_update>& _updates;
-
-    nonatomic_column_update& get_or_append_entry(api::timestamp_type ts, gc_clock::duration ttl) {
-        auto& updates = this->_updates[std::pair(ts, ttl)].nonatomic_entries;
-        if (updates.empty() || updates.back().id != _id) {
-            updates.push_back({_id});
+static
+std::map<std::pair<api::timestamp_type, gc_clock::duration>, row_update>
+extract_row_updates(const row& r, column_kind ckind, const schema& schema) {
+    std::map<std::pair<api::timestamp_type, gc_clock::duration>, row_update> result;
+    r.for_each_cell([&] (column_id id, const atomic_cell_or_collection& cell) {
+        auto& cdef = schema.column_at(ckind, id);
+        if (cdef.is_atomic()) {
+            auto view = cell.as_atomic_cell(cdef);
+            auto timestamp_and_ttl = std::pair(
+                    view.timestamp(),
+                    view.is_live_and_has_ttl() ? view.ttl() : gc_clock::duration(0)
+                );
+            result[timestamp_and_ttl].atomic_entries.push_back({id, atomic_cell(*cdef.type, view)});
+            return;
         }
-        return updates.back();
-    }
 
-    /* To copy a value from a collection/non-frozen UDT (in order to put it into a bucket) we need to know the value's type.
-     * The method of obtaining the type depends on the collection type; in particular, for non-frozen UDT, each value
-     * might have a different type, thus in general we need a method that, given a key (identifying the value in the collection),
-     * returns the value' type.
-     *
-     * We use the `Curiously Recurring Template Pattern' to avoid performing a dynamic dispatch on the collection's type for each visited cell.
-     * Instead we perform a single dynamic dispatch at the beginning, when encountering the collection column;
-     * the dispatch provides us with a correct `get_value_type` method.
-     * See `extract_row_visitor::collection_column` where the dispatch is done.
-
-    data_type get_value_type(bytes_view);
-    */
-
-    void cell(bytes_view key, const atomic_cell_view& c) {
-        auto& entry = get_or_append_entry(c.timestamp(), get_ttl(c));
-        entry.cells.emplace_back(to_bytes(key), atomic_cell(*static_cast<V&>(*this).get_value_type(key), c));
-    }
-
-public:
-    extract_collection_visitor(column_id id, std::map<change_key_t, row_update>& updates)
-        : _id(id), _updates(updates) {}
-
-    void collection_tombstone(const tombstone& t) {
-        auto& entry = get_or_append_entry(t.timestamp + 1, gc_clock::duration(0));
-        entry.t = t;
-    }
-
-    void live_collection_cell(bytes_view key, const atomic_cell_view& c) {
-        cell(key, c);
-    }
-
-    void dead_collection_cell(bytes_view key, const atomic_cell_view& c) {
-        cell(key, c);
-    }
-
-    constexpr bool finished() const { return false; }
-};
-
-/* Visits all cells and tombstones in a row, putting the encountered changes into buckets
- * sorted by timestamp first and ttl second (see `_updates`).
- */
-struct extract_row_visitor {
-    std::map<change_key_t, row_update> _updates;
-
-    void cell(const column_definition& cdef, const atomic_cell_view& cell) {
-        _updates[std::pair(cell.timestamp(), get_ttl(cell))].atomic_entries.push_back({cdef.id, atomic_cell(*cdef.type, cell)});
-    }
-
-    void live_atomic_cell(const column_definition& cdef, const atomic_cell_view& c) {
-        cell(cdef, c);
-    }
-
-    void dead_atomic_cell(const column_definition& cdef, const atomic_cell_view& c) {
-        cell(cdef, c);
-    }
-
-    void collection_column(const column_definition& cdef, auto&& visit_collection) {
-        visit(*cdef.type, make_visitor(
-        [&] (const collection_type_impl& ctype) {
-            struct collection_visitor : public extract_collection_visitor<collection_visitor> {
-                data_type _value_type;
-
-                collection_visitor(column_id id, std::map<change_key_t, row_update>& updates, const collection_type_impl& ctype)
-                    : extract_collection_visitor<collection_visitor>(id, updates), _value_type(ctype.value_comparator()) {}
-
-                data_type get_value_type(bytes_view) {
-                    return _value_type;
+        cell.as_collection_mutation().with_deserialized(*cdef.type, [&] (collection_mutation_view_description mview) {
+            auto desc = mview.materialize(*cdef.type);
+            for (auto& [k, v]: desc.cells) {
+                auto timestamp_and_ttl = std::pair(
+                        v.timestamp(),
+                        v.is_live_and_has_ttl() ? v.ttl() : gc_clock::duration(0)
+                    );
+                auto& updates = result[timestamp_and_ttl].nonatomic_updates;
+                if (updates.empty() || updates.back().id != id) {
+                    updates.push_back({id, {}});
                 }
-            } v(cdef.id, _updates, ctype);
-
-            visit_collection(v);
-        },
-        [&] (const user_type_impl& utype) {
-            struct udt_visitor : public extract_collection_visitor<udt_visitor> {
-                const user_type_impl& _utype;
-
-                udt_visitor(column_id id, std::map<change_key_t, row_update>& updates, const user_type_impl& utype)
-                    : extract_collection_visitor<udt_visitor>(id, updates), _utype(utype) {}
-
-                data_type get_value_type(bytes_view key) {
-                    return _utype.type(deserialize_field_index(key));
-                }
-            } v(cdef.id, _updates, utype);
-
-            visit_collection(v);
-        },
-        [&] (const abstract_type& o) {
-            throw std::runtime_error(format("extract_changes: unknown collection type:", o.name()));
-        }
-        ));
-    }
-
-    constexpr bool finished() const { return false; }
-};
-
-struct extract_changes_visitor {
-    set_of_changes _result;
-
-    void static_row_cells(auto&& visit_row_cells) {
-        extract_row_visitor v;
-        visit_row_cells(v);
-
-        for (auto& [ts_ttl, row_update]: v._updates) {
-            _result[ts_ttl.first].static_updates.push_back({
-                ts_ttl.second,
-                std::move(row_update.atomic_entries),
-                std::move(row_update.nonatomic_entries)
-            });
-        }
-    }
-
-    void clustered_row_cells(const clustering_key& ckey, auto&& visit_row_cells) {
-        struct clustered_cells_visitor : public extract_row_visitor {
-            api::timestamp_type _marker_ts;
-            gc_clock::duration _marker_ttl;
-            std::optional<row_marker> _marker;
-
-            void marker(const row_marker& rm) {
-                _marker_ts = rm.timestamp();
-                _marker_ttl = get_ttl(rm);
-                _marker = rm;
-
-                // make sure that an entry corresponding to the row marker's timestamp and ttl is in the map
-                (void)_updates[std::pair(_marker_ts, _marker_ttl)];
+                updates.back().cells.push_back({std::move(k), std::move(v)});
             }
-        } v;
-        visit_row_cells(v);
 
-        for (auto& [ts_ttl, row_update]: v._updates) {
-            // It is important that changes in the resulting `set_of_changes` are listed
-            // in increasing TTL order. The reason is explained in a comment in cdc/log.cc,
-            // search for "#6070".
-            auto [ts, ttl] = ts_ttl;
+            if (desc.tomb) {
+                auto timestamp_and_ttl = std::pair(desc.tomb.timestamp, gc_clock::duration(0));
+                result[timestamp_and_ttl].nonatomic_deletions.push_back({id, desc.tomb});
+            }
+        });
+    });
+    return result;
+};
 
-            if (v._marker && ts == v._marker_ts && ttl == v._marker_ttl) {
-                _result[ts].clustered_inserts.push_back({
+set_of_changes extract_changes(const mutation& base_mutation, const schema& base_schema) {
+    set_of_changes res;
+    auto& p = base_mutation.partition();
+
+    auto sr_updates = extract_row_updates(p.static_row().get(), column_kind::static_column, base_schema);
+    for (auto& [k, up]: sr_updates) {
+        auto [timestamp, ttl] = k;
+        res[timestamp].static_updates.push_back({
+                ttl,
+                std::move(up.atomic_entries),
+                std::move(up.nonatomic_deletions),
+                std::move(up.nonatomic_updates)
+            });
+    }
+
+    for (const rows_entry& cr : p.clustered_rows()) {
+        auto cr_updates = extract_row_updates(cr.row().cells(), column_kind::regular_column, base_schema);
+
+        const auto& marker = cr.row().marker();
+        auto marker_timestamp = marker.timestamp();
+        auto marker_ttl = marker.is_expiring() ? marker.ttl() : gc_clock::duration(0);
+        if (marker.is_live()) {
+            // make sure that an entry corresponding to the row marker's timestamp and ttl is in the map
+            (void)cr_updates[std::pair(marker_timestamp, marker_ttl)];
+        }
+
+        auto is_insert = [&] (api::timestamp_type timestamp, gc_clock::duration ttl) {
+            if (!marker.is_live()) {
+                return false;
+            }
+
+            return timestamp == marker_timestamp && ttl == marker_ttl;
+        };
+
+        for (auto& [k, up]: cr_updates) {
+            auto [timestamp, ttl] = k;
+
+            if (is_insert(timestamp, ttl)) {
+                res[timestamp].clustered_inserts.push_back({
                         ttl,
-                        ckey,
-                        *v._marker,
-                        std::move(row_update.atomic_entries),
-                        {}
+                        cr.key(),
+                        marker,
+                        std::move(up.atomic_entries),
+                        std::move(up.nonatomic_deletions)
                     });
-
-                auto& cr_insert = _result[ts].clustered_inserts.back();
-                bool clustered_update_exists = false;
-                for (auto& nonatomic_up: row_update.nonatomic_entries) {
-                    // Updating a collection column with an INSERT statement implies inserting a tombstone.
-                    //
-                    // For example, suppose that we have:
-                    //     CREATE TABLE t (a int primary key, b map<int, int>);
-                    // Then the following statement:
-                    //     INSERT INTO t (a, b) VALUES (0, {0:0}) USING TIMESTAMP T;
-                    // creates a tombstone in column b with timestamp T-1.
-                    // It also creates a cell (0, 0) with timestamp T.
-                    //
-                    // There is no way to create just the cell using an INSERT statement.
-                    // This can only be done using an UPDATE, as follows:
-                    //     UPDATE t USING TIMESTAMP T SET b = b + {0:0} WHERE a = 0;
-                    // note that this is different  than
-                    //     UPDATE t USING TIMESTAMP T SET b = {0:0} WHERE a = 0;
-                    // which also creates a tombstone with timestamp T-1.
-                    //
-                    // It follows that:
-                    // - if `nonatomic_up` has a tombstone, it can be made merged with our `cr_insert`,
-                    //   which represents an INSERT change.
-                    // - but if `nonatomic_up` only has cells, we must create a separate UPDATE change
-                    //   for the cells alone.
-                    if (nonatomic_up.t) {
-                        cr_insert.nonatomic_entries.push_back(std::move(nonatomic_up));
-                    } else {
-                        if (!clustered_update_exists) {
-                            _result[ts].clustered_updates.push_back({
-                                ttl,
-                                ckey,
-                                {},
-                                {}
-                            });
-
-                            // Multiple iterations of this `for` loop (for different collection columns)
-                            // might want to put their `nonatomic_up`s into an UPDATE change;
-                            // but we don't want to create a separate change for each of them, reusing one instead.
-                            //
-                            // Example:
-                            // CREATE TABLE t (a int primary key, b map<int, int>, c map <int, int>) with cdc = {'enabled':true};
-                            // insert into t (a, b, c) values (0, {1:1}, {2:2}) USING TTL 5;
-                            //
-                            // this should create 3 delta rows:
-                            // 1. one for the row marker (indicating an INSERT), with TTL 5
-                            // 2. one for the b and c tombstones, without TTL (cdc$ttl = null)
-                            // 3. one for the b and c cells, with TTL 5
-                            // This logic takes care that b cells and c cells are put into a single change (3. above).
-                            clustered_update_exists = true;
-                        }
-
-                        auto& cr_update = _result[ts].clustered_updates.back();
-                        cr_update.nonatomic_entries.push_back(std::move(nonatomic_up));
-                    }
+                if (!up.nonatomic_updates.empty()) {
+                    // nonatomic updates cannot be expressed with an INSERT.
+                    res[timestamp].clustered_updates.push_back({
+                            ttl,
+                            cr.key(),
+                            {},
+                            {},
+                            std::move(up.nonatomic_updates)
+                        });
                 }
             } else {
-                _result[ts].clustered_updates.push_back({
+                res[timestamp].clustered_updates.push_back({
                         ttl,
-                        ckey,
-                        std::move(row_update.atomic_entries),
-                        std::move(row_update.nonatomic_entries)
+                        cr.key(),
+                        std::move(up.atomic_entries),
+                        std::move(up.nonatomic_deletions),
+                        std::move(up.nonatomic_updates)
                     });
             }
         }
+
+        auto row_tomb = cr.row().deleted_at().regular();
+        if (row_tomb) {
+            res[row_tomb.timestamp].clustered_row_deletions.push_back({cr.key(), row_tomb});
+        }
     }
 
-    void clustered_row_delete(const clustering_key& ckey, const tombstone& t) {
-        _result[t.timestamp].clustered_row_deletions.push_back({ckey, t});
+    for (const auto& rt: p.row_tombstones()) {
+        if (rt.tomb.timestamp != api::missing_timestamp) {
+            res[rt.tomb.timestamp].clustered_range_deletions.push_back({rt});
+        }
     }
 
-    void range_delete(const range_tombstone& rt) {
-        _result[rt.tomb.timestamp].clustered_range_deletions.push_back({rt});
+    auto partition_tomb_timestamp = p.partition_tombstone().timestamp;
+    if (partition_tomb_timestamp != api::missing_timestamp) {
+        res[partition_tomb_timestamp].partition_deletions = {p.partition_tombstone()};
     }
 
-    void partition_delete(const tombstone& t) {
-        _result[t.timestamp].partition_deletions = {t};
-    }
-
-    constexpr bool finished() const { return false; }
-};
-
-set_of_changes extract_changes(const mutation& m) {
-    extract_changes_visitor v;
-    cdc::inspect_mutation(m, v);
-    return std::move(v._result);
+    return res;
 }
 
 namespace cdc {
 
-struct find_timestamp_visitor {
-    api::timestamp_type _ts = api::missing_timestamp;
+bool should_split(const mutation& base_mutation, const schema& base_schema) {
+    auto& p = base_mutation.partition();
 
-    bool finished() const { return _ts != api::missing_timestamp; }
+    api::timestamp_type found_ts = api::missing_timestamp;
+    std::optional<gc_clock::duration> found_ttl; // 0 = "no ttl"
 
-    void visit(api::timestamp_type ts) { _ts = ts; }
-    void visit(const atomic_cell_view& cell) { visit(cell.timestamp()); }
+    auto check_or_set = [&] (api::timestamp_type ts, gc_clock::duration ttl) {
+        if (found_ts != api::missing_timestamp && found_ts != ts) {
+            return true;
+        }
+        found_ts = ts;
 
-    void live_atomic_cell(const column_definition&, const atomic_cell_view& cell) { visit(cell); }
-    void dead_atomic_cell(const column_definition&, const atomic_cell_view& cell) { visit(cell); }
-    void collection_tombstone(const tombstone& t) {
-        // A collection tombstone with timestamp T can be created with:
-        // UPDATE ks.t USING TIMESTAMP T + 1 SET X = null WHERE ...
-        // (where X is a collection column).
-        // This is, among others, the reason why we show it in the CDC log
-        // with cdc$time using timestamp T + 1 instead of T.
-        visit(t.timestamp + 1);
-    }
-    void live_collection_cell(bytes_view, const atomic_cell_view& cell) { visit(cell); }
-    void dead_collection_cell(bytes_view, const atomic_cell_view& cell) { visit(cell); }
-    void collection_column(const column_definition&, auto&& visit_collection) { visit_collection(*this); }
-    void marker(const row_marker& rm) { visit(rm.timestamp()); }
-    void static_row_cells(auto&& visit_row_cells) { visit_row_cells(*this); }
-    void clustered_row_cells(const clustering_key&, auto&& visit_row_cells) { visit_row_cells(*this); }
-    void clustered_row_delete(const clustering_key&, const tombstone& t) { visit(t.timestamp); }
-    void range_delete(const range_tombstone& t) { visit(t.tomb.timestamp); }
-    void partition_delete(const tombstone& t) { visit(t.timestamp); }
-};
+        if (found_ttl && *found_ttl != ttl) {
+            return true;
+        }
+        found_ttl = ttl;
 
-/* Find some timestamp inside the given mutation.
- *
- * If this mutation was created using a single insert/update/delete statement, then it will have a single,
- * well-defined timestamp (even if this timestamp occurs multiple times, e.g. in a cell and row_marker).
- *
- * This function shouldn't be used for mutations that have multiple different timestamps: the function
- * would only find one of them. When dealing with such mutations, the caller should first split the mutation
- * into multiple ones, each with a single timestamp.
- */
-api::timestamp_type find_timestamp(const mutation& m) {
-    find_timestamp_visitor v;
+        return false;
+    };
 
-    cdc::inspect_mutation(m, v);
+    bool had_static_row = false;
 
-    if (v._ts == api::missing_timestamp) {
-        throw std::runtime_error("cdc: could not find timestamp of mutation");
+    bool should_split = false;
+    p.static_row().get().for_each_cell([&] (column_id id, const atomic_cell_or_collection& cell) {
+        had_static_row = true;
+
+        auto& cdef = base_schema.column_at(column_kind::static_column, id);
+        if (cdef.is_atomic()) {
+            auto view = cell.as_atomic_cell(cdef);
+            if (check_or_set(view.timestamp(), view.is_live_and_has_ttl() ? view.ttl() : gc_clock::duration(0))) {
+                should_split = true;
+            }
+            return;
+        }
+
+        cell.as_collection_mutation().with_deserialized(*cdef.type, [&] (collection_mutation_view_description mview) {
+            auto desc = mview.materialize(*cdef.type);
+            for (auto& [k, v]: desc.cells) {
+                if (check_or_set(v.timestamp(), v.is_live_and_has_ttl() ? v.ttl() : gc_clock::duration(0))) {
+                    should_split = true;
+                    return;
+                }
+            }
+
+            if (desc.tomb) {
+                if (check_or_set(desc.tomb.timestamp, gc_clock::duration(0))) {
+                    should_split = true;
+                    return;
+                }
+            }
+        });
+    });
+
+    if (should_split) {
+        return true;
     }
 
-    return v._ts;
+    bool had_clustered_row = false;
+
+    if (!p.clustered_rows().empty() && had_static_row) {
+        return true;
+    }
+    for (const rows_entry& cr : p.clustered_rows()) {
+        had_clustered_row = true;
+
+        const auto& marker = cr.row().marker();
+        if (marker.is_live() && check_or_set(marker.timestamp(), marker.is_expiring() ? marker.ttl() : gc_clock::duration(0))) {
+            return true;
+        }
+
+        bool is_insert = marker.is_live();
+
+        bool had_cells = false;
+        cr.row().cells().for_each_cell([&] (column_id id, const atomic_cell_or_collection& cell) {
+            had_cells = true;
+
+            auto& cdef = base_schema.column_at(column_kind::regular_column, id);
+            if (cdef.is_atomic()) {
+                auto view = cell.as_atomic_cell(cdef);
+                if (check_or_set(view.timestamp(), view.is_live_and_has_ttl() ? view.ttl() : gc_clock::duration(0))) {
+                    should_split = true;
+                }
+                return;
+            }
+
+            cell.as_collection_mutation().with_deserialized(*cdef.type, [&] (collection_mutation_view_description mview) {
+                for (auto& [k, v]: mview.cells) {
+                    if (check_or_set(v.timestamp(), v.is_live_and_has_ttl() ? v.ttl() : gc_clock::duration(0))) {
+                        should_split = true;
+                        return;
+                    }
+
+                    if (is_insert) {
+                        // nonatomic updates cannot be expressed with an INSERT.
+                        should_split = true;
+                        return;
+                    }
+                }
+
+                if (mview.tomb) {
+                    if (check_or_set(mview.tomb.timestamp, gc_clock::duration(0))) {
+                        should_split = true;
+                        return;
+                    }
+                }
+            });
+        });
+
+        if (should_split) {
+            return true;
+        }
+
+        auto row_tomb = cr.row().deleted_at().regular();
+        if (row_tomb) {
+            if (had_cells) {
+                return true;
+            }
+
+            // there were no cells, so no ttl
+            assert(!found_ttl);
+            if (found_ts != api::missing_timestamp && found_ts != row_tomb.timestamp) {
+                return true;
+            }
+
+            found_ts = row_tomb.timestamp;
+        }
+    }
+
+    if (!p.row_tombstones().empty() && (had_static_row || had_clustered_row)) {
+        return true;
+    }
+
+    for (const auto& rt: p.row_tombstones()) {
+        if (rt.tomb) {
+            if (found_ts != api::missing_timestamp && found_ts != rt.tomb.timestamp) {
+                return true;
+            }
+
+            found_ts = rt.tomb.timestamp;
+        }
+    }
+
+    if (p.partition_tombstone().timestamp != api::missing_timestamp
+            && (!p.row_tombstones().empty() || had_static_row || had_clustered_row)) {
+        return true;
+    }
+
+    // A mutation with no timestamp will be split into 0 mutations
+    return found_ts == api::missing_timestamp;
 }
 
-/* If a mutation contains multiple timestamps, multiple ttls, or multiple types of changes
- * (e.g. it was created from a batch that both updated a clustered row and deleted a clustered row),
- * we split it into multiple mutations, each with exactly one timestamp, at most one ttl, and a single type of change.
- * We also split if we find both a change with no ttl (e.g. a cell tombstone) and a change with ttl (e.g. a ttled cell update).
- *
- * The `should_split` function checks whether the mutation requires such splitting, using `should_split_visitor`.
- * The visitor uses the order in which the mutation is being visited (see the documentation of ChangeVisitor),
- * remembers a bunch of state based on whatever was visited until now (e.g. was there a static row update?
- * Was there a clustered row update? Was there a clustered row delete? Was there a TTL?)
- * and tells the caller to stop on the first occurence of a second timestamp/ttl/type of change.
- */
-struct should_split_visitor {
-    bool _had_static_row = false;
-    bool _had_clustered_row = false;
-    bool _had_upsert = false;
-    bool _had_row_marker = false;
-    bool _had_range_delete = false;
-
-    bool _result = false;
-
-    // This becomes a valid (non-missing) timestamp after visiting the first change.
-    // Then, if we encounter any different timestamp, it means that we should split.
-    api::timestamp_type _ts = api::missing_timestamp;
-
-    // This becomes non-null after visiting the fist change.
-    // If the change did not have a ttl (e.g. a non-ttled cell, or a tombstone), we store gc_clock::duration(0) there,
-    // because specifying ttl = 0 is equivalent to not specifying a TTL.
-    // Otherwise we store the change's ttl.
-    std::optional<gc_clock::duration> _ttl = std::nullopt;
-
-    inline bool finished() const { return _result; }
-    inline void stop() { _result = true; }
-
-    void visit(api::timestamp_type ts, gc_clock::duration ttl = gc_clock::duration(0)) {
-        if (_ts != api::missing_timestamp && _ts != ts) {
-            return stop();
-        }
-        _ts = ts;
-
-        if (_ttl && *_ttl != ttl) {
-            return stop();
-        }
-        _ttl = { ttl };
-    }
-
-    void visit(const atomic_cell_view& cell) { visit(cell.timestamp(), get_ttl(cell)); }
-
-    void live_atomic_cell(const column_definition&, const atomic_cell_view& cell) { visit(cell); }
-    void dead_atomic_cell(const column_definition&, const atomic_cell_view& cell) { visit(cell); }
-
-    void collection_tombstone(const tombstone& t) { visit(t.timestamp + 1); }
-
-    void live_collection_cell(bytes_view, const atomic_cell_view& cell) {
-        if (_had_row_marker) {
-            // nonatomic updates cannot be expressed with an INSERT.
-            return stop();
-        }
-        visit(cell);
-    }
-    void dead_collection_cell(bytes_view, const atomic_cell_view& cell) { visit(cell); }
-    void collection_column(const column_definition&, auto&& visit_collection) { visit_collection(*this); }
-
-    void marker(const row_marker& rm) {
-        _had_row_marker = true;
-        visit(rm.timestamp(), get_ttl(rm));
-    }
-
-    void static_row_cells(auto&& visit_row_cells) {
-        _had_static_row = true;
-        visit_row_cells(*this);
-    }
-
-    void clustered_row_cells(const clustering_key&, auto&& visit_row_cells) {
-        if (_had_static_row) {
-            return stop();
-        }
-        _had_clustered_row = _had_upsert = true;
-        visit_row_cells(*this);
-    }
-
-    void clustered_row_delete(const clustering_key&, const tombstone& t) {
-        if (_had_static_row || _had_upsert) {
-            return stop();
-        }
-        _had_clustered_row = true;
-        visit(t.timestamp);
-    }
-
-    void range_delete(const range_tombstone& t) {
-        if (_had_static_row || _had_clustered_row) {
-            return stop();
-        }
-        _had_range_delete = true;
-        visit(t.tomb.timestamp);
-    }
-
-    void partition_delete(const tombstone&) {
-        if (_had_range_delete || _had_static_row || _had_clustered_row) {
-            return stop();
-        }
-    }
-};
-
-bool should_split(const mutation& m) {
-    should_split_visitor v;
-
-    cdc::inspect_mutation(m, v);
-
-    return v._result
-    // A mutation with no timestamp will be split into 0 mutations:
-        || v._ts == api::missing_timestamp;
-}
-
-void process_changes_with_splitting(const mutation& base_mutation, change_processor& processor,
-        bool enable_preimage, bool enable_postimage) {
-    const auto base_schema = base_mutation.schema();
-    auto changes = extract_changes(base_mutation);
+void for_each_change(const mutation& base_mutation, const schema_ptr& base_schema,
+        seastar::noncopyable_function<void(mutation, api::timestamp_type, bytes, int&)> f) {
+    auto changes = extract_changes(base_mutation, *base_schema);
     auto pk = base_mutation.key();
 
-    if (changes.empty()) {
-        return;
-    }
-
-    const auto last_timestamp = changes.rbegin()->first;
-
     for (auto& [change_ts, btch] : changes) {
-        const bool is_last = change_ts == last_timestamp;
-        processor.begin_timestamp(change_ts, is_last);
-
-        clustered_column_set affected_clustered_columns_per_row{clustering_key::less_compare(*base_schema)};
-        one_kind_column_set affected_static_columns{base_schema->static_columns_count()};
-
-        if (enable_preimage || enable_postimage) {
-            affected_static_columns = btch.get_affected_static_columns(*base_schema);
-            affected_clustered_columns_per_row = btch.get_affected_clustered_columns_per_row(*base_mutation.schema());
-        }
-
-        if (enable_preimage) {
-            if (affected_static_columns.count() > 0) {
-                processor.produce_preimage(nullptr, affected_static_columns);
-            }
-            for (const auto& [ck, affected_row_cells] : affected_clustered_columns_per_row) {
-                processor.produce_preimage(&ck, affected_row_cells);
-            }
-        }
+        auto tuuid = timeuuid_type->decompose(generate_timeuuid(change_ts));
+        int batch_no = 0;
 
         for (auto& sr_update : btch.static_updates) {
             mutation m(base_schema, pk);
@@ -618,11 +392,15 @@ void process_changes_with_splitting(const mutation& base_mutation, change_proces
                 auto& cdef = base_schema->column_at(column_kind::static_column, atomic_update.id);
                 m.set_static_cell(cdef, std::move(atomic_update.cell));
             }
-            for (auto& nonatomic_update : sr_update.nonatomic_entries) {
-                auto& cdef = base_schema->column_at(column_kind::static_column, nonatomic_update.id);
-                m.set_static_cell(cdef, collection_mutation_description{nonatomic_update.t, std::move(nonatomic_update.cells)}.serialize(*cdef.type));
+            for (auto& nonatomic_delete : sr_update.nonatomic_deletions) {
+                auto& cdef = base_schema->column_at(column_kind::static_column, nonatomic_delete.id);
+                m.set_static_cell(cdef, collection_mutation_description{nonatomic_delete.t, {}}.serialize(*cdef.type));
             }
-            processor.process_change(m);
+            for (auto& nonatomic_update : sr_update.nonatomic_updates) {
+                auto& cdef = base_schema->column_at(column_kind::static_column, nonatomic_update.id);
+                m.set_static_cell(cdef, collection_mutation_description{{}, std::move(nonatomic_update.cells)}.serialize(*cdef.type));
+            }
+            f(std::move(m), change_ts, tuuid, batch_no);
         }
 
         for (auto& cr_insert : btch.clustered_inserts) {
@@ -633,13 +411,13 @@ void process_changes_with_splitting(const mutation& base_mutation, change_proces
                 auto& cdef = base_schema->column_at(column_kind::regular_column, atomic_update.id);
                 row.cells().apply(cdef, std::move(atomic_update.cell));
             }
-            for (auto& nonatomic_update : cr_insert.nonatomic_entries) {
-                auto& cdef = base_schema->column_at(column_kind::regular_column, nonatomic_update.id);
-                row.cells().apply(cdef, collection_mutation_description{nonatomic_update.t, std::move(nonatomic_update.cells)}.serialize(*cdef.type));
+            for (auto& nonatomic_delete : cr_insert.nonatomic_deletions) {
+                auto& cdef = base_schema->column_at(column_kind::regular_column, nonatomic_delete.id);
+                row.cells().apply(cdef, collection_mutation_description{nonatomic_delete.t, {}}.serialize(*cdef.type));
             }
             row.apply(cr_insert.marker);
 
-            processor.process_change(m);
+            f(std::move(m), change_ts, tuuid, batch_no);
         }
 
         for (auto& cr_update : btch.clustered_updates) {
@@ -650,91 +428,36 @@ void process_changes_with_splitting(const mutation& base_mutation, change_proces
                 auto& cdef = base_schema->column_at(column_kind::regular_column, atomic_update.id);
                 row.apply(cdef, std::move(atomic_update.cell));
             }
-            for (auto& nonatomic_update : cr_update.nonatomic_entries) {
+            for (auto& nonatomic_delete : cr_update.nonatomic_deletions) {
+                auto& cdef = base_schema->column_at(column_kind::regular_column, nonatomic_delete.id);
+                row.apply(cdef, collection_mutation_description{nonatomic_delete.t, {}}.serialize(*cdef.type));
+            }
+            for (auto& nonatomic_update : cr_update.nonatomic_updates) {
                 auto& cdef = base_schema->column_at(column_kind::regular_column, nonatomic_update.id);
-                row.apply(cdef, collection_mutation_description{nonatomic_update.t, std::move(nonatomic_update.cells)}.serialize(*cdef.type));
+                row.apply(cdef, collection_mutation_description{{}, std::move(nonatomic_update.cells)}.serialize(*cdef.type));
             }
 
-            processor.process_change(m);
+            f(std::move(m), change_ts, tuuid, batch_no);
         }
 
         for (auto& cr_delete : btch.clustered_row_deletions) {
             mutation m(base_schema, pk);
             m.partition().apply_delete(*base_schema, cr_delete.key, cr_delete.t);
-            processor.process_change(m);
+            f(std::move(m), change_ts, tuuid, batch_no);
         }
 
         for (auto& crange_delete : btch.clustered_range_deletions) {
             mutation m(base_schema, pk);
             m.partition().apply_delete(*base_schema, crange_delete.rt);
-            processor.process_change(m);
+            f(std::move(m), change_ts, tuuid, batch_no);
         }
 
         if (btch.partition_deletions) {
             mutation m(base_schema, pk);
             m.partition().apply(btch.partition_deletions->t);
-            processor.process_change(m);
-        }
-
-        if (enable_postimage) {
-            if (affected_static_columns.count() > 0) {
-                processor.produce_postimage(nullptr);
-            }
-            for (const auto& [ck, crow] : affected_clustered_columns_per_row) {
-                processor.produce_postimage(&ck);
-            }
-        }
-
-        processor.end_record();
-    }
-}
-
-void process_changes_without_splitting(const mutation& base_mutation, change_processor& processor,
-        bool enable_preimage, bool enable_postimage) {
-    auto ts = find_timestamp(base_mutation);
-    processor.begin_timestamp(ts, true);
-
-    const auto base_schema = base_mutation.schema();
-
-    if (enable_preimage) {
-        const auto& p = base_mutation.partition();
-
-        one_kind_column_set columns{base_schema->static_columns_count()};
-        if (!p.static_row().empty()) {
-            p.static_row().get().for_each_cell([&] (column_id id, const atomic_cell_or_collection& cell) {
-                columns.set(id);
-            });
-            processor.produce_preimage(nullptr, columns);
-        }
-
-        columns.resize(base_schema->regular_columns_count());
-        for (const rows_entry& cr : p.clustered_rows()) {
-            columns.reset();
-            if (cr.row().deleted_at().regular()) {
-                // Row deleted - include all columns in preimage
-                columns.set(0, base_schema->regular_columns_count(), true);
-            } else {
-                cr.row().cells().for_each_cell([&] (column_id id, const atomic_cell_or_collection& cell) {
-                    columns.set(id);
-                });
-            }
-            processor.produce_preimage(&cr.key(), columns);
+            f(std::move(m), change_ts, tuuid, batch_no);
         }
     }
-
-    processor.process_change(base_mutation);
-
-    if (enable_postimage) {
-        const auto& p = base_mutation.partition();
-        if (!p.static_row().empty()) {
-            processor.produce_postimage(nullptr);
-        }
-        for (const rows_entry& cr : p.clustered_rows()) {
-            processor.produce_postimage(&cr.key());
-        }
-    }
-
-    processor.end_record();
 }
 
 } // namespace cdc

cdc/split.hh

@@ -22,7 +22,6 @@
 #pragma once
 
 #include <vector>
-#include <boost/dynamic_bitset.hpp>
 #include "schema_fwd.hh"
 #include "timestamp.hh"
 #include "bytes.hh"
@@ -32,61 +31,8 @@ class mutation;
 
 namespace cdc {
 
-// Represents a set of column ids of one kind (partition key, clustering key, regular row or static row).
-// There already exists a column_set type, but it keeps ordinal_column_ids, not column_ids (ordinal column ids
-// are unique across whole table, while kind-specific ids are unique only within one column kind).
-// To avoid converting back and forth between ordinal and kind-specific ids, one_kind_column_set is used instead.
-using one_kind_column_set = boost::dynamic_bitset<uint64_t>;
-
-// An object that processes changes from a single, big mutation.
-// It is intended to be used with process_changes_xxx_splitting. Those functions define the order and layout in which
-// changes should appear in CDC log, and change_processor is responsible for producing CDC log rows from changes given
-// by those two functions.
-//
-// The flow of calling its methods should go as follows:
-//   -> begin_timestamp #1
-//     -> produce_preimage (one call for each preimage row to be generated)
-//     -> process_change (one call for each part generated by the splitting function)
-//     -> produce_postimage (one call for each postimage row to be generated)
-//   -> begin_timestamp #2
-//   ...
-class change_processor {
-protected:
-    ~change_processor() {};
-public:
-    // Tells the processor that changes that follow from now on will be of given timestamp.
-    // This method must be called in increasing timestamp order.
-    // begin_timestamp can be called only once for a given timestamp and change_processor object.
-    //   ts - timestamp of mutation parts
-    //   is_last - determines if this will be the last timestamp to be processed by this change_processor instance.
-    virtual void begin_timestamp(api::timestamp_type ts, bool is_last) = 0;
-
-    // Tells the processor to produce a preimage for a given clustering/static row.
-    //   ck - clustering key of the row for which to produce a preimage; if nullptr, static row preimage is requested
-    //   columns_to_include - include information about the current state of those columns only, leave others as null
-    virtual void produce_preimage(const clustering_key* ck, const one_kind_column_set& columns_to_include) = 0;
-
-    // Tells the processor to produce a postimage for a given clustering/static row.
-    // Contrary to preimage, this requires data from all columns to be present.
-    //   ck - clustering key of the row for which to produce a postimage; if nullptr, static row postimage is requested
-    virtual void produce_postimage(const clustering_key* ck) = 0;
-
-    // Processes a smaller mutation which is a subset of the big mutation.
-    // The mutation provided to process_change should be simple enough for it to be possible to convert it
-    // into CDC log rows - for example, it cannot represent a write to two columns of the same row, where
-    // both columns have different timestamp or TTL set.
-    //   m - the small mutation to be converted into CDC log rows.
-    virtual void process_change(const mutation& m) = 0;
-
-    // Tells processor we have reached end of record - last part
-    // of a given timestamp batch
-    virtual void end_record() = 0;
-};
-
-bool should_split(const mutation& base_mutation);
-void process_changes_with_splitting(const mutation& base_mutation, change_processor& processor,
-        bool enable_preimage, bool enable_postimage);
-void process_changes_without_splitting(const mutation& base_mutation, change_processor& processor,
-        bool enable_preimage, bool enable_postimage);
+bool should_split(const mutation& base_mutation, const schema& base_schema);
+void for_each_change(const mutation& base_mutation, const schema_ptr& base_schema,
+        seastar::noncopyable_function<void(mutation, api::timestamp_type, bytes, int&)>);
 
 }

clustering_bounds_comparator.hh

@@ -122,26 +122,26 @@ public:
         return {_empty_prefix, bound_kind::incl_end};
     }
     template<template<typename> typename R>
-    requires Range<R, clustering_key_prefix_view>
+    GCC6_CONCEPT( requires Range<R, clustering_key_prefix_view> )
     static bound_view from_range_start(const R<clustering_key_prefix>& range) {
         return range.start()
                ? bound_view(range.start()->value(), range.start()->is_inclusive() ? bound_kind::incl_start : bound_kind::excl_start)
                : bottom();
     }
     template<template<typename> typename R>
-    requires Range<R, clustering_key_prefix>
+    GCC6_CONCEPT( requires Range<R, clustering_key_prefix> )
     static bound_view from_range_end(const R<clustering_key_prefix>& range) {
         return range.end()
                ? bound_view(range.end()->value(), range.end()->is_inclusive() ? bound_kind::incl_end : bound_kind::excl_end)
                : top();
     }
     template<template<typename> typename R>
-    requires Range<R, clustering_key_prefix>
+    GCC6_CONCEPT( requires Range<R, clustering_key_prefix> )
     static std::pair<bound_view, bound_view> from_range(const R<clustering_key_prefix>& range) {
         return {from_range_start(range), from_range_end(range)};
     }
     template<template<typename> typename R>
-    requires Range<R, clustering_key_prefix_view>
+    GCC6_CONCEPT( requires Range<R, clustering_key_prefix_view> )
     static std::optional<typename R<clustering_key_prefix_view>::bound> to_range_bound(const bound_view& bv) {
         if (&bv._prefix.get() == &_empty_prefix) {
             return {};

collection_mutation.cc

@@ -61,7 +61,7 @@ bool collection_mutation_view::is_empty() const {
 }
 
 template <typename F>
-requires std::is_invocable_r_v<const data::type_info&, F, collection_mutation_input_stream&>
+GCC6_CONCEPT(requires std::is_invocable_r_v<const data::type_info&, F, collection_mutation_input_stream&>)
 static bool is_any_live(const atomic_cell_value_view& data, tombstone tomb, gc_clock::time_point now, F&& read_cell_type_info) {
     auto in = collection_mutation_input_stream(data);
     auto has_tomb = in.read_trivial<bool>();
@@ -108,7 +108,7 @@ bool collection_mutation_view::is_any_live(const abstract_type& type, tombstone
 }
 
 template <typename F>
-requires std::is_invocable_r_v<const data::type_info&, F, collection_mutation_input_stream&>
+GCC6_CONCEPT(requires std::is_invocable_r_v<const data::type_info&, F, collection_mutation_input_stream&>)
 static api::timestamp_type last_update(const atomic_cell_value_view& data, F&& read_cell_type_info) {
     auto in = collection_mutation_input_stream(data);
     api::timestamp_type max = api::missing_timestamp;
@@ -313,7 +313,7 @@ collection_mutation collection_mutation_view_description::serialize(const abstra
 }
 
 template <typename C>
-requires std::is_base_of_v<abstract_type, std::remove_reference_t<C>>
+GCC6_CONCEPT(requires std::is_base_of_v<abstract_type, std::remove_reference_t<C>>)
 static collection_mutation_view_description
 merge(collection_mutation_view_description a, collection_mutation_view_description b, C&& key_type) {
     using element_type = std::pair<bytes_view, atomic_cell_view>;
@@ -375,7 +375,7 @@ collection_mutation merge(const abstract_type& type, collection_mutation_view a,
 }
 
 template <typename C>
-requires std::is_base_of_v<abstract_type, std::remove_reference_t<C>>
+GCC6_CONCEPT(requires std::is_base_of_v<abstract_type, std::remove_reference_t<C>>)
 static collection_mutation_view_description
 difference(collection_mutation_view_description a, collection_mutation_view_description b, C&& key_type)
 {
@@ -421,7 +421,7 @@ collection_mutation difference(const abstract_type& type, collection_mutation_vi
 }
 
 template <typename F>
-requires std::is_invocable_r_v<std::pair<bytes_view, atomic_cell_view>, F, collection_mutation_input_stream&>
+GCC6_CONCEPT(requires std::is_invocable_r_v<std::pair<bytes_view, atomic_cell_view>, F, collection_mutation_input_stream&>)
 static collection_mutation_view_description
 deserialize_collection_mutation(collection_mutation_input_stream& in, F&& read_kv) {
     collection_mutation_view_description ret;

column_computation.hh

@@ -21,7 +21,8 @@
 
 #pragma once
 
-#include "utils/rjson.hh"
+#include <json/json.h>
+
 #include "bytes.hh"
 
 class schema;
@@ -46,7 +47,7 @@ public:
     virtual ~column_computation() = default;
 
     static column_computation_ptr deserialize(bytes_view raw);
-    static column_computation_ptr deserialize(const rjson::value& json);
+    static column_computation_ptr deserialize(const Json::Value& json);
 
     virtual column_computation_ptr clone() const = 0;
 

compaction_strategy.hh

@@ -23,13 +23,11 @@
 
 #include <seastar/core/future.hh>
 #include <seastar/util/noncopyable_function.hh>
-#include <seastar/core/file.hh>
 
 #include "schema_fwd.hh"
 #include "sstables/shared_sstable.hh"
 #include "exceptions/exceptions.hh"
 #include "sstables/compaction_backlog_manager.hh"
-#include "compaction_strategy_type.hh"
 
 class table;
 using column_family = table;
@@ -39,6 +37,15 @@ struct mutation_source_metadata;
 
 namespace sstables {
 
+enum class compaction_strategy_type {
+    null,
+    major,
+    size_tiered,
+    leveled,
+    date_tiered,
+    time_window,
+};
+
 class compaction_strategy_impl;
 class sstable;
 class sstable_set;
@@ -63,6 +70,8 @@ public:
 
     compaction_descriptor get_major_compaction_job(column_family& cf, std::vector<shared_sstable> candidates);
 
+    std::vector<resharding_descriptor> get_resharding_jobs(column_family& cf, std::vector<shared_sstable> candidates);
+
     // Some strategies may look at the compacted and resulting sstables to
     // get some useful information for subsequent compactions.
     void notify_completion(const std::vector<shared_sstable>& removed, const std::vector<shared_sstable>& added);
@@ -134,20 +143,6 @@ public:
 
     // Returns whether or not interposer consumer is used by a given strategy.
     bool use_interposer_consumer() const;
-
-    // Informs the caller (usually the compaction manager) about what would it take for this set of
-    // SSTables closer to becoming in-strategy. If this returns an empty compaction descriptor, this
-    // means that the sstable set is already in-strategy.
-    //
-    // The caller can specify one of two modes: strict or relaxed. In relaxed mode the tolerance for
-    // what is considered offstrategy is higher. It can be used, for instance, for when the system
-    // is restarting and previous compactions were likely in-flight. In strict mode, we are less
-    // tolerant to invariant breakages.
-    //
-    // The caller should also pass a maximum number of SSTables which is the maximum amount of
-    // SSTables that can be added into a single job.
-    compaction_descriptor get_reshaping_job(std::vector<shared_sstable> input, schema_ptr schema, const ::io_priority_class& iop, reshape_mode mode);
-
 };
 
 // Creates a compaction_strategy object from one of the strategies available.

compaction_strategy_type.hh

@@ -1,36 +0,0 @@
-/*
- * Copyright (C) 2020 ScyllaDB
- */
-
-/*
- * This file is part of Scylla.
- *
- * Scylla is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Scylla 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 GNU General Public License
- * along with Scylla.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-namespace sstables {
-
-enum class compaction_strategy_type {
-    null,
-    major,
-    size_tiered,
-    leveled,
-    date_tiered,
-    time_window,
-};
-
-enum class reshape_mode { strict, relaxed };
-}

compound.hh

@@ -29,6 +29,7 @@
 #include <boost/range/adaptor/transformed.hpp>
 #include "utils/serialization.hh"
 #include <seastar/util/backtrace.hh>
+#include "unimplemented.hh"
 
 enum class allow_prefixes { no, yes };
 
@@ -90,7 +91,7 @@ private:
         return len;
     }
 public:
-    bytes serialize_single(bytes&& v) const {
+    bytes serialize_single(bytes&& v) {
         return serialize_value({std::move(v)});
     }
     template<typename RangeOfSerializedComponents>
@@ -108,7 +109,7 @@ public:
     static bytes serialize_value(std::initializer_list<T> values) {
         return serialize_value(boost::make_iterator_range(values.begin(), values.end()));
     }
-    bytes serialize_optionals(const std::vector<bytes_opt>& values) const {
+    bytes serialize_optionals(const std::vector<bytes_opt>& values) {
         return serialize_value(values | boost::adaptors::transformed([] (const bytes_opt& bo) -> bytes_view {
             if (!bo) {
                 throw std::logic_error("attempted to create key component from empty optional");
@@ -116,7 +117,7 @@ public:
             return *bo;
         }));
     }
-    bytes serialize_value_deep(const std::vector<data_value>& values) const {
+    bytes serialize_value_deep(const std::vector<data_value>& values) {
         // TODO: Optimize
         std::vector<bytes> partial;
         partial.reserve(values.size());
@@ -127,7 +128,7 @@ public:
         }
         return serialize_value(partial);
     }
-    bytes decompose_value(const value_type& values) const {
+    bytes decompose_value(const value_type& values) {
         return serialize_value(values);
     }
     class iterator : public std::iterator<std::input_iterator_tag, const bytes_view> {
@@ -179,7 +180,7 @@ public:
     static boost::iterator_range<iterator> components(const bytes_view& v) {
         return { begin(v), end(v) };
     }
-    value_type deserialize_value(bytes_view v) const {
+    value_type deserialize_value(bytes_view v) {
         std::vector<bytes> result;
         result.reserve(_types.size());
         std::transform(begin(v), end(v), std::back_inserter(result), [] (auto&& v) {
@@ -187,10 +188,10 @@ public:
         });
         return result;
     }
-    bool less(bytes_view b1, bytes_view b2) const {
+    bool less(bytes_view b1, bytes_view b2) {
         return compare(b1, b2) < 0;
     }
-    size_t hash(bytes_view v) const {
+    size_t hash(bytes_view v) {
         if (_byte_order_equal) {
             return std::hash<bytes_view>()(v);
         }
@@ -202,7 +203,7 @@ public:
         }
         return h;
     }
-    int compare(bytes_view b1, bytes_view b2) const {
+    int compare(bytes_view b1, bytes_view b2) {
         if (_byte_order_comparable) {
             if (_is_reversed) {
                 return compare_unsigned(b2, b1);
@@ -223,21 +224,11 @@ public:
     bool is_empty(bytes_view v) const {
         return begin(v) == end(v);
     }
-    void validate(bytes_view v) const {
-        std::vector<bytes_view> values(begin(v), end(v));
-        if (AllowPrefixes == allow_prefixes::no && values.size() < _types.size()) {
-            throw marshal_exception(fmt::format("compound::validate(): non-prefixable compound cannot be a prefix"));
-        }
-        if (values.size() > _types.size()) {
-            throw marshal_exception(fmt::format("compound::validate(): cannot have more values than types, have {} values but only {} types",
-                        values.size(), _types.size()));
-        }
-        for (size_t i = 0; i != values.size(); ++i) {
-            //FIXME: is it safe to assume internal serialization-format format?
-            _types[i]->validate(values[i], cql_serialization_format::internal());
-        }
+    void validate(bytes_view v) {
+        // FIXME: implement
+        warn(unimplemented::cause::VALIDATION);
     }
-    bool equal(bytes_view v1, bytes_view v2) const {
+    bool equal(bytes_view v1, bytes_view v2) {
         if (_byte_order_equal) {
             return compare_unsigned(v1, v2) == 0;
         }

compound_compat.hh

@@ -148,8 +148,8 @@ public:
                 _type.begin(k1), _type.end(k1),
                 _type.begin(k2), _type.end(k2),
                 [] (const bytes_view& c1, const bytes_view& c2) -> int {
-                    if (c1.size() != c2.size() || !c1.size()) {
-                        return c1.size() < c2.size() ? -1 : c1.size() ? 1 : 0;
+                    if (c1.size() != c2.size()) {
+                        return c1.size() < c2.size() ? -1 : 1;
                     }
                     return memcmp(c1.begin(), c2.begin(), c1.size());
                 });
@@ -213,8 +213,6 @@ public:
             , _is_compound(true)
     { }
 
-    explicit composite(const composite_view& v);
-
     composite()
             : _bytes()
             , _is_compound(true)
@@ -505,7 +503,6 @@ public:
 };
 
 class composite_view final {
-    friend class composite;
     bytes_view _bytes;
     bool _is_compound;
 public:
@@ -605,11 +602,6 @@ public:
     }
 };
 
-inline
-composite::composite(const composite_view& v)
-    : composite(bytes(v._bytes), v._is_compound)
-{ }
-
 inline
 std::ostream& operator<<(std::ostream& os, const composite& v) {
     return os << composite_view(v);

compress.cc

@@ -205,7 +205,7 @@ void compression_parameters::validate_options(const std::map<sstring, sstring>&
         ckw = _compressor->option_names();
     }
     for (auto&& opt : options) {
-        if (!keywords.contains(opt.first) && !ckw.contains(opt.first)) {
+        if (!keywords.count(opt.first) && !ckw.count(opt.first)) {
             throw exceptions::configuration_exception(format("Unknown compression option '{}'.", opt.first));
         }
     }

concrete_types.hh

@@ -152,39 +152,41 @@ struct uuid_type_impl final : public concrete_type<utils::UUID> {
 
 template <typename Func> using visit_ret_type = std::invoke_result_t<Func, const ascii_type_impl&>;
 
-template <typename Func> concept CanHandleAllTypes = requires(Func f) {
-    { f(*static_cast<const ascii_type_impl*>(nullptr)) }       -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const boolean_type_impl*>(nullptr)) }     -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const byte_type_impl*>(nullptr)) }        -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const bytes_type_impl*>(nullptr)) }       -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const counter_type_impl*>(nullptr)) }     -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const date_type_impl*>(nullptr)) }        -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const decimal_type_impl*>(nullptr)) }     -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const double_type_impl*>(nullptr)) }      -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const duration_type_impl*>(nullptr)) }    -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const empty_type_impl*>(nullptr)) }       -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const float_type_impl*>(nullptr)) }       -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const inet_addr_type_impl*>(nullptr)) }   -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const int32_type_impl*>(nullptr)) }       -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const list_type_impl*>(nullptr)) }        -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const long_type_impl*>(nullptr)) }        -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const map_type_impl*>(nullptr)) }         -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const reversed_type_impl*>(nullptr)) }    -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const set_type_impl*>(nullptr)) }         -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const short_type_impl*>(nullptr)) }       -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const simple_date_type_impl*>(nullptr)) } -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const time_type_impl*>(nullptr)) }        -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const timestamp_type_impl*>(nullptr)) }   -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const timeuuid_type_impl*>(nullptr)) }    -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const tuple_type_impl*>(nullptr)) }       -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const user_type_impl*>(nullptr)) }        -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const utf8_type_impl*>(nullptr)) }        -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const uuid_type_impl*>(nullptr)) }        -> std::same_as<visit_ret_type<Func>>;
-    { f(*static_cast<const varint_type_impl*>(nullptr)) }      -> std::same_as<visit_ret_type<Func>>;
+GCC6_CONCEPT(
+template <typename Func> concept bool CanHandleAllTypes = requires(Func f) {
+    { f(*static_cast<const ascii_type_impl*>(nullptr)) }       -> visit_ret_type<Func>;
+    { f(*static_cast<const boolean_type_impl*>(nullptr)) }     -> visit_ret_type<Func>;
+    { f(*static_cast<const byte_type_impl*>(nullptr)) }        -> visit_ret_type<Func>;
+    { f(*static_cast<const bytes_type_impl*>(nullptr)) }       -> visit_ret_type<Func>;
+    { f(*static_cast<const counter_type_impl*>(nullptr)) }     -> visit_ret_type<Func>;
+    { f(*static_cast<const date_type_impl*>(nullptr)) }        -> visit_ret_type<Func>;
+    { f(*static_cast<const decimal_type_impl*>(nullptr)) }     -> visit_ret_type<Func>;
+    { f(*static_cast<const double_type_impl*>(nullptr)) }      -> visit_ret_type<Func>;
+    { f(*static_cast<const duration_type_impl*>(nullptr)) }    -> visit_ret_type<Func>;
+    { f(*static_cast<const empty_type_impl*>(nullptr)) }       -> visit_ret_type<Func>;
+    { f(*static_cast<const float_type_impl*>(nullptr)) }       -> visit_ret_type<Func>;
+    { f(*static_cast<const inet_addr_type_impl*>(nullptr)) }   -> visit_ret_type<Func>;
+    { f(*static_cast<const int32_type_impl*>(nullptr)) }       -> visit_ret_type<Func>;
+    { f(*static_cast<const list_type_impl*>(nullptr)) }        -> visit_ret_type<Func>;
+    { f(*static_cast<const long_type_impl*>(nullptr)) }        -> visit_ret_type<Func>;
+    { f(*static_cast<const map_type_impl*>(nullptr)) }         -> visit_ret_type<Func>;
+    { f(*static_cast<const reversed_type_impl*>(nullptr)) }    -> visit_ret_type<Func>;
+    { f(*static_cast<const set_type_impl*>(nullptr)) }         -> visit_ret_type<Func>;
+    { f(*static_cast<const short_type_impl*>(nullptr)) }       -> visit_ret_type<Func>;
+    { f(*static_cast<const simple_date_type_impl*>(nullptr)) } -> visit_ret_type<Func>;
+    { f(*static_cast<const time_type_impl*>(nullptr)) }        -> visit_ret_type<Func>;
+    { f(*static_cast<const timestamp_type_impl*>(nullptr)) }   -> visit_ret_type<Func>;
+    { f(*static_cast<const timeuuid_type_impl*>(nullptr)) }    -> visit_ret_type<Func>;
+    { f(*static_cast<const tuple_type_impl*>(nullptr)) }       -> visit_ret_type<Func>;
+    { f(*static_cast<const user_type_impl*>(nullptr)) }        -> visit_ret_type<Func>;
+    { f(*static_cast<const utf8_type_impl*>(nullptr)) }        -> visit_ret_type<Func>;
+    { f(*static_cast<const uuid_type_impl*>(nullptr)) }        -> visit_ret_type<Func>;
+    { f(*static_cast<const varint_type_impl*>(nullptr)) }      -> visit_ret_type<Func>;
 };
+)
 
 template<typename Func>
-requires CanHandleAllTypes<Func>
+GCC6_CONCEPT(requires CanHandleAllTypes<Func>)
 static inline visit_ret_type<Func> visit(const abstract_type& t, Func&& f) {
     switch (t.get_kind()) {
     case abstract_type::kind::ascii:

conf/scylla.yaml

@@ -100,13 +100,8 @@ listen_address: localhost
 
 # port for the CQL native transport to listen for clients on
 # For security reasons, you should not expose this port to the internet.  Firewall it if needed.
-# To disable the CQL native transport, set this option to 0.
 native_transport_port: 9042
 
-# Like native_transport_port, but clients are forwarded to specific shards, based on the
-# client-side port numbers.
-native_shard_aware_transport_port: 19042
-
 # Enabling native transport encryption in client_encryption_options allows you to either use
 # encryption for the standard port or to use a dedicated, additional port along with the unencrypted
 # standard native_transport_port.
@@ -116,10 +111,6 @@ native_shard_aware_transport_port: 19042
 # keeping native_transport_port unencrypted.
 #native_transport_port_ssl: 9142
 
-# Like native_transport_port_ssl, but clients are forwarded to specific shards, based on the
-# client-side port numbers.
-#native_shard_aware_transport_port_ssl: 19142
-
 # How long the coordinator should wait for read operations to complete
 read_request_timeout_in_ms: 5000
 

counters.cc

@@ -29,6 +29,15 @@ counter_id counter_id::local()
     return counter_id(service::get_local_storage_service().get_local_id());
 }
 
+bool counter_id::less_compare_1_7_4::operator()(const counter_id& a, const counter_id& b) const
+{
+    if (a._most_significant != b._most_significant) {
+        return a._most_significant < b._most_significant;
+    } else {
+        return a._least_significant < b._least_significant;
+    }
+}
+
 std::ostream& operator<<(std::ostream& os, const counter_id& id) {
     return os << id.to_uuid();
 }
@@ -59,6 +68,16 @@ void counter_cell_builder::do_sort_and_remove_duplicates()
     _sorted = true;
 }
 
+std::vector<counter_shard> counter_cell_view::shards_compatible_with_1_7_4() const
+{
+    auto sorted_shards = boost::copy_range<std::vector<counter_shard>>(shards());
+    counter_id::less_compare_1_7_4 cmp;
+    boost::range::sort(sorted_shards, [&] (auto& a, auto& b) {
+        return cmp(a.id(), b.id());
+    });
+    return sorted_shards;
+}
+
 static bool apply_in_place(const column_definition& cdef, atomic_cell_mutable_view dst, atomic_cell_mutable_view src)
 {
     auto dst_ccmv = counter_cell_mutable_view(dst);

counters.hh

@@ -60,6 +60,11 @@ public:
     bool operator!=(const counter_id& other) const {
         return !(*this == other);
     }
+public:
+    // (Wrong) Counter ID ordering used by Scylla 1.7.4 and earlier.
+    struct less_compare_1_7_4 {
+        bool operator()(const counter_id& a, const counter_id& b) const;
+    };
 public:
     static counter_id local();
 
@@ -68,9 +73,7 @@ public:
         return counter_id(utils::make_random_uuid());
     }
 };
-static_assert(
-        std::is_standard_layout_v<counter_id> && std::is_trivial_v<counter_id>,
-        "counter_id should be a POD type");
+static_assert(std::is_pod<counter_id>::value, "counter_id should be a POD type");
 
 std::ostream& operator<<(std::ostream& os, const counter_id& id);
 
@@ -151,10 +154,10 @@ private:
     // Shared logic for applying counter_shards and counter_shard_views.
     // T is either counter_shard or basic_counter_shard_view<U>.
     template<typename T>
-    requires requires(T shard) {
-        { shard.value() } -> std::same_as<int64_t>;
-        { shard.logical_clock() } -> std::same_as<int64_t>;
-    }
+    GCC6_CONCEPT(requires requires(T shard) {
+        { shard.value() } -> int64_t;
+        { shard.logical_clock() } -> int64_t;
+    })
     counter_shard& do_apply(T&& other) noexcept {
         auto other_clock = other.logical_clock();
         if (_logical_clock < other_clock) {
@@ -181,7 +184,7 @@ public:
     int64_t logical_clock() const { return _logical_clock; }
 
     counter_shard& update(int64_t value_delta, int64_t clock_increment) noexcept {
-        _value = uint64_t(_value) + uint64_t(value_delta); // signed int overflow is undefined hence the cast
+        _value += value_delta;
         _logical_clock += clock_increment;
         return *this;
     }
@@ -286,7 +289,7 @@ public:
             return *this;
         }
         inserter_iterator& operator=(const counter_shard_view& csv) {
-            return this->operator=(counter_shard(csv));
+            return operator=(counter_shard(csv));
         }
         inserter_iterator& operator++() { return *this; }
         inserter_iterator& operator++(int) { return *this; }
@@ -412,6 +415,9 @@ struct counter_cell_view : basic_counter_cell_view<mutable_view::no> {
         });
     }
 
+    // Returns counter shards in an order that is compatible with Scylla 1.7.4.
+    std::vector<counter_shard> shards_compatible_with_1_7_4() const;
+
     // Reversibly applies two counter cells, at least one of them must be live.
     static void apply(const column_definition& cdef, atomic_cell_or_collection& dst, atomic_cell_or_collection& src);
 

cql3/Cql.g

@@ -93,7 +93,6 @@ options {
 #include "cql3/ut_name.hh"
 #include "cql3/functions/function_name.hh"
 #include "cql3/functions/function_call.hh"
-#include "cql3/expr/expression.hh"
 #include <seastar/core/sstring.hh>
 #include "CqlLexer.hpp"
 
@@ -107,7 +106,7 @@ using namespace cql3::statements;
 using namespace cql3::selection;
 using cql3::cql3_type;
 using conditions_type = std::vector<std::pair<::shared_ptr<cql3::column_identifier::raw>,lw_shared_ptr<cql3::column_condition::raw>>>;
-using operations_type = std::vector<std::pair<::shared_ptr<cql3::column_identifier::raw>, std::unique_ptr<cql3::operation::raw_update>>>;
+using operations_type = std::vector<std::pair<::shared_ptr<cql3::column_identifier::raw>,::shared_ptr<cql3::operation::raw_update>>>;
 
 // ANTLR forces us to define a default-initialized return value
 // for every rule (e.g. [returns ut_name name]), but not every type
@@ -256,8 +255,8 @@ struct uninitialized {
         return to_lower(s) == "true";
     }
 
-    void add_raw_update(std::vector<std::pair<::shared_ptr<cql3::column_identifier::raw>, std::unique_ptr<cql3::operation::raw_update>>>& operations,
-        ::shared_ptr<cql3::column_identifier::raw> key, std::unique_ptr<cql3::operation::raw_update> update)
+    void add_raw_update(std::vector<std::pair<::shared_ptr<cql3::column_identifier::raw>,::shared_ptr<cql3::operation::raw_update>>>& operations,
+        ::shared_ptr<cql3::column_identifier::raw> key, ::shared_ptr<cql3::operation::raw_update> update)
     {
         for (auto&& p : operations) {
             if (*p.first == *key && !p.second->is_compatible_with(update)) {
@@ -533,7 +532,7 @@ updateStatement returns [std::unique_ptr<raw::update_statement> expr]
     @init {
         bool if_exists = false;
         auto attrs = std::make_unique<cql3::attributes::raw>();
-        std::vector<std::pair<::shared_ptr<cql3::column_identifier::raw>, std::unique_ptr<cql3::operation::raw_update>>> operations;
+        std::vector<std::pair<::shared_ptr<cql3::column_identifier::raw>, ::shared_ptr<cql3::operation::raw_update>>> operations;
     }
     : K_UPDATE cf=columnFamilyName
       ( usingClause[attrs] )?
@@ -564,7 +563,7 @@ updateConditions returns [conditions_type conditions]
 deleteStatement returns [std::unique_ptr<raw::delete_statement> expr]
     @init {
         auto attrs = std::make_unique<cql3::attributes::raw>();
-        std::vector<std::unique_ptr<cql3::operation::raw_deletion>> column_deletions;
+        std::vector<::shared_ptr<cql3::operation::raw_deletion>> column_deletions;
         bool if_exists = false;
     }
     : K_DELETE ( dels=deleteSelection { column_deletions = std::move(dels); } )?
@@ -582,15 +581,15 @@ deleteStatement returns [std::unique_ptr<raw::delete_statement> expr]
       }
     ;
 
-deleteSelection returns [std::vector<std::unique_ptr<cql3::operation::raw_deletion>> operations]
+deleteSelection returns [std::vector<::shared_ptr<cql3::operation::raw_deletion>> operations]
     : t1=deleteOp { $operations.emplace_back(std::move(t1)); }
       (',' tN=deleteOp { $operations.emplace_back(std::move(tN)); })*
     ;
 
-deleteOp returns [std::unique_ptr<cql3::operation::raw_deletion> op]
-    : c=cident                { $op = std::make_unique<cql3::operation::column_deletion>(std::move(c)); }
-    | c=cident '[' t=term ']' { $op = std::make_unique<cql3::operation::element_deletion>(std::move(c), std::move(t)); }
-    | c=cident '.' field=ident { $op = std::make_unique<cql3::operation::field_deletion>(std::move(c), std::move(field)); }
+deleteOp returns [::shared_ptr<cql3::operation::raw_deletion> op]
+    : c=cident                { $op = ::make_shared<cql3::operation::column_deletion>(std::move(c)); }
+    | c=cident '[' t=term ']' { $op = ::make_shared<cql3::operation::element_deletion>(std::move(c), std::move(t)); }
+    | c=cident '.' field=ident { $op = ::make_shared<cql3::operation::field_deletion>(std::move(c), std::move(field)); }
     ;
 
 usingClauseDelete[std::unique_ptr<cql3::attributes::raw>& attrs]
@@ -1333,7 +1332,7 @@ setOrMapLiteral[shared_ptr<cql3::term::raw> t] returns [shared_ptr<cql3::term::r
       { $value = ::make_shared<cql3::maps::literal>(std::move(m)); }
     | { s.push_back(t); }
           ( ',' tn=term { s.push_back(tn); } )*
-      { $value = ::make_shared<cql3::sets::literal>(std::move(s)); }
+      { $value = make_shared(cql3::sets::literal(std::move(s))); }
     ;
 
 collectionLiteral returns [shared_ptr<cql3::term::raw> value]
@@ -1344,7 +1343,7 @@ collectionLiteral returns [shared_ptr<cql3::term::raw> value]
     | '{' t=term v=setOrMapLiteral[t] { $value = v; } '}'
     // Note that we have an ambiguity between maps and set for "{}". So we force it to a set literal,
     // and deal with it later based on the type of the column (SetLiteral.java).
-    | '{' '}' { $value = ::make_shared<cql3::sets::literal>(std::vector<shared_ptr<cql3::term::raw>>()); }
+    | '{' '}' { $value = make_shared(cql3::sets::literal({})); }
     ;
 
 usertypeLiteral returns [shared_ptr<cql3::user_types::literal> ut]
@@ -1417,12 +1416,12 @@ normalColumnOperation[operations_type& operations, ::shared_ptr<cql3::column_ide
     : t=term ('+' c=cident )?
       {
           if (!c) {
-              add_raw_update(operations, key, std::make_unique<cql3::operation::set_value>(t));
+              add_raw_update(operations, key, ::make_shared<cql3::operation::set_value>(t));
           } else {
               if (*key != *c) {
                 add_recognition_error("Only expressions of the form X = <value> + X are supported.");
               }
-              add_raw_update(operations, key, std::make_unique<cql3::operation::prepend>(t));
+              add_raw_update(operations, key, ::make_shared<cql3::operation::prepend>(t));
           }
       }
     | c=cident sig=('+' | '-') t=term
@@ -1430,11 +1429,11 @@ normalColumnOperation[operations_type& operations, ::shared_ptr<cql3::column_ide
           if (*key != *c) {
               add_recognition_error("Only expressions of the form X = X " + $sig.text + "<value> are supported.");
           }
-          std::unique_ptr<cql3::operation::raw_update> op;
+          shared_ptr<cql3::operation::raw_update> op;
           if ($sig.text == "+") {
-              op = std::make_unique<cql3::operation::addition>(t);
+              op = make_shared<cql3::operation::addition>(t);
           } else {
-              op = std::make_unique<cql3::operation::subtraction>(t);
+              op = make_shared<cql3::operation::subtraction>(t);
           }
           add_raw_update(operations, key, std::move(op));
       }
@@ -1445,11 +1444,11 @@ normalColumnOperation[operations_type& operations, ::shared_ptr<cql3::column_ide
               // We don't yet allow a '+' in front of an integer, but we could in the future really, so let's be future-proof in our error message
               add_recognition_error("Only expressions of the form X = X " + sstring($i.text[0] == '-' ? "-" : "+") + " <value> are supported.");
           }
-          add_raw_update(operations, key, std::make_unique<cql3::operation::addition>(cql3::constants::literal::integer($i.text)));
+          add_raw_update(operations, key, make_shared<cql3::operation::addition>(cql3::constants::literal::integer($i.text)));
       }
     | K_SCYLLA_COUNTER_SHARD_LIST '(' t=term ')'
       {
-          add_raw_update(operations, key, std::make_unique<cql3::operation::set_counter_value_from_tuple_list>(t));
+          add_raw_update(operations, key, ::make_shared<cql3::operation::set_counter_value_from_tuple_list>(t));      
       }
     ;
 
@@ -1459,7 +1458,7 @@ collectionColumnOperation[operations_type& operations,
                           bool by_uuid]
     : '=' t=term
       {
-          add_raw_update(operations, key, std::make_unique<cql3::operation::set_element>(k, t, by_uuid));
+          add_raw_update(operations, key, make_shared<cql3::operation::set_element>(k, t, by_uuid));
       }
     ;
 
@@ -1468,20 +1467,20 @@ udtColumnOperation[operations_type& operations,
                    shared_ptr<cql3::column_identifier> field]
     : '=' t=term
       {
-          add_raw_update(operations, std::move(key), std::make_unique<cql3::operation::set_field>(std::move(field), std::move(t)));
+          add_raw_update(operations, std::move(key), make_shared<cql3::operation::set_field>(std::move(field), std::move(t)));
       }
     ;
 
 columnCondition[conditions_type& conditions]
     // Note: we'll reject duplicates later
     : key=cident
-        ( op=relationType t=term { conditions.emplace_back(key, cql3::column_condition::raw::simple_condition(t, {}, op)); }
+        ( op=relationType t=term { conditions.emplace_back(key, cql3::column_condition::raw::simple_condition(t, {}, *op)); }
         | K_IN
             ( values=singleColumnInValues { conditions.emplace_back(key, cql3::column_condition::raw::in_condition({}, {}, values)); }
             | marker=inMarker { conditions.emplace_back(key, cql3::column_condition::raw::in_condition({}, marker, {})); }
             )
         | '[' element=term ']'
-            ( op=relationType t=term { conditions.emplace_back(key, cql3::column_condition::raw::simple_condition(t, element, op)); }
+            ( op=relationType t=term { conditions.emplace_back(key, cql3::column_condition::raw::simple_condition(t, element, *op)); }
             | K_IN
                 ( values=singleColumnInValues { conditions.emplace_back(key, cql3::column_condition::raw::in_condition(element, {}, values)); }
                 | marker=inMarker { conditions.emplace_back(key, cql3::column_condition::raw::in_condition(element, marker, {})); }
@@ -1504,31 +1503,31 @@ propertyValue returns [sstring str]
     | u=unreserved_keyword { $str = u; }
     ;
 
-relationType returns [cql3::expr::oper_t op]
-    : '='  { $op = cql3::expr::oper_t::EQ; }
-    | '<'  { $op = cql3::expr::oper_t::LT; }
-    | '<=' { $op = cql3::expr::oper_t::LTE; }
-    | '>'  { $op = cql3::expr::oper_t::GT; }
-    | '>=' { $op = cql3::expr::oper_t::GTE; }
-    | '!=' { $op = cql3::expr::oper_t::NEQ; }
-    | K_LIKE { $op = cql3::expr::oper_t::LIKE; }
+relationType returns [const cql3::operator_type* op = nullptr]
+    : '='  { $op = &cql3::operator_type::EQ; }
+    | '<'  { $op = &cql3::operator_type::LT; }
+    | '<=' { $op = &cql3::operator_type::LTE; }
+    | '>'  { $op = &cql3::operator_type::GT; }
+    | '>=' { $op = &cql3::operator_type::GTE; }
+    | '!=' { $op = &cql3::operator_type::NEQ; }
+    | K_LIKE { $op = &cql3::operator_type::LIKE; }
     ;
 
 relation[std::vector<cql3::relation_ptr>& clauses]
-    @init{ cql3::expr::oper_t rt; }
-    : name=cident type=relationType t=term { $clauses.emplace_back(::make_shared<cql3::single_column_relation>(std::move(name), type, std::move(t))); }
+    @init{ const cql3::operator_type* rt = nullptr; }
+    : name=cident type=relationType t=term { $clauses.emplace_back(::make_shared<cql3::single_column_relation>(std::move(name), *type, std::move(t))); }
 
     | K_TOKEN l=tupleOfIdentifiers type=relationType t=term
-        { $clauses.emplace_back(::make_shared<cql3::token_relation>(std::move(l), type, std::move(t))); }
+        { $clauses.emplace_back(::make_shared<cql3::token_relation>(std::move(l), *type, std::move(t))); }
     | name=cident K_IS K_NOT K_NULL {
-          $clauses.emplace_back(make_shared<cql3::single_column_relation>(std::move(name), cql3::expr::oper_t::IS_NOT, cql3::constants::NULL_LITERAL)); }
+          $clauses.emplace_back(make_shared<cql3::single_column_relation>(std::move(name), cql3::operator_type::IS_NOT, cql3::constants::NULL_LITERAL)); }
     | name=cident K_IN marker=inMarker
-        { $clauses.emplace_back(make_shared<cql3::single_column_relation>(std::move(name), cql3::expr::oper_t::IN, std::move(marker))); }
+        { $clauses.emplace_back(make_shared<cql3::single_column_relation>(std::move(name), cql3::operator_type::IN, std::move(marker))); }
     | name=cident K_IN in_values=singleColumnInValues
         { $clauses.emplace_back(cql3::single_column_relation::create_in_relation(std::move(name), std::move(in_values))); }
-    | name=cident K_CONTAINS { rt = cql3::expr::oper_t::CONTAINS; } (K_KEY { rt = cql3::expr::oper_t::CONTAINS_KEY; })?
-        t=term { $clauses.emplace_back(make_shared<cql3::single_column_relation>(std::move(name), rt, std::move(t))); }
-    | name=cident '[' key=term ']' type=relationType t=term { $clauses.emplace_back(make_shared<cql3::single_column_relation>(std::move(name), std::move(key), type, std::move(t))); }
+    | name=cident K_CONTAINS { rt = &cql3::operator_type::CONTAINS; } (K_KEY { rt = &cql3::operator_type::CONTAINS_KEY; })?
+        t=term { $clauses.emplace_back(make_shared<cql3::single_column_relation>(std::move(name), *rt, std::move(t))); }
+    | name=cident '[' key=term ']' type=relationType t=term { $clauses.emplace_back(make_shared<cql3::single_column_relation>(std::move(name), std::move(key), *type, std::move(t))); }
     | ids=tupleOfIdentifiers
       ( K_IN
           ( '(' ')'
@@ -1544,10 +1543,10 @@ relation[std::vector<cql3::relation_ptr>& clauses]
           )
       | type=relationType literal=tupleLiteral /* (a, b, c) > (1, 2, 3) or (a, b, c) > (?, ?, ?) */
           {
-              $clauses.emplace_back(cql3::multi_column_relation::create_non_in_relation(ids, type, literal));
+              $clauses.emplace_back(cql3::multi_column_relation::create_non_in_relation(ids, *type, literal));
           }
       | type=relationType tupleMarker=markerForTuple /* (a, b, c) >= ? */
-          { $clauses.emplace_back(cql3::multi_column_relation::create_non_in_relation(ids, type, tupleMarker)); }
+          { $clauses.emplace_back(cql3::multi_column_relation::create_non_in_relation(ids, *type, tupleMarker)); }
       )
     | '(' relation[$clauses] ')'
     ;
@@ -1695,7 +1694,7 @@ username returns [sstring str]
 // Basically the same as cident, but we need to exlude existing CQL3 types
 // (which for some reason are not reserved otherwise)
 non_type_ident returns [shared_ptr<cql3::column_identifier> id]
-    : t=IDENT                    { if (_reserved_type_names().contains($t.text)) { add_recognition_error("Invalid (reserved) user type name " + $t.text); } $id = ::make_shared<cql3::column_identifier>($t.text, false); }
+    : t=IDENT                    { if (_reserved_type_names().count($t.text)) { add_recognition_error("Invalid (reserved) user type name " + $t.text); } $id = ::make_shared<cql3::column_identifier>($t.text, false); }
     | t=QUOTED_NAME              { $id = ::make_shared<cql3::column_identifier>($t.text, true); }
     | k=basic_unreserved_keyword { $id = ::make_shared<cql3::column_identifier>(k, false); }
     | kk=K_KEY                   { $id = ::make_shared<cql3::column_identifier>($kk.text, false); }

cql3/abstract_marker.cc

@@ -87,7 +87,7 @@ abstract_marker::raw::raw(int32_t bind_index)
     return ::make_shared<constants::marker>(_bind_index, receiver);
 }
 
-assignment_testable::test_result abstract_marker::raw::test_assignment(database& db, const sstring& keyspace, const column_specification& receiver) const {
+assignment_testable::test_result abstract_marker::raw::test_assignment(database& db, const sstring& keyspace, lw_shared_ptr<column_specification> receiver) const {
     return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
 }
 

cql3/abstract_marker.hh

@@ -72,7 +72,7 @@ public:
 
         virtual ::shared_ptr<term> prepare(database& db, const sstring& keyspace, lw_shared_ptr<column_specification> receiver) const override;
 
-        virtual assignment_testable::test_result test_assignment(database& db, const sstring& keyspace, const column_specification& receiver) const override;
+        virtual assignment_testable::test_result test_assignment(database& db, const sstring& keyspace, lw_shared_ptr<column_specification> receiver) const override;
 
         virtual sstring to_string() const override;
     };

cql3/assignment_testable.hh

@@ -70,7 +70,7 @@ public:
     // Test all elements of toTest for assignment. If all are exact match, return exact match. If any is not assignable,
     // return not assignable. Otherwise, return weakly assignable.
     template <typename AssignmentTestablePtrRange>
-    static test_result test_all(database& db, const sstring& keyspace, const column_specification& receiver,
+    static test_result test_all(database& db, const sstring& keyspace, lw_shared_ptr<column_specification> receiver,
                 AssignmentTestablePtrRange&& to_test) {
         test_result res = test_result::EXACT_MATCH;
         for (auto&& rt : to_test) {
@@ -99,7 +99,7 @@ public:
      * Most caller should just call the isAssignable() method on the result, though functions have a use for
      * testing "strong" equality to decide the most precise overload to pick when multiple could match.
      */
-    virtual test_result test_assignment(database& db, const sstring& keyspace, const column_specification& receiver) const = 0;
+    virtual test_result test_assignment(database& db, const sstring& keyspace, lw_shared_ptr<column_specification> receiver) const = 0;
 
     // for error reporting
     virtual sstring assignment_testable_source_context() const = 0;