cequel 2.1.0 → 3.0.0

data/lib/cequel/schema/table.rb

@@ -12,19 +12,25 @@ module Cequel
 
       # @return [Symbol] the name of the table
       attr_reader :name
+
       # @return [Array<Column>] all columns defined on the table
       attr_reader :columns
+
       # @return [Array<PartitionKey>] partition key columns defined on the
       #   table
       attr_reader :partition_key_columns
+
       # @return [Array<ClusteringColumn>] clustering columns defined on the
       #   table
       attr_reader :clustering_columns
+
       # @return [Array<DataColumn,CollectionColumn>] data columns and
       #   collection columns defined on the table
       attr_reader :data_columns
+
       # @return [Hash] storage properties defined on the table
       attr_reader :properties
+
       # @return [Boolean] `true` if this table is configured with compact
       #   storage
       attr_writer :compact_storage
@@ -33,147 +39,48 @@ module Cequel
       # @param name [Symbol] the name of the table
       # @api private
       #
-      def initialize(name)
-        @name = name
+      def initialize(name, is_view=false)
+        @name = name.to_sym
+        @is_view = is_view
         @partition_key_columns, @clustering_columns, @data_columns = [], [], []
         @columns, @columns_by_name = [], {}
         @properties = ActiveSupport::HashWithIndifferentAccess.new
       end
 
-      #
-      # Define a key column. If this is the first key column defined, it will
-      # be a partition key; otherwise, it will be a clustering column.
-      #
-      # @param name [Symbol] the name of the column
-      # @param type [Symbol,Type] the type for the column
-      # @param clustering_order [:asc,:desc] whether rows should be in
-      #   ascending or descending order by this column. Only meaningful for
-      #   clustering columns.
-      # @return [void]
-      #
-      # @see #add_partition_key
-      #
-      def add_key(name, type, clustering_order = nil)
-        if @partition_key_columns.empty?
-          unless clustering_order.nil?
-            fail ArgumentError,
-                 "Can't set clustering order for partition key #{name}"
-          end
-          add_partition_key(name, type)
-        else
-          add_clustering_column(name, type, clustering_order)
-        end
-      end
-
-      #
-      # Define a partition key for the table
-      #
-      # @param name [Symbol] the name of the column
-      # @param type [Symbol,Type] the type for the column
-      # @return [void]
-      #
-      def add_partition_key(name, type)
-        PartitionKey.new(name, type(type)).tap do |column|
-          @partition_key_columns << add_column(column)
-        end
+      # @return [Boolean] `true` when this table is a materialized view
+      def materialized_view?
+        @is_view
       end
 
+      # Add a column descriptor to this table descriptor.
       #
-      # Define a clustering column for the table
-      #
-      # @param (see #add_key)
-      # @return [void]
+      # column_desc - Descriptor of column to add. Can be PartitionKey,
+      #   ClusteringColumn, DataColumn, List, Set, or Map.
       #
-      def add_clustering_column(name, type, clustering_order = nil)
-        ClusteringColumn.new(name, type(type), clustering_order)
-          .tap { |column| @clustering_columns << add_column(column) }
-      end
+      def add_column(column_desc)
+        column_flavor = case column_desc
+                        when PartitionKey
+                          @partition_key_columns
+                        when ClusteringColumn
+                          @clustering_columns
+                        else
+                          @data_columns
+                        end
 
-      #
-      # Define a data column on the table
-      #
-      # @param name [Symbol] name of the column
-      # @param type [Type] type for the column
-      # @param options [Options] options for the column
-      # @option options [Boolean,Symbol] :index (nil) name of a secondary index
-      #   to apply to the column, or `true` to infer an index name by
-      #   convention
-      # @return [void]
-      #
-      def add_data_column(name, type, options = {})
-        options = {index: options} unless options.is_a?(Hash)
-        index_name = options[:index]
-        index_name = :"#{@name}_#{name}_idx" if index_name == true
-        if type == :enum
-          type = :int
-        end
-        DataColumn.new(name, type(type), index_name)
-          .tap { |column| @data_columns << add_column(column) }
+        column_flavor << column_desc
+        columns << column_desc
+        columns_by_name[column_desc.name] = column_desc
       end
 
+      # Add a property to this table descriptor
       #
-      # Define a list column on the table
-      #
-      # @param name [Symbol] name of the list
-      # @param type [Symbol,Type] type of the list's elements
-      # @return [void]
-      #
-      # @see List
+      # property_desc - A `TableProperty` describing one property of this table.
       #
-      def add_list(name, type)
-        List.new(name, type(type)).tap do |column|
-          @data_columns << add_column(column)
-        end
+      def add_property(property_desc)
+        properties[property_desc.name] = property_desc
       end
 
       #
