google-cloud-bigtable 0.6.2 → 0.7.0

data/lib/google/cloud/bigtable/cluster/job.rb

@@ -17,6 +17,7 @@ module Google
   module Cloud
     module Bigtable
       class Cluster
+        ##
         # # Job
         #
         # A resource representing the long-running, asynchronous processing of
@@ -55,6 +56,7 @@ module Google
         #   end
         #
         class Job < LongrunningJob
+          ##
           # Gets the cluster object from job results
           #
           # @return [Google::Cloud::Bigtable::Cluster, nil] The cluster instance, or
@@ -73,17 +75,11 @@ module Google
           #     storage_type: :SSD
           #   )
           #
-          #   job.done? #=> false
-          #   job.reload!
-          #   job.done? #=> true
-          #
-          #   # OR wait utill complete
-          #
           #   job.wait_until_done!
           #   cluster = job.cluster
           #
           def cluster
-            Cluster.from_grpc(results, service) if results
+            Cluster.from_grpc results, service if results
           end
         end
       end

data/lib/google/cloud/bigtable/cluster/list.rb

@@ -21,6 +21,7 @@ module Google
   module Cloud
     module Bigtable
       class Cluster
+        ##
         # Cluster::List is a special case Array with additional
         # values.
         class List < DelegateClass(::Array)
@@ -32,10 +33,12 @@ module Google
           # Instance ID
           attr_accessor :instance_id
 
+          ##
           # If not empty, indicates that there are more records that match
           # the request and this value should be passed to continue.
           attr_accessor :token
 
+          ##
           # Locations from which cluster information could not be retrieved,
           # due to an outage or some other transient condition.
           # Clusters from these locations may be missing from `clusters`
@@ -46,9 +49,10 @@ module Google
           # Create a new Cluster::List with an array of
           # Cluster instances.
           def initialize arr = []
-            super(arr)
+            super arr
           end
 
+          ##
           # Whether there is a next page of instances.
           #
           # @return [Boolean]
@@ -58,14 +62,16 @@ module Google
           #
           #   bigtable = Google::Cloud::Bigtable.new
           #
-          #   clusters = bigtable.clusters("instance-id")
+          #   clusters = bigtable.clusters
           #   if clusters.next?
           #     next_clusters = clusters.next
           #   end
+          #
           def next?
             !token.nil?
           end
 
+          ##
           # Retrieve the next page of clusters.
           #
           # @return [Cluster::List] The list of clusters.
@@ -75,25 +81,21 @@ module Google
           #
           #   bigtable = Google::Cloud::Bigtable.new
           #
-          #   clusters = bigtable.clusters("instance-id")
-          #   if instances.next?
+          #   clusters = bigtable.clusters
+          #   if clusters.next?
           #     next_clusters = clusters.next
           #   end
+          #
           def next
             return nil unless next?
             ensure_service!
-            grpc = service.list_clusters(instance_id, token: token)
-            next_list = self.class.from_grpc(
-              grpc,
-              service,
-              instance_id: instance_id
-            )
-            if failed_locations
-              next_list.failed_locations.concat(failed_locations.map(&:to_s))
-            end
+            grpc = service.list_clusters instance_id, token: token
+            next_list = self.class.from_grpc grpc, service, instance_id: instance_id
+            next_list.failed_locations.concat(failed_locations.map(&:to_s)) if failed_locations
             next_list
           end
 
+          ##
           # Retrieves remaining results by repeatedly invoking {#next} until
           # {#next?} returns `false`. Calls the given block once for each
           # result, which is passed as the argument to the block.
@@ -114,7 +116,7 @@ module Google
           #
           #   bigtable = Google::Cloud::Bigtable.new
           #
-          #   bigtable.clusters("instance-id").all do |cluster|
+          #   bigtable.clusters.all do |cluster|
           #     puts cluster.cluster_id
           #   end
           #
@@ -123,12 +125,12 @@ module Google
           #
           #   bigtable = Google::Cloud::Bigtable.new
           #
