Rename serialization_format to cql_serialization_format

cql3/functions/aggregate_fcts.hh

@@ -58,10 +58,10 @@ public:
     virtual void reset() override {
         _count = 0;
     }
-    virtual opt_bytes compute(serialization_format sf) override {
+    virtual opt_bytes compute(cql_serialization_format sf) override {
         return long_type->decompose(_count);
     }
-    virtual void add_input(serialization_format sf, const std::vector<opt_bytes>& values) override {
+    virtual void add_input(cql_serialization_format sf, const std::vector<opt_bytes>& values) override {
         ++_count;
     }
 };
@@ -83,10 +83,10 @@ public:
     virtual void reset() override {
         _sum = {};
     }
-    virtual opt_bytes compute(serialization_format sf) override {
+    virtual opt_bytes compute(cql_serialization_format sf) override {
         return data_type_for<Type>()->decompose(_sum);
     }
-    virtual void add_input(serialization_format sf, const std::vector<opt_bytes>& values) override {
+    virtual void add_input(cql_serialization_format sf, const std::vector<opt_bytes>& values) override {
         if (!values[0]) {
             return;
         }
@@ -120,14 +120,14 @@ public:
         _sum = {};
         _count = 0;
     }
-    virtual opt_bytes compute(serialization_format sf) override {
+    virtual opt_bytes compute(cql_serialization_format sf) override {
         Type ret = 0;
         if (_count) {
             ret = _sum / _count;
         }
         return data_type_for<Type>()->decompose(ret);
     }
-    virtual void add_input(serialization_format sf, const std::vector<opt_bytes>& values) override {
+    virtual void add_input(cql_serialization_format sf, const std::vector<opt_bytes>& values) override {
         if (!values[0]) {
             return;
         }
@@ -159,13 +159,13 @@ public:
     virtual void reset() override {
         _max = {};
     }
-    virtual opt_bytes compute(serialization_format sf) override {
+    virtual opt_bytes compute(cql_serialization_format sf) override {
         if (!_max) {
             return {};
         }
         return data_type_for<Type>()->decompose(*_max);
     }
-    virtual void add_input(serialization_format sf, const std::vector<opt_bytes>& values) override {
+    virtual void add_input(cql_serialization_format sf, const std::vector<opt_bytes>& values) override {
         if (!values[0]) {
             return;
         }
@@ -206,13 +206,13 @@ public:
     virtual void reset() override {
         _min = {};
     }
-    virtual opt_bytes compute(serialization_format sf) override {
+    virtual opt_bytes compute(cql_serialization_format sf) override {
         if (!_min) {
             return {};
         }
         return data_type_for<Type>()->decompose(*_min);
     }
-    virtual void add_input(serialization_format sf, const std::vector<opt_bytes>& values) override {
+    virtual void add_input(cql_serialization_format sf, const std::vector<opt_bytes>& values) override {
         if (!values[0]) {
             return;
         }
@@ -255,10 +255,10 @@ public:
     virtual void reset() override {
         _count = 0;
     }
-    virtual opt_bytes compute(serialization_format sf) override {
+    virtual opt_bytes compute(cql_serialization_format sf) override {
         return long_type->decompose(_count);
     }
-    virtual void add_input(serialization_format sf, const std::vector<opt_bytes>& values) override {
+    virtual void add_input(cql_serialization_format sf, const std::vector<opt_bytes>& values) override {
         if (!values[0]) {
             return;
         }

cql3/functions/aggregate_function.hh

@@ -77,15 +77,15 @@ public:
          * @param protocol_version native protocol version
          * @param values the values to add to the aggregate.
          */
-        virtual void add_input(serialization_format sf, const std::vector<opt_bytes>& values) = 0;
+        virtual void add_input(cql_serialization_format sf, const std::vector<opt_bytes>& values) = 0;
 
         /**
          * Computes and returns the aggregate current value.
          *
          * @param protocol_version native protocol version
          * @return the aggregate current value.
          */
-        virtual opt_bytes compute(serialization_format sf) = 0;
+        virtual opt_bytes compute(cql_serialization_format sf) = 0;
 
         /**
          * Reset this aggregate.

cql3/functions/bytes_conversion_fcts.hh

@@ -58,7 +58,7 @@ shared_ptr<function>
 make_to_blob_function(data_type from_type) {
     auto name = from_type->as_cql3_type()->to_string() + "asblob";
     return make_native_scalar_function<true>(name, bytes_type, { from_type },
-            [] (serialization_format sf, const std::vector<bytes_opt>& parameters) {
+            [] (cql_serialization_format sf, const std::vector<bytes_opt>& parameters) {
         return parameters[0];
     });
 }
@@ -68,7 +68,7 @@ shared_ptr<function>
 make_from_blob_function(data_type to_type) {
     sstring name = sstring("blobas") + to_type->as_cql3_type()->to_string();
     return make_native_scalar_function<true>(name, to_type, { bytes_type },
-            [name, to_type] (serialization_format sf, const std::vector<bytes_opt>& parameters) -> bytes_opt {
+            [name, to_type] (cql_serialization_format sf, const std::vector<bytes_opt>& parameters) -> bytes_opt {
         auto&& val = parameters[0];
         if (!val) {
             return val;
@@ -89,7 +89,7 @@ inline
 shared_ptr<function>
 make_varchar_as_blob_fct() {
     return make_native_scalar_function<true>("varcharasblob", bytes_type, { utf8_type },
-            [] (serialization_format sf, const std::vector<bytes_opt>& parameters) -> bytes_opt {
+            [] (cql_serialization_format sf, const std::vector<bytes_opt>& parameters) -> bytes_opt {
         return parameters[0];
     });
 }
@@ -98,7 +98,7 @@ inline
 shared_ptr<function>
 make_blob_as_varchar_fct() {
     return make_native_scalar_function<true>("blobasvarchar", utf8_type, { bytes_type },
-            [] (serialization_format sf, const std::vector<bytes_opt>& parameters) -> bytes_opt {
+            [] (cql_serialization_format sf, const std::vector<bytes_opt>& parameters) -> bytes_opt {
         return parameters[0];
     });
 }

cql3/functions/function_call.hh

@@ -61,11 +61,11 @@ public:
     virtual shared_ptr<terminal> bind(const query_options& options) override;
     virtual bytes_view_opt bind_and_get(const query_options& options) override;
 private:
-    static bytes_opt execute_internal(serialization_format sf, scalar_function& fun, std::vector<bytes_opt> params);
+    static bytes_opt execute_internal(cql_serialization_format sf, scalar_function& fun, std::vector<bytes_opt> params);
 public:
     virtual bool contains_bind_marker() const override;
 private:
-    static shared_ptr<terminal> make_terminal(shared_ptr<function> fun, bytes_opt result, serialization_format sf);
+    static shared_ptr<terminal> make_terminal(shared_ptr<function> fun, bytes_opt result, cql_serialization_format sf);
 public:
     class raw : public term::raw {
         function_name _name;

cql3/functions/functions.cc

@@ -299,7 +299,7 @@ function_call::collect_marker_specification(shared_ptr<variable_specifications>
 
 shared_ptr<terminal>
 function_call::bind(const query_options& options) {
-    return make_terminal(_fun, to_bytes_opt(bind_and_get(options)), options.get_serialization_format());
+    return make_terminal(_fun, to_bytes_opt(bind_and_get(options)), options.get_cql_serialization_format());
 }
 
 bytes_view_opt
@@ -315,12 +315,12 @@ function_call::bind_and_get(const query_options& options) {
         }
         buffers.push_back(std::move(to_bytes_opt(val)));
     }
-    auto result = execute_internal(options.get_serialization_format(), *_fun, std::move(buffers));
+    auto result = execute_internal(options.get_cql_serialization_format(), *_fun, std::move(buffers));
     return options.make_temporary(result);
 }
 
 bytes_opt
-function_call::execute_internal(serialization_format sf, scalar_function& fun, std::vector<bytes_opt> params) {
+function_call::execute_internal(cql_serialization_format sf, scalar_function& fun, std::vector<bytes_opt> params) {
     bytes_opt result = fun.execute(sf, params);
     try {
         // Check the method didn't lied on it's declared return type
@@ -347,7 +347,7 @@ function_call::contains_bind_marker() const {
 }
 
 shared_ptr<terminal>
-function_call::make_terminal(shared_ptr<function> fun, bytes_opt result, serialization_format sf)  {
+function_call::make_terminal(shared_ptr<function> fun, bytes_opt result, cql_serialization_format sf)  {
     if (!dynamic_pointer_cast<const collection_type_impl>(fun->return_type())) {
         return ::make_shared<constants::value>(std::move(result));
     }
@@ -413,7 +413,7 @@ function_call::raw::prepare(database& db, const sstring& keyspace, ::shared_ptr<
     // If all parameters are terminal and the function is pure, we can
     // evaluate it now, otherwise we'd have to wait execution time
     if (all_terminal && scalar_fun->is_pure()) {
-        return make_terminal(scalar_fun, execute(*scalar_fun, parameters), query_options::DEFAULT.get_serialization_format());
+        return make_terminal(scalar_fun, execute(*scalar_fun, parameters), query_options::DEFAULT.get_cql_serialization_format());
     } else {
         return ::make_shared<function_call>(scalar_fun, parameters);
     }
@@ -429,7 +429,7 @@ function_call::raw::execute(scalar_function& fun, std::vector<shared_ptr<term>>
         buffers.push_back(std::move(param));
     }
 
-    return execute_internal(serialization_format::internal(), fun, buffers);
+    return execute_internal(cql_serialization_format::internal(), fun, buffers);
 }
 
 assignment_testable::test_result

cql3/functions/native_scalar_function.hh

@@ -74,7 +74,7 @@ public:
             : native_scalar_function(std::move(name), std::move(return_type), std::move(arg_types))
             , _func(std::forward<Func>(func)) {
     }
-    virtual bytes_opt execute(serialization_format sf, const std::vector<bytes_opt>& parameters) override {
+    virtual bytes_opt execute(cql_serialization_format sf, const std::vector<bytes_opt>& parameters) override {
         return _func(sf, parameters);
     }
 };

cql3/functions/scalar_function.hh

@@ -58,7 +58,7 @@ public:
      * @return the result of applying this function to the parameter
      * @throws InvalidRequestException if this function cannot not be applied to the parameter
      */
-    virtual bytes_opt execute(serialization_format sf, const std::vector<bytes_opt>& parameters) = 0;
+    virtual bytes_opt execute(cql_serialization_format sf, const std::vector<bytes_opt>& parameters) = 0;
 };
 
 

cql3/functions/time_uuid_fcts.hh

@@ -56,7 +56,7 @@ inline
 shared_ptr<function>
 make_now_fct() {
     return make_native_scalar_function<false>("now", timeuuid_type, {},
-            [] (serialization_format sf, const std::vector<bytes_opt>& values) -> bytes_opt {
+            [] (cql_serialization_format sf, const std::vector<bytes_opt>& values) -> bytes_opt {
         return {to_bytes(utils::UUID_gen::get_time_UUID())};
     });
 }
@@ -65,7 +65,7 @@ inline
 shared_ptr<function>
 make_min_timeuuid_fct() {
     return make_native_scalar_function<true>("mintimeuuid", timeuuid_type, { timestamp_type },
-            [] (serialization_format sf, const std::vector<bytes_opt>& values) -> bytes_opt {
+            [] (cql_serialization_format sf, const std::vector<bytes_opt>& values) -> bytes_opt {
         auto& bb = values[0];
         if (!bb) {
             return {};
@@ -84,7 +84,7 @@ inline
 shared_ptr<function>
 make_max_timeuuid_fct() {
     return make_native_scalar_function<true>("maxtimeuuid", timeuuid_type, { timestamp_type },
-            [] (serialization_format sf, const std::vector<bytes_opt>& values) -> bytes_opt {
+            [] (cql_serialization_format sf, const std::vector<bytes_opt>& values) -> bytes_opt {
         // FIXME: should values be a vector<optional<bytes>>?
         auto& bb = values[0];
         if (!bb) {
@@ -104,7 +104,7 @@ inline
 shared_ptr<function>
 make_date_of_fct() {
     return make_native_scalar_function<true>("dateof", timestamp_type, { timeuuid_type },
-            [] (serialization_format sf, const std::vector<bytes_opt>& values) -> bytes_opt {
+            [] (cql_serialization_format sf, const std::vector<bytes_opt>& values) -> bytes_opt {
         using namespace utils;
         auto& bb = values[0];
         if (!bb) {
@@ -119,7 +119,7 @@ inline
 shared_ptr<function>
 make_unix_timestamp_of_fcf() {
     return make_native_scalar_function<true>("unixtimestampof", long_type, { timeuuid_type },
-            [] (serialization_format sf, const std::vector<bytes_opt>& values) -> bytes_opt {
+            [] (cql_serialization_format sf, const std::vector<bytes_opt>& values) -> bytes_opt {
         using namespace utils;
         auto& bb = values[0];
         if (!bb) {

cql3/functions/token_fct.hh

@@ -61,7 +61,7 @@ public:
                     , _schema(s) {
     }
 
-    bytes_opt execute(serialization_format sf, const std::vector<bytes_opt>& parameters) override {
+    bytes_opt execute(cql_serialization_format sf, const std::vector<bytes_opt>& parameters) override {
         auto key = partition_key::from_optional_exploded(*_schema, parameters);
         auto tok = dht::global_partitioner().get_token(*_schema, key);
         warn(unimplemented::cause::VALIDATION);

cql3/functions/uuid_fcts.hh

@@ -53,7 +53,7 @@ inline
 shared_ptr<function>
 make_uuid_fct() {
     return make_native_scalar_function<false>("uuid", uuid_type, {},
-            [] (serialization_format sf, const std::vector<bytes_opt>& parameters) -> bytes_opt {
+            [] (cql_serialization_format sf, const std::vector<bytes_opt>& parameters) -> bytes_opt {
         return {uuid_type->decompose(utils::make_random_uuid())};
     });
 }

cql3/lists.cc

@@ -108,7 +108,7 @@ lists::literal::to_string() const {
 }
 
 lists::value
-lists::value::from_serialized(bytes_view v, list_type type, serialization_format sf) {
+lists::value::from_serialized(bytes_view v, list_type type, cql_serialization_format sf) {
     try {
         // Collections have this small hack that validate cannot be called on a serialized object,
         // but compose does the validation (so we're fine).
@@ -128,11 +128,11 @@ lists::value::from_serialized(bytes_view v, list_type type, serialization_format
 
 bytes_opt
 lists::value::get(const query_options& options) {
-    return get_with_protocol_version(options.get_serialization_format());
+    return get_with_protocol_version(options.get_cql_serialization_format());
 }
 
 bytes
-lists::value::get_with_protocol_version(serialization_format sf) {
+lists::value::get_with_protocol_version(cql_serialization_format sf) {
     // Can't use boost::indirect_iterator, because optional is not an iterator
     auto deref = [] (bytes_opt& x) { return *x; };
     return collection_type_impl::pack(
@@ -212,7 +212,7 @@ lists::marker::bind(const query_options& options) {
     if (!value) {
         return nullptr;
     } else {
-        return make_shared(value::from_serialized(*value, std::move(ltype), options.get_serialization_format()));
+        return make_shared(value::from_serialized(*value, std::move(ltype), options.get_cql_serialization_format()));
     }
 }
 
@@ -342,7 +342,7 @@ lists::do_append(shared_ptr<term> t,
             auto&& newv = collection_mutation{list_type_impl::pack(
                     boost::make_transform_iterator(to_add.begin(), deref),
                     boost::make_transform_iterator(to_add.end(), deref),
-                    to_add.size(), serialization_format::internal())};
+                    to_add.size(), cql_serialization_format::internal())};
             m.set_cell(prefix, column, atomic_cell_or_collection::from_collection_mutation(std::move(newv)));
         }
     }

cql3/lists.hh

@@ -78,9 +78,9 @@ public:
         explicit value(std::vector<bytes_opt> elements)
             : _elements(std::move(elements)) {
         }
-        static value from_serialized(bytes_view v, list_type type, serialization_format sf);
+        static value from_serialized(bytes_view v, list_type type, cql_serialization_format sf);
         virtual bytes_opt get(const query_options& options) override;
-        virtual bytes get_with_protocol_version(serialization_format sf) override;
+        virtual bytes get_with_protocol_version(cql_serialization_format sf) override;
         bool equals(shared_ptr<list_type_impl> lt, const value& v);
         virtual std::vector<bytes_opt> get_elements() override;
         virtual sstring to_string() const;

cql3/maps.cc

@@ -152,7 +152,7 @@ maps::literal::to_string() const {
 }
 
 maps::value
-maps::value::from_serialized(bytes_view value, map_type type, serialization_format sf) {
+maps::value::from_serialized(bytes_view value, map_type type, cql_serialization_format sf) {
     try {
         // Collections have this small hack that validate cannot be called on a serialized object,
         // but compose does the validation (so we're fine).
@@ -171,11 +171,11 @@ maps::value::from_serialized(bytes_view value, map_type type, serialization_form
 
 bytes_opt
 maps::value::get(const query_options& options) {
-    return get_with_protocol_version(options.get_serialization_format());
+    return get_with_protocol_version(options.get_cql_serialization_format());
 }
 
 bytes
-maps::value::get_with_protocol_version(serialization_format sf) {
+maps::value::get_with_protocol_version(cql_serialization_format sf) {
     //FIXME: share code with serialize_partially_deserialized_form
     size_t len = collection_value_len(sf) * map.size() * 2 + collection_size_len(sf);
     for (auto&& e : map) {
@@ -257,7 +257,7 @@ maps::marker::bind(const query_options& options) {
                     maps::value::from_serialized(*val,
                             static_pointer_cast<const map_type_impl>(
                                     _receiver->type),
-                            options.get_serialization_format())) :
+                            options.get_cql_serialization_format())) :
             nullptr;
 }
 
@@ -333,7 +333,7 @@ maps::do_put(mutation& m, const exploded_clustering_prefix& prefix, const update
             m.set_cell(prefix, column, params.make_dead_cell());
         } else {
             auto v = map_type_impl::serialize_partially_deserialized_form({map_value->map.begin(), map_value->map.end()},
-                    serialization_format::internal());
+                    cql_serialization_format::internal());
             m.set_cell(prefix, column, params.make_cell(std::move(v)));
         }
     }

cql3/maps.hh

@@ -81,9 +81,9 @@ public:
         value(std::map<bytes, bytes, serialized_compare> map)
             : map(std::move(map)) {
         }
-        static value from_serialized(bytes_view value, map_type type, serialization_format sf);
+        static value from_serialized(bytes_view value, map_type type, cql_serialization_format sf);
         virtual bytes_opt get(const query_options& options) override;
-        virtual bytes get_with_protocol_version(serialization_format sf);
+        virtual bytes get_with_protocol_version(cql_serialization_format sf);
         bool equals(map_type mt, const value& v);
         virtual sstring to_string() const;
     };