Java ByteBufferUtil.UNSET_BYTE_BUFFER属性代码示例

public long getTimestamp(long now, QueryOptions options) throws InvalidRequestException
{
    if (timestamp == null)
        return now;

    ByteBuffer tval = timestamp.bindAndGet(options);
    if (tval == null)
        throw new InvalidRequestException("Invalid null value of timestamp");

    if (tval == ByteBufferUtil.UNSET_BYTE_BUFFER)
        return now;

    try
    {
        LongType.instance.validate(tval);
    }
    catch (MarshalException e)
    {
        throw new InvalidRequestException("Invalid timestamp value: " + tval);
    }

    return LongType.instance.compose(tval);
}
 

private ByteBuffer[] bindInternal(QueryOptions options) throws InvalidRequestException
{
    if (elements.size() > type.size())
        throw new InvalidRequestException(String.format(
                "Tuple value contained too many fields (expected %s, got %s)", type.size(), elements.size()));

    ByteBuffer[] buffers = new ByteBuffer[elements.size()];
    for (int i = 0; i < elements.size(); i++)
    {
        buffers[i] = elements.get(i).bindAndGet(options);
        // Since A tuple value is always written in its entirety Cassandra can't preserve a pre-existing value by 'not setting' the new value. Reject the query.
        if (buffers[i] == ByteBufferUtil.UNSET_BYTE_BUFFER)
            throw new InvalidRequestException(String.format("Invalid unset value for tuple field number %d", i));
    }
    return buffers;
}
 

public Terminal bind(QueryOptions options) throws InvalidRequestException
{
    SortedSet<ByteBuffer> buffers = new TreeSet<>(comparator);
    for (Term t : elements)
    {
        ByteBuffer bytes = t.bindAndGet(options);

        if (bytes == null)
            throw new InvalidRequestException("null is not supported inside collections");
        if (bytes == ByteBufferUtil.UNSET_BYTE_BUFFER)
            return UNSET_VALUE;

        buffers.add(bytes);
    }
    return new Value(buffers);
}
 

static void doAdd(Term.Terminal value, ColumnDefinition column, UpdateParameters params) throws InvalidRequestException
{
    if (column.type.isMultiCell())
    {
        if (value == null)
            return;

        for (ByteBuffer bb : ((Value) value).elements)
        {
            if (bb == ByteBufferUtil.UNSET_BYTE_BUFFER)
                continue;

            params.addCell(column, CellPath.create(bb), ByteBufferUtil.EMPTY_BYTE_BUFFER);
        }
    }
    else
    {
        // for frozen sets, we're overwriting the whole cell
        if (value == null)
            params.addTombstone(column);
        else
            params.addCell(column, value.get(ProtocolVersion.CURRENT));
    }
}
 

public Terminal bind(QueryOptions options) throws InvalidRequestException
{
    List<ByteBuffer> buffers = new ArrayList<ByteBuffer>(elements.size());
    for (Term t : elements)
    {
        ByteBuffer bytes = t.bindAndGet(options);

        if (bytes == null)
            throw new InvalidRequestException("null is not supported inside collections");
        if (bytes == ByteBufferUtil.UNSET_BYTE_BUFFER)
            return UNSET_VALUE;

        buffers.add(bytes);
    }
    return new Value(buffers);
}
 

public MultiCBuilder addElementToAll(ByteBuffer value)
{
    checkUpdateable();

    if (elementsList.isEmpty())
        elementsList.add(new ArrayList<ByteBuffer>());

    if (value == null)
        containsNull = true;
    else if (value == ByteBufferUtil.UNSET_BYTE_BUFFER)
        containsUnset = true;

    for (int i = 0, m = elementsList.size(); i < m; i++)
        elementsList.get(i).add(value);

    size++;
    return this;
}
 

public Terminal bind(QueryOptions options) throws InvalidRequestException
{
    Map<ByteBuffer, ByteBuffer> buffers = new TreeMap<ByteBuffer, ByteBuffer>(comparator);
    for (Map.Entry<Term, Term> entry : elements.entrySet())
    {
        // We don't support values > 64K because the serialization format encode the length as an unsigned short.
        ByteBuffer keyBytes = entry.getKey().bindAndGet(options);

        if (keyBytes == null)
            throw new InvalidRequestException("null is not supported inside collections");
        if (keyBytes == ByteBufferUtil.UNSET_BYTE_BUFFER)
            throw new InvalidRequestException("unset value is not supported for map keys");

        ByteBuffer valueBytes = entry.getValue().bindAndGet(options);
        if (valueBytes == null)
            throw new InvalidRequestException("null is not supported inside collections");
        if (valueBytes == ByteBufferUtil.UNSET_BYTE_BUFFER)
            return UNSET_VALUE;

        buffers.put(keyBytes, valueBytes);
    }
    return new Value(buffers);
}
 

