Java tutorial
/** * 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 com.facebook.infrastructure.db; import com.facebook.infrastructure.utils.FBUtilities; import org.apache.log4j.Logger; import org.apache.commons.lang.ArrayUtils; import org.apache.commons.lang.StringUtils; import org.apache.commons.collections.CollectionUtils; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.io.Serializable; import java.util.Collection; import java.util.Set; import java.util.concurrent.atomic.AtomicInteger; /** * Author : Avinash Lakshman ( alakshman@facebook.com) & Prashant Malik ( pmalik@facebook.com ) */ public final class SuperColumn implements IColumn, Serializable { private static Logger logger_ = Logger.getLogger(SuperColumn.class); private static ICompactSerializer2<IColumn> serializer_; private final static String seperator_ = ":"; static { serializer_ = new SuperColumnSerializer(); } static ICompactSerializer2<IColumn> serializer() { return serializer_; } private String name_; private EfficientBidiMap columns_ = new EfficientBidiMap( ColumnComparatorFactory.getComparator(ColumnComparatorFactory.ComparatorType.TIMESTAMP)); private long markedForDeleteAt = Long.MIN_VALUE; private AtomicInteger size_ = new AtomicInteger(0); SuperColumn() { } SuperColumn(String name) { name_ = name; } public boolean isMarkedForDelete() { return markedForDeleteAt > Long.MIN_VALUE; } public String name() { return name_; } public String name(String key) { IColumn column = columns_.get(key); if (column instanceof SuperColumn) throw new UnsupportedOperationException("A super column cannot hold other super columns."); if (column != null) return column.name(); return null; } public Collection<IColumn> getSubColumns() { return columns_.getSortedColumns(); } public IColumn getSubColumn(String name) { return columns_.get(name); } public int compareTo(IColumn superColumn) { return (name_.compareTo(superColumn.name())); } public int size() { /* * return the size of the individual columns * that make up the super column. This is an * APPROXIMATION of the size used only from the * Memtable. */ return size_.get(); } /** * This returns the size of the super-column when serialized. * @see com.facebook.infrastructure.db.IColumn#serializedSize() */ public int serializedSize() { /* * Size of a super-column is = * size of a name (UtfPrefix + length of the string) * + 1 byte to indicate if the super-column has been deleted * + 4 bytes for size of the sub-columns * + 4 bytes for the number of sub-columns * + size of all the sub-columns. */ /* * We store the string as UTF-8 encoded, so when we calculate the length, it * should be converted to UTF-8. */ /* * We need to keep the way we are calculating the column size in sync with the * way we are calculating the size for the column family serializer. */ return IColumn.UtfPrefix_ + FBUtilities.getUTF8Length(name_) + DBConstants.boolSize_ + DBConstants.intSize_ + DBConstants.intSize_ + getSizeOfAllColumns(); } /** * This calculates the exact size of the sub columns on the fly */ int getSizeOfAllColumns() { int size = 0; Collection<IColumn> subColumns = getSubColumns(); for (IColumn subColumn : subColumns) { size += subColumn.serializedSize(); } return size; } public void remove(String columnName) { columns_.remove(columnName); } public long timestamp() { throw new UnsupportedOperationException("This operation is not supported for Super Columns."); } public long timestamp(String key) { IColumn column = columns_.get(key); if (column instanceof SuperColumn) throw new UnsupportedOperationException("A super column cannot hold other super columns."); if (column != null) return column.timestamp(); throw new IllegalArgumentException("Timestamp was requested for a column that does not exist."); } public byte[] value() { throw new UnsupportedOperationException("This operation is not supported for Super Columns."); } public byte[] value(String key) { IColumn column = columns_.get(key); if (column instanceof SuperColumn) throw new UnsupportedOperationException("A super column cannot hold other super columns."); if (column != null) return column.value(); throw new IllegalArgumentException("Value was requested for a column that does not exist."); } public void addColumn(String name, IColumn column) { if (column instanceof SuperColumn) throw new UnsupportedOperationException("A super column cannot hold other super columns."); IColumn oldColumn = columns_.get(name); if (oldColumn == null) { columns_.put(name, column); size_.addAndGet(column.size()); } else { if (oldColumn.timestamp() <= column.timestamp()) { columns_.put(name, column); int delta = (-1) * oldColumn.size(); /* subtract the size of the oldColumn */ size_.addAndGet(delta); /* add the size of the new column */ size_.addAndGet(column.size()); } } } /* * Go through each sub column if it exists then as it to resolve itself * if the column does not exist then create it. */ public boolean integrate(IColumn column) { if (!(column instanceof SuperColumn)) throw new UnsupportedOperationException("Only Super column objects should be put here"); if (!name_.equals(column.name())) throw new IllegalArgumentException( "The name should match the name of the current column or super column"); Collection<IColumn> columns = column.getSubColumns(); for (IColumn subColumn : columns) { addColumn(subColumn.name(), subColumn); } markedForDeleteAt = Math.max(markedForDeleteAt, column.getMarkedForDeleteAt()); return false; } public int getObjectCount() { return 1 + columns_.size(); } public void delete() { throw new UnsupportedOperationException( "Cannot delete supercolumn directly; only simple columns may be deleted"); } public long getMarkedForDeleteAt() { return markedForDeleteAt; } int getColumnCount() { return columns_.size(); } public IColumn diff(IColumn column) { IColumn columnDiff = new SuperColumn(column.name()); Collection<IColumn> columns = column.getSubColumns(); for (IColumn subColumn : columns) { IColumn columnInternal = columns_.get(subColumn.name()); if (columnInternal == null) { columnDiff.addColumn(subColumn.name(), subColumn); } else { IColumn subColumnDiff = columnInternal.diff(subColumn); if (subColumnDiff != null) { columnDiff.addColumn(subColumn.name(), subColumnDiff); } } } if (columnDiff.getSubColumns().size() != 0) return columnDiff; else return null; } public byte[] digest() { Set<IColumn> columns = columns_.getSortedColumns(); byte[] xorHash = ArrayUtils.EMPTY_BYTE_ARRAY; if (name_ == null) return xorHash; xorHash = name_.getBytes(); for (IColumn column : columns) { xorHash = FBUtilities.xor(xorHash, column.digest()); } return xorHash; } public String toString() { StringBuilder sb = new StringBuilder(); sb.append("SuperColumn("); sb.append(name_); if (isMarkedForDelete()) { sb.append("-delete at " + getMarkedForDeleteAt() + "-"); } sb.append(" ["); sb.append(StringUtils.join(getSubColumns(), ", ")); sb.append("])"); return sb.toString(); } public void markForDeleteAt(long timestamp) { this.markedForDeleteAt = timestamp; } } class SuperColumnSerializer implements ICompactSerializer2<IColumn> { public void serialize(IColumn column, DataOutputStream dos) throws IOException { SuperColumn superColumn = (SuperColumn) column; dos.writeUTF(superColumn.name()); dos.writeLong(superColumn.getMarkedForDeleteAt()); Collection<IColumn> columns = column.getSubColumns(); int size = columns.size(); dos.writeInt(size); /* * Add the total size of the columns. This is useful * to skip over all the columns in this super column * if we are not interested in this super column. */ dos.writeInt(superColumn.getSizeOfAllColumns()); // dos.writeInt(superColumn.size()); for (IColumn subColumn : columns) { Column.serializer().serialize(subColumn, dos); } } /* * Use this method to create a bare bones Super Column. This super column * does not have any of the Column information. */ private SuperColumn defreezeSuperColumn(DataInputStream dis) throws IOException { String name = dis.readUTF(); SuperColumn superColumn = new SuperColumn(name); superColumn.markForDeleteAt(dis.readLong()); return superColumn; } public IColumn deserialize(DataInputStream dis) throws IOException { SuperColumn superColumn = defreezeSuperColumn(dis); if (!superColumn.isMarkedForDelete()) fillSuperColumn(superColumn, dis); return superColumn; } public void skip(DataInputStream dis) throws IOException { defreezeSuperColumn(dis); /* read the number of columns stored */ dis.readInt(); /* read the size of all columns to skip */ int size = dis.readInt(); dis.skip(size); } private void fillSuperColumn(IColumn superColumn, DataInputStream dis) throws IOException { if (dis.available() == 0) return; /* read the number of columns */ int size = dis.readInt(); /* read the size of all columns */ dis.readInt(); for (int i = 0; i < size; ++i) { IColumn subColumn = Column.serializer().deserialize(dis); superColumn.addColumn(subColumn.name(), subColumn); } } public IColumn deserialize(DataInputStream dis, IFilter filter) throws IOException { if (dis.available() == 0) return null; IColumn superColumn = defreezeSuperColumn(dis); superColumn = filter.filter(superColumn, dis); if (superColumn != null) { if (!superColumn.isMarkedForDelete()) fillSuperColumn(superColumn, dis); return superColumn; } else { /* read the number of columns stored */ dis.readInt(); /* read the size of all columns to skip */ int size = dis.readInt(); dis.skip(size); return null; } } /* * Deserialize a particular column since the name is in the form of * superColumn:column. */ public IColumn deserialize(DataInputStream dis, String name, IFilter filter) throws IOException { if (dis.available() == 0) return null; String[] names = RowMutation.getColumnAndColumnFamily(name); if (names.length == 1) { IColumn superColumn = defreezeSuperColumn(dis); if (name.equals(superColumn.name())) { if (!superColumn.isMarkedForDelete()) { /* read the number of columns stored */ int size = dis.readInt(); /* read the size of all columns */ dis.readInt(); IColumn column = null; for (int i = 0; i < size; ++i) { column = Column.serializer().deserialize(dis, filter); if (column != null) { superColumn.addColumn(column.name(), column); column = null; if (filter.isDone()) { break; } } } } return superColumn; } else { /* read the number of columns stored */ dis.readInt(); /* read the size of all columns to skip */ int size = dis.readInt(); dis.skip(size); return null; } } SuperColumn superColumn = defreezeSuperColumn(dis); if (!superColumn.isMarkedForDelete()) { int size = dis.readInt(); /* skip the size of the columns */ dis.readInt(); if (size > 0) { for (int i = 0; i < size; ++i) { IColumn subColumn = Column.serializer().deserialize(dis, names[1], filter); if (subColumn != null) { superColumn.addColumn(subColumn.name(), subColumn); break; } } } } return superColumn; } }