예제 #1
0
  public <ID> Composite createKeyForCounter(String fqcn, ID key, PropertyMeta<Void, ID> idMeta) {
    Composite comp = new Composite();
    comp.setComponent(0, fqcn, STRING_SRZ);
    comp.setComponent(1, idMeta.writeValueToString(key), STRING_SRZ);

    return comp;
  }
예제 #2
0
  @SuppressWarnings("unchecked")
  public <K, V, T> Composite createForQuery(
      PropertyMeta<K, V> propertyMeta, T keyValue, ComponentEquality equality) {
    log.trace("Creating query composite for propertyMeta {}", propertyMeta.getPropertyName());

    Composite composite = new Composite();
    String propertyName = propertyMeta.getPropertyName();

    if (propertyMeta.isSingleKey()) {
      if (keyValue == null) {
        composite = null;
      } else {
        composite.addComponent(0, keyValue, equality);
      }
    } else {
      MultiKeyProperties multiKeyProperties = propertyMeta.getMultiKeyProperties();
      List<Serializer<?>> componentSerializers = multiKeyProperties.getComponentSerializers();
      List<Object> keyValues =
          entityHelper.determineMultiKey(keyValue, multiKeyProperties.getComponentGetters());
      int srzCount = componentSerializers.size();
      int valueCount = keyValues.size();

      Validator.validateTrue(
          srzCount >= valueCount,
          "There should be at most"
              + srzCount
              + " values for the key of WideMap '"
              + propertyName
              + "'");

      int lastNotNullIndex = helper.findLastNonNullIndexForComponents(propertyName, keyValues);

      for (int i = 0; i <= lastNotNullIndex; i++) {
        Serializer<Object> srz = (Serializer<Object>) componentSerializers.get(i);
        Object value = keyValues.get(i);
        if (i < lastNotNullIndex) {
          composite.setComponent(i, value, srz, srz.getComparatorType().getTypeName(), EQUAL);
        } else {
          composite.setComponent(i, value, srz, srz.getComparatorType().getTypeName(), equality);
        }
      }
    }
    return composite;
  }