public static ByteBuffer readBoundValue(ByteBuf cb, ProtocolVersion protocolVersion)
{
    int length = cb.readInt();
    if (length < 0)
    {
        if (protocolVersion.isSmallerThan(ProtocolVersion.V4)) // backward compatibility for pre-version 4
            return null;
        if (length == -1)
            return null;
        else if (length == -2)
            return ByteBufferUtil.UNSET_BYTE_BUFFER;
        else
            throw new ProtocolException("Invalid ByteBuf length " + length);
    }
    ByteBuf slice = cb.readSlice(length);

    return ByteBuffer.wrap(readRawBytes(slice));
}
 

public int getTimeToLive(QueryOptions options, int defaultTimeToLive) throws InvalidRequestException
{
    if (timeToLive == null)
        return defaultTimeToLive;

    ByteBuffer tval = timeToLive.bindAndGet(options);
    if (tval == null)
        return 0;

    if (tval == ByteBufferUtil.UNSET_BYTE_BUFFER)
        return defaultTimeToLive;

    try
    {
        Int32Type.instance.validate(tval);
    }
    catch (MarshalException e)
    {
        throw new InvalidRequestException("Invalid timestamp value: " + tval);
    }

    int ttl = Int32Type.instance.compose(tval);
    if (ttl < 0)
        throw new InvalidRequestException("A TTL must be greater or equal to 0, but was " + ttl);

    if (ttl > MAX_TTL)
        throw new InvalidRequestException(String.format("ttl is too large. requested (%d) maximum (%d)", ttl, MAX_TTL));

    if (defaultTimeToLive != LivenessInfo.NO_TTL && ttl == LivenessInfo.NO_TTL)
        return LivenessInfo.NO_TTL;

    return ttl;
}
 

public Value bind(QueryOptions options) throws InvalidRequestException
{
    ByteBuffer value = options.getValues().get(bindIndex);
    if (value == ByteBufferUtil.UNSET_BYTE_BUFFER)
        throw new InvalidRequestException(String.format("Invalid unset value for tuple %s", receiver.name));
    return value == null ? null : Value.fromSerialized(value, (TupleType)receiver.type);
}
 

public MultiCBuilder addEachElementToAll(List<ByteBuffer> values)
{
    checkUpdateable();

    if (elementsList.isEmpty())
        elementsList.add(new ArrayList<ByteBuffer>());

    if (values.isEmpty())
    {
        hasMissingElements = true;
    }
    else
    {
        for (int i = 0, m = elementsList.size(); i < m; i++)
        {
            List<ByteBuffer> oldComposite = elementsList.remove(0);

            for (int j = 0, n = values.size(); j < n; j++)
            {
                List<ByteBuffer> newComposite = new ArrayList<>(oldComposite);
                elementsList.add(newComposite);

                ByteBuffer value = values.get(j);

                if (value == null)
                    containsNull = true;
                if (value == ByteBufferUtil.UNSET_BYTE_BUFFER)
                    containsUnset = true;

                newComposite.add(values.get(j));
            }
        }
    }
    size++;
    return this;
}
 

public Terminal bind(QueryOptions options) throws InvalidRequestException
{
    ByteBuffer value = options.getValues().get(bindIndex);
    if (value == null)
        return null;
    if (value == ByteBufferUtil.UNSET_BYTE_BUFFER)
        return UNSET_VALUE;
    return Value.fromSerialized(value, (UserType) receiver.type);
}
 

@Override
public ByteBuffer bindAndGet(QueryOptions options) throws InvalidRequestException
{
    try
    {
        ByteBuffer value = options.getValues().get(bindIndex);
        if (value != null && value != ByteBufferUtil.UNSET_BYTE_BUFFER)
            receiver.type.validate(value);
        return value;
    }
    catch (MarshalException e)
    {
        throw new InvalidRequestException(e.getMessage());
    }
}
 

public Value bind(QueryOptions options) throws InvalidRequestException
{
    ByteBuffer bytes = bindAndGet(options);
    if (bytes == null)
        return null;
    if (bytes == ByteBufferUtil.UNSET_BYTE_BUFFER)
        return Constants.UNSET_VALUE;
    return new Constants.Value(bytes);
}
 

public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException
{
    ByteBuffer bytes = t.bindAndGet(params.options);
    if (bytes == null)
        throw new InvalidRequestException("Invalid null value for counter increment");
    if (bytes == ByteBufferUtil.UNSET_BYTE_BUFFER)
        return;

    long increment = ByteBufferUtil.toLong(bytes);
    params.addCounter(column, increment);
}