-      # Define a set column on the table
-      #
-      # @param name [Symbol] name of the set
-      # @param type [Symbol,Type] type of the set's elements
-      # @return [void]
-      #
-      # @see Set
-      #
-      def add_set(name, type)
-        Set.new(name, type(type)).tap do |column|
-          @data_columns << add_column(column)
-        end
-      end
-
-      #
-      # Define a map column on the table
-      #
-      # @param name [Symbol] name of the set
-      # @param key_type [Symbol,Type] type of the map's keys
-      # @param value_type [Symbol,Type] type of the map's values
-      # @return [void]
-      #
-      # @see Map
-      #
-      def add_map(name, key_type, value_type)
-        Map.new(name, type(key_type), type(value_type)).tap do |column|
-          @data_columns << add_column(column)
-        end
-      end
-
-      #
-      # Define a storage property for the table
-      #
-      # @param name [Symbol] name of the property
-      # @param value value for the property
-      # @return [void]
-      #
-      # @see STORAGE_PROPERTIES List of storage property names
-      # @see http://cassandra.apache.org/doc/cql3/CQL.html#createTableOptions
-      #   list of CQL3 table storage properties
-      #
-      def add_property(name, value)
-        TableProperty.build(name, value).tap do |property|
-          @properties[name] = property
-        end
-      end
-
       #
       # @param name [Symbol] name of column to look up
       # @return [Column] column defined on table with given name
@@ -182,17 +89,23 @@ module Cequel
         columns_by_name[name.to_sym]
       end
 
+      # Returns true iff this table has the specified column name.
+      #
+      def has_column?(name)
+        columns_by_name.has_key?(name.to_sym)
+      end
+
       #
       # @return [Array<Symbol>] the names of all columns
       def column_names
-        columns.map { |column| column.name }
+        columns_by_name.keys
       end
 
       #
       # @return [Array<Column>] all key columns (partition + clustering)
       #
       def key_columns
-        @partition_key_columns + @clustering_columns
+        partition_key_columns + clustering_columns
       end
 
       #
@@ -224,6 +137,12 @@ module Cequel
         partition_key_columns.length
       end
 
+      # Returns true iff this table descriptor currently has at least one
+      # partition key defined.
+      def has_partition_key?
+        partition_key_columns.any?
+      end
+
       #
       # @return [Array<Symbol>] names of clustering columns
       #
@@ -243,7 +162,7 @@ module Cequel
       # @return [PartitionKey] partition key column with given name
       #
       def partition_key(name)
-        @partition_key_columns.find { |column| column.name == name }
+        partition_key_columns.find { |column| column.name == name }
       end
 
       #
@@ -251,7 +170,7 @@ module Cequel
       # @return [ClusteringColumn] clustering column with given name
       #
       def clustering_column(name)
-        @clustering_columns.find { |column| column.name == name }
+        clustering_columns.find { |column| column.name == name }
       end
 
       #
@@ -261,7 +180,7 @@ module Cequel
       #
       def data_column(name)
         name = name.to_sym
-        @data_columns.find { |column| column.name == name }
+        data_columns.find { |column| column.name == name }
       end
 
       #
@@ -269,7 +188,7 @@ module Cequel
       # @return [TableProperty] property as defined on table
       #
       def property(name)
-        @properties[name].try(:value)
+        properties.fetch(name, null_table_property).value
       end
 
       #
@@ -283,19 +202,18 @@ module Cequel
 
       attr_reader :columns_by_name
 
-      private
-
-      def add_column(column)
-        columns << column
-        columns_by_name[column.name] = column
-      end
-
       def type(type)
         type = type.kind if type.respond_to?(:kind)
 
         ::Cequel::Type[type]
       end
 
+      def null_table_property
+        @@null_table_property ||= Class.new do
+          def value; nil; end
+          def name; nil; end
+        end.new
+      end
     end
   end
 end

data/lib/cequel/schema/table_desc_dsl.rb