예제 #3
0
  @SuppressWarnings("unchecked")
  public <K, V, T> Composite createBaseComposite(PropertyMeta<K, V> propertyMeta, T keyValue) {
    log.trace("Creating base composite for propertyMeta {}", propertyMeta.getPropertyName());

    Composite composite = new Composite();
    String propertyName = propertyMeta.getPropertyName();

    if (propertyMeta.isSingleKey()) {
      Validator.validateNotNull(
          keyValue,
          "The values for the for the key of WideMap '" + propertyName + "' should not be null");

      Serializer<T> keySerializer = (Serializer<T>) propertyMeta.getKeySerializer();
      composite.setComponent(
          0, keyValue, keySerializer, keySerializer.getComparatorType().getTypeName());
    } else {
      MultiKeyProperties multiKeyProperties = propertyMeta.getMultiKeyProperties();
      List<Serializer<?>> componentSerializers = multiKeyProperties.getComponentSerializers();
      List<Object> keyValues =
          entityHelper.determineMultiKey(keyValue, multiKeyProperties.getComponentGetters());
      int srzCount = componentSerializers.size();
      int valueCount = keyValues.size();

      Validator.validateTrue(
          srzCount == valueCount,
          "There should be " + srzCount + " values for the key of WideMap '" + propertyName + "'");

      for (Object value : keyValues) {
        Validator.validateNotNull(
            value,
            "The values for the for the key of WideMap '" + propertyName + "' should not be null");
      }

      for (int i = 0; i < srzCount; i++) {
        Serializer<Object> srz = (Serializer<Object>) componentSerializers.get(i);
        composite.setComponent(i, keyValues.get(i), srz, srz.getComparatorType().getTypeName());
      }
    }
    return composite;
  }
 private Composite getCompositeEnd(String ID, String URN, int situation, Node[] q) {
   Composite columnStop = new Composite();
   switch (situation) {
       // ID:*:*
     case 1:
       columnStop.addComponent(0, ID, Composite.ComponentEquality.GREATER_THAN_EQUAL);
       break;
     case 2:
       // URN:*:*
       columnStop.addComponent(0, URN, Composite.ComponentEquality.GREATER_THAN_EQUAL);
       break;
     case 3:
       // ID:URN:*
       columnStop.addComponent(0, ID, Composite.ComponentEquality.EQUAL);
       columnStop.addComponent(1, URN, Composite.ComponentEquality.GREATER_THAN_EQUAL);
       break;
     case 4:
       // URN:ID:*
       columnStop.addComponent(0, URN, Composite.ComponentEquality.EQUAL);
       columnStop.addComponent(1, ID, Composite.ComponentEquality.GREATER_THAN_EQUAL);
       break;
     case 5:
       // *:*:*
       break;
     case 6:
       // ID:URN:prop
       columnStop.addComponent(0, ID, Composite.ComponentEquality.EQUAL);
       columnStop.addComponent(1, URN, Composite.ComponentEquality.EQUAL);
       columnStop.addComponent(
           2, q[1].toN3() + "_", Composite.ComponentEquality.GREATER_THAN_EQUAL);
       break;
     case 7:
       // ID:URN:prop-value
       columnStop.addComponent(0, ID, Composite.ComponentEquality.EQUAL);
       columnStop.addComponent(1, URN, Composite.ComponentEquality.EQUAL);
       columnStop.addComponent(
           2,
           q[1].toN3() + " " + q[2].toN3() + "_",
           Composite.ComponentEquality.GREATER_THAN_EQUAL);
       break;
     default:
       break;
   }
   return columnStop;
 }
  @Override
  public int batchUpdateVersioning(
      String cf, List<Node[]> li, String keyspace, String URN_author, String txID) {
    Hashtable<String, List<Node[]>> versioned_entities = new Hashtable<String, List<Node[]>>();
    Hashtable<String, String> previous_commit_id = new Hashtable<String, String>();
    boolean successful_fetch =
        fetchMostRecentVersions(
            keyspace, cf, li, txID, URN_author, versioned_entities, previous_commit_id);
    if (!successful_fetch) {
      // it means that for one entity there is already a lastCID > txID
      // we have to abort here the insertion
      return 2;
    }

    // now update the properties into the recent versions fetched
    for (Iterator<Node[]> it = li.iterator(); it.hasNext(); ) {
      Node[] current = it.next();
      String prop = current[1].toN3();
      String value_old = current[2].toN3();
      Node value_new = current[3];

      List<Node[]> entity_version = versioned_entities.get("<" + current[0].toString() + "-VER>");
      for (Iterator<Node[]> it_version = entity_version.iterator(); it_version.hasNext(); ) {
        Node[] ver_ent = it_version.next();
        String ver_prop = ver_ent[1].toN3();
        String ver_value = ver_ent[2].toN3();
        // check if this is the triple to be replaces
        if (prop.equals(ver_prop) && value_old.equals(ver_value)) ver_ent[2] = value_new;
      }
    }

    // SPO
    // insert 's-VER' and 's-URN' new versions
    Mutator<String> m = HFactory.createMutator(getExistingKeyspace(keyspace), _ss);
    for (Iterator<String> it = versioned_entities.keySet().iterator(); it.hasNext(); ) {
      String row_entity_key = it.next();
      // there is a list of properties to be added to the new version of this entity
      List<Node[]> entity_old_version = versioned_entities.get(row_entity_key);
      String old_version_num = previous_commit_id.get(row_entity_key);

      for (Iterator it_old_v = entity_old_version.iterator(); it_old_v.hasNext(); ) {
        Node[] nx = (Node[]) it_old_v.next();
        // reorder for the key
        Node[] reordered = Util.reorder(nx, _maps.get(cf));
        String rowKey = new Resource(reordered[0].toString()).toN3();
        if (!reordered[0].toString().contains("-VER"))
          rowKey = new Resource(reordered[0].toString() + "-VER").toN3();

        /* this is the approach without using Snowflake
        int next_ver = old_version_num+1;*/
        String next_ver;
        // if txID is different than null, it means this is called in a transactional context
        if (txID != null) next_ver = txID;
        else next_ver = String.valueOf(Integer.valueOf(old_version_num) + 1);

        // VER, URN
        Composite colKey = new Composite();
        colKey.addComponent(next_ver, StringSerializer.get());
        colKey.addComponent(URN_author, StringSerializer.get());
        String colKey_s = Nodes.toN3(new Node[] {reordered[1], reordered[2]});
        colKey.addComponent(colKey_s, StringSerializer.get());
        HColumn<Composite, String> hColumnObj_itemID =
            HFactory.createColumn(colKey, "", new CompositeSerializer(), StringSerializer.get());
        m.addInsertion(rowKey, cf, hColumnObj_itemID);

        // URN, VER
        rowKey = new Resource(reordered[0].toString() + "-URN").toN3();
        colKey = new Composite();
        colKey.addComponent(URN_author, StringSerializer.get());
        colKey.addComponent(String.valueOf(next_ver), StringSerializer.get());
        colKey_s = Nodes.toN3(new Node[] {reordered[1], reordered[2]});
        colKey.addComponent(colKey_s, StringSerializer.get());

        hColumnObj_itemID =
            HFactory.createColumn(colKey, "", new CompositeSerializer(), StringSerializer.get());
        m.addInsertion(rowKey, cf, hColumnObj_itemID);
      }
      m.execute();
    }
    // now try to write all CID,prevCID; if check my writes is enabled, it can abort in case
    // there are conflicts
    return commitOrAbort(keyspace, txID, URN_author, versioned_entities, previous_commit_id);
  }
  @Override
  protected int batchInsertVersioning(
      String cf, List<Node[]> li, String keyspace, String URN_author, String txID) {
    Hashtable<String, List<Node[]>> versioned_entities = new Hashtable<String, List<Node[]>>();
    Hashtable<String, String> previous_commit_id = new Hashtable<String, String>();
    boolean successful_fetch =
        fetchMostRecentVersions(
            keyspace, cf, li, txID, URN_author, versioned_entities, previous_commit_id);
    if (!successful_fetch) {
      // it means that for one entity there is already a lastCID > txID
      // we have to abort here the insertion
      return 2;
    }

    /*
    // SIMULATE SOME DELAY HERE !!
    try{
    Thread.sleep(System.currentTimeMillis()%10000);
    }catch(Exception ex) {}
    // END [THIS MUST BE ERASED IN PRODUCTION!!]*/

    // add the new triples to previous versions
    for (Iterator<Node[]> it_triples = li.iterator(); it_triples.hasNext(); ) {
      Node[] triple = it_triples.next();
      String rowKey = new Resource(triple[0].toString() + "-VER").toN3();

      List<Node[]> prev_version = versioned_entities.get(rowKey);
      prev_version.add(triple);
      versioned_entities.put(rowKey, prev_version);
    }

    // SPO
    // insert 's-VER' and 's-URN' new versions
    Mutator<String> m = HFactory.createMutator(getExistingKeyspace(keyspace), _ss);
    for (Iterator<String> it = versioned_entities.keySet().iterator(); it.hasNext(); ) {
      String row_entity_key = it.next();
      // there is a list of properties to be added to the new version of this entity
      List<Node[]> entity_old_version = versioned_entities.get(row_entity_key);
      String old_version_num = previous_commit_id.get(row_entity_key);

      for (Iterator it_old_v = entity_old_version.iterator(); it_old_v.hasNext(); ) {
        Node[] nx = (Node[]) it_old_v.next();
        // reorder for the key
        Node[] reordered = Util.reorder(nx, _maps.get(cf));
        String rowKey = new Resource(reordered[0].toString()).toN3();
        if (!reordered[0].toString().contains("-VER"))
          rowKey = new Resource(reordered[0].toString() + "-VER").toN3();

        /* this is the approach without using Snowflake
        int next_ver = old_version_num+1;*/
        String next_ver;
        // if txID is different than null, it means this is called in a transactional context
        if (txID != null) next_ver = txID;
        else next_ver = String.valueOf(Integer.valueOf(old_version_num) + 1);

        // VER, URN
        Composite colKey = new Composite();
        colKey.addComponent(next_ver, StringSerializer.get());
        colKey.addComponent(URN_author, StringSerializer.get());
        String colKey_s = Nodes.toN3(new Node[] {reordered[1], reordered[2]});
        colKey.addComponent(colKey_s, StringSerializer.get());
        HColumn<Composite, String> hColumnObj_itemID =
            HFactory.createColumn(colKey, "", new CompositeSerializer(), StringSerializer.get());
        m.addInsertion(rowKey, cf, hColumnObj_itemID);

        // URN, VER
        rowKey = new Resource(reordered[0].toString() + "-URN").toN3();
        colKey = new Composite();
        colKey.addComponent(URN_author, StringSerializer.get());
        colKey.addComponent(String.valueOf(next_ver), StringSerializer.get());
        colKey_s = Nodes.toN3(new Node[] {reordered[1], reordered[2]});
        colKey.addComponent(colKey_s, StringSerializer.get());

        hColumnObj_itemID =
            HFactory.createColumn(colKey, "", new CompositeSerializer(), StringSerializer.get());
        m.addInsertion(rowKey, cf, hColumnObj_itemID);
      }
      m.execute();
    }
    // now try to write all CID,prevCID; if check my writes is enabled, it can abort in case
    // there are conflicts
    return commitOrAbort(keyspace, txID, URN_author, versioned_entities, previous_commit_id);
  }
예제 #7
0
 /**
  * Encapsulates the creation of Composite to make it easier to experiment with values
  *
  * @param componentName
  * @param equalityOp
  * @return
  */
 public static Composite compositeFrom(
     String componentName, Composite.ComponentEquality equalityOp) {
   Composite composite = new Composite();
   composite.addComponent(0, componentName, equalityOp);
   return composite;
 }
예제 #8
0
  @Override
  public Float toEntityValue(Class<?> fieldType, int index, Composite columnName) {

    return columnName.get(index, DoubleSerializer.get()).floatValue();
  }