public PagedRangeCommand deserialize(DataInput in, int version) throws IOException { String keyspace = in.readUTF(); String columnFamily = in.readUTF(); long timestamp = in.readLong(); AbstractBounds<RowPosition> keyRange = AbstractBounds.serializer.deserialize(in, version).toRowBounds(); CFMetaData metadata = Schema.instance.getCFMetaData(keyspace, columnFamily); if (metadata == null) { String message = String.format("Got paged range command for nonexistent table %s.%s. If the table was just " + "created, this is likely due to the schema not being fully propagated. Please wait for schema " + "agreement on table creation." , keyspace, columnFamily); throw new UnknownColumnFamilyException(message, null); } SliceQueryFilter predicate = metadata.comparator.sliceQueryFilterSerializer().deserialize(in, version); Composite start = metadata.comparator.serializer().deserialize(in); Composite stop = metadata.comparator.serializer().deserialize(in); int filterCount = in.readInt(); List<IndexExpression> rowFilter = new ArrayList<IndexExpression>(filterCount); for (int i = 0; i < filterCount; i++) { rowFilter.add(IndexExpression.readFrom(in)); } int limit = in.readInt(); boolean countCQL3Rows = version >= MessagingService.VERSION_21 ? in.readBoolean() : predicate.compositesToGroup >= 0 || predicate.count != 1; // See #6857 return new PagedRangeCommand(keyspace, columnFamily, timestamp, keyRange, predicate, start, stop, rowFilter, limit, countCQL3Rows); }
public void serialize(PrepareMessage message, DataOutputPlus out, int version) throws IOException { out.writeInt(message.cfIds.size()); for (UUID cfId : message.cfIds) UUIDSerializer.serializer.serialize(cfId, out, version); UUIDSerializer.serializer.serialize(message.parentRepairSession, out, version); out.writeInt(message.ranges.size()); for (Range r : message.ranges) Range.serializer.serialize(r, out, version); }
public long serializedSize(PrepareMessage message, int version) { long size; TypeSizes sizes = TypeSizes.NATIVE; size = sizes.sizeof(message.cfIds.size()); for (UUID cfId : message.cfIds) size += UUIDSerializer.serializer.serializedSize(cfId, version); size += UUIDSerializer.serializer.serializedSize(message.parentRepairSession, version); size += sizes.sizeof(message.ranges.size()); for (Range r : message.ranges) size += Range.serializer.serializedSize(r, version); return size; } }
size += AbstractBounds.serializer.serializedSize(rsc.keyRange, version); size += TypeSizes.NATIVE.sizeof(rsc.maxResults); size += TypeSizes.NATIVE.sizeof(rsc.countCQL3Rows);
public RangeSliceCommand deserialize(DataInput in, int version) throws IOException { String keyspace = in.readUTF(); String columnFamily = in.readUTF(); long timestamp = in.readLong(); CFMetaData metadata = Schema.instance.getCFMetaData(keyspace, columnFamily); if (metadata == null) { String message = String.format("Got range slice command for nonexistent table %s.%s. If the table was just " + "created, this is likely due to the schema not being fully propagated. Please wait for schema " + "agreement on table creation." , keyspace, columnFamily); throw new UnknownColumnFamilyException(message, null); } IDiskAtomFilter predicate = metadata.comparator.diskAtomFilterSerializer().deserialize(in, version); List<IndexExpression> rowFilter; int filterCount = in.readInt(); rowFilter = new ArrayList<>(filterCount); for (int i = 0; i < filterCount; i++) { rowFilter.add(IndexExpression.readFrom(in)); } AbstractBounds<RowPosition> range = AbstractBounds.serializer.deserialize(in, version).toRowBounds(); int maxResults = in.readInt(); boolean countCQL3Rows = in.readBoolean(); boolean isPaging = in.readBoolean(); return new RangeSliceCommand(keyspace, columnFamily, timestamp, predicate, range, rowFilter, maxResults, countCQL3Rows, isPaging); }
public void serialize(RangeSliceCommand sliceCommand, DataOutputPlus out, int version) throws IOException { out.writeUTF(sliceCommand.keyspace); out.writeUTF(sliceCommand.columnFamily); out.writeLong(sliceCommand.timestamp); CFMetaData metadata = Schema.instance.getCFMetaData(sliceCommand.keyspace, sliceCommand.columnFamily); metadata.comparator.diskAtomFilterSerializer().serialize(sliceCommand.predicate, out, version); if (sliceCommand.rowFilter == null) { out.writeInt(0); } else { out.writeInt(sliceCommand.rowFilter.size()); for (IndexExpression expr : sliceCommand.rowFilter) { expr.writeTo(out); } } AbstractBounds.serializer.serialize(sliceCommand.keyRange, out, version); out.writeInt(sliceCommand.maxResults); out.writeBoolean(sliceCommand.countCQL3Rows); out.writeBoolean(sliceCommand.isPaging); }
public long serializedSize(PagedRangeCommand cmd, int version) { long size = 0; size += TypeSizes.NATIVE.sizeof(cmd.keyspace); size += TypeSizes.NATIVE.sizeof(cmd.columnFamily); size += TypeSizes.NATIVE.sizeof(cmd.timestamp); size += AbstractBounds.serializer.serializedSize(cmd.keyRange, version); CFMetaData metadata = Schema.instance.getCFMetaData(cmd.keyspace, cmd.columnFamily); size += metadata.comparator.sliceQueryFilterSerializer().serializedSize((SliceQueryFilter)cmd.predicate, version); size += metadata.comparator.serializer().serializedSize(cmd.start, TypeSizes.NATIVE); size += metadata.comparator.serializer().serializedSize(cmd.stop, TypeSizes.NATIVE); size += TypeSizes.NATIVE.sizeof(cmd.rowFilter.size()); for (IndexExpression expr : cmd.rowFilter) { size += TypeSizes.NATIVE.sizeofWithShortLength(expr.column); size += TypeSizes.NATIVE.sizeof(expr.operator.ordinal()); size += TypeSizes.NATIVE.sizeofWithShortLength(expr.value); } size += TypeSizes.NATIVE.sizeof(cmd.limit); if (version >= MessagingService.VERSION_21) size += TypeSizes.NATIVE.sizeof(cmd.countCQL3Rows); return size; } }
public void serialize(PagedRangeCommand cmd, DataOutputPlus out, int version) throws IOException { out.writeUTF(cmd.keyspace); out.writeUTF(cmd.columnFamily); out.writeLong(cmd.timestamp); AbstractBounds.serializer.serialize(cmd.keyRange, out, version); CFMetaData metadata = Schema.instance.getCFMetaData(cmd.keyspace, cmd.columnFamily); // SliceQueryFilter (the count is not used) SliceQueryFilter filter = (SliceQueryFilter)cmd.predicate; metadata.comparator.sliceQueryFilterSerializer().serialize(filter, out, version); // The start and stop of the page metadata.comparator.serializer().serialize(cmd.start, out); metadata.comparator.serializer().serialize(cmd.stop, out); out.writeInt(cmd.rowFilter.size()); for (IndexExpression expr : cmd.rowFilter) { expr.writeTo(out);; } out.writeInt(cmd.limit); if (version >= MessagingService.VERSION_21) out.writeBoolean(cmd.countCQL3Rows); }
public void serialize(AbstractBounds<?> range, DataOutputPlus out, int version) throws IOException { /* * The first int tells us if it's a range or bounds (depending on the value) _and_ if it's tokens or keys (depending on the * sign). We use negative kind for keys so as to preserve the serialization of token from older version. */ out.writeInt(kindInt(range)); if (range.left instanceof Token) { Token.serializer.serialize((Token) range.left, out); Token.serializer.serialize((Token) range.right, out); } else { RowPosition.serializer.serialize((RowPosition) range.left, out); RowPosition.serializer.serialize((RowPosition) range.right, out); } }
public long serializedSize(RepairJobDesc desc, int version) { int size = 0; if (version >= MessagingService.VERSION_21) { size += TypeSizes.NATIVE.sizeof(desc.parentSessionId != null); if (desc.parentSessionId != null) size += UUIDSerializer.serializer.serializedSize(desc.parentSessionId, version); } size += UUIDSerializer.serializer.serializedSize(desc.sessionId, version); size += TypeSizes.NATIVE.sizeof(desc.keyspace); size += TypeSizes.NATIVE.sizeof(desc.columnFamily); size += AbstractBounds.serializer.serializedSize(desc.range, version); return size; } }
public long serializedSize(AbstractBounds<?> ab, int version) { int size = TypeSizes.NATIVE.sizeof(kindInt(ab)); if (ab.left instanceof Token) { size += Token.serializer.serializedSize((Token) ab.left, TypeSizes.NATIVE); size += Token.serializer.serializedSize((Token) ab.right, TypeSizes.NATIVE); } else { size += RowPosition.serializer.serializedSize((RowPosition) ab.left, TypeSizes.NATIVE); size += RowPosition.serializer.serializedSize((RowPosition) ab.right, TypeSizes.NATIVE); } return size; } }
public PrepareMessage deserialize(DataInput in, int version) throws IOException { int cfIdCount = in.readInt(); List<UUID> cfIds = new ArrayList<>(cfIdCount); for (int i = 0; i < cfIdCount; i++) cfIds.add(UUIDSerializer.serializer.deserialize(in, version)); UUID parentRepairSession = UUIDSerializer.serializer.deserialize(in, version); int rangeCount = in.readInt(); List<Range<Token>> ranges = new ArrayList<>(rangeCount); for (int i = 0; i < rangeCount; i++) ranges.add((Range<Token>) Range.serializer.deserialize(in, version).toTokenBounds()); return new PrepareMessage(parentRepairSession, cfIds, ranges); }
public RepairJobDesc deserialize(DataInput in, int version) throws IOException { UUID parentSessionId = null; if (version >= MessagingService.VERSION_21) { if (in.readBoolean()) parentSessionId = UUIDSerializer.serializer.deserialize(in, version); } UUID sessionId = UUIDSerializer.serializer.deserialize(in, version); String keyspace = in.readUTF(); String columnFamily = in.readUTF(); Range<Token> range = (Range<Token>)AbstractBounds.serializer.deserialize(in, version); return new RepairJobDesc(parentSessionId, sessionId, keyspace, columnFamily, range); }
public void serialize(AbstractBounds<T> range, DataOutputPlus out, int version) throws IOException { /* * The first int tells us if it's a range or bounds (depending on the value) _and_ if it's tokens or keys (depending on the * sign). We use negative kind for keys so as to preserve the serialization of token from older version. */ if (version < MessagingService.VERSION_30) out.writeInt(kindInt(range)); else out.writeByte(kindFlags(range)); serializer.serialize(range.left, out, version); serializer.serialize(range.right, out, version); }
public void serialize(AbstractBounds<T> range, DataOutputPlus out, int version) throws IOException { /* * The first int tells us if it's a range or bounds (depending on the value) _and_ if it's tokens or keys (depending on the * sign). We use negative kind for keys so as to preserve the serialization of token from older version. */ if (version < MessagingService.VERSION_30) out.writeInt(kindInt(range)); else out.writeByte(kindFlags(range)); serializer.serialize(range.left, out, version); serializer.serialize(range.right, out, version); }
public void serialize(AbstractBounds<T> range, DataOutputPlus out, int version) throws IOException { /* * The first int tells us if it's a range or bounds (depending on the value) _and_ if it's tokens or keys (depending on the * sign). We use negative kind for keys so as to preserve the serialization of token from older version. */ if (version < MessagingService.VERSION_30) out.writeInt(kindInt(range)); else out.writeByte(kindFlags(range)); serializer.serialize(range.left, out, version); serializer.serialize(range.right, out, version); }
public void serialize(AbstractBounds<T> range, DataOutputPlus out, int version) throws IOException { /* * The first int tells us if it's a range or bounds (depending on the value) _and_ if it's tokens or keys (depending on the * sign). We use negative kind for keys so as to preserve the serialization of token from older version. */ if (version < MessagingService.VERSION_30) out.writeInt(kindInt(range)); else out.writeByte(kindFlags(range)); serializer.serialize(range.left, out, version); serializer.serialize(range.right, out, version); }
public long serializedSize(AbstractBounds<T> ab, int version) { int size = version < MessagingService.VERSION_30 ? TypeSizes.sizeof(kindInt(ab)) : 1; size += serializer.serializedSize(ab.left, version); size += serializer.serializedSize(ab.right, version); return size; } }
public long serializedSize(AbstractBounds<T> ab, int version) { int size = version < MessagingService.VERSION_30 ? TypeSizes.sizeof(kindInt(ab)) : 1; size += serializer.serializedSize(ab.left, version); size += serializer.serializedSize(ab.right, version); return size; } }
public SyncRequest deserialize(DataInput in, int version) throws IOException { RepairJobDesc desc = RepairJobDesc.serializer.deserialize(in, version); InetAddress owner = CompactEndpointSerializationHelper.deserialize(in); InetAddress src = CompactEndpointSerializationHelper.deserialize(in); InetAddress dst = CompactEndpointSerializationHelper.deserialize(in); int rangesCount = in.readInt(); List<Range<Token>> ranges = new ArrayList<>(rangesCount); for (int i = 0; i < rangesCount; ++i) ranges.add((Range<Token>) AbstractBounds.serializer.deserialize(in, version).toTokenBounds()); return new SyncRequest(desc, owner, src, dst, ranges); }