Release 2.4.2-10

* Add support for blob and inet CQL types in primary key (in elasticsearch _id). * Fix partitioned index #83 and provides customizable partition function implementations. * Include optimized Cassandra serializers CASSANDRA-13271
strapdata · Mar 2, 2017 · cfeba37 · cfeba37
1 parent abf7e17
commit cfeba37
Show file tree

Hide file tree

Showing 18 changed files with 655 additions and 371 deletions.
diff --git a/CHANGES.txt b/CHANGES.txt
@@ -1,3 +1,8 @@
+2.4.2-10 - 2017-03-02
+  * Add support for blob and inet CQL types in primary key (in elasticsearch _id).
+  * Fix partitioned index #83 and provides customizable partition function implementations.
+  * Include optimized Cassandra serializers CASSANDRA-13271
+
 2.4.2-9 - 2017-02-26
   * Significant write performance improvement.
   * New optimized version less internal engine (don't store any more version number in lucene files).

diff --git a/...ndra/db/marshal/DynamicCompositeType.java → ...ndra/db/marshal/DynamicCompositeType.java b/...ndra/db/marshal/DynamicCompositeType.java → ...ndra/db/marshal/DynamicCompositeType.java
@@ -17,20 +17,20 @@
  */
 package org.apache.cassandra.db.marshal;
 
-import java.nio.charset.CharacterCodingException;
 import java.nio.ByteBuffer;
-import java.util.HashMap;
+import java.nio.charset.CharacterCodingException;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 
 import org.apache.cassandra.cql3.Term;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import org.apache.cassandra.exceptions.ConfigurationException;
 import org.apache.cassandra.exceptions.SyntaxException;
-import org.apache.cassandra.serializers.TypeSerializer;
 import org.apache.cassandra.serializers.MarshalException;
+import org.apache.cassandra.serializers.TypeSerializer;
 import org.apache.cassandra.utils.ByteBufferUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /*
  * The encoding of a DynamicCompositeType column name should be:
@@ -58,21 +58,18 @@ public class DynamicCompositeType extends AbstractCompositeType
     private final Map<Byte, AbstractType<?>> aliases;
 
     // interning instances
-    private static final Map<Map<Byte, AbstractType<?>>, DynamicCompositeType> instances = new HashMap<Map<Byte, AbstractType<?>>, DynamicCompositeType>();
+    private static final ConcurrentMap<Map<Byte, AbstractType<?>>, DynamicCompositeType> instances = new ConcurrentHashMap<Map<Byte, AbstractType<?>>, DynamicCompositeType>();
 
     public static synchronized DynamicCompositeType getInstance(TypeParser parser) throws ConfigurationException, SyntaxException
     {
         return getInstance(parser.getAliasParameters());
     }
 
-    public static synchronized DynamicCompositeType getInstance(Map<Byte, AbstractType<?>> aliases)
+    public static DynamicCompositeType getInstance(Map<Byte, AbstractType<?>> aliases)
     {
         DynamicCompositeType dct = instances.get(aliases);
         if (dct == null)
-        {
-            dct = new DynamicCompositeType(aliases);
-            instances.put(aliases, dct);
-        }
+            dct = instances.computeIfAbsent(aliases, K ->  new DynamicCompositeType(K));
         return dct;
     }
 

diff --git a/core/src/main/java/org/apache/cassandra/db/marshal/ListType.java b/core/src/main/java/org/apache/cassandra/db/marshal/ListType.java
@@ -18,11 +18,7 @@
 package org.apache.cassandra.db.marshal;
 
 import java.nio.ByteBuffer;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-import java.util.UUID;
+import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
@@ -35,7 +31,7 @@
 import org.apache.cassandra.serializers.CollectionSerializer;
 import org.apache.cassandra.serializers.MarshalException;
 import org.apache.cassandra.serializers.ListSerializer;
-import org.apache.cassandra.serializers.MarshalException;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -65,11 +61,7 @@ public static <T> ListType<T> getInstance(AbstractType<T> elements, final Boolea
         ConcurrentMap<AbstractType<?>, ListType> internMap = isMultiCell ? instances : frozenInstances;
         ListType<T> t = internMap.get(elements);
         if (t == null)
-        {
-            t = new ListType<T>(elements, isMultiCell);
-            ListType<T> t2 = internMap.putIfAbsent(elements, t);
-            t = (t2 == null) ? t : t2;
-        }
+            t = internMap.computeIfAbsent(elements, K -> new ListType<>(K, isMultiCell) );
         return t;
     }
 

diff --git a/.../apache/cassandra/db/marshal/MapType.java → .../apache/cassandra/db/marshal/MapType.java b/.../apache/cassandra/db/marshal/MapType.java → .../apache/cassandra/db/marshal/MapType.java
@@ -19,6 +19,8 @@
 
 import java.nio.ByteBuffer;
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 
 import org.apache.cassandra.cql3.Json;
 import org.apache.cassandra.cql3.Maps;
@@ -27,16 +29,16 @@
 import org.apache.cassandra.exceptions.ConfigurationException;
 import org.apache.cassandra.exceptions.SyntaxException;
 import org.apache.cassandra.serializers.CollectionSerializer;
-import org.apache.cassandra.serializers.MarshalException;
 import org.apache.cassandra.serializers.MapSerializer;
+import org.apache.cassandra.serializers.MarshalException;
 import org.apache.cassandra.transport.Server;
 import org.apache.cassandra.utils.Pair;
 
 public class MapType<K, V> extends CollectionType<Map<K, V>>
 {
     // interning instances
-    private static final Map<Pair<AbstractType<?>, AbstractType<?>>, MapType> instances = new HashMap<>();
-    private static final Map<Pair<AbstractType<?>, AbstractType<?>>, MapType> frozenInstances = new HashMap<>();
+    private static final ConcurrentMap<Pair<AbstractType<?>, AbstractType<?>>, MapType> instances = new ConcurrentHashMap<>();
+    private static final ConcurrentMap<Pair<AbstractType<?>, AbstractType<?>>, MapType> frozenInstances = new ConcurrentHashMap<>();
 
     private final AbstractType<K> keys;
     private final AbstractType<V> values;
@@ -52,16 +54,13 @@ public class MapType<K, V> extends CollectionType<Map<K, V>>
         return getInstance(l.get(0), l.get(1), true);
     }
 
-    public static synchronized <K, V> MapType<K, V> getInstance(AbstractType<K> keys, AbstractType<V> values, boolean isMultiCell)
+    public static <K, V> MapType<K, V> getInstance(AbstractType<K> keys, AbstractType<V> values, boolean isMultiCell)
     {
-        Map<Pair<AbstractType<?>, AbstractType<?>>, MapType> internMap = isMultiCell ? instances : frozenInstances;
+        ConcurrentMap<Pair<AbstractType<?>, AbstractType<?>>, MapType> internMap = isMultiCell ? instances : frozenInstances;
         Pair<AbstractType<?>, AbstractType<?>> p = Pair.<AbstractType<?>, AbstractType<?>>create(keys, values);
         MapType<K, V> t = internMap.get(p);
         if (t == null)
-        {
-            t = new MapType<>(keys, values, isMultiCell);
-            internMap.put(p, t);
-        }
+            t = internMap.computeIfAbsent(p, P -> new MapType<>(P.left, P.right, isMultiCell) );
         return t;
     }
 

diff --git a/core/src/main/java/org/apache/cassandra/db/marshal/SetType.java b/core/src/main/java/org/apache/cassandra/db/marshal/SetType.java
@@ -18,12 +18,7 @@
 package org.apache.cassandra.db.marshal;
 
 import java.nio.ByteBuffer;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
@@ -60,11 +55,7 @@ public static <T> SetType<T> getInstance(AbstractType<T> elements, boolean isMul
         ConcurrentMap<AbstractType<?>, SetType> internMap = isMultiCell ? instances : frozenInstances;
         SetType<T> t = internMap.get(elements);
         if (t == null)
-        {
-            t = new SetType<T>(elements, isMultiCell);
-            SetType<T> t2 = internMap.putIfAbsent(elements, t);
-            t = (t2 == null) ? t : t2;
-        }
+            t = internMap.computeIfAbsent(elements, K -> new SetType<>(K, isMultiCell) );
         return t;
     }
 

diff --git a/...cassandra/serializers/ListSerializer.java → ...cassandra/serializers/ListSerializer.java b/...cassandra/serializers/ListSerializer.java → ...cassandra/serializers/ListSerializer.java
@@ -18,27 +18,27 @@
 
 package org.apache.cassandra.serializers;
 
-import org.apache.cassandra.transport.Server;
-
 import java.nio.BufferUnderflowException;
 import java.nio.ByteBuffer;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import org.apache.cassandra.transport.Server;
 
 public class ListSerializer<T> extends CollectionSerializer<List<T>>
 {
     // interning instances
-    private static final Map<TypeSerializer<?>, ListSerializer> instances = new HashMap<TypeSerializer<?>, ListSerializer>();
+    private static final ConcurrentMap<TypeSerializer<?>, ListSerializer> instances = new ConcurrentHashMap<TypeSerializer<?>, ListSerializer>();
 
     public final TypeSerializer<T> elements;
 
-    public static synchronized <T> ListSerializer<T> getInstance(TypeSerializer<T> elements)
+    public static <T> ListSerializer<T> getInstance(TypeSerializer<T> elements)
     {
         ListSerializer<T> t = instances.get(elements);
         if (t == null)
-        {
-            t = new ListSerializer<T>(elements);
-            instances.put(elements, t);
-        }
+            t = instances.computeIfAbsent(elements, K -> new ListSerializer<>(K) );
         return t;
     }
 

diff --git a/.../cassandra/serializers/MapSerializer.java → .../cassandra/serializers/MapSerializer.java b/.../cassandra/serializers/MapSerializer.java → .../cassandra/serializers/MapSerializer.java
@@ -21,6 +21,8 @@
 import java.nio.BufferUnderflowException;
 import java.nio.ByteBuffer;
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 
 import org.apache.cassandra.db.marshal.AbstractType;
 import org.apache.cassandra.transport.Server;
@@ -29,21 +31,18 @@
 public class MapSerializer<K, V> extends CollectionSerializer<Map<K, V>>
 {
     // interning instances
-    private static final Map<Pair<TypeSerializer<?>, TypeSerializer<?>>, MapSerializer> instances = new HashMap<Pair<TypeSerializer<?>, TypeSerializer<?>>, MapSerializer>();
+    private static final ConcurrentMap<Pair<TypeSerializer<?>, TypeSerializer<?>>, MapSerializer> instances = new ConcurrentHashMap<Pair<TypeSerializer<?>, TypeSerializer<?>>, MapSerializer>();
 
     public final TypeSerializer<K> keys;
     public final TypeSerializer<V> values;
     private final Comparator<Pair<ByteBuffer, ByteBuffer>> comparator;
 
-    public static synchronized <K, V> MapSerializer<K, V> getInstance(TypeSerializer<K> keys, TypeSerializer<V> values, Comparator<ByteBuffer> comparator)
+    public static <K, V> MapSerializer<K, V> getInstance(TypeSerializer<K> keys, TypeSerializer<V> values, Comparator<ByteBuffer> comparator)
     {
         Pair<TypeSerializer<?>, TypeSerializer<?>> p = Pair.<TypeSerializer<?>, TypeSerializer<?>>create(keys, values);
         MapSerializer<K, V> t = instances.get(p);
         if (t == null)
-        {
-            t = new MapSerializer<K, V>(keys, values, comparator);
-            instances.put(p, t);
-        }
+            t = instances.computeIfAbsent(p, P -> new MapSerializer<>(P.left, P.right, comparator) );
         return t;
     }
 

diff --git a/.../cassandra/serializers/SetSerializer.java → .../cassandra/serializers/SetSerializer.java b/.../cassandra/serializers/SetSerializer.java → .../cassandra/serializers/SetSerializer.java
@@ -21,23 +21,22 @@
 import java.nio.BufferUnderflowException;
 import java.nio.ByteBuffer;
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 
 public class SetSerializer<T> extends CollectionSerializer<Set<T>>
 {
     // interning instances
-    private static final Map<TypeSerializer<?>, SetSerializer> instances = new HashMap<TypeSerializer<?>, SetSerializer>();
+    private static final ConcurrentMap<TypeSerializer<?>, SetSerializer> instances = new ConcurrentHashMap<TypeSerializer<?>, SetSerializer>();
 
     public final TypeSerializer<T> elements;
     private final Comparator<ByteBuffer> comparator;
 
-    public static synchronized <T> SetSerializer<T> getInstance(TypeSerializer<T> elements, Comparator<ByteBuffer> elementComparator)
+    public static <T> SetSerializer<T> getInstance(TypeSerializer<T> elements, Comparator<ByteBuffer> elementComparator)
     {
         SetSerializer<T> t = instances.get(elements);
         if (t == null)
-        {
-            t = new SetSerializer<T>(elements, elementComparator);
-            instances.put(elements, t);
-        }
+            t = instances.computeIfAbsent(elements, K -> new SetSerializer<>(K, elementComparator) );
         return t;
     }