Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package me.prettyprint.cassandra.service;
  
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
 
 
Implementation of a Keyspace

Author(s):
Ran Tavory (rantav@gmail.com)
 
 public class KeyspaceServiceImpl implements KeyspaceService {
   private static final Map<StringStringEMPTY_CREDENTIALS = Collections.emptyMap();
 
   @SuppressWarnings("unused")
   private static final Logger log = LoggerFactory.getLogger(KeyspaceServiceImpl.class);
 
   private final String keyspaceName;
 
   private final ConsistencyLevelPolicy consistency;
 
   private final ExceptionsTranslator xtrans;
 
   private final HConnectionManager connectionManager;
 
 
   private final FailoverPolicy failoverPolicy;
   
   private final Map<StringStringcredentials;
 
   public KeyspaceServiceImpl(String keyspaceName,
       ConsistencyLevelPolicy consistencyLevel,
       HConnectionManager connectionManager,
       FailoverPolicy failoverPolicy)
       throws HectorTransportException {
     this(keyspaceNameconsistencyLevelconnectionManagerfailoverPolicy);
   }
 
   public KeyspaceServiceImpl(String keyspaceName,
       ConsistencyLevelPolicy consistencyLevel,
       HConnectionManager connectionManager,
       FailoverPolicy failoverPolicy,
       Map<StringStringcredentials)
       throws HectorTransportException {
     this. = consistencyLevel;
     this. = keyspaceName;
     this. = connectionManager;
     this. = failoverPolicy;
     this. = Collections.unmodifiableMap(credentials);
      = new ExceptionsTranslatorImpl();
   }
 
 
   @Override
   public void batchMutate(final Map<ByteBuffer,Map<String,List<Mutation>>> mutationMap)
       throws HectorException {
 
       @Override
       public Void execute(Cassandra.Client cassandrathrows HectorException {
         try {
           cassandra.batch_mutate(mutationMapgetThriftCl(.));
         } catch (Exception e) {
           throw .translate(e);
         }
         return null;
       }
     };
  }
  public void batchMutate(BatchMutation batchMutatethrows HectorException {
    batchMutate(batchMutate.getMutationMap());
  }
  public int getCount(final ByteBuffer keyfinal ColumnParent columnParentfinal SlicePredicate predicatethrows HectorException {
      @Override
      public Integer execute(Cassandra.Client cassandrathrows HectorException {
        try {
          return cassandra.get_count(keycolumnParentpredicategetThriftCl(.));
        } catch (Exception e) {
          throw .translate(e);
        }
      }
    };
    return op.getResult();
  }
  private void operateWithFailover(Operation<?> opthrows HectorException {
    this. = op.getCassandraHost();
  }
    return this.;
  }
  public Map<ByteBufferList<Column>> getRangeSlices(final ColumnParent columnParent,
      final SlicePredicate predicatefinal KeyRange keyRangethrows HectorException {
      @Override
      public Map<ByteBufferList<Column>> execute(Cassandra.Client cassandra)
          throws HectorException {
        try {
          List<KeySlicekeySlices = cassandra.get_range_slices(columnParent,
              predicatekeyRangegetThriftCl(.));
          if (keySlices == null || keySlices.isEmpty()) {
            return new LinkedHashMap<ByteBufferList<Column>>(0);
          }
          LinkedHashMap<ByteBufferList<Column>> ret = new LinkedHashMap<ByteBufferList<Column>>(
              keySlices.size());
          for (KeySlice keySlice : keySlices) {
            ret.put(ByteBuffer.wrap(keySlice.getKey()), getColumnList(keySlice.getColumns()));
          }
          return ret;
        } catch (Exception e) {
          throw .translate(e);
        }
      };
    };
    return op.getResult();
  }
      final ColumnParent columnParentfinal SlicePredicate predicatefinal KeyRange keyRange)
      throws HectorException {
      @Override
      public Map<ByteBufferList<SuperColumn>> execute(Cassandra.Client cassandra)
          throws HectorException {
        try {
          List<KeySlicekeySlices = cassandra.get_range_slices(columnParent,
              predicatekeyRangegetThriftCl(.));
          if (keySlices == null || keySlices.isEmpty()) {
            return new LinkedHashMap<ByteBufferList<SuperColumn>>();
          }
              keySlices.size());
          for (KeySlice keySlice : keySlices) {
            ret.put(ByteBuffer.wrap(keySlice.getKey()), getSuperColumnList(keySlice.getColumns()));
          }
          return ret;
        } catch (Exception e) {
          throw .translate(e);
        }
      }
    };
    return op.getResult();
  }
  public List<ColumngetSlice(final ByteBuffer keyfinal ColumnParent columnParent,
      final SlicePredicate predicatethrows HectorException {
      @Override
      public List<Columnexecute(Cassandra.Client cassandrathrows HectorException {
        try {
          List<ColumnOrSuperColumncosclist = cassandra.get_slice(keycolumnParent,
              predicategetThriftCl(.));
          if (cosclist == null) {
            return null;
          }
          ArrayList<Columnresult = new ArrayList<Column>(cosclist.size());
          for (ColumnOrSuperColumn cosc : cosclist) {
            result.add(cosc.getColumn());
          }
          return result;
        } catch (Exception e) {
          throw .translate(e);
        }
      }
    };
    return op.getResult();
  }
  public List<ColumngetSlice(String keyColumnParent columnParentSlicePredicate predicate)
  throws HectorException {
      return getSlice(StringSerializer.get().toByteBuffer(key), columnParentpredicate);
  }
  public SuperColumn getSuperColumn(final ByteBuffer keyfinal ColumnPath columnPaththrows HectorException {
      @Override
      public SuperColumn execute(Cassandra.Client cassandrathrows HectorException {
        ColumnOrSuperColumn cosc;
        try {
          cosc = cassandra.get(keycolumnPathgetThriftCl(.));
        } catch (NotFoundException e) {
          setException(.translate(e));
          return null;
        } catch (Exception e) {
          throw .translate(e);
        }
        return cosc == null ? null : cosc.getSuper_column();
      }
    };
    if (op.hasException()) {
      throw op.getException();
    }
    return op.getResult();
  }
  public List<SuperColumngetSuperSlice(String keyColumnParent columnParent,
          SlicePredicate predicatethrows HectorException {
      return getSuperSlice(StringSerializer.get().toByteBuffer(key), columnParentpredicate);
  }
  public SuperColumn getSuperColumn(final ByteBuffer keyfinal ColumnPath columnPath,
      final boolean reversedfinal int sizethrows HectorException {
    //valideSuperColumnPath(columnPath);
    final SliceRange sliceRange = new SliceRange(ByteBuffer.wrap(new byte[0]),
        ByteBuffer.wrap(new byte[0]), reversedsize);
        ) {
      @Override
      public SuperColumn execute(Cassandra.Client cassandrathrows HectorException {
        ColumnParent clp = new ColumnParent(columnPath.getColumn_family());
        clp.setSuper_column(columnPath.getSuper_column());
        SlicePredicate sp = new SlicePredicate();
        sp.setSlice_range(sliceRange);
        try {
          List<ColumnOrSuperColumncosc = cassandra.get_slice(keyclpsp,
              getThriftCl(.));
          if (cosc == null || cosc.isEmpty()) {
            return null;
          }
          return new SuperColumn(ByteBuffer.wrap(columnPath.getSuper_column()), getColumnList(cosc));
        } catch (Exception e) {
          throw .translate(e);
        }
      }
    };
    return op.getResult();
  }
  public SuperColumn getSuperColumn(String keyColumnPath columnPaththrows HectorException {
      return getSuperColumn(StringSerializer.get().toByteBuffer(key), columnPath);
  }
  public List<SuperColumngetSuperSlice(final ByteBuffer keyfinal ColumnParent columnParent,
      final SlicePredicate predicatethrows HectorException {
      @Override
      public List<SuperColumnexecute(Cassandra.Client cassandrathrows HectorException {
        try {
          List<ColumnOrSuperColumncosclist = cassandra.get_slice(keycolumnParent,
              predicategetThriftCl(.));
          if (cosclist == null) {
            return null;
          }
          ArrayList<SuperColumnresult = new ArrayList<SuperColumn>(cosclist.size());
          for (ColumnOrSuperColumn cosc : cosclist) {
            result.add(cosc.getSuper_column());
          }
          return result;
        } catch (Exception e) {
          throw .translate(e);
        }
      }
    };
    return op.getResult();
  }
  public void insert(final ByteBuffer keyfinal ColumnParent columnParentfinal Column columnthrows HectorException {
      @Override
      public Void execute(Cassandra.Client cassandrathrows HectorException {
        try {
          cassandra.insert(keycolumnParentcolumngetThriftCl(.));
          return null;
        } catch (Exception e) {
          throw .translate(e);
        }
      }
    };
  }
  public void insert(String keyColumnPath columnPathByteBuffer valuethrows HectorException {
//    valideColumnPath(columnPath);
      ColumnParent columnParent = new ColumnParent(columnPath.getColumn_family());
      if (columnPath.isSetSuper_column()) {
        columnParent.setSuper_column(columnPath.getSuper_column());
      }
      Column column = new Column(ByteBuffer.wrap(columnPath.getColumn()), value.createClock());
      insert(StringSerializer.get().toByteBuffer(key), columnParentcolumn);
  }
  public void insert(String keyColumnPath columnPathByteBuffer valuelong timestampthrows HectorException {
//    valideColumnPath(columnPath);
      ColumnParent columnParent = new ColumnParent(columnPath.getColumn_family());
      if (columnPath.isSetSuper_column()) {
      columnParent.setSuper_column(columnPath.getSuper_column());
    }
      Column column = new Column(ByteBuffer.wrap(columnPath.getColumn()), valuetimestamp);
      insert(StringSerializer.get().toByteBuffer(key), columnParentcolumn);
  }
  public Map<ByteBufferList<Column>> multigetSlice(final List<ByteBufferkeys,
      final ColumnParent columnParentfinal SlicePredicate predicatethrows HectorException {
    Operation<Map<ByteBufferList<Column>>> getCount = new Operation<Map<ByteBufferList<Column>>>(
      @Override
      public Map<ByteBufferList<Column>> execute(Cassandra.Client cassandrathrows HectorException {
        try {
          Map<ByteBufferList<ColumnOrSuperColumn>> cfmap = cassandra.multiget_slice(
              keyscolumnParentpredicategetThriftCl(.));
          Map<ByteBufferList<Column>> result = new HashMap<ByteBufferList<Column>>();
          for (Map.Entry<ByteBufferList<ColumnOrSuperColumn>> entry : cfmap.entrySet()) {
            result.put(entry.getKey(), getColumnList(entry.getValue()));
          }
          return result;
        } catch (Exception e) {
          throw .translate(e);
        }
      }
    };
    operateWithFailover(getCount);
    return getCount.getResult();
  }
      throws HectorException {
    return multigetSuperColumn(keyscolumnPathfalse.);
  }
      boolean reversedint sizethrows HectorException {
    //valideSuperColumnPath(columnPath);
    // only can get supercolumn by multigetSuperSlice
    ColumnParent clp = new ColumnParent(columnPath.getColumn_family());
    clp.setSuper_column(columnPath.getSuper_column());
    SliceRange sr = new SliceRange(ByteBuffer.wrap(new byte[0]), ByteBuffer.wrap(new byte[0]), reversedsize);
    SlicePredicate sp = new SlicePredicate();
    sp.setSlice_range(sr);
    Map<ByteBufferList<SuperColumn>> sclist = multigetSuperSlice(keysclpsp);
    if (sclist == null || sclist.isEmpty()) {
      return Collections.emptyMap();
    }
    Map<ByteBufferSuperColumnresult = new HashMap<ByteBufferSuperColumn>(keys.size() * 2);
    for (Map.Entry<ByteBufferList<SuperColumn>> entry : sclist.entrySet()) {
      List<SuperColumnsclistByKey = entry.getValue();
      if (sclistByKey.size() > 0) {
        result.put(entry.getKey(), sclistByKey.get(0));
      }
    }
    return result;
  }
      final ColumnParent columnParentfinal SlicePredicate predicatethrows HectorException {
      @Override
      public Map<ByteBufferList<SuperColumn>> execute(Cassandra.Client cassandra)
          throws HectorException {
        try {
          Map<ByteBufferList<ColumnOrSuperColumn>> cfmap = cassandra.multiget_slice(
              keyscolumnParentpredicategetThriftCl(.));
          // if user not given super column name, the multiget_slice will return
          // List
          // filled with
          // super column, if user given a column name, the return List will
          // filled
          // with column,
          // this is a bad interface design.
          if (!columnParent.isSetSuper_column()) {
            Map<ByteBufferList<SuperColumn>> result = new HashMap<ByteBufferList<SuperColumn>>();
            for (Map.Entry<ByteBufferList<ColumnOrSuperColumn>> entry : cfmap.entrySet()) {
              result.put(entry.getKey(), getSuperColumnList(entry.getValue()));
            }
            return result;
          } else {
            Map<ByteBufferList<SuperColumn>> result = new HashMap<ByteBufferList<SuperColumn>>();
            for (Map.Entry<ByteBufferList<ColumnOrSuperColumn>> entry : cfmap.entrySet()) {
              SuperColumn spc = new SuperColumn(ByteBuffer.wrap(columnParent.getSuper_column()),
                  getColumnList(entry.getValue()));
              ArrayList<SuperColumnspclist = new ArrayList<SuperColumn>(1);
              spclist.add(spc);
              result.put(entry.getKey(), spclist);
            }
            return result;
          }
        } catch (Exception e) {
          throw .translate(e);
        }
      }
    };
    operateWithFailover(getCount);
    return getCount.getResult();
  }
  public Map<ByteBufferList<Column>> getIndexedSlices(final ColumnParent columnParent,
      final IndexClause indexClause,
      final SlicePredicate predicatethrows HectorException {
      @Override
      public Map<ByteBufferList<Column>> execute(Cassandra.Client cassandra)
          throws HectorException {
        try {
          List<KeySlicekeySlices = cassandra.get_indexed_slices(columnParentindexClause,
              predicategetThriftCl(.));
          if (keySlices == null || keySlices.isEmpty()) {
            return new LinkedHashMap<ByteBufferList<Column>>(0);
          }
          LinkedHashMap<ByteBufferList<Column>> ret = new LinkedHashMap<ByteBufferList<Column>>(
              keySlices.size());
          for (KeySlice keySlice : keySlices) {
            ret.put(ByteBuffer.wrap(keySlice.getKey()), getColumnList(keySlice.getColumns()));
          }
          return ret;
        } catch (Exception e) {
          throw .translate(e);
        }
      };
    };
    return op.getResult();
  }
  public void remove(ByteBuffer keyColumnPath columnPath) {
    this.remove(keycolumnPath.createClock());
  }
  public Map<ByteBufferIntegermultigetCount(final List<ByteBufferkeysfinal ColumnParent columnParent,
      final SlicePredicate slicePredicatethrows HectorException {
      @Override
      public Map<ByteBufferIntegerexecute(Cassandra.Client cassandrathrows HectorException {
        try {
          return cassandra.multiget_count(keyscolumnParentslicePredicate,
              getThriftCl(.));
        } catch (Exception e) {
          throw .translate(e);
        }
      }
    };
    return op.getResult();
  }
  public void remove(final ByteBuffer keyfinal ColumnPath columnPathfinal long timestamp)
  throws HectorException {
      @Override
      public Void execute(Cassandra.Client cassandrathrows HectorException {
        try {
          cassandra.remove(keycolumnPathtimestampgetThriftCl(.));
          return null;
        } catch (Exception e) {
          throw .translate(e);
        }
      }
    };
  }
  public void remove(String keyColumnPath columnPaththrows HectorException {
    remove(StringSerializer.get().toByteBuffer(key), columnPath);
  }

  
Same as two argument version, but the caller must specify their own timestamp
  public void remove(String keyColumnPath columnPathlong timestampthrows HectorException {
    remove(StringSerializer.get().toByteBuffer(key), columnPathtimestamp);
  }
  public String getName() {
    return ;
  }
  public Column getColumn(final ByteBuffer keyfinal ColumnPath columnPaththrows HectorException {
//    valideColumnPath(columnPath);
      @Override
      public Column execute(Cassandra.Client cassandrathrows HectorException {
        ColumnOrSuperColumn cosc;
        try {
          cosc = cassandra.get(keycolumnPathgetThriftCl(.));
        } catch (NotFoundException e) {
          setException(.translate(e));
          return null;
        } catch (Exception e) {
          throw .translate(e);
        }
        return cosc == null ? null : cosc.getColumn();
      }
    };
    if (op.hasException()) {
      throw op.getException();
    }
    return op.getResult();
  }
  public Column getColumn(String keyColumnPath columnPaththrows HectorException {
      return getColumn(StringSerializer.get().toByteBuffer(key), columnPath);
  }
    return .get(operationType);
  }
  private ConsistencyLevel getThriftCl(OperationType operationType) {
    return ThriftConverter.consistencyLevel(.get(operationType));
  }
//  private static List<ColumnOrSuperColumn> getSoscList(List<Column> columns) {
//    ArrayList<ColumnOrSuperColumn> list = new ArrayList<ColumnOrSuperColumn>(columns.size());
//    for (Column col : columns) {
//      ColumnOrSuperColumn columnOrSuperColumn = new ColumnOrSuperColumn();
//      columnOrSuperColumn.setColumn(col);
//      list.add(columnOrSuperColumn);
//    }
//    return list;
//  }
//
//  private static List<ColumnOrSuperColumn> getSoscSuperList(List<SuperColumn> columns) {
//    ArrayList<ColumnOrSuperColumn> list = new ArrayList<ColumnOrSuperColumn>(columns.size());
//    for (SuperColumn col : columns) {
//      ColumnOrSuperColumn columnOrSuperColumn = new ColumnOrSuperColumn();
//      columnOrSuperColumn.setSuper_column(col);
//      list.add(columnOrSuperColumn);
//    }
//    return list;
//  }
  private static List<ColumngetColumnList(List<ColumnOrSuperColumncolumns) {
    ArrayList<Columnlist = new ArrayList<Column>(columns.size());
    for (ColumnOrSuperColumn col : columns) {
      list.add(col.getColumn());
    }
    return list;
  }
  private static List<SuperColumngetSuperColumnList(List<ColumnOrSuperColumncolumns) {
    ArrayList<SuperColumnlist = new ArrayList<SuperColumn>(columns.size());
    for (ColumnOrSuperColumn col : columns) {
      list.add(col.getSuper_column());
    }
    return list;
  }
  public String toString() {
    StringBuilder b = new StringBuilder();
    b.append("KeyspaceImpl<");
    b.append(">");
    return b.toString();
  }
New to GrepCode? Check out our FAQ X