Package org.apache.cassandra.db.marshal

Class IntegerType

java.lang.Object
org.apache.cassandra.db.marshal.AbstractType<T>
org.apache.cassandra.db.marshal.NumberType<BigInteger>
org.apache.cassandra.db.marshal.IntegerType
All Implemented Interfaces:
Comparator<ByteBuffer>, AssignmentTestable
public final class IntegerType extends NumberType<BigInteger>

  • Field Details

  • Method Details

    • allowsEmpty

      public boolean allowsEmpty()
      Description copied from class: AbstractType
      Defines if the type allows an empty set of bytes (new byte[0]) as valid input. The AbstractType.validate(Object, ValueAccessor) and AbstractType.compose(Object, ValueAccessor) methods must allow empty bytes when this returns true, and must reject empty bytes when this is false.

      As of this writing, the main user of this API is for testing to know what types allow empty values and what types don't, so that the data that gets generated understands when ByteBufferUtil.EMPTY_BYTE_BUFFER is allowed as valid data.

      Overrides:
      allowsEmpty in class AbstractType<BigInteger>

    • isEmptyValueMeaningless

      public boolean isEmptyValueMeaningless()
      Description copied from class: AbstractType
      Returns true for types where empty should be handled like null like Int32Type.
      Overrides:
      isEmptyValueMeaningless in class AbstractType<BigInteger>

    • compareCustom

      public <VL, VR> int compareCustom(VL left, ValueAccessor<VL> accessorL, VR right, ValueAccessor<VR> accessorR)
      Description copied from class: AbstractType
      Implement IFF ComparisonType is CUSTOM Compares the byte representation of two instances of this class, for types where this cannot be done by simple in-order comparison of the unsigned bytes Standard Java compare semantics
      Overrides:
      compareCustom in class AbstractType<BigInteger>

    • compareIntegers

      public static <VL, VR> int compareIntegers(VL lhs, ValueAccessor<VL> accessorL, VR rhs, ValueAccessor<VR> accessorR)

    • asComparableBytes

      public <V> ByteSource asComparableBytes(ValueAccessor<V> accessor, V data, ByteComparable.Version version)
      Constructs a byte-comparable representation of the number. In the current format we represent it: directly as varint, if the length is 6 or smaller (the encoding has non-00/FF first byte) <signbyte><length as unsigned integer - 7><7 or more bytes>, otherwise where <signbyte> is 00 for negative numbers and FF for positive ones, and the length's bytes are inverted if the number is negative (so that longer length sorts smaller). Because we present the sign separately, we don't need to include 0x00 prefix for positive integers whose first byte is >= 0x80 or 0xFF prefix for negative integers whose first byte is < 0x80. Note that we do this before taking the length for the purposes of choosing between varint and full-form encoding. The representations are prefix-free, because the choice between varint and full-form encoding is determined by the first byte where varints are properly ordered between full-form negative and full-form positive, varint encoding is prefix-free, and full-form representations of different length always have length bytes that differ. Examples: -1 as 7F 0 as 80 1 as 81 127 as C07F 255 as C0FF 2^32-1 as F8FFFFFFFF 2^32 as F900000000 2^56-1 as FEFFFFFFFFFFFFFF 2^56 as FF000100000000000000 See asComparableBytesLegacy(org.apache.cassandra.db.marshal.ValueAccessor<V>, V, int, int, int) for description of the legacy format.
      Overrides:
      asComparableBytes in class AbstractType<BigInteger>

    • fromComparableBytes

      public <V> V fromComparableBytes(ValueAccessor<V> accessor, ByteSource.Peekable comparableBytes, ByteComparable.Version version)
      Description copied from class: AbstractType
      Translates the given byte-ordered representation to the common, non-byte-ordered binary representation of a payload for this abstract type (the latter, common binary representation is what we mostly work with in the storage engine internals). If the given bytes don't correspond to the encoding of some payload value for this abstract type, an IllegalArgumentException may be thrown.
      Overrides:
      fromComparableBytes in class AbstractType<BigInteger>
      Parameters:
      accessor - value accessor used to construct the value.
      comparableBytes - A byte-ordered representation (presumably of a payload for this abstract type).
      version - The byte-comparable version used to construct the representation.
      Returns:
      A of a payload for this abstract type, corresponding to the given byte-ordered representation, constructed using the supplied value accessor.
      See Also:

    • fromString

      public ByteBuffer fromString(String source) throws MarshalException
      Description copied from class: AbstractType
      get a byte representation of the given string.
      Specified by:
      fromString in class AbstractType<BigInteger>
      Throws:
      MarshalException

    • fromJSONObject

      public Term fromJSONObject(Object parsed) throws MarshalException
      Description copied from class: AbstractType
      Given a parsed JSON string, return a byte representation of the object.
      Specified by:
      fromJSONObject in class AbstractType<BigInteger>
      Parameters:
      parsed - the result of parsing a json string
      Throws:
      MarshalException

    • toJSONString

      public String toJSONString(ByteBuffer buffer, ProtocolVersion protocolVersion)
      Description copied from class: AbstractType
      Converts the specified value into its JSON representation.

      The buffer position will stay the same.

      Overrides:
      toJSONString in class AbstractType<BigInteger>
      Parameters:
      buffer - the value to convert
      protocolVersion - the protocol version to use for the conversion
      Returns:
      a JSON string representing the specified value

    • isValueCompatibleWithInternal

      public boolean isValueCompatibleWithInternal(AbstractType<?> otherType)
      Description copied from class: AbstractType
      Needed to handle ReversedType in value-compatibility checks. Subclasses should implement this instead of isValueCompatibleWith().
      Overrides:
      isValueCompatibleWithInternal in class AbstractType<BigInteger>

    • asCQL3Type

      public CQL3Type asCQL3Type()
      Overrides:
      asCQL3Type in class AbstractType<BigInteger>

    • getSerializer

      public TypeSerializer<BigInteger> getSerializer()
      Specified by:
      getSerializer in class AbstractType<BigInteger>

    • getArgumentDeserializer

      public ArgumentDeserializer getArgumentDeserializer()
      Overrides:
      getArgumentDeserializer in class AbstractType<BigInteger>
      Returns:
      the deserializer used to deserialize the function arguments of this type.

    • add

      public ByteBuffer add(Number left, Number right)
      Description copied from class: NumberType
      Adds the left argument to the right one.
      Specified by:
      add in class NumberType<BigInteger>
      Parameters:
      left - the left argument
      right - the right argument
      Returns:
      the addition result

    • substract

      public ByteBuffer substract(Number left, Number right)
      Description copied from class: NumberType
      Substracts the left argument from the right one.
      Specified by:
      substract in class NumberType<BigInteger>
      Parameters:
      left - the left argument
      right - the right argument
      Returns:
      the substraction result

    • multiply

      public ByteBuffer multiply(Number left, Number right)
      Description copied from class: NumberType
      Multiplies the left argument with the right one.
      Specified by:
      multiply in class NumberType<BigInteger>
      Parameters:
      left - the left argument
      right - the right argument
      Returns:
      the multiplication result

    • divide

      public ByteBuffer divide(Number left, Number right)
      Description copied from class: NumberType
      Divides the left argument by the right one.
      Specified by:
      divide in class NumberType<BigInteger>
      Parameters:
      left - the left argument
      right - the right argument
      Returns:
      the division result

    • mod

      public ByteBuffer mod(Number left, Number right)
      Description copied from class: NumberType
      Return the remainder.
      Specified by:
      mod in class NumberType<BigInteger>
      Parameters:
      left - the left argument
      right - the right argument
      Returns:
      the remainder

    • negate

      public ByteBuffer negate(Number input)
      Description copied from class: NumberType
      Negates the argument.
      Specified by:
      negate in class NumberType<BigInteger>
      Parameters:
      input - the argument to negate
      Returns:
      the negated argument

    • abs

      public ByteBuffer abs(Number input)
      Description copied from class: NumberType
      Takes the absolute value of the argument.
      Specified by:
      abs in class NumberType<BigInteger>
      Parameters:
      input - the argument to take the absolute value of
      Returns:
      a ByteBuffer containing the absolute value of the argument. The type of the contents of the ByteBuffer will match that of the input.

    • exp

      public ByteBuffer exp(Number input)
      Description copied from class: NumberType
      Raises e to the power of the argument.
      Specified by:
      exp in class NumberType<BigInteger>
      Parameters:
      input - the argument to raise e to
      Returns:
      a ByteBuffer containg the value of e (the base of natural logarithms) raised to the power of the argument. The type of the contents of the ByteBuffer will be a double, unless the input is a DecimalType or IntegerType, in which the ByteBuffer will contain a DecimalType.

    • log

      public ByteBuffer log(Number input)
      Description copied from class: NumberType
      Takes the natural logrithm of the argument.
      Specified by:
      log in class NumberType<BigInteger>
      Parameters:
      input - the argument to take the natural log (ln) of
      Returns:
      a ByteBuffer containg the log base e (ln) of the argument. The type of the contents of the ByteBuffer will be a double, unless the input is a DecimalType or IntegerType, in which the ByteBuffer will contain a DecimalType.

    • log10

      public ByteBuffer log10(Number input)
      Description copied from class: NumberType
      Takes the log base 10 of the arguement.
      Specified by:
      log10 in class NumberType<BigInteger>
      Parameters:
      input - the argument to take the log base ten of
      Returns:
      a ByteBuffer containg the log base 10 of the argument. The type of the contents of the ByteBuffer will be a double, unless the input is a DecimalType or IntegerType, in which the ByteBuffer will contain a DecimalType.

    • round

      public ByteBuffer round(Number input)
      Description copied from class: NumberType
      Rounds the argument to the nearest whole number.
      Specified by:
      round in class NumberType<BigInteger>
      Parameters:
      input - the argument to round
      Returns:
      a ByteBuffer containg the rounded argument. If the input is an integral type, the ByteBuffer will contain a copy of the input. If the input is a float, the ByteBuffer will contain an int32. If the input is a double, the output will contain a long. If the input is a DecimalType, the output will contain an IntegerType.

    • getMaskedValue

      public ByteBuffer getMaskedValue()
      Overrides:
      getMaskedValue in class AbstractType<BigInteger>
      Returns:
      A fixed, serialized value to be used when the column is masked, to be returned instead of the real value.