-          #   all_cluster_ids = bigtable.clusters("instance-id").all.map do |cluster|
+          #   all_cluster_ids = bigtable.clusters.all.map do |cluster|
           #     puts cluster.instance_id
           #   end
           #
           def all
-            return enum_for(:all) unless block_given?
+            return enum_for :all unless block_given?
 
             results = self
             loop do
@@ -143,10 +145,10 @@ module Google
           # New Cluster::List from a Google::Bigtable::Admin::V2::ListClustersResponse object.
           def self.from_grpc grpc, service, instance_id: nil
             clusters = List.new(Array(grpc.clusters).map do |cluster|
-              Cluster.from_grpc(cluster, service)
+              Cluster.from_grpc cluster, service
             end)
             token = grpc.next_page_token
-            token = nil if token == "".freeze
+            token = nil if token == ""
             clusters.token = token
             clusters.instance_id = instance_id
             clusters.service = service

data/lib/google/cloud/bigtable/column_family.rb

@@ -20,6 +20,7 @@ require "google/cloud/bigtable/gc_rule"
 module Google
   module Cloud
     module Bigtable
+      ##
       # # ColumnFamily
       #
       # A set of columns within a table that share a common configuration.
@@ -32,254 +33,46 @@ module Google
       #   instance = bigtable.instance("my-instance")
       #   table = instance.table("my-table")
       #
-      #   # Create
-      #   gc_rule = Google::Cloud::Bigtable::GcRule.max_versions(5)
-      #   column_family = table.column_families.add("cf1", gc_rule)
-      #
-      #   # Update
-      #   column_family = table.column_families.find_by_name("cf2")
-      #   column_family.gc_rule = Google::Cloud::Bigtable::GcRule.max_age(600)
-      #   column_family.update
-      #
-      #   # Delete
-      #   column_family = table.column_families.find_by_name("cf3")
-      #   column_family.delete
+      #   column_family = table.column_families["cf2"]
+      #   puts column_family.gc_rule
       #
       class ColumnFamily
-        # @private
-        # The gRPC Service object
-        attr_accessor :service
-
-        # @private
-        attr_accessor :instance_id
-
-        # @private
-        attr_accessor :table_id
-
-        # Column family name
+        # Name of the column family
+        # @return [String]
         attr_reader :name
 
+        # The garbage collection rule to be used for the column family.
+        # Optional. The service default value will be used when not specified.
+        # @return [Google::Cloud::Bigtable::GcRule, nil]
+        attr_accessor :gc_rule
+
         # @private
-        #
-        # Create instance of ColumnFamily
-        # @param service [Google::Cloud::Bigtable::Service]
-        # @param grpc [Google::Bigtable::Admin::V2::ColumnFamily]
-        # @param name [String] Name of the column family
-        #
-        def initialize service, grpc: nil, name: nil
-          @service = service
-          @grpc = grpc || Google::Bigtable::Admin::V2::ColumnFamily.new
+        def initialize name, gc_rule: nil
           @name = name
+          @gc_rule = gc_rule
         end
 
