src/java/org/apache/cassandra/db/marshal/DynamicCompositeType.java - cassandra - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you 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.
  */
 package org.apache.cassandra.db.marshal;

 import java.nio.charset.CharacterCodingException;
 import java.nio.ByteBuffer;
 import java.util.HashMap;
 import java.util.Map;

 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.transport.ProtocolVersion;
 import org.apache.cassandra.utils.ByteBufferUtil;

 /*
  * The encoding of a DynamicCompositeType column name should be:
  *   <component><component><component> ...
  * where <component> is:
  *   <comparator part><value><'end-of-component' byte>
  * where:
  *   - <comparator part>: either the comparator full name, or a declared
  *     aliases. This is at least 2 bytes (those 2 bytes are called header in
  *     the following). If the first bit of the header is 1, then this
  *     comparator part is an alias, otherwise it's a comparator full name:
  *       - aliases: the actual alias is the 2nd byte of header taken as a
  *         character. The whole <comparator part> is thus 2 byte long.
  *       - comparator full name: the header is the length of the remaining
  *         part. The remaining part is the UTF-8 encoded comparator class
  *         name.
  *   - <value>: the component value bytes preceded by 2 byte containing the
  *     size of value (see CompositeType).
  *   - 'end-of-component' byte is defined as in CompositeType
  */
 public class DynamicCompositeType extends AbstractCompositeType
 {
     private static final Logger logger = LoggerFactory.getLogger(DynamicCompositeType.class);

     private final Map<Byte, AbstractType<?>> aliases;

     // interning instances
     private static final Map<Map<Byte, AbstractType<?>>, DynamicCompositeType> instances = new HashMap<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)
     {
         DynamicCompositeType dct = instances.get(aliases);
         if (dct == null)
         {
             dct = new DynamicCompositeType(aliases);
             instances.put(aliases, dct);
         }
         return dct;
     }

     private DynamicCompositeType(Map<Byte, AbstractType<?>> aliases)
     {
         this.aliases = aliases;
     }

     protected boolean readIsStatic(ByteBuffer bb)
     {
         // We don't have the static nothing for DCT
         return false;
     }

     private AbstractType<?> getComparator(ByteBuffer bb)
     {
         try
         {
             int header = ByteBufferUtil.readShortLength(bb);
             if ((header & 0x8000) == 0)
             {
                 String name = ByteBufferUtil.string(ByteBufferUtil.readBytes(bb, header));
                 return TypeParser.parse(name);
             }
             else
             {
                 return aliases.get((byte)(header & 0xFF));
             }
         }
         catch (CharacterCodingException e)
         {
             throw new RuntimeException(e);
         }
     }

     protected AbstractType<?> getComparator(int i, ByteBuffer bb)
     {
         return getComparator(bb);
     }

     protected AbstractType<?> getComparator(int i, ByteBuffer bb1, ByteBuffer bb2)
     {
         AbstractType<?> comp1 = getComparator(bb1);
         AbstractType<?> comp2 = getComparator(bb2);
         AbstractType<?> rawComp = comp1;

         /*
          * If both types are ReversedType(Type), we need to compare on the wrapped type (which may differ between the two types) to avoid
          * incompatible comparisons being made.
          */
         if ((comp1 instanceof ReversedType) && (comp2 instanceof ReversedType))
         {
             comp1 = ((ReversedType<?>) comp1).baseType;
             comp2 = ((ReversedType<?>) comp2).baseType;
         }

         // Fast test if the comparator uses singleton instances
         if (comp1 != comp2)
         {
             /*
              * We compare component of different types by comparing the
              * comparator class names. We start with the simple classname
              * first because that will be faster in almost all cases, but
              * fallback on the full name if necessary
              */
             int cmp = comp1.getClass().getSimpleName().compareTo(comp2.getClass().getSimpleName());
             if (cmp != 0)
                 return cmp < 0 ? FixedValueComparator.alwaysLesserThan : FixedValueComparator.alwaysGreaterThan;

             cmp = comp1.getClass().getName().compareTo(comp2.getClass().getName());
             if (cmp != 0)
                 return cmp < 0 ? FixedValueComparator.alwaysLesserThan : FixedValueComparator.alwaysGreaterThan;

             // if cmp == 0, we're actually having the same type, but one that
             // did not have a singleton instance. It's ok (though inefficient).
         }
         // Use the raw comparator (prior to ReversedType unwrapping)
         return rawComp;
     }

     protected AbstractType<?> getAndAppendComparator(int i, ByteBuffer bb, StringBuilder sb)
     {
         try
         {
             int header = ByteBufferUtil.readShortLength(bb);
             if ((header & 0x8000) == 0)
             {
                 String name = ByteBufferUtil.string(ByteBufferUtil.readBytes(bb, header));
                 sb.append(name).append("@");
                 return TypeParser.parse(name);
             }
             else
             {
                 sb.append((char)(header & 0xFF)).append("@");
                 return aliases.get((byte)(header & 0xFF));
             }
         }
         catch (CharacterCodingException e)
         {
             throw new RuntimeException(e);
         }
     }

     protected ParsedComparator parseComparator(int i, String part)
     {
         return new DynamicParsedComparator(part);
     }

     protected AbstractType<?> validateComparator(int i, ByteBuffer bb) throws MarshalException
     {
         AbstractType<?> comparator = null;
         if (bb.remaining() < 2)
             throw new MarshalException("Not enough bytes to header of the comparator part of component " + i);
         int header = ByteBufferUtil.readShortLength(bb);
         if ((header & 0x8000) == 0)
         {
             if (bb.remaining() < header)
                 throw new MarshalException("Not enough bytes to read comparator name of component " + i);

             ByteBuffer value = ByteBufferUtil.readBytes(bb, header);
             String valueStr = null;
             try
             {
                 valueStr = ByteBufferUtil.string(value);
                 comparator = TypeParser.parse(valueStr);
             }
             catch (CharacterCodingException ce)
             {
                 // ByteBufferUtil.string failed.
                 // Log it here and we'll further throw an exception below since comparator == null
                 logger.error("Failed with [{}] when decoding the byte buffer in ByteBufferUtil.string()",
                    ce.toString());
             }
             catch (Exception e)
             {
                 // parse failed.
                 // Log it here and we'll further throw an exception below since comparator == null
                 logger.error("Failed to parse value string \"{}\" with exception: [{}]",
                    valueStr, e.toString());
             }
         }
         else
         {
             comparator = aliases.get((byte)(header & 0xFF));
         }

         if (comparator == null)
             throw new MarshalException("Cannot find comparator for component " + i);
         else
             return comparator;
     }

     public ByteBuffer decompose(Object... objects)
     {
         throw new UnsupportedOperationException();
     }

     @Override
     public boolean isCompatibleWith(AbstractType<?> previous)
     {
         if (this == previous)
             return true;

         if (!(previous instanceof DynamicCompositeType))
             return false;

         // Adding new aliases is fine (but removing is not)
         // Note that modifying the type for an alias to a compatible type is
         // *not* fine since this would deal correctly with mixed aliased/not
         // aliased component.
         DynamicCompositeType cp = (DynamicCompositeType)previous;
         if (aliases.size() < cp.aliases.size())
             return false;

         for (Map.Entry<Byte, AbstractType<?>> entry : cp.aliases.entrySet())
         {
             AbstractType<?> tprev = entry.getValue();
             AbstractType<?> tnew = aliases.get(entry.getKey());
             if (tnew == null || tnew != tprev)
                 return false;
         }
         return true;
     }

     private class DynamicParsedComparator implements ParsedComparator
     {
         final AbstractType<?> type;
         final boolean isAlias;
         final String comparatorName;
         final String remainingPart;

         DynamicParsedComparator(String part)
         {
             String[] splits = part.split("@");
             if (splits.length != 2)
                 throw new IllegalArgumentException("Invalid component representation: " + part);

             comparatorName = splits[0];
             remainingPart = splits[1];

             try
             {
                 AbstractType<?> t = null;
                 if (comparatorName.length() == 1)
                 {
                     // try for an alias
                     // Note: the char to byte cast is theorically bogus for unicode character. I take full
                     // responsibility if someone get hit by this (without making it on purpose)
                     t = aliases.get((byte)comparatorName.charAt(0));
                 }
                 isAlias = t != null;
                 if (!isAlias)
                 {
                     t = TypeParser.parse(comparatorName);
                 }
                 type = t;
             }
             catch (SyntaxException | ConfigurationException e)
             {
                 throw new IllegalArgumentException(e);
             }
         }

         public AbstractType<?> getAbstractType()
         {
             return type;
         }

         public String getRemainingPart()
         {
             return remainingPart;
         }

         public int getComparatorSerializedSize()
         {
             return isAlias ? 2 : 2 + ByteBufferUtil.bytes(comparatorName).remaining();
         }

         public void serializeComparator(ByteBuffer bb)
         {
             int header = 0;
             if (isAlias)
                 header = 0x8000 | (((byte)comparatorName.charAt(0)) & 0xFF);
             else
                 header = comparatorName.length();
             ByteBufferUtil.writeShortLength(bb, header);

             if (!isAlias)
                 bb.put(ByteBufferUtil.bytes(comparatorName));
         }
     }

     @Override
     public String toString()
     {
         return getClass().getName() + TypeParser.stringifyAliasesParameters(aliases);
     }

     /*
      * A comparator that always sorts it's first argument before the second
      * one.
      */
     private static class FixedValueComparator extends AbstractType<Void>
     {
         public static final FixedValueComparator alwaysLesserThan = new FixedValueComparator(-1);
         public static final FixedValueComparator alwaysGreaterThan = new FixedValueComparator(1);

         private final int cmp;

         public FixedValueComparator(int cmp)
         {
             super(ComparisonType.CUSTOM);
             this.cmp = cmp;
         }

         public int compareCustom(ByteBuffer v1, ByteBuffer v2)
         {
             return cmp;
         }

         @Override
         public Void compose(ByteBuffer bytes)
         {
             throw new UnsupportedOperationException();
         }

         @Override
         public ByteBuffer decompose(Void value)
         {
             throw new UnsupportedOperationException();
         }

         public String getString(ByteBuffer bytes)
         {
             throw new UnsupportedOperationException();
         }

         public ByteBuffer fromString(String str)
         {
             throw new UnsupportedOperationException();
         }

         @Override
         public Term fromJSONObject(Object parsed)
         {
             throw new UnsupportedOperationException();
         }

         @Override
         public String toJSONString(ByteBuffer buffer, ProtocolVersion protocolVersion)
         {
             throw new UnsupportedOperationException();
         }

         @Override
         public void validate(ByteBuffer bytes)
         {
             throw new UnsupportedOperationException();
         }

         public TypeSerializer<Void> getSerializer()
         {
             throw new UnsupportedOperationException();
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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.
	*/
	package org.apache.cassandra.db.marshal;

	import java.nio.charset.CharacterCodingException;
	import java.nio.ByteBuffer;
	import java.util.HashMap;
	import java.util.Map;

	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.transport.ProtocolVersion;
	import org.apache.cassandra.utils.ByteBufferUtil;

	/*
	* The encoding of a DynamicCompositeType column name should be:
	* <component><component><component> ...
	* where <component> is:
	* <comparator part><value><'end-of-component' byte>
	* where:
	* - <comparator part>: either the comparator full name, or a declared
	* aliases. This is at least 2 bytes (those 2 bytes are called header in
	* the following). If the first bit of the header is 1, then this
	* comparator part is an alias, otherwise it's a comparator full name:
	* - aliases: the actual alias is the 2nd byte of header taken as a
	* character. The whole <comparator part> is thus 2 byte long.
	* - comparator full name: the header is the length of the remaining
	* part. The remaining part is the UTF-8 encoded comparator class
	* name.
	* - <value>: the component value bytes preceded by 2 byte containing the
	* size of value (see CompositeType).
	* - 'end-of-component' byte is defined as in CompositeType
	*/
	public class DynamicCompositeType extends AbstractCompositeType
	{
	private static final Logger logger = LoggerFactory.getLogger(DynamicCompositeType.class);

	private final Map<Byte, AbstractType<?>> aliases;

	// interning instances
	private static final Map<Map<Byte, AbstractType<?>>, DynamicCompositeType> instances = new HashMap<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)
	{
	DynamicCompositeType dct = instances.get(aliases);
	if (dct == null)
	{
	dct = new DynamicCompositeType(aliases);
	instances.put(aliases, dct);
	}
	return dct;
	}

	private DynamicCompositeType(Map<Byte, AbstractType<?>> aliases)
	{
	this.aliases = aliases;
	}

	protected boolean readIsStatic(ByteBuffer bb)
	{
	// We don't have the static nothing for DCT
	return false;
	}

	private AbstractType<?> getComparator(ByteBuffer bb)
	{
	try
	{
	int header = ByteBufferUtil.readShortLength(bb);
	if ((header & 0x8000) == 0)
	{
	String name = ByteBufferUtil.string(ByteBufferUtil.readBytes(bb, header));
	return TypeParser.parse(name);
	}
	else
	{
	return aliases.get((byte)(header & 0xFF));
	}
	}
	catch (CharacterCodingException e)
	{
	throw new RuntimeException(e);
	}
	}

	protected AbstractType<?> getComparator(int i, ByteBuffer bb)
	{
	return getComparator(bb);
	}

	protected AbstractType<?> getComparator(int i, ByteBuffer bb1, ByteBuffer bb2)
	{
	AbstractType<?> comp1 = getComparator(bb1);
	AbstractType<?> comp2 = getComparator(bb2);
	AbstractType<?> rawComp = comp1;

	/*
	* If both types are ReversedType(Type), we need to compare on the wrapped type (which may differ between the two types) to avoid
	* incompatible comparisons being made.
	*/
	if ((comp1 instanceof ReversedType) && (comp2 instanceof ReversedType))
	{
	comp1 = ((ReversedType<?>) comp1).baseType;
	comp2 = ((ReversedType<?>) comp2).baseType;
	}

	// Fast test if the comparator uses singleton instances
	if (comp1 != comp2)
	{
	/*
	* We compare component of different types by comparing the
	* comparator class names. We start with the simple classname
	* first because that will be faster in almost all cases, but
	* fallback on the full name if necessary
	*/
	int cmp = comp1.getClass().getSimpleName().compareTo(comp2.getClass().getSimpleName());
	if (cmp != 0)
	return cmp < 0 ? FixedValueComparator.alwaysLesserThan : FixedValueComparator.alwaysGreaterThan;

	cmp = comp1.getClass().getName().compareTo(comp2.getClass().getName());
	if (cmp != 0)
	return cmp < 0 ? FixedValueComparator.alwaysLesserThan : FixedValueComparator.alwaysGreaterThan;

	// if cmp == 0, we're actually having the same type, but one that
	// did not have a singleton instance. It's ok (though inefficient).
	}
	// Use the raw comparator (prior to ReversedType unwrapping)
	return rawComp;
	}

	protected AbstractType<?> getAndAppendComparator(int i, ByteBuffer bb, StringBuilder sb)
	{
	try
	{
	int header = ByteBufferUtil.readShortLength(bb);
	if ((header & 0x8000) == 0)
	{
	String name = ByteBufferUtil.string(ByteBufferUtil.readBytes(bb, header));
	sb.append(name).append("@");
	return TypeParser.parse(name);
	}
	else
	{
	sb.append((char)(header & 0xFF)).append("@");
	return aliases.get((byte)(header & 0xFF));
	}
	}
	catch (CharacterCodingException e)
	{
	throw new RuntimeException(e);
	}
	}

	protected ParsedComparator parseComparator(int i, String part)
	{
	return new DynamicParsedComparator(part);
	}

	protected AbstractType<?> validateComparator(int i, ByteBuffer bb) throws MarshalException
	{
	AbstractType<?> comparator = null;
	if (bb.remaining() < 2)
	throw new MarshalException("Not enough bytes to header of the comparator part of component " + i);
	int header = ByteBufferUtil.readShortLength(bb);
	if ((header & 0x8000) == 0)
	{
	if (bb.remaining() < header)
	throw new MarshalException("Not enough bytes to read comparator name of component " + i);

	ByteBuffer value = ByteBufferUtil.readBytes(bb, header);
	String valueStr = null;
	try
	{
	valueStr = ByteBufferUtil.string(value);
	comparator = TypeParser.parse(valueStr);
	}
	catch (CharacterCodingException ce)
	{
	// ByteBufferUtil.string failed.
	// Log it here and we'll further throw an exception below since comparator == null
	logger.error("Failed with [{}] when decoding the byte buffer in ByteBufferUtil.string()",
	ce.toString());
	}
	catch (Exception e)
	{
	// parse failed.
	// Log it here and we'll further throw an exception below since comparator == null
	logger.error("Failed to parse value string \"{}\" with exception: [{}]",
	valueStr, e.toString());
	}
	}
	else
	{
	comparator = aliases.get((byte)(header & 0xFF));
	}

	if (comparator == null)
	throw new MarshalException("Cannot find comparator for component " + i);
	else
	return comparator;
	}

	public ByteBuffer decompose(Object... objects)
	{
	throw new UnsupportedOperationException();
	}

	@Override
	public boolean isCompatibleWith(AbstractType<?> previous)
	{
	if (this == previous)
	return true;

	if (!(previous instanceof DynamicCompositeType))
	return false;

	// Adding new aliases is fine (but removing is not)
	// Note that modifying the type for an alias to a compatible type is
	// not fine since this would deal correctly with mixed aliased/not
	// aliased component.
	DynamicCompositeType cp = (DynamicCompositeType)previous;
	if (aliases.size() < cp.aliases.size())
	return false;

	for (Map.Entry<Byte, AbstractType<?>> entry : cp.aliases.entrySet())
	{
	AbstractType<?> tprev = entry.getValue();
	AbstractType<?> tnew = aliases.get(entry.getKey());
	if (tnew == null \|\| tnew != tprev)
	return false;
	}
	return true;
	}

	private class DynamicParsedComparator implements ParsedComparator
	{
	final AbstractType<?> type;
	final boolean isAlias;
	final String comparatorName;
	final String remainingPart;

	DynamicParsedComparator(String part)
	{
	String[] splits = part.split("@");
	if (splits.length != 2)
	throw new IllegalArgumentException("Invalid component representation: " + part);

	comparatorName = splits[0];
	remainingPart = splits[1];

	try
	{
	AbstractType<?> t = null;
	if (comparatorName.length() == 1)
	{
	// try for an alias
	// Note: the char to byte cast is theorically bogus for unicode character. I take full
	// responsibility if someone get hit by this (without making it on purpose)
	t = aliases.get((byte)comparatorName.charAt(0));
	}
	isAlias = t != null;
	if (!isAlias)
	{
	t = TypeParser.parse(comparatorName);
	}
	type = t;
	}
	catch (SyntaxException \| ConfigurationException e)
	{
	throw new IllegalArgumentException(e);
	}
	}

	public AbstractType<?> getAbstractType()
	{
	return type;
	}

	public String getRemainingPart()
	{
	return remainingPart;
	}

	public int getComparatorSerializedSize()
	{
	return isAlias ? 2 : 2 + ByteBufferUtil.bytes(comparatorName).remaining();
	}

	public void serializeComparator(ByteBuffer bb)
	{
	int header = 0;
	if (isAlias)
	header = 0x8000 \| (((byte)comparatorName.charAt(0)) & 0xFF);
	else
	header = comparatorName.length();
	ByteBufferUtil.writeShortLength(bb, header);

	if (!isAlias)
	bb.put(ByteBufferUtil.bytes(comparatorName));
	}
	}

	@Override
	public String toString()
	{
	return getClass().getName() + TypeParser.stringifyAliasesParameters(aliases);
	}

	/*
	* A comparator that always sorts it's first argument before the second
	* one.
	*/
	private static class FixedValueComparator extends AbstractType<Void>
	{
	public static final FixedValueComparator alwaysLesserThan = new FixedValueComparator(-1);
	public static final FixedValueComparator alwaysGreaterThan = new FixedValueComparator(1);

	private final int cmp;

	public FixedValueComparator(int cmp)
	{
	super(ComparisonType.CUSTOM);
	this.cmp = cmp;
	}

	public int compareCustom(ByteBuffer v1, ByteBuffer v2)
	{
	return cmp;
	}

	@Override
	public Void compose(ByteBuffer bytes)
	{
	throw new UnsupportedOperationException();
	}

	@Override
	public ByteBuffer decompose(Void value)
	{
	throw new UnsupportedOperationException();
	}

	public String getString(ByteBuffer bytes)
	{
	throw new UnsupportedOperationException();
	}

	public ByteBuffer fromString(String str)
	{
	throw new UnsupportedOperationException();
	}

	@Override
	public Term fromJSONObject(Object parsed)
	{
	throw new UnsupportedOperationException();
	}

	@Override
	public String toJSONString(ByteBuffer buffer, ProtocolVersion protocolVersion)
	{
	throw new UnsupportedOperationException();
	}

	@Override
	public void validate(ByteBuffer bytes)
	{
	throw new UnsupportedOperationException();
	}

	public TypeSerializer<Void> getSerializer()
	{
	throw new UnsupportedOperationException();
	}
	}
	}