yugabyte-ycql-driver 3.2.3.1

data/lib/cassandra/cluster/schema/fqcn_type_parser.rb

@@ -0,0 +1,175 @@
+# encoding: utf-8
+
+#--
+# Copyright DataStax, Inc.
+#
+# 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
+#
+# http://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.
+#++
+
+module Cassandra
+  class Cluster
+    class Schema
+      class FQCNTypeParser
+        # @private
+        Node   = Struct.new(:parent, :name, :children)
+        # @private
+        Result = Struct.new(:results, :collections)
+
+        @@types = {
+          'org.apache.cassandra.db.marshal.AsciiType'         => :ascii,
+          'org.apache.cassandra.db.marshal.LongType'          => :bigint,
+          'org.apache.cassandra.db.marshal.BytesType'         => :blob,
+          'org.apache.cassandra.db.marshal.BooleanType'       => :boolean,
+          'org.apache.cassandra.db.marshal.CounterColumnType' => :counter,
+          'org.apache.cassandra.db.marshal.DecimalType'       => :decimal,
+          'org.apache.cassandra.db.marshal.DoubleType'        => :double,
+          'org.apache.cassandra.db.marshal.FloatType'         => :float,
+          'org.apache.cassandra.db.marshal.InetAddressType'   => :inet,
+          'org.apache.cassandra.db.marshal.Int32Type'         => :int,
+          'org.apache.cassandra.db.marshal.UTF8Type'          => :text,
+          'org.apache.cassandra.db.marshal.TimestampType'     => :timestamp,
+          'org.apache.cassandra.db.marshal.DateType'          => :timestamp,
+          'org.apache.cassandra.db.marshal.UUIDType'          => :uuid,
+          'org.apache.cassandra.db.marshal.IntegerType'       => :varint,
+          'org.apache.cassandra.db.marshal.TimeUUIDType'      => :timeuuid,
+          'org.apache.cassandra.db.marshal.MapType'           => :map,
+          'org.apache.cassandra.db.marshal.SetType'           => :set,
+          'org.apache.cassandra.db.marshal.ListType'          => :list,
+          'org.apache.cassandra.db.marshal.UserType'          => :udt,
+          'org.apache.cassandra.db.marshal.TupleType'         => :tuple,
+          'org.apache.cassandra.db.marshal.ShortType'         => :smallint,
+          'org.apache.cassandra.db.marshal.ByteType'          => :tinyint,
+          'org.apache.cassandra.db.marshal.TimeType'          => :time,
+          'org.apache.cassandra.db.marshal.SimpleDateType'    => :date,
+          'org.apache.cassandra.db.marshal.FrozenType'        => :frozen
+        }.freeze
+
+        def parse(string)
+          create_result(parse_node(string))
+        end
+
+        private
+
+        def create_result(node)
+          collections = nil
+          results     = []
+
+          if node.name == 'org.apache.cassandra.db.marshal.CompositeType'
+            collections = {}
+
+            if node.children.last.name ==
+               'org.apache.cassandra.db.marshal.ColumnToCollectionType'
+              node.children.pop.children.each do |child|
+                key, name  = child.name.split(':')
+                key        = [key].pack('H*').force_encoding(::Encoding::UTF_8)
+
+                if name == 'org.apache.cassandra.db.marshal.ReversedType'
+                  collections[key] = lookup_type(child.children.first)
+                else
+                  child.name = name
+                  collections[key] = lookup_type(child)
+                end
+              end
+            end
+
+            node.children.each do |child|
+              results << create_type(child)
+            end
+          else
+            results << create_type(node)
+          end
+
+          Result.new(results, collections)
+        end
+
+        def create_type(node)
+          order  = :asc
+          frozen = false
+
+          if node.name == 'org.apache.cassandra.db.marshal.ReversedType'
+            order = :desc
+            node  = node.children.first
+          end
+
+          if node.name == 'org.apache.cassandra.db.marshal.FrozenType'
+            frozen = true
+            node   = node.children.first
+          end
+
+          [lookup_type(node), order, frozen]
+        end
+
+        def lookup_type(node)
+          type = @@types.fetch(node.name) do
+            return Cassandra::Types.custom(dump_node(node))
+          end
+
+          case type
+          when :set, :list, :frozen
+            Cassandra::Types.send(type, lookup_type(node.children.first))
+          when :map
+            Cassandra::Types.map(*node.children.map(&method(:lookup_type)))
+          when :udt
+            keyspace = node.children.shift.name
+            name     = [node.children.shift.name].pack('H*')
+            fields   = node.children.map do |child|
+              field_name, child_name = child.name.split(':')
+
+              child.name = child_name
+              field_name = [field_name].pack('H*').force_encoding(::Encoding::UTF_8)
+
+              [field_name, lookup_type(child)]
+            end
+
+            Cassandra::Types.udt(keyspace, name, fields)
+          when :tuple
+            Cassandra::Types.tuple(*node.children.map(&method(:lookup_type)))
+          else
+            Cassandra::Types.send(type)
+          end
+        end
+
+        def parse_node(string)
+          root = node = Node.new(nil, '', [])
+
+          string.each_char do |char|
+            case char
+            when '(' # starting type params
+              child = Node.new(node, '', [])
+              node.children << child
+              node = child
+            when ','
+              child = Node.new(node.parent, '', [])
+              node.parent.children << child
+              node = child
+            when ')'
+              node = node.parent
+            when ' '
+              next
+            else
+              node.name << char
+            end
+          end
+
+          root
+        end
+
+        def dump_node(node)
+          str = node.name
+          str << '(' + node.children.map { |n| dump_node(n) }.join(',') + ')' unless node.children.empty?
+          str
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/cluster/schema/partitioners.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+#--
+# Copyright DataStax, Inc.
+#
+# 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
+#
+# http://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 'cassandra/cluster/schema/partitioners/ordered'
+require 'cassandra/cluster/schema/partitioners/random'
+require 'cassandra/cluster/schema/partitioners/murmur3'