-        # Set Column Family garbage collection rules
-        #
-        # @param rule [Google::Cloud::Bigtable::GcRule, nil] the new rule, or
-        #   `nil` for the service default value.
-        #
-        def gc_rule= rule
-          @grpc.gc_rule = rule.nil? ? nil : rule.to_grpc
-        end
-
-        # Get garbage collection rule
-        #
-        # @return [Google::Cloud::Bigtable::GcRule]
-        #
-        def gc_rule
-          GcRule.from_grpc(@grpc.gc_rule) if @grpc.gc_rule
-        end
-
-        # Create column family
-        #
-        # @return [Google::Cloud::Bigtable::ColumnFamily]
-        #
-        # @example
-        #   require "google/cloud/bigtable"
-        #
-        #   bigtable = Google::Cloud::Bigtable.new
-        #
-        #   instance = bigtable.instance("my-instance")
-        #   table = instance.table("my-table")
-        #
-        #   gc_rule = Google::Cloud::Bigtable::GcRule.max_versions(3)
-        #   cf = table.column_family("cf", gc_rule)
-        #   cf.create
-        #
-        def create
-          modify_column_family(self.class.create_modification(name, gc_rule))
-        end
-
-        # Update column family
-        #
-        # @return [Google::Cloud::Bigtable::ColumnFamily]
-        #
-        # @example
-        #   require "google/cloud/bigtable"
-        #
-        #   bigtable = Google::Cloud::Bigtable.new
-        #
-        #   instance = bigtable.instance("my-instance")
-        #   table = instance.table("my-table")
-        #
-        #   column_family = table.column_families.find {|cf| cf.name == "cf" }
-        #   column_family.gc_rule = Google::Cloud::Bigtable::GcRule.max_age(600)
-        #   column_family.save
-        #
-        def save
-          modify_column_family(self.class.update_modification(name, gc_rule))
-        end
-        alias update save
-
-        # Permanently delete column family from table
-        #
-        # @return [Boolean] Returns true if the column family was deleted.
-        #
-        # @example
-        #   require "google/cloud/bigtable"
-        #
-        #   bigtable = Google::Cloud::Bigtable.new
-        #
-        #   instance = bigtable.instance("my-instance")
-        #   table = instance.table("my-table")
-        #
-        #   column_family = table.column_families.find {|cf| cf.name == "cf" }
-        #   column_family.delete
-        #
-        def delete
-          modify_column_family(self.class.drop_modification(name)).nil?
-        end
-
-        # Create gPRC instance to create column family modification
-        #
-        # @param name [String] Column family name
-        # @param gc_rule [Google::Cloud::Bigtable::GcRule] The garbage
-        #   collection rule to be used for the column family. Optional. The
-        #   service default value will be used when not specified.
-        # @return [Google::Bigtable::Admin::V2::ModifyColumnFamiliesRequest::Modification]
-        #
-        # @example
-        #   require "google/cloud/bigtable"
-        #
-        #   Google::Cloud::Bigtable::ColumnFamily.create_modification(
-        #     "cf1", Google::Cloud::Bigtable::GcRule.max_age(600))
-        #   )
-        #
-        def self.create_modification name, gc_rule
-          column_modification_grpc(:create, name, gc_rule)
-        end
-
-        # Create update column family modification gPRC instance
-        #
-        # @param name [String] Column family name
-        # @param gc_rule [Google::Cloud::Bigtable::GcRule] The garbage
-        #   collection rule to be used for the column family. Optional. The
-        #   service default value will be used when not specified.
-        # @return [Google::Bigtable::Admin::V2::ModifyColumnFamiliesRequest::Modification]
-        #
-        # @example
-        #   require "google/cloud/bigtable"
-        #
-        #   Google::Cloud::Bigtable::ColumnFamily.update_modification(
-        #     "cf1", Google::Cloud::Bigtable::GcRule.max_age(600))
-        #   )
-        #
-        def self.update_modification name, gc_rule
-          column_modification_grpc(:update, name, gc_rule)
-        end
-
-        # Create drop column family modification gRPC instance
-        #
-        # @param name [String] Column family name
-        # @return [Google::Bigtable::Admin::V2::ModifyColumnFamiliesRequest::Modification]
-        #
-        # @example
-        #   require "google/cloud/bigtable"
-        #
-        #   Google::Cloud::Bigtable::ColumnFamily.drop_modification("cf1")
-        #
-        def self.drop_modification name
-          column_modification_grpc(:drop, name)
+        # @private
+        # @return [Google::Bigtable::Admin::V2::ColumnFamily]
+        def to_grpc
+          grpc = Google::Bigtable::Admin::V2::ColumnFamily.new
+          grpc.gc_rule = gc_rule.to_grpc if gc_rule
+          grpc
         end
 
         # @private
         #
-        # Create a new ColumnFamily instance from a
-        # Google::Bigtable::Admin::V2::ColumnFamily.
+        # Create a new ColumnFamily instance from a {Google::Bigtable::Admin::V2::ColumnFamily}.
         #
         # @param grpc [Google::Bigtable::Admin::V2::ColumnFamily]