@@ -0,0 +1,196 @@
+# -*- encoding : utf-8 -*-
+module Cequel
+  module Schema
+    #
+    # Implements a DSL used to describe CQL tables.
+    #
+    # Examples
+    #
+    #   TableDescDsl.new("posts").eval do
+    #     partition_key :blog_subdomain, :text
+    #     key :slug, :text
+    #     column :body, :text
+    #     set :author_names, :text
+    #     list :comments, :text
+    #     map :something_contrived, :text, :text
+    #   end
+    #
+    #   TableDescDsl.new("posts_view").eval do
+    #     materialized_view
+    #     partition_key :blog_subdomain, :text
+    #     key :slug, :text
+    #     column :body, :text
+    #   end
+
+    #
+    class TableDescDsl < BasicObject
+      extend ::Cequel::Util::Forwardable
+
+      # Initialize a new instance
+      #
+      # table_name - The name of the table being described.
+      protected def initialize(table_name)
+        @table_name = table_name
+        @columns = []
+        @properties = []
+        @is_compact_storage = false
+        @is_view = false
+        @has_part_key = false
+      end
+
+      # Returns a Table object built by evaluating the provided block.
+      #
+      # Yields nothing but block is instance_evaled so it as access to
+      #   all the methods of the instance.
+      def eval(&desc_block)
+        instance_eval(&desc_block)
+
+        table
+      end
+
+      # Describe (one of) the partition key(s) of the table.
+      #
+      # name - The name of the column.
+      # type - The type of the column. Either a `Cequel::Type` or a symbol.
+      #   See `Cequel::Type`.
+      #
+      def partition_key(name, type)
+        columns <<  PartitionKey.new(name, type(type))
+      end
+
+
+      # Describe (one of) the key(s) of the table.
+      #
+      # name - The name of the column
+      # type - The type of the column.  Either a `Cequel::Type` or a symbol.
+      #   See `Cequel::Type`.
+      # clustering_order - `:asc` or `:desc`. Only meaningful for cluster
+      #   keys. Leave nil for partition keys.
+      #
+      def key(name, type, clustering_order = nil)
+        columns << if has_partition_key?
+                     ClusteringColumn.new(name, type(type), clustering_order)
+                   else
+                     (fail ArgumentError, "Can't set clustering order for partition key #{name}") if clustering_order
+
+                     PartitionKey.new(name, type(type))
+                   end
+      end
+
+      # Describe a column of the table
+      #
+      # name - The name of the column.
+      # type - The type of the column. Either a `Cequel::Type` or a symbol.
+      #   See `Cequel::Type`.
+      # options
+      #   :index - name of a secondary index to apply to the column, or
+      #     `true` to infer an index name by convention
+      #
+      def column(name, type, options = {})
+        columns << DataColumn.new(name, type(type),
+                                  figure_index_name(name, options.fetch(:index, nil)))
+      end
+
+      # Describe a column of type list.
+      #
+      # name - The name of the column.
+      # type - The type of the elements of this column. Either a
+      #   `Cequel::Type` or a symbol. See `Cequel::Type`.
+      #
+      def list(name, type)
+        columns << List.new(name, type(type))
+      end
+
+      # Describe a column of type set.
+      #
+      # name - The name of the column.
+      # type - The type of the members of this column. Either a
+      #  `Cequel::Type` or a symbol. See `Cequel::Type`.
+      #
+      def set(name, type)
+        columns << Set.new(name, type(type))
+      end
+
+      # Describe a column of type map.
+      #
+      # name - The name of the column.
+      # key_type - The type of the keys of this column. Either a
+      #   `Cequel::Type` or a symbol. See `Cequel::Type`.
+      # value_type - The type of the values of this column. Either a
+      #   `Cequel::Type` or a symbol. See `Cequel::Type`.
+      def map(name, key_type, value_type)
+        columns << Map.new(name, type(key_type), type(value_type))
+      end
+
+      # Describe property of the table.
+      #
+      # name - name of property.
+      # value - value of property.
+      #
+      # See `STORAGE_PROPERTIES` List of storage property names
+      # See http://cassandra.apache.org/doc/cql3/CQL.html#createTableOptions
+      #   list of CQL3 table storage properties
+      #
+      def with(name, value)
+        properties << TableProperty.build(name, value)
+      end
+
+      #
+      # Direct that this table use "compact storage". This is primarily useful
+      # for backwards compatibility with legacy CQL2 table schemas.
+      #
+      # @return [void]
+      #
+      def compact_storage
+        @is_compact_storage = true
+      end
+
+      #
+      # Indicates that this is a materialized view.
+      #
+      # @return [void]
+      def materialized_view
+        self.is_view = true
+      end
+
+      def table
+        Table.new(table_name, is_view).tap do |tab|
+          columns.each do |c|
+            tab.add_column c
+          end
+          properties.each do |p|
+            tab.add_property p
+          end
+          tab.compact_storage = is_compact_storage
+        end
+      end
+
+      protected
+
+      attr_reader :table_name, :columns, :properties, :is_compact_storage,
+                  :is_view
+
+
+      def has_partition_key?
+        columns.any?{|c| c.partition_key? }
+      end
+
+      def type(type)
+        type = :int if type == :enum
+
+        ::Cequel::Type[type]
+      end
+
+      def figure_index_name(column_name, idx_opt)
+        case idx_opt
+        when true
+          :"#{table_name}_#{column_name}_idx"
+        when false, nil
+          nil
+        else
+          idx_opt
+        end
+      end
+    end
+  end
+end