data/lib/cassandra/cluster/schema/partitioners/murmur3.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+#--
+# Copyright DataStax, Inc.
+#
+# 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
+#
+# http://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.
+#++
+
+module Cassandra
+  class Cluster
+    class Schema
+      # @private
+      module Partitioners
+        # @private
+        class Murmur3
+          # @private
+          LONG_MIN = -2**63
+          # @private
+          LONG_MAX = 2**63 - 1
+
+          def create_token(partition_key)
+            token = Cassandra::Murmur3.hash(partition_key)
+            token = LONG_MAX if token == LONG_MIN
+
+            token
+          end
+
+          def parse_token(token_string)
+            token_string.to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/cluster/schema/partitioners/ordered.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+#--
+# Copyright DataStax, Inc.
+#
+# 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
+#
+# http://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.
+#++
+
+module Cassandra
+  class Cluster
+    class Schema
+      # @private
+      module Partitioners
+        # @private
+        class Ordered
+          def create_token(partition_key)
+            partition_key
+          end
+
+          def parse_token(token_string)
+            token_string
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/cluster/schema/partitioners/random.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+#--
+# Copyright DataStax, Inc.
+#
+# 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
+#
+# http://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.
+#++
+
+module Cassandra
+  class Cluster
+    class Schema
+      # @private
+      module Partitioners
+        # @private
+        class Random
+          def create_token(partition_key)
+            Digest::MD5.hexdigest(partition_key).to_i(16)
+          end
+
+          def parse_token(token_string)
+            token_string.to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/cluster/schema/replication_strategies.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+#--
+# Copyright DataStax, Inc.
+#
+# 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
+#
+# http://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 'cassandra/cluster/schema/replication_strategies/simple'
+require 'cassandra/cluster/schema/replication_strategies/network_topology'
+require 'cassandra/cluster/schema/replication_strategies/none'

data/lib/cassandra/cluster/schema/replication_strategies/network_topology.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+
+#--
+# Copyright DataStax, Inc.
+#
+# 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
+#
+# http://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.
+#++
+
+module Cassandra
+  class Cluster
+    class Schema
+      # @private
+      module ReplicationStrategies
+        # @private
+        class NetworkTopology
+          def replication_map(token_hosts, token_ring, replication_options)
+            racks                  = ::Hash.new
+            datacenter_token_rings = ::Hash.new
+            size                   = token_ring.size
+
+            token_ring.each_with_index do |token, i|
+              host = token_hosts[token]
+
+              racks[host.datacenter] ||= ::Set.new
+              racks[host.datacenter].add(host.rack)
+
+              datacenter_token_rings[host.datacenter]  ||= {}
+              datacenter_token_rings[host.datacenter][i] = token
+            end
+
+            replication_map = ::Hash.new
+
+            token_ring.each_with_index do |token, i|
+              replicas = ::Set.new
+              visited  = ::Hash.new
+              skipped  = ::Hash.new
+
+              replication_options.each do |datacenter, factor|
+                ring = datacenter_token_rings[datacenter]
+                next unless ring
+                factor = begin
+                           [Integer(factor), ring.size].min
+                         rescue
+                           next
+                         end
+
+                total_racks    = racks[datacenter].size
+                visited_racks  = visited[datacenter] ||= ::Set.new
+                skipped_hosts  = skipped[datacenter] ||= ::Set.new
+                added_replicas = ::Set.new
+
+                size.times do |j|
+                  break if added_replicas.size >= factor
+
+                  tk = ring[(i + j) % size]
+                  next unless tk
+                  host = token_hosts[tk]
+                  rack = host.rack
+
+                  # unknown rack or seen all racks
+                  if rack.nil? || visited_racks.size == total_racks
+                    replicas << host
+                    added_replicas << host
+                  elsif visited_racks.include?(rack)
+                    skipped_hosts << host
+                  else
+                    replicas << host
+                    visited_racks << rack
+                    added_replicas << host
+
+                    if visited_racks.size == total_racks
+                      skipped_hosts.each do |skipped_host|
+                        break if added_replicas.size >= factor
+
+                        replicas << skipped_host
+                        added_replicas << host
+                      end
+                    end
+                  end
+                end
+              end
+
+              replication_map[token] = replicas.to_a.freeze
+            end
+
+            replication_map
+          end
+        end
+      end
+    end
+  end
+end