-        # @param service [Google::Cloud::Bigtable::Service]
         # @param name [String] Column family name
-        # @param instance_id [String]
-        # @param table_id [String]
         # @return [Google::Cloud::Bigtable::ColumnFamily]
         #
-        def self.from_grpc \
-            grpc,
-            service,
-            name: nil,
-            instance_id: nil,
-            table_id: nil
-          new(service, grpc: grpc, name: name).tap do |cf|
-            cf.table_id = table_id
-            cf.instance_id = instance_id
+        def self.from_grpc grpc, name
+          new(name).tap do |cf|
+            cf.gc_rule = GcRule.from_grpc grpc.gc_rule if grpc.gc_rule
           end
         end
-
-        # @private
-        #
-        # Create column family modification gRPC instance
-        #
-        # @param type [Symbol] Type of modification.
-        #   Valid values are `:create`, `:update`, `drop`
-        # @param family_name [String] Column family name
-        # @param gc_rule [Google::Cloud::Bigtable::GcRule] The garbage
-        #   collection rule to be used for the column family. Optional. The
-        #   service default value will be used when not specified.
-        # @return [Google::Bigtable::Admin::V2::ModifyColumnFamiliesRequest::Modification]
-        #
-        def self.column_modification_grpc type, family_name, gc_rule = nil
-          attrs = { id: family_name }
-
-          attrs[type] = if type == :drop
-                          true
-                        else
-                          cf = Google::Bigtable::Admin::V2::ColumnFamily.new
-                          cf.gc_rule = gc_rule.to_grpc if gc_rule
-                          cf
-                        end
-
-          Google::Bigtable::Admin::V2::ModifyColumnFamiliesRequest:: \
-              Modification.new(attrs)
-        end
-
-        protected
-
-        # @private
-        #
-        # Create/Update/Delete column_family
-        #
-        # @param modification [Google::Bigtable::Admin::V2::ModifyColumnFamiliesRequest::Modification]
-        # @return [Google::Cloud::Bigtable::ColumnFamily]
-        #
-        def modify_column_family modification
-          ensure_service!
-          table = Table.modify_column_families(
-            service,
-            instance_id,
-            table_id,
-            modification
-          )
-          table.column_families.find { |cf| cf.name == name }
-        end
-
-        # @private
-        #
-        # Raise an error unless an active connection to the service is
-        # available
-        #
-        def ensure_service!
-          raise "Must have active connection to service" unless service
-        end
       end
     end
   end

data/lib/google/cloud/bigtable/column_family_map.rb

