From 8028fb441ab7155b6256775ef4e70d1cee500c2e Mon Sep 17 00:00:00 2001 From: Avi Kivity Date: Thu, 30 Apr 2015 17:11:22 +0300 Subject: [PATCH] db: make column_family a class, not a struct Don't expose privates in public. --- database.cc | 20 +++++++++++++------- database.hh | 15 ++++++++++----- sstables/sstables.cc | 10 +++++----- tests/urchin/cql_test_env.cc | 4 ++-- thrift/handler.cc | 18 +++++++++--------- 5 files changed, 39 insertions(+), 28 deletions(-) diff --git a/database.cc b/database.cc index 12476dd839..f8de4de06b 100644 --- a/database.cc +++ b/database.cc @@ -174,6 +174,12 @@ future<> column_family::probe_file(sstring sstdir, sstring fname) { return make_ready_future<>(); } +const std::map& +column_family::all_partitions() const { + return partitions; +} + + future<> column_family::populate(sstring sstdir) { return lister::scan_dir(sstdir, directory_entry_type::regular, [this, sstdir] (directory_entry de) { @@ -291,22 +297,22 @@ void database::drop_keyspace(const sstring& name) { } void database::add_column_family(const utils::UUID& uuid, column_family&& cf) { - if (_keyspaces.count(cf._schema->ks_name()) == 0) { - throw std::invalid_argument("Keyspace " + cf._schema->ks_name() + " not defined"); + if (_keyspaces.count(cf.schema()->ks_name()) == 0) { + throw std::invalid_argument("Keyspace " + cf.schema()->ks_name() + " not defined"); } if (_column_families.count(uuid) != 0) { throw std::invalid_argument("UUID " + uuid.to_sstring() + " already mapped"); } - auto kscf = std::make_pair(cf._schema->ks_name(), cf._schema->cf_name()); + auto kscf = std::make_pair(cf.schema()->ks_name(), cf.schema()->cf_name()); if (_ks_cf_to_uuid.count(kscf) != 0) { - throw std::invalid_argument("Column family " + cf._schema->cf_name() + " exists"); + throw std::invalid_argument("Column family " + cf.schema()->cf_name() + " exists"); } _column_families.emplace(uuid, std::move(cf)); _ks_cf_to_uuid.emplace(std::move(kscf), uuid); } void database::add_column_family(column_family&& cf) { - auto id = cf._schema->id(); + auto id = cf.schema()->id(); add_column_family(id, std::move(cf)); } @@ -406,7 +412,7 @@ schema_ptr database::find_schema(const sstring& ks_name, const sstring& cf_name) } schema_ptr database::find_schema(const utils::UUID& uuid) const throw (no_such_column_family) { - return find_column_family(uuid)._schema; + return find_column_family(uuid).schema(); } keyspace& @@ -553,7 +559,7 @@ std::ostream& operator<<(std::ostream& out, const database& db) { out << "{\n"; for (auto&& e : db._column_families) { auto&& cf = e.second; - out << "(" << e.first.to_sstring() << ", " << cf._schema->cf_name() << ", " << cf._schema->ks_name() << "): " << cf << "\n"; + out << "(" << e.first.to_sstring() << ", " << cf.schema()->cf_name() << ", " << cf.schema()->ks_name() << "): " << cf << "\n"; } out << "}"; return out; diff --git a/database.hh b/database.hh index 527e0e1738..bf60e64113 100644 --- a/database.hh +++ b/database.hh @@ -53,30 +53,35 @@ class commitlog; class config; } -struct column_family { +class column_family { + schema_ptr _schema; + std::map partitions; + // generation -> sstable. Ordered by key so we can easily get the most recent. + std::map> _sstables; +public: column_family(schema_ptr schema); column_family(column_family&&) = default; ~column_family(); + schema_ptr schema() const { return _schema; } mutation_partition& find_or_create_partition(const dht::decorated_key& key); mutation_partition& find_or_create_partition_slow(const partition_key& key); const mutation_partition* find_partition(const dht::decorated_key& key) const; const mutation_partition* find_partition_slow(const partition_key& key) const; row& find_or_create_row_slow(const partition_key& partition_key, const clustering_key& clustering_key); const row* find_row(const dht::decorated_key& partition_key, const clustering_key& clustering_key) const; - schema_ptr _schema; - std::map partitions; void apply(const mutation& m); // Returns at most "cmd.limit" rows future> query(const query::read_command& cmd) const; future<> populate(sstring datadir); + const std::map& all_partitions() const; private: - // generation -> sstable. Ordered by key so we can easily get the most recent. - std::map> _sstables; future<> probe_file(sstring sstdir, sstring fname); // Returns at most "limit" rows. The limit must be greater than 0. void get_partition_slice(mutation_partition& partition, const query::partition_slice& slice, uint32_t limit, query::result::partition_writer&); + + friend std::ostream& operator<<(std::ostream& out, const column_family& cf); }; class user_types_metadata { diff --git a/sstables/sstables.cc b/sstables/sstables.cc index f29db434c2..c929e56c08 100644 --- a/sstables/sstables.cc +++ b/sstables/sstables.cc @@ -984,11 +984,11 @@ future<> write_datafile(column_family& cf, sstring datafile) { // Iterate through CQL partitions, then CQL rows, then CQL columns. // Each cf.partitions entry is a set of clustered rows sharing the same partition key. - return do_for_each(cf.partitions, - [w, &cf] (std::pair& partition_entry) { + return do_for_each(cf.all_partitions(), + [w, &cf] (const std::pair& partition_entry) { // TODO: Write index and summary files on-the-fly. - key partition_key = key::from_partition_key(*cf._schema, partition_entry.first._key); + key partition_key = key::from_partition_key(*cf.schema(), partition_entry.first._key); return do_with(std::move(partition_key), [w, &partition_entry] (auto& partition_key) { disk_string_view p_key; @@ -1015,11 +1015,11 @@ future<> write_datafile(column_family& cf, sstring datafile) { auto& partition = partition_entry.second; auto& static_row = partition.static_row(); - return write_static_row(*w, cf._schema, static_row).then([w, &cf, &partition] { + return write_static_row(*w, cf.schema(), static_row).then([w, &cf, &partition] { // Write all CQL rows from a given mutation partition. return do_for_each(partition.clustered_rows(), [w, &cf] (const rows_entry& clustered_row) { - return write_clustered_row(*w, cf._schema, clustered_row); + return write_clustered_row(*w, cf.schema(), clustered_row); }).then([w] { // end_of_row is appended to the end of each partition. int16_t end_of_row = 0; diff --git a/tests/urchin/cql_test_env.cc b/tests/urchin/cql_test_env.cc index 19639706f7..e72b574508 100644 --- a/tests/urchin/cql_test_env.cc +++ b/tests/urchin/cql_test_env.cc @@ -118,7 +118,7 @@ public: boost::any expected) override { auto& db = _db->local(); auto& cf = db.find_column_family(ks_name, table_name); - auto schema = cf._schema; + auto schema = cf.schema(); auto pkey = partition_key::from_deeply_exploded(*schema, pk); auto dk = dht::global_partitioner().decorate_key(*schema, pkey); auto shard = db.shard_of(dk._token); @@ -129,7 +129,7 @@ public: expected = std::move(expected), table_name = std::move(table_name)] (database& db) { auto& cf = db.find_column_family(ks_name, table_name); - auto schema = cf._schema; + auto schema = cf.schema(); auto p = cf.find_partition_slow(pkey); assert(p != nullptr); auto row = p->find_row(clustering_key::from_deeply_exploded(*schema, ck)); diff --git a/thrift/handler.cc b/thrift/handler.cc index f8b2f0354c..e0ed3827b5 100644 --- a/thrift/handler.cc +++ b/thrift/handler.cc @@ -133,15 +133,15 @@ public: throw unimplemented_exception(); } else if (predicate.__isset.slice_range) { auto&& range = predicate.slice_range; - const row* rw = cf.find_row(dk, clustering_key::make_empty(*cf._schema)); + const row* rw = cf.find_row(dk, clustering_key::make_empty(*cf.schema())); if (rw) { - auto beg = cf._schema->regular_begin(); + auto beg = cf.schema()->regular_begin(); if (!range.start.empty()) { - beg = cf._schema->regular_lower_bound(to_bytes(range.start)); + beg = cf.schema()->regular_lower_bound(to_bytes(range.start)); } - auto end = cf._schema->regular_end(); + auto end = cf.schema()->regular_end(); if (!range.finish.empty()) { - end = cf._schema->regular_upper_bound(to_bytes(range.finish)); + end = cf.schema()->regular_upper_bound(to_bytes(range.finish)); } auto count = range.count; // FIXME: force limit count? @@ -253,15 +253,15 @@ public: sstring cf_name = cf_mutations.first; const std::vector& mutations = cf_mutations.second; auto& cf = lookup_column_family(_db.local(), _ks_name, cf_name); - mutation m_to_apply(key_from_thrift(cf._schema, thrift_key), cf._schema); - auto empty_clustering_key = clustering_key::make_empty(*cf._schema); + mutation m_to_apply(key_from_thrift(cf.schema(), thrift_key), cf.schema()); + auto empty_clustering_key = clustering_key::make_empty(*cf.schema()); for (const Mutation& m : mutations) { if (m.__isset.column_or_supercolumn) { auto&& cosc = m.column_or_supercolumn; if (cosc.__isset.column) { auto&& col = cosc.column; bytes cname = to_bytes(col.name); - auto def = cf._schema->get_column_definition(cname); + auto def = cf.schema()->get_column_definition(cname); if (!def) { throw make_exception("column %s not found", col.name); } @@ -273,7 +273,7 @@ public: ttl = std::chrono::duration_cast(std::chrono::seconds(col.ttl)); } if (ttl.count() <= 0) { - ttl = cf._schema->default_time_to_live(); + ttl = cf.schema()->default_time_to_live(); } auto ttl_option = ttl.count() > 0 ? ttl_opt(gc_clock::now() + ttl) : ttl_opt(); m_to_apply.set_clustered_cell(empty_clustering_key, *def,