public IndexInfo deserialize(DataInput in) throws IOException { return new IndexInfo(type.serializer().deserialize(in), type.serializer().deserialize(in), in.readLong(), in.readLong()); }
public long serializedSizeForSSTable(RangeTombstone t) { TypeSizes typeSizes = TypeSizes.NATIVE; return type.serializer().serializedSize(t.min, typeSizes) + 1 // serialization flag + type.serializer().serializedSize(t.max, typeSizes) + DeletionTime.serializer.serializedSize(t.data, typeSizes); } }
public static void validateComposite(Composite name, CType type) throws InvalidRequestException { long serializedSize = type.serializer().serializedSize(name, TypeSizes.NATIVE); if (serializedSize > Cell.MAX_NAME_LENGTH) throw new InvalidRequestException(String.format("The sum of all clustering columns is too long (%s > %s)", serializedSize, Cell.MAX_NAME_LENGTH)); }
public RangeTombstone deserializeFromSSTable(DataInput in, Descriptor.Version version) throws IOException { Composite min = type.serializer().deserialize(in); int b = in.readUnsignedByte(); assert (b & ColumnSerializer.RANGE_TOMBSTONE_MASK) != 0; return deserializeBody(in, min, version); }
public void serialize(ColumnSlice cs, DataOutputPlus out, int version) throws IOException { ISerializer<Composite> serializer = type.serializer(); serializer.serialize(cs.start, out); serializer.serialize(cs.finish, out); }
public long serializedSize(ColumnSlice cs, int version) { ISerializer<Composite> serializer = type.serializer(); return serializer.serializedSize(cs.start, TypeSizes.NATIVE) + serializer.serializedSize(cs.finish, TypeSizes.NATIVE); } }
public void skipBody(DataInput in, Descriptor.Version version) throws IOException { type.serializer().skip(in); DeletionTime.serializer.skip(in); }
public void serializeForSSTable(RangeTombstone t, DataOutputPlus out) throws IOException { type.serializer().serialize(t.min, out); out.writeByte(ColumnSerializer.RANGE_TOMBSTONE_MASK); type.serializer().serialize(t.max, out); DeletionTime.serializer.serialize(t.data, out); }
public void serialize(IndexInfo info, DataOutputPlus out) throws IOException { type.serializer().serialize(info.firstName, out); type.serializer().serialize(info.lastName, out); out.writeLong(info.offset); out.writeLong(info.width); }
public long serializedSize(IndexInfo info, TypeSizes typeSizes) { return type.serializer().serializedSize(info.firstName, typeSizes) + type.serializer().serializedSize(info.lastName, typeSizes) + typeSizes.sizeof(info.offset) + typeSizes.sizeof(info.width); } }
public RangeTombstoneList deserialize(DataInput in, int version) throws IOException { int size = in.readInt(); if (size == 0) return null; RangeTombstoneList tombstones = new RangeTombstoneList(type, size); for (int i = 0; i < size; i++) { Composite start = type.serializer().deserialize(in); Composite end = type.serializer().deserialize(in); int delTime = in.readInt(); long markedAt = in.readLong(); if (version >= MessagingService.VERSION_20) { tombstones.setInternal(i, start, end, markedAt, delTime); } else { /* * The old implementation used to have range sorted by left value, but with potentially * overlapping range. So we need to use the "slow" path. */ tombstones.add(start, end, markedAt, delTime); } } // The "slow" path take care of updating the size, but not the fast one if (version >= MessagingService.VERSION_20) tombstones.size = size; return tombstones; }
public ColumnSlice deserialize(DataInput in, int version) throws IOException { ISerializer<Composite> serializer = type.serializer(); Composite start = serializer.deserialize(in); Composite finish = serializer.deserialize(in); return new ColumnSlice(start, finish); }
public RangeTombstone deserializeBody(DataInput in, Composite min, Descriptor.Version version) throws IOException { Composite max = type.serializer().deserialize(in); DeletionTime dt = DeletionTime.serializer.deserialize(in); // If the max equals the min.end(), we can avoid keeping an extra ByteBuffer in memory by using // min.end() instead of max Composite minEnd = min.end(); max = minEnd.equals(max) ? minEnd : max; return new RangeTombstone(min, max, dt); }
public long serializedSize(RangeTombstoneList tombstones, TypeSizes typeSizes, int version) { if (tombstones == null) return typeSizes.sizeof(0); long size = typeSizes.sizeof(tombstones.size); for (int i = 0; i < tombstones.size; i++) { size += type.serializer().serializedSize(tombstones.starts[i], typeSizes); size += type.serializer().serializedSize(tombstones.ends[i], typeSizes); size += typeSizes.sizeof(tombstones.delTimes[i]); size += typeSizes.sizeof(tombstones.markedAts[i]); } return size; }
public void serialize(RangeTombstoneList tombstones, DataOutputPlus out, int version) throws IOException { if (tombstones == null) { out.writeInt(0); return; } out.writeInt(tombstones.size); for (int i = 0; i < tombstones.size; i++) { type.serializer().serialize(tombstones.starts[i], out); type.serializer().serialize(tombstones.ends[i], out); out.writeInt(tombstones.delTimes[i]); out.writeLong(tombstones.markedAts[i]); } }