@@ -0,0 +1,426 @@
+# frozen_string_literal: true
+
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require "google/cloud/bigtable/column_family"
+
+module Google
+  module Cloud
+    module Bigtable
+      ##
+      # Represents a table's column families.
+      #
+      # See {Project#create_table}, {Instance#create_table} and
+      # {Table#column_families}.
+      #
+      # @example
+      #   require "google/cloud/bigtable"
+      #
+      #   bigtable = Google::Cloud::Bigtable.new
+      #
+      #   column_families = Google::Cloud::Bigtable::ColumnFamilyMap.new
+      #
+      #   column_families.add "cf1", gc_rule: Google::Cloud::Bigtable::GcRule.max_age(600)
+      #   column_families.add "cf2", gc_rule: Google::Cloud::Bigtable::GcRule.max_versions(5)
+      #
+      # @example Create a table with a block yielding a ColumnFamilyMap.
+      #   require "google/cloud/bigtable"
+      #
+      #   bigtable = Google::Cloud::Bigtable.new
+      #
+      #   table = bigtable.create_table("my-instance", "my-table") do |cfm|
+      #     cfm.add('cf1', gc_rule: Google::Cloud::Bigtable::GcRule.max_versions(5))
+      #     cfm.add('cf2', gc_rule: Google::Cloud::Bigtable::GcRule.max_age(600))
+      #
+      #     gc_rule = Google::Cloud::Bigtable::GcRule.union(
+      #       Google::Cloud::Bigtable::GcRule.max_age(1800),
+      #       Google::Cloud::Bigtable::GcRule.max_versions(3)
+      #     )
+      #     cfm.add('cf3', gc_rule: gc_rule)
+      #   end
+      #
+      #   puts table.column_families
+      #
+      # @example Update column families with a block yielding a ColumnFamilyMap.
+      #   require "google/cloud/bigtable"
+      #
+      #   bigtable = Google::Cloud::Bigtable.new
+      #
+      #   table = bigtable.table("my-instance", "my-table", perform_lookup: true)
+      #
+      #   table.column_families do |cfm|
+      #     cfm.add "cf4", gc_rule: Google::Cloud::Bigtable::GcRule.max_age(600)
+      #     cfm.add "cf5", gc_rule: Google::Cloud::Bigtable::GcRule.max_versions(5)
+      #
+      #     rule_1 = Google::Cloud::Bigtable::GcRule.max_versions(3)
+      #     rule_2 = Google::Cloud::Bigtable::GcRule.max_age(600)
+      #     rule_union = Google::Cloud::Bigtable::GcRule.union(rule_1, rule_2)
+      #     cfm.update "cf2", gc_rule: rule_union
+      #
+      #     cfm.delete "cf3"
+      #   end
+      #
+      #   puts table.column_families["cf3"] #=> nil
+      #
+      class ColumnFamilyMap
+        include Enumerable
+
+        ##
+        # Create a new ColumnFamilyMap object.
+        #
+        # @example
+        #   require "google/cloud/bigtable"
+        #
+        #   bigtable = Google::Cloud::Bigtable.new
+        #
+        #   column_families = Google::Cloud::Bigtable::ColumnFamilyMap.new
+        #
+        #   column_families.add "cf1", gc_rule: Google::Cloud::Bigtable::GcRule.max_age(600)
+        #   column_families.add "cf2", gc_rule: Google::Cloud::Bigtable::GcRule.max_versions(5)
+        #
+        # @example Create new column families using block syntax:
+        #   require "google/cloud/bigtable"
+        #
+        #   bigtable = Google::Cloud::Bigtable.new
+        #
+        #   column_families = Google::Cloud::Bigtable::ColumnFamilyMap.new do |cfm|
+        #     cfm.add "cf1", gc_rule: Google::Cloud::Bigtable::GcRule.max_age(600)
+        #     cfm.add "cf2", gc_rule: Google::Cloud::Bigtable::GcRule.max_versions(5)
+        #   end
+        #
+        def initialize
+          @column_families = empty_map
+
+          yield self if block_given?
+        end
+
+        ##
+        # Calls block once for each column family in the map, passing passing
+        # the name and column family pair as parameters.
+        #
+        # If no block is given, an enumerator is returned instead.
+        #
+        # @yield [name, column_family] The name and column family pair
+        # @yieldparam [String] name the column family name
+        # @yieldparam [ColumnFamily] column_family the column family object
+        #
+        # @return [Enumerator]
+        #
+        def each
+          return enum_for :each unless block_given?
+
+          @column_families.each do |name, column_family_grpc|
+            column_family = ColumnFamily.from_grpc column_family_grpc, name
+            yield name, column_family
+          end
+        end
+
+        ##
+        # Retrieves the ColumnFamily object corresponding to the `name`. If not
+        # found, returns `nil`.
+        #
+        # @return [ColumnFamily]
+        #
+        def [] name
+          return nil unless name? name
+
+          ColumnFamily.from_grpc @column_families[name], name
+        end
+
+        ##
+        # Returns true if the given name is present in the map.
+        #
+        # @return [Boolean]
+        #
+        def name? name
+          @column_families.has_key? name
+        end
+        alias key? name?
+
+        ##
+        # Returns a new array populated with the names from the map.
+        #
+        # @return [Array<String>]
+        #
+        def names
+          @column_families.keys
+        end
+        alias keys names
+
+        ##
+        # Returns the number of name and column family pairs in the map.
+        #
+        # @return [Integer]
+        #
+        def length
+          @column_families.length
+        end
+        alias size length
+
+        ##
+        # Returns true if the map contains no name and column family pairs.
+        #
+        # @return [Boolean]
+        #
+        def empty?
+          length.zero?
+        end
+
+        ##
+        # Adds a new column family to the table.
+        #
+        # @overload add(name, gc_rule: nil)
+        #   @param name [String] Column family name
+        #   @param gc_rule [Google::Cloud::Bigtable::GcRule] The garbage
+        #     collection rule to be used for the column family. Optional. The
+        #     service default value will be used when not specified.
+        #
+        # @raise [ArgumentError] if the column family name already exists.
+        # @raise [FrozenError] if the column family map is frozen.
+        #
+        # @example
+        #   require "google/cloud/bigtable"
+        #
+        #   bigtable = Google::Cloud::Bigtable.new
+        #
+        #   table = bigtable.table("my-instance", "my-table", perform_lookup: true)
+        #
+        #   table.column_families do |column_families|
+        #     column_families.add "cf4", gc_rule: Google::Cloud::Bigtable::GcRule.max_age(600)
+        #     column_families.add "cf5", gc_rule: Google::Cloud::Bigtable::GcRule.max_versions(5)
+        #   end
+        #
+        def add name, positional_gc_rule = nil, gc_rule: nil
+          raise ArgumentError, "column family #{name.inspect} already exists" if @column_families.has_key? name
+
+          gc_rule ||= positional_gc_rule
+          if positional_gc_rule
+            warn "The positional gc_rule argument is deprecated. Use the named gc_rule argument instead."
+          end
+
+          column_family = Google::Bigtable::Admin::V2::ColumnFamily.new
+          column_family.gc_rule = gc_rule.to_grpc if gc_rule
+          @column_families[name] = column_family
+
+          nil
+        end
+        alias create add
+
+        ##
+        # Updates an existing column family in the table.
+        #
+        # @param name [String] Column family name
+        # @param gc_rule [Google::Cloud::Bigtable::GcRule] The new garbage
+        #   collection rule to be used for the column family. Optional. The
+        #   service default value will be used when not specified.
+        #
+        # @raise [ArgumentError] if the column family name does not exist.
+        # @raise [FrozenError] if the column family map is frozen.
+        #
+        # @example
+        #   require "google/cloud/bigtable"
+        #
+        #   bigtable = Google::Cloud::Bigtable.new
+        #
+        #   table = bigtable.table("my-instance", "my-table", perform_lookup: true)
+        #
+        #   table.column_families do |column_families|
+        #     rule_1 = Google::Cloud::Bigtable::GcRule.max_versions(3)
+        #     rule_2 = Google::Cloud::Bigtable::GcRule.max_age(600)
+        #     rule_union = Google::Cloud::Bigtable::GcRule.union(rule_1, rule_2)
+        #
+        #     column_families.update "cf2", gc_rule: rule_union
+        #   end
+        #
+        def update name, gc_rule: nil
+          raise ArgumentError, "column family #{name.inspect} does not exist" unless @column_families.has_key? name
+
+          column_family = Google::Bigtable::Admin::V2::ColumnFamily.new
+          column_family.gc_rule = gc_rule.to_grpc if gc_rule
+          @column_families[name] = column_family
+
+          nil
+        end
+
+        ##
+        # Deletes the named column family from the table.
+        #
+        # @param name [String] Column family name
+        #
+        # @raise [ArgumentError] if the column family name does not exist.
+        # @raise [FrozenError] if the column family map is frozen.
+        #
+        # @example
+        #   require "google/cloud/bigtable"
+        #
+        #   bigtable = Google::Cloud::Bigtable.new
+        #
+        #   table = bigtable.table("my-instance", "my-table", perform_lookup: true)
+        #
+        #   table.column_families do |column_families|
+        #     column_families.delete "cf3"
+        #   end
+        #
+        def delete name
+          raise ArgumentError, "column family #{name.inspect} does not exist" unless @column_families.has_key? name
+
+          @column_families.delete name
+
+          nil
+        end
+        alias drop delete
+
+        ##
+        # @private
+        # We don't need to document this method.
+        #
+        def freeze
+          @column_families.freeze
+          super
+        end
+
+        ##
+        # @private
+        #
+        # Build column family modifications for the map.
+        #
+        # @param comparison_map [Google::Protobuf::Map] The map to compare the
+        #   current map against for building the modification entries.
+        # @return [Array<Google::Bigtable::Admin::V2::ModifyColumnFamiliesRequest::Modification>]
+        #
+        def modifications comparison_map = nil
+          comparison_map ||= empty_map
+
+          created_modifications(comparison_map) +
+            updated_modifications(comparison_map) +
+            dropped_modifications(comparison_map)
+        end
+
+        ##
+        # @private
+        #
+        # Return the Google::Protobuf::Map for the ColumnFamilyMap.
+        #
+        # @return [Google::Protobuf::Map]
+        #
+        def to_grpc
+          # Always return a dup in case it was frozen.
+          @column_families.dup
+        end
+
+        ##
+        # @private
+        #
+        # Return the Hash for the ColumnFamilyMap.
+        #
+        # @return [Hash]
+        #
+        def to_grpc_hash
+          Hash[to_grpc.to_a]
+        end
+
+        ##
+        # @private
+        #
+        # Create new ColumnFamilyMap from Google::Protobuf::Map.
+        #
+        # @param grpc_map [Google::Protobuf::Map]
+        # @return [ColumnFamilyMap]
+        #
+        def self.from_grpc grpc_map
+          new.tap do |cfm|
+            # Always dup so we don't modify the original map object.
+            cfm.instance_variable_set :@column_families, grpc_map.dup
+          end
+        end
+
+        protected
+
+        ##
+        # Create an empty Google::Protobuf::Map suitable for column_families.
+        def empty_map
+          Google::Bigtable::Admin::V2::Table.new.column_families
+        end
+
+        ##
+        # @private
+        #
+        # Build column family modifications for created column families.
+        #
+        # @param comparison_map [Google::Protobuf::Map] The map to compare the
+        #   current map against for building the modification entries.
+        # @return [Array<Google::Bigtable::Admin::V2::ModifyColumnFamiliesRequest::Modification>]
+        #
+        def created_modifications comparison_map
+          added_keys = @column_families.keys - comparison_map.keys
+
+          added_keys.map do |name|
+            Google::Bigtable::Admin::V2::ModifyColumnFamiliesRequest:: \
+            Modification.new(
+              id:     name,
+              create: @column_families[name]
+            )
+          end
+        end
+
+        ##
+        # @private
+        #
+        # Build column family modifications for updated column families.
+        #
+        # @param comparison_map [Google::Protobuf::Map] The map to compare the
+        #   current map against for building the modification entries.
+        # @return [Array<Google::Bigtable::Admin::V2::ModifyColumnFamiliesRequest::Modification>]
+        #
+        def updated_modifications comparison_map
+          possibly_updated_keys = @column_families.keys & comparison_map.keys
+          updated_keys = possibly_updated_keys.reject do |name|
+            @column_families[name] == comparison_map[name]
+          end
+
+          updated_keys.map do |name|
+            Google::Bigtable::Admin::V2::ModifyColumnFamiliesRequest:: \
+            Modification.new(
+              id:     name,
+              update: @column_families[name]
+            )
+          end
+        end
+
+        ##
+        # @private
+        #
+        # Build column family modifications for dropped column families.
+        #
+        # @param comparison_map [Google::Protobuf::Map] The map to compare the
+        #   current map against for building the modification entries.
+        # @return [Array<Google::Bigtable::Admin::V2::ModifyColumnFamiliesRequest::Modification>]
+        #
+        def dropped_modifications comparison_map
+          dropped_keys = comparison_map.keys - @column_families.keys
+
+          dropped_keys.map do |name|
+            Google::Bigtable::Admin::V2::ModifyColumnFamiliesRequest:: \
+            Modification.new(
+              id:   name,
+              drop: true
+            )
+          end
+        end
+      end
+    end
+  end
+end